graphql-code-generator/dist/commonjs/codegen.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const graphql_codegen_plugin_helpers_1 = require("graphql-codegen-plugin-helpers");
const graphql_codegen_core_1 = require("graphql-codegen-core");
const Listr = require("listr");
const helpers_1 = require("./helpers");
const prettier_1 = require("./utils/prettier");
const listr_renderer_1 = require("./utils/listr-renderer");
const errors_1 = require("./errors");
const load_1 = require("./load");
const graphql_1 = require("graphql");
const plugins_1 = require("./plugins");
exports.defaultPluginLoader = (mod) => Promise.resolve().then(() => require(mod));
async function executeCodegen(config) {
    function wrapTask(task, source) {
        return async () => {
            try {
                await task();
            }
            catch (error) {
                if (source && !(error instanceof graphql_1.GraphQLError)) {
                    error.source = source;
                }
                throw error;
            }
        };
    }
    const result = [];
    const commonListrOptions = {
        exitOnError: true
    };
    let listr;
    if (process.env.VERBOSE) {
        listr = new Listr(Object.assign({}, commonListrOptions, { renderer: 'verbose', nonTTYRenderer: 'verbose' }));
    }
    else if (process.env.NODE_ENV === 'test') {
        listr = new Listr(Object.assign({}, commonListrOptions, { renderer: 'silent', nonTTYRenderer: 'silent' }));
    }
    else {
        listr = new Listr(Object.assign({}, commonListrOptions, { renderer: config.silent ? 'silent' : listr_renderer_1.Renderer, nonTTYRenderer: config.silent ? 'silent' : 'default', collapse: true, clearOutput: false }));
    }
    let rootConfig = {};
    let rootSchemas;
    let rootDocuments;
    let generates = {};
    async function normalize() {
        /* Load Require extensions */
        const requireExtensions = helpers_1.normalizeInstanceOrArray(config.require);
        for (const mod of requireExtensions) {
            await Promise.resolve().then(() => require(mod));
        }
        /* Root templates-config */
        rootConfig = config.config || {};
        /* Normalize root "schema" field */
        rootSchemas = helpers_1.normalizeInstanceOrArray(config.schema);
        /* Normalize root "documents" field */
        rootDocuments = helpers_1.normalizeInstanceOrArray(config.documents);
        /* Normalize "generators" field */
        const generateKeys = Object.keys(config.generates);
        if (generateKeys.length === 0) {
            throw new errors_1.DetailedError('Invalid Codegen Configuration!', `
        Please make sure that your codegen config file contains the "generates" field, with a specification for the plugins you need.
        
        It should looks like that:

        schema:
          - my-schema.graphql
        generates:
          my-file.ts:
            - plugin1
            - plugin2
            - plugin3
        `);
        }
        for (const filename of generateKeys) {
            generates[filename] = helpers_1.normalizeOutputParam(config.generates[filename]);
            if (generates[filename].plugins.length === 0) {
                throw new errors_1.DetailedError('Invalid Codegen Configuration!', `
          Please make sure that your codegen config file has defined plugins list for output "${filename}".
          
          It should looks like that:
  
          schema:
            - my-schema.graphql
          generates:
            my-file.ts:
              - plugin1
              - plugin2
              - plugin3
          `);
            }
        }
        if (rootSchemas.length === 0 && Object.keys(generates).some(filename => generates[filename].schema.length === 0)) {
            throw new errors_1.DetailedError('Invalid Codegen Configuration!', `
        Please make sure that your codegen config file contains either the "schema" field 
        or every generated file has its own "schema" field.
        
        It should looks like that:
        schema:
          - my-schema.graphql

        or:
        generates:
          path/to/output:
            schema: my-schema.graphql
      `);
        }
    }
    listr.add({
        title: 'Parse configuration',
        task: () => normalize()
    });
    listr.add({
        title: 'Generate outputs',
        task: () => {
            return new Listr(Object.keys(generates).map((filename, i) => ({
                title: `Generate ${filename}`,
                task: () => {
                    const outputConfig = generates[filename];
                    const outputFileTemplateConfig = outputConfig.config || {};
                    const outputDocuments = [];
                    let outputSchema;
                    const outputSpecificSchemas = helpers_1.normalizeInstanceOrArray(outputConfig.schema);
                    const outputSpecificDocuments = helpers_1.normalizeInstanceOrArray(outputConfig.documents);
                    return new Listr([
                        {
                            title: 'Load GraphQL schemas',
                            task: wrapTask(async () => {
                                graphql_codegen_plugin_helpers_1.debugLog(`[CLI] Loading Schemas`);
                                const allSchemas = [
                                    ...rootSchemas.map(pointToScehma => load_1.loadSchema(pointToScehma, config)),
                                    ...outputSpecificSchemas.map(pointToScehma => load_1.loadSchema(pointToScehma, config))
                                ];
                                if (allSchemas.length > 0) {
                                    outputSchema = await graphql_codegen_core_1.mergeSchemas(await Promise.all(allSchemas));
                                }
                            }, filename)
                        },
                        {
                            title: 'Load GraphQL documents',
                            task: wrapTask(async () => {
                                graphql_codegen_plugin_helpers_1.debugLog(`[CLI] Loading Documents`);
                                const allDocuments = [...rootDocuments, ...outputSpecificDocuments];
                                for (const docDef of allDocuments) {
                                    const documents = await load_1.loadDocuments(docDef, config);
                                    if (documents.length > 0) {
                                        outputDocuments.push(...documents);
                                    }
                                }
                            }, filename)
                        },
                        {
                            title: 'Generate',
                            task: wrapTask(async () => {
                                graphql_codegen_plugin_helpers_1.debugLog(`[CLI] Generating output`);
                                const normalizedPluginsArray = helpers_1.normalizeConfig(outputConfig.plugins);
                                const pluginLoader = config.pluginLoader || exports.defaultPluginLoader;
                                const pluginPackages = await Promise.all(normalizedPluginsArray.map(plugin => plugins_1.getPluginByName(Object.keys(plugin)[0], pluginLoader)));
                                const pluginMap = {};
                                pluginPackages.forEach((pluginPackage, i) => {
                                    const plugin = normalizedPluginsArray[i];
                                    const name = Object.keys(plugin)[0];
                                    pluginMap[name] = pluginPackage;
                                });
                                const output = await graphql_codegen_core_1.codegen({
                                    filename,
                                    plugins: normalizedPluginsArray,
                                    schema: outputSchema,
                                    documents: outputDocuments,
                                    config: Object.assign({}, rootConfig, outputFileTemplateConfig),
                                    pluginMap
                                });
                                result.push({
                                    filename,
                                    content: await prettier_1.prettify(filename, output)
                                });
                            }, 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
            });
        }
    });
    await listr.run();
    return result;
}
exports.executeCodegen = executeCodegen;
//# sourceMappingURL=codegen.js.map