@depup/graphql-codegen__cli 6.2.1-depup.0

package/README.md

@@ -0,0 +1,51 @@
+# @depup/graphql-codegen__cli
+
+> Dependency-bumped version of [@graphql-codegen/cli](https://www.npmjs.com/package/@graphql-codegen/cli)
+
+Generated by [DepUp](https://github.com/depup/npm) -- all production
+dependencies bumped to latest versions.
+
+## Installation
+
+```bash
+npm install @depup/graphql-codegen__cli
+```
+
+| Field | Value |
+|-------|-------|
+| Original | [@graphql-codegen/cli](https://www.npmjs.com/package/@graphql-codegen/cli) @ 6.2.1 |
+| Processed | 2026-03-17 |
+| Smoke test | passed |
+| Deps updated | 21 |
+
+## Dependency Changes
+
+| Dependency | From | To |
+|------------|------|-----|
+| @babel/generator | ^7.18.13 | ^7.29.1 |
+| @babel/template | ^7.18.10 | ^7.28.6 |
+| @babel/types | ^7.18.13 | ^7.29.0 |
+| @graphql-tools/graphql-file-loader | ^8.1.11 | ^8.1.12 |
+| @graphql-tools/merge | ^9.0.6 | ^9.1.7 |
+| @inquirer/prompts | ^7.8.2 | ^8.3.2 |
+| @whatwg-node/fetch | ^0.10.0 | ^0.10.13 |
+| chalk | ^4.1.0 | ^5.6.2 |
+| cosmiconfig | ^9.0.0 | ^9.0.1 |
+| debounce | ^2.0.0 | ^3.0.0 |
+| detect-indent | ^6.0.0 | ^7.0.2 |
+| is-glob | ^4.0.1 | ^4.0.3 |
+| jiti | ^2.3.0 | ^2.6.1 |
+| listr2 | ^9.0.0 | ^10.2.1 |
+| log-symbols | ^4.0.0 | ^7.0.1 |
+| micromatch | ^4.0.5 | ^4.0.8 |
+| shell-quote | ^1.7.3 | ^1.8.3 |
+| ts-log | ^2.2.3 | ^2.2.7 |
+| tslib | ^2.4.0 | ^2.8.1 |
+| yaml | ^2.3.1 | ^2.8.2 |
+| yargs | ^17.0.0 | ^18.0.0 |
+
+---
+
+Source: https://github.com/depup/npm | Original: https://www.npmjs.com/package/@graphql-codegen/cli
+
+License inherited from the original package.

package/changes.json

@@ -0,0 +1,90 @@
+{
+  "bumped": {
+    "@babel/generator": {
+      "from": "^7.18.13",
+      "to": "^7.29.1"
+    },
+    "@babel/template": {
+      "from": "^7.18.10",
+      "to": "^7.28.6"
+    },
+    "@babel/types": {
+      "from": "^7.18.13",
+      "to": "^7.29.0"
+    },
+    "@graphql-tools/graphql-file-loader": {
+      "from": "^8.1.11",
+      "to": "^8.1.12"
+    },
+    "@graphql-tools/merge": {
+      "from": "^9.0.6",
+      "to": "^9.1.7"
+    },
+    "@inquirer/prompts": {
+      "from": "^7.8.2",
+      "to": "^8.3.2"
+    },
+    "@whatwg-node/fetch": {
+      "from": "^0.10.0",
+      "to": "^0.10.13"
+    },
+    "chalk": {
+      "from": "^4.1.0",
+      "to": "^5.6.2"
+    },
+    "cosmiconfig": {
+      "from": "^9.0.0",
+      "to": "^9.0.1"
+    },
+    "debounce": {
+      "from": "^2.0.0",
+      "to": "^3.0.0"
+    },
+    "detect-indent": {
+      "from": "^6.0.0",
+      "to": "^7.0.2"
+    },
+    "is-glob": {
+      "from": "^4.0.1",
+      "to": "^4.0.3"
+    },
+    "jiti": {
+      "from": "^2.3.0",
+      "to": "^2.6.1"
+    },
+    "listr2": {
+      "from": "^9.0.0",
+      "to": "^10.2.1"
+    },
+    "log-symbols": {
+      "from": "^4.0.0",
+      "to": "^7.0.1"
+    },
+    "micromatch": {
+      "from": "^4.0.5",
+      "to": "^4.0.8"
+    },
+    "shell-quote": {
+      "from": "^1.7.3",
+      "to": "^1.8.3"
+    },
+    "ts-log": {
+      "from": "^2.2.3",
+      "to": "^2.2.7"
+    },
+    "tslib": {
+      "from": "^2.4.0",
+      "to": "^2.8.1"
+    },
+    "yaml": {
+      "from": "^2.3.1",
+      "to": "^2.8.2"
+    },
+    "yargs": {
+      "from": "^17.0.0",
+      "to": "^18.0.0"
+    }
+  },
+  "timestamp": "2026-03-17T16:31:22.793Z",
+  "totalUpdated": 21
+}

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(returnCode => {
+    process.exit(returnCode);
+})
+    .catch(error => {
+    (0, cli_error_js_1.cliError)(error);
+});

package/cjs/cli.js

@@ -0,0 +1,64 @@
+"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.runCli = runCli;
+exports.ensureGraphQlPackage = ensureGraphQlPackage;
+const config_js_1 = require("./config.js");
+const generate_and_save_js_1 = require("./generate-and-save.js");
+const hooks_js_1 = require("./hooks.js");
+const index_js_1 = require("./init/index.js");
+async function runCli(cmd) {
+    await ensureGraphQlPackage();
+    if (cmd === 'init') {
+        await (0, index_js_1.init)();
+        return 0;
+    }
+    const context = await (0, config_js_1.createContext)();
+    try {
+        await (0, generate_and_save_js_1.generate)(context);
+        if (context.checkMode && context.checkModeStaleFiles.length > 0) {
+            // eslint-disable-next-line no-console
+            console.log(`The following stale files were detected:\n${context.checkModeStaleFiles.map(file => `  - ${file}\n`)}`);
+            return 1;
+        }
+        return 0;
+    }
+    catch (error) {
+        await (0, hooks_js_1.lifecycleHooks)(context.getConfig().hooks).onError(error.toString());
+        return 1;
+    }
+}
+async function ensureGraphQlPackage() {
+    try {
+        await Promise.resolve().then(() => __importStar(require('graphql')));
+    }
+    catch {
+        throw new Error(`Unable to load "graphql" package. Please make sure to install "graphql" as a dependency! \n
+       To install "graphql", run:
+         yarn add graphql
+       Or, with NPM:
+         npm install --save graphql`);
+    }
+}

package/cjs/codegen.js

@@ -0,0 +1,388 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCodegen = executeCodegen;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const module_1 = require("module");
+const os_1 = require("os");
+const path_1 = tslib_1.__importDefault(require("path"));
+const core_1 = require("@graphql-codegen/core");
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const load_1 = require("@graphql-tools/load");
+const graphql_1 = require("graphql");
+const merge_1 = require("@graphql-tools/merge");
+const listr2_1 = require("listr2");
+const config_js_1 = require("./config.js");
+const plugins_js_1 = require("./plugins.js");
+const presets_js_1 = require("./presets.js");
+const debugging_js_1 = require("./utils/debugging.js");
+const documentTransforms_js_1 = require("./documentTransforms.js");
+/**
+ * Poor mans ESM detection.
+ * Looking at this and you have a better method?
+ * Send a PR.
+ */
+const isESMModule = (typeof __dirname === 'string') === false;
+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 async (mod) => {
+        return Promise.resolve(`${isESMModule
+            ? /**
+               * For ESM we currently have no "resolve path" solution
+               * as import.meta is unavailable in a CommonJS context
+               * and furthermore unavailable in stable Node.js.
+               **/
+                mod
+            : relativeRequire.resolve(mod)}`).then(s => tslib_1.__importStar(require(s)));
+    };
+};
+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 = [];
+    let rootConfig = {};
+    let rootSchemas;
+    let rootDocuments;
+    const generates = {};
+    const cache = createCache();
+    // We need a simple string to uniqually identify the provided GraphQLSchema objects for the above cache.
+    // Because JavaScript does not provide access to its internal object ids, we need a workaround.
+    // Below is a common way to get unique ids for objects in JavaScript,
+    // by using a WeakMap and autoincrementing the id.
+    const jsObjectIds = new WeakMap();
+    let jsObjectIdCounter = 0;
+    function getJsObjectId(schema) {
+        if (!jsObjectIds.has(schema)) {
+            jsObjectIds.set(schema, jsObjectIdCounter++);
+        }
+        return jsObjectIds.get(schema);
+    }
+    function wrapTask(task, source, taskName, ctx) {
+        return () => context.profiler.run(async () => {
+            try {
+                await Promise.resolve().then(() => task());
+            }
+            catch (error) {
+                if (source && !(error instanceof graphql_1.GraphQLError)) {
+                    error.source = source;
+                }
+                ctx.errors.push(error);
+                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 Error(`Invalid Codegen Configuration! \n
+        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 Error(`Invalid Codegen Configuration! \n
+          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 ||
+                (Array.isArray(generates[filename].schema === 'object') &&
+                    generates[filename].schema.length === 0))) {
+            throw new Error(`Invalid Codegen Configuration! \n
+        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
+      `);
+        }
+    }
+    const isTest = process.env.NODE_ENV === 'test';
+    const tasks = new listr2_1.Listr([
+        {
+            title: 'Parse Configuration',
+            task: () => normalize(),
+        },
+        {
+            title: 'Generate outputs',
+            task: (ctx, task) => {
+                const generateTasks = Object.keys(generates).map(filename => {
+                    const outputConfig = generates[filename];
+                    const hasPreset = !!outputConfig.preset;
+                    const title = `Generate to ${filename}`;
+                    return {
+                        title,
+                        async task(_, subTask) {
+                            let outputSchemaAst;
+                            let outputSchema;
+                            const outputFileTemplateConfig = outputConfig.config || {};
+                            let outputDocuments = [];
+                            const outputSpecificSchemas = (0, plugin_helpers_1.normalizeInstanceOrArray)(outputConfig.schema);
+                            let outputSpecificDocuments = (0, plugin_helpers_1.normalizeInstanceOrArray)(outputConfig.documents);
+                            const preset = hasPreset
+                                ? typeof outputConfig.preset === 'string'
+                                    ? await (0, presets_js_1.getPresetByName)(outputConfig.preset, makeDefaultLoader(context.cwd))
+                                    : outputConfig.preset
+                                : null;
+                            if (preset?.prepareDocuments) {
+                                outputSpecificDocuments = await preset.prepareDocuments(filename, outputSpecificDocuments);
+                            }
+                            return subTask.newListr([
+                                {
+                                    title: 'Load GraphQL schemas',
+                                    task: wrapTask(async () => {
+                                        (0, debugging_js_1.debugLog)(`[CLI] Loading Schemas`);
+                                        const schemaPointerMap = {};
+                                        const parsedSchemas = [];
+                                        const allSchemaDenormalizedPointers = [...rootSchemas, ...outputSpecificSchemas];
+                                        for (const denormalizedPtr of allSchemaDenormalizedPointers) {
+                                            if ((0, graphql_1.isSchema)(denormalizedPtr)) {
+                                                parsedSchemas.push(denormalizedPtr);
+                                            }
+                                            else if (typeof denormalizedPtr === 'string') {
+                                                schemaPointerMap[denormalizedPtr] = {};
+                                            }
+                                            else if (typeof denormalizedPtr === 'object') {
+                                                Object.assign(schemaPointerMap, denormalizedPtr);
+                                            }
+                                        }
+                                        const hash = JSON.stringify(schemaPointerMap) + parsedSchemas.map(getJsObjectId).join(',');
+                                        const result = await cache('schema', hash, async () => {
+                                            // collect parsed schemas
+                                            const schemasToMerge = [...parsedSchemas];
+                                            // collect schemas, provided by pointers
+                                            if (Object.keys(schemaPointerMap).length) {
+                                                schemasToMerge.push(await context.loadSchema(schemaPointerMap));
+                                            }
+                                            // merge all collected schemas into one
+                                            const outputSchemaAst = schemasToMerge.length === 1
+                                                ? schemasToMerge[0]
+                                                : (0, graphql_1.buildASTSchema)((0, merge_1.mergeTypeDefs)(schemasToMerge));
+                                            const outputSchema = (0, plugin_helpers_1.getCachedDocumentNodeFromSchema)(outputSchemaAst);
+                                            return {
+                                                outputSchemaAst,
+                                                outputSchema,
+                                            };
+                                        });
+                                        outputSchemaAst = result.outputSchemaAst;
+                                        outputSchema = result.outputSchema;
+                                    }, filename, `Load GraphQL schemas: ${filename}`, ctx),
+                                },
+                                {
+                                    title: 'Load GraphQL documents',
+                                    task: wrapTask(async () => {
+                                        (0, debugging_js_1.debugLog)(`[CLI] Loading Documents`);
+                                        const documentPointerMap = {};
+                                        const allDocumentsDenormalizedPointers = [...rootDocuments, ...outputSpecificDocuments];
+                                        for (const denormalizedPtr of allDocumentsDenormalizedPointers) {
+                                            if (typeof denormalizedPtr === 'string') {
+                                                documentPointerMap[denormalizedPtr] = {};
+                                            }
+                                            else if (typeof denormalizedPtr === 'object') {
+                                                Object.assign(documentPointerMap, denormalizedPtr);
+                                            }
+                                        }
+                                        const hash = JSON.stringify(documentPointerMap);
+                                        const result = await cache('documents', hash, async () => {
+                                            try {
+                                                const documents = await context.loadDocuments(documentPointerMap);
+                                                return {
+                                                    documents,
+                                                };
+                                            }
+                                            catch (error) {
+                                                if (error instanceof load_1.NoTypeDefinitionsFound && config.ignoreNoDocuments) {
+                                                    return {
+                                                        documents: [],
+                                                    };
+                                                }
+                                                throw error;
+                                            }
+                                        });
+                                        outputDocuments = result.documents;
+                                    }, filename, `Load GraphQL documents: ${filename}`, ctx),
+                                },
+                                {
+                                    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 = Object.fromEntries(pluginPackages.map((pkg, i) => {
+                                            const plugin = normalizedPluginsArray[i];
+                                            const name = Object.keys(plugin)[0];
+                                            return [name, pkg];
+                                        }));
+                                        const rawMergedConfig = {
+                                            ...rootConfig,
+                                            emitLegacyCommonJSImports: config.emitLegacyCommonJSImports,
+                                            importExtension: config.importExtension,
+                                            ...(typeof outputFileTemplateConfig === 'string'
+                                                ? { value: outputFileTemplateConfig }
+                                                : outputFileTemplateConfig),
+                                        };
+                                        const importExtension = (0, plugin_helpers_1.normalizeImportExtension)({
+                                            emitLegacyCommonJSImports: rawMergedConfig.emitLegacyCommonJSImports,
+                                            importExtension: rawMergedConfig.importExtension,
+                                        });
+                                        const mergedConfig = {
+                                            ...rawMergedConfig,
+                                            importExtension,
+                                            emitLegacyCommonJSImports: rawMergedConfig.emitLegacyCommonJSImports ?? true,
+                                        };
+                                        const documentTransforms = Array.isArray(outputConfig.documentTransforms)
+                                            ? await Promise.all(outputConfig.documentTransforms.map(async (config, index) => {
+                                                return await (0, documentTransforms_js_1.getDocumentTransform)(config, makeDefaultLoader(context.cwd), `the element at index ${index} of the documentTransforms`);
+                                            }))
+                                            : [];
+                                        const outputs = preset
+                                            ? 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,
+                                                documentTransforms,
+                                            }), `Build Generates Section: ${filename}`)
+                                            : [
+                                                {
+                                                    filename,
+                                                    plugins: normalizedPluginsArray,
+                                                    schema: outputSchema,
+                                                    schemaAst: outputSchemaAst,
+                                                    documents: outputDocuments,
+                                                    config: mergedConfig,
+                                                    pluginMap,
+                                                    pluginContext,
+                                                    profiler: context.profiler,
+                                                    documentTransforms,
+                                                },
+                                            ];
+                                        const process = async (outputArgs) => {
+                                            const output = await (0, core_1.codegen)({
+                                                ...outputArgs,
+                                                importExtension,
+                                                emitLegacyCommonJSImports: rawMergedConfig.emitLegacyCommonJSImports ?? true,
+                                                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}`, ctx),
+                                },
+                            ], {
+                                /**
+                                 * For each `generates` task, we must do the following in order:
+                                 *
+                                 * 1. Load schema
+                                 * 2. Load documents
+                                 * 3. Generate based on the schema + documents
+                                 *
+                                 * This way, the 3rd step has all the schema and documents loaded in previous steps to work correctly
+                                 */
+                                exitOnError: true,
+                                concurrent: false,
+                            });
+                        },
+                        // It doesn't stop when one of tasks failed, to finish at least some of outputs
+                        exitOnError: false,
+                    };
+                });
+                return task.newListr(generateTasks, { concurrent: (0, os_1.cpus)().length || 1 });
+            },
+        },
+    ], {
+        rendererOptions: {
+            clearOutput: false,
+            collapseSubtasks: true,
+            formatOutput: 'wrap',
+            removeEmptyLines: false,
+        },
+        renderer: config.verbose ? 'verbose' : 'default',
+        ctx: { errors: [] },
+        silentRendererCondition: isTest || config.silent,
+        exitOnError: true,
+    });
+    // All the errors throw in `listr2` are collected in context
+    // Running tasks doesn't throw anything
+    const executedContext = await tasks.run();
+    if (config.debug) {
+        // if we have debug logs, make sure to print them before throwing the errors
+        (0, debugging_js_1.printLogs)();
+    }
+    let error = null;
+    if (executedContext.errors.length > 0) {
+        const errors = executedContext.errors.map(subErr => subErr.message || subErr.toString());
+        error = new AggregateError(executedContext.errors, String(errors.join('\n\n')));
+        // Best-effort to all stack traces for debugging
+        error.stack = `${error.stack}\n\n${executedContext.errors.map(subErr => subErr.stack).join('\n\n')}`;
+    }
+    return { result, error };
+}