apollo-codegen - npm Package Compare versions

		#!/usr/bin/env node
		'use strict';

		var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

		require('./env-setup');

		var _glob = require('glob');

		var _glob2 = _interopRequireDefault(_glob);

		var _process = require('process');

		var _process2 = _interopRequireDefault(_process);

		var _path = require('path');

		var _path2 = _interopRequireDefault(_path);

		var _yargs = require('yargs');

		var _yargs2 = _interopRequireDefault(_yargs);

		var _ = require('.');

		var _errors = require('./errors');

		require('source-map-support/register');

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

		// Make sure unhandled errors in async code are propagated correctly
		_process2.default.on('unhandledRejection', function (error) {
		throw error;
		});

		_process2.default.on('uncaughtException', handleError);

		"use strict";
		var __awaiter = (this && this.__awaiter) \|\| function (thisArg, _arguments, P, generator) {
		return new (P \|\| (P = Promise))(function (resolve, reject) {
		function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
		function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
		function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
		step((generator = generator.apply(thisArg, _arguments \|\| [])).next());
		});
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		const glob = require("glob");
		const process = require("process");
		const path = require("path");
		const yargs = require("yargs");
		const _1 = require(".");
		const errors_1 = require("./errors");
		require("source-map-support/register");
		process.on('unhandledRejection', (error) => { throw error; });
		process.on('uncaughtException', handleError);
		function handleError(error) {
		(0, _errors.logError)(error);
		_process2.default.exit(1);
		errors_1.logError(error);
		process.exit(1);
		}

		_yargs2.default.command(['introspect-schema <schema>', 'download-schema'], 'Generate an introspection JSON from a local GraphQL file or from a remote GraphQL server', {
		output: {
		demand: true,
		describe: 'Output path for GraphQL schema file',
		default: 'schema.json',
		normalize: true,
		coerce: _path2.default.resolve
		},
		header: {
		alias: 'H',
		describe: 'Additional header to send to the server as part of the introspection query request',
		type: 'array',
		coerce: function coerce(arg) {
		var additionalHeaders = {};
		var _iteratorNormalCompletion = true;
		var _didIteratorError = false;
		var _iteratorError = undefined;

		try {
		for (var _iterator = arg[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
		var header = _step.value;

		var _header$split = header.split(/\s:\s/),
		_header$split2 = _slicedToArray(_header$split, 2),
		name = _header$split2[0],
		value = _header$split2[1];

		if (!(name && value)) {
		throw new _errors.ToolError('Headers should be specified as "Name: Value"');
		}
		additionalHeaders[name] = value;
		yargs
		.command(['introspect-schema <schema>', 'download-schema'], 'Generate an introspection JSON from a local GraphQL file or from a remote GraphQL server', {
		output: {
		demand: true,
		describe: 'Output path for GraphQL schema file',
		default: 'schema.json',
		normalize: true,
		coerce: path.resolve,
		},
		header: {
		alias: 'H',
		describe: 'Additional header to send to the server as part of the introspection query request',
		type: 'array',
		coerce: (arg) => {
		let additionalHeaders = {};
		for (const header of arg) {
		const [name, value] = header.split(/\s:\s/);
		if (!(name && value)) {
		throw new errors_1.ToolError('Headers should be specified as "Name: Value"');
		}
		additionalHeaders[name] = value;
		}
		return additionalHeaders;
		}
		} catch (err) {
		_didIteratorError = true;
		_iteratorError = err;
		} finally {
		try {
		if (!_iteratorNormalCompletion && _iterator.return) {
		_iterator.return();
		}
		} finally {
		if (_didIteratorError) {
		throw _iteratorError;
		}
		}
		}

		return additionalHeaders;
		},
		insecure: {
		alias: 'K',
		describe: 'Allows "insecure" SSL connection to the server',
		type: 'boolean'
		}
		},
		insecure: {
		alias: 'K',
		describe: 'Allows "insecure" SSL connection to the server',
		type: 'boolean'
		}
		}, function () {
		var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee(argv) {
		var schema, output, header, insecure, urlRegex;
		return regeneratorRuntime.wrap(function _callee$(_context) {
		while (1) {
		switch (_context.prev = _context.next) {
		case 0:
		schema = argv.schema, output = argv.output, header = argv.header, insecure = argv.insecure;
		urlRegex = /^https?:\/\//i;

		if (!urlRegex.test(schema)) {
		_context.next = 7;
		break;
		}

		_context.next = 5;
		return (0, _.downloadSchema)(schema, output, header, insecure);

		case 5:
		_context.next = 9;
		break;

		case 7:
		_context.next = 9;
		return (0, _.introspectSchema)(schema, output);

		case 9:
		case 'end':
		return _context.stop();
		}
		}
		}, _callee, undefined);
		}));

		return function (_x) {
		return _ref.apply(this, arguments);
		};
		}()).command(['print-schema [schema]'], 'Print the provided schema in the GraphQL schema language format', {
		schema: {
		demand: true,
		describe: 'Path to GraphQL introspection query result',
		default: 'schema.json',
		normalize: true,
		coerce: _path2.default.resolve
		},
		output: {
		demand: true,
		describe: 'Output path for GraphQL schema language file',
		default: 'schema.graphql',
		normalize: true,
		coerce: _path2.default.resolve
		}
		}, function () {
		var _ref2 = _asyncToGenerator(regeneratorRuntime.mark(function _callee2(argv) {
		var schema, output;
		return regeneratorRuntime.wrap(function _callee2$(_context2) {
		while (1) {
		switch (_context2.prev = _context2.next) {
		case 0:
		schema = argv.schema, output = argv.output;
		_context2.next = 3;
		return (0, _.printSchema)(schema, output);

		case 3:
		case 'end':
		return _context2.stop();
		}
		}
		}, _callee2, undefined);
		}));

		return function (_x2) {
		return _ref2.apply(this, arguments);
		};
		}()).command('generate [input...]', 'Generate code from a GraphQL schema and query documents', {
		schema: {
		demand: true,
		describe: 'Path to GraphQL schema file',
		default: 'schema.json',
		normalize: true,
		coerce: _path2.default.resolve
		},
		output: {
		describe: 'Output directory for the generated files',
		normalize: true,
		coerce: _path2.default.resolve
		},
		target: {
		demand: false,
		describe: 'Code generation target language',
		choices: ['swift', 'json', 'ts', 'typescript', 'flow'],
		default: 'swift'
		},
		namespace: {
		demand: false,
		describe: 'Optional namespace for generated types [currently Swift-only]',
		type: 'string'
		},
		"passthrough-custom-scalars": {
		demand: false,
		describe: "Don't attempt to map custom scalars [temporary option]",
		default: false
		},
		"custom-scalars-prefix": {
		demand: false,
		describe: "Prefix for custom scalars. (Implies that passthrough-custom-scalars is true if set)",
		default: '',
		normalize: true
		},
		"add-typename": {
		demand: false,
		describe: "Automatically add the __typename field to every selection set",
		default: true
		}
		}, function (argv) {
		var input = argv.input;

		// Use glob if the user's shell was unable to expand the pattern

		if (input.length === 1 && _glob2.default.hasMagic(input[0])) {
		input = _glob2.default.sync(input[0]);
		}

		var inputPaths = input.map(function (input) {
		return _path2.default.resolve(input);
		}
		// Sort to normalize different glob expansions between different terminals.
		).sort();

		var options = {
		passthroughCustomScalars: argv["passthrough-custom-scalars"] \|\| argv["custom-scalars-prefix"] !== '',
		customScalarsPrefix: argv["custom-scalars-prefix"] \|\| '',
		addTypename: argv["add-typename"],
		namespace: argv.namespace
		};

		(0, _.generate)(inputPaths, argv.schema, argv.output, argv.target, options);
		}).fail(function (message, error) {
		handleError(error ? error : new _errors.ToolError(message));
		}).help().version().strict().argv;
		}, (argv) => __awaiter(this, void 0, void 0, function* () {
		const { schema, output, header, insecure } = argv;
		const urlRegex = /^https?:\/\//i;
		if (urlRegex.test(schema)) {
		yield _1.downloadSchema(schema, output, header, insecure);
		}
		else {
		yield _1.introspectSchema(schema, output);
		}
		}))
		.command(['print-schema [schema]'], 'Print the provided schema in the GraphQL schema language format', {
		schema: {
		demand: true,
		describe: 'Path to GraphQL introspection query result',
		default: 'schema.json',
		normalize: true,
		coerce: path.resolve,
		},
		output: {
		demand: true,
		describe: 'Output path for GraphQL schema language file',
		default: 'schema.graphql',
		normalize: true,
		coerce: path.resolve,
		}
		}, (argv) => __awaiter(this, void 0, void 0, function* () {
		const { schema, output } = argv;
		yield _1.printSchema(schema, output);
		}))
		.command('generate [input...]', 'Generate code from a GraphQL schema and query documents', {
		schema: {
		demand: true,
		describe: 'Path to GraphQL schema file',
		default: 'schema.json',
		normalize: true,
		coerce: path.resolve,
		},
		output: {
		describe: 'Output directory for the generated files',
		normalize: true,
		coerce: path.resolve,
		},
		target: {
		demand: false,
		describe: 'Code generation target language',
		choices: ['swift', 'json', 'ts', 'typescript', 'flow'],
		default: 'swift'
		},
		namespace: {
		demand: false,
		describe: 'Optional namespace for generated types [currently Swift-only]',
		type: 'string'
		},
		"passthrough-custom-scalars": {
		demand: false,
		describe: "Don't attempt to map custom scalars [temporary option]",
		default: false
		},
		"custom-scalars-prefix": {
		demand: false,
		describe: "Prefix for custom scalars. (Implies that passthrough-custom-scalars is true if set)",
		default: '',
		normalize: true
		},
		"add-typename": {
		demand: false,
		describe: "Automatically add the __typename field to every selection set",
		default: true
		}
		}, argv => {
		let { input } = argv;
		if (input.length === 1 && glob.hasMagic(input[0])) {
		input = glob.sync(input[0]);
		}
		const inputPaths = input
		.map(input => path.resolve(input))
		.sort();
		const options = {
		passthroughCustomScalars: argv["passthrough-custom-scalars"] \|\| argv["custom-scalars-prefix"] !== '',
		customScalarsPrefix: argv["custom-scalars-prefix"] \|\| '',
		addTypename: argv["add-typename"],
		namespace: argv.namespace
		};
		_1.generate(inputPaths, argv.schema, argv.output, argv.target, options);
		})
		.fail(function (message, error) {
		handleError(error ? error : new errors_1.ToolError(message));
		})
		.help()
		.version()
		.strict()
		.argv;
		//# sourceMappingURL=cli.js.map

935

lib/compilation.js

		@@ -1,716 +0,295 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.Compiler = undefined;

		var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const graphql_1 = require("graphql");
		const graphql_2 = require("./utilities/graphql");
		const printing_1 = require("./utilities/printing");
		function compileToIR(schema, document, options = { mergeInFieldsFromFragmentSpreads: true }) {
		if (options.addTypename) {
		document = graphql_2.withTypenameFieldAddedWhereNeeded(schema, document);
		}
		const compiler = new Compiler(schema, document, options);
		const operations = Object.create(null);
		compiler.operations.forEach(operation => {
		operations[operation.name.value] = compiler.compileOperation(operation);
		});
		const fragments = Object.create(null);
		compiler.fragments.forEach(fragment => {
		fragments[fragment.name.value] = compiler.compileFragment(fragment);
		});
		const typesUsed = compiler.typesUsed;
		return { schema, operations, fragments, typesUsed };
		}
		exports.compileToIR = compileToIR;
		exports.printIR = printIR;

		var _graphql = require('graphql');

		var _graphql2 = require('./utilities/graphql');

		var _printing = require('./utilities/printing');

		function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

		// Parts of this code are adapted from graphql-js

		function compileToIR(schema, document) {
		var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : { mergeInFieldsFromFragmentSpreads: true };

		if (options.addTypename) {
		document = (0, _graphql2.withTypenameFieldAddedWhereNeeded)(schema, document);
		}

		var compiler = new Compiler(schema, document, options);

		var operations = Object.create(null);

		compiler.operations.forEach(function (operation) {
		operations[operation.name.value] = compiler.compileOperation(operation);
		});

		var fragments = Object.create(null);

		compiler.fragments.forEach(function (fragment) {
		fragments[fragment.name.value] = compiler.compileFragment(fragment);
		});

		var typesUsed = compiler.typesUsed;

		return { schema, operations, fragments, typesUsed };
		}

		var Compiler = exports.Compiler = function () {
		function Compiler(schema, document, options) {
		_classCallCheck(this, Compiler);

		this.schema = schema;
		this.options = options;

		this.typesUsedSet = new Set();

		this.fragmentMap = Object.create(null);
		this.operations = [];

		var _iteratorNormalCompletion = true;
		var _didIteratorError = false;
		var _iteratorError = undefined;

		try {
		for (var _iterator = document.definitions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
		var definition = _step.value;

		switch (definition.kind) {
		case _graphql.Kind.OPERATION_DEFINITION:
		this.operations.push(definition);
		break;
		case _graphql.Kind.FRAGMENT_DEFINITION:
		this.fragmentMap[definition.name.value] = definition;
		break;
		class Compiler {
		constructor(schema, document, options) {
		this.schema = schema;
		this.options = options;
		this.typesUsedSet = new Set();
		this.fragmentMap = Object.create(null);
		this.operations = [];
		for (const definition of document.definitions) {
		switch (definition.kind) {
		case graphql_1.Kind.OPERATION_DEFINITION:
		this.operations.push(definition);
		break;
		case graphql_1.Kind.FRAGMENT_DEFINITION:
		this.fragmentMap[definition.name.value] = definition;
		break;
		}
		}
		}
		} catch (err) {
		_didIteratorError = true;
		_iteratorError = err;
		} finally {
		try {
		if (!_iteratorNormalCompletion && _iterator.return) {
		_iterator.return();
		this.compiledFragmentMap = Object.create(null);
		}
		addTypeUsed(type) {
		if (this.typesUsedSet.has(type))
		return;
		if (type instanceof graphql_1.GraphQLEnumType \|\|
		type instanceof graphql_1.GraphQLInputObjectType \|\|
		(type instanceof graphql_1.GraphQLScalarType && !graphql_2.isBuiltInScalarType(type))) {
		this.typesUsedSet.add(type);
		}
		} finally {
		if (_didIteratorError) {
		throw _iteratorError;
		}
		}
		}

		this.compiledFragmentMap = Object.create(null);
		}

		_createClass(Compiler, [{
		key: 'addTypeUsed',
		value: function addTypeUsed(type) {
		if (this.typesUsedSet.has(type)) return;

		if (type instanceof _graphql.GraphQLEnumType \|\| type instanceof _graphql.GraphQLInputObjectType \|\| type instanceof _graphql.GraphQLScalarType && !(0, _graphql2.isBuiltInScalarType)(type)) {
		this.typesUsedSet.add(type);
		}
		if (type instanceof _graphql.GraphQLInputObjectType) {
		var _iteratorNormalCompletion2 = true;
		var _didIteratorError2 = false;
		var _iteratorError2 = undefined;

		try {
		for (var _iterator2 = Object.values(type.getFields())[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
		var field = _step2.value;

		this.addTypeUsed((0, _graphql.getNamedType)(field.type));
		}
		} catch (err) {
		_didIteratorError2 = true;
		_iteratorError2 = err;
		} finally {
		try {
		if (!_iteratorNormalCompletion2 && _iterator2.return) {
		_iterator2.return();
		if (type instanceof graphql_1.GraphQLInputObjectType) {
		for (const field of Object.values(type.getFields())) {
		this.addTypeUsed(graphql_1.getNamedType(field.type));
		}
		} finally {
		if (_didIteratorError2) {
		throw _iteratorError2;
		}
		}
		}
		}
		}
		}, {
		key: 'fragmentNamed',
		value: function fragmentNamed(fragmentName) {
		return this.fragmentMap[fragmentName];
		get typesUsed() {
		return Array.from(this.typesUsedSet);
		}
		}, {
		key: 'compileOperation',
		value: function compileOperation(operationDefinition) {
		var _this = this;

		var filePath = (0, _graphql2.filePathForNode)(operationDefinition);
		var operationName = operationDefinition.name.value;
		var operationType = operationDefinition.operation;

		var variables = operationDefinition.variableDefinitions.map(function (node) {
		var name = node.variable.name.value;
		var type = (0, _graphql.typeFromAST)(_this.schema, node.type);
		_this.addTypeUsed((0, _graphql.getNamedType)(type));
		return { name, type };
		});

		var source = (0, _graphql.print)(operationDefinition);
		var rootType = (0, _graphql2.getOperationRootType)(this.schema, operationDefinition);

		var groupedVisitedFragmentSet = new Map();
		var groupedFieldSet = this.collectFields(rootType, operationDefinition.selectionSet, undefined, groupedVisitedFragmentSet);

		var fragmentsReferencedSet = Object.create(null);

		var _resolveFields = this.resolveFields(rootType, groupedFieldSet, groupedVisitedFragmentSet, fragmentsReferencedSet),
		fields = _resolveFields.fields;

		var fragmentsReferenced = Object.keys(fragmentsReferencedSet);

		return { filePath, operationName, operationType, rootType, variables, source, fields, fragmentsReferenced };
		fragmentNamed(fragmentName) {
		return this.fragmentMap[fragmentName];
		}
		}, {
		key: 'compileFragment',
		value: function compileFragment(fragmentDefinition) {
		var filePath = (0, _graphql2.filePathForNode)(fragmentDefinition);
		var fragmentName = fragmentDefinition.name.value;

		var source = (0, _graphql.print)(fragmentDefinition);

		var typeCondition = (0, _graphql.typeFromAST)(this.schema, fragmentDefinition.typeCondition);
		var possibleTypes = this.possibleTypesForType(typeCondition);

		var groupedVisitedFragmentSet = new Map();
		var groupedFieldSet = this.collectFields(typeCondition, fragmentDefinition.selectionSet, undefined, groupedVisitedFragmentSet);

		var fragmentsReferencedSet = Object.create(null);

		var _resolveFields2 = this.resolveFields(typeCondition, groupedFieldSet, groupedVisitedFragmentSet, fragmentsReferencedSet),
		fields = _resolveFields2.fields,
		fragmentSpreads = _resolveFields2.fragmentSpreads,
		inlineFragments = _resolveFields2.inlineFragments;

		var fragmentsReferenced = Object.keys(fragmentsReferencedSet);

		return { filePath, fragmentName, source, typeCondition, possibleTypes, fields, fragmentSpreads, inlineFragments, fragmentsReferenced };
		get fragments() {
		return Object.values(this.fragmentMap);
		}
		}, {
		key: 'collectFields',
		value: function collectFields(parentType, selectionSet) {
		var groupedFieldSet = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.create(null);
		var groupedVisitedFragmentSet = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Map();

		if (!(0, _graphql.isCompositeType)(parentType)) {
		throw new Error(`parentType should be a composite type, but is "${String(parentType)}"`);
		}

		var _iteratorNormalCompletion3 = true;
		var _didIteratorError3 = false;
		var _iteratorError3 = undefined;

		try {
		for (var _iterator3 = selectionSet.selections[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
		var selection = _step3.value;

		switch (selection.kind) {
		case _graphql.Kind.FIELD:
		{
		var fieldName = selection.name.value;
		var responseName = selection.alias ? selection.alias.value : fieldName;

		var field = (0, _graphql2.getFieldDef)(this.schema, parentType, selection);
		if (!field) {
		throw new _graphql.GraphQLError(`Cannot query field "${fieldName}" on type "${String(parentType)}"`, [selection]);
		compileOperation(operationDefinition) {
		const filePath = graphql_2.filePathForNode(operationDefinition);
		const operationName = operationDefinition.name.value;
		const operationType = operationDefinition.operation;
		const variables = operationDefinition.variableDefinitions.map(node => {
		const name = node.variable.name.value;
		const type = graphql_1.typeFromAST(this.schema, node.type);
		this.addTypeUsed(graphql_1.getNamedType(type));
		return { name, type };
		});
		const source = graphql_1.print(operationDefinition);
		const rootType = graphql_2.getOperationRootType(this.schema, operationDefinition);
		const groupedVisitedFragmentSet = new Map();
		const groupedFieldSet = this.collectFields(rootType, operationDefinition.selectionSet, undefined, groupedVisitedFragmentSet);
		const fragmentsReferencedSet = Object.create(null);
		const { fields } = this.resolveFields(rootType, groupedFieldSet, groupedVisitedFragmentSet, fragmentsReferencedSet);
		const fragmentsReferenced = Object.keys(fragmentsReferencedSet);
		return { filePath, operationName, operationType, rootType, variables, source, fields, fragmentsReferenced };
		}
		compileFragment(fragmentDefinition) {
		const filePath = graphql_2.filePathForNode(fragmentDefinition);
		const fragmentName = fragmentDefinition.name.value;
		const source = graphql_1.print(fragmentDefinition);
		const typeCondition = graphql_1.typeFromAST(this.schema, fragmentDefinition.typeCondition);
		const possibleTypes = this.possibleTypesForType(typeCondition);
		const groupedVisitedFragmentSet = new Map();
		const groupedFieldSet = this.collectFields(typeCondition, fragmentDefinition.selectionSet, undefined, groupedVisitedFragmentSet);
		const fragmentsReferencedSet = Object.create(null);
		const { fields, fragmentSpreads, inlineFragments } = this.resolveFields(typeCondition, groupedFieldSet, groupedVisitedFragmentSet, fragmentsReferencedSet);
		const fragmentsReferenced = Object.keys(fragmentsReferencedSet);
		return { filePath, fragmentName, source, typeCondition, possibleTypes, fields, fragmentSpreads, inlineFragments, fragmentsReferenced };
		}
		collectFields(parentType, selectionSet, groupedFieldSet = Object.create(null), groupedVisitedFragmentSet = new Map()) {
		if (!graphql_1.isCompositeType(parentType)) {
		throw new Error(`parentType should be a composite type, but is "${String(parentType)}"`);
		}
		for (const selection of selectionSet.selections) {
		switch (selection.kind) {
		case graphql_1.Kind.FIELD: {
		const fieldName = selection.name.value;
		const responseName = selection.alias ? selection.alias.value : fieldName;
		const field = graphql_2.getFieldDef(this.schema, parentType, selection);
		if (!field) {
		throw new graphql_1.GraphQLError(`Cannot query field "${fieldName}" on type "${String(parentType)}"`, [selection]);
		}
		if (groupedFieldSet) {
		if (!groupedFieldSet[responseName]) {
		groupedFieldSet[responseName] = [];
		}
		groupedFieldSet[responseName].push([parentType, {
		responseName,
		fieldName,
		args: argumentsFromAST(selection.arguments),
		type: field.type,
		directives: selection.directives,
		selectionSet: selection.selectionSet
		}]);
		}
		break;
		}

		if (groupedFieldSet) {
		if (!groupedFieldSet[responseName]) {
		groupedFieldSet[responseName] = [];
		}

		groupedFieldSet[responseName].push([parentType, {
		responseName,
		fieldName,
		args: argumentsFromAST(selection.arguments),
		type: field.type,
		directives: selection.directives,
		selectionSet: selection.selectionSet
		}]);
		case graphql_1.Kind.INLINE_FRAGMENT: {
		const typeCondition = selection.typeCondition;
		const inlineFragmentType = typeCondition ?
		graphql_1.typeFromAST(this.schema, typeCondition) :
		parentType;
		if (!graphql_1.doTypesOverlap(this.schema, inlineFragmentType, parentType))
		continue;
		const effectiveType = parentType instanceof graphql_1.GraphQLObjectType ? parentType : inlineFragmentType;
		this.collectFields(effectiveType, selection.selectionSet, groupedFieldSet, groupedVisitedFragmentSet);
		break;
		}
		break;
		}
		case _graphql.Kind.INLINE_FRAGMENT:
		{
		var typeCondition = selection.typeCondition;
		var inlineFragmentType = typeCondition ? (0, _graphql.typeFromAST)(this.schema, typeCondition) : parentType;

		if (!(0, _graphql.doTypesOverlap)(this.schema, inlineFragmentType, parentType)) continue;
		var effectiveType = parentType instanceof _graphql.GraphQLObjectType ? parentType : inlineFragmentType;

		this.collectFields(effectiveType, selection.selectionSet, groupedFieldSet, groupedVisitedFragmentSet);
		break;
		}
		case _graphql.Kind.FRAGMENT_SPREAD:
		{
		var fragmentName = selection.name.value;

		var fragment = this.fragmentNamed(fragmentName);
		if (!fragment) throw new _graphql.GraphQLError(`Cannot find fragment "${fragmentName}"`);

		var _typeCondition = fragment.typeCondition;
		var fragmentType = (0, _graphql.typeFromAST)(this.schema, _typeCondition);

		if (groupedVisitedFragmentSet) {
		var visitedFragmentSet = groupedVisitedFragmentSet.get(parentType);
		if (!visitedFragmentSet) {
		visitedFragmentSet = {};
		groupedVisitedFragmentSet.set(parentType, visitedFragmentSet);
		}

		if (visitedFragmentSet[fragmentName]) continue;
		visitedFragmentSet[fragmentName] = true;
		case graphql_1.Kind.FRAGMENT_SPREAD: {
		const fragmentName = selection.name.value;
		const fragment = this.fragmentNamed(fragmentName);
		if (!fragment)
		throw new graphql_1.GraphQLError(`Cannot find fragment "${fragmentName}"`);
		const typeCondition = fragment.typeCondition;
		const fragmentType = graphql_1.typeFromAST(this.schema, typeCondition);
		if (groupedVisitedFragmentSet) {
		let visitedFragmentSet = groupedVisitedFragmentSet.get(parentType);
		if (!visitedFragmentSet) {
		visitedFragmentSet = {};
		groupedVisitedFragmentSet.set(parentType, visitedFragmentSet);
		}
		if (visitedFragmentSet[fragmentName])
		continue;
		visitedFragmentSet[fragmentName] = true;
		}
		if (!graphql_1.doTypesOverlap(this.schema, fragmentType, parentType))
		continue;
		const effectiveType = parentType instanceof graphql_1.GraphQLObjectType ? parentType : fragmentType;
		this.collectFields(effectiveType, fragment.selectionSet, this.options.mergeInFieldsFromFragmentSpreads ? groupedFieldSet : null, groupedVisitedFragmentSet);
		break;
		}

		if (!(0, _graphql.doTypesOverlap)(this.schema, fragmentType, parentType)) continue;
		var _effectiveType = parentType instanceof _graphql.GraphQLObjectType ? parentType : fragmentType;

		this.collectFields(_effectiveType, fragment.selectionSet, this.options.mergeInFieldsFromFragmentSpreads ? groupedFieldSet : null, groupedVisitedFragmentSet);
		break;
		}
		}
		}
		}
		} catch (err) {
		_didIteratorError3 = true;
		_iteratorError3 = err;
		} finally {
		try {
		if (!_iteratorNormalCompletion3 && _iterator3.return) {
		_iterator3.return();
		}
		} finally {
		if (_didIteratorError3) {
		throw _iteratorError3;
		}
		}
		}

		return groupedFieldSet;
		return groupedFieldSet;
		}
		}, {
		key: 'possibleTypesForType',
		value: function possibleTypesForType(type) {
		if ((0, _graphql.isAbstractType)(type)) {
		return this.schema.getPossibleTypes(type);
		} else {
		return [type];
		}
		}
		}, {
		key: 'mergeSelectionSets',
		value: function mergeSelectionSets(parentType, fieldSet, groupedVisitedFragmentSet) {
		var groupedFieldSet = Object.create(null);

		var _iteratorNormalCompletion4 = true;
		var _didIteratorError4 = false;
		var _iteratorError4 = undefined;

		try {
		for (var _iterator4 = fieldSet[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
		var _ref = _step4.value;

		var _ref2 = _slicedToArray(_ref, 2);

		var field = _ref2[1];

		var selectionSet = field.selectionSet;

		if (selectionSet) {
		this.collectFields(parentType, selectionSet, groupedFieldSet, groupedVisitedFragmentSet);
		}
		possibleTypesForType(type) {
		if (graphql_1.isAbstractType(type)) {
		return this.schema.getPossibleTypes(type);
		}
		} catch (err) {
		_didIteratorError4 = true;
		_iteratorError4 = err;
		} finally {
		try {
		if (!_iteratorNormalCompletion4 && _iterator4.return) {
		_iterator4.return();
		}
		} finally {
		if (_didIteratorError4) {
		throw _iteratorError4;
		}
		else {
		return [type];
		}
		}

		return groupedFieldSet;
		}
		}, {
		key: 'resolveFields',
		value: function resolveFields(parentType, groupedFieldSet, groupedVisitedFragmentSet, fragmentsReferencedSet) {
		var _this2 = this;

		var fields = [];

		var _iteratorNormalCompletion5 = true;
		var _didIteratorError5 = false;
		var _iteratorError5 = undefined;

		try {
		for (var _iterator5 = Object.entries(groupedFieldSet)[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
		var _ref3 = _step5.value;

		var _ref4 = _slicedToArray(_ref3, 2);

		var responseName = _ref4[0];
		var fieldSet = _ref4[1];

		fieldSet = fieldSet.filter(function (_ref5) {
		var _ref6 = _slicedToArray(_ref5, 1),
		typeCondition = _ref6[0];

		return (0, _graphql.isTypeSubTypeOf)(_this2.schema, parentType, typeCondition);
		});
		if (fieldSet.length < 1) continue;

		var _fieldSet$ = _slicedToArray(fieldSet[0], 2),
		firstField = _fieldSet$[1];

		var fieldName = firstField.fieldName;
		var args = firstField.args;
		var type = firstField.type;

		var field = { responseName, fieldName, type };

		if (args && args.length > 0) {
		field.args = args;
		}

		var isConditional = fieldSet.some(function (_ref7) {
		var _ref8 = _slicedToArray(_ref7, 2),
		field = _ref8[1];

		return field.directives && field.directives.some(function (directive) {
		var directiveName = directive.name.value;
		return directiveName == 'skip' \|\| directiveName == 'include';
		mergeSelectionSets(parentType, fieldSet, groupedVisitedFragmentSet) {
		const groupedFieldSet = Object.create(null);
		for (const [, field] of fieldSet) {
		const selectionSet = field.selectionSet;
		if (selectionSet) {
		this.collectFields(parentType, selectionSet, groupedFieldSet, groupedVisitedFragmentSet);
		}
		}
		return groupedFieldSet;
		}
		resolveFields(parentType, groupedFieldSet, groupedVisitedFragmentSet, fragmentsReferencedSet) {
		const fields = [];
		for (let [responseName, fieldSet] of Object.entries(groupedFieldSet)) {
		fieldSet = fieldSet.filter(([typeCondition,]) => graphql_1.isTypeSubTypeOf(this.schema, parentType, typeCondition));
		if (fieldSet.length < 1)
		continue;
		const [, firstField] = fieldSet[0];
		const fieldName = firstField.fieldName;
		const args = firstField.args;
		const type = firstField.type;
		let field = { responseName, fieldName, type };
		if (args && args.length > 0) {
		field.args = args;
		}
		const isConditional = fieldSet.some(([, field]) => {
		return field.directives && field.directives.some(directive => {
		const directiveName = directive.name.value;
		return directiveName == 'skip' \|\| directiveName == 'include';
		});
		});
		});

		if (isConditional) {
		field.isConditional = true;
		}

		var fieldDef = parentType.getFields()[fieldName];
		if (fieldDef) {
		var description = fieldDef.description;
		if (description) {
		field.description = description;
		if (isConditional) {
		field.isConditional = true;
		}

		Object.assign(field, {
		isDeprecated: fieldDef.isDeprecated,
		deprecationReason: fieldDef.deprecationReason
		});
		}

		var bareType = (0, _graphql.getNamedType)(type);

		this.addTypeUsed(bareType);

		if ((0, _graphql.isCompositeType)(bareType)) {
		var subSelectionGroupedVisitedFragmentSet = new Map();
		var subSelectionGroupedFieldSet = this.mergeSelectionSets(bareType, fieldSet, subSelectionGroupedVisitedFragmentSet);

		var _resolveFields3 = this.resolveFields(bareType, subSelectionGroupedFieldSet, subSelectionGroupedVisitedFragmentSet, fragmentsReferencedSet),
		_fields = _resolveFields3.fields,
		_fragmentSpreads = _resolveFields3.fragmentSpreads,
		_inlineFragments = _resolveFields3.inlineFragments;

		Object.assign(field, { fields: _fields, fragmentSpreads: _fragmentSpreads, inlineFragments: _inlineFragments });
		}

		fields.push(field);
		}
		} catch (err) {
		_didIteratorError5 = true;
		_iteratorError5 = err;
		} finally {
		try {
		if (!_iteratorNormalCompletion5 && _iterator5.return) {
		_iterator5.return();
		}
		} finally {
		if (_didIteratorError5) {
		throw _iteratorError5;
		}
		}
		}

		var fragmentSpreads = this.fragmentSpreadsForParentType(parentType, groupedVisitedFragmentSet);
		var inlineFragments = this.resolveInlineFragments(parentType, groupedFieldSet, groupedVisitedFragmentSet, fragmentsReferencedSet);

		if (fragmentsReferencedSet) {
		Object.assign.apply(Object, [fragmentsReferencedSet].concat(_toConsumableArray(groupedVisitedFragmentSet.values())));

		// TODO: This is a really inefficient way of keeping track of fragments referenced by other fragments
		// We need to either cache compiled fragments or find a way to make resolveFields smarter
		var _iteratorNormalCompletion6 = true;
		var _didIteratorError6 = false;
		var _iteratorError6 = undefined;

		try {
		for (var _iterator6 = fragmentSpreads[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
		var fragmentName = _step6.value;

		var fragment = this.fragmentNamed(fragmentName);
		if (!fragment) throw new _graphql.GraphQLError(`Cannot find fragment "${fragmentName}"`);

		var _compileFragment = this.compileFragment(fragment),
		fragmentsReferencedFromFragment = _compileFragment.fragmentsReferenced;

		var _iteratorNormalCompletion7 = true;
		var _didIteratorError7 = false;
		var _iteratorError7 = undefined;

		try {
		for (var _iterator7 = fragmentsReferencedFromFragment[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
		var fragmentReferenced = _step7.value;

		fragmentsReferencedSet[fragmentReferenced] = true;
		}
		} catch (err) {
		_didIteratorError7 = true;
		_iteratorError7 = err;
		} finally {
		try {
		if (!_iteratorNormalCompletion7 && _iterator7.return) {
		_iterator7.return();
		if (parentType instanceof graphql_1.GraphQLObjectType \|\| parentType instanceof graphql_1.GraphQLInterfaceType) {
		const fieldDef = parentType.getFields()[fieldName];
		if (fieldDef) {
		const description = fieldDef.description;
		if (description) {
		field.description = description;
		}
		Object.assign(field, {
		isDeprecated: fieldDef.isDeprecated,
		deprecationReason: fieldDef.deprecationReason,
		});
		}
		} finally {
		if (_didIteratorError7) {
		throw _iteratorError7;
		}
		}
		}
		}
		} catch (err) {
		_didIteratorError6 = true;
		_iteratorError6 = err;
		} finally {
		try {
		if (!_iteratorNormalCompletion6 && _iterator6.return) {
		_iterator6.return();
		const bareType = graphql_1.getNamedType(type);
		this.addTypeUsed(bareType);
		if (graphql_1.isCompositeType(bareType)) {
		const subSelectionGroupedVisitedFragmentSet = new Map();
		const subSelectionGroupedFieldSet = this.mergeSelectionSets(bareType, fieldSet, subSelectionGroupedVisitedFragmentSet);
		const { fields, fragmentSpreads, inlineFragments } = this.resolveFields(bareType, subSelectionGroupedFieldSet, subSelectionGroupedVisitedFragmentSet, fragmentsReferencedSet);
		Object.assign(field, { fields, fragmentSpreads, inlineFragments });
		}
		} finally {
		if (_didIteratorError6) {
		throw _iteratorError6;
		fields.push(field);
		}
		const fragmentSpreads = this.fragmentSpreadsForParentType(parentType, groupedVisitedFragmentSet);
		const inlineFragments = this.resolveInlineFragments(parentType, groupedFieldSet, groupedVisitedFragmentSet, fragmentsReferencedSet);
		if (fragmentsReferencedSet) {
		Object.assign(fragmentsReferencedSet, ...groupedVisitedFragmentSet.values());
		for (let fragmentName of fragmentSpreads) {
		const fragment = this.fragmentNamed(fragmentName);
		if (!fragment)
		throw new graphql_1.GraphQLError(`Cannot find fragment "${fragmentName}"`);
		const { fragmentsReferenced: fragmentsReferencedFromFragment } = this.compileFragment(fragment);
		for (let fragmentReferenced of fragmentsReferencedFromFragment) {
		fragmentsReferencedSet[fragmentReferenced] = true;
		}
		}
		}
		}
		}

		return { fields, fragmentSpreads, inlineFragments };
		return { fields, fragmentSpreads, inlineFragments };
		}
		}, {
		key: 'resolveInlineFragments',
		value: function resolveInlineFragments(parentType, groupedFieldSet, groupedVisitedFragmentSet, fragmentsReferencedSet) {
		var _this3 = this;

		return this.collectPossibleTypes(parentType, groupedFieldSet, groupedVisitedFragmentSet).map(function (typeCondition) {
		var _resolveFields4 = _this3.resolveFields(typeCondition, groupedFieldSet, groupedVisitedFragmentSet, fragmentsReferencedSet),
		fields = _resolveFields4.fields,
		fragmentSpreads = _resolveFields4.fragmentSpreads;

		var possibleTypes = _this3.possibleTypesForType(typeCondition);
		return { typeCondition, possibleTypes, fields, fragmentSpreads };
		});
		resolveInlineFragments(parentType, groupedFieldSet, groupedVisitedFragmentSet, fragmentsReferencedSet) {
		return this.collectPossibleTypes(parentType, groupedFieldSet, groupedVisitedFragmentSet).map(typeCondition => {
		const { fields, fragmentSpreads } = this.resolveFields(typeCondition, groupedFieldSet, groupedVisitedFragmentSet, fragmentsReferencedSet);
		const possibleTypes = this.possibleTypesForType(typeCondition);
		return { typeCondition, possibleTypes, fields, fragmentSpreads };
		});
		}
		}, {
		key: 'collectPossibleTypes',
		value: function collectPossibleTypes(parentType, groupedFieldSet, groupedVisitedFragmentSet) {
		if (!(0, _graphql.isAbstractType)(parentType)) return [];

		var possibleTypes = new Set();

		var _iteratorNormalCompletion8 = true;
		var _didIteratorError8 = false;
		var _iteratorError8 = undefined;

		try {
		for (var _iterator8 = Object.values(groupedFieldSet)[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
		var fieldSet = _step8.value;
		var _iteratorNormalCompletion10 = true;
		var _didIteratorError10 = false;
		var _iteratorError10 = undefined;

		try {
		for (var _iterator10 = fieldSet[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
		var _ref9 = _step10.value;

		var _ref10 = _slicedToArray(_ref9, 1);

		var typeCondition = _ref10[0];

		if (this.schema.isPossibleType(parentType, typeCondition)) {
		possibleTypes.add(typeCondition);
		}
		collectPossibleTypes(parentType, groupedFieldSet, groupedVisitedFragmentSet) {
		if (!graphql_1.isAbstractType(parentType))
		return [];
		const possibleTypes = new Set();
		for (const fieldSet of Object.values(groupedFieldSet)) {
		for (const [typeCondition,] of fieldSet) {
		if (this.schema.isPossibleType(parentType, typeCondition)) {
		possibleTypes.add(typeCondition);
		}
		}
		} catch (err) {
		_didIteratorError10 = true;
		_iteratorError10 = err;
		} finally {
		try {
		if (!_iteratorNormalCompletion10 && _iterator10.return) {
		_iterator10.return();
		}
		} finally {
		if (_didIteratorError10) {
		throw _iteratorError10;
		}
		}
		}
		}

		// Also include type conditions for fragment spreads
		} catch (err) {
		_didIteratorError8 = true;
		_iteratorError8 = err;
		} finally {
		try {
		if (!_iteratorNormalCompletion8 && _iterator8.return) {
		_iterator8.return();
		}
		} finally {
		if (_didIteratorError8) {
		throw _iteratorError8;
		}
		}
		}

		if (groupedVisitedFragmentSet) {
		var _iteratorNormalCompletion9 = true;
		var _didIteratorError9 = false;
		var _iteratorError9 = undefined;

		try {
		for (var _iterator9 = groupedVisitedFragmentSet.keys()[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
		var effectiveType = _step9.value;

		if (this.schema.isPossibleType(parentType, effectiveType)) {
		possibleTypes.add(effectiveType);
		if (groupedVisitedFragmentSet) {
		for (const effectiveType of groupedVisitedFragmentSet.keys()) {
		if (this.schema.isPossibleType(parentType, effectiveType)) {
		possibleTypes.add(effectiveType);
		}
		}
		}
		} catch (err) {
		_didIteratorError9 = true;
		_iteratorError9 = err;
		} finally {
		try {
		if (!_iteratorNormalCompletion9 && _iterator9.return) {
		_iterator9.return();
		}
		} finally {
		if (_didIteratorError9) {
		throw _iteratorError9;
		}
		}
		}
		}

		return Array.from(possibleTypes);
		return Array.from(possibleTypes);
		}
		}, {
		key: 'fragmentSpreadsForParentType',
		value: function fragmentSpreadsForParentType(parentType, groupedVisitedFragmentSet) {
		if (!groupedVisitedFragmentSet) return [];

		var fragmentSpreads = new Set();

		var _iteratorNormalCompletion11 = true;
		var _didIteratorError11 = false;
		var _iteratorError11 = undefined;

		try {
		for (var _iterator11 = groupedVisitedFragmentSet[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
		var _ref11 = _step11.value;

		var _ref12 = _slicedToArray(_ref11, 2);

		var effectiveType = _ref12[0];
		var visitedFragmentSet = _ref12[1];

		if (!(0, _graphql2.isTypeProperSuperTypeOf)(this.schema, effectiveType, parentType)) continue;

		var _iteratorNormalCompletion12 = true;
		var _didIteratorError12 = false;
		var _iteratorError12 = undefined;

		try {
		for (var _iterator12 = Object.keys(visitedFragmentSet)[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
		var fragmentName = _step12.value;

		fragmentSpreads.add(fragmentName);
		fragmentSpreadsForParentType(parentType, groupedVisitedFragmentSet) {
		if (!groupedVisitedFragmentSet)
		return [];
		let fragmentSpreads = new Set();
		for (const [effectiveType, visitedFragmentSet] of groupedVisitedFragmentSet) {
		if (!graphql_2.isTypeProperSuperTypeOf(this.schema, effectiveType, parentType))
		continue;
		for (const fragmentName of Object.keys(visitedFragmentSet)) {
		fragmentSpreads.add(fragmentName);
		}
		} catch (err) {
		_didIteratorError12 = true;
		_iteratorError12 = err;
		} finally {
		try {
		if (!_iteratorNormalCompletion12 && _iterator12.return) {
		_iterator12.return();
		}
		} finally {
		if (_didIteratorError12) {
		throw _iteratorError12;
		}
		}
		}
		}
		} catch (err) {
		_didIteratorError11 = true;
		_iteratorError11 = err;
		} finally {
		try {
		if (!_iteratorNormalCompletion11 && _iterator11.return) {
		_iterator11.return();
		}
		} finally {
		if (_didIteratorError11) {
		throw _iteratorError11;
		}
		}
		}

		return Array.from(fragmentSpreads);
		return Array.from(fragmentSpreads);
		}
		}, {
		key: 'typesUsed',
		get: function get() {
		return Array.from(this.typesUsedSet);
		}
		}, {
		key: 'fragments',
		get: function get() {
		return Object.values(this.fragmentMap);
		}
		}]);

		return Compiler;
		}();

		}
		exports.Compiler = Compiler;
		function argumentsFromAST(args) {
		return args && args.map(function (arg) {
		return { name: arg.name.value, value: (0, _graphql2.valueFromValueNode)(arg.value) };
		});
		return args && args.map(arg => {
		return { name: arg.name.value, value: graphql_2.valueFromValueNode(arg.value) };
		});
		}

		function printIR(_ref13) {
		var fields = _ref13.fields,
		inlineFragments = _ref13.inlineFragments,
		fragmentSpreads = _ref13.fragmentSpreads;

		return fields && (0, _printing.wrap)('<', (0, _printing.join)(fragmentSpreads, ', '), '> ') + (0, _printing.block)(fields.map(function (field) {
		return `${field.name}: ${String(field.type)}` + (0, _printing.wrap)(' ', printIR(field));
		}).concat(inlineFragments && inlineFragments.map(function (inlineFragment) {
		return `${String(inlineFragment.typeCondition)}` + (0, _printing.wrap)(' ', printIR(inlineFragment));
		})));
		function printIR({ fields, inlineFragments, fragmentSpreads }) {
		return fields && printing_1.wrap('<', printing_1.join(fragmentSpreads, ', '), '> ')
		+ printing_1.block(fields.map(field => `${field.name}: ${String(field.type)}` + printing_1.wrap(' ', printIR(field))).concat(inlineFragments && inlineFragments.map(inlineFragment => `${String(inlineFragment.typeCondition)}` + printing_1.wrap(' ', printIR(inlineFragment)))));
		}
		exports.printIR = printIR;
		//# sourceMappingURL=compilation.js.map

146

lib/downloadSchema.js

		@@ -1,106 +0,48 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});

		var _nodeFetch = require('node-fetch');

		var _nodeFetch2 = _interopRequireDefault(_nodeFetch);

		var _fs = require('fs');

		var _fs2 = _interopRequireDefault(_fs);

		var _path = require('path');

		var _path2 = _interopRequireDefault(_path);

		var _https = require('https');

		var _https2 = _interopRequireDefault(_https);

		var _utilities = require('graphql/utilities');

		var _errors = require('./errors');

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; } // Based on https://facebook.github.io/relay/docs/guides-babel-plugin.html#using-other-graphql-implementations

		var defaultHeaders = {
		'Accept': 'application/json',
		'Content-Type': 'application/json'
		"use strict";
		var __awaiter = (this && this.__awaiter) \|\| function (thisArg, _arguments, P, generator) {
		return new (P \|\| (P = Promise))(function (resolve, reject) {
		function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
		function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
		function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
		step((generator = generator.apply(thisArg, _arguments \|\| [])).next());
		});
		};

		exports.default = function () {
		var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee(url, outputPath, additionalHeaders, insecure) {
		var headers, agent, result, response, schemaData;
		return regeneratorRuntime.wrap(function _callee$(_context) {
		while (1) {
		switch (_context.prev = _context.next) {
		case 0:
		headers = Object.assign(defaultHeaders, additionalHeaders);
		agent = insecure ? new _https2.default.Agent({ rejectUnauthorized: false }) : null;
		result = void 0;
		_context.prev = 3;
		_context.next = 6;
		return (0, _nodeFetch2.default)(url, {
		method: 'POST',
		headers: headers,
		body: JSON.stringify({ 'query': _utilities.introspectionQuery }),
		agent
		Object.defineProperty(exports, "__esModule", { value: true });
		const fetch = require("node-fetch");
		const fs = require("fs");
		const https = require("https");
		const utilities_1 = require("graphql/utilities");
		const errors_1 = require("./errors");
		const defaultHeaders = {
		'Accept': 'application/json',
		'Content-Type': 'application/json'
		};
		function downloadSchema(url, outputPath, additionalHeaders, insecure) {
		return __awaiter(this, void 0, void 0, function* () {
		const headers = Object.assign(defaultHeaders, additionalHeaders);
		const agent = insecure ? new https.Agent({ rejectUnauthorized: false }) : null;
		let result;
		try {
		const response = yield fetch(url, {
		method: 'POST',
		headers: headers,
		body: JSON.stringify({ 'query': utilities_1.introspectionQuery }),
		agent,
		});

		case 6:
		response = _context.sent;
		_context.next = 9;
		return response.json();

		case 9:
		result = _context.sent;
		_context.next = 15;
		break;

		case 12:
		_context.prev = 12;
		_context.t0 = _context['catch'](3);
		throw new _errors.ToolError(`Error while fetching introspection query result: ${_context.t0.message}`);

		case 15:
		if (!result.errors) {
		_context.next = 17;
		break;
		}

		throw new _errors.ToolError(`Errors in introspection query result: ${result.errors}`);

		case 17:
		schemaData = result;

		if (schemaData.data) {
		_context.next = 20;
		break;
		}

		throw new _errors.ToolError(`No introspection query result data found, server responded with: ${JSON.stringify(result)}`);

		case 20:

		_fs2.default.writeFileSync(outputPath, JSON.stringify(schemaData, null, 2));

		case 21:
		case 'end':
		return _context.stop();
		result = yield response.json();
		}
		}
		}, _callee, this, [[3, 12]]);
		}));

		function downloadSchema(_x, _x2, _x3, _x4) {
		return _ref.apply(this, arguments);
		}

		return downloadSchema;
		}();
		catch (error) {
		throw new errors_1.ToolError(`Error while fetching introspection query result: ${error.message}`);
		}
		if (result.errors) {
		throw new errors_1.ToolError(`Errors in introspection query result: ${result.errors}`);
		}
		const schemaData = result;
		if (!schemaData.data) {
		throw new errors_1.ToolError(`No introspection query result data found, server responded with: ${JSON.stringify(result)}`);
		}
		fs.writeFileSync(outputPath, JSON.stringify(schemaData, null, 2));
		});
		}
		exports.default = downloadSchema;
		//# sourceMappingURL=downloadSchema.js.map

121

lib/errors.js

		@@ -1,89 +0,54 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const graphql_1 = require("graphql");
		const path = require("path");
		class ToolError extends Error {
		constructor(message) {
		super(message);
		this.name = 'ToolError';
		this.message = message;
		}
		}
		exports.ToolError = ToolError;
		exports.logError = logError;
		exports.logErrorMessage = logErrorMessage;

		var _graphql = require('graphql');

		var _path = require('path');

		var _path2 = _interopRequireDefault(_path);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		// ToolError is used for errors that are part of the expected flow
		// and for which a stack trace should not be printed

		function ToolError(message) {
		this.message = message;
		}

		ToolError.prototype = Object.create(Error.prototype, {
		constructor: { value: ToolError },
		name: { value: 'ToolError' }
		});

		var isRunningFromXcodeScript = process.env.XCODE_VERSION_ACTUAL;

		const isRunningFromXcodeScript = process.env.XCODE_VERSION_ACTUAL;
		function logError(error) {
		if (error instanceof ToolError) {
		logErrorMessage(error.message);
		} else if (error instanceof _graphql.GraphQLError) {
		var fileName = error.source && error.source.name;
		if (error.locations) {
		var _iteratorNormalCompletion = true;
		var _didIteratorError = false;
		var _iteratorError = undefined;

		try {
		for (var _iterator = error.locations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
		var location = _step.value;

		logErrorMessage(error.message, fileName, location.line);
		if (error instanceof ToolError) {
		logErrorMessage(error.message);
		}
		else if (error instanceof graphql_1.GraphQLError) {
		const fileName = error.source && error.source.name;
		if (error.locations) {
		for (const location of error.locations) {
		logErrorMessage(error.message, fileName, location.line);
		}
		}
		} catch (err) {
		_didIteratorError = true;
		_iteratorError = err;
		} finally {
		try {
		if (!_iteratorNormalCompletion && _iterator.return) {
		_iterator.return();
		}
		} finally {
		if (_didIteratorError) {
		throw _iteratorError;
		}
		else {
		logErrorMessage(error.message, fileName);
		}
		}
		} else {
		logErrorMessage(error.message, fileName);
		}
		} else {
		console.log(error.stack);
		}
		else {
		console.log(error.stack);
		}
		}

		exports.logError = logError;
		function logErrorMessage(message, fileName, lineNumber) {
		if (isRunningFromXcodeScript) {
		if (fileName && lineNumber) {
		// Prefixing error output with file name, line and 'error: ',
		// so Xcode will associate it with the right file and display the error inline
		console.log(`${fileName}:${lineNumber}: error: ${message}`);
		} else {
		// Prefixing error output with 'error: ', so Xcode will display it as an error
		console.log(`error: ${message}`);
		if (isRunningFromXcodeScript) {
		if (fileName && lineNumber) {
		console.log(`${fileName}:${lineNumber}: error: ${message}`);
		}
		else {
		console.log(`error: ${message}`);
		}
		}
		} else {
		if (fileName) {
		var truncatedFileName = '/' + fileName.split(_path2.default.sep).slice(-4).join(_path2.default.sep);
		console.log(`...${truncatedFileName}: ${message}`);
		} else {
		console.log(`error: ${message}`);
		else {
		if (fileName) {
		const truncatedFileName = '/' + fileName.split(path.sep).slice(-4).join(path.sep);
		console.log(`...${truncatedFileName}: ${message}`);
		}
		else {
		console.log(`error: ${message}`);
		}
		}
		}
		}
		exports.logErrorMessage = logErrorMessage;
		//# sourceMappingURL=errors.js.map

547

lib/flow/codeGeneration.js

		@@ -1,368 +0,245 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.generateSource = generateSource;
		exports.typeDeclarationForGraphQLType = typeDeclarationForGraphQLType;
		exports.interfaceVariablesDeclarationForOperation = interfaceVariablesDeclarationForOperation;
		exports.typeDeclarationForOperation = typeDeclarationForOperation;
		exports.typeDeclarationForFragment = typeDeclarationForFragment;
		exports.propertiesFromFields = propertiesFromFields;
		exports.propertyFromField = propertyFromField;
		exports.propertyDeclarations = propertyDeclarations;

		var _graphql = require('graphql');

		var _graphql2 = require('../utilities/graphql');

		var _changeCase = require('change-case');

		var _inflected = require('inflected');

		var _inflected2 = _interopRequireDefault(_inflected);

		var _printing = require('../utilities/printing');

		var _CodeGenerator = require('../utilities/CodeGenerator');

		var _CodeGenerator2 = _interopRequireDefault(_CodeGenerator);

		var _language = require('./language');

		var _types = require('./types');

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const graphql_1 = require("graphql");
		const change_case_1 = require("change-case");
		const Inflector = require("inflected");
		const printing_1 = require("../utilities/printing");
		const CodeGenerator_1 = require("../utilities/CodeGenerator");
		const language_1 = require("./language");
		const types_1 = require("./types");
		function generateSource(context, options) {
		var generator = new _CodeGenerator2.default(context);
		generator.printOnNewline('/* @flow */');
		generator.printOnNewline('// This file was automatically generated and should not be edited.');
		typeDeclarationForGraphQLType(context.typesUsed.forEach(function (type) {
		return typeDeclarationForGraphQLType(generator, type);
		}));

		// When an object has fragment spreads or inline fragments
		// and __typename is requested at the top level, __typename
		// needs to be added as a property of the fragments
		var fragmentsWithTypenameField = {};
		Object.values(context.operations).forEach(function (operation) {
		interfaceVariablesDeclarationForOperation(generator, operation);
		typeDeclarationForOperation(generator, operation, fragmentsWithTypenameField);
		});

		Object.values(context.fragments).forEach(function (operation) {
		return typeDeclarationForFragment(generator, operation, fragmentsWithTypenameField);
		});

		return generator.output;
		const generator = new CodeGenerator_1.default(context);
		generator.printOnNewline('/* @flow */');
		generator.printOnNewline('// This file was automatically generated and should not be edited.');
		typeDeclarationForGraphQLType(context.typesUsed.forEach(type => typeDeclarationForGraphQLType(generator, type)));
		const fragmentsWithTypenameField = {};
		Object.values(context.operations).forEach(operation => {
		interfaceVariablesDeclarationForOperation(generator, operation);
		typeDeclarationForOperation(generator, operation, fragmentsWithTypenameField);
		});
		Object.values(context.fragments).forEach(operation => typeDeclarationForFragment(generator, operation, fragmentsWithTypenameField));
		return generator.output;
		}

		exports.generateSource = generateSource;
		function typeDeclarationForGraphQLType(generator, type) {
		if (type instanceof _graphql.GraphQLEnumType) {
		enumerationDeclaration(generator, type);
		} else if (type instanceof _graphql.GraphQLInputObjectType) {
		structDeclarationForInputObjectType(generator, type);
		}
		if (type instanceof graphql_1.GraphQLEnumType) {
		enumerationDeclaration(generator, type);
		}
		else if (type instanceof graphql_1.GraphQLInputObjectType) {
		structDeclarationForInputObjectType(generator, type);
		}
		}

		exports.typeDeclarationForGraphQLType = typeDeclarationForGraphQLType;
		function enumerationDeclaration(generator, type) {
		var name = type.name,
		description = type.description;

		var values = type.getValues();

		generator.printNewlineIfNeeded();
		generator.printOnNewline(description && `// ${description}`);
		generator.printOnNewline(`export type ${name} =`);
		var nValues = values.length;
		values.forEach(function (value, i) {
		return generator.printOnNewline(` "${value.value}"${i === nValues - 1 ? ';' : ' \|'}${(0, _printing.wrap)(' // ', value.description)}`);
		});
		generator.printNewline();
		const { name, description } = type;
		const values = type.getValues();
		generator.printNewlineIfNeeded();
		generator.printOnNewline(description && `// ${description}`);
		generator.printOnNewline(`export type ${name} =`);
		const nValues = values.length;
		values.forEach((value, i) => generator.printOnNewline(` "${value.value}"${i === nValues - 1 ? ';' : ' \|'}${printing_1.wrap(' // ', value.description)}`));
		generator.printNewline();
		}

		function structDeclarationForInputObjectType(generator, type) {
		var interfaceName = (0, _changeCase.pascalCase)(type.name);
		(0, _language.typeDeclaration)(generator, {
		interfaceName
		}, function () {
		var properties = propertiesFromFields(generator.context, Object.values(type.getFields()));
		propertyDeclarations(generator, properties, true);
		});
		const interfaceName = change_case_1.pascalCase(type.name);
		language_1.typeDeclaration(generator, {
		interfaceName,
		}, () => {
		const properties = propertiesFromFields(generator.context, Object.values(type.getFields()));
		propertyDeclarations(generator, properties, true);
		});
		}

		function interfaceNameFromOperation(_ref) {
		var operationName = _ref.operationName,
		operationType = _ref.operationType;

		switch (operationType) {
		case 'query':
		return `${(0, _changeCase.pascalCase)(operationName)}Query`;
		break;
		case 'mutation':
		return `${(0, _changeCase.pascalCase)(operationName)}Mutation`;
		break;
		case 'subscription':
		return `${(0, _changeCase.pascalCase)(operationName)}Subscription`;
		break;
		default:
		throw new _graphql.GraphQLError(`Unsupported operation type "${operationType}"`);
		}
		function interfaceNameFromOperation({ operationName, operationType }) {
		switch (operationType) {
		case 'query':
		return `${change_case_1.pascalCase(operationName)}Query`;
		break;
		case 'mutation':
		return `${change_case_1.pascalCase(operationName)}Mutation`;
		break;
		case 'subscription':
		return `${change_case_1.pascalCase(operationName)}Subscription`;
		break;
		default:
		throw new graphql_1.GraphQLError(`Unsupported operation type "${operationType}"`);
		}
		}

		function interfaceVariablesDeclarationForOperation(generator, _ref2) {
		var operationName = _ref2.operationName,
		operationType = _ref2.operationType,
		variables = _ref2.variables,
		fields = _ref2.fields,
		fragmentsReferenced = _ref2.fragmentsReferenced,
		source = _ref2.source;

		if (!variables \|\| variables.length < 1) {
		return null;
		}
		var interfaceName = `${interfaceNameFromOperation({ operationName, operationType })}Variables`;

		(0, _language.typeDeclaration)(generator, {
		interfaceName
		}, function () {
		var properties = propertiesFromFields(generator.context, variables);
		propertyDeclarations(generator, properties, true);
		});
		function interfaceVariablesDeclarationForOperation(generator, { operationName, operationType, variables, fields, fragmentsReferenced, source, }) {
		if (!variables \|\| variables.length < 1) {
		return null;
		}
		const interfaceName = `${interfaceNameFromOperation({ operationName, operationType })}Variables`;
		language_1.typeDeclaration(generator, {
		interfaceName,
		}, () => {
		const properties = propertiesFromFields(generator.context, variables);
		propertyDeclarations(generator, properties, true);
		});
		}

		function typeDeclarationForOperation(generator, _ref3, fragmentsWithTypenameField) {
		var operationName = _ref3.operationName,
		operationType = _ref3.operationType,
		variables = _ref3.variables,
		fields = _ref3.fields,
		fragmentSpreads = _ref3.fragmentSpreads,
		inlineFragments = _ref3.inlineFragments,
		fragmentsReferenced = _ref3.fragmentsReferenced,
		source = _ref3.source;

		if (hasTypenameField(fields)) {
		console.error('__typename on operations are not yet supported');
		}
		var interfaceName = interfaceNameFromOperation({ operationName, operationType });
		var properties = propertiesFromFields(generator.context, fields, {
		typeNameSuffix: `From${operationName}`
		});

		(0, _language.typeDeclaration)(generator, { interfaceName }, function () {
		propertyDeclarations(generator, properties, true);
		});

		properties.forEach(function (_ref4) {
		var fragmentSpreads = _ref4.fragmentSpreads,
		inlineFragments = _ref4.inlineFragments,
		bareTypeName = _ref4.bareTypeName;

		if (fragmentSpreads.length > 0) {
		fragmentSpreads.forEach(function (fragmentSpread) {
		fragmentsWithTypenameField[fragmentSpread] = true;
		});
		exports.interfaceVariablesDeclarationForOperation = interfaceVariablesDeclarationForOperation;
		function typeDeclarationForOperation(generator, { operationName, operationType, variables, fields, fragmentSpreads, inlineFragments, fragmentsReferenced, source, }, fragmentsWithTypenameField) {
		if (hasTypenameField(fields)) {
		console.error('__typename on operations are not yet supported');
		}

		const interfaceName = interfaceNameFromOperation({ operationName, operationType });
		const properties = propertiesFromFields(generator.context, fields, {
		typeNameSuffix: `From${operationName}`
		});
		language_1.typeDeclaration(generator, { interfaceName }, () => {
		propertyDeclarations(generator, properties, true);
		});
		properties.forEach(({ fragmentSpreads, inlineFragments, bareTypeName }) => {
		if (fragmentSpreads && fragmentSpreads.length > 0) {
		fragmentSpreads.forEach(fragmentSpread => {
		fragmentsWithTypenameField[fragmentSpread] = true;
		});
		}
		if (inlineFragments && inlineFragments.length > 0) {
		const fragmentName = `${change_case_1.pascalCase(bareTypeName)}From${operationName}`;
		handleInlineFragments(generator, fragmentName, inlineFragments);
		}
		});
		}
		exports.typeDeclarationForOperation = typeDeclarationForOperation;
		function typeDeclarationForFragment(generator, { fragmentName, typeCondition, fields, inlineFragments, fragmentSpreads, source, possibleTypes }, fragmentsWithTypenameField) {
		const interfaceName = `${change_case_1.pascalCase(fragmentName)}Fragment`;
		if (inlineFragments.length > 0) {
		var fragmentName = `${(0, _changeCase.pascalCase)(bareTypeName)}From${operationName}`;
		handleInlineFragments(generator, fragmentName, inlineFragments);
		handleInlineFragments(generator, interfaceName, inlineFragments);
		}
		});
		else {
		language_1.typeDeclaration(generator, {
		interfaceName,
		}, () => {
		if (fragmentsWithTypenameField[fragmentName]) {
		addTypenameFieldIfNeeded(generator, fields, typeCondition);
		}
		const properties = propertiesFromFields(generator.context, fields, {
		typeNameSuffix: 'Fragment'
		});
		propertyDeclarations(generator, properties, true);
		});
		}
		}

		function typeDeclarationForFragment(generator, _ref5, fragmentsWithTypenameField) {
		var fragmentName = _ref5.fragmentName,
		typeCondition = _ref5.typeCondition,
		fields = _ref5.fields,
		inlineFragments = _ref5.inlineFragments,
		fragmentSpreads = _ref5.fragmentSpreads,
		source = _ref5.source,
		possibleTypes = _ref5.possibleTypes;

		var interfaceName = `${(0, _changeCase.pascalCase)(fragmentName)}Fragment`;

		if (inlineFragments.length > 0) {
		handleInlineFragments(generator, interfaceName, inlineFragments);
		} else {
		(0, _language.typeDeclaration)(generator, {
		interfaceName
		// extendTypes: fragmentSpreads ? fragmentSpreads.map(f => `${pascalCase(f)}Fragment`) : null,
		}, function () {
		if (fragmentsWithTypenameField[fragmentName]) {
		addTypenameFieldIfNeeded(generator, fields, typeCondition);
		}

		var properties = propertiesFromFields(generator.context, fields, {
		typeNameSuffix: 'Fragment'
		});

		propertyDeclarations(generator, properties, true);
		});
		}
		exports.typeDeclarationForFragment = typeDeclarationForFragment;
		function propertiesFromFields(context, fields, { forceNullable, typeNameSuffix } = {}) {
		return fields.map(field => propertyFromField(context, field, { forceNullable, typeNameSuffix }));
		}

		function propertiesFromFields(context, fields) {
		var _ref6 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
		forceNullable = _ref6.forceNullable,
		typeNameSuffix = _ref6.typeNameSuffix;

		return fields.map(function (field) {
		return propertyFromField(context, field, { forceNullable, typeNameSuffix });
		});
		}

		function propertyFromField(context, field) {
		var _ref7 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
		forceNullable = _ref7.forceNullable,
		typeNameSuffix = _ref7.typeNameSuffix;

		var fieldName = field.name,
		fieldType = field.type,
		description = field.description,
		fragmentSpreads = field.fragmentSpreads,
		inlineFragments = field.inlineFragments;

		fieldName = fieldName \|\| field.responseName;

		var propertyName = fieldName;
		var property = { fieldName, fieldType, propertyName, description, inlineFragments };
		var namedType = (0, _graphql.getNamedType)(fieldType);

		if ((0, _graphql.isCompositeType)(namedType)) {
		var typeName = void 0,
		bareTypeName = void 0;
		if (propertyName === '__typename') {
		// Handle the __typename field specially. the fieldType is set
		// to the parentType but we want the target type to be a string literal
		// of the parentType.
		bareTypeName = `"${fieldType}"`;
		typeName = `"${fieldType}"`;
		} else {
		bareTypeName = (0, _changeCase.pascalCase)(_inflected2.default.singularize(propertyName));
		if (inlineFragments && inlineFragments.length > 0 \|\| fragmentSpreads && fragmentSpreads.length > 0) {
		typeName = (0, _types.typeNameFromGraphQLType)(context, fieldType, `${(0, _changeCase.pascalCase)(bareTypeName)}${typeNameSuffix}`);
		} else {
		typeName = (0, _types.typeNameFromGraphQLType)(context, fieldType, bareTypeName);
		}
		exports.propertiesFromFields = propertiesFromFields;
		function propertyFromField(context, field, { forceNullable, typeNameSuffix } = {}) {
		let { name: fieldName, type: fieldType, description, fragmentSpreads, inlineFragments } = field;
		fieldName = fieldName \|\| field.responseName;
		const propertyName = fieldName;
		let property = { fieldName, fieldType, propertyName, description, inlineFragments };
		const namedType = graphql_1.getNamedType(fieldType);
		if (graphql_1.isCompositeType(namedType)) {
		let typeName, bareTypeName;
		if (propertyName === '__typename') {
		bareTypeName = `"${fieldType}"`;
		typeName = `"${fieldType}"`;
		}
		else {
		bareTypeName = change_case_1.pascalCase(Inflector.singularize(propertyName));
		if (inlineFragments && inlineFragments.length > 0 \|\|
		fragmentSpreads && fragmentSpreads.length > 0) {
		typeName = types_1.typeNameFromGraphQLType(context, fieldType, `${change_case_1.pascalCase(bareTypeName)}${typeNameSuffix}`);
		}
		else {
		typeName = types_1.typeNameFromGraphQLType(context, fieldType, bareTypeName);
		}
		}
		let isArray = false;
		if (fieldType instanceof graphql_1.GraphQLList) {
		isArray = true;
		}
		else if (fieldType instanceof graphql_1.GraphQLNonNull && fieldType.ofType instanceof graphql_1.GraphQLList) {
		isArray = true;
		}
		let isNullable = true;
		if (fieldType instanceof graphql_1.GraphQLNonNull && !forceNullable) {
		isNullable = false;
		}
		return Object.assign({}, property, { typeName, bareTypeName, fields: field.fields, isComposite: true, fragmentSpreads, inlineFragments, fieldType,
		isArray, isNullable });
		}
		var isArray = false;
		if (fieldType instanceof _graphql.GraphQLList) {
		isArray = true;
		} else if (fieldType instanceof _graphql.GraphQLNonNull && fieldType.ofType instanceof _graphql.GraphQLList) {
		isArray = true;
		else {
		const typeName = types_1.typeNameFromGraphQLType(context, fieldType);
		return Object.assign({}, property, { typeName, isComposite: false, fieldType });
		}
		var isNullable = true;
		if (fieldType instanceof _graphql.GraphQLNonNull && !forceNullable) {
		isNullable = false;
		}
		return Object.assign({}, property, {
		typeName, bareTypeName, fields: field.fields, isComposite: true, fragmentSpreads, inlineFragments, fieldType,
		isArray, isNullable
		});
		} else {
		var _typeName = (0, _types.typeNameFromGraphQLType)(context, fieldType);
		return Object.assign({}, property, { typeName: _typeName, isComposite: false, fieldType });
		}
		}

		exports.propertyFromField = propertyFromField;
		function propertyDeclarations(generator, properties, inInterface) {
		if (!properties) return;
		properties.forEach(function (property) {
		if (property.fields && property.fields.length > 0 \|\| property.inlineFragments && property.inlineFragments.length > 0) {
		if (property.inlineFragments.length > 0) {
		(0, _language.propertyDeclaration)(generator, Object.assign({}, property, {
		inInterface
		}));
		} else {
		(0, _language.propertyDeclaration)(generator, Object.assign({}, property, { inInterface }), function () {
		var properties = propertiesFromFields(generator.context, property.fields);
		propertyDeclarations(generator, properties);
		});
		}
		} else {
		(0, _language.propertyDeclaration)(generator, Object.assign({}, property, { inInterface }));
		}
		});
		if (!properties)
		return;
		properties.forEach(property => {
		if (property.fields && property.fields.length > 0 \|\|
		property.inlineFragments && property.inlineFragments.length > 0) {
		if (property.inlineFragments.length > 0) {
		language_1.propertyDeclaration(generator, Object.assign({}, property, { inInterface }));
		}
		else {
		language_1.propertyDeclaration(generator, Object.assign({}, property, { inInterface }), () => {
		const properties = propertiesFromFields(generator.context, property.fields);
		propertyDeclarations(generator, properties);
		});
		}
		}
		else {
		language_1.propertyDeclaration(generator, Object.assign({}, property, { inInterface }));
		}
		});
		}

		exports.propertyDeclarations = propertyDeclarations;
		function makeTypenameField(typeName) {
		return {
		responseName: '__typename',
		fieldName: '__typename',
		type: typeName
		};
		return {
		responseName: '__typename',
		fieldName: '__typename',
		type: typeName,
		};
		}

		function hasTypenameField(fields) {
		if (!fields) {
		return false;
		}

		return fields.find(function (field) {
		return field.fieldName === '__typename' \|\| field.responseName === '__typename';
		});
		if (!fields) {
		return false;
		}
		return fields.find(field => field.fieldName === '__typename' \|\| field.responseName === '__typename');
		}

		function removeTypenameFieldIfExists(generator, fields) {
		if (hasTypenameField(fields)) {
		fields = fields.filter(function (field) {
		return field.fieldName !== '__typename' \|\| field.responseName !== '__typename';
		});
		return true;
		} else {
		return false;
		}
		if (hasTypenameField(fields)) {
		fields = fields.filter(field => field.fieldName !== '__typename' \|\| field.responseName !== '__typename');
		return true;
		}
		else {
		return false;
		}
		}

		/**
		* NOTE: Mutates `fields`
		*/
		function addTypenameFieldIfNeeded(generator, fields, parentTypeName) {
		var removed = removeTypenameFieldIfExists();

		if (generator.context.addTypename \|\| removed) {
		fields.unshift(makeTypenameField(parentTypeName));
		}
		const removed = removeTypenameFieldIfExists();
		if (generator.context.addTypename \|\| removed) {
		fields.unshift(makeTypenameField(parentTypeName));
		}
		}

		function handleInlineFragments(generator, fragmentName, inlineFragments) {
		// Keep track of these generated destination type names so we can build a union afterwards
		var unionTypes = [];
		inlineFragments.forEach(function (_ref8) {
		var fields = _ref8.fields,
		typeCondition = _ref8.typeCondition;

		var typeName = `${fragmentName}On${typeCondition}`;
		unionTypes.push(typeName);

		addTypenameFieldIfNeeded(generator, fields, typeCondition);

		var properties = propertiesFromFields(generator.context, fields, {
		typeNameSuffix: 'Fragment'
		let unionTypes = [];
		inlineFragments.forEach(({ fields, typeCondition }) => {
		const typeName = `${fragmentName}On${typeCondition}`;
		unionTypes.push(typeName);
		addTypenameFieldIfNeeded(generator, fields, typeCondition);
		let properties = propertiesFromFields(generator.context, fields, {
		typeNameSuffix: 'Fragment'
		});
		language_1.typeDeclaration(generator, {
		interfaceName: typeName,
		}, () => {
		propertyDeclarations(generator, properties, true);
		});
		properties.forEach(({ inlineFragments, bareTypeName }) => {
		if (inlineFragments && inlineFragments.length > 0) {
		const innerFragmentName = `${bareTypeName}Fragment`;
		handleInlineFragments(generator, innerFragmentName, inlineFragments);
		}
		});
		});

		(0, _language.typeDeclaration)(generator, {
		interfaceName: typeName
		}, function () {
		propertyDeclarations(generator, properties, true);
		language_1.typeDeclaration(generator, { interfaceName: fragmentName, noBrackets: true }, () => {
		language_1.unionDeclaration(generator, unionTypes);
		});

		properties.forEach(function (_ref9) {
		var inlineFragments = _ref9.inlineFragments,
		bareTypeName = _ref9.bareTypeName;

		if (inlineFragments && inlineFragments.length > 0) {
		var innerFragmentName = `${bareTypeName}Fragment`;
		handleInlineFragments(generator, innerFragmentName, inlineFragments);
		}
		});
		});

		// TODO: Refactor typeDeclaration to not automatically assume bracketed type
		(0, _language.typeDeclaration)(generator, { interfaceName: fragmentName, noBrackets: true }, function () {
		(0, _language.unionDeclaration)(generator, unionTypes);
		});
		}
		//# sourceMappingURL=codeGeneration.js.map

lib/flow/index.js

		@@ -1,15 +0,5 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});

		var _codeGeneration = require('./codeGeneration');

		Object.defineProperty(exports, 'generateSource', {
		enumerable: true,
		get: function get() {
		return _codeGeneration.generateSource;
		}
		});
		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		var codeGeneration_1 = require("./codeGeneration");
		exports.generateSource = codeGeneration_1.generateSource;
		//# sourceMappingURL=index.js.map

157

lib/flow/language.js

		@@ -1,103 +0,74 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.typeDeclaration = typeDeclaration;
		exports.propertyDeclaration = propertyDeclaration;
		exports.propertyDeclarations = propertyDeclarations;
		exports.unionDeclaration = unionDeclaration;

		var _printing = require('../utilities/printing');

		var _changeCase = require('change-case');

		function typeDeclaration(generator, _ref, closure) {
		var interfaceName = _ref.interfaceName,
		noBrackets = _ref.noBrackets;

		generator.printNewlineIfNeeded();
		generator.printNewline();
		generator.print(`export type ${interfaceName} =`);
		generator.pushScope({ typeName: interfaceName });
		if (!noBrackets) {
		generator.withinBlock(closure, ' {\|', '\|}');
		} else {
		generator.withinBlock(closure, '', '');
		}
		generator.popScope();
		generator.print(';');
		}

		function propertyDeclaration(generator, _ref2, closure) {
		var propertyName = _ref2.propertyName,
		typeName = _ref2.typeName,
		description = _ref2.description,
		isArray = _ref2.isArray,
		isNullable = _ref2.isNullable,
		inInterface = _ref2.inInterface,
		fragmentSpreads = _ref2.fragmentSpreads;

		generator.printOnNewline(description && `// ${description}`);
		if (closure) {
		generator.printOnNewline(`${propertyName}:`);
		if (isNullable) {
		generator.print(' ?');
		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const change_case_1 = require("change-case");
		function typeDeclaration(generator, { interfaceName, noBrackets }, closure) {
		generator.printNewlineIfNeeded();
		generator.printNewline();
		generator.print(`export type ${interfaceName} =`);
		generator.pushScope({ typeName: interfaceName });
		if (!noBrackets) {
		generator.withinBlock(closure, ' {\|', '\|}');
		}
		if (isArray) {
		if (!isNullable) {
		generator.print(' ');
		}
		generator.print('Array<');
		else {
		generator.withinBlock(closure, '', '');
		}

		generator.pushScope({ typeName: propertyName });

		generator.withinBlock(function () {
		if (fragmentSpreads && fragmentSpreads.length > 0) {
		fragmentSpreads.forEach(function (n) {
		return generator.printOnNewline(`...${(0, _changeCase.pascalCase)(n)}Fragment,`);
		});
		}

		closure();
		}, ' {\|', '\|}');

		generator.popScope();

		if (isArray) {
		generator.print(' >');
		generator.print(';');
		}
		exports.typeDeclaration = typeDeclaration;
		function propertyDeclaration(generator, { propertyName, typeName, description, isArray, isNullable, inInterface, fragmentSpreads }, closure) {
		generator.printOnNewline(description && `// ${description}`);
		if (closure) {
		generator.printOnNewline(`${propertyName}:`);
		if (isNullable) {
		generator.print(' ?');
		}
		if (isArray) {
		if (!isNullable) {
		generator.print(' ');
		}
		generator.print('Array<');
		}
		generator.pushScope({ typeName: propertyName });
		generator.withinBlock(() => {
		if (fragmentSpreads && fragmentSpreads.length > 0) {
		fragmentSpreads.forEach(n => generator.printOnNewline(`...${change_case_1.pascalCase(n)}Fragment,`));
		}
		closure();
		}, ' {\|', '\|}');
		generator.popScope();
		if (isArray) {
		generator.print(' >');
		}
		}
		} else if (fragmentSpreads && fragmentSpreads.length === 1) {
		generator.printOnNewline(`${propertyName}: ${isArray ? 'Array<' : ''}${(0, _changeCase.pascalCase)(fragmentSpreads[0])}Fragment${isArray ? '>' : ''}`);
		} else if (fragmentSpreads && fragmentSpreads.length > 1) {
		generator.printOnNewline(`${propertyName}: ${isArray ? 'Array<' : ''}`);

		generator.withinBlock(function () {
		fragmentSpreads.forEach(function (n) {
		return generator.printOnNewline(`...${(0, _changeCase.pascalCase)(n)}Fragment,`);
		});
		}, '{\|', '\|}');

		generator.print(isArray ? '>' : '');
		} else {
		generator.printOnNewline(`${propertyName}: ${typeName}`);
		}
		generator.print(',');
		else if (fragmentSpreads && fragmentSpreads.length === 1) {
		generator.printOnNewline(`${propertyName}: ${isArray ? 'Array<' : ''}${change_case_1.pascalCase(fragmentSpreads[0])}Fragment${isArray ? '>' : ''}`);
		}
		else if (fragmentSpreads && fragmentSpreads.length > 1) {
		generator.printOnNewline(`${propertyName}: ${isArray ? 'Array<' : ''}`);
		generator.withinBlock(() => {
		fragmentSpreads.forEach(n => generator.printOnNewline(`...${change_case_1.pascalCase(n)}Fragment,`));
		}, '{\|', '\|}');
		generator.print(isArray ? '>' : '');
		}
		else {
		generator.printOnNewline(`${propertyName}: ${typeName}`);
		}
		generator.print(',');
		}

		exports.propertyDeclaration = propertyDeclaration;
		function propertyDeclarations(generator, properties) {
		if (!properties) return;
		properties.forEach(function (property) {
		return propertyDeclaration(generator, property);
		});
		if (!properties)
		return;
		properties.forEach(property => propertyDeclaration(generator, property));
		}

		exports.propertyDeclarations = propertyDeclarations;
		function unionDeclaration(generator, typeNames) {
		if (!typeNames) throw new Error('Union Declaration requires types');

		typeNames.forEach(function (typeName) {
		generator.printOnNewline(`\| ${typeName}`);
		});
		if (!typeNames)
		throw new Error('Union Declaration requires types');
		typeNames.forEach(typeName => {
		generator.printOnNewline(`\| ${typeName}`);
		});
		}
		exports.unionDeclaration = unionDeclaration;
		//# sourceMappingURL=language.js.map

lib/flow/types.js

		@@ -1,40 +0,28 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.typeNameFromGraphQLType = typeNameFromGraphQLType;

		var _printing = require('../utilities/printing');

		var _changeCase = require('change-case');

		var _graphql = require('graphql');

		var builtInScalarMap = {
		[_graphql.GraphQLString.name]: 'string',
		[_graphql.GraphQLInt.name]: 'number',
		[_graphql.GraphQLFloat.name]: 'number',
		[_graphql.GraphQLBoolean.name]: 'boolean',
		[_graphql.GraphQLID.name]: 'string'
		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const graphql_1 = require("graphql");
		const builtInScalarMap = {
		[graphql_1.GraphQLString.name]: 'string',
		[graphql_1.GraphQLInt.name]: 'number',
		[graphql_1.GraphQLFloat.name]: 'number',
		[graphql_1.GraphQLBoolean.name]: 'boolean',
		[graphql_1.GraphQLID.name]: 'string',
		};

		function typeNameFromGraphQLType(context, type, bareTypeName) {
		var nullable = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;

		if (type instanceof _graphql.GraphQLNonNull) {
		return typeNameFromGraphQLType(context, type.ofType, bareTypeName, false);
		}

		var typeName = void 0;
		if (type instanceof _graphql.GraphQLList) {
		typeName = `Array< ${typeNameFromGraphQLType(context, type.ofType, bareTypeName, true)} >`;
		} else if (type instanceof _graphql.GraphQLScalarType) {
		typeName = builtInScalarMap[type.name] \|\| (context.passthroughCustomScalars ? context.customScalarsPrefix + type.name : 'any');
		} else {
		typeName = bareTypeName \|\| type.name;
		}

		return nullable ? '?' + typeName : typeName;
		function typeNameFromGraphQLType(context, type, bareTypeName, nullable = true) {
		if (type instanceof graphql_1.GraphQLNonNull) {
		return typeNameFromGraphQLType(context, type.ofType, bareTypeName, false);
		}
		let typeName;
		if (type instanceof graphql_1.GraphQLList) {
		typeName = `Array< ${typeNameFromGraphQLType(context, type.ofType, bareTypeName, true)} >`;
		}
		else if (type instanceof graphql_1.GraphQLScalarType) {
		typeName = builtInScalarMap[type.name] \|\| (context.passthroughCustomScalars ? context.customScalarsPrefix + type.name : 'any');
		}
		else {
		typeName = bareTypeName \|\| type.name;
		}
		return nullable ? '?' + typeName : typeName;
		}
		exports.typeNameFromGraphQLType = typeNameFromGraphQLType;
		//# sourceMappingURL=types.js.map

118

lib/generate.js

		@@ -1,75 +0,51 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = generate;

		var _fs = require('fs');

		var _fs2 = _interopRequireDefault(_fs);

		var _errors = require('./errors');

		var _loading = require('./loading');

		var _validation = require('./validation');

		var _compilation = require('./compilation');

		var _serializeToJSON = require('./serializeToJSON');

		var _serializeToJSON2 = _interopRequireDefault(_serializeToJSON);

		var _swift = require('./swift');

		var _typescript = require('./typescript');

		var _flow = require('./flow');

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const fs = require("fs");
		const loading_1 = require("./loading");
		const validation_1 = require("./validation");
		const compilation_1 = require("./compilation");
		const serializeToJSON_1 = require("./serializeToJSON");
		const swift_1 = require("./swift");
		const typescript_1 = require("./typescript");
		const flow_1 = require("./flow");
		function generate(inputPaths, schemaPath, outputPath, target, options) {
		var schema = (0, _loading.loadSchema)(schemaPath);

		var document = (0, _loading.loadAndMergeQueryDocuments)(inputPaths);

		(0, _validation.validateQueryDocument)(schema, document, target);

		if (target === 'swift') {
		if (!options.addTypename) {
		console.warn('Apollo iOS requires the __typename field to be added automatically');
		const schema = loading_1.loadSchema(schemaPath);
		const document = loading_1.loadAndMergeQueryDocuments(inputPaths);
		validation_1.validateQueryDocument(schema, document, target);
		if (target === 'swift') {
		if (!options.addTypename) {
		console.warn('Apollo iOS requires the __typename field to be added automatically');
		}
		options.addTypename = true;
		options.mergeInFieldsFromFragmentSpreads = true;
		}
		options.addTypename = true;
		options.mergeInFieldsFromFragmentSpreads = true;
		} else {
		options.mergeInFieldsFromFragmentSpreads = false;
		}

		var context = (0, _compilation.compileToIR)(schema, document, options);
		Object.assign(context, options);

		var output = void 0;
		switch (target) {
		case 'json':
		output = (0, _serializeToJSON2.default)(context);
		break;
		case 'ts':
		case 'typescript':
		output = (0, _typescript.generateSource)(context, options);
		break;
		case 'flow':
		output = (0, _flow.generateSource)(context, options);
		break;
		case 'swift':
		output = (0, _swift.generateSource)(context, options);
		break;
		}

		if (outputPath) {
		_fs2.default.writeFileSync(outputPath, output);
		} else {
		console.log(output);
		}
		else {
		options.mergeInFieldsFromFragmentSpreads = false;
		}
		const context = compilation_1.compileToIR(schema, document, options);
		Object.assign(context, options);
		let output = '';
		switch (target) {
		case 'json':
		output = serializeToJSON_1.default(context);
		break;
		case 'ts':
		case 'typescript':
		output = typescript_1.generateSource(context, options);
		break;
		case 'flow':
		output = flow_1.generateSource(context, options);
		break;
		case 'swift':
		output = swift_1.generateSource(context, options);
		break;
		}
		if (outputPath) {
		fs.writeFileSync(outputPath, output);
		}
		else {
		console.log(output);
		}
		}
		exports.default = generate;
		//# sourceMappingURL=generate.js.map

lib/index.js

		@@ -1,44 +0,12 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});

		var _downloadSchema = require('./downloadSchema');

		Object.defineProperty(exports, 'downloadSchema', {
		enumerable: true,
		get: function get() {
		return _interopRequireDefault(_downloadSchema).default;
		}
		});

		var _introspectSchema = require('./introspectSchema');

		Object.defineProperty(exports, 'introspectSchema', {
		enumerable: true,
		get: function get() {
		return _interopRequireDefault(_introspectSchema).default;
		}
		});

		var _printSchema = require('./printSchema');

		Object.defineProperty(exports, 'printSchema', {
		enumerable: true,
		get: function get() {
		return _interopRequireDefault(_printSchema).default;
		}
		});

		var _generate = require('./generate');

		Object.defineProperty(exports, 'generate', {
		enumerable: true,
		get: function get() {
		return _interopRequireDefault(_generate).default;
		}
		});

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		require("./polyfills");
		var downloadSchema_1 = require("./downloadSchema");
		exports.downloadSchema = downloadSchema_1.default;
		var introspectSchema_1 = require("./introspectSchema");
		exports.introspectSchema = introspectSchema_1.default;
		var printSchema_1 = require("./printSchema");
		exports.printSchema = printSchema_1.default;
		var generate_1 = require("./generate");
		exports.generate = generate_1.default;
		//# sourceMappingURL=index.js.map

126

lib/introspectSchema.js

		@@ -1,96 +0,36 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.introspect = undefined;

		var introspect = exports.introspect = function () {
		var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee(schemaContents) {
		var schema;
		return regeneratorRuntime.wrap(function _callee$(_context) {
		while (1) {
		switch (_context.prev = _context.next) {
		case 0:
		schema = (0, _graphql.buildASTSchema)((0, _graphql.parse)(schemaContents));
		_context.next = 3;
		return (0, _graphql.graphql)(schema, _utilities.introspectionQuery);

		case 3:
		return _context.abrupt('return', _context.sent);

		case 4:
		case 'end':
		return _context.stop();
		"use strict";
		var __awaiter = (this && this.__awaiter) \|\| function (thisArg, _arguments, P, generator) {
		return new (P \|\| (P = Promise))(function (resolve, reject) {
		function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
		function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
		function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
		step((generator = generator.apply(thisArg, _arguments \|\| [])).next());
		});
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		const fs_1 = require("fs");
		const graphql_1 = require("graphql");
		const utilities_1 = require("graphql/utilities");
		const errors_1 = require("./errors");
		function introspect(schemaContents) {
		return __awaiter(this, void 0, void 0, function* () {
		const schema = graphql_1.buildASTSchema(graphql_1.parse(schemaContents));
		return yield graphql_1.graphql(schema, utilities_1.introspectionQuery);
		});
		}
		exports.introspect = introspect;
		function introspectSchema(schemaPath, outputPath) {
		return __awaiter(this, void 0, void 0, function* () {
		if (!fs_1.default.existsSync(schemaPath)) {
		throw new errors_1.ToolError(`Cannot find GraphQL schema file: ${schemaPath}`);
		}
		}
		}, _callee, this);
		}));

		return function introspect(_x) {
		return _ref.apply(this, arguments);
		};
		}();

		var _fs = require('fs');

		var _fs2 = _interopRequireDefault(_fs);

		var _graphql = require('graphql');

		var _utilities = require('graphql/utilities');

		var _errors = require('./errors');

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

		exports.default = function () {
		var _ref2 = _asyncToGenerator(regeneratorRuntime.mark(function _callee2(schemaPath, outputPath) {
		var schemaContents, result;
		return regeneratorRuntime.wrap(function _callee2$(_context2) {
		while (1) {
		switch (_context2.prev = _context2.next) {
		case 0:
		if (_fs2.default.existsSync(schemaPath)) {
		_context2.next = 2;
		break;
		}

		throw new _errors.ToolError(`Cannot find GraphQL schema file: ${schemaPath}`);

		case 2:
		schemaContents = _fs2.default.readFileSync(schemaPath).toString();
		_context2.next = 5;
		return introspect(schemaContents);

		case 5:
		result = _context2.sent;

		if (!result.errors) {
		_context2.next = 8;
		break;
		}

		throw new _errors.ToolError(`Errors in introspection query result: ${result.errors}`);

		case 8:

		_fs2.default.writeFileSync(outputPath, JSON.stringify(result, null, 2));

		case 9:
		case 'end':
		return _context2.stop();
		const schemaContents = fs_1.default.readFileSync(schemaPath).toString();
		const result = yield introspect(schemaContents);
		if (result.errors) {
		throw new errors_1.ToolError(`Errors in introspection query result: ${result.errors}`);
		}
		}
		}, _callee2, this);
		}));

		function introspectSchema(_x2, _x3) {
		return _ref2.apply(this, arguments);
		}

		return introspectSchema;
		}();
		fs_1.default.writeFileSync(outputPath, JSON.stringify(result, null, 2));
		});
		}
		exports.default = introspectSchema;
		//# sourceMappingURL=introspectSchema.js.map

106

lib/loading.js

		@@ -1,75 +0,45 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.loadSchema = loadSchema;
		exports.loadAndMergeQueryDocuments = loadAndMergeQueryDocuments;

		var _path = require('path');

		var _path2 = _interopRequireDefault(_path);

		var _fs = require('fs');

		var _fs2 = _interopRequireDefault(_fs);

		var _mkdirp = require('mkdirp');

		var _mkdirp2 = _interopRequireDefault(_mkdirp);

		var _graphql = require('graphql');

		var _errors = require('./errors');

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const fs = require("fs");
		const graphql_1 = require("graphql");
		const errors_1 = require("./errors");
		function loadSchema(schemaPath) {
		if (!_fs2.default.existsSync(schemaPath)) {
		throw new _errors.ToolError(`Cannot find GraphQL schema file: ${schemaPath}`);
		}
		var schemaData = require(schemaPath);

		if (!schemaData.data && !schemaData.__schema) {
		throw new _errors.ToolError('GraphQL schema file should contain a valid GraphQL introspection query result');
		}
		return (0, _graphql.buildClientSchema)(schemaData.data ? schemaData.data : schemaData);
		if (!fs.existsSync(schemaPath)) {
		throw new errors_1.ToolError(`Cannot find GraphQL schema file: ${schemaPath}`);
		}
		const schemaData = require(schemaPath);
		if (!schemaData.data && !schemaData.__schema) {
		throw new errors_1.ToolError('GraphQL schema file should contain a valid GraphQL introspection query result');
		}
		return graphql_1.buildClientSchema((schemaData.data) ? schemaData.data : schemaData);
		}

		exports.loadSchema = loadSchema;
		function extractDocumentFromJavascript(content) {
		var re = /gql`([^`]*)`/g;
		var match = void 0;
		var matches = [];

		while (match = re.exec(content)) {
		var _doc = match[1].replace(/\${[^}]*}/g, '');

		matches.push(_doc);
		}

		var doc = matches.join('\n');
		return doc.length ? doc : null;
		const re = /gql`([^`]*)`/g;
		let match;
		const matches = [];
		while (match = re.exec(content)) {
		const doc = match[1]
		.replace(/\${[^}]*}/g, '');
		matches.push(doc);
		}
		const doc = matches.join('\n');
		return doc.length ? doc : null;
		}

		function loadAndMergeQueryDocuments(inputPaths) {
		var sources = inputPaths.map(function (inputPath) {
		var body = _fs2.default.readFileSync(inputPath, 'utf8');
		if (!body) {
		return null;
		}

		if (inputPath.endsWith('.jsx') \|\| inputPath.endsWith('.js') \|\| inputPath.endsWith('.tsx') \|\| inputPath.endsWith('.ts')) {
		var doc = extractDocumentFromJavascript(body.toString());
		return doc ? new _graphql.Source(doc, inputPath) : null;
		}

		return new _graphql.Source(body, inputPath);
		}).filter(function (source) {
		return source;
		});

		return (0, _graphql.concatAST)(sources.map(function (source) {
		return (0, _graphql.parse)(source);
		}));
		const sources = inputPaths.map(inputPath => {
		const body = fs.readFileSync(inputPath, 'utf8');
		if (!body) {
		return null;
		}
		if (inputPath.endsWith('.jsx') \|\| inputPath.endsWith('.js')
		\|\| inputPath.endsWith('.tsx') \|\| inputPath.endsWith('.ts')) {
		const doc = extractDocumentFromJavascript(body.toString());
		return doc ? new graphql_1.Source(doc, inputPath) : null;
		}
		return new graphql_1.Source(body, inputPath);
		}).filter(source => source);
		return graphql_1.concatAST(sources.map(source => graphql_1.parse(source)));
		}
		exports.loadAndMergeQueryDocuments = loadAndMergeQueryDocuments;
		//# sourceMappingURL=loading.js.map

lib/printSchema.js

		@@ -1,68 +0,34 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});

		var _fs = require('fs');

		var _fs2 = _interopRequireDefault(_fs);

		var _graphql = require('graphql');

		var _errors = require('./errors');

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

		exports.default = function () {
		var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee(schemaPath, outputPath) {
		var schemaJSON, schema, schemaIDL;
		return regeneratorRuntime.wrap(function _callee$(_context) {
		while (1) {
		switch (_context.prev = _context.next) {
		case 0:
		if (_fs2.default.existsSync(schemaPath)) {
		_context.next = 2;
		break;
		}

		throw new _errors.ToolError(`Cannot find GraphQL schema file: ${schemaPath}`);

		case 2:
		schemaJSON = JSON.parse(_fs2.default.readFileSync(schemaPath, 'utf8'));

		if (schemaJSON.data) {
		_context.next = 5;
		break;
		}

		throw new _errors.ToolError(`No introspection query result data found in: ${schemaPath}`);

		case 5:
		schema = (0, _graphql.buildClientSchema)(schemaJSON.data);
		schemaIDL = (0, _graphql.printSchema)(schema);


		if (outputPath) {
		_fs2.default.writeFileSync(outputPath, schemaIDL);
		} else {
		console.log(schemaIDL);
		}

		case 8:
		case 'end':
		return _context.stop();
		"use strict";
		var __awaiter = (this && this.__awaiter) \|\| function (thisArg, _arguments, P, generator) {
		return new (P \|\| (P = Promise))(function (resolve, reject) {
		function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
		function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
		function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
		step((generator = generator.apply(thisArg, _arguments \|\| [])).next());
		});
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		const fs_1 = require("fs");
		const graphql_1 = require("graphql");
		const errors_1 = require("./errors");
		function printSchemaFromIntrospectionResult(schemaPath, outputPath) {
		return __awaiter(this, void 0, void 0, function* () {
		if (!fs_1.default.existsSync(schemaPath)) {
		throw new errors_1.ToolError(`Cannot find GraphQL schema file: ${schemaPath}`);
		}
		}
		}, _callee, this);
		}));

		function printSchemaFromIntrospectionResult(_x, _x2) {
		return _ref.apply(this, arguments);
		}

		return printSchemaFromIntrospectionResult;
		}();
		const schemaJSON = JSON.parse(fs_1.default.readFileSync(schemaPath, 'utf8'));
		if (!schemaJSON.data) {
		throw new errors_1.ToolError(`No introspection query result data found in: ${schemaPath}`);
		}
		const schema = graphql_1.buildClientSchema(schemaJSON.data);
		const schemaIDL = graphql_1.printSchema(schema);
		if (outputPath) {
		fs_1.default.writeFileSync(outputPath, schemaIDL);
		}
		else {
		console.log(schemaIDL);
		}
		});
		}
		exports.default = printSchemaFromIntrospectionResult;
		//# sourceMappingURL=printSchema.js.map

126

lib/serializeToJSON.js

		@@ -1,85 +0,67 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = serializeToJSON;
		exports.serializeAST = serializeAST;

		var _graphql = require('graphql');

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const graphql_1 = require("graphql");
		function serializeToJSON(context) {
		return serializeAST({
		operations: Object.values(context.operations),
		fragments: Object.values(context.fragments),
		typesUsed: context.typesUsed.map(serializeType)
		}, '\t');
		return serializeAST({
		operations: Object.values(context.operations),
		fragments: Object.values(context.fragments),
		typesUsed: context.typesUsed.map(serializeType),
		}, '\t');
		}

		exports.default = serializeToJSON;
		function serializeAST(ast, space) {
		return JSON.stringify(ast, function (key, value) {
		if ((0, _graphql.isType)(value)) {
		return String(value);
		} else {
		return value;
		}
		}, space);
		return JSON.stringify(ast, function (key, value) {
		if (graphql_1.isType(value)) {
		return String(value);
		}
		else {
		return value;
		}
		}, space);
		}

		exports.serializeAST = serializeAST;
		function serializeType(type) {
		if (type instanceof _graphql.GraphQLEnumType) {
		return serializeEnumType(type);
		} else if (type instanceof _graphql.GraphQLInputObjectType) {
		return serializeInputObjectType(type);
		} else if (type instanceof _graphql.GraphQLScalarType) {
		return serializeScalarType(type);
		}
		if (type instanceof graphql_1.GraphQLEnumType) {
		return serializeEnumType(type);
		}
		else if (type instanceof graphql_1.GraphQLInputObjectType) {
		return serializeInputObjectType(type);
		}
		else if (type instanceof graphql_1.GraphQLScalarType) {
		return serializeScalarType(type);
		}
		}

		function serializeEnumType(type) {
		var name = type.name,
		description = type.description;

		var values = type.getValues();

		return {
		kind: 'EnumType',
		name,
		description,
		values: values.map(function (value) {
		return {
		name: value.name,
		description: value.description,
		isDeprecated: value.isDeprecated,
		deprecationReason: value.deprecationReason
		};
		})
		};
		const { name, description } = type;
		const values = type.getValues();
		return {
		kind: 'EnumType',
		name,
		description,
		values: values.map(value => ({
		name: value.name,
		description: value.description,
		isDeprecated: value.isDeprecated,
		deprecationReason: value.deprecationReason
		}))
		};
		}

		function serializeInputObjectType(type) {
		var name = type.name,
		description = type.description;

		var fields = Object.values(type.getFields());

		return {
		kind: 'InputObjectType',
		name,
		description,
		fields
		};
		const { name, description } = type;
		const fields = Object.values(type.getFields());
		return {
		kind: 'InputObjectType',
		name,
		description,
		fields
		};
		}

		function serializeScalarType(type) {
		var name = type.name,
		description = type.description;


		return {
		kind: 'ScalarType',
		name,
		description
		};
		const { name, description } = type;
		return {
		kind: 'ScalarType',
		name,
		description
		};
		}
		//# sourceMappingURL=serializeToJSON.js.map

924

lib/swift/codeGeneration.js

		@@ -1,579 +0,427 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const graphql_1 = require("graphql");
		const graphql_2 = require("../utilities/graphql");
		const printing_1 = require("../utilities/printing");
		const language_1 = require("./language");
		const naming_1 = require("./naming");
		const values_1 = require("./values");
		const types_1 = require("./types");
		const CodeGenerator_1 = require("../utilities/CodeGenerator");
		function generateSource(context, options) {
		const generator = new CodeGenerator_1.default(context);
		generator.printOnNewline('// This file was automatically generated and should not be edited.');
		generator.printNewline();
		generator.printOnNewline('import Apollo');
		language_1.namespaceDeclaration(generator, context.namespace, () => {
		context.typesUsed.forEach(type => {
		typeDeclarationForGraphQLType(generator, type);
		});
		Object.values(context.operations).forEach(operation => {
		classDeclarationForOperation(generator, operation);
		});
		Object.values(context.fragments).forEach(fragment => {
		structDeclarationForFragment(generator, fragment);
		});
		});
		return generator.output;
		}
		exports.generateSource = generateSource;
		exports.classDeclarationForOperation = classDeclarationForOperation;
		exports.structDeclarationForFragment = structDeclarationForFragment;
		exports.structDeclarationForSelectionSet = structDeclarationForSelectionSet;
		exports.initializerDeclarationForProperties = initializerDeclarationForProperties;
		exports.selectionSetInitialization = selectionSetInitialization;
		exports.typeDeclarationForGraphQLType = typeDeclarationForGraphQLType;

		var _graphql = require('graphql');

		var _graphql2 = require('../utilities/graphql');

		var _printing = require('../utilities/printing');

		var _language = require('./language');

		var _naming = require('./naming');

		var _values = require('./values');

		var _types = require('./types');

		var _CodeGenerator = require('../utilities/CodeGenerator');

		var _CodeGenerator2 = _interopRequireDefault(_CodeGenerator);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

		function generateSource(context) {
		var generator = new _CodeGenerator2.default(context);

		generator.printOnNewline('// This file was automatically generated and should not be edited.');
		generator.printNewline();
		generator.printOnNewline('import Apollo');

		(0, _language.namespaceDeclaration)(generator, context.namespace, function () {

		context.typesUsed.forEach(function (type) {
		typeDeclarationForGraphQLType(generator, type);
		function classDeclarationForOperation(generator, { operationName, operationType, rootType, variables, fields, inlineFragments, fragmentSpreads, fragmentsReferenced, source, }) {
		let className;
		let protocol;
		switch (operationType) {
		case 'query':
		className = `${naming_1.operationClassName(operationName)}Query`;
		protocol = 'GraphQLQuery';
		break;
		case 'mutation':
		className = `${naming_1.operationClassName(operationName)}Mutation`;
		protocol = 'GraphQLMutation';
		break;
		default:
		throw new graphql_1.GraphQLError(`Unsupported operation type "${operationType}"`);
		}
		language_1.classDeclaration(generator, {
		className,
		modifiers: ['public', 'final'],
		adoptedProtocols: [protocol]
		}, () => {
		if (source) {
		generator.printOnNewline('public static let operationString =');
		generator.withIndent(() => {
		values_1.multilineString(generator, source);
		});
		}
		if (fragmentsReferenced && fragmentsReferenced.length > 0) {
		generator.printOnNewline('public static var requestString: String { return operationString');
		fragmentsReferenced.forEach(fragment => {
		generator.print(`.appending(${naming_1.structNameForFragmentName(fragment)}.fragmentString)`);
		});
		generator.print(' }');
		}
		generator.printNewlineIfNeeded();
		if (variables && variables.length > 0) {
		const properties = variables.map(({ name, type }) => {
		const propertyName = language_1.escapeIdentifierIfNeeded(name);
		const typeName = types_1.typeNameFromGraphQLType(generator.context, type);
		const isOptional = !(type instanceof graphql_1.GraphQLNonNull \|\| type.ofType instanceof graphql_1.GraphQLNonNull);
		return { name, propertyName, type, typeName, isOptional };
		});
		language_1.propertyDeclarations(generator, properties);
		generator.printNewlineIfNeeded();
		initializerDeclarationForProperties(generator, properties);
		generator.printNewlineIfNeeded();
		generator.printOnNewline(`public var variables: GraphQLMap?`);
		generator.withinBlock(() => {
		generator.printOnNewline(printing_1.wrap(`return [`, printing_1.join(properties.map(({ name, propertyName }) => `"${name}": ${propertyName}`), ', ') \|\| ':', `]`));
		});
		}
		else {
		initializerDeclarationForProperties(generator, []);
		}
		structDeclarationForSelectionSet(generator, {
		structName: "Data",
		parentType: rootType,
		fields,
		inlineFragments,
		fragmentSpreads
		});
		});

		Object.values(context.operations).forEach(function (operation) {
		classDeclarationForOperation(generator, operation);
		});

		Object.values(context.fragments).forEach(function (fragment) {
		structDeclarationForFragment(generator, fragment);
		});
		});

		return generator.output;
		}

		function classDeclarationForOperation(generator, _ref) {
		var operationName = _ref.operationName,
		operationType = _ref.operationType,
		rootType = _ref.rootType,
		variables = _ref.variables,
		fields = _ref.fields,
		inlineFragments = _ref.inlineFragments,
		fragmentSpreads = _ref.fragmentSpreads,
		fragmentsReferenced = _ref.fragmentsReferenced,
		source = _ref.source;

		var className = void 0;
		var protocol = void 0;

		switch (operationType) {
		case 'query':
		className = `${(0, _naming.operationClassName)(operationName)}Query`;
		protocol = 'GraphQLQuery';
		break;
		case 'mutation':
		className = `${(0, _naming.operationClassName)(operationName)}Mutation`;
		protocol = 'GraphQLMutation';
		break;
		default:
		throw new _graphql.GraphQLError(`Unsupported operation type "${operationType}"`);
		}

		(0, _language.classDeclaration)(generator, {
		className,
		modifiers: ['public', 'final'],
		adoptedProtocols: [protocol]
		}, function () {
		if (source) {
		generator.printOnNewline('public static let operationString =');
		generator.withIndent(function () {
		(0, _values.multilineString)(generator, source);
		});
		}

		if (fragmentsReferenced && fragmentsReferenced.length > 0) {
		generator.printOnNewline('public static var requestString: String { return operationString');
		fragmentsReferenced.forEach(function (fragment) {
		generator.print(`.appending(${(0, _naming.structNameForFragmentName)(fragment)}.fragmentString)`);
		});
		generator.print(' }');
		}

		generator.printNewlineIfNeeded();

		if (variables && variables.length > 0) {
		var properties = variables.map(function (_ref2) {
		var name = _ref2.name,
		type = _ref2.type;

		var propertyName = (0, _language.escapeIdentifierIfNeeded)(name);
		var typeName = (0, _types.typeNameFromGraphQLType)(generator.context, type);
		var isOptional = !(type instanceof _graphql.GraphQLNonNull \|\| type.ofType instanceof _graphql.GraphQLNonNull);
		return { name, propertyName, type, typeName, isOptional };
		});

		(0, _language.propertyDeclarations)(generator, properties);

		generator.printNewlineIfNeeded();
		initializerDeclarationForProperties(generator, properties);

		generator.printNewlineIfNeeded();
		generator.printOnNewline(`public var variables: GraphQLMap?`);
		generator.withinBlock(function () {
		generator.printOnNewline((0, _printing.wrap)(`return [`, (0, _printing.join)(properties.map(function (_ref3) {
		var name = _ref3.name,
		propertyName = _ref3.propertyName;
		return `"${name}": ${propertyName}`;
		}), ', ') \|\| ':', `]`));
		});
		} else {
		initializerDeclarationForProperties(generator, []);
		}

		exports.classDeclarationForOperation = classDeclarationForOperation;
		function structDeclarationForFragment(generator, { fragmentName, typeCondition, fields, inlineFragments, fragmentSpreads, source }) {
		const structName = naming_1.structNameForFragmentName(fragmentName);
		structDeclarationForSelectionSet(generator, {
		structName: "Data",
		parentType: rootType,
		fields,
		inlineFragments,
		fragmentSpreads
		structName,
		adoptedProtocols: ['GraphQLFragment'],
		parentType: typeCondition,
		fields,
		inlineFragments,
		fragmentSpreads
		}, () => {
		if (source) {
		generator.printOnNewline('public static let fragmentString =');
		generator.withIndent(() => {
		values_1.multilineString(generator, source);
		});
		}
		});
		});
		}

		function structDeclarationForFragment(generator, _ref4) {
		var fragmentName = _ref4.fragmentName,
		typeCondition = _ref4.typeCondition,
		fields = _ref4.fields,
		inlineFragments = _ref4.inlineFragments,
		fragmentSpreads = _ref4.fragmentSpreads,
		source = _ref4.source;

		var structName = (0, _naming.structNameForFragmentName)(fragmentName);

		structDeclarationForSelectionSet(generator, {
		structName,
		adoptedProtocols: ['GraphQLFragment'],
		parentType: typeCondition,
		fields,
		inlineFragments,
		fragmentSpreads
		}, function () {
		if (source) {
		generator.printOnNewline('public static let fragmentString =');
		generator.withIndent(function () {
		(0, _values.multilineString)(generator, source);
		});
		}
		});
		}

		function structDeclarationForSelectionSet(generator, _ref5, beforeClosure) {
		var structName = _ref5.structName,
		_ref5$adoptedProtocol = _ref5.adoptedProtocols,
		adoptedProtocols = _ref5$adoptedProtocol === undefined ? ['GraphQLSelectionSet'] : _ref5$adoptedProtocol,
		parentType = _ref5.parentType,
		fields = _ref5.fields,
		inlineFragments = _ref5.inlineFragments,
		fragmentSpreads = _ref5.fragmentSpreads;

		var possibleTypes = parentType ? (0, _types.possibleTypesForType)(generator.context, parentType) : null;

		(0, _language.structDeclaration)(generator, { structName, adoptedProtocols }, function () {
		if (beforeClosure) {
		beforeClosure();
		}

		if (possibleTypes) {
		generator.printNewlineIfNeeded();
		generator.printOnNewline('public static let possibleTypes = [');
		generator.print((0, _printing.join)(possibleTypes.map(function (type) {
		return `"${String(type)}"`;
		}), ', '));
		generator.print(']');
		}

		generator.printNewlineIfNeeded();
		generator.printOnNewline('public static let selections: [Selection] = ');
		selectionSetInitialization(generator, fields, inlineFragments, structName);

		generator.printNewlineIfNeeded();

		(0, _language.propertyDeclaration)(generator, { propertyName: "snapshot", typeName: "Snapshot" });

		generator.printNewlineIfNeeded();
		generator.printOnNewline('public init(snapshot: Snapshot)');
		generator.withinBlock(function () {
		generator.printOnNewline(`self.snapshot = snapshot`);
		});

		if (!possibleTypes \|\| possibleTypes.length == 1) {
		generator.printNewlineIfNeeded();
		generator.printOnNewline(`public init`);

		var properties = fields.map(function (field) {
		return (0, _naming.propertyFromField)(generator.context, field);
		}).filter(function (field) {
		return field.propertyName != "__typename";
		});

		parametersForProperties(generator, properties);

		generator.withinBlock(function () {
		generator.printOnNewline((0, _printing.wrap)(`self.init(snapshot: [`, (0, _printing.join)([`"__typename": "${possibleTypes[0]}"`].concat(_toConsumableArray(properties.map(function (_ref6) {
		var propertyName = _ref6.propertyName;
		return `"${propertyName}": ${propertyName}`;
		}))), ', ') \|\| ':', `])`));
		});
		} else {
		possibleTypes.forEach(function (possibleType) {
		exports.structDeclarationForFragment = structDeclarationForFragment;
		function structDeclarationForSelectionSet(generator, { structName, adoptedProtocols = ['GraphQLSelectionSet'], parentType, fields, inlineFragments, fragmentSpreads, }, beforeClosure) {
		const possibleTypes = parentType ? types_1.possibleTypesForType(generator.context, parentType) : null;
		language_1.structDeclaration(generator, { structName, adoptedProtocols }, () => {
		if (beforeClosure) {
		beforeClosure();
		}
		if (possibleTypes) {
		generator.printNewlineIfNeeded();
		generator.printOnNewline('public static let possibleTypes = [');
		generator.print(printing_1.join(possibleTypes.map(type => `"${String(type)}"`), ', '));
		generator.print(']');
		}
		generator.printNewlineIfNeeded();
		generator.printOnNewline(`public static func make${possibleType}`);

		var inlineFragment = inlineFragments && inlineFragments.find(function (inlineFragment) {
		return inlineFragment.typeCondition === possibleType;
		generator.printOnNewline('public static let selections: [Selection] = ');
		selectionSetInitialization(generator, fields, inlineFragments, structName);
		generator.printNewlineIfNeeded();
		language_1.propertyDeclaration(generator, { propertyName: "snapshot", typeName: "Snapshot" });
		generator.printNewlineIfNeeded();
		generator.printOnNewline('public init(snapshot: Snapshot)');
		generator.withinBlock(() => {
		generator.printOnNewline(`self.snapshot = snapshot`);
		});
		var fieldsForPossibleType = inlineFragment ? inlineFragment.fields : fields;

		var properties = fieldsForPossibleType.map(function (field) {
		return (0, _naming.propertyFromField)(generator.context, field, inlineFragment && (0, _naming.structNameForInlineFragment)(inlineFragment));
		}).filter(function (field) {
		return field.propertyName != "__typename";
		if (!possibleTypes \|\| possibleTypes.length == 1) {
		generator.printNewlineIfNeeded();
		generator.printOnNewline(`public init`);
		const properties = fields
		.map(field => naming_1.propertyFromField(generator.context, field))
		.filter(field => field.propertyName != "__typename");
		parametersForProperties(generator, properties);
		generator.withinBlock(() => {
		generator.printOnNewline(printing_1.wrap(`self.init(snapshot: [`, printing_1.join([
		`"__typename": "${possibleTypes[0]}"`,
		...properties.map(({ propertyName }) => `"${propertyName}": ${propertyName}`)
		], ', ') \|\| ':', `])`));
		});
		}
		else {
		possibleTypes.forEach(possibleType => {
		generator.printNewlineIfNeeded();
		generator.printOnNewline(`public static func make${possibleType}`);
		const inlineFragment = inlineFragments && inlineFragments.find(inlineFragment => inlineFragment.typeCondition === possibleType);
		const fieldsForPossibleType = inlineFragment ? inlineFragment.fields : fields;
		const properties = fieldsForPossibleType
		.map(field => naming_1.propertyFromField(generator.context, field, inlineFragment && naming_1.structNameForInlineFragment(inlineFragment)))
		.filter(field => field.propertyName != "__typename");
		parametersForProperties(generator, properties);
		generator.print(` -> ${structName}`);
		generator.withinBlock(() => {
		generator.printOnNewline(printing_1.wrap(`return ${structName}(snapshot: [`, printing_1.join([
		`"__typename": "${possibleType}"`,
		...properties.map(({ propertyName }) => `"${propertyName}": ${propertyName}`)
		], ', ') \|\| ':', `])`));
		});
		});
		}
		fields.forEach(field => propertyDeclarationForField(generator, field));
		inlineFragments && inlineFragments.forEach(inlineFragment => propertyDeclarationForInlineFragment(generator, inlineFragment));
		if (fragmentSpreads && fragmentSpreads.length > 0) {
		generator.printNewlineIfNeeded();
		generator.printOnNewline(`public var fragments: Fragments`);
		generator.withinBlock(() => {
		generator.printOnNewline("get");
		generator.withinBlock(() => {
		generator.printOnNewline(`return Fragments(snapshot: snapshot)`);
		});
		generator.printOnNewline("set");
		generator.withinBlock(() => {
		generator.printOnNewline(`snapshot = newValue.snapshot`);
		});
		});
		}
		if (inlineFragments && inlineFragments.length > 0) {
		inlineFragments.forEach((inlineFragment) => {
		structDeclarationForSelectionSet(generator, {
		structName: naming_1.structNameForInlineFragment(inlineFragment),
		parentType: inlineFragment.typeCondition,
		adoptedProtocols: ['GraphQLFragment'],
		fields: inlineFragment.fields,
		inlineFragments: inlineFragment.inlineFragments,
		fragmentSpreads: inlineFragment.fragmentSpreads
		});
		});
		}
		if (fragmentSpreads && fragmentSpreads.length > 0) {
		language_1.structDeclaration(generator, {
		structName: 'Fragments'
		}, () => {
		language_1.propertyDeclaration(generator, { propertyName: "snapshot", typeName: "Snapshot" });
		fragmentSpreads.forEach(fragmentSpread => {
		const { propertyName, bareTypeName, typeName, fragment } = naming_1.propertyFromFragmentSpread(generator.context, fragmentSpread);
		const isOptional = !graphql_2.isTypeProperSuperTypeOf(generator.context.schema, fragment.typeCondition, parentType);
		generator.printNewlineIfNeeded();
		generator.printOnNewline(`public var ${propertyName}: ${isOptional ? typeName + '?' : typeName}`);
		generator.withinBlock(() => {
		generator.printOnNewline("get");
		generator.withinBlock(() => {
		if (isOptional) {
		generator.printOnNewline(`if !${typeName}.possibleTypes.contains(snapshot["__typename"]! as! String) { return nil }`);
		}
		generator.printOnNewline(`return ${typeName}(snapshot: snapshot)`);
		});
		generator.printOnNewline("set");
		generator.withinBlock(() => {
		if (isOptional) {
		generator.printOnNewline(`guard let newValue = newValue else { return }`);
		generator.printOnNewline(`snapshot = newValue.snapshot`);
		}
		else {
		generator.printOnNewline(`snapshot = newValue.snapshot`);
		}
		});
		});
		});
		});
		}
		fields.filter(field => graphql_1.isCompositeType(graphql_1.getNamedType(field.type))).forEach(field => {
		structDeclarationForSelectionSet(generator, {
		structName: naming_1.structNameForPropertyName(field.responseName),
		parentType: graphql_1.getNamedType(field.type),
		fields: field.fields,
		inlineFragments: field.inlineFragments,
		fragmentSpreads: field.fragmentSpreads
		});
		});

		parametersForProperties(generator, properties);

		generator.print(` -> ${structName}`);

		generator.withinBlock(function () {
		generator.printOnNewline((0, _printing.wrap)(`return ${structName}(snapshot: [`, (0, _printing.join)([`"__typename": "${possibleType}"`].concat(_toConsumableArray(properties.map(function (_ref7) {
		var propertyName = _ref7.propertyName;
		return `"${propertyName}": ${propertyName}`;
		}))), ', ') \|\| ':', `])`));
		});
		});
		}

		fields.forEach(function (field) {
		return propertyDeclarationForField(generator, field);
		});
		inlineFragments && inlineFragments.forEach(function (inlineFragment) {
		return propertyDeclarationForInlineFragment(generator, inlineFragment);
		});

		if (fragmentSpreads && fragmentSpreads.length > 0) {
		generator.printNewlineIfNeeded();
		generator.printOnNewline(`public var fragments: Fragments`);
		generator.withinBlock(function () {
		generator.printOnNewline("get");
		generator.withinBlock(function () {
		generator.printOnNewline(`return Fragments(snapshot: snapshot)`);
		});
		generator.printOnNewline("set");
		generator.withinBlock(function () {
		generator.printOnNewline(`snapshot = newValue.snapshot`);
		});
		});
		}

		if (inlineFragments && inlineFragments.length > 0) {
		inlineFragments.forEach(function (inlineFragment) {
		structDeclarationForSelectionSet(generator, {
		structName: (0, _naming.structNameForInlineFragment)(inlineFragment),
		parentType: inlineFragment.typeCondition,
		adoptedProtocols: ['GraphQLFragment'],
		fields: inlineFragment.fields,
		inlineFragments: inlineFragment.inlineFragments,
		fragmentSpreads: inlineFragment.fragmentSpreads
		});
		});
		}

		if (fragmentSpreads && fragmentSpreads.length > 0) {
		(0, _language.structDeclaration)(generator, {
		structName: 'Fragments'
		}, function () {
		(0, _language.propertyDeclaration)(generator, { propertyName: "snapshot", typeName: "Snapshot" });
		fragmentSpreads.forEach(function (fragmentSpread) {
		var _propertyFromFragment = (0, _naming.propertyFromFragmentSpread)(generator.context, fragmentSpread),
		propertyName = _propertyFromFragment.propertyName,
		bareTypeName = _propertyFromFragment.bareTypeName,
		typeName = _propertyFromFragment.typeName,
		fragment = _propertyFromFragment.fragment;

		var isOptional = !(0, _graphql2.isTypeProperSuperTypeOf)(generator.context.schema, fragment.typeCondition, parentType);

		generator.printNewlineIfNeeded();
		generator.printOnNewline(`public var ${propertyName}: ${isOptional ? typeName + '?' : typeName}`);
		generator.withinBlock(function () {
		}
		exports.structDeclarationForSelectionSet = structDeclarationForSelectionSet;
		function propertyDeclarationForField(generator, field) {
		const { kind, propertyName, typeName, type, isConditional, description } = naming_1.propertyFromField(generator.context, field);
		const responseName = field.responseName;
		const namedType = graphql_1.getNamedType(type);
		generator.printNewlineIfNeeded();
		language_1.comment(generator, description);
		generator.printOnNewline(`public var ${propertyName}: ${typeName}`);
		generator.withinBlock(() => {
		if (graphql_1.isCompositeType(namedType)) {
		const isOptional = isConditional \|\| !(type instanceof graphql_1.GraphQLNonNull);
		const isList = type instanceof graphql_1.GraphQLList \|\| type.ofType instanceof graphql_1.GraphQLList;
		const structName = language_1.escapeIdentifierIfNeeded(naming_1.structNameForPropertyName(propertyName));
		if (isList) {
		generator.printOnNewline("get");
		generator.withinBlock(() => {
		const snapshotTypeName = types_1.typeNameFromGraphQLType(generator.context, type, 'Snapshot', isOptional);
		let getter = `return (snapshot["${responseName}"]! as! ${snapshotTypeName})`;
		getter += mapExpressionForType(generator.context, type, `${structName}(snapshot: $0)`);
		generator.printOnNewline(getter);
		});
		generator.printOnNewline("set");
		generator.withinBlock(() => {
		let newValueExpression = "newValue" + mapExpressionForType(generator.context, type, `$0.snapshot`);
		generator.printOnNewline(`snapshot.updateValue(${newValueExpression}, forKey: "${responseName}")`);
		});
		}
		else {
		generator.printOnNewline("get");
		generator.withinBlock(() => {
		if (isOptional) {
		generator.printOnNewline(`return (snapshot["${responseName}"]! as! Snapshot?).flatMap { ${structName}(snapshot: $0) }`);
		}
		else {
		generator.printOnNewline(`return ${structName}(snapshot: snapshot["${responseName}"]! as! Snapshot)`);
		}
		});
		generator.printOnNewline("set");
		generator.withinBlock(() => {
		let newValueExpression;
		if (isOptional) {
		newValueExpression = 'newValue?.snapshot';
		}
		else {
		newValueExpression = 'newValue.snapshot';
		}
		generator.printOnNewline(`snapshot.updateValue(${newValueExpression}, forKey: "${responseName}")`);
		});
		}
		}
		else {
		generator.printOnNewline("get");
		generator.withinBlock(function () {
		if (isOptional) {
		generator.printOnNewline(`if !${typeName}.possibleTypes.contains(snapshot["__typename"]! as! String) { return nil }`);
		}
		generator.printOnNewline(`return ${typeName}(snapshot: snapshot)`);
		generator.withinBlock(() => {
		generator.printOnNewline(`return snapshot["${responseName}"]! as! ${typeName}`);
		});
		generator.printOnNewline("set");
		generator.withinBlock(function () {
		if (isOptional) {
		generator.printOnNewline(`guard let newValue = newValue else { return }`);
		generator.printOnNewline(`snapshot = newValue.snapshot`);
		} else {
		generator.printOnNewline(`snapshot = newValue.snapshot`);
		}
		generator.withinBlock(() => {
		generator.printOnNewline(`snapshot.updateValue(newValue, forKey: "${responseName}")`);
		});
		});
		});
		});
		}

		fields.filter(function (field) {
		return (0, _graphql.isCompositeType)((0, _graphql.getNamedType)(field.type));
		}).forEach(function (field) {
		structDeclarationForSelectionSet(generator, {
		structName: (0, _naming.structNameForPropertyName)(field.responseName),
		parentType: (0, _graphql.getNamedType)(field.type),
		fields: field.fields,
		inlineFragments: field.inlineFragments,
		fragmentSpreads: field.fragmentSpreads
		});
		}
		});
		});
		}

		function propertyDeclarationForField(generator, field) {
		var _propertyFromField = (0, _naming.propertyFromField)(generator.context, field),
		kind = _propertyFromField.kind,
		propertyName = _propertyFromField.propertyName,
		typeName = _propertyFromField.typeName,
		type = _propertyFromField.type,
		isConditional = _propertyFromField.isConditional,
		description = _propertyFromField.description;

		var responseName = field.responseName;
		var namedType = (0, _graphql.getNamedType)(type);

		generator.printNewlineIfNeeded();
		(0, _language.comment)(generator, description);
		generator.printOnNewline(`public var ${propertyName}: ${typeName}`);
		generator.withinBlock(function () {
		if ((0, _graphql.isCompositeType)(namedType)) {
		var isOptional = isConditional \|\| !(type instanceof _graphql.GraphQLNonNull);
		var isList = type instanceof _graphql.GraphQLList \|\| type.ofType instanceof _graphql.GraphQLList;
		var structName = (0, _language.escapeIdentifierIfNeeded)((0, _naming.structNameForPropertyName)(propertyName));

		if (isList) {
		function propertyDeclarationForInlineFragment(generator, inlineFragment) {
		const { kind, propertyName, typeName, type, isConditional, description } = naming_1.propertyFromInlineFragment(generator.context, inlineFragment);
		const namedType = graphql_1.getNamedType(type);
		generator.printNewlineIfNeeded();
		language_1.comment(generator, description);
		generator.printOnNewline(`public var ${propertyName}: ${typeName}`);
		generator.withinBlock(() => {
		const structName = naming_1.structNameForInlineFragment(inlineFragment);
		generator.printOnNewline("get");
		generator.withinBlock(function () {
		var snapshotTypeName = (0, _types.typeNameFromGraphQLType)(generator.context, type, 'Snapshot', isOptional);
		var getter = `return (snapshot["${responseName}"]! as! ${snapshotTypeName})`;
		getter += mapExpressionForType(generator.context, type, `${structName}(snapshot: $0)`);
		generator.printOnNewline(getter);
		generator.withinBlock(() => {
		generator.printOnNewline(`if !${structName}.possibleTypes.contains(__typename) { return nil }`);
		generator.printOnNewline(`return ${structName}(snapshot: snapshot)`);
		});
		generator.printOnNewline("set");
		generator.withinBlock(function () {
		var newValueExpression = "newValue" + mapExpressionForType(generator.context, type, `$0.snapshot`);
		generator.printOnNewline(`snapshot.updateValue(${newValueExpression}, forKey: "${responseName}")`);
		generator.withinBlock(() => {
		generator.printOnNewline(`guard let newValue = newValue else { return }`);
		generator.printOnNewline(`snapshot = newValue.snapshot`);
		});
		} else {
		generator.printOnNewline("get");
		generator.withinBlock(function () {
		if (isOptional) {
		generator.printOnNewline(`return (snapshot["${responseName}"]! as! Snapshot?).flatMap { ${structName}(snapshot: $0) }`);
		} else {
		generator.printOnNewline(`return ${structName}(snapshot: snapshot["${responseName}"]! as! Snapshot)`);
		}
		});
		generator.printOnNewline("set");
		generator.withinBlock(function () {
		var newValueExpression = void 0;
		if (isOptional) {
		newValueExpression = 'newValue?.snapshot';
		} else {
		newValueExpression = 'newValue.snapshot';
		}
		generator.printOnNewline(`snapshot.updateValue(${newValueExpression}, forKey: "${responseName}")`);
		});
		}
		} else {
		generator.printOnNewline("get");
		generator.withinBlock(function () {
		generator.printOnNewline(`return snapshot["${responseName}"]! as! ${typeName}`);
		});
		generator.printOnNewline("set");
		generator.withinBlock(function () {
		generator.printOnNewline(`snapshot.updateValue(newValue, forKey: "${responseName}")`);
		});
		}
		});
		}

		function propertyDeclarationForInlineFragment(generator, inlineFragment) {
		var _propertyFromInlineFr = (0, _naming.propertyFromInlineFragment)(generator.context, inlineFragment),
		kind = _propertyFromInlineFr.kind,
		propertyName = _propertyFromInlineFr.propertyName,
		typeName = _propertyFromInlineFr.typeName,
		type = _propertyFromInlineFr.type,
		isConditional = _propertyFromInlineFr.isConditional,
		description = _propertyFromInlineFr.description;

		var namedType = (0, _graphql.getNamedType)(type);

		generator.printNewlineIfNeeded();
		(0, _language.comment)(generator, description);
		generator.printOnNewline(`public var ${propertyName}: ${typeName}`);
		generator.withinBlock(function () {
		var structName = (0, _naming.structNameForInlineFragment)(inlineFragment);

		generator.printOnNewline("get");
		generator.withinBlock(function () {
		generator.printOnNewline(`if !${structName}.possibleTypes.contains(__typename) { return nil }`);
		generator.printOnNewline(`return ${structName}(snapshot: snapshot)`);
		});
		generator.printOnNewline("set");
		generator.withinBlock(function () {
		generator.printOnNewline(`guard let newValue = newValue else { return }`);
		generator.printOnNewline(`snapshot = newValue.snapshot`);
		});
		});
		}

		function mapExpressionForType(context, type, expression) {
		var prefix = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';

		var isOptional = void 0;
		if (type instanceof _graphql.GraphQLNonNull) {
		isOptional = false;
		type = type.ofType;
		} else {
		isOptional = true;
		}

		if (type instanceof _graphql.GraphQLList) {
		if (isOptional) {
		return `${prefix}.flatMap { $0.map { ${mapExpressionForType(context, type.ofType, expression, '$0')} } }`;
		} else {
		return `${prefix}.map { ${mapExpressionForType(context, type.ofType, expression, '$0')} }`;
		function mapExpressionForType(context, type, expression, prefix = '') {
		let isOptional;
		if (type instanceof graphql_1.GraphQLNonNull) {
		isOptional = false;
		type = type.ofType;
		}
		} else if (isOptional) {
		return `${prefix}.flatMap { ${expression} }`;
		} else {
		return expression;
		}
		else {
		isOptional = true;
		}
		if (type instanceof graphql_1.GraphQLList) {
		if (isOptional) {
		return `${prefix}.flatMap { $0.map { ${mapExpressionForType(context, type.ofType, expression, '$0')} } }`;
		}
		else {
		return `${prefix}.map { ${mapExpressionForType(context, type.ofType, expression, '$0')} }`;
		}
		}
		else if (isOptional) {
		return `${prefix}.flatMap { ${expression} }`;
		}
		else {
		return expression;
		}
		}

		function initializerDeclarationForProperties(generator, properties) {
		generator.printOnNewline(`public init`);
		parametersForProperties(generator, properties);

		generator.withinBlock(function () {
		properties.forEach(function (_ref8) {
		var propertyName = _ref8.propertyName;

		generator.printOnNewline(`self.${propertyName} = ${propertyName}`);
		generator.printOnNewline(`public init`);
		parametersForProperties(generator, properties);
		generator.withinBlock(() => {
		properties.forEach(({ propertyName }) => {
		generator.printOnNewline(`self.${propertyName} = ${propertyName}`);
		});
		});
		});
		}

		exports.initializerDeclarationForProperties = initializerDeclarationForProperties;
		function parametersForProperties(generator, properties) {
		generator.print('(');
		generator.print((0, _printing.join)(properties.map(function (_ref9) {
		var propertyName = _ref9.propertyName,
		type = _ref9.type,
		typeName = _ref9.typeName,
		isOptional = _ref9.isOptional;
		return (0, _printing.join)([`${propertyName}: ${typeName}`, isOptional && ' = nil']);
		}), ', '));
		generator.print(')');
		generator.print('(');
		generator.print(printing_1.join(properties.map(({ propertyName, type, typeName, isOptional }) => printing_1.join([
		`${propertyName}: ${typeName}`,
		isOptional && ' = nil'
		])), ', '));
		generator.print(')');
		}

		function selectionSetInitialization(generator, fields, inlineFragments, parentStructName) {
		generator.print('[');
		generator.withIndent(function () {
		fields.forEach(function (field) {
		var responseName = field.responseName,
		fieldName = field.fieldName,
		args = field.args,
		type = field.type;

		var structName = (0, _printing.join)([parentStructName, (0, _naming.structNameForPropertyName)(responseName)], '.');

		generator.printOnNewline(`Field(`);
		generator.print((0, _printing.join)([`"${fieldName}"`, responseName != fieldName ? `alias: "${responseName}"` : null, args && args.length && `arguments: ${(0, _values.dictionaryLiteralForFieldArguments)(args)}`, `type: ${(0, _types.fieldTypeEnum)(generator.context, type, structName)}`], ', '));
		generator.print('),');
		generator.print('[');
		generator.withIndent(() => {
		fields.forEach(field => {
		const { responseName, fieldName, args, type } = field;
		const structName = printing_1.join([parentStructName, naming_1.structNameForPropertyName(responseName)], '.');
		generator.printOnNewline(`Field(`);
		generator.print(printing_1.join([
		`"${fieldName}"`,
		responseName != fieldName ? `alias: "${responseName}"` : null,
		args && args.length && `arguments: ${values_1.dictionaryLiteralForFieldArguments(args)}`,
		`type: ${types_1.fieldTypeEnum(generator.context, type, structName)}`
		], ', '));
		generator.print('),');
		});
		inlineFragments && inlineFragments.forEach(InlineFragment => {
		const structName = printing_1.join([parentStructName, naming_1.structNameForInlineFragment(InlineFragment)], '.');
		generator.printOnNewline(`FragmentSpread(${structName}.self),`);
		});
		});

		inlineFragments && inlineFragments.forEach(function (InlineFragment) {
		var structName = (0, _printing.join)([parentStructName, (0, _naming.structNameForInlineFragment)(InlineFragment)], '.');
		generator.printOnNewline(`FragmentSpread(${structName}.self),`);
		});
		});
		generator.printOnNewline(']');
		generator.printOnNewline(']');
		}

		exports.selectionSetInitialization = selectionSetInitialization;
		function typeDeclarationForGraphQLType(generator, type) {
		if (type instanceof _graphql.GraphQLEnumType) {
		enumerationDeclaration(generator, type);
		} else if (type instanceof _graphql.GraphQLInputObjectType) {
		structDeclarationForInputObjectType(generator, type);
		}
		if (type instanceof graphql_1.GraphQLEnumType) {
		enumerationDeclaration(generator, type);
		}
		else if (type instanceof graphql_1.GraphQLInputObjectType) {
		structDeclarationForInputObjectType(generator, type);
		}
		}

		exports.typeDeclarationForGraphQLType = typeDeclarationForGraphQLType;
		function enumerationDeclaration(generator, type) {
		var name = type.name,
		description = type.description;

		var values = type.getValues();

		generator.printNewlineIfNeeded();
		generator.printOnNewline(description && `/// ${description}`);
		generator.printOnNewline(`public enum ${name}: String`);
		generator.withinBlock(function () {
		values.forEach(function (value) {
		return generator.printOnNewline(`case ${(0, _language.escapeIdentifierIfNeeded)((0, _naming.enumCaseName)(value.name))} = "${value.value}"${(0, _printing.wrap)(' /// ', value.description)}`);
		const { name, description } = type;
		const values = type.getValues();
		generator.printNewlineIfNeeded();
		generator.printOnNewline(description && `/// ${description}`);
		generator.printOnNewline(`public enum ${name}: String`);
		generator.withinBlock(() => {
		values.forEach(value => generator.printOnNewline(`case ${language_1.escapeIdentifierIfNeeded(naming_1.enumCaseName(value.name))} = "${value.value}"${printing_1.wrap(' /// ', value.description)}`));
		});
		});
		generator.printNewline();
		generator.printOnNewline(`extension ${name}: Apollo.JSONDecodable, Apollo.JSONEncodable {}`);
		generator.printNewline();
		generator.printOnNewline(`extension ${name}: Apollo.JSONDecodable, Apollo.JSONEncodable {}`);
		}

		function structDeclarationForInputObjectType(generator, type) {
		var structName = type.name,
		description = type.description;

		var adoptedProtocols = ['GraphQLMapConvertible'];
		var fields = Object.values(type.getFields());
		var properties = fields.map(function (field) {
		return (0, _naming.propertyFromField)(generator.context, field);
		});

		properties.forEach(function (property) {
		if (property.isOptional) {
		property.typeName = `Optional<${property.typeName}>`;
		}
		});

		(0, _language.structDeclaration)(generator, { structName, description, adoptedProtocols }, function () {
		(0, _language.propertyDeclarations)(generator, properties);

		generator.printNewlineIfNeeded();

		initializerDeclarationForProperties(generator, properties);

		generator.printNewlineIfNeeded();
		generator.printOnNewline(`public var graphQLMap: GraphQLMap`);
		generator.withinBlock(function () {
		generator.printOnNewline((0, _printing.wrap)(`return [`, (0, _printing.join)(properties.map(function (_ref10) {
		var name = _ref10.name,
		propertyName = _ref10.propertyName;
		return `"${name}": ${propertyName}`;
		}), ', ') \|\| ':', `]`));
		const { name: structName, description } = type;
		const adoptedProtocols = ['GraphQLMapConvertible'];
		const fields = Object.values(type.getFields());
		const properties = fields.map(field => naming_1.propertyFromField(generator.context, field));
		properties.forEach(property => {
		if (property.isOptional) {
		property.typeName = `Optional<${property.typeName}>`;
		}
		});
		});
		language_1.structDeclaration(generator, { structName, description, adoptedProtocols }, () => {
		language_1.propertyDeclarations(generator, properties);
		generator.printNewlineIfNeeded();
		initializerDeclarationForProperties(generator, properties);
		generator.printNewlineIfNeeded();
		generator.printOnNewline(`public var graphQLMap: GraphQLMap`);
		generator.withinBlock(() => {
		generator.printOnNewline(printing_1.wrap(`return [`, printing_1.join(properties.map(({ name, propertyName }) => `"${name}": ${propertyName}`), ', ') \|\| ':', `]`));
		});
		});
		}
		//# sourceMappingURL=codeGeneration.js.map

lib/swift/index.js

		@@ -1,15 +0,5 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});

		var _codeGeneration = require('./codeGeneration');

		Object.defineProperty(exports, 'generateSource', {
		enumerable: true,
		get: function get() {
		return _codeGeneration.generateSource;
		}
		});
		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		var codeGeneration_1 = require("./codeGeneration");
		exports.generateSource = codeGeneration_1.generateSource;
		//# sourceMappingURL=index.js.map

181

lib/swift/language.js

		@@ -1,123 +0,94 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.comment = comment;
		exports.namespaceDeclaration = namespaceDeclaration;
		exports.classDeclaration = classDeclaration;
		exports.structDeclaration = structDeclaration;
		exports.propertyDeclaration = propertyDeclaration;
		exports.propertyDeclarations = propertyDeclarations;
		exports.protocolDeclaration = protocolDeclaration;
		exports.protocolPropertyDeclaration = protocolPropertyDeclaration;
		exports.protocolPropertyDeclarations = protocolPropertyDeclarations;
		exports.escapeIdentifierIfNeeded = escapeIdentifierIfNeeded;

		var _printing = require('../utilities/printing');

		function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const printing_1 = require("../utilities/printing");
		function comment(generator, comment) {
		comment && comment.split('\n').forEach(function (line) {
		generator.printOnNewline(`/// ${line.trim()}`);
		});
		comment && comment.split('\n')
		.forEach(line => {
		generator.printOnNewline(`/// ${line.trim()}`);
		});
		}

		exports.comment = comment;
		function namespaceDeclaration(generator, namespace, closure) {
		if (namespace) {
		if (namespace) {
		generator.printNewlineIfNeeded();
		generator.printOnNewline(`/// ${namespace} namespace`);
		generator.printOnNewline(`public enum ${namespace}`);
		generator.pushScope({ typeName: namespace });
		generator.withinBlock(closure);
		generator.popScope();
		}
		else {
		closure();
		}
		}
		exports.namespaceDeclaration = namespaceDeclaration;
		function classDeclaration(generator, { className, modifiers, superClass, adoptedProtocols = [], properties }, closure) {
		generator.printNewlineIfNeeded();
		generator.printOnNewline(`/// ${namespace} namespace`);
		generator.printOnNewline(`public enum ${namespace}`);
		generator.pushScope({ typeName: namespace });
		generator.printOnNewline(printing_1.wrap('', printing_1.join(modifiers, ' '), ' ') + `class ${className}`);
		generator.print(printing_1.wrap(': ', printing_1.join([superClass, ...adoptedProtocols], ', ')));
		generator.pushScope({ typeName: className });
		generator.withinBlock(closure);
		generator.popScope();
		} else {
		closure();
		}
		}

		function classDeclaration(generator, _ref, closure) {
		var className = _ref.className,
		modifiers = _ref.modifiers,
		superClass = _ref.superClass,
		_ref$adoptedProtocols = _ref.adoptedProtocols,
		adoptedProtocols = _ref$adoptedProtocols === undefined ? [] : _ref$adoptedProtocols,
		properties = _ref.properties;

		generator.printNewlineIfNeeded();
		generator.printOnNewline((0, _printing.wrap)('', (0, _printing.join)(modifiers, ' '), ' ') + `class ${className}`);
		generator.print((0, _printing.wrap)(': ', (0, _printing.join)([superClass].concat(_toConsumableArray(adoptedProtocols)), ', ')));
		generator.pushScope({ typeName: className });
		generator.withinBlock(closure);
		generator.popScope();
		exports.classDeclaration = classDeclaration;
		function structDeclaration(generator, { structName, description, adoptedProtocols = [] }, closure) {
		generator.printNewlineIfNeeded();
		comment(generator, description);
		generator.printOnNewline(`public struct ${structName}`);
		generator.print(printing_1.wrap(': ', printing_1.join(adoptedProtocols, ', ')));
		generator.pushScope({ typeName: structName });
		generator.withinBlock(closure);
		generator.popScope();
		}

		function structDeclaration(generator, _ref2, closure) {
		var structName = _ref2.structName,
		description = _ref2.description,
		_ref2$adoptedProtocol = _ref2.adoptedProtocols,
		adoptedProtocols = _ref2$adoptedProtocol === undefined ? [] : _ref2$adoptedProtocol;

		generator.printNewlineIfNeeded();
		comment(generator, description);
		generator.printOnNewline(`public struct ${structName}`);
		generator.print((0, _printing.wrap)(': ', (0, _printing.join)(adoptedProtocols, ', ')));
		generator.pushScope({ typeName: structName });
		generator.withinBlock(closure);
		generator.popScope();
		exports.structDeclaration = structDeclaration;
		function propertyDeclaration(generator, { propertyName, typeName, description }) {
		comment(generator, description);
		generator.printOnNewline(`public var ${propertyName}: ${typeName}`);
		}

		function propertyDeclaration(generator, _ref3) {
		var propertyName = _ref3.propertyName,
		typeName = _ref3.typeName,
		description = _ref3.description;

		comment(generator, description);
		generator.printOnNewline(`public var ${propertyName}: ${typeName}`);
		}

		exports.propertyDeclaration = propertyDeclaration;
		function propertyDeclarations(generator, properties) {
		if (!properties) return;
		properties.forEach(function (property) {
		return propertyDeclaration(generator, property);
		});
		if (!properties)
		return;
		properties.forEach(property => propertyDeclaration(generator, property));
		}

		function protocolDeclaration(generator, _ref4, closure) {
		var protocolName = _ref4.protocolName,
		adoptedProtocols = _ref4.adoptedProtocols,
		properties = _ref4.properties;

		generator.printNewlineIfNeeded();
		generator.printOnNewline(`public protocol ${protocolName}`);
		generator.print((0, _printing.wrap)(': ', (0, _printing.join)(adoptedProtocols, ', ')));
		generator.pushScope({ typeName: protocolName });
		generator.withinBlock(closure);
		generator.popScope();
		exports.propertyDeclarations = propertyDeclarations;
		function protocolDeclaration(generator, { protocolName, adoptedProtocols, properties }, closure) {
		generator.printNewlineIfNeeded();
		generator.printOnNewline(`public protocol ${protocolName}`);
		generator.print(printing_1.wrap(': ', printing_1.join(adoptedProtocols, ', ')));
		generator.pushScope({ typeName: protocolName });
		generator.withinBlock(closure);
		generator.popScope();
		}

		function protocolPropertyDeclaration(generator, _ref5) {
		var propertyName = _ref5.propertyName,
		typeName = _ref5.typeName;

		generator.printOnNewline(`var ${propertyName}: ${typeName} { get }`);
		exports.protocolDeclaration = protocolDeclaration;
		function protocolPropertyDeclaration(generator, { propertyName, typeName }) {
		generator.printOnNewline(`var ${propertyName}: ${typeName} { get }`);
		}

		exports.protocolPropertyDeclaration = protocolPropertyDeclaration;
		function protocolPropertyDeclarations(generator, properties) {
		if (!properties) return;
		properties.forEach(function (property) {
		return protocolPropertyDeclaration(generator, property);
		});
		if (!properties)
		return;
		properties.forEach(property => protocolPropertyDeclaration(generator, property));
		}

		var reservedKeywords = new Set(['associatedtype', 'class', 'deinit', 'enum', 'extension', 'fileprivate', 'func', 'import', 'init', 'inout', 'internal', 'let', 'open', 'operator', 'private', 'protocol', 'public', 'static', 'struct', 'subscript', 'typealias', 'var', 'break', 'case', 'continue', 'default', 'defer', 'do', 'else', 'fallthrough', 'for', 'guard', 'if', 'in', 'repeat', 'return', 'switch', 'where', 'while', 'as', 'Any', 'catch', 'false', 'is', 'nil', 'rethrows', 'super', 'self', 'Self', 'throw', 'throws', 'true', 'try', 'associativity', 'convenience', 'dynamic', 'didSet', 'final', 'get', 'infix', 'indirect', 'lazy', 'left', 'mutating', 'none', 'nonmutating', 'optional', 'override', 'postfix', 'precedence', 'prefix', 'Protocol', 'required', 'right', 'set', 'Type', 'unowned', 'weak', 'willSet']);

		exports.protocolPropertyDeclarations = protocolPropertyDeclarations;
		const reservedKeywords = new Set(['associatedtype', 'class', 'deinit', 'enum', 'extension',
		'fileprivate', 'func', 'import', 'init', 'inout', 'internal', 'let', 'open',
		'operator', 'private', 'protocol', 'public', 'static', 'struct', 'subscript',
		'typealias', 'var', 'break', 'case', 'continue', 'default', 'defer', 'do',
		'else', 'fallthrough', 'for', 'guard', 'if', 'in', 'repeat', 'return',
		'switch', 'where', 'while', 'as', 'Any', 'catch', 'false', 'is', 'nil',
		'rethrows', 'super', 'self', 'Self', 'throw', 'throws', 'true', 'try',
		'associativity', 'convenience', 'dynamic', 'didSet', 'final', 'get', 'infix',
		'indirect', 'lazy', 'left', 'mutating', 'none', 'nonmutating', 'optional',
		'override', 'postfix', 'precedence', 'prefix', 'Protocol', 'required', 'right',
		'set', 'Type', 'unowned', 'weak', 'willSet']);
		function escapeIdentifierIfNeeded(identifier) {
		if (reservedKeywords.has(identifier)) {
		return '`' + identifier + '`';
		} else {
		return identifier;
		}
		if (reservedKeywords.has(identifier)) {
		return '`' + identifier + '`';
		}
		else {
		return identifier;
		}
		}
		exports.escapeIdentifierIfNeeded = escapeIdentifierIfNeeded;
		//# sourceMappingURL=language.js.map

126

lib/swift/naming.js

		@@ -1,92 +0,72 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.enumCaseName = enumCaseName;
		exports.operationClassName = operationClassName;
		exports.structNameForPropertyName = structNameForPropertyName;
		exports.structNameForFragmentName = structNameForFragmentName;
		exports.structNameForInlineFragment = structNameForInlineFragment;
		exports.propertyFromField = propertyFromField;
		exports.propertyFromInlineFragment = propertyFromInlineFragment;
		exports.propertyFromFragmentSpread = propertyFromFragmentSpread;

		var _changeCase = require('change-case');

		var _inflected = require('inflected');

		var _inflected2 = _interopRequireDefault(_inflected);

		var _printing = require('../utilities/printing');

		var _language = require('./language');

		var _types = require('./types');

		var _graphql = require('graphql');

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const change_case_1 = require("change-case");
		const Inflector = require("inflected");
		const printing_1 = require("../utilities/printing");
		const language_1 = require("./language");
		const types_1 = require("./types");
		const graphql_1 = require("graphql");
		function enumCaseName(name) {
		return (0, _changeCase.camelCase)(name);
		return change_case_1.camelCase(name);
		}

		exports.enumCaseName = enumCaseName;
		function operationClassName(name) {
		return (0, _changeCase.pascalCase)(name);
		return change_case_1.pascalCase(name);
		}

		exports.operationClassName = operationClassName;
		function structNameForPropertyName(propertyName) {
		return (0, _changeCase.pascalCase)(_inflected2.default.singularize(propertyName));
		return change_case_1.pascalCase(Inflector.singularize(propertyName));
		}

		exports.structNameForPropertyName = structNameForPropertyName;
		function structNameForFragmentName(fragmentName) {
		return (0, _changeCase.pascalCase)(fragmentName);
		return change_case_1.pascalCase(fragmentName);
		}

		exports.structNameForFragmentName = structNameForFragmentName;
		function structNameForInlineFragment(inlineFragment) {
		return 'As' + (0, _changeCase.pascalCase)(String(inlineFragment.typeCondition));
		return 'As' + change_case_1.pascalCase(String(inlineFragment.typeCondition));
		}

		exports.structNameForInlineFragment = structNameForInlineFragment;
		function propertyFromField(context, field, namespace) {
		var name = field.name \|\| field.responseName;
		var unescapedPropertyName = isMetaFieldName(name) ? name : (0, _changeCase.camelCase)(name);
		var propertyName = (0, _language.escapeIdentifierIfNeeded)(unescapedPropertyName);

		var type = field.type;
		var isList = type instanceof _graphql.GraphQLList \|\| type.ofType instanceof _graphql.GraphQLList;
		var isOptional = field.isConditional \|\| !(type instanceof _graphql.GraphQLNonNull);
		var bareType = (0, _graphql.getNamedType)(type);

		if ((0, _graphql.isCompositeType)(bareType)) {
		var bareTypeName = (0, _printing.join)([namespace, (0, _language.escapeIdentifierIfNeeded)((0, _changeCase.pascalCase)(_inflected2.default.singularize(name)))], '.');
		var typeName = (0, _types.typeNameFromGraphQLType)(context, type, bareTypeName, isOptional);
		return Object.assign({}, field, { propertyName, typeName, bareTypeName, isOptional, isList, isComposite: true });
		} else {
		var _typeName = (0, _types.typeNameFromGraphQLType)(context, type, undefined, isOptional);
		return Object.assign({}, field, { propertyName, typeName: _typeName, isOptional, isList, isComposite: false });
		}
		const name = field.name \|\| field.responseName;
		const unescapedPropertyName = isMetaFieldName(name) ? name : change_case_1.camelCase(name);
		const propertyName = language_1.escapeIdentifierIfNeeded(unescapedPropertyName);
		const type = field.type;
		const isList = type instanceof graphql_1.GraphQLList \|\| type.ofType instanceof graphql_1.GraphQLList;
		const isOptional = field.isConditional \|\| !(type instanceof graphql_1.GraphQLNonNull);
		const bareType = graphql_1.getNamedType(type);
		if (graphql_1.isCompositeType(bareType)) {
		const bareTypeName = printing_1.join([
		namespace,
		language_1.escapeIdentifierIfNeeded(change_case_1.pascalCase(Inflector.singularize(name)))
		], '.');
		const typeName = types_1.typeNameFromGraphQLType(context, type, bareTypeName, isOptional);
		return Object.assign({}, field, { propertyName, typeName, bareTypeName, isOptional, isList, isComposite: true });
		}
		else {
		const typeName = types_1.typeNameFromGraphQLType(context, type, undefined, isOptional);
		return Object.assign({}, field, { propertyName, typeName, isOptional, isList, isComposite: false });
		}
		}

		exports.propertyFromField = propertyFromField;
		function propertyFromInlineFragment(context, inlineFragment) {
		var structName = structNameForInlineFragment(inlineFragment);
		var propertyName = (0, _changeCase.camelCase)(structName);
		var typeName = structName + '?';
		return Object.assign({ propertyName, typeName, structName, isComposite: true }, inlineFragment);
		const structName = structNameForInlineFragment(inlineFragment);
		const propertyName = change_case_1.camelCase(structName);
		const typeName = structName + '?';
		return Object.assign({ propertyName, typeName, structName, isComposite: true }, inlineFragment);
		}

		exports.propertyFromInlineFragment = propertyFromInlineFragment;
		function propertyFromFragmentSpread(context, fragmentSpread) {
		var fragmentName = fragmentSpread;
		var fragment = context.fragments[fragmentName];
		if (!fragment) {
		throw new _graphql.GraphQLError(`Cannot find fragment "${fragmentName}"`);
		}
		var propertyName = (0, _changeCase.camelCase)(fragmentName);
		var typeName = structNameForFragmentName(fragmentName);
		return { propertyName, typeName, fragment, isComposite: true };
		const fragmentName = fragmentSpread;
		const fragment = context.fragments[fragmentName];
		if (!fragment) {
		throw new graphql_1.GraphQLError(`Cannot find fragment "${fragmentName}"`);
		}
		const propertyName = change_case_1.camelCase(fragmentName);
		const typeName = structNameForFragmentName(fragmentName);
		return { propertyName, typeName, fragment, isComposite: true };
		}

		exports.propertyFromFragmentSpread = propertyFromFragmentSpread;
		function isMetaFieldName(name) {
		return name.startsWith("__");
		return name.startsWith("__");
		}
		//# sourceMappingURL=naming.js.map

109

lib/swift/types.js

		@@ -1,68 +0,61 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.possibleTypesForType = possibleTypesForType;
		exports.typeNameFromGraphQLType = typeNameFromGraphQLType;
		exports.fieldTypeEnum = fieldTypeEnum;

		var _printing = require('../utilities/printing');

		var _changeCase = require('change-case');

		var _graphql = require('graphql');

		var builtInScalarMap = {
		[_graphql.GraphQLString.name]: 'String',
		[_graphql.GraphQLInt.name]: 'Int',
		[_graphql.GraphQLFloat.name]: 'Double',
		[_graphql.GraphQLBoolean.name]: 'Bool',
		[_graphql.GraphQLID.name]: 'GraphQLID'
		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const graphql_1 = require("graphql");
		const builtInScalarMap = {
		[graphql_1.GraphQLString.name]: 'String',
		[graphql_1.GraphQLInt.name]: 'Int',
		[graphql_1.GraphQLFloat.name]: 'Double',
		[graphql_1.GraphQLBoolean.name]: 'Bool',
		[graphql_1.GraphQLID.name]: 'GraphQLID',
		};

		function possibleTypesForType(context, type) {
		if ((0, _graphql.isAbstractType)(type)) {
		return context.schema.getPossibleTypes(type);
		} else {
		return [type];
		}
		if (graphql_1.isAbstractType(type)) {
		return context.schema.getPossibleTypes(type);
		}
		else {
		return [type];
		}
		}

		exports.possibleTypesForType = possibleTypesForType;
		function typeNameFromGraphQLType(context, type, bareTypeName, isOptional) {
		if (type instanceof _graphql.GraphQLNonNull) {
		return typeNameFromGraphQLType(context, type.ofType, bareTypeName, isOptional \|\| false);
		} else if (isOptional === undefined) {
		isOptional = true;
		}

		var typeName = void 0;
		if (type instanceof _graphql.GraphQLList) {
		typeName = '[' + typeNameFromGraphQLType(context, type.ofType, bareTypeName) + ']';
		} else if (type instanceof _graphql.GraphQLScalarType) {
		typeName = typeNameForScalarType(context, type);
		} else {
		typeName = bareTypeName \|\| type.name;
		}

		return isOptional ? typeName + '?' : typeName;
		if (type instanceof graphql_1.GraphQLNonNull) {
		return typeNameFromGraphQLType(context, type.ofType, bareTypeName, isOptional \|\| false);
		}
		else if (isOptional === undefined) {
		isOptional = true;
		}
		let typeName;
		if (type instanceof graphql_1.GraphQLList) {
		typeName = '[' + typeNameFromGraphQLType(context, type.ofType, bareTypeName) + ']';
		}
		else if (type instanceof graphql_1.GraphQLScalarType) {
		typeName = typeNameForScalarType(context, type);
		}
		else {
		typeName = bareTypeName \|\| type.name;
		}
		return isOptional ? typeName + '?' : typeName;
		}

		exports.typeNameFromGraphQLType = typeNameFromGraphQLType;
		function typeNameForScalarType(context, type) {
		return builtInScalarMap[type.name] \|\| (context.passthroughCustomScalars ? context.customScalarsPrefix + type.name : _graphql.GraphQLString);
		return builtInScalarMap[type.name] \|\| (context.passthroughCustomScalars ? context.customScalarsPrefix + type.name : graphql_1.GraphQLString);
		}

		function fieldTypeEnum(context, type, structName) {
		if (type instanceof _graphql.GraphQLNonNull) {
		return `.nonNull(${fieldTypeEnum(context, type.ofType, structName)})`;
		} else if (type instanceof _graphql.GraphQLList) {
		return `.list(${fieldTypeEnum(context, type.ofType, structName)})`;
		} else if (type instanceof _graphql.GraphQLScalarType) {
		return `.scalar(${typeNameForScalarType(context, type)}.self)`;
		} else if (type instanceof _graphql.GraphQLEnumType) {
		return `.scalar(${type.name}.self)`;
		} else if ((0, _graphql.isCompositeType)(type)) {
		return `.object(${structName}.self)`;
		}
		if (type instanceof graphql_1.GraphQLNonNull) {
		return `.nonNull(${fieldTypeEnum(context, type.ofType, structName)})`;
		}
		else if (type instanceof graphql_1.GraphQLList) {
		return `.list(${fieldTypeEnum(context, type.ofType, structName)})`;
		}
		else if (type instanceof graphql_1.GraphQLScalarType) {
		return `.scalar(${typeNameForScalarType(context, type)}.self)`;
		}
		else if (type instanceof graphql_1.GraphQLEnumType) {
		return `.scalar(${type.name}.self)`;
		}
		else if (graphql_1.isCompositeType(type)) {
		return `.object(${structName}.self)`;
		}
		}
		exports.fieldTypeEnum = fieldTypeEnum;
		//# sourceMappingURL=types.js.map

lib/swift/values.js

		@@ -1,50 +0,38 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});

		var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

		exports.escapedString = escapedString;
		exports.multilineString = multilineString;
		exports.dictionaryLiteralForFieldArguments = dictionaryLiteralForFieldArguments;

		var _printing = require('../utilities/printing');

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const printing_1 = require("../utilities/printing");
		function escapedString(string) {
		return string.replace(/"/g, '\\"');
		return string.replace(/"/g, '\\"');
		}

		exports.escapedString = escapedString;
		function multilineString(context, string) {
		var lines = string.split('\n');
		lines.forEach(function (line, index) {
		var isLastLine = index != lines.length - 1;
		context.printOnNewline(`"${escapedString(line)}"` + (isLastLine ? ' +' : ''));
		});
		const lines = string.split('\n');
		lines.forEach((line, index) => {
		const isLastLine = index != lines.length - 1;
		context.printOnNewline(`"${escapedString(line)}"` + (isLastLine ? ' +' : ''));
		});
		}

		exports.multilineString = multilineString;
		function dictionaryLiteralForFieldArguments(args) {
		function expressionFromValue(value) {
		if (value.kind === 'Variable') {
		return `Variable("${value.variableName}")`;
		} else if (Array.isArray(value)) {
		return (0, _printing.wrap)('[', (0, _printing.join)(value.map(expressionFromValue), ', '), ']');
		} else if (typeof value === 'object') {
		return (0, _printing.wrap)('[', (0, _printing.join)(Object.entries(value).map(function (_ref) {
		var _ref2 = _slicedToArray(_ref, 2),
		key = _ref2[0],
		value = _ref2[1];

		return `"${key}": ${expressionFromValue(value)}`;
		}), ', ') \|\| ':', ']');
		} else {
		return JSON.stringify(value);
		function expressionFromValue(value) {
		if (value.kind === 'Variable') {
		return `Variable("${value.variableName}")`;
		}
		else if (Array.isArray(value)) {
		return printing_1.wrap('[', printing_1.join(value.map(expressionFromValue), ', '), ']');
		}
		else if (typeof value === 'object') {
		return printing_1.wrap('[', printing_1.join(Object.entries(value).map(([key, value]) => {
		return `"${key}": ${expressionFromValue(value)}`;
		}), ', ') \|\| ':', ']');
		}
		else {
		return JSON.stringify(value);
		}
		}
		}

		return (0, _printing.wrap)('[', (0, _printing.join)(args.map(function (arg) {
		return `"${arg.name}": ${expressionFromValue(arg.value)}`;
		}), ', ') \|\| ':', ']');
		return printing_1.wrap('[', printing_1.join(args.map(arg => {
		return `"${arg.name}": ${expressionFromValue(arg.value)}`;
		}), ', ') \|\| ':', ']');
		}
		exports.dictionaryLiteralForFieldArguments = dictionaryLiteralForFieldArguments;
		//# sourceMappingURL=values.js.map

578

lib/typescript/codeGeneration.js

		@@ -1,387 +0,257 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.generateSource = generateSource;
		exports.typeDeclarationForGraphQLType = typeDeclarationForGraphQLType;
		exports.interfaceVariablesDeclarationForOperation = interfaceVariablesDeclarationForOperation;
		exports.interfaceDeclarationForOperation = interfaceDeclarationForOperation;
		exports.interfaceDeclarationForFragment = interfaceDeclarationForFragment;
		exports.propertiesFromFields = propertiesFromFields;
		exports.propertyFromField = propertyFromField;
		exports.propertyDeclarations = propertyDeclarations;

		var _graphql = require('graphql');

		var _graphql2 = require('../utilities/graphql');

		var _changeCase = require('change-case');

		var _inflected = require('inflected');

		var _inflected2 = _interopRequireDefault(_inflected);

		var _printing = require('../utilities/printing');

		var _CodeGenerator = require('../utilities/CodeGenerator');

		var _CodeGenerator2 = _interopRequireDefault(_CodeGenerator);

		var _language = require('./language');

		var _types = require('./types');

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const graphql_1 = require("graphql");
		const change_case_1 = require("change-case");
		const Inflector = require("inflected");
		const printing_1 = require("../utilities/printing");
		const CodeGenerator_1 = require("../utilities/CodeGenerator");
		const language_1 = require("./language");
		const types_1 = require("./types");
		function generateSource(context, options) {
		var generator = new _CodeGenerator2.default(context);

		generator.printOnNewline('/* tslint:disable */');
		generator.printOnNewline('// This file was automatically generated and should not be edited.');

		typeDeclarationForGraphQLType(context.typesUsed.forEach(function (type) {
		return typeDeclarationForGraphQLType(generator, type);
		}));

		// When an object has fragment spreads or inline fragments
		// and __typename is requested at the top level, __typename
		// needs to be added as a property of the fragments
		var fragmentsWithTypenameField = {};
		Object.values(context.operations).forEach(function (operation) {
		interfaceVariablesDeclarationForOperation(generator, operation);
		interfaceDeclarationForOperation(generator, operation, fragmentsWithTypenameField);
		});
		Object.values(context.fragments).forEach(function (operation) {
		return interfaceDeclarationForFragment(generator, operation, fragmentsWithTypenameField);
		});

		generator.printOnNewline('/* tslint:enable */');
		generator.printNewline();

		return generator.output;
		const generator = new CodeGenerator_1.default(context);
		generator.printOnNewline('/* tslint:disable */');
		generator.printOnNewline('// This file was automatically generated and should not be edited.');
		typeDeclarationForGraphQLType(context.typesUsed.forEach(type => typeDeclarationForGraphQLType(generator, type)));
		const fragmentsWithTypenameField = {};
		Object.values(context.operations).forEach(operation => {
		interfaceVariablesDeclarationForOperation(generator, operation);
		interfaceDeclarationForOperation(generator, operation, fragmentsWithTypenameField);
		});
		Object.values(context.fragments).forEach(operation => interfaceDeclarationForFragment(generator, operation, fragmentsWithTypenameField));
		generator.printOnNewline('/* tslint:enable */');
		generator.printNewline();
		return generator.output;
		}

		exports.generateSource = generateSource;
		function typeDeclarationForGraphQLType(generator, type) {
		if (type instanceof _graphql.GraphQLEnumType) {
		enumerationDeclaration(generator, type);
		} else if (type instanceof _graphql.GraphQLInputObjectType) {
		structDeclarationForInputObjectType(generator, type);
		}
		if (type instanceof graphql_1.GraphQLEnumType) {
		enumerationDeclaration(generator, type);
		}
		else if (type instanceof graphql_1.GraphQLInputObjectType) {
		structDeclarationForInputObjectType(generator, type);
		}
		}

		exports.typeDeclarationForGraphQLType = typeDeclarationForGraphQLType;
		function enumerationDeclaration(generator, type) {
		var name = type.name,
		description = type.description;

		var values = type.getValues();

		generator.printNewlineIfNeeded();
		generator.printOnNewline(description && `// ${description}`);
		generator.printOnNewline(`export type ${name} =`);
		var nValues = values.length;
		values.forEach(function (value, i) {
		return generator.printOnNewline(` "${value.value}"${i === nValues - 1 ? ';' : ' \|'}${(0, _printing.wrap)(' // ', value.description)}`);
		});
		generator.printNewline();
		const { name, description } = type;
		const values = type.getValues();
		generator.printNewlineIfNeeded();
		generator.printOnNewline(description && `// ${description}`);
		generator.printOnNewline(`export type ${name} =`);
		const nValues = values.length;
		values.forEach((value, i) => generator.printOnNewline(` "${value.value}"${i === nValues - 1 ? ';' : ' \|'}${printing_1.wrap(' // ', value.description)}`));
		generator.printNewline();
		}

		function structDeclarationForInputObjectType(generator, type) {
		var interfaceName = (0, _changeCase.pascalCase)(type.name);
		(0, _language.interfaceDeclaration)(generator, {
		interfaceName
		}, function () {
		var properties = propertiesFromFields(generator.context, Object.values(type.getFields()));
		propertyDeclarations(generator, properties, true);
		});
		const interfaceName = change_case_1.pascalCase(type.name);
		language_1.interfaceDeclaration(generator, {
		interfaceName,
		}, () => {
		const properties = propertiesFromFields(generator.context, Object.values(type.getFields()));
		propertyDeclarations(generator, properties, true);
		});
		}

		function interfaceNameFromOperation(_ref) {
		var operationName = _ref.operationName,
		operationType = _ref.operationType;

		switch (operationType) {
		case 'query':
		return `${(0, _changeCase.pascalCase)(operationName)}Query`;
		break;
		case 'mutation':
		return `${(0, _changeCase.pascalCase)(operationName)}Mutation`;
		break;
		case 'subscription':
		return `${(0, _changeCase.pascalCase)(operationName)}Subscription`;
		break;
		default:
		throw new _graphql.GraphQLError(`Unsupported operation type "${operationType}"`);
		}
		function interfaceNameFromOperation({ operationName, operationType }) {
		switch (operationType) {
		case 'query':
		return `${change_case_1.pascalCase(operationName)}Query`;
		break;
		case 'mutation':
		return `${change_case_1.pascalCase(operationName)}Mutation`;
		break;
		case 'subscription':
		return `${change_case_1.pascalCase(operationName)}Subscription`;
		break;
		default:
		throw new graphql_1.GraphQLError(`Unsupported operation type "${operationType}"`);
		}
		}

		function interfaceVariablesDeclarationForOperation(generator, _ref2) {
		var operationName = _ref2.operationName,
		operationType = _ref2.operationType,
		variables = _ref2.variables,
		fields = _ref2.fields,
		fragmentsReferenced = _ref2.fragmentsReferenced,
		source = _ref2.source;

		if (!variables \|\| variables.length < 1) {
		return null;
		}
		var interfaceName = `${interfaceNameFromOperation({ operationName, operationType })}Variables`;

		(0, _language.interfaceDeclaration)(generator, {
		interfaceName
		}, function () {
		var properties = propertiesFromFields(generator.context, variables);
		propertyDeclarations(generator, properties, true);
		});
		function interfaceVariablesDeclarationForOperation(generator, { operationName, operationType, variables, fields, fragmentsReferenced, source, }) {
		if (!variables \|\| variables.length < 1) {
		return null;
		}
		const interfaceName = `${interfaceNameFromOperation({ operationName, operationType })}Variables`;
		language_1.interfaceDeclaration(generator, {
		interfaceName,
		}, () => {
		const properties = propertiesFromFields(generator.context, variables);
		propertyDeclarations(generator, properties, true);
		});
		}

		function interfaceDeclarationForOperation(generator, _ref3, fragmentsWithTypenameField) {
		var operationName = _ref3.operationName,
		operationType = _ref3.operationType,
		variables = _ref3.variables,
		fields = _ref3.fields,
		fragmentSpreads = _ref3.fragmentSpreads,
		fragmentsReferenced = _ref3.fragmentsReferenced,
		source = _ref3.source;

		if (hasTypenameField(fields)) {
		console.error('__typename on operations are not yet supported');
		}

		var interfaceName = interfaceNameFromOperation({ operationName, operationType });
		var properties = propertiesFromFields(generator.context, fields, {
		typeNameSuffix: `From${operationName}`
		});

		(0, _language.interfaceDeclaration)(generator, {
		interfaceName,
		extendTypes: fragmentSpreads ? fragmentSpreads.map(function (f) {
		return `${(0, _changeCase.pascalCase)(f)}Fragment`;
		}) : null
		}, function () {
		propertyDeclarations(generator, properties, true);
		});

		properties.forEach(function (_ref4) {
		var fragmentSpreads = _ref4.fragmentSpreads,
		inlineFragments = _ref4.inlineFragments,
		bareTypeName = _ref4.bareTypeName;

		if (fragmentSpreads.length > 0) {
		fragmentSpreads.forEach(function (fragmentSpread) {
		fragmentsWithTypenameField[fragmentSpread] = true;
		});
		exports.interfaceVariablesDeclarationForOperation = interfaceVariablesDeclarationForOperation;
		function interfaceDeclarationForOperation(generator, { operationName, operationType, variables, fields, fragmentSpreads, fragmentsReferenced, source, }, fragmentsWithTypenameField) {
		if (hasTypenameField(fields)) {
		console.error('__typename on operations are not yet supported');
		}

		const interfaceName = interfaceNameFromOperation({ operationName, operationType });
		const properties = propertiesFromFields(generator.context, fields, {
		typeNameSuffix: `From${operationName}`
		});
		language_1.interfaceDeclaration(generator, {
		interfaceName,
		extendTypes: fragmentSpreads ? fragmentSpreads.map(f => `${change_case_1.pascalCase(f)}Fragment`) : null,
		}, () => {
		propertyDeclarations(generator, properties, true);
		});
		properties.forEach(({ fragmentSpreads, inlineFragments, bareTypeName }) => {
		if (fragmentSpreads && fragmentSpreads.length > 0) {
		fragmentSpreads.forEach(fragmentSpread => {
		fragmentsWithTypenameField[fragmentSpread] = true;
		});
		}
		if (inlineFragments && inlineFragments.length > 0) {
		const objectName = `${change_case_1.pascalCase(bareTypeName)}From${operationName}`;
		handleInlineFragments(generator, objectName, inlineFragments);
		}
		});
		}
		exports.interfaceDeclarationForOperation = interfaceDeclarationForOperation;
		function interfaceDeclarationForFragment(generator, { fragmentName, typeCondition, fields, inlineFragments, fragmentSpreads, source, possibleTypes }, fragmentsWithTypenameField) {
		const interfaceName = `${change_case_1.pascalCase(fragmentName)}Fragment`;
		if (inlineFragments.length > 0) {
		var objectName = `${(0, _changeCase.pascalCase)(bareTypeName)}From${operationName}`;
		handleInlineFragments(generator, objectName, inlineFragments);
		handleInlineFragments(generator, interfaceName, inlineFragments);
		}
		});
		else {
		language_1.interfaceDeclaration(generator, {
		interfaceName,
		extendTypes: fragmentSpreads ? fragmentSpreads.map(f => `${change_case_1.pascalCase(f)}Fragment`) : null,
		}, () => {
		if (fragmentsWithTypenameField[fragmentName]) {
		addTypenameFieldIfNeeded(generator, fields, typeCondition);
		}
		const properties = propertiesFromFields(generator.context, fields, {
		typeNameSuffix: 'Fragment'
		});
		propertyDeclarations(generator, properties, true);
		});
		}
		}

		function interfaceDeclarationForFragment(generator, _ref5, fragmentsWithTypenameField) {
		var fragmentName = _ref5.fragmentName,
		typeCondition = _ref5.typeCondition,
		fields = _ref5.fields,
		inlineFragments = _ref5.inlineFragments,
		fragmentSpreads = _ref5.fragmentSpreads,
		source = _ref5.source,
		possibleTypes = _ref5.possibleTypes;

		var interfaceName = `${(0, _changeCase.pascalCase)(fragmentName)}Fragment`;

		if (inlineFragments.length > 0) {
		handleInlineFragments(generator, interfaceName, inlineFragments);
		} else {
		(0, _language.interfaceDeclaration)(generator, {
		interfaceName,
		extendTypes: fragmentSpreads ? fragmentSpreads.map(function (f) {
		return `${(0, _changeCase.pascalCase)(f)}Fragment`;
		}) : null
		}, function () {
		if (fragmentsWithTypenameField[fragmentName]) {
		addTypenameFieldIfNeeded(generator, fields, typeCondition);
		}

		var properties = propertiesFromFields(generator.context, fields, {
		typeNameSuffix: 'Fragment'
		});

		propertyDeclarations(generator, properties, true);
		});
		}
		exports.interfaceDeclarationForFragment = interfaceDeclarationForFragment;
		function propertiesFromFields(context, fields, { forceNullable, typeNameSuffix } = {}) {
		return fields.map(field => propertyFromField(context, field, { forceNullable, typeNameSuffix }));
		}

		function propertiesFromFields(context, fields) {
		var _ref6 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
		forceNullable = _ref6.forceNullable,
		typeNameSuffix = _ref6.typeNameSuffix;

		return fields.map(function (field) {
		return propertyFromField(context, field, { forceNullable, typeNameSuffix });
		});
		}

		function propertyFromField(context, field) {
		var _ref7 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
		forceNullable = _ref7.forceNullable,
		typeNameSuffix = _ref7.typeNameSuffix;

		var fieldName = field.name,
		fieldType = field.type,
		description = field.description,
		fragmentSpreads = field.fragmentSpreads,
		inlineFragments = field.inlineFragments;

		fieldName = fieldName \|\| field.responseName;

		var propertyName = fieldName;

		var property = { fieldName, fieldType, propertyName, description, inlineFragments };

		var namedType = (0, _graphql.getNamedType)(fieldType);

		if ((0, _graphql.isCompositeType)(namedType)) {
		var typeName = void 0,
		bareTypeName = void 0;
		if (propertyName === '__typename') {
		// Handle the __typename field specially. the fieldType is set
		// to the parentType but we want the flow type to be a string literal
		// of the parentType.
		bareTypeName = `"${fieldType}"`;
		typeName = `"${fieldType}"`;
		} else {
		bareTypeName = (0, _changeCase.pascalCase)(_inflected2.default.singularize(propertyName));
		if (property.inlineFragments && property.inlineFragments.length > 0) {
		typeName = (0, _types.typeNameFromGraphQLType)(context, fieldType, `${(0, _changeCase.pascalCase)(bareTypeName)}${typeNameSuffix}`);
		} else {
		typeName = (0, _types.typeNameFromGraphQLType)(context, fieldType, bareTypeName);
		}
		exports.propertiesFromFields = propertiesFromFields;
		function propertyFromField(context, field, { forceNullable, typeNameSuffix } = {}) {
		let { name: fieldName, type: fieldType, description, fragmentSpreads, inlineFragments } = field;
		fieldName = fieldName \|\| field.responseName;
		const propertyName = fieldName;
		let property = { fieldName, fieldType, propertyName, description, inlineFragments };
		const namedType = graphql_1.getNamedType(fieldType);
		if (graphql_1.isCompositeType(namedType)) {
		let typeName, bareTypeName;
		if (propertyName === '__typename') {
		bareTypeName = `"${fieldType}"`;
		typeName = `"${fieldType}"`;
		}
		else {
		bareTypeName = change_case_1.pascalCase(Inflector.singularize(propertyName));
		if (property.inlineFragments && property.inlineFragments.length > 0) {
		typeName = types_1.typeNameFromGraphQLType(context, fieldType, `${change_case_1.pascalCase(bareTypeName)}${typeNameSuffix}`);
		}
		else {
		typeName = types_1.typeNameFromGraphQLType(context, fieldType, bareTypeName);
		}
		}
		let isArray = false;
		if (fieldType instanceof graphql_1.GraphQLList) {
		isArray = true;
		}
		else if (fieldType instanceof graphql_1.GraphQLNonNull && fieldType.ofType instanceof graphql_1.GraphQLList) {
		isArray = true;
		}
		let isNullable = true;
		if (fieldType instanceof graphql_1.GraphQLNonNull && !forceNullable) {
		isNullable = false;
		}
		return Object.assign({}, property, { typeName, bareTypeName, fields: field.fields, isComposite: true, fragmentSpreads, inlineFragments, fieldType,
		isArray, isNullable });
		}
		var isArray = false;
		if (fieldType instanceof _graphql.GraphQLList) {
		isArray = true;
		} else if (fieldType instanceof _graphql.GraphQLNonNull && fieldType.ofType instanceof _graphql.GraphQLList) {
		isArray = true;
		else {
		const typeName = types_1.typeNameFromGraphQLType(context, fieldType);
		return Object.assign({}, property, { typeName, isComposite: false, fieldType });
		}
		var isNullable = true;
		if (fieldType instanceof _graphql.GraphQLNonNull && !forceNullable) {
		isNullable = false;
		}
		return Object.assign({}, property, {
		typeName, bareTypeName, fields: field.fields, isComposite: true, fragmentSpreads, inlineFragments, fieldType,
		isArray, isNullable
		});
		} else {
		var _typeName = (0, _types.typeNameFromGraphQLType)(context, fieldType);
		return Object.assign({}, property, { typeName: _typeName, isComposite: false, fieldType });
		}
		}

		exports.propertyFromField = propertyFromField;
		function propertyDeclarations(generator, properties, inInterface) {
		if (!properties) return;
		properties.forEach(function (property) {
		if (property.fields && property.fields.length > 0 \|\| property.inlineFragments && property.inlineFragments.length > 0) {
		if (property.inlineFragments.length > 0) {
		(0, _language.propertyDeclaration)(generator, Object.assign({}, property, {
		inInterface
		}));
		} else {
		(0, _language.propertyDeclaration)(generator, Object.assign({}, property, { inInterface }), function () {
		var properties = propertiesFromFields(generator.context, property.fields);
		propertyDeclarations(generator, properties);
		});
		}
		} else {
		(0, _language.propertyDeclaration)(generator, Object.assign({}, property, { inInterface }));
		}
		});
		if (!properties)
		return;
		properties.forEach(property => {
		if (property.fields && property.fields.length > 0 \|\| property.inlineFragments && property.inlineFragments.length > 0) {
		if (property.inlineFragments.length > 0) {
		language_1.propertyDeclaration(generator, Object.assign({}, property, { inInterface }));
		}
		else {
		language_1.propertyDeclaration(generator, Object.assign({}, property, { inInterface }), () => {
		const properties = propertiesFromFields(generator.context, property.fields);
		propertyDeclarations(generator, properties);
		});
		}
		}
		else {
		language_1.propertyDeclaration(generator, Object.assign({}, property, { inInterface }));
		}
		});
		}

		exports.propertyDeclarations = propertyDeclarations;
		function makeTypenameField(typeName) {
		return {
		responseName: '__typename',
		fieldName: '__typename',
		type: typeName
		};
		return {
		responseName: '__typename',
		fieldName: '__typename',
		type: typeName,
		};
		}

		function hasTypenameField(fields) {
		if (!fields) {
		return false;
		}

		return fields.find(function (field) {
		return field.fieldName === '__typename' \|\| field.responseName === '__typename';
		});
		if (!fields) {
		return false;
		}
		return fields.find(field => field.fieldName === '__typename' \|\| field.responseName === '__typename');
		}

		function removeTypenameFieldIfExists(generator, fields) {
		if (hasTypenameField(fields)) {
		fields = fields.filter(function (field) {
		return field.fieldName !== '__typename' \|\| field.responseName !== '__typename';
		});
		return true;
		} else {
		return false;
		}
		if (hasTypenameField(fields)) {
		fields = fields.filter(field => field.fieldName !== '__typename' \|\| field.responseName !== '__typename');
		return true;
		}
		else {
		return false;
		}
		}

		/**
		* NOTE: Mutates `fields`
		*/
		function addTypenameFieldIfNeeded(generator, fields, parentTypeName) {
		var removed = removeTypenameFieldIfExists();

		if (generator.context.addTypename \|\| removed) {
		fields.unshift(makeTypenameField(parentTypeName));
		}
		const removed = removeTypenameFieldIfExists();
		if (generator.context.addTypename \|\| removed) {
		fields.unshift(makeTypenameField(parentTypeName));
		}
		}

		function handleInlineFragments(generator, fragmentName, inlineFragments) {
		var typeNames = [];
		inlineFragments.forEach(function (inlineFragment) {
		var typeName = `${fragmentName}On${inlineFragment.typeCondition}`;
		typeNames.push(typeName);

		var hasTypenameField = inlineFragment.fields.find(function (field) {
		return field.fieldName === '__typename' \|\| field.responseName === '__typename';
		let typeNames = [];
		inlineFragments.forEach(inlineFragment => {
		const typeName = `${fragmentName}On${inlineFragment.typeCondition}`;
		typeNames.push(typeName);
		const hasTypenameField = inlineFragment.fields
		.find(field => field.fieldName === '__typename' \|\| field.responseName === '__typename');
		let fields = inlineFragment.fields;
		if (hasTypenameField) {
		fields = fields.filter(field => field.fieldName !== '__typename' \|\| field.responseName !== '__typename');
		}
		if (generator.context.addTypename \|\| hasTypenameField) {
		fields.unshift(makeTypenameField(inlineFragment.typeCondition));
		}
		let properties = propertiesFromFields(generator.context, fields, {
		typeNameSuffix: 'Fragment'
		});
		language_1.interfaceDeclaration(generator, {
		interfaceName: typeName,
		}, () => {
		propertyDeclarations(generator, properties, true);
		});
		properties.forEach(property => {
		if (property.inlineFragments && property.inlineFragments.length > 0) {
		const innerFragmentName = `${change_case_1.pascalCase(property.bareTypeName)}Fragment`;
		handleInlineFragments(generator, innerFragmentName, property.inlineFragments);
		}
		});
		});

		var fields = inlineFragment.fields;
		if (hasTypenameField) {
		fields = fields.filter(function (field) {
		return field.fieldName !== '__typename' \|\| field.responseName !== '__typename';
		});
		}

		if (generator.context.addTypename \|\| hasTypenameField) {
		fields.unshift(makeTypenameField(inlineFragment.typeCondition));
		}

		var properties = propertiesFromFields(generator.context, fields, {
		typeNameSuffix: 'Fragment'
		language_1.typeDeclaration(generator, { interfaceName: fragmentName, noBrackets: true }, () => {
		language_1.unionDeclaration(generator, typeNames);
		});

		(0, _language.interfaceDeclaration)(generator, {
		interfaceName: typeName
		}, function () {
		propertyDeclarations(generator, properties, true);
		});

		properties.forEach(function (property) {
		if (property.inlineFragments && property.inlineFragments.length > 0) {
		var innerFragmentName = `${(0, _changeCase.pascalCase)(property.bareTypeName)}Fragment`;
		handleInlineFragments(generator, innerFragmentName, property.inlineFragments);
		}
		});
		});

		// TODO: Refactor typeDeclaration to not automatically assume bracketed type
		(0, _language.typeDeclaration)(generator, { interfaceName: fragmentName, noBrackets: true }, function () {
		(0, _language.unionDeclaration)(generator, typeNames);
		});
		}
		//# sourceMappingURL=codeGeneration.js.map

lib/typescript/index.js

		@@ -1,15 +0,5 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});

		var _codeGeneration = require('./codeGeneration');

		Object.defineProperty(exports, 'generateSource', {
		enumerable: true,
		get: function get() {
		return _codeGeneration.generateSource;
		}
		});
		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		var codeGeneration_1 = require("./codeGeneration");
		exports.generateSource = codeGeneration_1.generateSource;
		//# sourceMappingURL=index.js.map

147

lib/typescript/language.js

		@@ -1,100 +0,73 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.interfaceDeclaration = interfaceDeclaration;
		exports.typeDeclaration = typeDeclaration;
		exports.propertyDeclaration = propertyDeclaration;
		exports.propertyDeclarations = propertyDeclarations;
		exports.unionDeclaration = unionDeclaration;

		var _printing = require('../utilities/printing');

		var _changeCase = require('change-case');

		function interfaceDeclaration(generator, _ref, closure) {
		var interfaceName = _ref.interfaceName,
		extendTypes = _ref.extendTypes;

		generator.printNewlineIfNeeded();
		generator.printNewline();
		generator.print(`export interface ${interfaceName}`);
		if (extendTypes && extendTypes.length > 0) {
		generator.print(` extends ${extendTypes.join(', ')}`);
		}
		generator.pushScope({ typeName: interfaceName });
		generator.withinBlock(closure);
		generator.popScope();
		}

		function typeDeclaration(generator, _ref2, closure) {
		var interfaceName = _ref2.interfaceName,
		noBrackets = _ref2.noBrackets;

		generator.printNewlineIfNeeded();
		generator.printNewline();
		generator.print(`export type ${interfaceName} =`);
		generator.pushScope({ typeName: interfaceName });
		if (!noBrackets) {
		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const change_case_1 = require("change-case");
		function interfaceDeclaration(generator, { interfaceName, extendTypes }, closure) {
		generator.printNewlineIfNeeded();
		generator.printNewline();
		generator.print(`export interface ${interfaceName}`);
		if (extendTypes && extendTypes.length > 0) {
		generator.print(` extends ${extendTypes.join(', ')}`);
		}
		generator.pushScope({ typeName: interfaceName });
		generator.withinBlock(closure);
		} else {
		generator.withinBlock(closure, '', '');
		}
		generator.popScope();
		generator.popScope();
		}

		function propertyDeclaration(generator, _ref3, closure) {
		var propertyName = _ref3.propertyName,
		typeName = _ref3.typeName,
		description = _ref3.description,
		isArray = _ref3.isArray,
		isNullable = _ref3.isNullable,
		inInterface = _ref3.inInterface,
		fragmentSpreads = _ref3.fragmentSpreads;

		generator.printOnNewline(description && `// ${description}`);
		if (closure) {
		generator.printOnNewline(`${propertyName}:`);
		if (isArray) {
		generator.print(' Array<');
		exports.interfaceDeclaration = interfaceDeclaration;
		function typeDeclaration(generator, { interfaceName, noBrackets }, closure) {
		generator.printNewlineIfNeeded();
		generator.printNewline();
		generator.print(`export type ${interfaceName} =`);
		generator.pushScope({ typeName: interfaceName });
		if (!noBrackets) {
		generator.withinBlock(closure);
		}
		if (fragmentSpreads && fragmentSpreads.length > 0) {
		generator.print(` ${fragmentSpreads.map(function (n) {
		return `${(0, _changeCase.pascalCase)(n)}Fragment`;
		}).join(' & ')} &`);
		else {
		generator.withinBlock(closure, '', '');
		}
		generator.pushScope({ typeName: propertyName });
		generator.withinBlock(closure);
		generator.popScope();
		if (isArray) {
		generator.print(' >');
		}
		exports.typeDeclaration = typeDeclaration;
		function propertyDeclaration(generator, { propertyName, typeName, description, isArray, isNullable, inInterface, fragmentSpreads }, closure) {
		generator.printOnNewline(description && `// ${description}`);
		if (closure) {
		generator.printOnNewline(`${propertyName}:`);
		if (isArray) {
		generator.print(' Array<');
		}
		if (fragmentSpreads && fragmentSpreads.length > 0) {
		generator.print(` ${fragmentSpreads.map(n => `${change_case_1.pascalCase(n)}Fragment`).join(' & ')} &`);
		}
		generator.pushScope({ typeName: propertyName });
		generator.withinBlock(closure);
		generator.popScope();
		if (isArray) {
		generator.print(' >');
		}
		if (isNullable) {
		generator.print(' \| null');
		}
		}
		if (isNullable) {
		generator.print(' \| null');
		else if (fragmentSpreads && fragmentSpreads.length > 0) {
		generator.printOnNewline(`${propertyName}: ${isArray ? 'Array<' : ''}${fragmentSpreads.map(n => `${change_case_1.pascalCase(n)}Fragment`).join(' & ')}${isArray ? '>' : ''}`);
		}
		} else if (fragmentSpreads && fragmentSpreads.length > 0) {
		generator.printOnNewline(`${propertyName}: ${isArray ? 'Array<' : ''}${fragmentSpreads.map(function (n) {
		return `${(0, _changeCase.pascalCase)(n)}Fragment`;
		}).join(' & ')}${isArray ? '>' : ''}`);
		} else {
		generator.printOnNewline(`${propertyName}: ${typeName}`);
		}
		generator.print(inInterface ? ';' : ',');
		else {
		generator.printOnNewline(`${propertyName}: ${typeName}`);
		}
		generator.print(inInterface ? ';' : ',');
		}

		exports.propertyDeclaration = propertyDeclaration;
		function propertyDeclarations(generator, properties) {
		if (!properties) return;
		properties.forEach(function (property) {
		return propertyDeclaration(generator, property);
		});
		if (!properties)
		return;
		properties.forEach(property => propertyDeclaration(generator, property));
		}

		exports.propertyDeclarations = propertyDeclarations;
		function unionDeclaration(generator, typeNames) {
		if (!typeNames) throw new Error('Union Declaration requires types');

		typeNames.forEach(function (typeName) {
		generator.printOnNewline(`\| ${typeName}`);
		});
		if (!typeNames)
		throw new Error('Union Declaration requires types');
		typeNames.forEach(typeName => {
		generator.printOnNewline(`\| ${typeName}`);
		});
		}
		exports.unionDeclaration = unionDeclaration;
		//# sourceMappingURL=language.js.map

lib/typescript/types.js

		@@ -1,40 +0,28 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.typeNameFromGraphQLType = typeNameFromGraphQLType;

		var _printing = require('../utilities/printing');

		var _changeCase = require('change-case');

		var _graphql = require('graphql');

		var builtInScalarMap = {
		[_graphql.GraphQLString.name]: 'string',
		[_graphql.GraphQLInt.name]: 'number',
		[_graphql.GraphQLFloat.name]: 'number',
		[_graphql.GraphQLBoolean.name]: 'boolean',
		[_graphql.GraphQLID.name]: 'string'
		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const graphql_1 = require("graphql");
		const builtInScalarMap = {
		[graphql_1.GraphQLString.name]: 'string',
		[graphql_1.GraphQLInt.name]: 'number',
		[graphql_1.GraphQLFloat.name]: 'number',
		[graphql_1.GraphQLBoolean.name]: 'boolean',
		[graphql_1.GraphQLID.name]: 'string',
		};

		function typeNameFromGraphQLType(context, type, bareTypeName) {
		var nullable = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;

		if (type instanceof _graphql.GraphQLNonNull) {
		return typeNameFromGraphQLType(context, type.ofType, bareTypeName, false);
		}

		var typeName = void 0;
		if (type instanceof _graphql.GraphQLList) {
		typeName = `Array< ${typeNameFromGraphQLType(context, type.ofType, bareTypeName, true)} >`;
		} else if (type instanceof _graphql.GraphQLScalarType) {
		typeName = builtInScalarMap[type.name] \|\| (context.passthroughCustomScalars ? context.customScalarsPrefix + type.name : builtInScalarMap[_graphql.GraphQLString.name]);
		} else {
		typeName = bareTypeName \|\| type.name;
		}

		return nullable ? typeName + ' \| null' : typeName;
		function typeNameFromGraphQLType(context, type, bareTypeName, nullable = true) {
		if (type instanceof graphql_1.GraphQLNonNull) {
		return typeNameFromGraphQLType(context, type.ofType, bareTypeName, false);
		}
		let typeName;
		if (type instanceof graphql_1.GraphQLList) {
		typeName = `Array< ${typeNameFromGraphQLType(context, type.ofType, bareTypeName, true)} >`;
		}
		else if (type instanceof graphql_1.GraphQLScalarType) {
		typeName = builtInScalarMap[type.name] \|\| (context.passthroughCustomScalars ? context.customScalarsPrefix + type.name : builtInScalarMap[graphql_1.GraphQLString.name]);
		}
		else {
		typeName = bareTypeName \|\| type.name;
		}
		return nullable ? typeName + ' \| null' : typeName;
		}
		exports.typeNameFromGraphQLType = typeNameFromGraphQLType;
		//# sourceMappingURL=types.js.map

137

lib/utilities/CodeGenerator.js

		@@ -1,100 +0,59 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

		var _printing = require('./printing');

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

		var CodeGenerator = function () {
		function CodeGenerator(context) {
		_classCallCheck(this, CodeGenerator);

		this.context = context;

		this.scopeStack = [];

		this.indentWidth = 2;
		this.indentLevel = 0;

		this.output = '';
		}

		_createClass(CodeGenerator, [{
		key: 'pushScope',
		value: function pushScope(scope) {
		this.scopeStack.push(scope);
		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		class CodeGenerator {
		constructor(context) {
		this.context = context;
		this.scopeStack = [];
		this.indentWidth = 2;
		this.indentLevel = 0;
		this.output = '';
		}
		}, {
		key: 'popScope',
		value: function popScope() {
		return this.scopeStack.pop();
		pushScope(scope) {
		this.scopeStack.push(scope);
		}
		}, {
		key: 'print',
		value: function print(maybeString) {
		if (maybeString) {
		this.output += maybeString;
		}
		popScope() {
		return this.scopeStack.pop();
		}
		}, {
		key: 'printNewline',
		value: function printNewline() {
		if (this.output) {
		this.print('\n');
		this.startOfIndentLevel = false;
		}
		print(maybeString) {
		if (maybeString) {
		this.output += maybeString;
		}
		}
		}, {
		key: 'printNewlineIfNeeded',
		value: function printNewlineIfNeeded() {
		if (!this.startOfIndentLevel) {
		this.printNewline();
		}
		printNewline() {
		if (this.output) {
		this.print('\n');
		this.startOfIndentLevel = false;
		}
		}
		}, {
		key: 'printOnNewline',
		value: function printOnNewline(maybeString) {
		if (maybeString) {
		this.printNewline();
		this.printIndent();
		this.print(maybeString);
		}
		printNewlineIfNeeded() {
		if (!this.startOfIndentLevel) {
		this.printNewline();
		}
		}
		}, {
		key: 'printIndent',
		value: function printIndent() {
		var indentation = ' '.repeat(this.indentLevel * this.indentWidth);
		this.output += indentation;
		printOnNewline(maybeString) {
		if (maybeString) {
		this.printNewline();
		this.printIndent();
		this.print(maybeString);
		}
		}
		}, {
		key: 'withIndent',
		value: function withIndent(closure) {
		if (!closure) return;

		this.indentLevel++;
		this.startOfIndentLevel = true;
		closure();
		this.indentLevel--;
		printIndent() {
		const indentation = ' '.repeat(this.indentLevel * this.indentWidth);
		this.output += indentation;
		}
		}, {
		key: 'withinBlock',
		value: function withinBlock(closure) {
		var open = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ' {';
		var close = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '}';

		this.print(open);
		this.withIndent(closure);
		this.printOnNewline(close);
		withIndent(closure) {
		if (!closure)
		return;
		this.indentLevel++;
		this.startOfIndentLevel = true;
		closure();
		this.indentLevel--;
		}
		}]);

		return CodeGenerator;
		}();

		withinBlock(closure, open = ' {', close = '}') {
		this.print(open);
		this.withIndent(closure);
		this.printOnNewline(close);
		}
		}
		exports.default = CodeGenerator;
		//# sourceMappingURL=CodeGenerator.js.map

201

lib/utilities/graphql.js

		@@ -1,127 +0,110 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.isBuiltInScalarType = isBuiltInScalarType;
		exports.withTypenameFieldAddedWhereNeeded = withTypenameFieldAddedWhereNeeded;
		exports.sourceAt = sourceAt;
		exports.filePathForNode = filePathForNode;
		exports.valueFromValueNode = valueFromValueNode;
		exports.isTypeProperSuperTypeOf = isTypeProperSuperTypeOf;
		exports.getOperationRootType = getOperationRootType;
		exports.getFieldDef = getFieldDef;

		var _graphql = require('graphql');

		function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

		var builtInScalarTypes = new Set([_graphql.GraphQLString, _graphql.GraphQLInt, _graphql.GraphQLFloat, _graphql.GraphQLBoolean, _graphql.GraphQLID]);

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const graphql_1 = require("graphql");
		const builtInScalarTypes = new Set([graphql_1.GraphQLString, graphql_1.GraphQLInt, graphql_1.GraphQLFloat, graphql_1.GraphQLBoolean, graphql_1.GraphQLID]);
		function isBuiltInScalarType(type) {
		return builtInScalarTypes.has(type);
		return builtInScalarTypes.has(type);
		}

		var typenameField = { kind: _graphql.Kind.FIELD, name: { kind: _graphql.Kind.NAME, value: '__typename' } };

		exports.isBuiltInScalarType = isBuiltInScalarType;
		const typenameField = { kind: graphql_1.Kind.FIELD, name: { kind: graphql_1.Kind.NAME, value: '__typename' } };
		function withTypenameFieldAddedWhereNeeded(schema, ast) {
		function isOperationRootType(type) {
		return type === schema.getQueryType() \|\| type === schema.getMutationType() \|\| type === schema.getSubscriptionType();
		}

		var typeInfo = new _graphql.TypeInfo(schema);

		return (0, _graphql.visit)(ast, (0, _graphql.visitWithTypeInfo)(typeInfo, {
		leave: {
		SelectionSet: function SelectionSet(node) {
		var parentType = typeInfo.getParentType();

		if (!isOperationRootType(parentType)) {
		return Object.assign({}, node, { selections: [typenameField].concat(_toConsumableArray(node.selections)) });
		function isOperationRootType(type) {
		return type === schema.getQueryType() \|\|
		type === schema.getMutationType() \|\|
		type === schema.getSubscriptionType();
		}
		const typeInfo = new graphql_1.TypeInfo(schema);
		return graphql_1.visit(ast, graphql_1.visitWithTypeInfo(typeInfo, {
		leave: {
		SelectionSet: node => {
		const parentType = typeInfo.getParentType();
		if (!isOperationRootType(parentType)) {
		return Object.assign({}, node, { selections: [typenameField, ...node.selections] });
		}
		}
		}
		}
		}
		}));
		}));
		}

		exports.withTypenameFieldAddedWhereNeeded = withTypenameFieldAddedWhereNeeded;
		function sourceAt(location) {
		return location.source.body.slice(location.start, location.end);
		return location.source.body.slice(location.start, location.end);
		}

		exports.sourceAt = sourceAt;
		function filePathForNode(node) {
		var name = node.loc.source && node.loc.source.name;
		return name === "GraphQL" ? undefined : name;
		const name = node.loc.source && node.loc.source.name;
		return (name === "GraphQL") ? undefined : name;
		}

		exports.filePathForNode = filePathForNode;
		function valueFromValueNode(valueNode) {
		var kind = valueNode.kind;

		if (kind === 'IntValue' \|\| kind === 'FloatValue') {
		return Number(valueNode.value);
		} else if (kind === 'NullValue') {
		return null;
		} else if (kind === 'ListValue') {
		return valueNode.values.map(valueFromValueNode);
		} else if (kind === 'ObjectValue') {
		return valueNode.fields.reduce(function (object, field) {
		object[field.name.value] = valueFromValueNode(field.value);
		return object;
		}, {});
		} else if (kind === 'Variable') {
		return { kind, variableName: valueNode.name.value };
		} else {
		return valueNode.value;
		}
		const kind = valueNode.kind;
		if (kind === 'IntValue' \|\| kind === 'FloatValue') {
		return Number(valueNode.value);
		}
		else if (kind === 'NullValue') {
		return null;
		}
		else if (kind === 'ListValue') {
		return valueNode.values.map(valueFromValueNode);
		}
		else if (kind === 'ObjectValue') {
		return valueNode.fields.reduce((object, field) => {
		object[field.name.value] = valueFromValueNode(field.value);
		return object;
		}, {});
		}
		else if (kind === 'Variable') {
		return { kind, variableName: valueNode.name.value };
		}
		else {
		return valueNode.value;
		}
		}

		exports.valueFromValueNode = valueFromValueNode;
		function isTypeProperSuperTypeOf(schema, maybeSuperType, subType) {
		return (0, _graphql.isEqualType)(maybeSuperType, subType) \|\| (0, _graphql.isAbstractType)(maybeSuperType) && schema.isPossibleType(maybeSuperType, subType);
		return graphql_1.isEqualType(maybeSuperType, subType) \|\| (graphql_1.isAbstractType(maybeSuperType) && schema.isPossibleType(maybeSuperType, subType));
		}

		// Utility functions extracted from graphql-js

		/**
		* Extracts the root type of the operation from the schema.
		*/
		exports.isTypeProperSuperTypeOf = isTypeProperSuperTypeOf;
		function getOperationRootType(schema, operation) {
		switch (operation.operation) {
		case 'query':
		return schema.getQueryType();
		case 'mutation':
		var mutationType = schema.getMutationType();
		if (!mutationType) {
		throw new GraphQLError('Schema is not configured for mutations', [operation]);
		}
		return mutationType;
		case 'subscription':
		var subscriptionType = schema.getSubscriptionType();
		if (!subscriptionType) {
		throw new GraphQLError('Schema is not configured for subscriptions', [operation]);
		}
		return subscriptionType;
		default:
		throw new GraphQLError('Can only compile queries, mutations and subscriptions', [operation]);
		}
		switch (operation.operation) {
		case 'query':
		return schema.getQueryType();
		case 'mutation':
		const mutationType = schema.getMutationType();
		if (!mutationType) {
		throw new GraphQLError('Schema is not configured for mutations', [operation]);
		}
		return mutationType;
		case 'subscription':
		const subscriptionType = schema.getSubscriptionType();
		if (!subscriptionType) {
		throw new GraphQLError('Schema is not configured for subscriptions', [operation]);
		}
		return subscriptionType;
		default:
		throw new GraphQLError('Can only compile queries, mutations and subscriptions', [operation]);
		}
		}

		/**
		* Not exactly the same as the executor's definition of getFieldDef, in this
		* statically evaluated environment we do not always have an Object type,
		* and need to handle Interface and Union types.
		*/
		exports.getOperationRootType = getOperationRootType;
		function getFieldDef(schema, parentType, fieldAST) {
		var name = fieldAST.name.value;
		if (name === _graphql.SchemaMetaFieldDef.name && schema.getQueryType() === parentType) {
		return _graphql.SchemaMetaFieldDef;
		}
		if (name === _graphql.TypeMetaFieldDef.name && schema.getQueryType() === parentType) {
		return _graphql.TypeMetaFieldDef;
		}
		if (name === _graphql.TypeNameMetaFieldDef.name && (parentType instanceof _graphql.GraphQLObjectType \|\| parentType instanceof _graphql.GraphQLInterfaceType \|\| parentType instanceof _graphql.GraphQLUnionType)) {
		return _graphql.TypeNameMetaFieldDef;
		}
		if (parentType instanceof _graphql.GraphQLObjectType \|\| parentType instanceof _graphql.GraphQLInterfaceType) {
		return parentType.getFields()[name];
		}
		const name = fieldAST.name.value;
		if (name === graphql_1.SchemaMetaFieldDef.name &&
		schema.getQueryType() === parentType) {
		return graphql_1.SchemaMetaFieldDef;
		}
		if (name === graphql_1.TypeMetaFieldDef.name &&
		schema.getQueryType() === parentType) {
		return graphql_1.TypeMetaFieldDef;
		}
		if (name === graphql_1.TypeNameMetaFieldDef.name &&
		(parentType instanceof graphql_1.GraphQLObjectType \|\|
		parentType instanceof graphql_1.GraphQLInterfaceType \|\|
		parentType instanceof graphql_1.GraphQLUnionType)) {
		return graphql_1.TypeNameMetaFieldDef;
		}
		if (parentType instanceof graphql_1.GraphQLObjectType \|\|
		parentType instanceof graphql_1.GraphQLInterfaceType) {
		return parentType.getFields()[name];
		}
		}
		exports.getFieldDef = getFieldDef;
		//# sourceMappingURL=graphql.js.map

lib/utilities/printing.js

		@@ -1,41 +0,23 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.join = join;
		exports.block = block;
		exports.wrap = wrap;
		exports.indent = indent;
		// Code generation helper functions copied from graphql-js (https://github.com/graphql/graphql-js)

		/**
		* Given maybeArray, print an empty string if it is null or empty, otherwise
		* print all items together separated by separator if provided
		*/
		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		function join(maybeArray, separator) {
		return maybeArray ? maybeArray.filter(function (x) {
		return x;
		}).join(separator \|\| '') : '';
		return maybeArray ? maybeArray.filter(x => x).join(separator \|\| '') : '';
		}

		/**
		* Given array, print each item on its own line, wrapped in an
		* indented "{ }" block.
		*/
		exports.join = join;
		function block(array) {
		return array && array.length !== 0 ? indent('{\n' + join(array, '\n')) + '\n}' : '{}';
		return array && array.length !== 0 ?
		indent('{\n' + join(array, '\n')) + '\n}' :
		'{}';
		}

		/**
		* If maybeString is not null or empty, then wrap with start and end, otherwise
		* print an empty string.
		*/
		exports.block = block;
		function wrap(start, maybeString, end) {
		return maybeString ? start + maybeString + (end \|\| '') : '';
		return maybeString ?
		start + maybeString + (end \|\| '') :
		'';
		}

		exports.wrap = wrap;
		function indent(maybeString) {
		return maybeString && maybeString.replace(/\n/g, '\n ');
		return maybeString && maybeString.replace(/\n/g, '\n ');
		}
		exports.indent = indent;
		//# sourceMappingURL=printing.js.map

120

lib/validation.js

		@@ -1,87 +0,55 @@
		'use strict';

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.validateQueryDocument = validateQueryDocument;
		exports.NoAnonymousQueries = NoAnonymousQueries;
		exports.NoExplicitTypename = NoExplicitTypename;
		exports.NoTypenameAlias = NoTypenameAlias;

		var _graphql = require('graphql');

		var _errors = require('./errors');

		function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		const graphql_1 = require("graphql");
		const errors_1 = require("./errors");
		function validateQueryDocument(schema, document, target) {
		var specifiedRulesToBeRemoved = [_graphql.NoUnusedFragments];

		var rules = [NoAnonymousQueries, NoTypenameAlias].concat(_toConsumableArray(target === 'swift' ? [NoExplicitTypename] : []), _toConsumableArray(_graphql.specifiedRules.filter(function (rule) {
		return specifiedRulesToBeRemoved.includes(rule);
		})));

		var validationErrors = (0, _graphql.validate)(schema, document, rules);
		if (validationErrors && validationErrors.length > 0) {
		var _iteratorNormalCompletion = true;
		var _didIteratorError = false;
		var _iteratorError = undefined;

		try {
		for (var _iterator = validationErrors[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
		var error = _step.value;

		(0, _errors.logError)(error);
		}
		} catch (err) {
		_didIteratorError = true;
		_iteratorError = err;
		} finally {
		try {
		if (!_iteratorNormalCompletion && _iterator.return) {
		_iterator.return();
		const specifiedRulesToBeRemoved = [graphql_1.NoUnusedFragments];
		const rules = [
		NoAnonymousQueries,
		NoTypenameAlias,
		...(target === 'swift' ? [NoExplicitTypename] : []),
		...graphql_1.specifiedRules.filter(rule => specifiedRulesToBeRemoved.includes(rule))
		];
		const validationErrors = graphql_1.validate(schema, document, rules);
		if (validationErrors && validationErrors.length > 0) {
		for (const error of validationErrors) {
		errors_1.logError(error);
		}
		} finally {
		if (_didIteratorError) {
		throw _iteratorError;
		}
		}
		throw new errors_1.ToolError("Validation of GraphQL query document failed");
		}

		throw new _errors.ToolError("Validation of GraphQL query document failed");
		}
		}

		exports.validateQueryDocument = validateQueryDocument;
		function NoAnonymousQueries(context) {
		return {
		OperationDefinition(node) {
		if (!node.name) {
		context.reportError(new _graphql.GraphQLError('Apollo does not support anonymous operations', [node]));
		}
		return false;
		}
		};
		return {
		OperationDefinition(node) {
		if (!node.name) {
		context.reportError(new graphql_1.GraphQLError('Apollo does not support anonymous operations', [node]));
		}
		return false;
		}
		};
		}

		exports.NoAnonymousQueries = NoAnonymousQueries;
		function NoExplicitTypename(context) {
		return {
		Field(node) {
		var fieldName = node.name.value;
		if (fieldName == "__typename") {
		context.reportError(new _graphql.GraphQLError('Apollo inserts __typename automatically when needed, please do not include it explicitly', [node]));
		}
		}
		};
		return {
		Field(node) {
		const fieldName = node.name.value;
		if (fieldName == "__typename") {
		context.reportError(new graphql_1.GraphQLError('Apollo inserts __typename automatically when needed, please do not include it explicitly', [node]));
		}
		}
		};
		}

		exports.NoExplicitTypename = NoExplicitTypename;
		function NoTypenameAlias(context) {
		return {
		Field(node) {
		var aliasName = node.alias && node.alias.value;
		if (aliasName == "__typename") {
		context.reportError(new _graphql.GraphQLError('Apollo needs to be able to insert __typename when needed, please do not use it as an alias', [node]));
		}
		}
		};
		return {
		Field(node) {
		const aliasName = node.alias && node.alias.value;
		if (aliasName == "__typename") {
		context.reportError(new graphql_1.GraphQLError('Apollo needs to be able to insert __typename when needed, please do not use it as an alias', [node]));
		}
		}
		};
		}
		exports.NoTypenameAlias = NoTypenameAlias;
		//# sourceMappingURL=validation.js.map

package.json

		{
		"name": "apollo-codegen",
		"version": "0.12.8",
		"version": "0.12.9",
		"description": "Generate API code or type annotations based on a GraphQL schema and query documents",
		@@ -8,5 +8,6 @@ "main": "./lib/index.js",
		"scripts": {
		"compile": "babel src --out-dir lib --source-maps",
		"watch": "babel src --out-dir lib --watch --source-maps",
		"prepublish": "rm -rf lib && npm run compile",
		"clean": "rm -rf lib",
		"compile": "tsc",
		"watch": "tsc -w",
		"prepare": "npm run clean && npm run compile",
		"test": "jest"
		@@ -24,15 +25,15 @@ },
		"devDependencies": {
		"@types/glob": "^5.0.30",
		"@types/graphql": "^0.9.1",
		"@types/inflected": "^1.1.29",
		"@types/mkdirp": "^0.3.29",
		"@types/node-fetch": "^1.6.7",
		"@types/yargs": "^6.6.0",
		"ansi-regex": "^2.1.1",
		"babel-cli": "^6.24.1",
		"babel-jest": "^20.0.3",
		"babel-plugin-transform-object-rest-spread": "^6.23.0",
		"babel-preset-env": "^1.4.0",
		"babel-register": "^6.24.1",
		"common-tags": "^1.3.0",
		"jest": "^20.0.4",
		"jest-matcher-utils": "^20.0.0",
		"regenerator-runtime": "^0.10.5"
		"typescript": "^2.3.4"
		},
		"dependencies": {
		"babel-polyfill": "^6.23.0",
		"change-case": "^3.0.0",
		@@ -48,5 +49,13 @@ "glob": "^7.0.5",
		"jest": {
		"globals": {
		"ts-jest": {
		"skipBabel": true
		}
		},
		"setupFiles": [
		"<rootDir>/src/polyfills.js"
		],
		"testMatch": [
		"/test//*.js",
		"*/test/.js"
		"/test//*.(js\|ts)",
		"*/test/.(js\|ts)"
		],
		@@ -56,8 +65,13 @@ "testPathIgnorePatterns": [
		"<rootDir>/lib/",
		"<rootDir>/test/starwars/"
		"<rootDir>/test/starwars/",
		"<rootDir>/test/preprocessor.js"
		],
		"setupFiles": [
		"<rootDir>/src/env-setup.js"
		"transform": {
		".(js\|ts)": "<rootDir>/test/preprocessor.js"
		},
		"moduleFileExtensions": [
		"ts",
		"js"
		]
		}
		}

test/loading.js

		@@ -1,3 +0,3 @@
		import {readFileSync} from 'fs';
		import path from 'path';
		import { readFileSync } from 'fs';
		import * as path from 'path';

		@@ -4,0 +4,0 @@ import { loadAndMergeQueryDocuments } from '../src/loading';

test/validation.js

		@@ -1,7 +0,7 @@
		import {readFileSync} from 'fs';
		import path from 'path';
		import { readFileSync } from 'fs';
		import * as path from 'path';

		import {loadSchema, loadAndMergeQueryDocuments} from '../src/loading';
		import { loadSchema, loadAndMergeQueryDocuments } from '../src/loading';

		import {validateQueryDocument} from '../src/validation';
		import { validateQueryDocument } from '../src/validation';

		@@ -8,0 +8,0 @@ const schema = loadSchema(require.resolve('./starwars/schema.json'));

.babelrc

lib/env-setup.js

lib/env-setup.js.map

.travis.yml