@depup/graphql-codegen__cli 6.2.1-depup.0

package/esm/utils/watcher.js

@@ -0,0 +1,239 @@
+import { join, isAbsolute, relative, resolve, sep } from 'path';
+import { normalizeOutputParam } from '@graphql-codegen/plugin-helpers';
+import debounce from 'debounce';
+import mm from 'micromatch';
+import logSymbols from 'log-symbols';
+import { executeCodegen } from '../codegen.js';
+import { loadContext } from '../config.js';
+import { lifecycleHooks } from '../hooks.js';
+import { access } from './file-system.js';
+import { debugLog } from './debugging.js';
+import { getLogger } from './logger.js';
+import { allAffirmativePatternsFromPatternSets, makeGlobalPatternSet, makeLocalPatternSet, makeShouldRebuild, } from './patterns.js';
+import { AbortController } from './abort-controller-polyfill.js';
+function log(msg) {
+    // double spaces to inline the message with Listr
+    getLogger().info(`  ${msg}`);
+}
+function emitWatching(watchDir) {
+    log(`${logSymbols.info} Watching for changes in ${watchDir}...`);
+}
+export const createWatcher = (initialContext, onNext) => {
+    debugLog(`[Watcher] Starting watcher...`);
+    let config = initialContext.getConfig();
+    const globalPatternSet = makeGlobalPatternSet(initialContext);
+    const localPatternSets = Object.keys(config.generates)
+        .map(filename => normalizeOutputParam(config.generates[filename]))
+        .map(conf => makeLocalPatternSet(conf));
+    const allAffirmativePatterns = allAffirmativePatternsFromPatternSets([globalPatternSet, ...localPatternSets]);
+    const shouldRebuild = makeShouldRebuild({ globalPatternSet, localPatternSets });
+    let watcherSubscription;
+    const runWatcher = async (abortSignal) => {
+        const watchDirectory = await findHighestCommonDirectory(allAffirmativePatterns);
+        // Try to load the parcel watcher, but don't fail if it's not available.
+        let parcelWatcher;
+        try {
+            parcelWatcher = await import('@parcel/watcher');
+        }
+        catch {
+            log('Failed to import @parcel/watcher.\n  To use watch mode, install https://www.npmjs.com/package/@parcel/watcher.');
+            return;
+        }
+        debugLog(`[Watcher] Parcel watcher loaded...`);
+        let isShutdown = false;
+        const debouncedExec = debounce(() => {
+            if (!isShutdown) {
+                executeCodegen(initialContext)
+                    .then(({ result, error }) => {
+                    // FIXME: this is a quick fix to stop `onNext` (writeOutput) from
+                    // removing all files when there is an error.
+                    //
+                    // This is because `removeStaleFiles()` will remove files if the
+                    // generated files are different between runs. And on error, it
+                    // returns an empty array i.e. will remove all generated files from
+                    // the previous run
+                    //
+                    // This also means we don't have config.allowPartialOutputs in watch mode
+                    if (error) {
+                        return;
+                    }
+                    onNext(result);
+                }, () => Promise.resolve())
+                    .then(() => emitWatching(watchDirectory));
+            }
+        }, 100);
+        emitWatching(watchDirectory);
+        const ignored = ['**/.git/**'];
+        for (const entry of Object.keys(config.generates).map(filename => ({
+            filename,
+            config: normalizeOutputParam(config.generates[filename]),
+        }))) {
+            // ParcelWatcher expects relative ignore patterns to be relative from watchDirectory,
+            // but we expect filename from config to be relative from cwd, so we need to convert
+            const filenameRelativeFromWatchDirectory = relative(watchDirectory, resolve(process.cwd(), entry.filename));
+            if (entry.config.preset) {
+                const extension = entry.config.presetConfig?.extension;
+                if (extension) {
+                    ignored.push(join(filenameRelativeFromWatchDirectory, '**', '*' + extension));
+                }
+            }
+            else {
+                ignored.push(filenameRelativeFromWatchDirectory);
+            }
+        }
+        watcherSubscription = await parcelWatcher.subscribe(watchDirectory, async (_, events) => {
+            // it doesn't matter what has changed, need to run whole process anyway
+            await Promise.all(
+            // NOTE: @parcel/watcher always provides path as an absolute path
+            events.map(async ({ type: eventName, path }) => {
+                if (!shouldRebuild({ path })) {
+                    return;
+                }
+                lifecycleHooks(config.hooks).onWatchTriggered(eventName, path);
+                debugLog(`[Watcher] triggered due to a file ${eventName} event: ${path}`);
+                // In ESM require is not defined
+                try {
+                    delete require.cache[path];
+                }
+                catch { }
+                if (eventName === 'update' && config.configFilePath && path === config.configFilePath) {
+                    log(`${logSymbols.info} Config file has changed, reloading...`);
+                    const context = await loadContext(config.configFilePath);
+                    const newParsedConfig = context.getConfig();
+                    newParsedConfig.watch = config.watch;
+                    newParsedConfig.silent = config.silent;
+                    newParsedConfig.overwrite = config.overwrite;
+                    newParsedConfig.configFilePath = config.configFilePath;
+                    config = newParsedConfig;
+                    initialContext.updateConfig(config);
+                }
+                debouncedExec();
+            }));
+        }, { ignore: ignored });
+        debugLog(`[Watcher] Started`);
+        const shutdown = (
+        /** Optional callback to execute after shutdown has completed its async tasks */
+        afterShutdown) => {
+            isShutdown = true;
+            debugLog(`[Watcher] Shutting down`);
+            log(`Shutting down watch...`);
+            const pendingUnsubscribe = watcherSubscription.unsubscribe();
+            const pendingBeforeDoneHook = lifecycleHooks(config.hooks).beforeDone();
+            if (afterShutdown && typeof afterShutdown === 'function') {
+                Promise.allSettled([pendingUnsubscribe, pendingBeforeDoneHook]).then(afterShutdown);
+            }
+        };
+        abortSignal.addEventListener('abort', () => shutdown(abortSignal.reason));
+        process.once('SIGINT', () => shutdown());
+        process.once('SIGTERM', () => shutdown());
+    };
+    // Use an AbortController for shutdown signals
+    // NOTE: This will be polyfilled on Node 14 (or any environment without it defined)
+    const abortController = new AbortController();
+    /**
+     * Send shutdown signal and return a promise that only resolves after the
+     * runningWatcher has resolved, which only resolved after the shutdown signal has been handled
+     */
+    const stopWatching = async function () {
+        // stopWatching.afterShutdown is lazily set to resolve pendingShutdown promise
+        abortController.abort(stopWatching.afterShutdown);
+        // SUBTLE: runningWatcher waits for pendingShutdown before it resolves itself, so
+        // by awaiting it here, we are awaiting both the shutdown handler, and runningWatcher itself
+        await stopWatching.runningWatcher;
+    };
+    stopWatching.afterShutdown = () => {
+        debugLog('Shutdown watcher before it started');
+    };
+    stopWatching.runningWatcher = Promise.resolve();
+    /** Promise will resolve after the shutdown() handler completes */
+    const pendingShutdown = new Promise(afterShutdown => {
+        // afterShutdown will be passed to shutdown() handler via abortSignal.reason
+        stopWatching.afterShutdown = afterShutdown;
+    });
+    /**
+     * Promise that resolves after the watch server has shutdown, either because
+     * stopWatching() was called or there was an error inside it
+     */
+    stopWatching.runningWatcher = new Promise((resolve, reject) => {
+        executeCodegen(initialContext)
+            .then(({ result, error }) => {
+            // TODO: this is the initial run, the logic here mimics the above watcher logic.
+            // We need to check whether it's ok to deviate between these two.
+            if (error) {
+                return;
+            }
+            onNext(result);
+        }, () => Promise.resolve())
+            .then(() => runWatcher(abortController.signal))
+            .catch(err => {
+            watcherSubscription.unsubscribe();
+            reject(err);
+        })
+            .then(() => pendingShutdown)
+            .finally(() => {
+            debugLog('Done watching.');
+            resolve();
+        });
+    });
+    return {
+        stopWatching,
+        runningWatcher: stopWatching.runningWatcher,
+    };
+};
+/**
+ * Given a list of file paths (each of which may be absolute, or relative from
+ * `process.cwd()`), find absolute path of the "highest" common directory,
+ * i.e. the directory that contains all the files in the list.
+ *
+ * @param files List of relative and/or absolute file paths (or micromatch patterns)
+ */
+const findHighestCommonDirectory = async (files) => {
+    // Map files to a list of basePaths, where "base" is the result of mm.scan(pathOrPattern)
+    // e.g. mm.scan("/**/foo/bar").base -> "/" ; mm.scan("/foo/bar/**/fizz/*.graphql") -> /foo/bar
+    const dirPaths = files
+        .map(filePath => (isAbsolute(filePath) ? filePath : resolve(filePath)))
+        // mm.scan doesn't know how to handle Windows \ path separator
+        .map(patterned => patterned.replace(/\\/g, '/'))
+        .map(patterned => mm.scan(patterned).base)
+        // revert the separators to the platform-supported ones
+        .map(base => base.replace(/\//g, sep));
+    // Return longest common prefix if it's accessible, otherwise process.cwd()
+    return (async (maybeValidPath) => {
+        debugLog(`[Watcher] Longest common prefix of all files: ${maybeValidPath}...`);
+        try {
+            await access(maybeValidPath);
+            return maybeValidPath;
+        }
+        catch {
+            log(`[Watcher] Longest common prefix (${maybeValidPath}) is not accessible`);
+            log(`[Watcher] Watching current working directory (${process.cwd()}) instead`);
+            return process.cwd();
+        }
+    })(longestCommonPrefix(dirPaths.map(path => path.split(sep))).join(sep));
+};
+/**
+ * Find the longest common prefix of an array of paths, where each item in
+ * the array an array of path segments which comprise an absolute path when
+ * joined together by a path separator
+ *
+ * Adapted from:
+ * https://duncan-mcardle.medium.com/leetcode-problem-14-longest-common-prefix-javascript-3bc6a2f777c4
+ *
+ * @param splitPaths An array of arrays, where each item is a path split by its separator
+ * @returns An array of path segments representing the longest common prefix of splitPaths
+ */
+const longestCommonPrefix = (splitPaths) => {
+    // Return early on empty input
+    if (!splitPaths.length) {
+        return [];
+    }
+    // Loop through the segments of the first path
+    for (let i = 0; i <= splitPaths[0].length; i++) {
+        // Check if this path segment is present in the same position of every path
+        if (!splitPaths.every(string => string[i] === splitPaths[0][i])) {
+            // If not, return the path segments up to and including the previous segment
+            return splitPaths[0].slice(0, i);
+        }
+    }
+    return splitPaths[0];
+};

package/package.json

@@ -0,0 +1,205 @@
+{
+  "name": "@depup/graphql-codegen__cli",
+  "version": "6.2.1-depup.0",
+  "peerDependenciesMeta": {
+    "@parcel/watcher": {
+      "optional": true
+    }
+  },
+  "peerDependencies": {
+    "@parcel/watcher": "^2.1.0",
+    "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
+  },
+  "dependencies": {
+    "@babel/generator": "^7.29.1",
+    "@babel/template": "^7.28.6",
+    "@babel/types": "^7.29.0",
+    "@graphql-codegen/client-preset": "^5.2.4",
+    "@graphql-codegen/core": "^5.0.1",
+    "@graphql-codegen/plugin-helpers": "^6.2.0",
+    "@graphql-tools/apollo-engine-loader": "^8.0.28",
+    "@graphql-tools/code-file-loader": "^8.1.28",
+    "@graphql-tools/git-loader": "^8.0.32",
+    "@graphql-tools/github-loader": "^9.0.6",
+    "@graphql-tools/graphql-file-loader": "^8.1.12",
+    "@graphql-tools/json-file-loader": "^8.0.26",
+    "@graphql-tools/load": "^8.1.8",
+    "@graphql-tools/url-loader": "^9.0.6",
+    "@graphql-tools/merge": "^9.1.7",
+    "@graphql-tools/utils": "^11.0.0",
+    "@inquirer/prompts": "^8.3.2",
+    "@whatwg-node/fetch": "^0.10.13",
+    "chalk": "^5.6.2",
+    "cosmiconfig": "^9.0.1",
+    "debounce": "^3.0.0",
+    "detect-indent": "^7.0.2",
+    "graphql-config": "^5.1.6",
+    "is-glob": "^4.0.3",
+    "jiti": "^2.6.1",
+    "json-to-pretty-yaml": "^1.2.2",
+    "listr2": "^10.2.1",
+    "log-symbols": "^7.0.1",
+    "micromatch": "^4.0.8",
+    "shell-quote": "^1.8.3",
+    "string-env-interpolation": "^1.0.1",
+    "ts-log": "^2.2.7",
+    "tslib": "^2.8.1",
+    "yaml": "^2.8.2",
+    "yargs": "^18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dotansimha/graphql-code-generator.git",
+    "directory": "packages/graphql-codegen-cli"
+  },
+  "homepage": "https://github.com/dotansimha/graphql-code-generator#readme",
+  "keywords": [
+    "depup",
+    "dependency-bumped",
+    "updated-deps",
+    "@graphql-codegen/cli",
+    "gql",
+    "generator",
+    "code",
+    "types",
+    "interfaces",
+    "graphql",
+    "codegen",
+    "apollo",
+    "node",
+    "typescript",
+    "ts",
+    "flow",
+    "d.ts",
+    "typings"
+  ],
+  "author": "Dotan Simha <dotansimha@gmail.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=16"
+  },
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "gql-gen": "cjs/bin.js",
+    "graphql-codegen": "cjs/bin.js",
+    "graphql-code-generator": "cjs/bin.js",
+    "graphql-codegen-esm": "esm/bin.js"
+  },
+  "description": "[DepUp] Dependency-bumped version of @graphql-codegen/cli",
+  "depup": {
+    "changes": {
+      "@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"
+      }
+    },
+    "depsUpdated": 21,
+    "originalPackage": "@graphql-codegen/cli",
+    "originalVersion": "6.2.1",
+    "processedAt": "2026-03-17T16:31:36.885Z",
+    "smokeTest": "passed"
+  }
+}

package/typings/bin.d.cts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/typings/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/typings/cli.d.cts

@@ -0,0 +1,2 @@
+export declare function runCli(cmd: string): Promise<number>;
+export declare function ensureGraphQlPackage(): Promise<void>;

package/typings/cli.d.ts

@@ -0,0 +1,2 @@
+export declare function runCli(cmd: string): Promise<number>;
+export declare function ensureGraphQlPackage(): Promise<void>;

package/typings/codegen.d.cts

@@ -0,0 +1,6 @@
+import { Types } from '@graphql-codegen/plugin-helpers';
+import { CodegenContext } from './config.cjs';
+export declare function executeCodegen(input: CodegenContext | Types.Config): Promise<{
+    result: Types.FileOutput[];
+    error: Error | null;
+}>;

package/typings/codegen.d.ts

@@ -0,0 +1,6 @@
+import { Types } from '@graphql-codegen/plugin-helpers';
+import { CodegenContext } from './config.js';
+export declare function executeCodegen(input: CodegenContext | Types.Config): Promise<{
+    result: Types.FileOutput[];
+    error: Error | null;
+}>;

package/typings/config.d.cts

@@ -0,0 +1,152 @@
+import { Profiler, Types } from '@graphql-codegen/plugin-helpers';
+import { GraphQLSchema } from 'graphql';
+import { GraphQLConfig } from 'graphql-config';
+export type CodegenConfig = Types.Config;
+export type YamlCliFlags = {
+    config: string;
+    watch: boolean | string | string[];
+    require: string[];
+    overwrite: boolean;
+    project: string;
+    silent: boolean;
+    errorsOnly: boolean;
+    profile: boolean;
+    check?: boolean;
+    verbose?: boolean;
+    debug?: boolean;
+    ignoreNoDocuments?: boolean;
+    emitLegacyCommonJSImports?: boolean;
+    importExtension?: '' | `.${string}`;
+};
+export declare function generateSearchPlaces(moduleName: string): string[];
+export type CodegenConfigLoader = (filepath: string, content: string) => Promise<Types.Config> | Types.Config;
+export interface LoadCodegenConfigOptions {
+    /**
+     * The path to the config file or directory contains the config file.
+     * @default process.cwd()
+     */
+    configFilePath?: string;
+    /**
+     * The name of the config file
+     * @default codegen
+     */
+    moduleName?: string;
+    /**
+     * Additional search paths for the config file you want to check
+     */
+    searchPlaces?: string[];
+    /**
+     * @default codegen
+     */
+    packageProp?: string;
+    /**
+     * Overrides or extends the loaders for specific file extensions
+     */
+    loaders?: Record<string, CodegenConfigLoader>;
+}
+export interface LoadCodegenConfigResult {
+    filepath: string;
+    config: Types.Config;
+    isEmpty?: boolean;
+}
+export declare function loadCodegenConfig({ configFilePath, moduleName, searchPlaces: additionalSearchPlaces, packageProp, loaders: customLoaders, }: LoadCodegenConfigOptions): Promise<LoadCodegenConfigResult>;
+export declare function loadContext(configFilePath?: string): Promise<CodegenContext> | never;
+export declare function buildOptions(): {
+    c: {
+        alias: string;
+        type: "string";
+        describe: string;
+    };
+    w: {
+        alias: string;
+        describe: string;
+        coerce(watch: any): string | boolean | any[];
+    };
+    r: {
+        alias: string;
+        describe: string;
+        type: "array";
+        default: any[];
+    };
+    o: {
+        alias: string;
+        describe: string;
+        type: "boolean";
+    };
+    s: {
+        alias: string;
+        describe: string;
+        type: "boolean";
+    };
+    e: {
+        alias: string;
+        describe: string;
+        type: "boolean";
+    };
+    profile: {
+        describe: string;
+        type: "boolean";
+    };
+    p: {
+        alias: string;
+        describe: string;
+        type: "string";
+    };
+    v: {
+        alias: string;
+        describe: string;
+        type: "boolean";
+        default: boolean;
+    };
+    d: {
+        alias: string;
+        describe: string;
+        type: "boolean";
+        default: boolean;
+    };
+    'emit-legacy-common-js-imports': {
+        describe: string;
+        type: "boolean";
+    };
+    'import-extension': {
+        describe: string;
+        type: "string";
+    };
+    'ignore-no-documents': {
+        describe: string;
+        type: "boolean";
+    };
+};
+export declare function parseArgv(argv?: string[]): YamlCliFlags;
+export declare function createContext(cliFlags?: YamlCliFlags): Promise<CodegenContext>;
+export declare function updateContextWithCliFlags(context: CodegenContext, cliFlags: YamlCliFlags): void;
+export declare class CodegenContext {
+    private _config;
+    private _graphqlConfig?;
+    private config;
+    private _project?;
+    private _checkMode;
+    private _pluginContext;
+    cwd: string;
+    filepath: string;
+    profiler: Profiler;
+    profilerOutput?: string;
+    checkModeStaleFiles: any[];
+    constructor({ config, graphqlConfig, filepath, }: {
+        config?: Types.Config;
+        graphqlConfig?: GraphQLConfig;
+        filepath?: string;
+    });
+    useProject(name?: string): void;
+    getConfig<T>(extraConfig?: T): T & Types.Config;
+    updateConfig(config: Partial<Types.Config>): void;
+    enableCheckMode(): void;
+    get checkMode(): boolean;
+    useProfiler(): void;
+    getPluginContext(): {
+        [key: string]: any;
+    };
+    loadSchema(pointer: Types.Schema | Types.Schema[]): Promise<GraphQLSchema>;
+    loadDocuments(pointer: Types.OperationDocument[]): Promise<Types.DocumentFile[]>;
+}
+export declare function ensureContext(input: CodegenContext | Types.Config): CodegenContext;