@graphql-codegen/cli 2.3.1 → 2.5.0-alpha-bc33c031d.0

package/bin.js

@@ -505,20 +505,30 @@ async function loadSchema(schemaPointers, config) {
 
         ${e.message || e}
         ${e.stack || ''}
-    
+
         GraphQL Code Generator supports:
           - 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
-    
+
         Try to use one of above options and run codegen again.
-    
+
       `);
     }
 }
-async function loadDocuments(documentPointers, config) {
+const requiredLoader = async (pointers, schema) => {
+    return Promise.all(pointers.map(async (pointer) => {
+        const userLoader = (await makeDefaultLoader(process.cwd())(pointer.require)).default;
+        const documents = userLoader(pointer.config || {}, schema);
+        return documents;
+    })).then(results => [].concat(...results));
+};
+const isRequirePointer = (pointer) => {
+    return typeof pointer === 'object' && 'require' in pointer;
+};
+async function loadDocuments(documentPointers, config, schema) {
     const loaders = [
         new codeFileLoader.CodeFileLoader({
             pluckConfig: {
@@ -537,14 +547,35 @@ async function loadDocuments(documentPointers, config) {
         }
         ignore.push(path.join(process.cwd(), generatePath));
     }
-    const loadedFromToolkit = await load.loadDocuments(documentPointers, {
+    const loaderPointers = [];
+    const requestPointers = [];
+    if (Array.isArray(documentPointers)) {
+        documentPointers.forEach(pointer => {
+            if (isRequirePointer(pointer)) {
+                requestPointers.push(pointer);
+            }
+            else {
+                loaderPointers.push(pointer);
+            }
+        });
+    }
+    else {
+        if (isRequirePointer(documentPointers)) {
+            requestPointers.push(documentPointers);
+        }
+        else {
+            loaderPointers.push(documentPointers);
+        }
+    }
+    const loadedFromToolkit = await load.loadDocuments(loaderPointers, {
         ...defaultDocumentsLoadOptions,
         ignore,
         loaders,
         ...config,
         ...config.config,
     });
-    return loadedFromToolkit;
+    const loadedAlterantively = await requiredLoader(requestPointers, schema);
+    return [...loadedFromToolkit, ...loadedAlterantively];
 }
 
 const { lstat } = fs.promises;
@@ -767,14 +798,14 @@ class CodegenContext {
         }
         return loadSchema(pointer, config);
     }
-    async loadDocuments(pointer) {
+    async loadDocuments(input) {
         const config = this.getConfig(defaultDocumentsLoadOptions);
         if (this._graphqlConfig) {
             // TODO: pointer won't work here
-            const documents = await this._graphqlConfig.getProject(this._project).loadDocuments(pointer, config);
+            const documents = await this._graphqlConfig.getProject(this._project).loadDocuments(input.pointer, config);
             return documents;
         }
-        return loadDocuments(pointer, config);
+        return loadDocuments(input.pointer, config, input.schema);
     }
 }
 function ensureContext(input) {
@@ -790,6 +821,20 @@ const makeDefaultLoader = (from) => {
         return new Promise(function (resolve) { resolve(_interopNamespace(require(relativeRequire.resolve(mod)))); });
     };
 };
+// TODO: Replace any with types
+function createCache(loader) {
+    const cache = new Map();
+    return {
+        load(key) {
+            if (cache.has(key)) {
+                return cache.get(key);
+            }
+            const value = loader(key);
+            cache.set(key, value);
+            return value;
+        },
+    };
+}
 async function executeCodegen(input) {
     function wrapTask(task, source) {
         return async () => {
@@ -839,6 +884,20 @@ async function executeCodegen(input) {
     let rootSchemas;
     let rootDocuments;
     const generates = {};
+    const schemaLoadingCache = createCache(async function (hash) {
+        const outputSchemaAst = await context.loadSchema(JSON.parse(hash));
+        const outputSchema = pluginHelpers.getCachedDocumentNodeFromSchema(outputSchemaAst);
+        return {
+            outputSchemaAst: outputSchemaAst,
+            outputSchema: outputSchema,
+        };
+    });
+    const documentsLoadingCache = createCache(async function (hash) {
+        const documents = await context.loadDocuments(JSON.parse(hash));
+        return {
+            documents,
+        };
+    });
     async function normalize() {
         /* Load Require extensions */
         const requireExtensions = pluginHelpers.normalizeInstanceOrArray(config.require);
@@ -940,8 +999,10 @@ async function executeCodegen(input) {
                                             Object.assign(schemaPointerMap, unnormalizedPtr);
                                         }
                                     }
-                                    outputSchemaAst = await context.loadSchema(schemaPointerMap);
-                                    outputSchema = pluginHelpers.getCachedDocumentNodeFromSchema(outputSchemaAst);
+                                    const hash = JSON.stringify(schemaPointerMap);
+                                    const result = await schemaLoadingCache.load(hash);
+                                    outputSchemaAst = await result.outputSchemaAst;
+                                    outputSchema = result.outputSchema;
                                 }, filename),
                             },
                             {
@@ -949,7 +1010,9 @@ async function executeCodegen(input) {
                                 task: wrapTask(async () => {
                                     debugLog(`[CLI] Loading Documents`);
                                     const allDocuments = [...rootDocuments, ...outputSpecificDocuments];
-                                    const documents = await context.loadDocuments(allDocuments);
+                                    const hash = JSON.stringify({ pointer: allDocuments, schema: outputSchema });
+                                    const result = await documentsLoadingCache.load(hash);
+                                    const documents = result.documents;
                                     if (documents.length > 0) {
                                         outputDocuments.push(...documents);
                                     }

package/codegen.d.ts

@@ -1,3 +1,4 @@
 import { Types } from '@graphql-codegen/plugin-helpers';
 import { CodegenContext } from './config';
+export declare const makeDefaultLoader: (from: string) => (mod: string) => Promise<any>;
 export declare function executeCodegen(input: CodegenContext | Types.Config): Promise<Types.FileOutput[]>;

package/config.d.ts

@@ -103,6 +103,9 @@ export declare class CodegenContext {
         [key: string]: any;
     };
     loadSchema(pointer: Types.Schema): Promise<GraphQLSchema>;
-    loadDocuments(pointer: Types.OperationDocument[]): Promise<Types.DocumentFile[]>;
+    loadDocuments(input: {
+        pointer: Types.OperationDocument[];
+        schema: GraphQLSchema;
+    }): Promise<Types.DocumentFile[]>;
 }
 export declare function ensureContext(input: CodegenContext | Types.Config): CodegenContext;

package/index.js

@@ -423,20 +423,30 @@ async function loadSchema(schemaPointers, config) {
 
         ${e.message || e}
         ${e.stack || ''}
-    
+
         GraphQL Code Generator supports:
           - 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
-    
+
         Try to use one of above options and run codegen again.
-    
+
       `);
     }
 }
-async function loadDocuments(documentPointers, config) {
+const requiredLoader = async (pointers, schema) => {
+    return Promise.all(pointers.map(async (pointer) => {
+        const userLoader = (await makeDefaultLoader(process.cwd())(pointer.require)).default;
+        const documents = userLoader(pointer.config || {}, schema);
+        return documents;
+    })).then(results => [].concat(...results));
+};
+const isRequirePointer = (pointer) => {
+    return typeof pointer === 'object' && 'require' in pointer;
+};
+async function loadDocuments(documentPointers, config, schema) {
     const loaders = [
         new codeFileLoader.CodeFileLoader({
             pluckConfig: {
@@ -455,14 +465,35 @@ async function loadDocuments(documentPointers, config) {
         }
         ignore.push(path.join(process.cwd(), generatePath));
     }
-    const loadedFromToolkit = await load.loadDocuments(documentPointers, {
+    const loaderPointers = [];
+    const requestPointers = [];
+    if (Array.isArray(documentPointers)) {
+        documentPointers.forEach(pointer => {
+            if (isRequirePointer(pointer)) {
+                requestPointers.push(pointer);
+            }
+            else {
+                loaderPointers.push(pointer);
+            }
+        });
+    }
+    else {
+        if (isRequirePointer(documentPointers)) {
+            requestPointers.push(documentPointers);
+        }
+        else {
+            loaderPointers.push(documentPointers);
+        }
+    }
+    const loadedFromToolkit = await load.loadDocuments(loaderPointers, {
         ...defaultDocumentsLoadOptions,
         ignore,
         loaders,
         ...config,
         ...config.config,
     });
-    return loadedFromToolkit;
+    const loadedAlterantively = await requiredLoader(requestPointers, schema);
+    return [...loadedFromToolkit, ...loadedAlterantively];
 }
 
 const { lstat } = fs.promises;
@@ -685,14 +716,14 @@ class CodegenContext {
         }
         return loadSchema(pointer, config);
     }
-    async loadDocuments(pointer) {
+    async loadDocuments(input) {
         const config = this.getConfig(defaultDocumentsLoadOptions);
         if (this._graphqlConfig) {
             // TODO: pointer won't work here
-            const documents = await this._graphqlConfig.getProject(this._project).loadDocuments(pointer, config);
+            const documents = await this._graphqlConfig.getProject(this._project).loadDocuments(input.pointer, config);
             return documents;
         }
-        return loadDocuments(pointer, config);
+        return loadDocuments(input.pointer, config, input.schema);
     }
 }
 function ensureContext(input) {
@@ -708,6 +739,20 @@ const makeDefaultLoader = (from) => {
         return new Promise(function (resolve) { resolve(_interopNamespace(require(relativeRequire.resolve(mod)))); });
     };
 };
+// TODO: Replace any with types
+function createCache(loader) {
+    const cache = new Map();
+    return {
+        load(key) {
+            if (cache.has(key)) {
+                return cache.get(key);
+            }
+            const value = loader(key);
+            cache.set(key, value);
+            return value;
+        },
+    };
+}
 async function executeCodegen(input) {
     function wrapTask(task, source) {
         return async () => {
@@ -757,6 +802,20 @@ async function executeCodegen(input) {
     let rootSchemas;
     let rootDocuments;
     const generates = {};
+    const schemaLoadingCache = createCache(async function (hash) {
+        const outputSchemaAst = await context.loadSchema(JSON.parse(hash));
+        const outputSchema = pluginHelpers.getCachedDocumentNodeFromSchema(outputSchemaAst);
+        return {
+            outputSchemaAst: outputSchemaAst,
+            outputSchema: outputSchema,
+        };
+    });
+    const documentsLoadingCache = createCache(async function (hash) {
+        const documents = await context.loadDocuments(JSON.parse(hash));
+        return {
+            documents,
+        };
+    });
     async function normalize() {
         /* Load Require extensions */
         const requireExtensions = pluginHelpers.normalizeInstanceOrArray(config.require);
@@ -858,8 +917,10 @@ async function executeCodegen(input) {
                                             Object.assign(schemaPointerMap, unnormalizedPtr);
                                         }
                                     }
-                                    outputSchemaAst = await context.loadSchema(schemaPointerMap);
-                                    outputSchema = pluginHelpers.getCachedDocumentNodeFromSchema(outputSchemaAst);
+                                    const hash = JSON.stringify(schemaPointerMap);
+                                    const result = await schemaLoadingCache.load(hash);
+                                    outputSchemaAst = await result.outputSchemaAst;
+                                    outputSchema = result.outputSchema;
                                 }, filename),
                             },
                             {
@@ -867,7 +928,9 @@ async function executeCodegen(input) {
                                 task: wrapTask(async () => {
                                     debugLog(`[CLI] Loading Documents`);
                                     const allDocuments = [...rootDocuments, ...outputSpecificDocuments];
-                                    const documents = await context.loadDocuments(allDocuments);
+                                    const hash = JSON.stringify({ pointer: allDocuments, schema: outputSchema });
+                                    const result = await documentsLoadingCache.load(hash);
+                                    const documents = result.documents;
                                     if (documents.length > 0) {
                                         outputDocuments.push(...documents);
                                     }

package/index.mjs

@@ -396,20 +396,30 @@ async function loadSchema(schemaPointers, config) {
 
         ${e.message || e}
         ${e.stack || ''}
-    
+
         GraphQL Code Generator supports:
           - 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
-    
+
         Try to use one of above options and run codegen again.
-    
+
       `);
     }
 }
-async function loadDocuments(documentPointers, config) {
+const requiredLoader = async (pointers, schema) => {
+    return Promise.all(pointers.map(async (pointer) => {
+        const userLoader = (await makeDefaultLoader(process.cwd())(pointer.require)).default;
+        const documents = userLoader(pointer.config || {}, schema);
+        return documents;
+    })).then(results => [].concat(...results));
+};
+const isRequirePointer = (pointer) => {
+    return typeof pointer === 'object' && 'require' in pointer;
+};
+async function loadDocuments(documentPointers, config, schema) {
     const loaders = [
         new CodeFileLoader({
             pluckConfig: {
@@ -428,14 +438,35 @@ async function loadDocuments(documentPointers, config) {
         }
         ignore.push(join(process.cwd(), generatePath));
     }
-    const loadedFromToolkit = await loadDocuments$1(documentPointers, {
+    const loaderPointers = [];
+    const requestPointers = [];
+    if (Array.isArray(documentPointers)) {
+        documentPointers.forEach(pointer => {
+            if (isRequirePointer(pointer)) {
+                requestPointers.push(pointer);
+            }
+            else {
+                loaderPointers.push(pointer);
+            }
+        });
+    }
+    else {
+        if (isRequirePointer(documentPointers)) {
+            requestPointers.push(documentPointers);
+        }
+        else {
+            loaderPointers.push(documentPointers);
+        }
+    }
+    const loadedFromToolkit = await loadDocuments$1(loaderPointers, {
         ...defaultDocumentsLoadOptions,
         ignore,
         loaders,
         ...config,
         ...config.config,
     });
-    return loadedFromToolkit;
+    const loadedAlterantively = await requiredLoader(requestPointers, schema);
+    return [...loadedFromToolkit, ...loadedAlterantively];
 }
 
 const { lstat } = promises;
@@ -658,14 +689,14 @@ class CodegenContext {
         }
         return loadSchema(pointer, config);
     }
-    async loadDocuments(pointer) {
+    async loadDocuments(input) {
         const config = this.getConfig(defaultDocumentsLoadOptions);
         if (this._graphqlConfig) {
             // TODO: pointer won't work here
-            const documents = await this._graphqlConfig.getProject(this._project).loadDocuments(pointer, config);
+            const documents = await this._graphqlConfig.getProject(this._project).loadDocuments(input.pointer, config);
             return documents;
         }
-        return loadDocuments(pointer, config);
+        return loadDocuments(input.pointer, config, input.schema);
     }
 }
 function ensureContext(input) {
@@ -681,6 +712,20 @@ const makeDefaultLoader = (from) => {
         return import(relativeRequire.resolve(mod));
     };
 };
+// TODO: Replace any with types
+function createCache(loader) {
+    const cache = new Map();
+    return {
+        load(key) {
+            if (cache.has(key)) {
+                return cache.get(key);
+            }
+            const value = loader(key);
+            cache.set(key, value);
+            return value;
+        },
+    };
+}
 async function executeCodegen(input) {
     function wrapTask(task, source) {
         return async () => {
@@ -730,6 +775,20 @@ async function executeCodegen(input) {
     let rootSchemas;
     let rootDocuments;
     const generates = {};
+    const schemaLoadingCache = createCache(async function (hash) {
+        const outputSchemaAst = await context.loadSchema(JSON.parse(hash));
+        const outputSchema = getCachedDocumentNodeFromSchema(outputSchemaAst);
+        return {
+            outputSchemaAst: outputSchemaAst,
+            outputSchema: outputSchema,
+        };
+    });
+    const documentsLoadingCache = createCache(async function (hash) {
+        const documents = await context.loadDocuments(JSON.parse(hash));
+        return {
+            documents,
+        };
+    });
     async function normalize() {
         /* Load Require extensions */
         const requireExtensions = normalizeInstanceOrArray(config.require);
@@ -831,8 +890,10 @@ async function executeCodegen(input) {
                                             Object.assign(schemaPointerMap, unnormalizedPtr);
                                         }
                                     }
-                                    outputSchemaAst = await context.loadSchema(schemaPointerMap);
-                                    outputSchema = getCachedDocumentNodeFromSchema(outputSchemaAst);
+                                    const hash = JSON.stringify(schemaPointerMap);
+                                    const result = await schemaLoadingCache.load(hash);
+                                    outputSchemaAst = await result.outputSchemaAst;
+                                    outputSchema = result.outputSchema;
                                 }, filename),
                             },
                             {
@@ -840,7 +901,9 @@ async function executeCodegen(input) {
                                 task: wrapTask(async () => {
                                     debugLog(`[CLI] Loading Documents`);
                                     const allDocuments = [...rootDocuments, ...outputSpecificDocuments];
-                                    const documents = await context.loadDocuments(allDocuments);
+                                    const hash = JSON.stringify({ pointer: allDocuments, schema: outputSchema });
+                                    const result = await documentsLoadingCache.load(hash);
+                                    const documents = result.documents;
                                     if (documents.length > 0) {
                                         outputDocuments.push(...documents);
                                     }

package/load.d.ts

@@ -12,4 +12,4 @@ export declare const defaultDocumentsLoadOptions: {
     skipGraphQLImport: boolean;
 };
 export declare function loadSchema(schemaPointers: UnnormalizedTypeDefPointer, config: Types.Config): Promise<GraphQLSchema>;
-export declare function loadDocuments(documentPointers: UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[], config: Types.Config): Promise<Types.DocumentFile[]>;
+export declare function loadDocuments(documentPointers: UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[], config: Types.Config, schema: GraphQLSchema): Promise<Types.DocumentFile[]>;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@graphql-codegen/cli",
-  "version": "2.3.1",
+  "version": "2.5.0-alpha-bc33c031d.0",
   "peerDependencies": {
     "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": {
-    "@graphql-codegen/core": "2.4.0",
-    "@graphql-codegen/plugin-helpers": "^2.3.2",
+    "@graphql-codegen/core": "2.4.1-alpha-bc33c031d.0",
+    "@graphql-codegen/plugin-helpers": "2.3.3-alpha-bc33c031d.0",
     "@graphql-tools/apollo-engine-loader": "^7.0.5",
     "@graphql-tools/code-file-loader": "^7.0.6",
     "@graphql-tools/git-loader": "^7.0.5",