@graphql-codegen/cli 2.5.0-alpha-fc06eb8e7.0 → 2.6.0-alpha-c9d165f6a.0

package/bin.js

@@ -28,6 +28,7 @@ const path = require('path');
 const path__default = _interopDefault(path);
 const pluginHelpers = require('@graphql-codegen/plugin-helpers');
 const core = require('@graphql-codegen/core');
+const utils = require('@graphql-tools/utils');
 const chalk = _interopDefault(require('chalk'));
 const logSymbols = _interopDefault(require('log-symbols'));
 const ansiEscapes = _interopDefault(require('ansi-escapes'));
@@ -52,11 +53,11 @@ const yaml = _interopDefault(require('yaml'));
 const module$1 = require('module');
 const fs = require('fs');
 const fs__default = _interopDefault(fs);
+const os = require('os');
 const Listr = _interopDefault(require('listr'));
 const isGlob = _interopDefault(require('is-glob'));
 const debounce = _interopDefault(require('debounce'));
-const utils = require('@graphql-tools/utils');
-const mkdirp = _interopDefault(require('mkdirp'));
+const fsExtra = require('fs-extra');
 const crypto = require('crypto');
 const inquirer = _interopDefault(require('inquirer'));
 const detectIndent = _interopDefault(require('detect-indent'));
@@ -729,6 +730,32 @@ function updateContextWithCliFlags(context, cliFlags) {
 class CodegenContext {
     constructor({ config, graphqlConfig, filepath, }) {
         this._pluginContext = {};
+        this.loadSchema = useCache((pointer) => {
+            const config = this.getConfig(defaultSchemaLoadOptions);
+            if (this._graphqlConfig) {
+                // TODO: SchemaWithLoader won't work here
+                return this._graphqlConfig.getProject(this._project).loadSchema(pointer, 'GraphQLSchema', config);
+            }
+            return loadSchema(pointer, config);
+        }, {
+            cacheKey(pointer) {
+                return JSON.stringify(pointer);
+            },
+            skip: () => { var _a; return !!((_a = this.config) === null || _a === void 0 ? void 0 : _a.watch); },
+        });
+        this.loadDocuments = useCache((pointer) => {
+            const config = this.getConfig(defaultDocumentsLoadOptions);
+            if (this._graphqlConfig) {
+                // TODO: pointer won't work here
+                return this._graphqlConfig.getProject(this._project).loadDocuments(pointer, config);
+            }
+            return loadDocuments(pointer, config);
+        }, {
+            cacheKey(pointer) {
+                return JSON.stringify(pointer);
+            },
+            skip: () => { var _a; return !!((_a = this.config) === null || _a === void 0 ? void 0 : _a.watch); },
+        });
         this._config = config;
         this._graphqlConfig = graphqlConfig;
         this.filepath = this._graphqlConfig ? this._graphqlConfig.filepath : filepath;
@@ -774,27 +801,55 @@ class CodegenContext {
     getPluginContext() {
         return this._pluginContext;
     }
-    async loadSchema(pointer) {
-        const config = this.getConfig(defaultSchemaLoadOptions);
-        if (this._graphqlConfig) {
-            // TODO: SchemaWithLoader won't work here
-            return this._graphqlConfig.getProject(this._project).loadSchema(pointer, 'GraphQLSchema', config);
-        }
-        return loadSchema(pointer, config);
-    }
-    async loadDocuments(pointer) {
-        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);
-            return documents;
-        }
-        return loadDocuments(pointer, config);
-    }
 }
 function ensureContext(input) {
     return input instanceof CodegenContext ? input : new CodegenContext({ config: input });
 }
+/**
+ * The goal here is to avoid loading the same schema or documents across projects.
+ */
+function useCache(originalFunction, { cacheKey, skip = () => false }) {
+    if (skip()) {
+        return originalFunction;
+    }
+    const cache = new Map();
+    return (input) => {
+        const key = cacheKey(input);
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = originalFunction(input);
+        cache.set(key, result);
+        return result;
+    };
+}
+
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+
+function isListrError(err) {
+    return err.name === 'ListrError' && Array.isArray(err.errors) && err.errors.length > 0;
+}
+function cliError(err, exitOnError = true) {
+    let msg;
+    if (err instanceof Error) {
+        msg = err.message || err.toString();
+    }
+    else if (typeof err === 'string') {
+        msg = err;
+    }
+    else {
+        msg = JSON.stringify(err);
+    }
+    // eslint-disable-next-line no-console
+    console.error(msg);
+    if (exitOnError && isNode) {
+        process.exit(1);
+    }
+    else if (exitOnError && isBrowser) {
+        throw err;
+    }
+}
 
 const makeDefaultLoader = (from) => {
     if (fs__default.statSync(from).isDirectory()) {
@@ -995,10 +1050,13 @@ async function executeCodegen(input) {
                                 title: 'Load GraphQL documents',
                                 task: wrapTask(async () => {
                                     debugLog(`[CLI] Loading Documents`);
-                                    const allDocuments = [...rootDocuments, ...outputSpecificDocuments];
-                                    const hash = JSON.stringify(allDocuments);
-                                    const result = await documentsLoadingCache.load(hash);
-                                    const documents = result.documents;
+                                    // get different cache for shared docs and output specific docs
+                                    const results = await Promise.all([rootDocuments, outputSpecificDocuments].map(docs => {
+                                        const hash = JSON.stringify(docs);
+                                        return documentsLoadingCache.load(hash);
+                                    }));
+                                    const documents = [];
+                                    results.forEach(source => documents.push(...source.documents));
                                     if (documents.length > 0) {
                                         outputDocuments.push(...documents);
                                     }
@@ -1078,12 +1136,25 @@ async function executeCodegen(input) {
             }), {
                 // it doesn't stop when one of tasks failed, to finish at least some of outputs
                 exitOnError: false,
-                // run 4 at once
-                concurrent: 4,
+                concurrent: os.cpus().length,
             });
         },
     });
-    await listr.run();
+    try {
+        await listr.run();
+    }
+    catch (err) {
+        if (isListrError(err)) {
+            const allErrs = err.errors.map(subErr => pluginHelpers.isDetailedError(subErr)
+                ? `${subErr.message} for "${subErr.source}"${subErr.details}`
+                : subErr.message || subErr.toString());
+            const newErr = new utils.AggregateError(err.errors, `${err.message} ${allErrs.join('\n\n')}`);
+            // Best-effort to all stack traces for debugging
+            newErr.stack = `${newErr.stack}\n\n${err.errors.map(subErr => subErr.stack).join('\n\n')}`;
+            throw newErr;
+        }
+        throw err;
+    }
     return result;
 }
 
@@ -1212,22 +1283,22 @@ const createWatcher = (initalContext, onNext) => {
     });
 };
 
-function writeSync(filepath, content) {
-    return fs.writeFileSync(filepath, content);
+function writeFile(filepath, content) {
+    return fsExtra.writeFile(filepath, content);
 }
-function readSync(filepath) {
-    return fs.readFileSync(filepath, 'utf-8');
+function readFile(filepath) {
+    return fsExtra.readFile(filepath, 'utf-8');
 }
-function fileExists(filePath) {
+async function fileExists(filePath) {
     try {
-        return fs.statSync(filePath).isFile();
+        return (await fsExtra.stat(filePath)).isFile();
     }
     catch (err) {
         return false;
     }
 }
 function unlinkFile(filePath, cb) {
-    fs.unlink(filePath, cb);
+    fsExtra.unlink(filePath, cb);
 }
 
 const hash = (content) => crypto.createHash('sha1').update(content).digest('base64');
@@ -1242,7 +1313,7 @@ async function generate(input, saveToFile = true) {
         const staleFilenames = previouslyGeneratedFilenames.filter(f => !filenames.includes(f));
         staleFilenames.forEach(filename => {
             if (shouldOverwrite(config, filename)) {
-                unlinkFile(filename, err => {
+                return unlinkFile(filename, err => {
                     const prettyFilename = filename.replace(`${input.cwd || process.cwd()}/`, '');
                     if (err) {
                         debugLog(`Cannot remove stale file: ${prettyFilename}\n${err}`);
@@ -1263,7 +1334,39 @@ async function generate(input, saveToFile = true) {
         if (config.watch) {
             removeStaleFiles(config, generationResult);
         }
-        await context.profiler.run(() => lifecycleHooks(config.hooks).beforeAllFileWrite(generationResult.map(r => r.filename)), 'Lifecycle: beforeAllFileWrite');
+        await context.profiler.run(async () => {
+            await lifecycleHooks(config.hooks).beforeAllFileWrite(generationResult.map(r => r.filename));
+            await Promise.all(generationResult.map(async (result) => {
+                const exists = await fileExists(result.filename);
+                if (!shouldOverwrite(config, result.filename) && exists) {
+                    return;
+                }
+                const content = result.content || '';
+                const currentHash = hash(content);
+                let previousHash = recentOutputHash.get(result.filename);
+                if (!previousHash && exists) {
+                    previousHash = hash(await readFile(result.filename));
+                }
+                if (previousHash && currentHash === previousHash) {
+                    debugLog(`Skipping file (${result.filename}) writing due to indentical hash...`);
+                    return;
+                }
+                if (content.length === 0) {
+                    return;
+                }
+                recentOutputHash.set(result.filename, currentHash);
+                const basedir = path.dirname(result.filename);
+                await lifecycleHooks(result.hooks).beforeOneFileWrite(result.filename);
+                await lifecycleHooks(config.hooks).beforeOneFileWrite(result.filename);
+                await fsExtra.mkdirp(basedir);
+                const absolutePath = path.isAbsolute(result.filename)
+                    ? result.filename
+                    : path.join(input.cwd || process.cwd(), result.filename);
+                await writeFile(absolutePath, result.content);
+                await lifecycleHooks(result.hooks).afterOneFileWrite(result.filename);
+                await lifecycleHooks(config.hooks).afterOneFileWrite(result.filename);
+            }));
+        }, 'Lifecycle: beforeAllFileWrite');
         await context.profiler.run(() => Promise.all(generationResult.map(async (result) => {
             const exists = fileExists(result.filename);
             if (!shouldOverwrite(config, result.filename) && exists) {
@@ -1273,7 +1376,7 @@ async function generate(input, saveToFile = true) {
             const currentHash = hash(content);
             let previousHash = recentOutputHash.get(result.filename);
             if (!previousHash && exists) {
-                previousHash = hash(readSync(result.filename));
+                previousHash = hash(await readFile(result.filename));
             }
             if (previousHash && currentHash === previousHash) {
                 debugLog(`Skipping file (${result.filename}) writing due to identical hash...`);
@@ -1286,11 +1389,11 @@ async function generate(input, saveToFile = true) {
             const basedir = path.dirname(result.filename);
             await lifecycleHooks(result.hooks).beforeOneFileWrite(result.filename);
             await lifecycleHooks(config.hooks).beforeOneFileWrite(result.filename);
-            mkdirp.sync(basedir);
+            fsExtra.mkdirp.sync(basedir);
             const absolutePath = path.isAbsolute(result.filename)
                 ? result.filename
                 : path.join(input.cwd || process.cwd(), result.filename);
-            writeSync(absolutePath, result.content);
+            await writeFile(absolutePath, result.content);
             await lifecycleHooks(result.hooks).afterOneFileWrite(result.filename);
             await lifecycleHooks(config.hooks).afterOneFileWrite(result.filename);
         })), 'Write files');
@@ -1305,7 +1408,7 @@ async function generate(input, saveToFile = true) {
     await context.profiler.run(() => writeOutput(outputFiles), 'writeOutput');
     await context.profiler.run(() => lifecycleHooks(config.hooks).beforeDone(), 'Lifecycle: beforeDone');
     if (context.profilerOutput) {
-        writeSync(path.join(context.cwd, context.profilerOutput), JSON.stringify(context.profiler.collect()));
+        await writeFile(path.join(context.cwd, context.profilerOutput), JSON.stringify(context.profiler.collect()));
     }
     return outputFiles;
 }
@@ -1805,30 +1908,6 @@ async function ensureGraphQlPackage() {
     }
 }
 
-const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
-const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
-
-function cliError(err, exitOnError = true) {
-    let msg;
-    if (err instanceof Error) {
-        msg = err.message || err.toString();
-    }
-    else if (typeof err === 'string') {
-        msg = err;
-    }
-    else {
-        msg = JSON.stringify(err);
-    }
-    // eslint-disable-next-line no-console
-    console.error(msg);
-    if (exitOnError && isNode) {
-        process.exit(1);
-    }
-    else if (exitOnError && isBrowser) {
-        throw err;
-    }
-}
-
 const [, , cmd] = process.argv;
 runCli(cmd)
     .then(() => {

package/config.d.ts

@@ -110,7 +110,7 @@ export declare class CodegenContext {
     getPluginContext(): {
         [key: string]: any;
     };
-    loadSchema(pointer: Types.Schema): Promise<GraphQLSchema>;
-    loadDocuments(pointer: Types.OperationDocument[]): Promise<Types.DocumentFile[]>;
+    loadSchema: (input: Types.Schema) => Promise<GraphQLSchema>;
+    loadDocuments: (input: Types.OperationDocument[]) => Promise<import("graphql-config").Source[]>;
 }
 export declare function ensureContext(input: CodegenContext | Types.Config): CodegenContext;

package/index.js

@@ -25,6 +25,7 @@ function _interopNamespace(e) {
 
 const pluginHelpers = require('@graphql-codegen/plugin-helpers');
 const core = require('@graphql-codegen/core');
+const utils = require('@graphql-tools/utils');
 const chalk = _interopDefault(require('chalk'));
 const logSymbols = _interopDefault(require('log-symbols'));
 const ansiEscapes = _interopDefault(require('ansi-escapes'));
@@ -52,12 +53,12 @@ const yaml = _interopDefault(require('yaml'));
 const module$1 = require('module');
 const fs = require('fs');
 const fs__default = _interopDefault(fs);
+const os = require('os');
 const Listr = _interopDefault(require('listr'));
 const child_process = require('child_process');
 const isGlob = _interopDefault(require('is-glob'));
 const debounce = _interopDefault(require('debounce'));
-const utils = require('@graphql-tools/utils');
-const mkdirp = _interopDefault(require('mkdirp'));
+const fsExtra = require('fs-extra');
 const crypto = require('crypto');
 const inquirer = _interopDefault(require('inquirer'));
 const detectIndent = _interopDefault(require('detect-indent'));
@@ -647,6 +648,32 @@ function updateContextWithCliFlags(context, cliFlags) {
 class CodegenContext {
     constructor({ config, graphqlConfig, filepath, }) {
         this._pluginContext = {};
+        this.loadSchema = useCache((pointer) => {
+            const config = this.getConfig(defaultSchemaLoadOptions);
+            if (this._graphqlConfig) {
+                // TODO: SchemaWithLoader won't work here
+                return this._graphqlConfig.getProject(this._project).loadSchema(pointer, 'GraphQLSchema', config);
+            }
+            return loadSchema(pointer, config);
+        }, {
+            cacheKey(pointer) {
+                return JSON.stringify(pointer);
+            },
+            skip: () => { var _a; return !!((_a = this.config) === null || _a === void 0 ? void 0 : _a.watch); },
+        });
+        this.loadDocuments = useCache((pointer) => {
+            const config = this.getConfig(defaultDocumentsLoadOptions);
+            if (this._graphqlConfig) {
+                // TODO: pointer won't work here
+                return this._graphqlConfig.getProject(this._project).loadDocuments(pointer, config);
+            }
+            return loadDocuments(pointer, config);
+        }, {
+            cacheKey(pointer) {
+                return JSON.stringify(pointer);
+            },
+            skip: () => { var _a; return !!((_a = this.config) === null || _a === void 0 ? void 0 : _a.watch); },
+        });
         this._config = config;
         this._graphqlConfig = graphqlConfig;
         this.filepath = this._graphqlConfig ? this._graphqlConfig.filepath : filepath;
@@ -692,27 +719,55 @@ class CodegenContext {
     getPluginContext() {
         return this._pluginContext;
     }
-    async loadSchema(pointer) {
-        const config = this.getConfig(defaultSchemaLoadOptions);
-        if (this._graphqlConfig) {
-            // TODO: SchemaWithLoader won't work here
-            return this._graphqlConfig.getProject(this._project).loadSchema(pointer, 'GraphQLSchema', config);
-        }
-        return loadSchema(pointer, config);
-    }
-    async loadDocuments(pointer) {
-        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);
-            return documents;
-        }
-        return loadDocuments(pointer, config);
-    }
 }
 function ensureContext(input) {
     return input instanceof CodegenContext ? input : new CodegenContext({ config: input });
 }
+/**
+ * The goal here is to avoid loading the same schema or documents across projects.
+ */
+function useCache(originalFunction, { cacheKey, skip = () => false }) {
+    if (skip()) {
+        return originalFunction;
+    }
+    const cache = new Map();
+    return (input) => {
+        const key = cacheKey(input);
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = originalFunction(input);
+        cache.set(key, result);
+        return result;
+    };
+}
+
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+
+function isListrError(err) {
+    return err.name === 'ListrError' && Array.isArray(err.errors) && err.errors.length > 0;
+}
+function cliError(err, exitOnError = true) {
+    let msg;
+    if (err instanceof Error) {
+        msg = err.message || err.toString();
+    }
+    else if (typeof err === 'string') {
+        msg = err;
+    }
+    else {
+        msg = JSON.stringify(err);
+    }
+    // eslint-disable-next-line no-console
+    console.error(msg);
+    if (exitOnError && isNode) {
+        process.exit(1);
+    }
+    else if (exitOnError && isBrowser) {
+        throw err;
+    }
+}
 
 const makeDefaultLoader = (from) => {
     if (fs__default.statSync(from).isDirectory()) {
@@ -913,10 +968,13 @@ async function executeCodegen(input) {
                                 title: 'Load GraphQL documents',
                                 task: wrapTask(async () => {
                                     debugLog(`[CLI] Loading Documents`);
-                                    const allDocuments = [...rootDocuments, ...outputSpecificDocuments];
-                                    const hash = JSON.stringify(allDocuments);
-                                    const result = await documentsLoadingCache.load(hash);
-                                    const documents = result.documents;
+                                    // get different cache for shared docs and output specific docs
+                                    const results = await Promise.all([rootDocuments, outputSpecificDocuments].map(docs => {
+                                        const hash = JSON.stringify(docs);
+                                        return documentsLoadingCache.load(hash);
+                                    }));
+                                    const documents = [];
+                                    results.forEach(source => documents.push(...source.documents));
                                     if (documents.length > 0) {
                                         outputDocuments.push(...documents);
                                     }
@@ -996,12 +1054,25 @@ async function executeCodegen(input) {
             }), {
                 // it doesn't stop when one of tasks failed, to finish at least some of outputs
                 exitOnError: false,
-                // run 4 at once
-                concurrent: 4,
+                concurrent: os.cpus().length,
             });
         },
     });
-    await listr.run();
+    try {
+        await listr.run();
+    }
+    catch (err) {
+        if (isListrError(err)) {
+            const allErrs = err.errors.map(subErr => pluginHelpers.isDetailedError(subErr)
+                ? `${subErr.message} for "${subErr.source}"${subErr.details}`
+                : subErr.message || subErr.toString());
+            const newErr = new utils.AggregateError(err.errors, `${err.message} ${allErrs.join('\n\n')}`);
+            // Best-effort to all stack traces for debugging
+            newErr.stack = `${newErr.stack}\n\n${err.errors.map(subErr => subErr.stack).join('\n\n')}`;
+            throw newErr;
+        }
+        throw err;
+    }
     return result;
 }
 
@@ -1213,22 +1284,22 @@ const createWatcher = (initalContext, onNext) => {
     });
 };
 
-function writeSync(filepath, content) {
-    return fs.writeFileSync(filepath, content);
+function writeFile(filepath, content) {
+    return fsExtra.writeFile(filepath, content);
 }
-function readSync(filepath) {
-    return fs.readFileSync(filepath, 'utf-8');
+function readFile(filepath) {
+    return fsExtra.readFile(filepath, 'utf-8');
 }
-function fileExists(filePath) {
+async function fileExists(filePath) {
     try {
-        return fs.statSync(filePath).isFile();
+        return (await fsExtra.stat(filePath)).isFile();
     }
     catch (err) {
         return false;
     }
 }
 function unlinkFile(filePath, cb) {
-    fs.unlink(filePath, cb);
+    fsExtra.unlink(filePath, cb);
 }
 
 const hash = (content) => crypto.createHash('sha1').update(content).digest('base64');
@@ -1243,7 +1314,7 @@ async function generate(input, saveToFile = true) {
         const staleFilenames = previouslyGeneratedFilenames.filter(f => !filenames.includes(f));
         staleFilenames.forEach(filename => {
             if (shouldOverwrite(config, filename)) {
-                unlinkFile(filename, err => {
+                return unlinkFile(filename, err => {
                     const prettyFilename = filename.replace(`${input.cwd || process.cwd()}/`, '');
                     if (err) {
                         debugLog(`Cannot remove stale file: ${prettyFilename}\n${err}`);
@@ -1264,7 +1335,39 @@ async function generate(input, saveToFile = true) {
         if (config.watch) {
             removeStaleFiles(config, generationResult);
         }
-        await context.profiler.run(() => lifecycleHooks(config.hooks).beforeAllFileWrite(generationResult.map(r => r.filename)), 'Lifecycle: beforeAllFileWrite');
+        await context.profiler.run(async () => {
+            await lifecycleHooks(config.hooks).beforeAllFileWrite(generationResult.map(r => r.filename));
+            await Promise.all(generationResult.map(async (result) => {
+                const exists = await fileExists(result.filename);
+                if (!shouldOverwrite(config, result.filename) && exists) {
+                    return;
+                }
+                const content = result.content || '';
+                const currentHash = hash(content);
+                let previousHash = recentOutputHash.get(result.filename);
+                if (!previousHash && exists) {
+                    previousHash = hash(await readFile(result.filename));
+                }
+                if (previousHash && currentHash === previousHash) {
+                    debugLog(`Skipping file (${result.filename}) writing due to indentical hash...`);
+                    return;
+                }
+                if (content.length === 0) {
+                    return;
+                }
+                recentOutputHash.set(result.filename, currentHash);
+                const basedir = path.dirname(result.filename);
+                await lifecycleHooks(result.hooks).beforeOneFileWrite(result.filename);
+                await lifecycleHooks(config.hooks).beforeOneFileWrite(result.filename);
+                await fsExtra.mkdirp(basedir);
+                const absolutePath = path.isAbsolute(result.filename)
+                    ? result.filename
+                    : path.join(input.cwd || process.cwd(), result.filename);
+                await writeFile(absolutePath, result.content);
+                await lifecycleHooks(result.hooks).afterOneFileWrite(result.filename);
+                await lifecycleHooks(config.hooks).afterOneFileWrite(result.filename);
+            }));
+        }, 'Lifecycle: beforeAllFileWrite');
         await context.profiler.run(() => Promise.all(generationResult.map(async (result) => {
             const exists = fileExists(result.filename);
             if (!shouldOverwrite(config, result.filename) && exists) {
@@ -1274,7 +1377,7 @@ async function generate(input, saveToFile = true) {
             const currentHash = hash(content);
             let previousHash = recentOutputHash.get(result.filename);
             if (!previousHash && exists) {
-                previousHash = hash(readSync(result.filename));
+                previousHash = hash(await readFile(result.filename));
             }
             if (previousHash && currentHash === previousHash) {
                 debugLog(`Skipping file (${result.filename}) writing due to identical hash...`);
@@ -1287,11 +1390,11 @@ async function generate(input, saveToFile = true) {
             const basedir = path.dirname(result.filename);
             await lifecycleHooks(result.hooks).beforeOneFileWrite(result.filename);
             await lifecycleHooks(config.hooks).beforeOneFileWrite(result.filename);
-            mkdirp.sync(basedir);
+            fsExtra.mkdirp.sync(basedir);
             const absolutePath = path.isAbsolute(result.filename)
                 ? result.filename
                 : path.join(input.cwd || process.cwd(), result.filename);
-            writeSync(absolutePath, result.content);
+            await writeFile(absolutePath, result.content);
             await lifecycleHooks(result.hooks).afterOneFileWrite(result.filename);
             await lifecycleHooks(config.hooks).afterOneFileWrite(result.filename);
         })), 'Write files');
@@ -1306,7 +1409,7 @@ async function generate(input, saveToFile = true) {
     await context.profiler.run(() => writeOutput(outputFiles), 'writeOutput');
     await context.profiler.run(() => lifecycleHooks(config.hooks).beforeDone(), 'Lifecycle: beforeDone');
     if (context.profilerOutput) {
-        writeSync(path.join(context.cwd, context.profilerOutput), JSON.stringify(context.profiler.collect()));
+        await writeFile(path.join(context.cwd, context.profilerOutput), JSON.stringify(context.profiler.collect()));
     }
     return outputFiles;
 }
@@ -1777,30 +1880,6 @@ function addIntrospection(config) {
     };
 }
 
-const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
-const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
-
-function cliError(err, exitOnError = true) {
-    let msg;
-    if (err instanceof Error) {
-        msg = err.message || err.toString();
-    }
-    else if (typeof err === 'string') {
-        msg = err;
-    }
-    else {
-        msg = JSON.stringify(err);
-    }
-    // eslint-disable-next-line no-console
-    console.error(msg);
-    if (exitOnError && isNode) {
-        process.exit(1);
-    }
-    else if (exitOnError && isBrowser) {
-        throw err;
-    }
-}
-
 async function runCli(cmd) {
     await ensureGraphQlPackage();
     switch (cmd) {
@@ -1842,6 +1921,7 @@ exports.findAndLoadGraphQLConfig = findAndLoadGraphQLConfig;
 exports.generate = generate;
 exports.generateSearchPlaces = generateSearchPlaces;
 exports.init = init;
+exports.isListrError = isListrError;
 exports.loadCodegenConfig = loadCodegenConfig;
 exports.loadContext = loadContext;
 exports.parseArgv = parseArgv;

package/index.mjs

@@ -1,5 +1,6 @@
 import { isDetailedError, DetailedError, createNoopProfiler, createProfiler, normalizeInstanceOrArray, normalizeConfig, normalizeOutputParam, getCachedDocumentNodeFromSchema } from '@graphql-codegen/plugin-helpers';
 import { codegen } from '@graphql-codegen/core';
+import { AggregateError, isValidPath } from '@graphql-tools/utils';
 import chalk from 'chalk';
 import logSymbols from 'log-symbols';
 import ansiEscapes from 'ansi-escapes';
@@ -24,13 +25,13 @@ import { JsonFileLoader } from '@graphql-tools/json-file-loader';
 import { UrlLoader } from '@graphql-tools/url-loader';
 import yaml from 'yaml';
 import { createRequire } from 'module';
-import fs, { promises, writeFileSync, readFileSync, statSync, unlink } from 'fs';
+import fs, { promises, writeFileSync, readFileSync } from 'fs';
+import { cpus } from 'os';
 import Listr from 'listr';
 import { exec } from 'child_process';
 import isGlob from 'is-glob';
 import debounce from 'debounce';
-import { isValidPath } from '@graphql-tools/utils';
-import mkdirp from 'mkdirp';
+import { writeFile as writeFile$1, readFile as readFile$1, stat, unlink, mkdirp } from 'fs-extra';
 import { createHash } from 'crypto';
 import inquirer from 'inquirer';
 import detectIndent from 'detect-indent';
@@ -620,6 +621,32 @@ function updateContextWithCliFlags(context, cliFlags) {
 class CodegenContext {
     constructor({ config, graphqlConfig, filepath, }) {
         this._pluginContext = {};
+        this.loadSchema = useCache((pointer) => {
+            const config = this.getConfig(defaultSchemaLoadOptions);
+            if (this._graphqlConfig) {
+                // TODO: SchemaWithLoader won't work here
+                return this._graphqlConfig.getProject(this._project).loadSchema(pointer, 'GraphQLSchema', config);
+            }
+            return loadSchema(pointer, config);
+        }, {
+            cacheKey(pointer) {
+                return JSON.stringify(pointer);
+            },
+            skip: () => { var _a; return !!((_a = this.config) === null || _a === void 0 ? void 0 : _a.watch); },
+        });
+        this.loadDocuments = useCache((pointer) => {
+            const config = this.getConfig(defaultDocumentsLoadOptions);
+            if (this._graphqlConfig) {
+                // TODO: pointer won't work here
+                return this._graphqlConfig.getProject(this._project).loadDocuments(pointer, config);
+            }
+            return loadDocuments(pointer, config);
+        }, {
+            cacheKey(pointer) {
+                return JSON.stringify(pointer);
+            },
+            skip: () => { var _a; return !!((_a = this.config) === null || _a === void 0 ? void 0 : _a.watch); },
+        });
         this._config = config;
         this._graphqlConfig = graphqlConfig;
         this.filepath = this._graphqlConfig ? this._graphqlConfig.filepath : filepath;
@@ -665,27 +692,55 @@ class CodegenContext {
     getPluginContext() {
         return this._pluginContext;
     }
-    async loadSchema(pointer) {
-        const config = this.getConfig(defaultSchemaLoadOptions);
-        if (this._graphqlConfig) {
-            // TODO: SchemaWithLoader won't work here
-            return this._graphqlConfig.getProject(this._project).loadSchema(pointer, 'GraphQLSchema', config);
-        }
-        return loadSchema(pointer, config);
-    }
-    async loadDocuments(pointer) {
-        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);
-            return documents;
-        }
-        return loadDocuments(pointer, config);
-    }
 }
 function ensureContext(input) {
     return input instanceof CodegenContext ? input : new CodegenContext({ config: input });
 }
+/**
+ * The goal here is to avoid loading the same schema or documents across projects.
+ */
+function useCache(originalFunction, { cacheKey, skip = () => false }) {
+    if (skip()) {
+        return originalFunction;
+    }
+    const cache = new Map();
+    return (input) => {
+        const key = cacheKey(input);
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = originalFunction(input);
+        cache.set(key, result);
+        return result;
+    };
+}
+
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+
+function isListrError(err) {
+    return err.name === 'ListrError' && Array.isArray(err.errors) && err.errors.length > 0;
+}
+function cliError(err, exitOnError = true) {
+    let msg;
+    if (err instanceof Error) {
+        msg = err.message || err.toString();
+    }
+    else if (typeof err === 'string') {
+        msg = err;
+    }
+    else {
+        msg = JSON.stringify(err);
+    }
+    // eslint-disable-next-line no-console
+    console.error(msg);
+    if (exitOnError && isNode) {
+        process.exit(1);
+    }
+    else if (exitOnError && isBrowser) {
+        throw err;
+    }
+}
 
 const makeDefaultLoader = (from) => {
     if (fs.statSync(from).isDirectory()) {
@@ -886,10 +941,13 @@ async function executeCodegen(input) {
                                 title: 'Load GraphQL documents',
                                 task: wrapTask(async () => {
                                     debugLog(`[CLI] Loading Documents`);
-                                    const allDocuments = [...rootDocuments, ...outputSpecificDocuments];
-                                    const hash = JSON.stringify(allDocuments);
-                                    const result = await documentsLoadingCache.load(hash);
-                                    const documents = result.documents;
+                                    // get different cache for shared docs and output specific docs
+                                    const results = await Promise.all([rootDocuments, outputSpecificDocuments].map(docs => {
+                                        const hash = JSON.stringify(docs);
+                                        return documentsLoadingCache.load(hash);
+                                    }));
+                                    const documents = [];
+                                    results.forEach(source => documents.push(...source.documents));
                                     if (documents.length > 0) {
                                         outputDocuments.push(...documents);
                                     }
@@ -969,12 +1027,25 @@ async function executeCodegen(input) {
             }), {
                 // it doesn't stop when one of tasks failed, to finish at least some of outputs
                 exitOnError: false,
-                // run 4 at once
-                concurrent: 4,
+                concurrent: cpus().length,
             });
         },
     });
-    await listr.run();
+    try {
+        await listr.run();
+    }
+    catch (err) {
+        if (isListrError(err)) {
+            const allErrs = err.errors.map(subErr => isDetailedError(subErr)
+                ? `${subErr.message} for "${subErr.source}"${subErr.details}`
+                : subErr.message || subErr.toString());
+            const newErr = new AggregateError(err.errors, `${err.message} ${allErrs.join('\n\n')}`);
+            // Best-effort to all stack traces for debugging
+            newErr.stack = `${newErr.stack}\n\n${err.errors.map(subErr => subErr.stack).join('\n\n')}`;
+            throw newErr;
+        }
+        throw err;
+    }
     return result;
 }
 
@@ -1186,15 +1257,15 @@ const createWatcher = (initalContext, onNext) => {
     });
 };
 
-function writeSync(filepath, content) {
-    return writeFileSync(filepath, content);
+function writeFile(filepath, content) {
+    return writeFile$1(filepath, content);
 }
-function readSync(filepath) {
-    return readFileSync(filepath, 'utf-8');
+function readFile(filepath) {
+    return readFile$1(filepath, 'utf-8');
 }
-function fileExists(filePath) {
+async function fileExists(filePath) {
     try {
-        return statSync(filePath).isFile();
+        return (await stat(filePath)).isFile();
     }
     catch (err) {
         return false;
@@ -1216,7 +1287,7 @@ async function generate(input, saveToFile = true) {
         const staleFilenames = previouslyGeneratedFilenames.filter(f => !filenames.includes(f));
         staleFilenames.forEach(filename => {
             if (shouldOverwrite(config, filename)) {
-                unlinkFile(filename, err => {
+                return unlinkFile(filename, err => {
                     const prettyFilename = filename.replace(`${input.cwd || process.cwd()}/`, '');
                     if (err) {
                         debugLog(`Cannot remove stale file: ${prettyFilename}\n${err}`);
@@ -1237,7 +1308,39 @@ async function generate(input, saveToFile = true) {
         if (config.watch) {
             removeStaleFiles(config, generationResult);
         }
-        await context.profiler.run(() => lifecycleHooks(config.hooks).beforeAllFileWrite(generationResult.map(r => r.filename)), 'Lifecycle: beforeAllFileWrite');
+        await context.profiler.run(async () => {
+            await lifecycleHooks(config.hooks).beforeAllFileWrite(generationResult.map(r => r.filename));
+            await Promise.all(generationResult.map(async (result) => {
+                const exists = await fileExists(result.filename);
+                if (!shouldOverwrite(config, result.filename) && exists) {
+                    return;
+                }
+                const content = result.content || '';
+                const currentHash = hash(content);
+                let previousHash = recentOutputHash.get(result.filename);
+                if (!previousHash && exists) {
+                    previousHash = hash(await readFile(result.filename));
+                }
+                if (previousHash && currentHash === previousHash) {
+                    debugLog(`Skipping file (${result.filename}) writing due to indentical hash...`);
+                    return;
+                }
+                if (content.length === 0) {
+                    return;
+                }
+                recentOutputHash.set(result.filename, currentHash);
+                const basedir = dirname(result.filename);
+                await lifecycleHooks(result.hooks).beforeOneFileWrite(result.filename);
+                await lifecycleHooks(config.hooks).beforeOneFileWrite(result.filename);
+                await mkdirp(basedir);
+                const absolutePath = isAbsolute(result.filename)
+                    ? result.filename
+                    : join(input.cwd || process.cwd(), result.filename);
+                await writeFile(absolutePath, result.content);
+                await lifecycleHooks(result.hooks).afterOneFileWrite(result.filename);
+                await lifecycleHooks(config.hooks).afterOneFileWrite(result.filename);
+            }));
+        }, 'Lifecycle: beforeAllFileWrite');
         await context.profiler.run(() => Promise.all(generationResult.map(async (result) => {
             const exists = fileExists(result.filename);
             if (!shouldOverwrite(config, result.filename) && exists) {
@@ -1247,7 +1350,7 @@ async function generate(input, saveToFile = true) {
             const currentHash = hash(content);
             let previousHash = recentOutputHash.get(result.filename);
             if (!previousHash && exists) {
-                previousHash = hash(readSync(result.filename));
+                previousHash = hash(await readFile(result.filename));
             }
             if (previousHash && currentHash === previousHash) {
                 debugLog(`Skipping file (${result.filename}) writing due to identical hash...`);
@@ -1264,7 +1367,7 @@ async function generate(input, saveToFile = true) {
             const absolutePath = isAbsolute(result.filename)
                 ? result.filename
                 : join(input.cwd || process.cwd(), result.filename);
-            writeSync(absolutePath, result.content);
+            await writeFile(absolutePath, result.content);
             await lifecycleHooks(result.hooks).afterOneFileWrite(result.filename);
             await lifecycleHooks(config.hooks).afterOneFileWrite(result.filename);
         })), 'Write files');
@@ -1279,7 +1382,7 @@ async function generate(input, saveToFile = true) {
     await context.profiler.run(() => writeOutput(outputFiles), 'writeOutput');
     await context.profiler.run(() => lifecycleHooks(config.hooks).beforeDone(), 'Lifecycle: beforeDone');
     if (context.profilerOutput) {
-        writeSync(join(context.cwd, context.profilerOutput), JSON.stringify(context.profiler.collect()));
+        await writeFile(join(context.cwd, context.profilerOutput), JSON.stringify(context.profiler.collect()));
     }
     return outputFiles;
 }
@@ -1750,30 +1853,6 @@ function addIntrospection(config) {
     };
 }
 
-const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
-const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
-
-function cliError(err, exitOnError = true) {
-    let msg;
-    if (err instanceof Error) {
-        msg = err.message || err.toString();
-    }
-    else if (typeof err === 'string') {
-        msg = err;
-    }
-    else {
-        msg = JSON.stringify(err);
-    }
-    // eslint-disable-next-line no-console
-    console.error(msg);
-    if (exitOnError && isNode) {
-        process.exit(1);
-    }
-    else if (exitOnError && isBrowser) {
-        throw err;
-    }
-}
-
 async function runCli(cmd) {
     await ensureGraphQlPackage();
     switch (cmd) {
@@ -1803,4 +1882,4 @@ async function ensureGraphQlPackage() {
     }
 }
 
-export { CodegenContext, CodegenExtension, buildOptions, cliError, createContext, ensureContext, ensureGraphQlPackage, executeCodegen, findAndLoadGraphQLConfig, generate, generateSearchPlaces, init, loadCodegenConfig, loadContext, parseArgv, runCli, updateContextWithCliFlags };
+export { CodegenContext, CodegenExtension, buildOptions, cliError, createContext, ensureContext, ensureGraphQlPackage, executeCodegen, findAndLoadGraphQLConfig, generate, generateSearchPlaces, init, isListrError, loadCodegenConfig, loadContext, parseArgv, runCli, updateContextWithCliFlags };

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@graphql-codegen/cli",
-  "version": "2.5.0-alpha-fc06eb8e7.0",
+  "version": "2.6.0-alpha-c9d165f6a.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.5.0-alpha-fc06eb8e7.0",
-    "@graphql-codegen/plugin-helpers": "2.4.0-alpha-fc06eb8e7.0",
+    "@graphql-codegen/core": "2.5.0",
+    "@graphql-codegen/plugin-helpers": "^2.4.0",
     "@graphql-tools/apollo-engine-loader": "^7.0.5",
     "@graphql-tools/code-file-loader": "^7.0.6",
     "@graphql-tools/git-loader": "^7.0.5",
@@ -26,6 +26,7 @@
     "debounce": "^1.2.0",
     "dependency-graph": "^0.11.0",
     "detect-indent": "^6.0.0",
+    "fs-extra": "^9.1.0",
     "glob": "^7.1.6",
     "globby": "^11.0.4",
     "graphql-config": "^4.1.0",
@@ -37,7 +38,6 @@
     "listr-update-renderer": "^0.5.0",
     "log-symbols": "^4.0.0",
     "minimatch": "^3.0.4",
-    "mkdirp": "^1.0.4",
     "string-env-interpolation": "^1.0.1",
     "ts-log": "^2.2.3",
     "tslib": "~2.3.0",

package/utils/cli-error.d.ts

@@ -1 +1,11 @@
+import { DetailedError } from '@graphql-codegen/plugin-helpers';
+declare type CompositeError = Error | DetailedError;
+declare type ListrError = Error & {
+    errors: CompositeError[];
+};
+export declare function isListrError(err: Error & {
+    name?: unknown;
+    errors?: unknown;
+}): err is ListrError;
 export declare function cliError(err: any, exitOnError?: boolean): void;
+export {};

package/utils/file-system.d.ts

@@ -1,4 +1,4 @@
-export declare function writeSync(filepath: string, content: string): void;
-export declare function readSync(filepath: string): string;
-export declare function fileExists(filePath: string): boolean;
+export declare function writeFile(filepath: string, content: string): any;
+export declare function readFile(filepath: string): any;
+export declare function fileExists(filePath: string): Promise<boolean>;
 export declare function unlinkFile(filePath: string, cb?: (err?: Error) => any): void;