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

package/bin.js

@@ -53,12 +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 crypto = require('crypto');
 const Listr = _interopDefault(require('listr'));
 const isGlob = _interopDefault(require('is-glob'));
 const debounce = _interopDefault(require('debounce'));
 const mkdirp = _interopDefault(require('mkdirp'));
-const crypto = require('crypto');
 const inquirer = _interopDefault(require('inquirer'));
 const detectIndent = _interopDefault(require('detect-indent'));
 const getLatestVersion = _interopDefault(require('latest-version'));
@@ -779,23 +778,52 @@ class CodegenContext {
         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 addHashToSchema(this._graphqlConfig.getProject(this._project).loadSchema(pointer, 'GraphQLSchema', config));
         }
-        return loadSchema(pointer, config);
+        return addHashToSchema(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 addHashToDocumentFiles(this._graphqlConfig.getProject(this._project).loadDocuments(pointer, config));
         }
-        return loadDocuments(pointer, config);
+        return addHashToDocumentFiles(loadDocuments(pointer, config));
     }
 }
 function ensureContext(input) {
     return input instanceof CodegenContext ? input : new CodegenContext({ config: input });
 }
+function hashContent(content) {
+    return crypto.createHash('sha256').update(content).digest('hex');
+}
+function hashSchema(schema) {
+    return hashContent(utils.printSchemaWithDirectives(schema, {
+        assumeValid: true,
+    }));
+}
+function addHashToSchema(schemaPromise) {
+    return schemaPromise.then(schema => {
+        // It's consumed later on. The general purpose is to use it for caching.
+        schema.extensions['hash'] = hashSchema(schema);
+        return schema;
+    });
+}
+function hashDocument(doc) {
+    if (doc.rawSDL) {
+        return hashContent(doc.rawSDL);
+    }
+    if (doc.document) {
+        return hashContent(graphql.print(doc.document));
+    }
+    return null;
+}
+function addHashToDocumentFiles(documentFilesPromise) {
+    return documentFilesPromise.then(documentFiles => documentFiles.map(doc => {
+        doc.hash = hashDocument(doc);
+        return doc;
+    }));
+}
 
 const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
@@ -833,18 +861,17 @@ const makeDefaultLoader = (from) => {
         return new Promise(function (resolve) { resolve(_interopNamespace(require(relativeRequire.resolve(mod)))); });
     };
 };
-// TODO: Replace any with types
-function createCache(loader) {
+function createCache() {
     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;
-        },
+    return function ensure(namespace, key, factory) {
+        const cacheKey = `${namespace}:${key}`;
+        const cachedValue = cache.get(cacheKey);
+        if (cachedValue) {
+            return cachedValue;
+        }
+        const value = factory();
+        cache.set(cacheKey, value);
+        return value;
     };
 }
 async function executeCodegen(input) {
@@ -883,20 +910,7 @@ 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: documents,
-        };
-    });
+    const cache = createCache();
     function wrapTask(task, source, taskName) {
         return () => {
             return context.profiler.run(async () => {
@@ -1014,7 +1028,14 @@ async function executeCodegen(input) {
                                         }
                                     }
                                     const hash = JSON.stringify(schemaPointerMap);
-                                    const result = await schemaLoadingCache.load(hash);
+                                    const result = await cache('schema', hash, async () => {
+                                        const outputSchemaAst = await context.loadSchema(schemaPointerMap);
+                                        const outputSchema = pluginHelpers.getCachedDocumentNodeFromSchema(outputSchemaAst);
+                                        return {
+                                            outputSchemaAst: outputSchemaAst,
+                                            outputSchema: outputSchema,
+                                        };
+                                    });
                                     outputSchemaAst = await result.outputSchemaAst;
                                     outputSchema = result.outputSchema;
                                 }, filename, `Load GraphQL schemas: ${filename}`),
@@ -1026,7 +1047,12 @@ async function executeCodegen(input) {
                                     // 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);
+                                        return cache('documents', hash, async () => {
+                                            const documents = await context.loadDocuments(docs);
+                                            return {
+                                                documents: documents,
+                                            };
+                                        });
                                     }));
                                     const documents = [];
                                     results.forEach(source => documents.push(...source.documents));
@@ -1072,6 +1098,7 @@ async function executeCodegen(input) {
                                             pluginMap,
                                             pluginContext,
                                             profiler: context.profiler,
+                                            cache,
                                         }), `Build Generates Section: ${filename}`);
                                     }
                                     else {
@@ -1086,6 +1113,7 @@ async function executeCodegen(input) {
                                                 pluginMap,
                                                 pluginContext,
                                                 profiler: context.profiler,
+                                                cache,
                                             },
                                         ];
                                     }
@@ -1109,7 +1137,8 @@ async function executeCodegen(input) {
             }), {
                 // it doesn't stop when one of tasks failed, to finish at least some of outputs
                 exitOnError: false,
-                concurrent: os.cpus().length,
+                // run 4 at once
+                concurrent: 4,
             });
         },
     });
@@ -1256,16 +1285,15 @@ const createWatcher = (initalContext, onNext) => {
     });
 };
 
-const { writeFile: fsWriteFile, readFile: fsReadFile, stat: fsStat } = fs.promises;
-function writeFile(filepath, content) {
-    return fsWriteFile(filepath, content);
+function writeSync(filepath, content) {
+    return fs.writeFileSync(filepath, content);
 }
-function readFile(filepath) {
-    return fsReadFile(filepath, 'utf-8');
+function readSync(filepath) {
+    return fs.readFileSync(filepath, 'utf-8');
 }
-async function fileExists(filePath) {
+function fileExists(filePath) {
     try {
-        return (await fsStat(filePath)).isFile();
+        return fs.statSync(filePath).isFile();
     }
     catch (err) {
         return false;
@@ -1287,7 +1315,7 @@ async function generate(input, saveToFile = true) {
         const staleFilenames = previouslyGeneratedFilenames.filter(f => !filenames.includes(f));
         staleFilenames.forEach(filename => {
             if (shouldOverwrite(config, filename)) {
-                return unlinkFile(filename, err => {
+                unlinkFile(filename, err => {
                     const prettyFilename = filename.replace(`${input.cwd || process.cwd()}/`, '');
                     if (err) {
                         debugLog(`Cannot remove stale file: ${prettyFilename}\n${err}`);
@@ -1308,39 +1336,7 @@ async function generate(input, saveToFile = true) {
         if (config.watch) {
             removeStaleFiles(config, generationResult);
         }
-        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(() => lifecycleHooks(config.hooks).beforeAllFileWrite(generationResult.map(r => r.filename)), 'Lifecycle: beforeAllFileWrite');
         await context.profiler.run(() => Promise.all(generationResult.map(async (result) => {
             const exists = fileExists(result.filename);
             if (!shouldOverwrite(config, result.filename) && exists) {
@@ -1350,7 +1346,7 @@ async function generate(input, saveToFile = true) {
             const currentHash = hash(content);
             let previousHash = recentOutputHash.get(result.filename);
             if (!previousHash && exists) {
-                previousHash = hash(await readFile(result.filename));
+                previousHash = hash(readSync(result.filename));
             }
             if (previousHash && currentHash === previousHash) {
                 debugLog(`Skipping file (${result.filename}) writing due to identical hash...`);
@@ -1367,7 +1363,7 @@ async function generate(input, saveToFile = true) {
             const absolutePath = path.isAbsolute(result.filename)
                 ? result.filename
                 : path.join(input.cwd || process.cwd(), result.filename);
-            await writeFile(absolutePath, result.content);
+            writeSync(absolutePath, result.content);
             await lifecycleHooks(result.hooks).afterOneFileWrite(result.filename);
             await lifecycleHooks(config.hooks).afterOneFileWrite(result.filename);
         })), 'Write files');
@@ -1382,7 +1378,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) {
-        await writeFile(path.join(context.cwd, context.profilerOutput), JSON.stringify(context.profiler.collect()));
+        writeSync(path.join(context.cwd, context.profilerOutput), JSON.stringify(context.profiler.collect()));
     }
     return outputFiles;
 }

package/index.js

@@ -53,13 +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 crypto = require('crypto');
 const Listr = _interopDefault(require('listr'));
 const child_process = require('child_process');
 const isGlob = _interopDefault(require('is-glob'));
 const debounce = _interopDefault(require('debounce'));
 const mkdirp = _interopDefault(require('mkdirp'));
-const crypto = require('crypto');
 const inquirer = _interopDefault(require('inquirer'));
 const detectIndent = _interopDefault(require('detect-indent'));
 const getLatestVersion = _interopDefault(require('latest-version'));
@@ -697,23 +696,52 @@ class CodegenContext {
         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 addHashToSchema(this._graphqlConfig.getProject(this._project).loadSchema(pointer, 'GraphQLSchema', config));
         }
-        return loadSchema(pointer, config);
+        return addHashToSchema(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 addHashToDocumentFiles(this._graphqlConfig.getProject(this._project).loadDocuments(pointer, config));
         }
-        return loadDocuments(pointer, config);
+        return addHashToDocumentFiles(loadDocuments(pointer, config));
     }
 }
 function ensureContext(input) {
     return input instanceof CodegenContext ? input : new CodegenContext({ config: input });
 }
+function hashContent(content) {
+    return crypto.createHash('sha256').update(content).digest('hex');
+}
+function hashSchema(schema) {
+    return hashContent(utils.printSchemaWithDirectives(schema, {
+        assumeValid: true,
+    }));
+}
+function addHashToSchema(schemaPromise) {
+    return schemaPromise.then(schema => {
+        // It's consumed later on. The general purpose is to use it for caching.
+        schema.extensions['hash'] = hashSchema(schema);
+        return schema;
+    });
+}
+function hashDocument(doc) {
+    if (doc.rawSDL) {
+        return hashContent(doc.rawSDL);
+    }
+    if (doc.document) {
+        return hashContent(graphql.print(doc.document));
+    }
+    return null;
+}
+function addHashToDocumentFiles(documentFilesPromise) {
+    return documentFilesPromise.then(documentFiles => documentFiles.map(doc => {
+        doc.hash = hashDocument(doc);
+        return doc;
+    }));
+}
 
 const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
@@ -751,18 +779,17 @@ const makeDefaultLoader = (from) => {
         return new Promise(function (resolve) { resolve(_interopNamespace(require(relativeRequire.resolve(mod)))); });
     };
 };
-// TODO: Replace any with types
-function createCache(loader) {
+function createCache() {
     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;
-        },
+    return function ensure(namespace, key, factory) {
+        const cacheKey = `${namespace}:${key}`;
+        const cachedValue = cache.get(cacheKey);
+        if (cachedValue) {
+            return cachedValue;
+        }
+        const value = factory();
+        cache.set(cacheKey, value);
+        return value;
     };
 }
 async function executeCodegen(input) {
@@ -801,20 +828,7 @@ 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: documents,
-        };
-    });
+    const cache = createCache();
     function wrapTask(task, source, taskName) {
         return () => {
             return context.profiler.run(async () => {
@@ -932,7 +946,14 @@ async function executeCodegen(input) {
                                         }
                                     }
                                     const hash = JSON.stringify(schemaPointerMap);
-                                    const result = await schemaLoadingCache.load(hash);
+                                    const result = await cache('schema', hash, async () => {
+                                        const outputSchemaAst = await context.loadSchema(schemaPointerMap);
+                                        const outputSchema = pluginHelpers.getCachedDocumentNodeFromSchema(outputSchemaAst);
+                                        return {
+                                            outputSchemaAst: outputSchemaAst,
+                                            outputSchema: outputSchema,
+                                        };
+                                    });
                                     outputSchemaAst = await result.outputSchemaAst;
                                     outputSchema = result.outputSchema;
                                 }, filename, `Load GraphQL schemas: ${filename}`),
@@ -944,7 +965,12 @@ async function executeCodegen(input) {
                                     // 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);
+                                        return cache('documents', hash, async () => {
+                                            const documents = await context.loadDocuments(docs);
+                                            return {
+                                                documents: documents,
+                                            };
+                                        });
                                     }));
                                     const documents = [];
                                     results.forEach(source => documents.push(...source.documents));
@@ -990,6 +1016,7 @@ async function executeCodegen(input) {
                                             pluginMap,
                                             pluginContext,
                                             profiler: context.profiler,
+                                            cache,
                                         }), `Build Generates Section: ${filename}`);
                                     }
                                     else {
@@ -1004,6 +1031,7 @@ async function executeCodegen(input) {
                                                 pluginMap,
                                                 pluginContext,
                                                 profiler: context.profiler,
+                                                cache,
                                             },
                                         ];
                                     }
@@ -1027,7 +1055,8 @@ async function executeCodegen(input) {
             }), {
                 // it doesn't stop when one of tasks failed, to finish at least some of outputs
                 exitOnError: false,
-                concurrent: os.cpus().length,
+                // run 4 at once
+                concurrent: 4,
             });
         },
     });
@@ -1257,16 +1286,15 @@ const createWatcher = (initalContext, onNext) => {
     });
 };
 
-const { writeFile: fsWriteFile, readFile: fsReadFile, stat: fsStat } = fs.promises;
-function writeFile(filepath, content) {
-    return fsWriteFile(filepath, content);
+function writeSync(filepath, content) {
+    return fs.writeFileSync(filepath, content);
 }
-function readFile(filepath) {
-    return fsReadFile(filepath, 'utf-8');
+function readSync(filepath) {
+    return fs.readFileSync(filepath, 'utf-8');
 }
-async function fileExists(filePath) {
+function fileExists(filePath) {
     try {
-        return (await fsStat(filePath)).isFile();
+        return fs.statSync(filePath).isFile();
     }
     catch (err) {
         return false;
@@ -1288,7 +1316,7 @@ async function generate(input, saveToFile = true) {
         const staleFilenames = previouslyGeneratedFilenames.filter(f => !filenames.includes(f));
         staleFilenames.forEach(filename => {
             if (shouldOverwrite(config, filename)) {
-                return unlinkFile(filename, err => {
+                unlinkFile(filename, err => {
                     const prettyFilename = filename.replace(`${input.cwd || process.cwd()}/`, '');
                     if (err) {
                         debugLog(`Cannot remove stale file: ${prettyFilename}\n${err}`);
@@ -1309,39 +1337,7 @@ async function generate(input, saveToFile = true) {
         if (config.watch) {
             removeStaleFiles(config, generationResult);
         }
-        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(() => lifecycleHooks(config.hooks).beforeAllFileWrite(generationResult.map(r => r.filename)), 'Lifecycle: beforeAllFileWrite');
         await context.profiler.run(() => Promise.all(generationResult.map(async (result) => {
             const exists = fileExists(result.filename);
             if (!shouldOverwrite(config, result.filename) && exists) {
@@ -1351,7 +1347,7 @@ async function generate(input, saveToFile = true) {
             const currentHash = hash(content);
             let previousHash = recentOutputHash.get(result.filename);
             if (!previousHash && exists) {
-                previousHash = hash(await readFile(result.filename));
+                previousHash = hash(readSync(result.filename));
             }
             if (previousHash && currentHash === previousHash) {
                 debugLog(`Skipping file (${result.filename}) writing due to identical hash...`);
@@ -1368,7 +1364,7 @@ async function generate(input, saveToFile = true) {
             const absolutePath = path.isAbsolute(result.filename)
                 ? result.filename
                 : path.join(input.cwd || process.cwd(), result.filename);
-            await writeFile(absolutePath, result.content);
+            writeSync(absolutePath, result.content);
             await lifecycleHooks(result.hooks).afterOneFileWrite(result.filename);
             await lifecycleHooks(config.hooks).afterOneFileWrite(result.filename);
         })), 'Write files');
@@ -1383,7 +1379,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) {
-        await writeFile(path.join(context.cwd, context.profilerOutput), JSON.stringify(context.profiler.collect()));
+        writeSync(path.join(context.cwd, context.profilerOutput), JSON.stringify(context.profiler.collect()));
     }
     return outputFiles;
 }

package/index.mjs

@@ -1,6 +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 { printSchemaWithDirectives, AggregateError, isValidPath } from '@graphql-tools/utils';
 import chalk from 'chalk';
 import logSymbols from 'log-symbols';
 import ansiEscapes from 'ansi-escapes';
@@ -8,7 +8,7 @@ import wrapAnsi from 'wrap-ansi';
 import { stripIndent } from 'common-tags';
 import { dummyLogger } from 'ts-log';
 import UpdateRenderer from 'listr-update-renderer';
-import { GraphQLError } from 'graphql';
+import { print, GraphQLError } from 'graphql';
 import path, { resolve, extname, join, delimiter, sep, dirname, isAbsolute, relative } from 'path';
 import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
 import { env } from 'string-env-interpolation';
@@ -25,14 +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, unlink, writeFileSync, readFileSync } from 'fs';
-import { cpus } from 'os';
+import fs, { promises, writeFileSync, readFileSync, statSync, unlink } from 'fs';
+import { createHash } from 'crypto';
 import Listr from 'listr';
 import { exec } from 'child_process';
 import isGlob from 'is-glob';
 import debounce from 'debounce';
 import mkdirp from 'mkdirp';
-import { createHash } from 'crypto';
 import inquirer from 'inquirer';
 import detectIndent from 'detect-indent';
 import getLatestVersion from 'latest-version';
@@ -670,23 +669,52 @@ class CodegenContext {
         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 addHashToSchema(this._graphqlConfig.getProject(this._project).loadSchema(pointer, 'GraphQLSchema', config));
         }
-        return loadSchema(pointer, config);
+        return addHashToSchema(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 addHashToDocumentFiles(this._graphqlConfig.getProject(this._project).loadDocuments(pointer, config));
         }
-        return loadDocuments(pointer, config);
+        return addHashToDocumentFiles(loadDocuments(pointer, config));
     }
 }
 function ensureContext(input) {
     return input instanceof CodegenContext ? input : new CodegenContext({ config: input });
 }
+function hashContent(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+function hashSchema(schema) {
+    return hashContent(printSchemaWithDirectives(schema, {
+        assumeValid: true,
+    }));
+}
+function addHashToSchema(schemaPromise) {
+    return schemaPromise.then(schema => {
+        // It's consumed later on. The general purpose is to use it for caching.
+        schema.extensions['hash'] = hashSchema(schema);
+        return schema;
+    });
+}
+function hashDocument(doc) {
+    if (doc.rawSDL) {
+        return hashContent(doc.rawSDL);
+    }
+    if (doc.document) {
+        return hashContent(print(doc.document));
+    }
+    return null;
+}
+function addHashToDocumentFiles(documentFilesPromise) {
+    return documentFilesPromise.then(documentFiles => documentFiles.map(doc => {
+        doc.hash = hashDocument(doc);
+        return doc;
+    }));
+}
 
 const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
@@ -724,18 +752,17 @@ const makeDefaultLoader = (from) => {
         return import(relativeRequire.resolve(mod));
     };
 };
-// TODO: Replace any with types
-function createCache(loader) {
+function createCache() {
     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;
-        },
+    return function ensure(namespace, key, factory) {
+        const cacheKey = `${namespace}:${key}`;
+        const cachedValue = cache.get(cacheKey);
+        if (cachedValue) {
+            return cachedValue;
+        }
+        const value = factory();
+        cache.set(cacheKey, value);
+        return value;
     };
 }
 async function executeCodegen(input) {
@@ -774,20 +801,7 @@ 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: documents,
-        };
-    });
+    const cache = createCache();
     function wrapTask(task, source, taskName) {
         return () => {
             return context.profiler.run(async () => {
@@ -905,7 +919,14 @@ async function executeCodegen(input) {
                                         }
                                     }
                                     const hash = JSON.stringify(schemaPointerMap);
-                                    const result = await schemaLoadingCache.load(hash);
+                                    const result = await cache('schema', hash, async () => {
+                                        const outputSchemaAst = await context.loadSchema(schemaPointerMap);
+                                        const outputSchema = getCachedDocumentNodeFromSchema(outputSchemaAst);
+                                        return {
+                                            outputSchemaAst: outputSchemaAst,
+                                            outputSchema: outputSchema,
+                                        };
+                                    });
                                     outputSchemaAst = await result.outputSchemaAst;
                                     outputSchema = result.outputSchema;
                                 }, filename, `Load GraphQL schemas: ${filename}`),
@@ -917,7 +938,12 @@ async function executeCodegen(input) {
                                     // 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);
+                                        return cache('documents', hash, async () => {
+                                            const documents = await context.loadDocuments(docs);
+                                            return {
+                                                documents: documents,
+                                            };
+                                        });
                                     }));
                                     const documents = [];
                                     results.forEach(source => documents.push(...source.documents));
@@ -963,6 +989,7 @@ async function executeCodegen(input) {
                                             pluginMap,
                                             pluginContext,
                                             profiler: context.profiler,
+                                            cache,
                                         }), `Build Generates Section: ${filename}`);
                                     }
                                     else {
@@ -977,6 +1004,7 @@ async function executeCodegen(input) {
                                                 pluginMap,
                                                 pluginContext,
                                                 profiler: context.profiler,
+                                                cache,
                                             },
                                         ];
                                     }
@@ -1000,7 +1028,8 @@ async function executeCodegen(input) {
             }), {
                 // it doesn't stop when one of tasks failed, to finish at least some of outputs
                 exitOnError: false,
-                concurrent: cpus().length,
+                // run 4 at once
+                concurrent: 4,
             });
         },
     });
@@ -1230,16 +1259,15 @@ const createWatcher = (initalContext, onNext) => {
     });
 };
 
-const { writeFile: fsWriteFile, readFile: fsReadFile, stat: fsStat } = promises;
-function writeFile(filepath, content) {
-    return fsWriteFile(filepath, content);
+function writeSync(filepath, content) {
+    return writeFileSync(filepath, content);
 }
-function readFile(filepath) {
-    return fsReadFile(filepath, 'utf-8');
+function readSync(filepath) {
+    return readFileSync(filepath, 'utf-8');
 }
-async function fileExists(filePath) {
+function fileExists(filePath) {
     try {
-        return (await fsStat(filePath)).isFile();
+        return statSync(filePath).isFile();
     }
     catch (err) {
         return false;
@@ -1261,7 +1289,7 @@ async function generate(input, saveToFile = true) {
         const staleFilenames = previouslyGeneratedFilenames.filter(f => !filenames.includes(f));
         staleFilenames.forEach(filename => {
             if (shouldOverwrite(config, filename)) {
-                return unlinkFile(filename, err => {
+                unlinkFile(filename, err => {
                     const prettyFilename = filename.replace(`${input.cwd || process.cwd()}/`, '');
                     if (err) {
                         debugLog(`Cannot remove stale file: ${prettyFilename}\n${err}`);
@@ -1282,39 +1310,7 @@ async function generate(input, saveToFile = true) {
         if (config.watch) {
             removeStaleFiles(config, generationResult);
         }
-        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(() => lifecycleHooks(config.hooks).beforeAllFileWrite(generationResult.map(r => r.filename)), 'Lifecycle: beforeAllFileWrite');
         await context.profiler.run(() => Promise.all(generationResult.map(async (result) => {
             const exists = fileExists(result.filename);
             if (!shouldOverwrite(config, result.filename) && exists) {
@@ -1324,7 +1320,7 @@ async function generate(input, saveToFile = true) {
             const currentHash = hash(content);
             let previousHash = recentOutputHash.get(result.filename);
             if (!previousHash && exists) {
-                previousHash = hash(await readFile(result.filename));
+                previousHash = hash(readSync(result.filename));
             }
             if (previousHash && currentHash === previousHash) {
                 debugLog(`Skipping file (${result.filename}) writing due to identical hash...`);
@@ -1341,7 +1337,7 @@ async function generate(input, saveToFile = true) {
             const absolutePath = isAbsolute(result.filename)
                 ? result.filename
                 : join(input.cwd || process.cwd(), result.filename);
-            await writeFile(absolutePath, result.content);
+            writeSync(absolutePath, result.content);
             await lifecycleHooks(result.hooks).afterOneFileWrite(result.filename);
             await lifecycleHooks(config.hooks).afterOneFileWrite(result.filename);
         })), 'Write files');
@@ -1356,7 +1352,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) {
-        await writeFile(join(context.cwd, context.profilerOutput), JSON.stringify(context.profiler.collect()));
+        writeSync(join(context.cwd, context.profilerOutput), JSON.stringify(context.profiler.collect()));
     }
     return outputFiles;
 }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@graphql-codegen/cli",
-  "version": "2.6.0-alpha-64b0da579.0",
+  "version": "2.6.0-alpha-a52c122aa.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",
-    "@graphql-codegen/plugin-helpers": "^2.4.0",
+    "@graphql-codegen/core": "2.6.0-alpha-a52c122aa.0",
+    "@graphql-codegen/plugin-helpers": "2.5.0-alpha-a52c122aa.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 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 writeSync(filepath: string, content: string): void;
+export declare function readSync(filepath: string): string;
+export declare function fileExists(filePath: string): boolean;
 export declare function unlinkFile(filePath: string, cb?: (err?: Error) => any): void;