@graphql-codegen/cli 2.6.0-alpha-bbecef04a.0 → 2.6.0-alpha-64b0da579.0

package/bin.js

@@ -53,6 +53,7 @@ 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'));
@@ -505,30 +506,20 @@ 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.
-
+    
       `);
     }
 }
-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) {
+async function loadDocuments(documentPointers, config) {
     const loaders = [
         new codeFileLoader.CodeFileLoader({
             pluckConfig: {
@@ -547,35 +538,14 @@ async function loadDocuments(documentPointers, config, schema) {
         }
         ignore.push(path.join(process.cwd(), generatePath));
     }
-    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, {
+    const loadedFromToolkit = await load.loadDocuments(documentPointers, {
         ...defaultDocumentsLoadOptions,
         ignore,
         loaders,
         ...config,
         ...config.config,
     });
-    const loadedAlterantively = await requiredLoader(requestPointers, schema);
-    return [...loadedFromToolkit, ...loadedAlterantively];
+    return loadedFromToolkit;
 }
 
 const { lstat } = fs.promises;
@@ -813,14 +783,14 @@ class CodegenContext {
         }
         return loadSchema(pointer, config);
     }
-    async loadDocuments(input) {
+    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(input.pointer, config);
+            const documents = await this._graphqlConfig.getProject(this._project).loadDocuments(pointer, config);
             return documents;
         }
-        return loadDocuments(input.pointer, config, input.schema);
+        return loadDocuments(pointer, config);
     }
 }
 function ensureContext(input) {
@@ -924,7 +894,7 @@ async function executeCodegen(input) {
     const documentsLoadingCache = createCache(async function (hash) {
         const documents = await context.loadDocuments(JSON.parse(hash));
         return {
-            documents,
+            documents: documents,
         };
     });
     function wrapTask(task, source, taskName) {
@@ -1055,7 +1025,7 @@ async function executeCodegen(input) {
                                     debugLog(`[CLI] Loading Documents`);
                                     // get different cache for shared docs and output specific docs
                                     const results = await Promise.all([rootDocuments, outputSpecificDocuments].map(docs => {
-                                        const hash = JSON.stringify({ pointer: docs, schema: outputSchema });
+                                        const hash = JSON.stringify(docs);
                                         return documentsLoadingCache.load(hash);
                                     }));
                                     const documents = [];
@@ -1139,8 +1109,7 @@ 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,
             });
         },
     });
@@ -1287,15 +1256,16 @@ const createWatcher = (initalContext, onNext) => {
     });
 };
 
-function writeSync(filepath, content) {
-    return fs.writeFileSync(filepath, content);
+const { writeFile: fsWriteFile, readFile: fsReadFile, stat: fsStat } = fs.promises;
+function writeFile(filepath, content) {
+    return fsWriteFile(filepath, content);
 }
-function readSync(filepath) {
-    return fs.readFileSync(filepath, 'utf-8');
+function readFile(filepath) {
+    return fsReadFile(filepath, 'utf-8');
 }
-function fileExists(filePath) {
+async function fileExists(filePath) {
     try {
-        return fs.statSync(filePath).isFile();
+        return (await fsStat(filePath)).isFile();
     }
     catch (err) {
         return false;
@@ -1317,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}`);
@@ -1338,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 = path.dirname(result.filename);
+                await lifecycleHooks(result.hooks).beforeOneFileWrite(result.filename);
+                await lifecycleHooks(config.hooks).beforeOneFileWrite(result.filename);
+                await 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) {
@@ -1348,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...`);
@@ -1365,7 +1367,7 @@ async function generate(input, saveToFile = true) {
             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');
@@ -1380,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(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;
 }

package/codegen.d.ts

@@ -1,4 +1,3 @@
 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

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

package/index.js

@@ -53,6 +53,7 @@ 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'));
@@ -423,30 +424,20 @@ 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.
-
+    
       `);
     }
 }
-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) {
+async function loadDocuments(documentPointers, config) {
     const loaders = [
         new codeFileLoader.CodeFileLoader({
             pluckConfig: {
@@ -465,35 +456,14 @@ async function loadDocuments(documentPointers, config, schema) {
         }
         ignore.push(path.join(process.cwd(), generatePath));
     }
-    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, {
+    const loadedFromToolkit = await load.loadDocuments(documentPointers, {
         ...defaultDocumentsLoadOptions,
         ignore,
         loaders,
         ...config,
         ...config.config,
     });
-    const loadedAlterantively = await requiredLoader(requestPointers, schema);
-    return [...loadedFromToolkit, ...loadedAlterantively];
+    return loadedFromToolkit;
 }
 
 const { lstat } = fs.promises;
@@ -731,14 +701,14 @@ class CodegenContext {
         }
         return loadSchema(pointer, config);
     }
-    async loadDocuments(input) {
+    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(input.pointer, config);
+            const documents = await this._graphqlConfig.getProject(this._project).loadDocuments(pointer, config);
             return documents;
         }
-        return loadDocuments(input.pointer, config, input.schema);
+        return loadDocuments(pointer, config);
     }
 }
 function ensureContext(input) {
@@ -842,7 +812,7 @@ async function executeCodegen(input) {
     const documentsLoadingCache = createCache(async function (hash) {
         const documents = await context.loadDocuments(JSON.parse(hash));
         return {
-            documents,
+            documents: documents,
         };
     });
     function wrapTask(task, source, taskName) {
@@ -973,7 +943,7 @@ async function executeCodegen(input) {
                                     debugLog(`[CLI] Loading Documents`);
                                     // get different cache for shared docs and output specific docs
                                     const results = await Promise.all([rootDocuments, outputSpecificDocuments].map(docs => {
-                                        const hash = JSON.stringify({ pointer: docs, schema: outputSchema });
+                                        const hash = JSON.stringify(docs);
                                         return documentsLoadingCache.load(hash);
                                     }));
                                     const documents = [];
@@ -1057,8 +1027,7 @@ 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,
             });
         },
     });
@@ -1288,15 +1257,16 @@ const createWatcher = (initalContext, onNext) => {
     });
 };
 
-function writeSync(filepath, content) {
-    return fs.writeFileSync(filepath, content);
+const { writeFile: fsWriteFile, readFile: fsReadFile, stat: fsStat } = fs.promises;
+function writeFile(filepath, content) {
+    return fsWriteFile(filepath, content);
 }
-function readSync(filepath) {
-    return fs.readFileSync(filepath, 'utf-8');
+function readFile(filepath) {
+    return fsReadFile(filepath, 'utf-8');
 }
-function fileExists(filePath) {
+async function fileExists(filePath) {
     try {
-        return fs.statSync(filePath).isFile();
+        return (await fsStat(filePath)).isFile();
     }
     catch (err) {
         return false;
@@ -1318,7 +1288,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}`);
@@ -1339,7 +1309,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 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) {
@@ -1349,7 +1351,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...`);
@@ -1366,7 +1368,7 @@ async function generate(input, saveToFile = true) {
             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');
@@ -1381,7 +1383,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;
 }

package/index.mjs

@@ -25,7 +25,8 @@ 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, unlink, writeFileSync, readFileSync } from 'fs';
+import { cpus } from 'os';
 import Listr from 'listr';
 import { exec } from 'child_process';
 import isGlob from 'is-glob';
@@ -396,30 +397,20 @@ 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.
-
+    
       `);
     }
 }
-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) {
+async function loadDocuments(documentPointers, config) {
     const loaders = [
         new CodeFileLoader({
             pluckConfig: {
@@ -438,35 +429,14 @@ async function loadDocuments(documentPointers, config, schema) {
         }
         ignore.push(join(process.cwd(), generatePath));
     }
-    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, {
+    const loadedFromToolkit = await loadDocuments$1(documentPointers, {
         ...defaultDocumentsLoadOptions,
         ignore,
         loaders,
         ...config,
         ...config.config,
     });
-    const loadedAlterantively = await requiredLoader(requestPointers, schema);
-    return [...loadedFromToolkit, ...loadedAlterantively];
+    return loadedFromToolkit;
 }
 
 const { lstat } = promises;
@@ -704,14 +674,14 @@ class CodegenContext {
         }
         return loadSchema(pointer, config);
     }
-    async loadDocuments(input) {
+    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(input.pointer, config);
+            const documents = await this._graphqlConfig.getProject(this._project).loadDocuments(pointer, config);
             return documents;
         }
-        return loadDocuments(input.pointer, config, input.schema);
+        return loadDocuments(pointer, config);
     }
 }
 function ensureContext(input) {
@@ -815,7 +785,7 @@ async function executeCodegen(input) {
     const documentsLoadingCache = createCache(async function (hash) {
         const documents = await context.loadDocuments(JSON.parse(hash));
         return {
-            documents,
+            documents: documents,
         };
     });
     function wrapTask(task, source, taskName) {
@@ -946,7 +916,7 @@ async function executeCodegen(input) {
                                     debugLog(`[CLI] Loading Documents`);
                                     // get different cache for shared docs and output specific docs
                                     const results = await Promise.all([rootDocuments, outputSpecificDocuments].map(docs => {
-                                        const hash = JSON.stringify({ pointer: docs, schema: outputSchema });
+                                        const hash = JSON.stringify(docs);
                                         return documentsLoadingCache.load(hash);
                                     }));
                                     const documents = [];
@@ -1030,8 +1000,7 @@ 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,
             });
         },
     });
@@ -1261,15 +1230,16 @@ const createWatcher = (initalContext, onNext) => {
     });
 };
 
-function writeSync(filepath, content) {
-    return writeFileSync(filepath, content);
+const { writeFile: fsWriteFile, readFile: fsReadFile, stat: fsStat } = promises;
+function writeFile(filepath, content) {
+    return fsWriteFile(filepath, content);
 }
-function readSync(filepath) {
-    return readFileSync(filepath, 'utf-8');
+function readFile(filepath) {
+    return fsReadFile(filepath, 'utf-8');
 }
-function fileExists(filePath) {
+async function fileExists(filePath) {
     try {
-        return statSync(filePath).isFile();
+        return (await fsStat(filePath)).isFile();
     }
     catch (err) {
         return false;
@@ -1291,7 +1261,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}`);
@@ -1312,7 +1282,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) {
@@ -1322,7 +1324,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...`);
@@ -1339,7 +1341,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');
@@ -1354,7 +1356,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;
 }

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, schema: GraphQLSchema): Promise<Types.DocumentFile[]>;
+export declare function loadDocuments(documentPointers: UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[], config: Types.Config): Promise<Types.DocumentFile[]>;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@graphql-codegen/cli",
-  "version": "2.6.0-alpha-bbecef04a.0",
+  "version": "2.6.0-alpha-64b0da579.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.1-alpha-bbecef04a.0",
-    "@graphql-codegen/plugin-helpers": "2.4.1-alpha-bbecef04a.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",

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): Promise<void>;
+export declare function readFile(filepath: string): Promise<string>;
+export declare function fileExists(filePath: string): Promise<boolean>;
 export declare function unlinkFile(filePath: string, cb?: (err?: Error) => any): void;