@depup/graphql-codegen__cli 6.2.1-depup.3 → 7.2.0-depup.8

package/cjs/graphql-config.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodegenExtension = void 0;
 exports.findAndLoadGraphQLConfig = findAndLoadGraphQLConfig;
+const graphql_config_1 = require("graphql-config");
 const apollo_engine_loader_1 = require("@graphql-tools/apollo-engine-loader");
 const code_file_loader_1 = require("@graphql-tools/code-file-loader");
 const git_loader_1 = require("@graphql-tools/git-loader");
 const github_loader_1 = require("@graphql-tools/github-loader");
-const graphql_config_1 = require("graphql-config");
 const CodegenExtension = (api) => {
     // Schema
     api.loaders.schema.register(new code_file_loader_1.CodeFileLoader({
@@ -48,10 +48,6 @@ function isGraphQLConfig(config) {
     if (!config) {
         return false;
     }
-    try {
-        return config.getDefault().hasExtension('codegen');
-    }
-    catch { }
     try {
         for (const projectName in config.projects) {
             if (Object.prototype.hasOwnProperty.call(config.projects, projectName)) {
@@ -63,5 +59,9 @@ function isGraphQLConfig(config) {
         }
     }
     catch { }
+    try {
+        return config.getDefault().hasExtension('codegen');
+    }
+    catch { }
     return false;
 }

package/cjs/init/helpers.js

@@ -8,21 +8,25 @@ exports.italic = italic;
 const tslib_1 = require("tslib");
 const fs_1 = require("fs");
 const path_1 = require("path");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const detect_indent_1 = tslib_1.__importDefault(require("detect-indent"));
 const generator_1 = tslib_1.__importDefault(require("@babel/generator"));
 const template_1 = tslib_1.__importDefault(require("@babel/template"));
 const t = tslib_1.__importStar(require("@babel/types"));
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const detect_indent_1 = tslib_1.__importDefault(require("detect-indent"));
 const get_latest_version_js_1 = require("../utils/get-latest-version.js");
 const types_js_1 = require("./types.js");
 function jsObjectToBabelObjectExpression(obj) {
     const objExp = t.objectExpression([]);
     for (const [key, val] of Object.entries(obj)) {
         if (Array.isArray(val)) {
-            objExp.properties.push(t.objectProperty(/^[a-zA-Z0-9]+$/.test(key) ? t.identifier(key) : t.stringLiteral(key), t.arrayExpression(val.map(v => (typeof v === 'object' ? jsObjectToBabelObjectExpression(v) : t.valueToNode(v))))));
+            objExp.properties.push(t.objectProperty(/^[a-zA-Z0-9]+$/.test(key) ? t.identifier(key) : t.stringLiteral(key), t.arrayExpression(val.map(v => typeof v === 'object'
+                ? jsObjectToBabelObjectExpression(v)
+                : t.valueToNode(v)))));
         }
         else {
-            objExp.properties.push(t.objectProperty(/^[a-zA-Z0-9]+$/.test(key) ? t.identifier(key) : t.stringLiteral(key), typeof val === 'object' ? jsObjectToBabelObjectExpression(val) : t.valueToNode(val)));
+            objExp.properties.push(t.objectProperty(/^[a-zA-Z0-9]+$/.test(key) ? t.identifier(key) : t.stringLiteral(key), typeof val === 'object'
+                ? jsObjectToBabelObjectExpression(val)
+                : t.valueToNode(val)));
         }
     }
     return objExp;

package/cjs/init/index.js

@@ -14,7 +14,7 @@ async function init() {
     Welcome to ${(0, helpers_js_1.bold)('GraphQL Code Generator')}!
     Answer few questions and we will setup everything for you.
   `);
-    const possibleTargets = await (0, targets_js_1.guessTargets)();
+    const possibleTargets = (0, targets_js_1.guessTargets)();
     const answers = await (0, questions_js_1.getAnswers)(possibleTargets);
     // define config
     const config = {

package/cjs/init/plugins.js

@@ -10,7 +10,9 @@ exports.plugins = [
         value: 'typescript',
         pathInRepo: 'typescript/typescript',
         available: hasTag(types_js_1.Tags.typescript),
-        shouldBeSelected: tags => oneOf(tags, types_js_1.Tags.angular, types_js_1.Tags.stencil) || allOf(tags, types_js_1.Tags.typescript, types_js_1.Tags.react) || noneOf(tags, types_js_1.Tags.flow),
+        shouldBeSelected: tags => oneOf(tags, types_js_1.Tags.angular, types_js_1.Tags.stencil) ||
+            allOf(tags, types_js_1.Tags.typescript, types_js_1.Tags.react) ||
+            noneOf(tags, types_js_1.Tags.flow),
         defaultExtension: '.ts',
     },
     {

package/cjs/init/questions.js

@@ -21,7 +21,9 @@ async function getAnswers(possibleTargets) {
             validate: str => str.length > 0,
         });
         let documents;
-        if (targets.includes(types_js_1.Tags.client) || targets.includes(types_js_1.Tags.angular) || targets.includes(types_js_1.Tags.stencil))
+        if (targets.includes(types_js_1.Tags.client) ||
+            targets.includes(types_js_1.Tags.angular) ||
+            targets.includes(types_js_1.Tags.stencil))
             documents = await (0, prompts_1.input)({
                 message: 'Where are your operations and fragments?:',
                 default: getDocumentsDefaultValue(targets),
@@ -46,7 +48,9 @@ async function getAnswers(possibleTargets) {
         });
         const config = await (0, prompts_1.input)({
             message: 'How to name the config file?',
-            default: (() => targets.includes(types_js_1.Tags.client) || targets.includes(types_js_1.Tags.typescript) || targets.includes(types_js_1.Tags.angular)
+            default: (() => targets.includes(types_js_1.Tags.client) ||
+                targets.includes(types_js_1.Tags.typescript) ||
+                targets.includes(types_js_1.Tags.angular)
                 ? 'codegen.ts'
                 : 'codegen.yml')(),
             validate: str => {
@@ -136,7 +140,10 @@ function getApplicationTypeChoices(possibleTargets) {
             name: 'Application built with other framework or vanilla JS',
             key: 'client',
             value: [types_js_1.Tags.typescript, types_js_1.Tags.flow],
-            checked: possibleTargets.Browser && !possibleTargets.Angular && !possibleTargets.React && !possibleTargets.Stencil,
+            checked: possibleTargets.Browser &&
+                !possibleTargets.Angular &&
+                !possibleTargets.React &&
+                !possibleTargets.Stencil,
         },
     ];
 }

package/cjs/init/targets.js

@@ -4,7 +4,7 @@ exports.guessTargets = guessTargets;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const types_js_1 = require("./types.js");
-async function guessTargets() {
+function guessTargets() {
     const pkg = JSON.parse((0, fs_1.readFileSync)((0, path_1.resolve)(process.cwd(), 'package.json'), 'utf8'));
     const dependencies = Object.keys({
         ...pkg.dependencies,

package/cjs/isESMModule.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isESMModule = void 0;
+/**
+ * Poor mans ESM detection.
+ * Looking at this and you have a better method?
+ * Send a PR.
+ */
+exports.isESMModule = (typeof __dirname === 'string') === false;

package/cjs/load.js

@@ -4,6 +4,7 @@ exports.defaultDocumentsLoadOptions = exports.defaultSchemaLoadOptions = void 0;
 exports.loadSchema = loadSchema;
 exports.loadDocuments = loadDocuments;
 const path_1 = require("path");
+const graphql_1 = require("graphql");
 const apollo_engine_loader_1 = require("@graphql-tools/apollo-engine-loader");
 const code_file_loader_1 = require("@graphql-tools/code-file-loader");
 const git_loader_1 = require("@graphql-tools/git-loader");
@@ -12,7 +13,6 @@ const graphql_file_loader_1 = require("@graphql-tools/graphql-file-loader");
 const json_file_loader_1 = require("@graphql-tools/json-file-loader");
 const load_1 = require("@graphql-tools/load");
 const url_loader_1 = require("@graphql-tools/url-loader");
-const graphql_1 = require("graphql");
 exports.defaultSchemaLoadOptions = {
     assumeValidSDL: true,
     sort: true,
@@ -73,7 +73,7 @@ async function loadDocuments(documentPointers, config) {
             // we omit paths that don't resolve to a specific file
             continue;
         }
-        ignore.push((0, path_1.join)(process.cwd(), generatePath));
+        ignore.push((0, path_1.join)(config.cwd || process.cwd(), generatePath));
     }
     try {
         const loadedFromToolkit = await (0, load_1.loadDocuments)(documentPointers, {
@@ -91,7 +91,10 @@ async function loadDocuments(documentPointers, config) {
             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'));
+        throw new Error([
+            `Failed to load documents from ${Object.keys(documentPointers).join(',')}:`,
+            printError(error),
+        ].join('\n'));
     }
 }
 const printError = (error) => {

package/cjs/utils/patterns.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sortPatterns = exports.makeLocalPatternSet = exports.makeGlobalPatternSet = exports.makeShouldRebuild = exports.allAffirmativePatternsFromPatternSets = void 0;
 const tslib_1 = require("tslib");
 const path_1 = require("path");
-const utils_1 = require("@graphql-tools/utils");
-const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
 const is_glob_1 = tslib_1.__importDefault(require("is-glob"));
 const micromatch_1 = tslib_1.__importDefault(require("micromatch"));
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const utils_1 = require("@graphql-tools/utils");
 const helpers_js_1 = require("./helpers.js");
 /**
  * Flatten a list of pattern sets to be a list of only the affirmative patterns
@@ -44,7 +44,10 @@ 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])) {
+            if (matchesAnyNegatedPattern(path, [
+                ...globalPatternSet.watch.negated,
+                ...localPatternSet.watch.negated,
+            ])) {
                 // Short circut: negations in watch patterns take priority
                 return false;
             }
@@ -61,7 +64,10 @@ const makeShouldRebuild = ({ globalPatternSet, localPatternSets, }) => {
                 ...globalPatternSet.documents.affirmative,
                 ...localPatternSet.documents.affirmative,
             ]) &&
-                !matchesAnyNegatedPattern(path, [...globalPatternSet.documents.negated, ...localPatternSet.documents.negated])) {
+                !matchesAnyNegatedPattern(path, [
+                    ...globalPatternSet.documents.negated,
+                    ...localPatternSet.documents.negated,
+                ])) {
                 return true;
             }
             // Does path match schemas patterns (without being negated)?
@@ -69,7 +75,10 @@ const makeShouldRebuild = ({ globalPatternSet, localPatternSets, }) => {
                 ...globalPatternSet.schemas.affirmative,
                 ...localPatternSet.schemas.affirmative,
             ]) &&
-                !matchesAnyNegatedPattern(path, [...globalPatternSet.schemas.negated, ...localPatternSet.schemas.negated])) {
+                !matchesAnyNegatedPattern(path, [
+                    ...globalPatternSet.schemas.negated,
+                    ...localPatternSet.schemas.negated,
+                ])) {
                 return true;
             }
             // Otherwise, there is no match
@@ -100,7 +109,9 @@ const makeGlobalPatternSet = (initialContext) => {
     const config = initialContext.getConfig();
     return {
         watch: (0, exports.sortPatterns)([
-            ...(typeof config.watch === 'boolean' ? [] : (0, plugin_helpers_1.normalizeInstanceOrArray)(config.watch ?? [])),
+            ...(typeof config.watch === 'boolean'
+                ? []
+                : (0, plugin_helpers_1.normalizeInstanceOrArray)(config.watch ?? [])),
             (0, path_1.relative)(process.cwd(), initialContext.filepath),
         ]),
         schemas: (0, exports.sortPatterns)(makePatternsFromSchemas((0, plugin_helpers_1.normalizeInstanceOrArray)(config.schema))),

package/cjs/utils/watcher.js

@@ -3,18 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createWatcher = void 0;
 const tslib_1 = require("tslib");
 const path_1 = require("path");
-const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
 const debounce_1 = tslib_1.__importDefault(require("debounce"));
-const micromatch_1 = tslib_1.__importDefault(require("micromatch"));
 const log_symbols_1 = tslib_1.__importDefault(require("log-symbols"));
+const micromatch_1 = tslib_1.__importDefault(require("micromatch"));
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
 const codegen_js_1 = require("../codegen.js");
 const config_js_1 = require("../config.js");
 const hooks_js_1 = require("../hooks.js");
-const file_system_js_1 = require("./file-system.js");
 const debugging_js_1 = require("./debugging.js");
+const file_system_js_1 = require("./file-system.js");
 const logger_js_1 = require("./logger.js");
 const patterns_js_1 = require("./patterns.js");
-const abort_controller_polyfill_js_1 = require("./abort-controller-polyfill.js");
 function log(msg) {
     // double spaces to inline the message with Listr
     (0, logger_js_1.getLogger)().info(`  ${msg}`);
@@ -29,8 +28,14 @@ const createWatcher = (initialContext, onNext) => {
     const localPatternSets = Object.keys(config.generates)
         .map(filename => (0, plugin_helpers_1.normalizeOutputParam)(config.generates[filename]))
         .map(conf => (0, patterns_js_1.makeLocalPatternSet)(conf));
-    const allAffirmativePatterns = (0, patterns_js_1.allAffirmativePatternsFromPatternSets)([globalPatternSet, ...localPatternSets]);
-    const shouldRebuild = (0, patterns_js_1.makeShouldRebuild)({ globalPatternSet, localPatternSets });
+    const allAffirmativePatterns = (0, patterns_js_1.allAffirmativePatternsFromPatternSets)([
+        globalPatternSet,
+        ...localPatternSets,
+    ]);
+    const shouldRebuild = (0, patterns_js_1.makeShouldRebuild)({
+        globalPatternSet,
+        localPatternSets,
+    });
     let watcherSubscription;
     const runWatcher = async (abortSignal) => {
         const watchDirectory = await findHighestCommonDirectory(allAffirmativePatterns);
@@ -133,7 +138,7 @@ const createWatcher = (initialContext, onNext) => {
     };
     // Use an AbortController for shutdown signals
     // NOTE: This will be polyfilled on Node 14 (or any environment without it defined)
-    const abortController = new abort_controller_polyfill_js_1.AbortController();
+    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

package/cjs/version.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+exports.version = '7.2.0';

package/esm/codegen.js

@@ -2,23 +2,18 @@ import fs from 'fs';
 import { createRequire } from 'module';
 import { cpus } from 'os';
 import path from 'path';
+import { buildASTSchema, GraphQLError, isSchema } from 'graphql';
+import { Listr } from 'listr2';
 import { codegen } from '@graphql-codegen/core';
 import { getCachedDocumentNodeFromSchema, normalizeConfig, normalizeImportExtension, normalizeInstanceOrArray, normalizeOutputParam, } from '@graphql-codegen/plugin-helpers';
 import { NoTypeDefinitionsFound } from '@graphql-tools/load';
-import { buildASTSchema, GraphQLError, isSchema } from 'graphql';
 import { mergeTypeDefs } from '@graphql-tools/merge';
-import { Listr } from 'listr2';
 import { ensureContext } from './config.js';
+import { getDocumentTransform } from './documentTransforms.js';
+import { isESMModule } from './isESMModule.js';
 import { getPluginByName } from './plugins.js';
 import { getPresetByName } from './presets.js';
 import { debugLog, printLogs } from './utils/debugging.js';
-import { getDocumentTransform } from './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.statSync(from).isDirectory()) {
         from = path.join(from, '__fake.js');
@@ -31,6 +26,8 @@ const makeDefaultLoader = (from) => {
                * as import.meta is unavailable in a CommonJS context
                * and furthermore unavailable in stable Node.js.
                **/
+                // FIXME(pnpm-update): this causes dev-test devDeps to be brought into CLI's package.json, which is not ideal.
+                // Note that `relativeRequire.resolve(mod)` seems to work correctly for ESM as well.
                 mod
             : relativeRequire.resolve(mod));
     };
@@ -56,6 +53,7 @@ export async function executeCodegen(input) {
     let rootConfig = {};
     let rootSchemas;
     let rootDocuments;
+    let rootExternalDocuments;
     const generates = {};
     const cache = createCache();
     // We need a simple string to uniqually identify the provided GraphQLSchema objects for the above cache.
@@ -97,6 +95,8 @@ export async function executeCodegen(input) {
         rootSchemas = normalizeInstanceOrArray(config.schema);
         /* Normalize root "documents" field */
         rootDocuments = normalizeInstanceOrArray(config.documents);
+        /* Normalize root "externalDocuments" field */
+        rootExternalDocuments = normalizeInstanceOrArray(config.externalDocuments);
         /* Normalize "generators" field */
         const generateKeys = Object.keys(config.generates || {});
         if (generateKeys.length === 0) {
@@ -169,9 +169,10 @@ export async function executeCodegen(input) {
                             let outputSchemaAst;
                             let outputSchema;
                             const outputFileTemplateConfig = outputConfig.config || {};
-                            let outputDocuments = [];
+                            const outputDocuments = [];
                             const outputSpecificSchemas = normalizeInstanceOrArray(outputConfig.schema);
                             let outputSpecificDocuments = normalizeInstanceOrArray(outputConfig.documents);
+                            let outputSpecificExternalDocuments = normalizeInstanceOrArray(outputConfig.externalDocuments);
                             const preset = hasPreset
                                 ? typeof outputConfig.preset === 'string'
                                     ? await getPresetByName(outputConfig.preset, makeDefaultLoader(context.cwd))
@@ -179,6 +180,7 @@ export async function executeCodegen(input) {
                                 : null;
                             if (preset?.prepareDocuments) {
                                 outputSpecificDocuments = await preset.prepareDocuments(filename, outputSpecificDocuments);
+                                outputSpecificExternalDocuments = await preset.prepareDocuments(filename, outputSpecificExternalDocuments);
                             }
                             return subTask.newListr([
                                 {
@@ -187,7 +189,10 @@ export async function executeCodegen(input) {
                                         debugLog(`[CLI] Loading Schemas`);
                                         const schemaPointerMap = {};
                                         const parsedSchemas = [];
-                                        const allSchemaDenormalizedPointers = [...rootSchemas, ...outputSpecificSchemas];
+                                        const allSchemaDenormalizedPointers = [
+                                            ...rootSchemas,
+                                            ...outputSpecificSchemas,
+                                        ];
                                         for (const denormalizedPtr of allSchemaDenormalizedPointers) {
                                             if (isSchema(denormalizedPtr)) {
                                                 parsedSchemas.push(denormalizedPtr);
@@ -199,7 +204,8 @@ export async function executeCodegen(input) {
                                                 Object.assign(schemaPointerMap, denormalizedPtr);
                                             }
                                         }
-                                        const hash = JSON.stringify(schemaPointerMap) + parsedSchemas.map(getJsObjectId).join(',');
+                                        const hash = JSON.stringify(schemaPointerMap) +
+                                            parsedSchemas.map(getJsObjectId).join(',');
                                         const result = await cache('schema', hash, async () => {
                                             // collect parsed schemas
                                             const schemasToMerge = [...parsedSchemas];
@@ -225,34 +231,74 @@ export async function executeCodegen(input) {
                                     title: 'Load GraphQL documents',
                                     task: wrapTask(async () => {
                                         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 populateDocumentPointerMap = (allDocumentsDenormalizedPointers) => {
+                                            const pointer = {};
+                                            for (const denormalizedPtr of allDocumentsDenormalizedPointers) {
+                                                if (typeof denormalizedPtr === 'string') {
+                                                    pointer[denormalizedPtr] = {};
+                                                }
+                                                else if (typeof denormalizedPtr === 'object') {
+                                                    Object.assign(pointer, denormalizedPtr);
+                                                }
                                             }
-                                        }
+                                            return pointer;
+                                        };
+                                        const allDocumentsDenormalizedPointers = [
+                                            ...rootDocuments,
+                                            ...outputSpecificDocuments,
+                                        ];
+                                        const documentPointerMap = populateDocumentPointerMap(allDocumentsDenormalizedPointers);
                                         const hash = JSON.stringify(documentPointerMap);
-                                        const result = await cache('documents', hash, async () => {
+                                        const outputDocumentsStandard = await cache('documents', hash, async () => {
                                             try {
-                                                const documents = await context.loadDocuments(documentPointerMap);
-                                                return {
-                                                    documents,
-                                                };
+                                                const documents = await context.loadDocuments(documentPointerMap, 'standard');
+                                                return documents;
                                             }
                                             catch (error) {
-                                                if (error instanceof NoTypeDefinitionsFound && config.ignoreNoDocuments) {
-                                                    return {
-                                                        documents: [],
-                                                    };
+                                                if (error instanceof NoTypeDefinitionsFound &&
+                                                    config.ignoreNoDocuments) {
+                                                    return [];
                                                 }
                                                 throw error;
                                             }
                                         });
-                                        outputDocuments = result.documents;
+                                        const allExternalDocumentsDenormalizedPointers = [
+                                            ...rootExternalDocuments,
+                                            ...outputSpecificExternalDocuments,
+                                        ];
+                                        const externalDocumentsPointerMap = populateDocumentPointerMap(allExternalDocumentsDenormalizedPointers);
+                                        const externalDocumentHash = JSON.stringify(externalDocumentsPointerMap);
+                                        const outputExternalDocuments = await cache('documents', externalDocumentHash, async () => {
+                                            try {
+                                                const documents = await context.loadDocuments(externalDocumentsPointerMap, 'external');
+                                                return documents;
+                                            }
+                                            catch (error) {
+                                                if (error instanceof NoTypeDefinitionsFound &&
+                                                    config.ignoreNoDocuments) {
+                                                    return [];
+                                                }
+                                                throw error;
+                                            }
+                                        });
+                                        /**
+                                         * Merging `standard` and `external` documents here,
+                                         * so they can be processed the same way,
+                                         * before passed into presets and plugins
+                                         */
+                                        const processedFile = {};
+                                        const mergedDocuments = [
+                                            ...outputDocumentsStandard,
+                                            ...outputExternalDocuments,
+                                        ];
+                                        for (const file of mergedDocuments) {
+                                            const fileIdentifier = (file.location || '') + (file.hash || '');
+                                            if (processedFile[fileIdentifier]) {
+                                                continue;
+                                            }
+                                            outputDocuments.push(file);
+                                            processedFile[fileIdentifier] = true;
+                                        }
                                     }, filename, `Load GraphQL documents: ${filename}`, ctx),
                                 },
                                 {
@@ -351,7 +397,9 @@ export async function executeCodegen(input) {
                         exitOnError: false,
                     };
                 });
-                return task.newListr(generateTasks, { concurrent: cpus().length || 1 });
+                return task.newListr(generateTasks, {
+                    concurrent: cpus().length || 1,
+                });
             },
         },
     ], {
@@ -378,7 +426,9 @@ export async function executeCodegen(input) {
         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')}`;
+        error.stack = `${error.stack}\n\n${executedContext.errors
+            .map(subErr => subErr.stack)
+            .join('\n\n')}`;
     }
     return { result, error };
 }

package/esm/config.js

@@ -1,16 +1,19 @@
 import { createHash } from 'crypto';
 import { promises } from 'fs';
 import { createRequire } from 'module';
+import * as url from 'node:url';
 import { resolve } from 'path';
-import { createNoopProfiler, createProfiler, getCachedDocumentNodeFromSchema, } from '@graphql-codegen/plugin-helpers';
 import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
-import { createJiti } from 'jiti';
 import { print } from 'graphql';
+import { createJiti } from 'jiti';
 import { env } from 'string-env-interpolation';
 import yaml from 'yaml';
 import yargs from 'yargs';
+import { createNoopProfiler, createProfiler, getCachedDocumentNodeFromSchema, } from '@graphql-codegen/plugin-helpers';
 import { findAndLoadGraphQLConfig } from './graphql-config.js';
-import { defaultDocumentsLoadOptions, defaultSchemaLoadOptions, loadDocuments, loadSchema } from './load.js';
+import { isESMModule } from './isESMModule.js';
+import { defaultDocumentsLoadOptions, defaultSchemaLoadOptions, loadDocuments, loadSchema, } from './load.js';
+import { version } from './version.js';
 const { lstat } = promises;
 export function generateSearchPlaces(moduleName) {
     const extensions = ['json', 'yaml', 'yml', 'js', 'ts', 'config.js'];
@@ -180,12 +183,12 @@ export function buildOptions() {
     };
 }
 export function parseArgv(argv = process.argv) {
-    return yargs(argv).options(buildOptions()).parse(argv);
+    return yargs(argv).version(version).options(buildOptions()).parse(argv);
 }
 export async function createContext(cliFlags = parseArgv(process.argv)) {
     if (cliFlags.require && cliFlags.require.length > 0) {
         const relativeRequire = createRequire(process.cwd());
-        await Promise.all(cliFlags.require.map(mod => import(relativeRequire.resolve(mod, {
+        await Promise.all(cliFlags.require.map(mod => safeDynamicImport(relativeRequire.resolve(mod, {
             paths: [process.cwd()],
         }))));
     }
@@ -254,7 +257,7 @@ export class CodegenContext {
         this._config = config;
         this._graphqlConfig = graphqlConfig;
         this.filepath = this._graphqlConfig ? this._graphqlConfig.filepath : filepath;
-        this.cwd = this._graphqlConfig ? this._graphqlConfig.dirpath : process.cwd();
+        this.cwd = this._graphqlConfig ? this._graphqlConfig.dirpath : config?.cwd || process.cwd();
         this.profiler = createNoopProfiler();
     }
     useProject(name) {
@@ -275,10 +278,18 @@ export class CodegenContext {
                 this.config = { ...this._config, pluginContext: this._pluginContext };
             }
         }
-        return {
+        const config = {
+            noSilentErrors: true, // When a `documents` pattern matches multiple files e.g. `*` exists in filename like `src/something.*.ts`, and some files fail but some pass syntax error check, the failed files will silently fail if `noSilentErrors: false`. So, `noSilentErrors: true` is turned on by default to help users detect errors faster.
             ...extraConfig,
             ...this.config,
         };
+        if (this._graphqlConfig) {
+            return config;
+        }
+        return {
+            ...config,
+            cwd: this.cwd,
+        };
     }
     updateConfig(config) {
         this.config = {
@@ -312,13 +323,15 @@ export class CodegenContext {
         }
         return addHashToSchema(loadSchema(pointer, config));
     }
-    async loadDocuments(pointer) {
+    async loadDocuments(pointer, type) {
         const config = this.getConfig(defaultDocumentsLoadOptions);
         if (this._graphqlConfig) {
             // TODO: pointer won't work here
-            return addHashToDocumentFiles(this._graphqlConfig.getProject(this._project).loadDocuments(pointer, { ...config, ...config.config }));
+            return addMetadataToSources(this._graphqlConfig
+                .getProject(this._project)
+                .loadDocuments(pointer, { ...config, ...config.config }), type);
         }
-        return addHashToDocumentFiles(loadDocuments(pointer, config));
+        return addMetadataToSources(loadDocuments(pointer, config), type);
     }
 }
 export function ensureContext(input) {
@@ -340,18 +353,40 @@ function addHashToSchema(schemaPromise) {
         return schema;
     });
 }
-function hashDocument(doc) {
-    if (doc.rawSDL) {
-        return hashContent(doc.rawSDL);
-    }
-    if (doc.document) {
-        return hashContent(print(doc.document));
+async function addMetadataToSources(documentFilesPromise, type) {
+    function hashDocument(doc) {
+        if (doc.rawSDL) {
+            return hashContent(doc.rawSDL);
+        }
+        if (doc.document) {
+            return hashContent(print(doc.document));
+        }
+        return null;
     }
-    return null;
-}
-function addHashToDocumentFiles(documentFilesPromise) {
-    return documentFilesPromise.then(documentFiles => documentFiles.map(doc => {
+    return documentFilesPromise.then(documentFiles => 
+    // Note: `doc` here is technically `Source`, but by the end of the funciton it's `Types.DocumentFile`. This re-declaration makes TypeScript happy.
+    documentFiles.map((doc) => {
         doc.hash = hashDocument(doc);
+        doc.type = type;
         return doc;
     }));
 }
+/**
+ * `safeDynamicImport` is a wrapper of dynamic `import()`
+ * to work across Linux and Windows
+ *
+ * CJS:
+ * `import()` seems to work well in CJS when given resolved filename
+ *
+ * ESM:
+ * On native Windows (i.e. no WSL or CI), filename may look like this: `C:\\Users\\path\\to\\file.ts`
+ * If used directly with `import()`, we'll see `ERR_UNSUPPORTED_ESM_URL_SCHEME` error because `c:` is not a valid protocol
+ * `url.pathToFileURL` turns the filename to `file:///C:/Users/path/to/file.ts`, which is import-able
+ */
+const safeDynamicImport = (absoluteFilename) => {
+    if (isESMModule) {
+        const { href: fileUrl } = url.pathToFileURL(absoluteFilename);
+        return import(fileUrl);
+    }
+    return import(absoluteFilename);
+};

package/esm/documentTransforms.js

@@ -10,7 +10,11 @@ export async function getDocumentTransform(documentTransform, loader, defaultNam
     if (isTransformFileConfig(documentTransform)) {
         const name = Object.keys(documentTransform)[0];
         const transformObject = await getDocumentTransformByName(name, loader);
-        return { name, transformObject, config: Object.values(documentTransform)[0] };
+        return {
+            name,
+            transformObject,
+            config: Object.values(documentTransform)[0],
+        };
     }
     throw new Error(`
         An unknown format document transform: '${defaultName}'.