@depup/graphql-codegen__cli 6.2.1-depup.0

package/esm/load.js

@@ -0,0 +1,97 @@
+import { extname, join } from 'path';
+import { ApolloEngineLoader } from '@graphql-tools/apollo-engine-loader';
+import { CodeFileLoader } from '@graphql-tools/code-file-loader';
+import { GitLoader } from '@graphql-tools/git-loader';
+import { GithubLoader } from '@graphql-tools/github-loader';
+import { GraphQLFileLoader } from '@graphql-tools/graphql-file-loader';
+import { JsonFileLoader } from '@graphql-tools/json-file-loader';
+import { loadDocuments as loadDocumentsToolkit, loadSchema as loadSchemaToolkit, NoTypeDefinitionsFound, } from '@graphql-tools/load';
+import { UrlLoader } from '@graphql-tools/url-loader';
+import { GraphQLError } from 'graphql';
+export const defaultSchemaLoadOptions = {
+    assumeValidSDL: true,
+    sort: true,
+    convertExtensions: true,
+    includeSources: true,
+};
+export const defaultDocumentsLoadOptions = {
+    sort: true,
+    skipGraphQLImport: true,
+};
+export async function loadSchema(schemaPointers, config) {
+    try {
+        const loaders = [
+            new CodeFileLoader(),
+            new GitLoader(),
+            new GithubLoader(),
+            new GraphQLFileLoader(),
+            new JsonFileLoader(),
+            new UrlLoader(),
+            new ApolloEngineLoader(),
+        ];
+        const schema = await loadSchemaToolkit(schemaPointers, {
+            ...defaultSchemaLoadOptions,
+            loaders,
+            ...config,
+            ...config.config,
+        });
+        return schema;
+    }
+    catch (e) {
+        throw new Error([
+            `Failed to load schema from ${Object.keys(schemaPointers).join(',')}:`,
+            printError(e),
+            '\nGraphQL Code Generator supports:',
+            '\n- ES Modules and CommonJS exports (export as default or named export "schema")',
+            '- Introspection JSON File',
+            '- URL of GraphQL endpoint',
+            '- Multiple files with type definitions (glob expression)',
+            '- String in config file',
+            '\nTry to use one of above options and run codegen again.\n',
+        ].join('\n'));
+    }
+}
+export async function loadDocuments(documentPointers, config) {
+    const loaders = [
+        new CodeFileLoader({
+            pluckConfig: {
+                skipIndent: true,
+            },
+        }),
+        new GitLoader(),
+        new GithubLoader(),
+        new GraphQLFileLoader(),
+    ];
+    const ignore = [];
+    for (const generatePath of Object.keys(config.generates)) {
+        if (extname(generatePath) === '') {
+            // we omit paths that don't resolve to a specific file
+            continue;
+        }
+        ignore.push(join(process.cwd(), generatePath));
+    }
+    try {
+        const loadedFromToolkit = await loadDocumentsToolkit(documentPointers, {
+            ...defaultDocumentsLoadOptions,
+            ignore,
+            loaders,
+            ...config,
+            ...config.config,
+        });
+        return loadedFromToolkit;
+    }
+    catch (error) {
+        // NoTypeDefinitionsFound from `@graphql-tools/load` already has a message with pointer, so we can just rethrow the error
+        if (error instanceof NoTypeDefinitionsFound) {
+            throw error;
+        }
+        // For other errors, we need to add an error message with documentPointers, so it's better for DevX
+        throw new Error([`Failed to load documents from ${Object.keys(documentPointers).join(',')}:`, printError(error)].join('\n'));
+    }
+}
+const printError = (error) => {
+    if (error instanceof GraphQLError) {
+        return String(error);
+    }
+    return [String(error.message || error), String(error.stack)].join('\n');
+};

package/esm/plugins.js

@@ -0,0 +1,40 @@
+import { resolve } from 'path';
+export async function getPluginByName(name, pluginLoader) {
+    const possibleNames = [
+        `@graphql-codegen/${name}`,
+        `@graphql-codegen/${name}-template`,
+        `@graphql-codegen/${name}-plugin`,
+        `graphql-codegen-${name}`,
+        `graphql-codegen-${name}-template`,
+        `graphql-codegen-${name}-plugin`,
+        `codegen-${name}`,
+        `codegen-${name}-template`,
+        name,
+    ];
+    const possibleModules = possibleNames.concat(resolve(process.cwd(), name));
+    for (const moduleName of possibleModules) {
+        try {
+            return await pluginLoader(moduleName);
+        }
+        catch (err) {
+            if (err.code !== 'MODULE_NOT_FOUND' && err.code !== 'ERR_MODULE_NOT_FOUND') {
+                throw new Error(`
+              Unable to load template plugin matching '${name}'.
+              Reason:
+                ${err.message}
+            `);
+            }
+        }
+    }
+    const possibleNamesMsg = possibleNames
+        .map(name => `
+        - ${name}
+    `.trimEnd())
+        .join('');
+    throw new Error(`
+        Unable to find template plugin matching '${name}'
+        Install one of the following packages:
+
+        ${possibleNamesMsg}
+      `);
+}

package/esm/presets.js

@@ -0,0 +1,47 @@
+import { resolve } from 'path';
+export async function getPresetByName(name, loader) {
+    const possibleNames = [
+        `@graphql-codegen/${name}`,
+        `@graphql-codegen/${name}-preset`,
+        name,
+        resolve(process.cwd(), name),
+    ];
+    for (const moduleName of possibleNames) {
+        try {
+            const loaded = await loader(moduleName);
+            if (loaded?.preset) {
+                return loaded.preset;
+            }
+            if (loaded?.default) {
+                return loaded.default;
+            }
+            return loaded;
+        }
+        catch (err) {
+            if (
+            /** CJS Error code */
+            err.code !== 'MODULE_NOT_FOUND' &&
+                /** ESM Error code */
+                err.code !== 'ERR_MODULE_NOT_FOUND') {
+                throw new Error(`Unable to load preset matching ${name}
+
+              Unable to load preset matching '${name}'.
+              Reason:
+                ${err.message}
+            `);
+            }
+        }
+    }
+    const possibleNamesMsg = possibleNames
+        .map(name => `
+        - ${name}
+    `.trimEnd())
+        .join('');
+    throw new Error(`Unable to find preset matching ${name}
+
+        Unable to find preset matching '${name}'
+        Install one of the following packages:
+
+        ${possibleNamesMsg}
+      `);
+}

package/esm/utils/abort-controller-polyfill.js

@@ -0,0 +1,96 @@
+import { EventEmitter } from 'events';
+import { debugLog } from './debugging.js';
+/**
+ * Node v14 does not have AbortSignal or AbortController, so to safely use it in
+ * another module, you can import it from here.
+ *
+ * Node v14.7+ does have it, but only with flag --experimental-abortcontroller
+ *
+ * We don't actually use AbortController anywhere except in tests, but it
+ * still gets called in watcher.ts, so by polyfilling it we can avoid breaking
+ * existing installations using Node v14 without flag --experimental-abortcontroller,
+ * and we also ensure that tests continue to pass under Node v14 without any new flags.
+ *
+ * This polyfill was adapted (TypeScript-ified) from here:
+ * https://github.com/southpolesteve/node-abort-controller/blob/master/index.js
+ */
+class AbortSignalPolyfill {
+    eventEmitter;
+    onabort;
+    aborted;
+    reason;
+    constructor() {
+        this.eventEmitter = new EventEmitter();
+        this.onabort = null;
+        this.aborted = false;
+        this.reason = undefined;
+    }
+    toString() {
+        return '[object AbortSignal]';
+    }
+    get [Symbol.toStringTag]() {
+        return 'AbortSignal';
+    }
+    removeEventListener(name, handler) {
+        this.eventEmitter.removeListener(name, handler);
+    }
+    addEventListener(name, handler) {
+        this.eventEmitter.on(name, handler);
+    }
+    // @ts-expect-error No Event type in Node 14
+    dispatchEvent(type) {
+        const event = { type, target: this };
+        const handlerName = `on${event.type}`;
+        if (typeof this[handlerName] === 'function')
+            this[handlerName](event);
+        return this.eventEmitter.emit(event.type, event);
+    }
+    throwIfAborted() {
+        if (this.aborted) {
+            throw this.reason;
+        }
+    }
+    static abort(reason) {
+        const controller = new AbortController();
+        controller.abort(reason);
+        return controller.signal;
+    }
+    static timeout(time) {
+        const controller = new AbortController();
+        setTimeout(() => controller.abort(new Error('TimeoutError')), time);
+        return controller.signal;
+    }
+}
+const AbortSignal = global.AbortSignal ?? AbortSignalPolyfill;
+class AbortControllerPolyfill {
+    signal;
+    constructor() {
+        debugLog('Using polyfilled AbortController');
+        // @ts-expect-error No Event type in Node 14
+        this.signal = new AbortSignal();
+    }
+    abort(reason) {
+        if (this.signal.aborted)
+            return;
+        // @ts-expect-error Not a read only property when polyfilling
+        this.signal.aborted = true;
+        if (reason) {
+            // @ts-expect-error Not a read only property when polyfilling
+            this.signal.reason = reason;
+        }
+        else {
+            // @ts-expect-error Not a read only property when polyfilling
+            this.signal.reason = new Error('AbortError');
+        }
+        // @ts-expect-error No Event type in Node 14
+        this.signal.dispatchEvent('abort');
+    }
+    toString() {
+        return '[object AbortController]';
+    }
+    get [Symbol.toStringTag]() {
+        return 'AbortController';
+    }
+}
+const AbortController = global.AbortController ?? AbortControllerPolyfill;
+export { AbortController };

package/esm/utils/cli-error.js

@@ -0,0 +1,20 @@
+export function isListrError(err) {
+    return err.name === 'ListrError' && Array.isArray(err.errors) && err.errors.length > 0;
+}
+export function cliError(err, exitOnError = true) {
+    let msg;
+    if (err instanceof Error) {
+        msg = err;
+    }
+    else if (typeof err === 'string') {
+        msg = err;
+    }
+    else {
+        msg = JSON.stringify(err);
+    }
+    // eslint-disable-next-line no-console
+    console.error(msg);
+    if (exitOnError) {
+        process.exit(1);
+    }
+}

package/esm/utils/debugging.js

@@ -0,0 +1,17 @@
+import { getLogger } from './logger.js';
+let queue = [];
+export function debugLog(message, ...meta) {
+    queue.push({
+        message,
+        meta,
+    });
+}
+export function printLogs() {
+    for (const log of queue) {
+        getLogger().info(log.message, ...log.meta);
+    }
+    resetLogs();
+}
+export function resetLogs() {
+    queue = [];
+}

package/esm/utils/file-system.js

@@ -0,0 +1,17 @@
+import { promises, unlink as fsUnlink } from 'fs';
+const { access: fsAccess, writeFile: fsWriteFile, readFile: fsReadFile, mkdir } = promises;
+export function access(...args) {
+    return fsAccess(...args);
+}
+export function writeFile(filepath, content) {
+    return fsWriteFile(filepath, content);
+}
+export function readFile(filepath) {
+    return fsReadFile(filepath, 'utf-8');
+}
+export function unlinkFile(filePath, cb) {
+    fsUnlink(filePath, cb);
+}
+export function mkdirp(filePath) {
+    return mkdir(filePath, { recursive: true });
+}

package/esm/utils/get-latest-version.js

@@ -0,0 +1,11 @@
+import { fetch } from '@whatwg-node/fetch';
+/**
+ * Fetches the version directly from the registry instead of depending on
+ * an ESM only module as latest-version does.
+ * @param packageName
+ */
+export async function getLatestVersion(packageName) {
+    return fetch(`https://unpkg.com/${packageName}/package.json`)
+        .then(res => res.json())
+        .then(pkg => pkg.version);
+}

package/esm/utils/helpers.js

@@ -0,0 +1,9 @@
+export function isURL(str) {
+    try {
+        const url = new URL(str);
+        return !!url;
+    }
+    catch {
+        return false;
+    }
+}

package/esm/utils/logger.js

@@ -0,0 +1,18 @@
+import { dummyLogger } from 'ts-log';
+let logger;
+export function getLogger() {
+    return logger || dummyLogger;
+}
+useWinstonLogger();
+export function setLogger(newLogger) {
+    logger = newLogger;
+}
+export function setSilentLogger() {
+    logger = dummyLogger;
+}
+export function useWinstonLogger() {
+    if (logger?.levels) {
+        return;
+    }
+    logger = console;
+}

package/esm/utils/patterns.js

@@ -0,0 +1,226 @@
+import { isAbsolute, relative } from 'path';
+import { isValidPath } from '@graphql-tools/utils';
+import { normalizeInstanceOrArray } from '@graphql-codegen/plugin-helpers';
+import isGlob from 'is-glob';
+import mm from 'micromatch';
+import { isURL } from './helpers.js';
+/**
+ * Flatten a list of pattern sets to be a list of only the affirmative patterns
+ * are contained in all of them.
+ *
+ * This can be used, for example, to find the "longest common prefix directory"
+ * by examining `mm.scan(pattern).base` for each `pattern`.
+ */
+export const allAffirmativePatternsFromPatternSets = (patternSets) => {
+    return patternSets.flatMap(patternSet => [
+        ...patternSet.watch.affirmative,
+        ...patternSet.documents.affirmative,
+        ...patternSet.schemas.affirmative,
+    ]);
+};
+/**
+ * Create a rebuild trigger that follows the algorithm described here:
+ * https://github.com/dotansimha/graphql-code-generator/issues/9270#issuecomment-1496765045
+ *
+ * There is a flow chart diagram in that comment.
+ *
+ * Basically:
+ *
+ *  * "Global" patterns are defined at top level of config file, and "local"
+ *    patterns are defined for each output target
+ *  * Each pattern can have "watch", "documents", and "schemas"
+ *  * Watch patterns (global and local) always take precedence over documents and
+ *    schemas patterns, i.e. a watch negation always negates, and a watch match is
+ *    a match even if it would be negated by some pattern in documents or schemas
+ *  * The trigger returns true if any output target's local patterns result in
+ *    a match, after considering the precedence of any global and local negations
+ */
+export const makeShouldRebuild = ({ globalPatternSet, localPatternSets, }) => {
+    const localMatchers = localPatternSets.map(localPatternSet => {
+        return (path) => {
+            // Is path negated by any negating watch pattern?
+            if (matchesAnyNegatedPattern(path, [...globalPatternSet.watch.negated, ...localPatternSet.watch.negated])) {
+                // Short circut: negations in watch patterns take priority
+                return false;
+            }
+            // Does path match any affirmative watch pattern?
+            if (matchesAnyAffirmativePattern(path, [
+                ...globalPatternSet.watch.affirmative,
+                ...localPatternSet.watch.affirmative,
+            ])) {
+                // Immediately return true: Watch pattern takes priority, even if documents or schema would negate it
+                return true;
+            }
+            // Does path match documents patterns (without being negated)?
+            if (matchesAnyAffirmativePattern(path, [
+                ...globalPatternSet.documents.affirmative,
+                ...localPatternSet.documents.affirmative,
+            ]) &&
+                !matchesAnyNegatedPattern(path, [...globalPatternSet.documents.negated, ...localPatternSet.documents.negated])) {
+                return true;
+            }
+            // Does path match schemas patterns (without being negated)?
+            if (matchesAnyAffirmativePattern(path, [
+                ...globalPatternSet.schemas.affirmative,
+                ...localPatternSet.schemas.affirmative,
+            ]) &&
+                !matchesAnyNegatedPattern(path, [...globalPatternSet.schemas.negated, ...localPatternSet.schemas.negated])) {
+                return true;
+            }
+            // Otherwise, there is no match
+            return false;
+        };
+    });
+    /**
+     * Return `true` if `path` should trigger a rebuild
+     */
+    return ({ path: absolutePath }) => {
+        if (!isAbsolute(absolutePath)) {
+            throw new Error('shouldRebuild trigger should be called with absolute path');
+        }
+        const path = relative(process.cwd(), absolutePath);
+        const shouldRebuild = localMatchers.some(matcher => matcher(path));
+        return shouldRebuild;
+    };
+};
+/**
+ * Create the pattern set for the "global" (top level) config.
+ *
+ * In the `shouldRebuild` algorithm, any of these watch patterns will take
+ * precedence over local configs, and any schemas and documents patterns will be
+ * mixed into the pattern set of each local config.
+ */
+export const makeGlobalPatternSet = (initialContext) => {
+    const config = initialContext.getConfig();
+    return {
+        watch: sortPatterns([
+            ...(typeof config.watch === 'boolean' ? [] : normalizeInstanceOrArray(config.watch ?? [])),
+            relative(process.cwd(), initialContext.filepath),
+        ]),
+        schemas: sortPatterns(makePatternsFromSchemas(normalizeInstanceOrArray(config.schema))),
+        documents: sortPatterns(makePatternsFromDocuments(normalizeInstanceOrArray(config.documents))),
+    };
+};
+/**
+ * Create the pattern set for a "local" (output target) config
+ *
+ * In the `shouldRebuild` algorithm, any of these watch patterns will take
+ * precedence over documents or schemas patterns, and the documents and schemas
+ * patterns will be mixed into the pattern set of their respective gobal pattern
+ * set equivalents.
+ */
+export const makeLocalPatternSet = (conf) => {
+    return {
+        watch: sortPatterns(normalizeInstanceOrArray(conf.watchPattern)),
+        documents: sortPatterns(makePatternsFromDocuments(normalizeInstanceOrArray(conf.documents))),
+        schemas: sortPatterns(makePatternsFromSchemas(normalizeInstanceOrArray(conf.schema))),
+    };
+};
+/**
+ * Parse a list of micromatch patterns from a list of documents, which should
+ * already have been normalized from their raw config values.
+ */
+const makePatternsFromDocuments = (documents) => {
+    const patterns = [];
+    if (documents) {
+        for (const doc of documents) {
+            if (typeof doc === 'string') {
+                patterns.push(doc);
+            }
+            else {
+                patterns.push(...Object.keys(doc));
+            }
+        }
+    }
+    return patterns;
+};
+/**
+ * Parse a list of micromatch patterns from a list of schemas, which should
+ * already have been normalized from their raw config values.
+ */
+const makePatternsFromSchemas = (schemas) => {
+    const patterns = [];
+    for (const s of schemas) {
+        const schema = s;
+        if (!isURL(schema) && (isGlob(schema) || isValidPath(schema))) {
+            patterns.push(schema);
+        }
+    }
+    return patterns;
+};
+/**
+ * Given a list of micromatch patterns, sort them into `patterns` (all of them),
+ * `affirmative` (only the affirmative patterns), and `negated` (only the negated patterns)
+ *
+ * @param patterns List of micromatch patterns
+ */
+export const sortPatterns = (patterns) => ({
+    patterns,
+    affirmative: onlyAffirmativePatterns(patterns),
+    negated: onlyNegatedPatterns(patterns),
+});
+/**
+ * Filter the provided list of patterns to include only "affirmative" (non-negated) patterns.
+ *
+ * @param patterns List of micromatch patterns (or paths) to filter
+ */
+const onlyAffirmativePatterns = (patterns) => {
+    return patterns.filter(pattern => !mm.scan(pattern).negated);
+};
+/**
+ * Filter the provided list of patterns to include only negated patterns.
+ *
+ * @param patterns List of micromatch patterns (or paths) to filter
+ */
+const onlyNegatedPatterns = (patterns) => {
+    return patterns.filter(pattern => mm.scan(pattern).negated);
+};
+/**
+ * Given a list of negated patterns, invert them by removing their negation prefix
+ *
+ * If there is a non-negated pattern in the list, throw an error, because this
+ * function should only be called after filtering the list to be only negated patterns
+ *
+ * @param patterns List of negated micromatch patterns
+ */
+const invertNegatedPatterns = (patterns) => {
+    return patterns.map(pattern => {
+        const scanned = mm.scan(pattern);
+        if (!scanned.negated) {
+            throw new Error(`onlyNegatedPatterns got a non-negated pattern: ${pattern}`);
+        }
+        // Remove the leading prefix (NOTE: this is not always "!")
+        // e.g. mm.scan("!./foo/bar/never-watch.graphql").prefix === '!./'
+        return pattern.slice(scanned.prefix.length);
+    });
+};
+/**
+ * Return true if relativeCandidatePath matches any of the affirmativePatterns
+ *
+ * @param relativeCandidatePath A relative path to evaluate against the supplied affirmativePatterns
+ * @param affirmativePatterns A list of patterns, containing no negated patterns, to evaluate
+ */
+const matchesAnyAffirmativePattern = (relativeCandidatePath, affirmativePatterns) => {
+    if (isAbsolute(relativeCandidatePath)) {
+        throw new Error('matchesAny should only be called with relative candidate path');
+    }
+    // Developer error: This function is not intended to work with pattern sets including negations
+    if (affirmativePatterns.some(pattern => mm.scan(pattern).negated)) {
+        throw new Error('matchesAnyAffirmativePattern should only include affirmative patterns');
+    }
+    // micromatch.isMatch does not omit matches that are negated by negation patterns,
+    // which is why we require this function only examine affirmative patterns
+    return mm.isMatch(relativeCandidatePath, affirmativePatterns);
+};
+/**
+ * Return true if relativeCandidatePath matches any of the negatedPatterns
+ *
+ * This function will invert the negated patterns and then call matchesAnyAffirmativePattern
+ *
+ * @param relativeCandidatePath A relative path to evaluate against the suppliednegatedPatterns
+ * @param negatedPatterns A list of patterns, containing no negated patterns, to evaluate
+ */
+const matchesAnyNegatedPattern = (relativeCandidatePath, negatedPatterns) => {
+    // NOTE: No safety check that negatedPatterns contains only negated, because that will happen in invertedNegatedPatterns
+    return matchesAnyAffirmativePattern(relativeCandidatePath, invertNegatedPatterns(negatedPatterns));
+};