graphql-code-generator/dist/codegen.js

import { debugLog } from 'graphql-codegen-core';
import Listr from 'listr';
import { normalizeOutputParam, normalizeInstanceOrArray, normalizeConfig } from './helpers';
import { prettify } from './utils/prettier';
import { Renderer } from './utils/listr-renderer';
import { DetailedError } from './errors';
import { loadSchema, loadDocuments } from './load';
import { mergeSchemas } from './merge-schemas';
import { GraphQLError, visit } from 'graphql';
import { executePlugin, getPluginByName } from './execute-plugin';
export async function executeCodegen(config) {
    function wrapTask(task, source) {
        return async () => {
            try {
                await task();
            }
            catch (error) {
                if (source && !(error instanceof 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' : Renderer, nonTTYRenderer: config.silent ? 'silent' : 'default', collapse: true, clearOutput: false }));
    }
    let rootConfig = {};
    let rootSchemas;
    let rootDocuments;
    let generates = {};
    function normalize() {
        /* Load Require extensions */
        const requireExtensions = normalizeInstanceOrArray(config.require);
        requireExtensions.forEach(mod => require(mod));
        /* Root templates-config */
        rootConfig = config.config || {};
        /* Normalize root "schema" field */
        rootSchemas = normalizeInstanceOrArray(config.schema);
        /* Normalize root "documents" field */
        rootDocuments = normalizeInstanceOrArray(config.documents);
        /* Normalize "generators" field */
        const generateKeys = Object.keys(config.generates);
        if (generateKeys.length === 0) {
            throw new 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] = normalizeOutputParam(config.generates[filename]);
            if (generates[filename].plugins.length === 0) {
                throw new 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 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 = normalizeInstanceOrArray(outputConfig.schema);
                    const outputSpecificDocuments = normalizeInstanceOrArray(outputConfig.documents);
                    return new Listr([
                        {
                            title: 'Load GraphQL schemas',
                            task: wrapTask(async () => {
                                debugLog(`[CLI] Loading Schemas`);
                                const allSchemas = [
                                    ...rootSchemas.map(pointToScehma => loadSchema(pointToScehma, config)),
                                    ...outputSpecificSchemas.map(pointToScehma => loadSchema(pointToScehma, config))
                                ];
                                if (allSchemas.length > 0) {
                                    outputSchema = await mergeSchemas(await Promise.all(allSchemas));
                                }
                            }, filename)
                        },
                        {
                            title: 'Load GraphQL documents',
                            task: wrapTask(async () => {
                                debugLog(`[CLI] Loading Documents`);
                                const allDocuments = [...rootDocuments, ...outputSpecificDocuments];
                                for (const docDef of allDocuments) {
                                    const documents = await loadDocuments(docDef, config);
                                    if (documents.length > 0) {
                                        outputDocuments.push(...documents);
                                    }
                                }
                            }, filename)
                        },
                        {
                            title: 'Generate',
                            task: wrapTask(async () => {
                                debugLog(`[CLI] Generating output`);
                                const normalizedPluginsArray = normalizeConfig(outputConfig.plugins);
                                const output = await generateOutput({
                                    filename,
                                    plugins: normalizedPluginsArray,
                                    schema: outputSchema,
                                    documents: outputDocuments,
                                    inheritedConfig: Object.assign({}, rootConfig, outputFileTemplateConfig),
                                    pluginLoader: config.pluginLoader || require
                                });
                                result.push(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;
}
function validateDocuments(schema, files) {
    // duplicated names
    const operationMap = {};
    files.forEach(file => {
        visit(file.content, {
            OperationDefinition(node) {
                if (typeof node.name !== 'undefined') {
                    if (!operationMap[node.name.value]) {
                        operationMap[node.name.value] = [];
                    }
                    operationMap[node.name.value].push(file.filePath);
                }
            }
        });
    });
    const names = Object.keys(operationMap);
    if (names.length) {
        const duplicated = names.filter(name => operationMap[name].length > 1);
        if (!duplicated.length) {
            return;
        }
        const list = duplicated
            .map(name => `
      * ${name} found in:
        ${operationMap[name]
            .map(filepath => {
            return `
            - ${filepath}
          `.trimRight();
        })
            .join('')}
  `.trimRight())
            .join('');
        throw new DetailedError(`Not all operations have an unique name: ${duplicated.join(', ')}`, `
        Not all operations have an unique name

        ${list}
      `);
    }
}
export async function generateOutput(options) {
    let output = '';
    validateDocuments(options.schema, options.documents);
    const pluginsPackages = await Promise.all(options.plugins.map(plugin => getPluginByName(Object.keys(plugin)[0], options.pluginLoader)));
    // merged schema with parts added by plugins
    const schema = pluginsPackages.reduce((schema, plugin) => {
        return !plugin.addToSchema ? schema : mergeSchemas([schema, plugin.addToSchema]);
    }, options.schema);
    for (let i = 0; i < options.plugins.length; i++) {
        const plugin = options.plugins[i];
        const pluginPackage = pluginsPackages[i];
        const name = Object.keys(plugin)[0];
        const pluginConfig = plugin[name];
        debugLog(`[CLI] Running plugin: ${name}`);
        const result = await executePlugin({
            name,
            config: typeof pluginConfig !== 'object'
                ? pluginConfig
                : Object.assign({}, options.inheritedConfig, pluginConfig),
            schema,
            documents: options.documents,
            outputFilename: options.filename,
            allPlugins: options.plugins
        }, pluginPackage);
        debugLog(`[CLI] Completed executing plugin: ${name}`);
        output += result;
    }
    return { filename: options.filename, content: await prettify(options.filename, output) };
}
//# sourceMappingURL=codegen.js.map