@toptal/davinci-graphql-codegen 0.4.0 → 0.4.2-alpha-chore-improve-packages-building-4fb91e1f.10

package/bin/davinci-graphql-codegen.js

@@ -2,8 +2,8 @@
 
 const cliEngine = require('@toptal/davinci-cli-shared')
 
-const codegenGenerateSchemaCreator = require('../src/commands/generate-schema')
-const codegenGenerateOperationsCreator = require('../src/commands/generate-operations')
+const codegenGenerateSchemaCreator = require('../dist/commands/generate-schema')
+const codegenGenerateOperationsCreator = require('../dist/commands/generate-operations')
 
 cliEngine.loadCommands(
   [codegenGenerateSchemaCreator, codegenGenerateOperationsCreator],

package/dist/commands/generate-operations.d.ts

@@ -0,0 +1,9 @@
+export const command: string;
+export const description: string;
+export const options: {
+    label: string;
+    name: string;
+}[];
+export function action({ options }: {
+    options: any;
+}): Promise<void>;

package/dist/commands/generate-operations.js

@@ -0,0 +1,117 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var chalk = require('chalk');
+var generateOperations = require('../generate').generateOperations;
+var readConfig = require('../read-config');
+var codegenGenerateOperations = function (_a) {
+    var config = _a.config, _b = _a.extension, extension = _b === void 0 ? '.ts' : _b;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var codegen, codegen_1, codegen_1_1, _c, schema, documents, _d, customConfig, e_1_1;
+        var e_1, _e;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0: return [4 /*yield*/, readConfig(config)];
+                case 1:
+                    codegen = _f.sent();
+                    _f.label = 2;
+                case 2:
+                    _f.trys.push([2, 8, 9, 14]);
+                    codegen_1 = __asyncValues(codegen);
+                    _f.label = 3;
+                case 3: return [4 /*yield*/, codegen_1.next()];
+                case 4:
+                    if (!(codegen_1_1 = _f.sent(), !codegen_1_1.done)) return [3 /*break*/, 7];
+                    _c = codegen_1_1.value, schema = _c.schema, documents = _c.documents, _d = _c.config, customConfig = _d === void 0 ? {} : _d;
+                    return [4 /*yield*/, generateOperations({
+                            schema: schema,
+                            documents: documents,
+                            extension: extension,
+                            config: customConfig,
+                        })];
+                case 5:
+                    _f.sent();
+                    _f.label = 6;
+                case 6: return [3 /*break*/, 3];
+                case 7: return [3 /*break*/, 14];
+                case 8:
+                    e_1_1 = _f.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 14];
+                case 9:
+                    _f.trys.push([9, , 12, 13]);
+                    if (!(codegen_1_1 && !codegen_1_1.done && (_e = codegen_1.return))) return [3 /*break*/, 11];
+                    return [4 /*yield*/, _e.call(codegen_1)];
+                case 10:
+                    _f.sent();
+                    _f.label = 11;
+                case 11: return [3 /*break*/, 13];
+                case 12:
+                    if (e_1) throw e_1.error;
+                    return [7 /*endfinally*/];
+                case 13: return [7 /*endfinally*/];
+                case 14: return [2 /*return*/];
+            }
+        });
+    });
+};
+var codegenGenerateOperationsCreator = {
+    command: 'generate-operations',
+    description: 'generate graphql operation types based off generated schemas',
+    options: [
+        {
+            label: "Path to your custom ".concat(chalk.green('codegen.json'), " config file"),
+            name: '--config <config-path>',
+        },
+        {
+            label: "Custom extension that generated files will have. Defaults to ".concat(chalk.green('.ts')),
+            name: '--extension <extension>',
+        },
+    ],
+    action: function (_a) {
+        var options = _a.options;
+        return codegenGenerateOperations(options);
+    },
+};
+module.exports = codegenGenerateOperationsCreator;

package/dist/commands/generate-schema.d.ts

@@ -0,0 +1,9 @@
+export const command: string;
+export const description: string;
+export const options: {
+    label: string;
+    name: string;
+}[];
+export function action({ options }: {
+    options: any;
+}): Promise<void>;

package/dist/commands/generate-schema.js

@@ -0,0 +1,117 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var chalk = require('chalk');
+var generateSchema = require('../generate').generateSchema;
+var readConfig = require('../read-config');
+var codegenGenerateSchema = function (_a) {
+    var _b = _a.projectId, projectId = _b === void 0 ? 'toptal-hub' : _b, config = _a.config;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var codegen, codegen_1, codegen_1_1, _c, schema, documents, target, e_1_1;
+        var e_1, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0: return [4 /*yield*/, readConfig(config)];
+                case 1:
+                    codegen = _e.sent();
+                    _e.label = 2;
+                case 2:
+                    _e.trys.push([2, 8, 9, 14]);
+                    codegen_1 = __asyncValues(codegen);
+                    _e.label = 3;
+                case 3: return [4 /*yield*/, codegen_1.next()];
+                case 4:
+                    if (!(codegen_1_1 = _e.sent(), !codegen_1_1.done)) return [3 /*break*/, 7];
+                    _c = codegen_1_1.value, schema = _c.schema, documents = _c.documents, target = _c.target;
+                    return [4 /*yield*/, generateSchema({
+                            schema: schema,
+                            documents: documents,
+                            target: target,
+                            projectId: projectId,
+                        })];
+                case 5:
+                    _e.sent();
+                    _e.label = 6;
+                case 6: return [3 /*break*/, 3];
+                case 7: return [3 /*break*/, 14];
+                case 8:
+                    e_1_1 = _e.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 14];
+                case 9:
+                    _e.trys.push([9, , 12, 13]);
+                    if (!(codegen_1_1 && !codegen_1_1.done && (_d = codegen_1.return))) return [3 /*break*/, 11];
+                    return [4 /*yield*/, _d.call(codegen_1)];
+                case 10:
+                    _e.sent();
+                    _e.label = 11;
+                case 11: return [3 /*break*/, 13];
+                case 12:
+                    if (e_1) throw e_1.error;
+                    return [7 /*endfinally*/];
+                case 13: return [7 /*endfinally*/];
+                case 14: return [2 /*return*/];
+            }
+        });
+    });
+};
+var codegenGenerateSchemaCreator = {
+    command: 'generate-schema',
+    description: 'generate graphql schemas',
+    options: [
+        {
+            label: "roject ID inside Google Storage Bucket. Defaults to ".concat(chalk.green('toptal-hub')),
+            name: '--projectId <id>',
+        },
+        {
+            label: "Path to your custom ".concat(chalk.green('codegen.json'), " config file"),
+            name: '--config <file-path>',
+        },
+    ],
+    action: function (_a) {
+        var options = _a.options;
+        return codegenGenerateSchema(options);
+    },
+};
+module.exports = codegenGenerateSchemaCreator;

package/dist/config/config.d.ts

@@ -0,0 +1,33 @@
+export namespace commonOperationTypesConfig {
+    const dedupeFragments: boolean;
+    const skipTypename: boolean;
+    const exportFragmentSpreadSubTypes: boolean;
+    namespace avoidOptionals {
+        const field: boolean;
+        const inputValue: boolean;
+        const object: boolean;
+    }
+    namespace namingConvention {
+        const enumValues: string;
+    }
+    namespace scalars {
+        const BigDecimal: string;
+        const Date: string;
+        const ISO8601Date: string;
+        const ISO8601DateTime: string;
+        const JobTypeEnum: string;
+        const JSON: string;
+        const PageSize: string;
+        const Time: string;
+        const TimeOfDay: string;
+        const Upload: string;
+    }
+}
+export namespace commonSchemaTypesConfig {
+    const resolverTypeWrapperSignature: string;
+    const allowParentTypeOverride: boolean;
+    const noSchemaStitching: boolean;
+    const optionalInfoArgument: boolean;
+    const optionalResolveType: boolean;
+}
+export const autoGenerationComments: string[];

package/dist/config/config.js

@@ -0,0 +1,47 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var commonTypesConfig = {
+    skipTypename: true,
+    exportFragmentSpreadSubTypes: true,
+    avoidOptionals: {
+        field: true,
+        inputValue: false,
+        object: true,
+    },
+    namingConvention: {
+        enumValues: 'upper-case#upperCase',
+    },
+    scalars: {
+        BigDecimal: 'string',
+        Date: 'string',
+        ISO8601Date: 'string',
+        ISO8601DateTime: 'string',
+        JobTypeEnum: 'string',
+        JSON: 'string',
+        PageSize: 'number',
+        Time: 'string',
+        TimeOfDay: 'string',
+        Upload: 'unknown',
+    },
+};
+var commonSchemaTypesConfig = __assign(__assign({}, commonTypesConfig), { resolverTypeWrapperSignature: '(parent: unknown, args: any) => ({ [K in keyof Partial<T>]: TypeOrMockList<T[K]> }) | null', allowParentTypeOverride: false, noSchemaStitching: true, optionalInfoArgument: true, optionalResolveType: true });
+var commonOperationTypesConfig = __assign(__assign({}, commonTypesConfig), { dedupeFragments: true });
+var autoGenerationComments = [
+    '/* eslint-disable */',
+    '/* ⚠️ THIS IS AN AUTOGENERATED FILE, DO NOT EDIT ⚠️  */',
+];
+module.exports = {
+    commonOperationTypesConfig: commonOperationTypesConfig,
+    commonSchemaTypesConfig: commonSchemaTypesConfig,
+    autoGenerationComments: autoGenerationComments,
+};

package/dist/config/index.d.ts

@@ -0,0 +1,2 @@
+export = config;
+import config = require("./config");

package/dist/config/index.js

@@ -0,0 +1,3 @@
+"use strict";
+var config = require('./config');
+module.exports = config;

package/dist/generate/index.d.ts

@@ -0,0 +1,3 @@
+import generateOperations = require("./operations");
+import generateSchema = require("./schema");
+export { generateOperations, generateSchema };

package/dist/generate/index.js

@@ -0,0 +1,4 @@
+"use strict";
+var generateOperations = require('./operations');
+var generateSchema = require('./schema');
+module.exports = { generateOperations: generateOperations, generateSchema: generateSchema };

package/dist/generate/operations.d.ts

@@ -0,0 +1,7 @@
+export = generateOperations;
+declare function generateOperations({ schema, documents, extension, config }: {
+    schema: any;
+    documents: any;
+    extension: any;
+    config: any;
+}): Promise<void>;

package/dist/generate/operations.js

@@ -0,0 +1,134 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var chalk = require('chalk');
+var generate = require('@graphql-codegen/cli').generate;
+var _a = require('fs-extra'), readFileSync = _a.readFileSync, writeFileSync = _a.writeFileSync;
+var prettier = require('prettier');
+var dirname = require('path').dirname;
+var merge = require('deepmerge');
+var _b = require('../config/config'), commonOperationTypesConfig = _b.commonOperationTypesConfig, autoGenerationComments = _b.autoGenerationComments;
+var getSchemaPath = require('../services/get-schema-path');
+var getRelativeFilePath = require('../utils/get-relative-file-path');
+var generateOperations = function (_a) {
+    var schema = _a.schema, documents = _a.documents, extension = _a.extension, config = _a.config;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var docsPath, _b, target, schemaPath, schemaPathResolution;
+        var _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    docsPath = getRelativeFilePath(documents);
+                    _b = getSchemaPath(schema), target = _b.target, schemaPath = _b.schemaPath, schemaPathResolution = _b.schemaPathResolution;
+                    console.log("\u2139\uFE0F  Generating [".concat(chalk.green(target), "] operations"));
+                    console.log("\u2139\uFE0F  Documents pattern: [".concat(chalk.green(documents), "]"));
+                    return [4 /*yield*/, generate({
+                            documents: docsPath,
+                            config: merge(commonOperationTypesConfig, config),
+                            generates: (_c = {},
+                                _c[schemaPath] = {
+                                    schema: schemaPathResolution,
+                                    preset: 'near-operation-file',
+                                    presetConfig: {
+                                        extension: extension,
+                                        baseTypesPath: "~".concat(schema, "/schema"),
+                                    },
+                                    plugins: [
+                                        'typescript-operations',
+                                        'typed-document-node',
+                                        {
+                                            add: {
+                                                content: autoGenerationComments,
+                                            },
+                                        },
+                                    ],
+                                },
+                                _c),
+                            hooks: {
+                                afterAllFileWrite: [
+                                    function () {
+                                        var filePaths = [];
+                                        for (var _i = 0; _i < arguments.length; _i++) {
+                                            filePaths[_i] = arguments[_i];
+                                        }
+                                        return __awaiter(void 0, void 0, void 0, function () {
+                                            var _a, filePaths_1, path, rawText, options, formattedText;
+                                            return __generator(this, function (_b) {
+                                                switch (_b.label) {
+                                                    case 0:
+                                                        _a = 0, filePaths_1 = filePaths;
+                                                        _b.label = 1;
+                                                    case 1:
+                                                        if (!(_a < filePaths_1.length)) return [3 /*break*/, 4];
+                                                        path = filePaths_1[_a];
+                                                        rawText = readFileSync(path, 'utf8');
+                                                        return [4 /*yield*/, prettier.resolveConfig(dirname(path))];
+                                                    case 2:
+                                                        options = _b.sent();
+                                                        formattedText = prettier.format(rawText, __assign({ parser: 'typescript' }, options));
+                                                        writeFileSync(path, formattedText);
+                                                        _b.label = 3;
+                                                    case 3:
+                                                        _a++;
+                                                        return [3 /*break*/, 1];
+                                                    case 4: return [2 /*return*/];
+                                                }
+                                            });
+                                        });
+                                    },
+                                ],
+                            },
+                        }, true)];
+                case 1:
+                    _d.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
+module.exports = generateOperations;

package/dist/generate/schema.d.ts

@@ -0,0 +1,6 @@
+export = generateSchema;
+declare function generateSchema({ schema, target, projectId }: {
+    schema: any;
+    target: any;
+    projectId: any;
+}): Promise<void>;

package/dist/generate/schema.js

@@ -0,0 +1,132 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var generate = require('@graphql-codegen/cli').generate;
+var chalk = require('chalk');
+var _a = require('fs'), readFileSync = _a.readFileSync, writeFileSync = _a.writeFileSync;
+var prettier = require('prettier');
+var dirname = require('path').dirname;
+var _b = require('../config/config'), commonSchemaTypesConfig = _b.commonSchemaTypesConfig, autoGenerationComments = _b.autoGenerationComments;
+var schemaLoader = require('../services/schema-loader');
+var isSchemaFromHttp = require('../utils/detect-schema-source').isSchemaFromHttp;
+var generateSchema = function (_a) {
+    var schema = _a.schema, target = _a.target, projectId = _a.projectId;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var _b, schemaPath, destinationPathTs;
+        var _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, schemaLoader(schema, target, projectId)];
+                case 1:
+                    _b = _d.sent(), schemaPath = _b.schema, destinationPathTs = _b.destination;
+                    console.log("\u2139\uFE0F  Generating [".concat(chalk.green(target), "] schema"));
+                    return [4 /*yield*/, generate({
+                            schema: schemaPath,
+                            generates: (_c = {},
+                                // [destinationPath]: {
+                                //   plugins: ['introspection']
+                                // },
+                                _c[destinationPathTs] = {
+                                    schema: isSchemaFromHttp(schema)
+                                        ? schema
+                                        : require.resolve(schemaPath),
+                                    plugins: [
+                                        'typescript',
+                                        'typescript-resolvers',
+                                        {
+                                            add: {
+                                                content: autoGenerationComments,
+                                            },
+                                        },
+                                    ],
+                                },
+                                _c),
+                            hooks: {
+                                afterAllFileWrite: [
+                                    function () {
+                                        var filePaths = [];
+                                        for (var _i = 0; _i < arguments.length; _i++) {
+                                            filePaths[_i] = arguments[_i];
+                                        }
+                                        return __awaiter(void 0, void 0, void 0, function () {
+                                            var _a, filePaths_1, path, rawText, options, formattedText;
+                                            return __generator(this, function (_b) {
+                                                switch (_b.label) {
+                                                    case 0:
+                                                        _a = 0, filePaths_1 = filePaths;
+                                                        _b.label = 1;
+                                                    case 1:
+                                                        if (!(_a < filePaths_1.length)) return [3 /*break*/, 4];
+                                                        path = filePaths_1[_a];
+                                                        rawText = readFileSync(path, 'utf8');
+                                                        return [4 /*yield*/, prettier.resolveConfig(dirname(path))];
+                                                    case 2:
+                                                        options = _b.sent();
+                                                        formattedText = prettier.format(rawText, __assign({ parser: 'typescript' }, options));
+                                                        writeFileSync(path, formattedText);
+                                                        _b.label = 3;
+                                                    case 3:
+                                                        _a++;
+                                                        return [3 /*break*/, 1];
+                                                    case 4: return [2 /*return*/];
+                                                }
+                                            });
+                                        });
+                                    },
+                                ],
+                            },
+                            config: __assign({}, commonSchemaTypesConfig),
+                        }, true)];
+                case 2:
+                    _d.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
+module.exports = generateSchema;