graphql-code-generator/dist/codegen.js

"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) {
    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());
    });
};
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 };
    }
};
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_tools_1 = require("graphql-tools");
var Listr = require("listr");
var helpers_1 = require("./helpers");
var documents_glob_1 = require("./utils/documents-glob");
var document_loader_1 = require("./loaders/documents/document-loader");
var validate_documents_1 = require("./loaders/documents/validate-documents");
var prettier_1 = require("./utils/prettier");
var listr_renderer_1 = require("./utils/listr-renderer");
var load_1 = require("./load");
var errors_1 = require("./errors");
function mergeSchemas(schemas) {
    return __awaiter(this, void 0, void 0, function () {
        return __generator(this, function (_a) {
            if (schemas.length === 0) {
                return [2 /*return*/, null];
            }
            else if (schemas.length === 1) {
                return [2 /*return*/, schemas[0]];
            }
            else {
                return [2 /*return*/, graphql_tools_1.mergeSchemas({ schemas: schemas.filter(function (s) { return s; }) })];
            }
            return [2 /*return*/];
        });
    });
}
function executeCodegen(config) {
    return __awaiter(this, void 0, void 0, function () {
        function wrapTask(task, source) {
            var _this = this;
            return function () { return __awaiter(_this, void 0, void 0, function () {
                var error_1;
                return __generator(this, function (_a) {
                    switch (_a.label) {
                        case 0:
                            _a.trys.push([0, 2, , 3]);
                            return [4 /*yield*/, task()];
                        case 1:
                            _a.sent();
                            return [3 /*break*/, 3];
                        case 2:
                            error_1 = _a.sent();
                            if (source) {
                                error_1.source = source;
                            }
                            throw error_1;
                        case 3: return [2 /*return*/];
                    }
                });
            }); };
        }
        function normalize() {
            /* Load Require extensions */
            var requireExtensions = helpers_1.normalizeInstanceOrArray(config.require);
            requireExtensions.forEach(function (mod) { return require(mod); });
            /* Root templates-config */
            rootConfig = config.config || {};
            /* Normalize root "schema" field */
            schemas = helpers_1.normalizeInstanceOrArray(config.schema);
            /* Normalize root "documents" field */
            documents = helpers_1.normalizeInstanceOrArray(config.documents);
            /* Normalize "generators" field */
            for (var _i = 0, _a = Object.keys(config.generates); _i < _a.length; _i++) {
                var filename = _a[_i];
                generates[filename] = helpers_1.normalizeOutputParam(config.generates[filename]);
            }
        }
        function loadRootSchema() {
            return __awaiter(this, void 0, void 0, function () {
                var _a;
                return __generator(this, function (_b) {
                    switch (_b.label) {
                        case 0:
                            _a = mergeSchemas;
                            return [4 /*yield*/, Promise.all(schemas.map(function (pointToScehma) { return load_1.loadSchema(pointToScehma, config); }))];
                        case 1: return [4 /*yield*/, _a.apply(void 0, [_b.sent()])];
                        case 2:
                            /* Load root schemas */
                            rootSchema = _b.sent();
                            return [2 /*return*/];
                    }
                });
            });
        }
        function loadRootDocuments() {
            return __awaiter(this, void 0, void 0, function () {
                var foundDocumentsPaths, errors;
                return __generator(this, function (_a) {
                    switch (_a.label) {
                        case 0:
                            if (!(documents.length > 0)) return [3 /*break*/, 3];
                            return [4 /*yield*/, documents_glob_1.documentsFromGlobs(documents)];
                        case 1:
                            foundDocumentsPaths = _a.sent();
                            return [4 /*yield*/, document_loader_1.loadDocumentsSources(foundDocumentsPaths)];
                        case 2:
                            rootDocuments = _a.sent();
                            if (rootSchema) {
                                errors = validate_documents_1.validateGraphQlDocuments(rootSchema, rootDocuments);
                                validate_documents_1.checkValidationErrors(errors);
                            }
                            _a.label = 3;
                        case 3: return [2 /*return*/];
                    }
                });
            });
        }
        var result, commonListrOptions, verboseOptions, listrOptions, listr, rootConfig, schemas, documents, generates, rootSchema, rootDocuments;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    result = [];
                    commonListrOptions = {
                        exitOnError: true
                    };
                    verboseOptions = __assign({}, commonListrOptions, { renderer: 'verbose', nonTTYRenderer: 'verbose' });
                    listrOptions = __assign({}, commonListrOptions, { renderer: config.silent ? 'silent' : listr_renderer_1.Renderer, nonTTYRenderer: config.silent ? 'silent' : 'default', collapse: true, clearOutput: false });
                    listr = new Listr(process.env.VERBOSE || process.env.NODE_ENV === 'test' ? verboseOptions : listrOptions);
                    rootConfig = {};
                    generates = {};
                    rootDocuments = [];
                    listr.add({
                        title: 'Parse configuration',
                        task: function (ctx) {
                            normalize();
                            ctx.hasSchemas = schemas.length > 0;
                            ctx.hasDocuments = documents.length > 0;
                        }
                    });
                    listr.add({
                        title: 'Load schema',
                        enabled: function (ctx) { return ctx.hasSchemas; },
                        task: wrapTask(loadRootSchema)
                    });
                    listr.add({
                        title: 'Load documents',
                        enabled: function (ctx) { return ctx.hasDocuments; },
                        task: wrapTask(loadRootDocuments)
                    });
                    listr.add({
                        title: 'Generate outputs',
                        task: function () {
                            return new Listr(Object.keys(generates).map(function (filename, i) { return ({
                                title: "Generate " + filename,
                                task: function () {
                                    var outputConfig = generates[filename];
                                    var outputFileTemplateConfig = outputConfig.config || {};
                                    var outputSchema = rootSchema;
                                    var outputDocuments = rootDocuments;
                                    var outputSpecificSchemas = helpers_1.normalizeInstanceOrArray(outputConfig.schema);
                                    var outputSpecificDocuments = helpers_1.normalizeInstanceOrArray(outputConfig.documents);
                                    function addSchema() {
                                        return __awaiter(this, void 0, void 0, function () {
                                            var _a, _b, _c;
                                            return __generator(this, function (_d) {
                                                switch (_d.label) {
                                                    case 0:
                                                        _a = mergeSchemas;
                                                        _c = (_b = [
                                                            rootSchema
                                                        ]).concat;
                                                        return [4 /*yield*/, Promise.all(outputSpecificSchemas.map(function (pointToScehma) { return load_1.loadSchema(pointToScehma, config); }))];
                                                    case 1: return [4 /*yield*/, _a.apply(void 0, [_c.apply(_b, [(_d.sent())])])];
                                                    case 2:
                                                        outputSchema = _d.sent();
                                                        return [2 /*return*/];
                                                }
                                            });
                                        });
                                    }
                                    function addDocuments() {
                                        return __awaiter(this, void 0, void 0, function () {
                                            var foundDocumentsPaths, additionalDocs, errors;
                                            return __generator(this, function (_a) {
                                                switch (_a.label) {
                                                    case 0: return [4 /*yield*/, documents_glob_1.documentsFromGlobs(outputSpecificDocuments)];
                                                    case 1:
                                                        foundDocumentsPaths = _a.sent();
                                                        return [4 /*yield*/, document_loader_1.loadDocumentsSources(foundDocumentsPaths)];
                                                    case 2:
                                                        additionalDocs = _a.sent();
                                                        if (outputSchema) {
                                                            errors = validate_documents_1.validateGraphQlDocuments(outputSchema, additionalDocs);
                                                            validate_documents_1.checkValidationErrors(errors);
                                                        }
                                                        outputDocuments = rootDocuments.concat(additionalDocs);
                                                        return [2 /*return*/];
                                                }
                                            });
                                        });
                                    }
                                    function doGenerateOutput() {
                                        return __awaiter(this, void 0, void 0, function () {
                                            var normalizedPluginsArray, output;
                                            return __generator(this, function (_a) {
                                                switch (_a.label) {
                                                    case 0:
                                                        normalizedPluginsArray = helpers_1.normalizeConfig(outputConfig.plugins);
                                                        return [4 /*yield*/, generateOutput({
                                                                filename: filename,
                                                                plugins: normalizedPluginsArray,
                                                                schema: outputSchema,
                                                                documents: outputDocuments,
                                                                inheritedConfig: __assign({}, rootConfig, outputFileTemplateConfig)
                                                            })];
                                                    case 1:
                                                        output = _a.sent();
                                                        result.push(output);
                                                        return [2 /*return*/];
                                                }
                                            });
                                        });
                                    }
                                    return new Listr([
                                        {
                                            title: 'Add related schemas',
                                            enabled: function () { return outputSpecificSchemas.length > 0; },
                                            task: wrapTask(addSchema, filename)
                                        },
                                        {
                                            title: 'Add related documents',
                                            enabled: function () { return outputSpecificDocuments.length > 0; },
                                            task: wrapTask(addDocuments, filename)
                                        },
                                        {
                                            title: 'Generate',
                                            task: wrapTask(doGenerateOutput, filename)
                                        }
                                    ], {
                                        // it stops when one of tasks failed
                                        exitOnError: true
                                    });
                                }
                            }); }), {
                                // it doesn't stop when one of tasks failed, to finish at least some of outputs
                                exitOnError: false,
                                // run 4 at once
                                concurrent: 4
                            });
                        }
                    });
                    return [4 /*yield*/, listr.run()];
                case 1:
                    _a.sent();
                    return [2 /*return*/, result];
            }
        });
    });
}
exports.executeCodegen = executeCodegen;
function generateOutput(options) {
    return __awaiter(this, void 0, void 0, function () {
        var output, _i, _a, plugin, name_1, pluginConfig, result, _b;
        return __generator(this, function (_c) {
            switch (_c.label) {
                case 0:
                    output = '';
                    _i = 0, _a = options.plugins;
                    _c.label = 1;
                case 1:
                    if (!(_i < _a.length)) return [3 /*break*/, 4];
                    plugin = _a[_i];
                    name_1 = Object.keys(plugin)[0];
                    pluginConfig = plugin[name_1];
                    return [4 /*yield*/, executePlugin({
                            name: name_1,
                            config: typeof pluginConfig !== 'object'
                                ? pluginConfig
                                : __assign({}, options.inheritedConfig, pluginConfig),
                            schema: options.schema,
                            documents: options.documents,
                            outputFilename: options.filename,
                            allPlugins: options.plugins
                        })];
                case 2:
                    result = _c.sent();
                    output += result;
                    _c.label = 3;
                case 3:
                    _i++;
                    return [3 /*break*/, 1];
                case 4:
                    _b = { filename: options.filename };
                    return [4 /*yield*/, prettier_1.prettify(options.filename, output)];
                case 5: return [2 /*return*/, (_b.content = _c.sent(), _b)];
            }
        });
    });
}
exports.generateOutput = generateOutput;
function getPluginByName(name) {
    return __awaiter(this, void 0, void 0, function () {
        var possibleNames, _i, possibleNames_1, packageName, possibleNamesMsg;
        return __generator(this, function (_a) {
            possibleNames = [
                "graphql-codegen-" + name,
                "graphql-codegen-" + name + "-template",
                "codegen-" + name,
                "codegen-" + name + "-template",
                name
            ];
            for (_i = 0, possibleNames_1 = possibleNames; _i < possibleNames_1.length; _i++) {
                packageName = possibleNames_1[_i];
                try {
                    return [2 /*return*/, require(packageName)];
                }
                catch (err) {
                    if (err.message.indexOf("Cannot find module '" + packageName + "'") === -1) {
                        throw new errors_1.DetailedError("Unable to load template plugin matching " + name, "\n            Unable to load template plugin matching '" + name + "'.\n            Reason: \n              " + err.message + "\n          ");
                    }
                }
            }
            possibleNamesMsg = possibleNames
                .map(function (name) {
                return ("\n      - " + name + "\n  ").trimRight();
            })
                .join('');
            throw new errors_1.DetailedError("Unable to find template plugin matching " + name, "\n      Unable to find template plugin matching '" + name + "'\n      Install one of the following packages:\n      \n      " + possibleNamesMsg + "\n    ");
        });
    });
}
exports.getPluginByName = getPluginByName;
function executePlugin(options) {
    return __awaiter(this, void 0, void 0, function () {
        var pluginPackage, schema, _a, e_1;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0: return [4 /*yield*/, getPluginByName(options.name)];
                case 1:
                    pluginPackage = _b.sent();
                    if (!!pluginPackage.addToSchema) return [3 /*break*/, 2];
                    _a = options.schema;
                    return [3 /*break*/, 4];
                case 2: return [4 /*yield*/, mergeSchemas([
                        options.schema,
                        graphql_tools_1.makeExecutableSchema({
                            typeDefs: pluginPackage.addToSchema,
                            allowUndefinedInResolve: true,
                            resolverValidationOptions: {
                                requireResolversForResolveType: false,
                                requireResolversForAllFields: false,
                                requireResolversForNonScalar: false,
                                requireResolversForArgs: false
                            }
                        })
                    ])];
                case 3:
                    _a = _b.sent();
                    _b.label = 4;
                case 4:
                    schema = _a;
                    if (!(pluginPackage.validate && typeof pluginPackage.validate === 'function')) return [3 /*break*/, 8];
                    _b.label = 5;
                case 5:
                    _b.trys.push([5, 7, , 8]);
                    return [4 /*yield*/, pluginPackage.validate(schema, options.documents, options.config, options.outputFilename, options.allPlugins)];
                case 6:
                    _b.sent();
                    return [3 /*break*/, 8];
                case 7:
                    e_1 = _b.sent();
                    return [3 /*break*/, 8];
                case 8: return [2 /*return*/, pluginPackage.plugin(schema, options.documents, options.config)];
            }
        });
    });
}
exports.executePlugin = executePlugin;
//# sourceMappingURL=codegen.js.map