@graphql-codegen/cli 2.7.0 → 2.7.1-alpha-223b75f49.0

package/cjs/utils/file-system.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unlinkFile = exports.fileExists = exports.readFile = exports.writeFile = void 0;
+const fs_1 = require("fs");
+const { writeFile: fsWriteFile, readFile: fsReadFile, stat: fsStat } = fs_1.promises;
+function writeFile(filepath, content) {
+    return fsWriteFile(filepath, content);
+}
+exports.writeFile = writeFile;
+function readFile(filepath) {
+    return fsReadFile(filepath, 'utf-8');
+}
+exports.readFile = readFile;
+async function fileExists(filePath) {
+    try {
+        return (await fsStat(filePath)).isFile();
+    }
+    catch (err) {
+        return false;
+    }
+}
+exports.fileExists = fileExists;
+function unlinkFile(filePath, cb) {
+    (0, fs_1.unlink)(filePath, cb);
+}
+exports.unlinkFile = unlinkFile;

package/cjs/utils/logger.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useWinstonLogger = exports.setSilentLogger = exports.setLogger = exports.getLogger = void 0;
+const ts_log_1 = require("ts-log");
+let logger;
+function getLogger() {
+    return logger || ts_log_1.dummyLogger;
+}
+exports.getLogger = getLogger;
+useWinstonLogger();
+function setLogger(newLogger) {
+    logger = newLogger;
+}
+exports.setLogger = setLogger;
+function setSilentLogger() {
+    logger = ts_log_1.dummyLogger;
+}
+exports.setSilentLogger = setSilentLogger;
+function useWinstonLogger() {
+    if (logger && logger.levels) {
+        return;
+    }
+    logger = console;
+}
+exports.useWinstonLogger = useWinstonLogger;

package/cjs/utils/watcher.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWatcher = void 0;
+const tslib_1 = require("tslib");
+const codegen_js_1 = require("../codegen.js");
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const is_glob_1 = tslib_1.__importDefault(require("is-glob"));
+const debounce_1 = tslib_1.__importDefault(require("debounce"));
+const log_symbols_1 = tslib_1.__importDefault(require("log-symbols"));
+const debugging_js_1 = require("./debugging.js");
+const logger_js_1 = require("./logger.js");
+const path_1 = require("path");
+const hooks_js_1 = require("../hooks.js");
+const config_js_1 = require("../config.js");
+const utils_1 = require("@graphql-tools/utils");
+function log(msg) {
+    // double spaces to inline the message with Listr
+    (0, logger_js_1.getLogger)().info(`  ${msg}`);
+}
+function emitWatching() {
+    log(`${log_symbols_1.default.info} Watching for changes...`);
+}
+const createWatcher = (initalContext, onNext) => {
+    (0, debugging_js_1.debugLog)(`[Watcher] Starting watcher...`);
+    let config = initalContext.getConfig();
+    const files = [initalContext.filepath].filter(a => a);
+    const documents = (0, plugin_helpers_1.normalizeInstanceOrArray)(config.documents);
+    const schemas = (0, plugin_helpers_1.normalizeInstanceOrArray)(config.schema);
+    // Add schemas and documents from "generates"
+    Object.keys(config.generates)
+        .map(filename => (0, plugin_helpers_1.normalizeOutputParam)(config.generates[filename]))
+        .forEach(conf => {
+        schemas.push(...(0, plugin_helpers_1.normalizeInstanceOrArray)(conf.schema));
+        documents.push(...(0, plugin_helpers_1.normalizeInstanceOrArray)(conf.documents));
+    });
+    if (documents) {
+        documents.forEach(doc => {
+            if (typeof doc === 'string') {
+                files.push(doc);
+            }
+            else {
+                files.push(...Object.keys(doc));
+            }
+        });
+    }
+    schemas.forEach((schema) => {
+        if ((0, is_glob_1.default)(schema) || (0, utils_1.isValidPath)(schema)) {
+            files.push(schema);
+        }
+    });
+    if (typeof config.watch !== 'boolean') {
+        files.push(...(0, plugin_helpers_1.normalizeInstanceOrArray)(config.watch));
+    }
+    let watcher;
+    const runWatcher = async () => {
+        var _a, _b;
+        const chokidar = await Promise.resolve().then(() => tslib_1.__importStar(require('chokidar')));
+        let isShutdown = false;
+        const debouncedExec = (0, debounce_1.default)(() => {
+            if (!isShutdown) {
+                (0, codegen_js_1.executeCodegen)(initalContext)
+                    .then(onNext, () => Promise.resolve())
+                    .then(() => emitWatching());
+            }
+        }, 100);
+        emitWatching();
+        const ignored = [];
+        Object.keys(config.generates)
+            .map(filename => ({ filename, config: (0, plugin_helpers_1.normalizeOutputParam)(config.generates[filename]) }))
+            .forEach(entry => {
+            if (entry.config.preset) {
+                const extension = entry.config.presetConfig && entry.config.presetConfig.extension;
+                if (extension) {
+                    ignored.push((0, path_1.join)(entry.filename, '**', '*' + extension));
+                }
+            }
+            else {
+                ignored.push(entry.filename);
+            }
+        });
+        watcher = chokidar.watch(files, {
+            persistent: true,
+            ignoreInitial: true,
+            followSymlinks: true,
+            cwd: process.cwd(),
+            disableGlobbing: false,
+            usePolling: (_a = config.watchConfig) === null || _a === void 0 ? void 0 : _a.usePolling,
+            interval: (_b = config.watchConfig) === null || _b === void 0 ? void 0 : _b.interval,
+            depth: 99,
+            awaitWriteFinish: true,
+            ignorePermissionErrors: false,
+            atomic: true,
+            ignored,
+        });
+        (0, debugging_js_1.debugLog)(`[Watcher] Started`);
+        const shutdown = () => {
+            isShutdown = true;
+            (0, debugging_js_1.debugLog)(`[Watcher] Shutting down`);
+            log(`Shutting down watch...`);
+            watcher.close();
+            (0, hooks_js_1.lifecycleHooks)(config.hooks).beforeDone();
+        };
+        // it doesn't matter what has changed, need to run whole process anyway
+        watcher.on('all', async (eventName, path) => {
+            (0, hooks_js_1.lifecycleHooks)(config.hooks).onWatchTriggered(eventName, path);
+            (0, debugging_js_1.debugLog)(`[Watcher] triggered due to a file ${eventName} event: ${path}`);
+            const fullPath = (0, path_1.join)(process.cwd(), path);
+            // In ESM require is not defined
+            try {
+                delete require.cache[fullPath];
+            }
+            catch (err) { }
+            if (eventName === 'change' && config.configFilePath && fullPath === config.configFilePath) {
+                log(`${log_symbols_1.default.info} Config file has changed, reloading...`);
+                const context = await (0, config_js_1.loadContext)(config.configFilePath);
+                const newParsedConfig = context.getConfig();
+                newParsedConfig.watch = config.watch;
+                newParsedConfig.silent = config.silent;
+                newParsedConfig.overwrite = config.overwrite;
+                newParsedConfig.configFilePath = config.configFilePath;
+                config = newParsedConfig;
+                initalContext.updateConfig(config);
+            }
+            debouncedExec();
+        });
+        process.once('SIGINT', shutdown);
+        process.once('SIGTERM', shutdown);
+    };
+    // the promise never resolves to keep process running
+    return new Promise((resolve, reject) => {
+        (0, codegen_js_1.executeCodegen)(initalContext)
+            .then(onNext, () => Promise.resolve())
+            .then(runWatcher)
+            .catch(err => {
+            watcher.close();
+            reject(err);
+        });
+    });
+};
+exports.createWatcher = createWatcher;

package/esm/bin.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { runCli } from './cli.js';
+import { cliError } from './utils/cli-error.js';
+const [, , cmd] = process.argv;
+runCli(cmd)
+    .then(() => {
+    process.exit(0);
+})
+    .catch(error => {
+    cliError(error);
+});

package/esm/cli.js

@@ -0,0 +1,32 @@
+import { generate } from './generate-and-save.js';
+import { init } from './init/index.js';
+import { createContext } from './config.js';
+import { lifecycleHooks } from './hooks.js';
+import { DetailedError } from '@graphql-codegen/plugin-helpers';
+export async function runCli(cmd) {
+    await ensureGraphQlPackage();
+    if (cmd === 'init') {
+        return init();
+    }
+    const context = await createContext();
+    try {
+        return await generate(context);
+    }
+    catch (error) {
+        await lifecycleHooks(context.getConfig().hooks).onError(error.toString());
+        throw error;
+    }
+}
+export async function ensureGraphQlPackage() {
+    try {
+        await import('graphql');
+    }
+    catch (e) {
+        throw new DetailedError(`Unable to load "graphql" package. Please make sure to install "graphql" as a dependency!`, `
+  To install "graphql", run:
+    yarn add graphql
+  Or, with NPM:
+    npm install --save graphql
+`);
+    }
+}

package/esm/codegen.js

@@ -0,0 +1,314 @@
+import { DetailedError, normalizeOutputParam, normalizeInstanceOrArray, normalizeConfig, getCachedDocumentNodeFromSchema, isDetailedError, } from '@graphql-codegen/plugin-helpers';
+import { codegen } from '@graphql-codegen/core';
+import { AggregateError } from '@graphql-tools/utils';
+import { GraphQLError } from 'graphql';
+import { getPluginByName } from './plugins.js';
+import { getPresetByName } from './presets.js';
+import { debugLog } from './utils/debugging.js';
+import { ensureContext } from './config.js';
+import fs from 'fs';
+import path from 'path';
+import { cpus } from 'os';
+import { createRequire } from 'module';
+import { Listr } from 'listr2';
+/**
+ * Poor mans ESM detection.
+ * Looking at this and you have a better method?
+ * Send a PR.
+ */
+const isESMModule = (typeof __dirname === 'string') === false;
+const makeDefaultLoader = (from) => {
+    if (fs.statSync(from).isDirectory()) {
+        from = path.join(from, '__fake.js');
+    }
+    const relativeRequire = createRequire(from);
+    return async (mod) => {
+        return import(isESMModule
+            ? /**
+               * For ESM we currently have no "resolve path" solution
+               * as import.meta is unavailable in a CommonJS context
+               * and furthermore unavailable in stable Node.js.
+               **/
+                mod
+            : relativeRequire.resolve(mod));
+    };
+};
+function createCache() {
+    const cache = new Map();
+    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;
+    };
+}
+export async function executeCodegen(input) {
+    const context = ensureContext(input);
+    const config = context.getConfig();
+    const pluginContext = context.getPluginContext();
+    const result = [];
+    let rootConfig = {};
+    let rootSchemas;
+    let rootDocuments;
+    const generates = {};
+    const cache = createCache();
+    function wrapTask(task, source, taskName, ctx) {
+        return () => {
+            return context.profiler.run(async () => {
+                try {
+                    await Promise.resolve().then(() => task());
+                }
+                catch (error) {
+                    if (source && !(error instanceof GraphQLError)) {
+                        error.source = source;
+                    }
+                    ctx.errors.push(error);
+                    throw error;
+                }
+            }, taskName);
+        };
+    }
+    async function normalize() {
+        /* Load Require extensions */
+        const requireExtensions = normalizeInstanceOrArray(config.require);
+        const loader = makeDefaultLoader(context.cwd);
+        for (const mod of requireExtensions) {
+            await loader(mod);
+        }
+        /* Root plugin  config */
+        rootConfig = config.config || {};
+        /* Normalize root "schema" field */
+        rootSchemas = normalizeInstanceOrArray(config.schema);
+        /* Normalize root "documents" field */
+        rootDocuments = normalizeInstanceOrArray(config.documents);
+        /* Normalize "generators" field */
+        const generateKeys = Object.keys(config.generates || {});
+        if (generateKeys.length === 0) {
+            throw new DetailedError('Invalid Codegen Configuration!', `
+        Please make sure that your codegen config file contains the "generates" field, with a specification for the plugins you need.
+
+        It should looks like that:
+
+        schema:
+          - my-schema.graphql
+        generates:
+          my-file.ts:
+            - plugin1
+            - plugin2
+            - plugin3
+        `);
+        }
+        for (const filename of generateKeys) {
+            const output = (generates[filename] = normalizeOutputParam(config.generates[filename]));
+            if (!output.preset && (!output.plugins || output.plugins.length === 0)) {
+                throw new DetailedError('Invalid Codegen Configuration!', `
+          Please make sure that your codegen config file has defined plugins list for output "${filename}".
+
+          It should looks like that:
+
+          schema:
+            - my-schema.graphql
+          generates:
+            my-file.ts:
+              - plugin1
+              - plugin2
+              - plugin3
+          `);
+            }
+        }
+        if (rootSchemas.length === 0 &&
+            Object.keys(generates).some(filename => !generates[filename].schema || generates[filename].schema.length === 0)) {
+            throw new DetailedError('Invalid Codegen Configuration!', `
+        Please make sure that your codegen config file contains either the "schema" field
+        or every generated file has its own "schema" field.
+
+        It should looks like that:
+        schema:
+          - my-schema.graphql
+
+        or:
+        generates:
+          path/to/output:
+            schema: my-schema.graphql
+      `);
+        }
+    }
+    const isTest = process.env.NODE_ENV === 'test';
+    const tasks = new Listr([
+        {
+            title: 'Parse Configuration',
+            task: () => normalize(),
+        },
+        {
+            title: 'Generate outputs',
+            task: (ctx, task) => {
+                const generateTasks = Object.keys(generates).map(filename => {
+                    const outputConfig = generates[filename];
+                    const hasPreset = !!outputConfig.preset;
+                    const title = hasPreset
+                        ? `Generate to ${filename} (using EXPERIMENTAL preset "${outputConfig.preset}")`
+                        : `Generate ${filename}`;
+                    return {
+                        title,
+                        task: (_, subTask) => {
+                            let outputSchemaAst;
+                            let outputSchema;
+                            const outputFileTemplateConfig = outputConfig.config || {};
+                            let outputDocuments = [];
+                            const outputSpecificSchemas = normalizeInstanceOrArray(outputConfig.schema);
+                            const outputSpecificDocuments = normalizeInstanceOrArray(outputConfig.documents);
+                            return subTask.newListr([
+                                {
+                                    title: 'Load GraphQL schemas',
+                                    task: wrapTask(async () => {
+                                        debugLog(`[CLI] Loading Schemas`);
+                                        const schemaPointerMap = {};
+                                        const allSchemaDenormalizedPointers = [...rootSchemas, ...outputSpecificSchemas];
+                                        for (const denormalizedPtr of allSchemaDenormalizedPointers) {
+                                            if (typeof denormalizedPtr === 'string') {
+                                                schemaPointerMap[denormalizedPtr] = {};
+                                            }
+                                            else if (typeof denormalizedPtr === 'object') {
+                                                Object.assign(schemaPointerMap, denormalizedPtr);
+                                            }
+                                        }
+                                        const hash = JSON.stringify(schemaPointerMap);
+                                        const result = await cache('schema', hash, async () => {
+                                            const outputSchemaAst = await context.loadSchema(schemaPointerMap);
+                                            const outputSchema = getCachedDocumentNodeFromSchema(outputSchemaAst);
+                                            return {
+                                                outputSchemaAst,
+                                                outputSchema,
+                                            };
+                                        });
+                                        outputSchemaAst = result.outputSchemaAst;
+                                        outputSchema = result.outputSchema;
+                                    }, filename, `Load GraphQL schemas: ${filename}`, ctx),
+                                },
+                                {
+                                    title: 'Load GraphQL documents',
+                                    task: wrapTask(async () => {
+                                        debugLog(`[CLI] Loading Documents`);
+                                        const documentPointerMap = {};
+                                        const allDocumentsDenormalizedPointers = [...rootDocuments, ...outputSpecificDocuments];
+                                        for (const denormalizedPtr of allDocumentsDenormalizedPointers) {
+                                            if (typeof denormalizedPtr === 'string') {
+                                                documentPointerMap[denormalizedPtr] = {};
+                                            }
+                                            else if (typeof denormalizedPtr === 'object') {
+                                                Object.assign(documentPointerMap, denormalizedPtr);
+                                            }
+                                        }
+                                        const hash = JSON.stringify(documentPointerMap);
+                                        const result = await cache('documents', hash, async () => {
+                                            const documents = await context.loadDocuments(documentPointerMap);
+                                            return {
+                                                documents,
+                                            };
+                                        });
+                                        outputDocuments = result.documents;
+                                    }, filename, `Load GraphQL documents: ${filename}`, ctx),
+                                },
+                                {
+                                    title: 'Generate',
+                                    task: wrapTask(async () => {
+                                        debugLog(`[CLI] Generating output`);
+                                        const normalizedPluginsArray = normalizeConfig(outputConfig.plugins);
+                                        const pluginLoader = config.pluginLoader || makeDefaultLoader(context.cwd);
+                                        const pluginPackages = await Promise.all(normalizedPluginsArray.map(plugin => getPluginByName(Object.keys(plugin)[0], pluginLoader)));
+                                        const preset = hasPreset
+                                            ? typeof outputConfig.preset === 'string'
+                                                ? await getPresetByName(outputConfig.preset, makeDefaultLoader(context.cwd))
+                                                : outputConfig.preset
+                                            : null;
+                                        const pluginMap = Object.fromEntries(pluginPackages.map((pkg, i) => {
+                                            const plugin = normalizedPluginsArray[i];
+                                            const name = Object.keys(plugin)[0];
+                                            return [name, pkg];
+                                        }));
+                                        const mergedConfig = {
+                                            ...rootConfig,
+                                            ...(typeof outputFileTemplateConfig === 'string'
+                                                ? { value: outputFileTemplateConfig }
+                                                : outputFileTemplateConfig),
+                                        };
+                                        const outputs = hasPreset
+                                            ? await context.profiler.run(async () => preset.buildGeneratesSection({
+                                                baseOutputDir: filename,
+                                                presetConfig: outputConfig.presetConfig || {},
+                                                plugins: normalizedPluginsArray,
+                                                schema: outputSchema,
+                                                schemaAst: outputSchemaAst,
+                                                documents: outputDocuments,
+                                                config: mergedConfig,
+                                                pluginMap,
+                                                pluginContext,
+                                                profiler: context.profiler,
+                                            }), `Build Generates Section: ${filename}`)
+                                            : [
+                                                {
+                                                    filename,
+                                                    plugins: normalizedPluginsArray,
+                                                    schema: outputSchema,
+                                                    schemaAst: outputSchemaAst,
+                                                    documents: outputDocuments,
+                                                    config: mergedConfig,
+                                                    pluginMap,
+                                                    pluginContext,
+                                                    profiler: context.profiler,
+                                                },
+                                            ];
+                                        const process = async (outputArgs) => {
+                                            const output = await codegen({
+                                                ...outputArgs,
+                                                cache,
+                                            });
+                                            result.push({
+                                                filename: outputArgs.filename,
+                                                content: output,
+                                                hooks: outputConfig.hooks || {},
+                                            });
+                                        };
+                                        await context.profiler.run(() => Promise.all(outputs.map(process)), `Codegen: ${filename}`);
+                                    }, filename, `Generate: ${filename}`, ctx),
+                                },
+                            ], {
+                                // it stops when of the tasks failed
+                                exitOnError: true,
+                            });
+                        },
+                        // It doesn't stop when one of tasks failed, to finish at least some of outputs
+                        exitOnError: false,
+                        concurrent: cpus().length,
+                    };
+                });
+                return task.newListr(generateTasks);
+            },
+        },
+    ], {
+        rendererOptions: {
+            clearOutput: false,
+            collapse: true,
+        },
+        ctx: { errors: [] },
+        rendererSilent: isTest || config.silent,
+        exitOnError: true,
+    });
+    // All the errors throw in `listr2` are collected in context
+    // Running tasks doesn't throw anything
+    const executedContext = await tasks.run();
+    if (executedContext.errors.length > 0) {
+        const errors = executedContext.errors.map(subErr => isDetailedError(subErr)
+            ? `${subErr.message} for "${subErr.source}"${subErr.details}`
+            : subErr.message || subErr.toString());
+        const newErr = new AggregateError(executedContext.errors, `${errors.join('\n\n')}`);
+        // Best-effort to all stack traces for debugging
+        newErr.stack = `${newErr.stack}\n\n${executedContext.errors.map(subErr => subErr.stack).join('\n\n')}`;
+        throw newErr;
+    }
+    return result;
+}