@graphql-codegen/cli 2.7.0 → 2.8.0-alpha-c108f8a9c.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/indentString.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indentString = void 0;
+/**
+Indent each line in a string.
+@param string - The string to indent.
+@param count - How many times you want `options.indent` repeated. Default: `1`.
+@example
+```
+import indentString from 'indent-string';
+indentString('Unicorns\nRainbows', 4);
+//=> '    Unicorns\n    Rainbows'
+indentString('Unicorns\nRainbows', 4, {indent: '♥'});
+//=> '♥♥♥♥Unicorns\n♥♥♥♥Rainbows'
+```
+*/
+function indentString(string, count = 1, options = {}) {
+    const { indent = ' ', includeEmptyLines = false } = options;
+    if (typeof string !== 'string') {
+        throw new TypeError(`Expected \`input\` to be a \`string\`, got \`${typeof string}\``);
+    }
+    if (typeof count !== 'number') {
+        throw new TypeError(`Expected \`count\` to be a \`number\`, got \`${typeof count}\``);
+    }
+    if (count < 0) {
+        throw new RangeError(`Expected \`count\` to be at least 0, got \`${count}\``);
+    }
+    if (typeof indent !== 'string') {
+        throw new TypeError(`Expected \`options.indent\` to be a \`string\`, got \`${typeof indent}\``);
+    }
+    if (count === 0) {
+        return string;
+    }
+    const regex = includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
+    return string.replace(regex, indent.repeat(count));
+}
+exports.indentString = indentString;

package/cjs/utils/listr-renderer.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorRenderer = exports.Renderer = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const indentString_js_1 = require("./indentString.js");
+const log_symbols_1 = tslib_1.__importDefault(require("log-symbols"));
+const ansi_escapes_1 = tslib_1.__importDefault(require("ansi-escapes"));
+const wrap_ansi_1 = tslib_1.__importDefault(require("wrap-ansi"));
+const common_tags_1 = require("common-tags");
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const debugging_js_1 = require("./debugging.js");
+const listr_update_renderer_1 = tslib_1.__importDefault(require("listr-update-renderer"));
+class Renderer {
+    constructor(tasks, options) {
+        this.updateRenderer = new listr_update_renderer_1.default(tasks, options);
+    }
+    render() {
+        return this.updateRenderer.render();
+    }
+    end(err) {
+        this.updateRenderer.end(err);
+        if (typeof err === 'undefined') {
+            logUpdate.clear();
+            return;
+        }
+        // persist the output
+        logUpdate.done();
+        // show errors
+        if (err) {
+            const errorCount = err.errors ? err.errors.length : 0;
+            if (errorCount > 0) {
+                const count = (0, indentString_js_1.indentString)(chalk_1.default.red.bold(`Found ${errorCount} error${errorCount > 1 ? 's' : ''}`), 1);
+                const details = err.errors
+                    .map(error => {
+                    (0, debugging_js_1.debugLog)(`[CLI] Exited with an error`, error);
+                    return { msg: (0, plugin_helpers_1.isDetailedError)(error) ? error.details : null, rawError: error };
+                })
+                    .map(({ msg, rawError }, i) => {
+                    const source = err.errors[i].source;
+                    msg = msg ? chalk_1.default.gray((0, indentString_js_1.indentString)((0, common_tags_1.stripIndent)(`${msg}`), 4)) : null;
+                    const stack = rawError.stack ? chalk_1.default.gray((0, indentString_js_1.indentString)((0, common_tags_1.stripIndent)(rawError.stack), 4)) : null;
+                    if (source) {
+                        const sourceOfError = typeof source === 'string' ? source : source.name;
+                        const title = (0, indentString_js_1.indentString)(`${log_symbols_1.default.error} ${sourceOfError}`, 2);
+                        return [title, msg, stack, stack].filter(Boolean).join('\n');
+                    }
+                    return [msg, stack].filter(Boolean).join('\n');
+                })
+                    .join('\n\n');
+                logUpdate.emit(['', count, details, ''].join('\n\n'));
+            }
+            else {
+                const details = err.details ? err.details : '';
+                logUpdate.emit(`${chalk_1.default.red.bold(`${(0, indentString_js_1.indentString)(err.message, 2)}`)}\n${details}\n${chalk_1.default.grey(err.stack)}`);
+            }
+        }
+        logUpdate.done();
+        (0, debugging_js_1.printLogs)();
+    }
+}
+exports.Renderer = Renderer;
+const render = tasks => {
+    for (const task of tasks) {
+        task.subscribe(event => {
+            if (event.type === 'SUBTASKS') {
+                render(task.subtasks);
+                return;
+            }
+            if (event.type === 'DATA') {
+                logUpdate.emit(chalk_1.default.dim(`${event.data}`));
+            }
+            logUpdate.done();
+        }, err => {
+            logUpdate.emit(err);
+            logUpdate.done();
+        });
+    }
+};
+class ErrorRenderer {
+    constructor(tasks, _options) {
+        this.tasks = tasks;
+    }
+    render() {
+        render(this.tasks);
+    }
+    static get nonTTY() {
+        return true;
+    }
+    end() { }
+}
+exports.ErrorRenderer = ErrorRenderer;
+class LogUpdate {
+    constructor() {
+        this.stream = process.stdout;
+        // state
+        this.previousLineCount = 0;
+        this.previousOutput = '';
+        this.previousWidth = this.getWidth();
+    }
+    emit(...args) {
+        let output = args.join(' ') + '\n';
+        const width = this.getWidth();
+        if (output === this.previousOutput && this.previousWidth === width) {
+            return;
+        }
+        this.previousOutput = output;
+        this.previousWidth = width;
+        output = (0, wrap_ansi_1.default)(output, width, {
+            trim: false,
+            hard: true,
+            wordWrap: false,
+        });
+        this.stream.write(ansi_escapes_1.default.eraseLines(this.previousLineCount) + output);
+        this.previousLineCount = output.split('\n').length;
+    }
+    clear() {
+        this.stream.write(ansi_escapes_1.default.eraseLines(this.previousLineCount));
+        this.previousOutput = '';
+        this.previousWidth = this.getWidth();
+        this.previousLineCount = 0;
+    }
+    done() {
+        this.previousOutput = '';
+        this.previousWidth = this.getWidth();
+        this.previousLineCount = 0;
+    }
+    getWidth() {
+        const { columns } = this.stream;
+        if (!columns) {
+            return 80;
+        }
+        return columns;
+    }
+}
+const logUpdate = new LogUpdate();

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
+`);
+    }
+}