@graphql-codegen/cli 2.6.5-alpha-acacb9e7a.0 → 2.6.5-alpha-2f4ab8fa6.0

package/index.mjs

@@ -1,9 +1,15 @@
-import { DetailedError, createNoopProfiler, createProfiler, getCachedDocumentNodeFromSchema, normalizeInstanceOrArray, normalizeConfig, isDetailedError, normalizeOutputParam } from '@graphql-codegen/plugin-helpers';
+import { isDetailedError, DetailedError, createNoopProfiler, createProfiler, getCachedDocumentNodeFromSchema, normalizeInstanceOrArray, normalizeConfig, normalizeOutputParam } from '@graphql-codegen/plugin-helpers';
 import { codegen } from '@graphql-codegen/core';
 import { AggregateError, isValidPath } from '@graphql-tools/utils';
+import chalk from 'chalk';
+import logSymbols from 'log-symbols';
+import ansiEscapes from 'ansi-escapes';
+import wrapAnsi from 'wrap-ansi';
+import { stripIndent } from 'common-tags';
+import { dummyLogger } from 'ts-log';
+import UpdateRenderer from 'listr-update-renderer';
 import { print, GraphQLError } from 'graphql';
 import path, { resolve, extname, join, delimiter, sep, dirname, isAbsolute, relative } from 'path';
-import { dummyLogger } from 'ts-log';
 import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
 import { env } from 'string-env-interpolation';
 import yargs from 'yargs';
@@ -22,17 +28,204 @@ import { createRequire } from 'module';
 import fs, { promises, unlink, writeFileSync, readFileSync } from 'fs';
 import { createHash } from 'crypto';
 import { cpus } from 'os';
-import { Listr } from 'listr2';
+import Listr from 'listr';
 import { exec } from 'child_process';
 import isGlob from 'is-glob';
 import debounce from 'debounce';
-import logSymbols from 'log-symbols';
 import mkdirp from 'mkdirp';
 import inquirer from 'inquirer';
-import chalk from 'chalk';
 import detectIndent from 'detect-indent';
 import getLatestVersion from 'latest-version';
 
+/**
+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));
+}
+
+let logger;
+function getLogger() {
+    return logger || dummyLogger;
+}
+useWinstonLogger();
+function useWinstonLogger() {
+    if (logger && logger.levels) {
+        return;
+    }
+    logger = console;
+}
+
+let queue = [];
+function debugLog(message, ...meta) {
+    if (!process.env.GQL_CODEGEN_NODEBUG && process.env.DEBUG !== undefined) {
+        queue.push({
+            message,
+            meta,
+        });
+    }
+}
+function printLogs() {
+    if (!process.env.GQL_CODEGEN_NODEBUG && process.env.DEBUG !== undefined) {
+        queue.forEach(log => {
+            getLogger().info(log.message, ...log.meta);
+        });
+        resetLogs();
+    }
+}
+function resetLogs() {
+    queue = [];
+}
+
+class Renderer {
+    constructor(tasks, options) {
+        this.updateRenderer = new UpdateRenderer(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 = indentString(chalk.red.bold(`Found ${errorCount} error${errorCount > 1 ? 's' : ''}`), 1);
+                const details = err.errors
+                    .map(error => {
+                    debugLog(`[CLI] Exited with an error`, error);
+                    return { msg: isDetailedError(error) ? error.details : null, rawError: error };
+                })
+                    .map(({ msg, rawError }, i) => {
+                    const source = err.errors[i].source;
+                    msg = msg ? chalk.gray(indentString(stripIndent(`${msg}`), 4)) : null;
+                    const stack = rawError.stack ? chalk.gray(indentString(stripIndent(rawError.stack), 4)) : null;
+                    if (source) {
+                        const sourceOfError = typeof source === 'string' ? source : source.name;
+                        const title = indentString(`${logSymbols.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.red.bold(`${indentString(err.message, 2)}`)}\n${details}\n${chalk.grey(err.stack)}`);
+            }
+        }
+        logUpdate.done();
+        printLogs();
+    }
+}
+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.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() { }
+}
+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 = wrapAnsi(output, width, {
+            trim: false,
+            hard: true,
+            wordWrap: false,
+        });
+        this.stream.write(ansiEscapes.eraseLines(this.previousLineCount) + output);
+        this.previousLineCount = output.split('\n').length;
+    }
+    clear() {
+        this.stream.write(ansiEscapes.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();
+
 async function getPluginByName(name, pluginLoader) {
     const possibleNames = [
         `@graphql-codegen/${name}`,
@@ -114,22 +307,6 @@ async function getPresetByName(name, loader) {
       `);
 }
 
-let logger;
-function getLogger() {
-    return logger || dummyLogger;
-}
-useWinstonLogger();
-function useWinstonLogger() {
-    if (logger && logger.levels) {
-        return;
-    }
-    logger = console;
-}
-
-function debugLog(message, ...meta) {
-    if (!process.env.GQL_CODEGEN_NODEBUG && process.env.DEBUG !== undefined) ;
-}
-
 const CodegenExtension = (api) => {
     // Schema
     api.loaders.schema.register(new CodeFileLoader({
@@ -546,6 +723,27 @@ function addHashToDocumentFiles(documentFilesPromise) {
     }));
 }
 
+function isListrError(err) {
+    return err.name === 'ListrError' && Array.isArray(err.errors) && err.errors.length > 0;
+}
+function cliError(err, exitOnError = true) {
+    let msg;
+    if (err instanceof Error) {
+        msg = err.message || err.toString();
+    }
+    else if (typeof err === 'string') {
+        msg = err;
+    }
+    else {
+        msg = JSON.stringify(err);
+    }
+    // eslint-disable-next-line no-console
+    console.error(msg);
+    if (exitOnError) {
+        process.exit(1);
+    }
+}
+
 const makeDefaultLoader = (from) => {
     if (fs.statSync(from).isDirectory()) {
         from = path.join(from, '__fake.js');
@@ -573,12 +771,39 @@ async function executeCodegen(input) {
     const config = context.getConfig();
     const pluginContext = context.getPluginContext();
     const result = [];
+    const commonListrOptions = {
+        exitOnError: true,
+    };
+    let listr;
+    if (process.env.VERBOSE) {
+        listr = new Listr({
+            ...commonListrOptions,
+            renderer: 'verbose',
+            nonTTYRenderer: 'verbose',
+        });
+    }
+    else if (process.env.NODE_ENV === 'test') {
+        listr = new Listr({
+            ...commonListrOptions,
+            renderer: 'silent',
+            nonTTYRenderer: 'silent',
+        });
+    }
+    else {
+        listr = new Listr({
+            ...commonListrOptions,
+            renderer: config.silent ? 'silent' : config.errorsOnly ? ErrorRenderer : Renderer,
+            nonTTYRenderer: config.silent ? 'silent' : 'default',
+            collapse: true,
+            clearOutput: false,
+        });
+    }
     let rootConfig = {};
     let rootSchemas;
     let rootDocuments;
     const generates = {};
     const cache = createCache();
-    function wrapTask(task, source, taskName, ctx) {
+    function wrapTask(task, source, taskName) {
         return () => {
             return context.profiler.run(async () => {
                 try {
@@ -588,7 +813,6 @@ async function executeCodegen(input) {
                     if (source && !(error instanceof GraphQLError)) {
                         error.source = source;
                     }
-                    ctx.errors.push(error);
                     throw error;
                 }
             }, taskName);
@@ -659,109 +883,123 @@ async function executeCodegen(input) {
       `);
         }
     }
-    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
+    listr.add({
+        title: 'Parse configuration',
+        task: () => normalize(),
+    });
+    listr.add({
+        title: 'Generate outputs',
+        task: () => {
+            return new Listr(Object.keys(generates).map(filename => {
+                const outputConfig = generates[filename];
+                const hasPreset = !!outputConfig.preset;
+                return {
+                    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);
-                                            }
+                        : `Generate ${filename}`,
+                    task: () => {
+                        let outputSchemaAst;
+                        let outputSchema;
+                        const outputFileTemplateConfig = outputConfig.config || {};
+                        let outputDocuments = [];
+                        const outputSpecificSchemas = normalizeInstanceOrArray(outputConfig.schema);
+                        const outputSpecificDocuments = normalizeInstanceOrArray(outputConfig.documents);
+                        return new Listr([
+                            {
+                                title: 'Load GraphQL schemas',
+                                task: wrapTask(async () => {
+                                    debugLog(`[CLI] Loading Schemas`);
+                                    const schemaPointerMap = {};
+                                    const allSchemaUnnormalizedPointers = [...rootSchemas, ...outputSpecificSchemas];
+                                    for (const unnormalizedPtr of allSchemaUnnormalizedPointers) {
+                                        if (typeof unnormalizedPtr === 'string') {
+                                            schemaPointerMap[unnormalizedPtr] = {};
                                         }
-                                        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);
-                                            }
+                                        else if (typeof unnormalizedPtr === 'object') {
+                                            Object.assign(schemaPointerMap, unnormalizedPtr);
                                         }
-                                        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 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 = await result.outputSchemaAst;
+                                    outputSchema = result.outputSchema;
+                                }, filename, `Load GraphQL schemas: ${filename}`),
+                            },
+                            {
+                                title: 'Load GraphQL documents',
+                                task: wrapTask(async () => {
+                                    debugLog(`[CLI] Loading Documents`);
+                                    // get different cache for shared docs and output specific docs
+                                    const documentPointerMap = {};
+                                    const allDocumentsUnnormalizedPointers = [...rootDocuments, ...outputSpecificDocuments];
+                                    for (const unnormalizedPtr of allDocumentsUnnormalizedPointers) {
+                                        if (typeof unnormalizedPtr === 'string') {
+                                            documentPointerMap[unnormalizedPtr] = {};
+                                        }
+                                        else if (typeof unnormalizedPtr === 'object') {
+                                            Object.assign(documentPointerMap, unnormalizedPtr);
+                                        }
+                                    }
+                                    const hash = JSON.stringify(documentPointerMap);
+                                    const result = await cache('documents', hash, async () => {
+                                        const documents = await context.loadDocuments(documentPointerMap);
+                                        return {
+                                            documents,
                                         };
-                                        const outputs = hasPreset
-                                            ? await context.profiler.run(async () => preset.buildGeneratesSection({
-                                                baseOutputDir: filename,
-                                                presetConfig: outputConfig.presetConfig || {},
+                                    });
+                                    outputDocuments = await result.documents;
+                                }, filename, `Load GraphQL documents: ${filename}`),
+                            },
+                            {
+                                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 pluginMap = {};
+                                    const preset = hasPreset
+                                        ? typeof outputConfig.preset === 'string'
+                                            ? await getPresetByName(outputConfig.preset, makeDefaultLoader(context.cwd))
+                                            : outputConfig.preset
+                                        : null;
+                                    pluginPackages.forEach((pluginPackage, i) => {
+                                        const plugin = normalizedPluginsArray[i];
+                                        const name = Object.keys(plugin)[0];
+                                        pluginMap[name] = pluginPackage;
+                                    });
+                                    const mergedConfig = {
+                                        ...rootConfig,
+                                        ...(typeof outputFileTemplateConfig === 'string'
+                                            ? { value: outputFileTemplateConfig }
+                                            : outputFileTemplateConfig),
+                                    };
+                                    let outputs = [];
+                                    if (hasPreset) {
+                                        outputs = 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}`);
+                                    }
+                                    else {
+                                        outputs = [
+                                            {
+                                                filename,
                                                 plugins: normalizedPluginsArray,
                                                 schema: outputSchema,
                                                 schemaAst: outputSchemaAst,
@@ -770,67 +1008,50 @@ async function executeCodegen(input) {
                                                 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,
+                                            },
+                                        ];
+                                    }
+                                    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}`),
+                            },
+                        ], {
+                            // it stops when one of 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,
+            });
         },
-        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;
+    try {
+        await listr.run();
+    }
+    catch (err) {
+        if (isListrError(err)) {
+            const allErrs = err.errors.map(subErr => isDetailedError(subErr)
+                ? `${subErr.message} for "${subErr.source}"${subErr.details}`
+                : subErr.message || subErr.toString());
+            const newErr = new AggregateError(err.errors, `${err.message} ${allErrs.join('\n\n')}`);
+            // Best-effort to all stack traces for debugging
+            newErr.stack = `${newErr.stack}\n\n${err.errors.map(subErr => subErr.stack).join('\n\n')}`;
+            throw newErr;
+        }
+        throw err;
     }
     return result;
 }
@@ -890,7 +1111,7 @@ function execShellCommand(cmd) {
     });
 }
 async function executeHooks(hookName, scripts = [], args = []) {
-    debugLog();
+    debugLog(`Running lifecycle hook "${hookName}" scripts...`);
     for (const script of scripts) {
         if (typeof script === 'string') {
             debugLog(`Running lifecycle hook "${hookName}" script: ${script} with args: ${args.join(' ')}...`);
@@ -924,7 +1145,7 @@ function emitWatching() {
     log(`${logSymbols.info} Watching for changes...`);
 }
 const createWatcher = (initalContext, onNext) => {
-    debugLog();
+    debugLog(`[Watcher] Starting watcher...`);
     let config = initalContext.getConfig();
     const files = [initalContext.filepath].filter(a => a);
     const documents = normalizeInstanceOrArray(config.documents);
@@ -995,10 +1216,10 @@ const createWatcher = (initalContext, onNext) => {
             atomic: true,
             ignored,
         });
-        debugLog();
+        debugLog(`[Watcher] Started`);
         const shutdown = () => {
             isShutdown = true;
-            debugLog();
+            debugLog(`[Watcher] Shutting down`);
             log(`Shutting down watch...`);
             watcher.close();
             lifecycleHooks(config.hooks).beforeDone();
@@ -1006,7 +1227,7 @@ const createWatcher = (initalContext, onNext) => {
         // it doesn't matter what has changed, need to run whole process anyway
         watcher.on('all', async (eventName, path) => {
             lifecycleHooks(config.hooks).onWatchTriggered(eventName, path);
-            debugLog();
+            debugLog(`[Watcher] triggered due to a file ${eventName} event: ${path}`);
             const fullPath = join(process.cwd(), path);
             // In ESM require is not defined
             try {
@@ -1075,10 +1296,10 @@ async function generate(input, saveToFile = true) {
                 return unlinkFile(filename, err => {
                     const prettyFilename = filename.replace(`${input.cwd || process.cwd()}/`, '');
                     if (err) {
-                        debugLog();
+                        debugLog(`Cannot remove stale file: ${prettyFilename}\n${err}`);
                     }
                     else {
-                        debugLog();
+                        debugLog(`Removed stale file: ${prettyFilename}`);
                     }
                 });
             }
@@ -1145,7 +1366,7 @@ function shouldOverwrite(config, outputPath) {
     const globalValue = config.overwrite === undefined ? true : !!config.overwrite;
     const outputConfig = config.generates[outputPath];
     if (!outputConfig) {
-        debugLog();
+        debugLog(`Couldn't find a config of ${outputPath}`);
         return globalValue;
     }
     if (isConfiguredOutput(outputConfig) && typeof outputConfig.overwrite === 'boolean') {
@@ -1606,40 +1827,18 @@ function addIntrospection(config) {
     };
 }
 
-function isListrError(err) {
-    return err.name === 'ListrError' && Array.isArray(err.errors) && err.errors.length > 0;
-}
-function cliError(err, exitOnError = true) {
-    let msg;
-    if (err instanceof Error) {
-        msg = err.message || err.toString();
-    }
-    else if (typeof err === 'string') {
-        msg = err;
-    }
-    else {
-        msg = JSON.stringify(err);
-    }
-    // eslint-disable-next-line no-console
-    console.error(msg);
-    if (exitOnError) {
-        process.exit(1);
-    }
-}
-
 async function runCli(cmd) {
     await ensureGraphQlPackage();
-    switch (cmd) {
-        case 'init':
-            return init();
-        default: {
-            return createContext().then(context => {
-                return generate(context).catch(async (error) => {
-                    await lifecycleHooks(context.getConfig().hooks).onError(error.toString());
-                    throw error;
-                });
-            });
-        }
+    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;
     }
 }
 async function ensureGraphQlPackage() {