@graphql-codegen/cli 2.7.0 → 2.8.0-alpha-36b27f965.0

package/cjs/bin.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_js_1 = require("./cli.js");
+const cli_error_js_1 = require("./utils/cli-error.js");
+const [, , cmd] = process.argv;
+(0, cli_js_1.runCli)(cmd)
+    .then(() => {
+    process.exit(0);
+})
+    .catch(error => {
+    (0, cli_error_js_1.cliError)(error);
+});

package/cjs/cli.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureGraphQlPackage = exports.runCli = void 0;
+const generate_and_save_js_1 = require("./generate-and-save.js");
+const index_js_1 = require("./init/index.js");
+const config_js_1 = require("./config.js");
+const hooks_js_1 = require("./hooks.js");
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+async function runCli(cmd) {
+    await ensureGraphQlPackage();
+    if (cmd === 'init') {
+        return (0, index_js_1.init)();
+    }
+    const context = await (0, config_js_1.createContext)();
+    try {
+        return await (0, generate_and_save_js_1.generate)(context);
+    }
+    catch (error) {
+        await (0, hooks_js_1.lifecycleHooks)(context.getConfig().hooks).onError(error.toString());
+        throw error;
+    }
+}
+exports.runCli = runCli;
+async function ensureGraphQlPackage() {
+    try {
+        await Promise.resolve().then(() => __importStar(require('graphql')));
+    }
+    catch (e) {
+        throw new plugin_helpers_1.DetailedError(`Unable to load "graphql" package. Please make sure to install "graphql" as a dependency!`, `
+  To install "graphql", run:
+    yarn add graphql
+  Or, with NPM:
+    npm install --save graphql
+`);
+    }
+}
+exports.ensureGraphQlPackage = ensureGraphQlPackage;

package/cjs/codegen.js

@@ -0,0 +1,332 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCodegen = void 0;
+const tslib_1 = require("tslib");
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const core_1 = require("@graphql-codegen/core");
+const utils_1 = require("@graphql-tools/utils");
+const listr_renderer_js_1 = require("./utils/listr-renderer.js");
+const graphql_1 = require("graphql");
+const plugins_js_1 = require("./plugins.js");
+const presets_js_1 = require("./presets.js");
+const debugging_js_1 = require("./utils/debugging.js");
+const config_js_1 = require("./config.js");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const os_1 = require("os");
+// eslint-disable-next-line
+const module_1 = require("module");
+const listr_1 = tslib_1.__importDefault(require("listr"));
+const cli_error_js_1 = require("./utils/cli-error.js");
+const makeDefaultLoader = (from) => {
+    if (fs_1.default.statSync(from).isDirectory()) {
+        from = path_1.default.join(from, '__fake.js');
+    }
+    const relativeRequire = (0, module_1.createRequire)(from);
+    return (mod) => {
+        return Promise.resolve().then(() => tslib_1.__importStar(require(relativeRequire.resolve(mod))));
+    };
+};
+function createCache() {
+    const cache = new Map();
+    return function ensure(namespace, key, factory) {
+        const cacheKey = `${namespace}:${key}`;
+        const cachedValue = cache.get(cacheKey);
+        if (cachedValue) {
+            return cachedValue;
+        }
+        const value = factory();
+        cache.set(cacheKey, value);
+        return value;
+    };
+}
+async function executeCodegen(input) {
+    const context = (0, config_js_1.ensureContext)(input);
+    const config = context.getConfig();
+    const pluginContext = context.getPluginContext();
+    const result = [];
+    const commonListrOptions = {
+        exitOnError: true,
+    };
+    let listr;
+    if (process.env.VERBOSE) {
+        listr = new listr_1.default({
+            ...commonListrOptions,
+            renderer: 'verbose',
+            nonTTYRenderer: 'verbose',
+        });
+    }
+    else if (process.env.NODE_ENV === 'test') {
+        listr = new listr_1.default({
+            ...commonListrOptions,
+            renderer: 'silent',
+            nonTTYRenderer: 'silent',
+        });
+    }
+    else {
+        listr = new listr_1.default({
+            ...commonListrOptions,
+            renderer: config.silent ? 'silent' : config.errorsOnly ? listr_renderer_js_1.ErrorRenderer : listr_renderer_js_1.Renderer,
+            nonTTYRenderer: config.silent ? 'silent' : 'default',
+            collapse: true,
+            clearOutput: false,
+        });
+    }
+    let rootConfig = {};
+    let rootSchemas;
+    let rootDocuments;
+    const generates = {};
+    const cache = createCache();
+    function wrapTask(task, source, taskName) {
+        return () => {
+            return context.profiler.run(async () => {
+                try {
+                    await Promise.resolve().then(() => task());
+                }
+                catch (error) {
+                    if (source && !(error instanceof graphql_1.GraphQLError)) {
+                        error.source = source;
+                    }
+                    throw error;
+                }
+            }, taskName);
+        };
+    }
+    async function normalize() {
+        /* Load Require extensions */
+        const requireExtensions = (0, plugin_helpers_1.normalizeInstanceOrArray)(config.require);
+        const loader = makeDefaultLoader(context.cwd);
+        for (const mod of requireExtensions) {
+            await loader(mod);
+        }
+        /* Root plugin  config */
+        rootConfig = config.config || {};
+        /* Normalize root "schema" field */
+        rootSchemas = (0, plugin_helpers_1.normalizeInstanceOrArray)(config.schema);
+        /* Normalize root "documents" field */
+        rootDocuments = (0, plugin_helpers_1.normalizeInstanceOrArray)(config.documents);
+        /* Normalize "generators" field */
+        const generateKeys = Object.keys(config.generates || {});
+        if (generateKeys.length === 0) {
+            throw new plugin_helpers_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) {
+            const output = (generates[filename] = (0, plugin_helpers_1.normalizeOutputParam)(config.generates[filename]));
+            if (!output.preset && (!output.plugins || output.plugins.length === 0)) {
+                throw new plugin_helpers_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 || generates[filename].schema.length === 0)) {
+            throw new plugin_helpers_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_1.default(Object.keys(generates).map(filename => {
+                const outputConfig = generates[filename];
+                const hasPreset = !!outputConfig.preset;
+                return {
+                    title: hasPreset
+                        ? `Generate to ${filename} (using EXPERIMENTAL preset "${outputConfig.preset}")`
+                        : `Generate ${filename}`,
+                    task: () => {
+                        let outputSchemaAst;
+                        let outputSchema;
+                        const outputFileTemplateConfig = outputConfig.config || {};
+                        let outputDocuments = [];
+                        const outputSpecificSchemas = (0, plugin_helpers_1.normalizeInstanceOrArray)(outputConfig.schema);
+                        const outputSpecificDocuments = (0, plugin_helpers_1.normalizeInstanceOrArray)(outputConfig.documents);
+                        return new listr_1.default([
+                            {
+                                title: 'Load GraphQL schemas',
+                                task: wrapTask(async () => {
+                                    (0, debugging_js_1.debugLog)(`[CLI] Loading Schemas`);
+                                    const schemaPointerMap = {};
+                                    const allSchemaUnnormalizedPointers = [...rootSchemas, ...outputSpecificSchemas];
+                                    for (const unnormalizedPtr of allSchemaUnnormalizedPointers) {
+                                        if (typeof unnormalizedPtr === 'string') {
+                                            schemaPointerMap[unnormalizedPtr] = {};
+                                        }
+                                        else if (typeof unnormalizedPtr === 'object') {
+                                            Object.assign(schemaPointerMap, unnormalizedPtr);
+                                        }
+                                    }
+                                    const hash = JSON.stringify(schemaPointerMap);
+                                    const result = await cache('schema', hash, async () => {
+                                        const outputSchemaAst = await context.loadSchema(schemaPointerMap);
+                                        const outputSchema = (0, plugin_helpers_1.getCachedDocumentNodeFromSchema)(outputSchemaAst);
+                                        return {
+                                            outputSchemaAst,
+                                            outputSchema,
+                                        };
+                                    });
+                                    outputSchemaAst = await result.outputSchemaAst;
+                                    outputSchema = result.outputSchema;
+                                }, filename, `Load GraphQL schemas: ${filename}`),
+                            },
+                            {
+                                title: 'Load GraphQL documents',
+                                task: wrapTask(async () => {
+                                    (0, debugging_js_1.debugLog)(`[CLI] Loading Documents`);
+                                    // get different cache for shared docs and output specific docs
+                                    const documentPointerMap = {};
+                                    const allDocumentsUnnormalizedPointers = [...rootDocuments, ...outputSpecificDocuments];
+                                    for (const unnormalizedPtr of allDocumentsUnnormalizedPointers) {
+                                        if (typeof unnormalizedPtr === 'string') {
+                                            documentPointerMap[unnormalizedPtr] = {};
+                                        }
+                                        else if (typeof unnormalizedPtr === 'object') {
+                                            Object.assign(documentPointerMap, unnormalizedPtr);
+                                        }
+                                    }
+                                    const hash = JSON.stringify(documentPointerMap);
+                                    const result = await cache('documents', hash, async () => {
+                                        const documents = await context.loadDocuments(documentPointerMap);
+                                        return {
+                                            documents,
+                                        };
+                                    });
+                                    outputDocuments = await result.documents;
+                                }, filename, `Load GraphQL documents: ${filename}`),
+                            },
+                            {
+                                title: 'Generate',
+                                task: wrapTask(async () => {
+                                    (0, debugging_js_1.debugLog)(`[CLI] Generating output`);
+                                    const normalizedPluginsArray = (0, plugin_helpers_1.normalizeConfig)(outputConfig.plugins);
+                                    const pluginLoader = config.pluginLoader || makeDefaultLoader(context.cwd);
+                                    const pluginPackages = await Promise.all(normalizedPluginsArray.map(plugin => (0, plugins_js_1.getPluginByName)(Object.keys(plugin)[0], pluginLoader)));
+                                    const pluginMap = {};
+                                    const preset = hasPreset
+                                        ? typeof outputConfig.preset === 'string'
+                                            ? await (0, presets_js_1.getPresetByName)(outputConfig.preset, makeDefaultLoader(context.cwd))
+                                            : outputConfig.preset
+                                        : null;
+                                    pluginPackages.forEach((pluginPackage, i) => {
+                                        const plugin = normalizedPluginsArray[i];
+                                        const name = Object.keys(plugin)[0];
+                                        pluginMap[name] = pluginPackage;
+                                    });
+                                    const mergedConfig = {
+                                        ...rootConfig,
+                                        ...(typeof outputFileTemplateConfig === 'string'
+                                            ? { value: outputFileTemplateConfig }
+                                            : outputFileTemplateConfig),
+                                    };
+                                    let outputs = [];
+                                    if (hasPreset) {
+                                        outputs = await context.profiler.run(async () => preset.buildGeneratesSection({
+                                            baseOutputDir: filename,
+                                            presetConfig: outputConfig.presetConfig || {},
+                                            plugins: normalizedPluginsArray,
+                                            schema: outputSchema,
+                                            schemaAst: outputSchemaAst,
+                                            documents: outputDocuments,
+                                            config: mergedConfig,
+                                            pluginMap,
+                                            pluginContext,
+                                            profiler: context.profiler,
+                                        }), `Build Generates Section: ${filename}`);
+                                    }
+                                    else {
+                                        outputs = [
+                                            {
+                                                filename,
+                                                plugins: normalizedPluginsArray,
+                                                schema: outputSchema,
+                                                schemaAst: outputSchemaAst,
+                                                documents: outputDocuments,
+                                                config: mergedConfig,
+                                                pluginMap,
+                                                pluginContext,
+                                                profiler: context.profiler,
+                                            },
+                                        ];
+                                    }
+                                    const process = async (outputArgs) => {
+                                        const output = await (0, core_1.codegen)({
+                                            ...outputArgs,
+                                            cache,
+                                        });
+                                        result.push({
+                                            filename: outputArgs.filename,
+                                            content: output,
+                                            hooks: outputConfig.hooks || {},
+                                        });
+                                    };
+                                    await context.profiler.run(() => Promise.all(outputs.map(process)), `Codegen: ${filename}`);
+                                }, filename, `Generate: ${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,
+                concurrent: (0, os_1.cpus)().length,
+            });
+        },
+    });
+    try {
+        await listr.run();
+    }
+    catch (err) {
+        if ((0, cli_error_js_1.isListrError)(err)) {
+            const allErrs = err.errors.map(subErr => (0, plugin_helpers_1.isDetailedError)(subErr)
+                ? `${subErr.message} for "${subErr.source}"${subErr.details}`
+                : subErr.message || subErr.toString());
+            const newErr = new utils_1.AggregateError(err.errors, `${err.message} ${allErrs.join('\n\n')}`);
+            // Best-effort to all stack traces for debugging
+            newErr.stack = `${newErr.stack}\n\n${err.errors.map(subErr => subErr.stack).join('\n\n')}`;
+            throw newErr;
+        }
+        throw err;
+    }
+    return result;
+}
+exports.executeCodegen = executeCodegen;