@graphql-codegen/cli 2.7.0 → 2.7.1-alpha-9d615db71.0

package/cjs/init/index.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+const tslib_1 = require("tslib");
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const questions_js_1 = require("./questions.js");
+const targets_js_1 = require("./targets.js");
+const types_js_1 = require("./types.js");
+const helpers_js_1 = require("./helpers.js");
+function log(...msgs) {
+    // eslint-disable-next-line no-console
+    console.log(...msgs);
+}
+async function init() {
+    log(`
+    Welcome to ${(0, helpers_js_1.bold)('GraphQL Code Generator')}!
+    Answer few questions and we will setup everything for you.
+  `);
+    const possibleTargets = await (0, targets_js_1.guessTargets)();
+    const answers = await inquirer_1.default.prompt((0, questions_js_1.getQuestions)(possibleTargets));
+    // define config
+    const config = {
+        overwrite: true,
+        schema: answers.schema,
+        documents: answers.targets.includes(types_js_1.Tags.browser) ? answers.documents : null,
+        generates: {
+            [answers.output]: {
+                plugins: answers.plugins.map(p => p.value),
+            },
+        },
+    };
+    // introspection
+    if (answers.introspection) {
+        addIntrospection(config);
+    }
+    // config file
+    const { relativePath } = await (0, helpers_js_1.writeConfig)(answers, config);
+    log(`Fetching latest versions of selected plugins...`);
+    // write package.json
+    await (0, helpers_js_1.writePackage)(answers, relativePath);
+    // Emit status to the terminal
+    log(`
+    Config file generated at ${(0, helpers_js_1.bold)(relativePath)}
+    
+      ${(0, helpers_js_1.bold)('$ npm install')}
+
+    To install the plugins.
+
+      ${(0, helpers_js_1.bold)(`$ npm run ${answers.script}`)}
+
+    To run GraphQL Code Generator.
+  `);
+}
+exports.init = init;
+// adds an introspection to `generates`
+function addIntrospection(config) {
+    config.generates['./graphql.schema.json'] = {
+        plugins: ['introspection'],
+    };
+}

package/cjs/init/plugins.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugins = void 0;
+const helpers_js_1 = require("./helpers.js");
+const types_js_1 = require("./types.js");
+exports.plugins = [
+    {
+        name: `TypeScript ${(0, helpers_js_1.italic)('(required by other typescript plugins)')}`,
+        package: '@graphql-codegen/typescript',
+        value: 'typescript',
+        pathInRepo: 'typescript/typescript',
+        available: hasTag(types_js_1.Tags.typescript),
+        shouldBeSelected: tags => oneOf(tags, types_js_1.Tags.angular, types_js_1.Tags.stencil) || allOf(tags, types_js_1.Tags.typescript, types_js_1.Tags.react) || noneOf(tags, types_js_1.Tags.flow),
+        defaultExtension: '.ts',
+    },
+    {
+        name: `TypeScript Operations ${(0, helpers_js_1.italic)('(operations and fragments)')}`,
+        package: '@graphql-codegen/typescript-operations',
+        value: 'typescript-operations',
+        pathInRepo: 'typescript/operations',
+        available: tags => allOf(tags, types_js_1.Tags.browser, types_js_1.Tags.typescript),
+        shouldBeSelected: tags => oneOf(tags, types_js_1.Tags.angular, types_js_1.Tags.stencil) || allOf(tags, types_js_1.Tags.typescript, types_js_1.Tags.react),
+        defaultExtension: '.ts',
+    },
+    {
+        name: `TypeScript Resolvers ${(0, helpers_js_1.italic)('(strongly typed resolve functions)')}`,
+        package: '@graphql-codegen/typescript-resolvers',
+        value: 'typescript-resolvers',
+        pathInRepo: 'typescript/resolvers',
+        available: tags => allOf(tags, types_js_1.Tags.node, types_js_1.Tags.typescript),
+        shouldBeSelected: tags => noneOf(tags, types_js_1.Tags.flow),
+        defaultExtension: '.ts',
+    },
+    {
+        name: `Flow ${(0, helpers_js_1.italic)('(required by other flow plugins)')}`,
+        package: '@graphql-codegen/flow',
+        value: 'flow',
+        pathInRepo: 'flow/flow',
+        available: hasTag(types_js_1.Tags.flow),
+        shouldBeSelected: tags => noneOf(tags, types_js_1.Tags.typescript),
+        defaultExtension: '.js',
+    },
+    {
+        name: `Flow Operations ${(0, helpers_js_1.italic)('(operations and fragments)')}`,
+        package: '@graphql-codegen/flow-operations',
+        value: 'flow-operations',
+        pathInRepo: 'flow/operations',
+        available: tags => allOf(tags, types_js_1.Tags.browser, types_js_1.Tags.flow),
+        shouldBeSelected: tags => noneOf(tags, types_js_1.Tags.typescript),
+        defaultExtension: '.js',
+    },
+    {
+        name: `Flow Resolvers ${(0, helpers_js_1.italic)('(strongly typed resolve functions)')}`,
+        package: '@graphql-codegen/flow-resolvers',
+        value: 'flow-resolvers',
+        pathInRepo: 'flow/resolvers',
+        available: tags => allOf(tags, types_js_1.Tags.node, types_js_1.Tags.flow),
+        shouldBeSelected: tags => noneOf(tags, types_js_1.Tags.typescript),
+        defaultExtension: '.js',
+    },
+    {
+        name: `TypeScript Apollo Angular ${(0, helpers_js_1.italic)('(typed GQL services)')}`,
+        package: '@graphql-codegen/typescript-apollo-angular',
+        value: 'typescript-apollo-angular',
+        pathInRepo: 'typescript/apollo-angular',
+        available: hasTag(types_js_1.Tags.angular),
+        shouldBeSelected: () => true,
+        defaultExtension: '.js',
+    },
+    {
+        name: `TypeScript Vue Apollo Composition API ${(0, helpers_js_1.italic)('(typed functions)')}`,
+        package: '@graphql-codegen/typescript-vue-apollo',
+        value: 'typescript-vue-apollo',
+        pathInRepo: 'typescript/vue-apollo',
+        available: tags => allOf(tags, types_js_1.Tags.vue, types_js_1.Tags.typescript),
+        shouldBeSelected: () => true,
+        defaultExtension: '.ts',
+    },
+    {
+        name: `TypeScript Vue Apollo Smart Operations ${(0, helpers_js_1.italic)('(typed functions)')}`,
+        package: '@graphql-codegen/typescript-vue-apollo-smart-ops',
+        value: 'typescript-vue-apollo-smart-ops',
+        pathInRepo: 'typescript/vue-apollo-smart-ops',
+        available: tags => allOf(tags, types_js_1.Tags.vue, types_js_1.Tags.typescript),
+        shouldBeSelected: () => true,
+        defaultExtension: '.ts',
+    },
+    {
+        name: `TypeScript React Apollo ${(0, helpers_js_1.italic)('(typed components and HOCs)')}`,
+        package: '@graphql-codegen/typescript-react-apollo',
+        value: 'typescript-react-apollo',
+        pathInRepo: 'typescript/react-apollo',
+        available: tags => allOf(tags, types_js_1.Tags.react, types_js_1.Tags.typescript),
+        shouldBeSelected: () => true,
+        defaultExtension: '.tsx',
+    },
+    {
+        name: `TypeScript Stencil Apollo ${(0, helpers_js_1.italic)('(typed components)')}`,
+        package: '@graphql-codegen/typescript-stencil-apollo',
+        value: 'typescript-stencil-apollo',
+        pathInRepo: 'typescript/stencil-apollo',
+        available: hasTag(types_js_1.Tags.stencil),
+        shouldBeSelected: () => true,
+        defaultExtension: '.tsx',
+    },
+    {
+        name: `TypeScript MongoDB ${(0, helpers_js_1.italic)('(typed MongoDB objects)')}`,
+        package: '@graphql-codegen/typescript-mongodb',
+        value: 'typescript-mongodb',
+        pathInRepo: 'typescript/mongodb',
+        available: tags => allOf(tags, types_js_1.Tags.node, types_js_1.Tags.typescript),
+        shouldBeSelected: () => false,
+        defaultExtension: '.ts',
+    },
+    {
+        name: `TypeScript GraphQL files modules ${(0, helpers_js_1.italic)('(declarations for .graphql files)')}`,
+        package: '@graphql-codegen/typescript-graphql-files-modules',
+        value: 'typescript-graphql-files-modules',
+        pathInRepo: 'typescript/graphql-files-modules',
+        available: tags => allOf(tags, types_js_1.Tags.browser, types_js_1.Tags.typescript),
+        shouldBeSelected: () => false,
+        defaultExtension: '.ts',
+    },
+    {
+        name: `TypeScript GraphQL document nodes ${(0, helpers_js_1.italic)('(embedded GraphQL document)')}`,
+        package: '@graphql-codegen/typescript-document-nodes',
+        value: 'typescript-document-nodes',
+        pathInRepo: 'typescript/document-nodes',
+        available: tags => allOf(tags, types_js_1.Tags.typescript),
+        shouldBeSelected: () => false,
+        defaultExtension: '.ts',
+    },
+    {
+        name: `Introspection Fragment Matcher ${(0, helpers_js_1.italic)('(for Apollo Client)')}`,
+        package: '@graphql-codegen/fragment-matcher',
+        value: 'fragment-matcher',
+        pathInRepo: 'other/fragment-matcher',
+        available: hasTag(types_js_1.Tags.browser),
+        shouldBeSelected: () => false,
+        defaultExtension: '.ts',
+    },
+    {
+        name: `Urql Introspection ${(0, helpers_js_1.italic)('(for Urql Client)')}`,
+        package: '@graphql-codegen/urql-introspection',
+        value: 'urql-introspection',
+        pathInRepo: 'other/urql-introspection',
+        available: hasTag(types_js_1.Tags.browser),
+        shouldBeSelected: () => false,
+        defaultExtension: '.ts',
+    },
+];
+function hasTag(tag) {
+    return (tags) => tags.includes(tag);
+}
+function oneOf(list, ...items) {
+    return list.some(i => items.includes(i));
+}
+function noneOf(list, ...items) {
+    return !list.some(i => items.includes(i));
+}
+function allOf(list, ...items) {
+    return items.every(i => list.includes(i));
+}

package/cjs/init/questions.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOutputDefaultValue = exports.getPluginChoices = exports.getApplicationTypeChoices = exports.getQuestions = void 0;
+const helpers_js_1 = require("./helpers.js");
+const types_js_1 = require("./types.js");
+const plugins_js_1 = require("./plugins.js");
+function getQuestions(possibleTargets) {
+    return [
+        {
+            type: 'checkbox',
+            name: 'targets',
+            message: `What type of application are you building?`,
+            choices: getApplicationTypeChoices(possibleTargets),
+            validate: ((targets) => targets.length > 0),
+        },
+        {
+            type: 'input',
+            name: 'schema',
+            message: 'Where is your schema?:',
+            suffix: (0, helpers_js_1.grey)(' (path or url)'),
+            default: 'http://localhost:4000',
+            validate: (str) => str.length > 0,
+        },
+        {
+            type: 'input',
+            name: 'documents',
+            message: 'Where are your operations and fragments?:',
+            when: answers => {
+                // flatten targets
+                // I can't find an API in Inquirer that would do that
+                answers.targets = normalizeTargets(answers.targets);
+                return answers.targets.includes(types_js_1.Tags.browser);
+            },
+            default: 'src/**/*.graphql',
+            validate: (str) => str.length > 0,
+        },
+        {
+            type: 'checkbox',
+            name: 'plugins',
+            message: 'Pick plugins:',
+            choices: getPluginChoices,
+            validate: ((plugins) => plugins.length > 0),
+        },
+        {
+            type: 'input',
+            name: 'output',
+            message: 'Where to write the output:',
+            default: getOutputDefaultValue,
+            validate: (str) => str.length > 0,
+        },
+        {
+            type: 'confirm',
+            name: 'introspection',
+            message: 'Do you want to generate an introspection file?',
+        },
+        {
+            type: 'input',
+            name: 'config',
+            message: 'How to name the config file?',
+            default: 'codegen.yml',
+            validate: (str) => {
+                const isNotEmpty = str.length > 0;
+                const hasCorrectExtension = ['json', 'yml', 'yaml'].some(ext => str.toLocaleLowerCase().endsWith(`.${ext}`));
+                return isNotEmpty && hasCorrectExtension;
+            },
+        },
+        {
+            type: 'input',
+            name: 'script',
+            message: 'What script in package.json should run the codegen?',
+            validate: (str) => str.length > 0,
+        },
+    ];
+}
+exports.getQuestions = getQuestions;
+function getApplicationTypeChoices(possibleTargets) {
+    function withFlowOrTypescript(tags) {
+        if (possibleTargets.TypeScript) {
+            tags.push(types_js_1.Tags.typescript);
+        }
+        else if (possibleTargets.Flow) {
+            tags.push(types_js_1.Tags.flow);
+        }
+        else {
+            tags.push(types_js_1.Tags.flow, types_js_1.Tags.typescript);
+        }
+        return tags;
+    }
+    return [
+        {
+            name: 'Backend - API or server',
+            key: 'backend',
+            value: withFlowOrTypescript([types_js_1.Tags.node]),
+            checked: possibleTargets.Node,
+        },
+        {
+            name: 'Application built with Angular',
+            key: 'angular',
+            value: [types_js_1.Tags.angular, types_js_1.Tags.browser, types_js_1.Tags.typescript],
+            checked: possibleTargets.Angular,
+        },
+        {
+            name: 'Application built with React',
+            key: 'react',
+            value: withFlowOrTypescript([types_js_1.Tags.react, types_js_1.Tags.browser]),
+            checked: possibleTargets.React,
+        },
+        {
+            name: 'Application built with Stencil',
+            key: 'stencil',
+            value: [types_js_1.Tags.stencil, types_js_1.Tags.browser, types_js_1.Tags.typescript],
+            checked: possibleTargets.Stencil,
+        },
+        {
+            name: 'Application built with other framework or vanilla JS',
+            key: 'client',
+            value: [types_js_1.Tags.browser, types_js_1.Tags.typescript, types_js_1.Tags.flow],
+            checked: possibleTargets.Browser && !possibleTargets.Angular && !possibleTargets.React && !possibleTargets.Stencil,
+        },
+    ];
+}
+exports.getApplicationTypeChoices = getApplicationTypeChoices;
+function getPluginChoices(answers) {
+    return plugins_js_1.plugins
+        .filter(p => p.available(answers.targets))
+        .map(p => {
+        return {
+            name: p.name,
+            value: p,
+            checked: p.shouldBeSelected(answers.targets),
+        };
+    });
+}
+exports.getPluginChoices = getPluginChoices;
+function normalizeTargets(targets) {
+    return [].concat(...targets);
+}
+function getOutputDefaultValue(answers) {
+    if (answers.plugins.some(plugin => plugin.defaultExtension === '.tsx')) {
+        return 'src/generated/graphql.tsx';
+    }
+    if (answers.plugins.some(plugin => plugin.defaultExtension === '.ts')) {
+        return 'src/generated/graphql.ts';
+    }
+    return 'src/generated/graphql.js';
+}
+exports.getOutputDefaultValue = getOutputDefaultValue;

package/cjs/init/targets.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guessTargets = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const types_js_1 = require("./types.js");
+async function guessTargets() {
+    const pkg = JSON.parse((0, fs_1.readFileSync)((0, path_1.resolve)(process.cwd(), 'package.json'), {
+        encoding: 'utf-8',
+    }));
+    const dependencies = Object.keys({
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+    });
+    return {
+        [types_js_1.Tags.angular]: isAngular(dependencies),
+        [types_js_1.Tags.react]: isReact(dependencies),
+        [types_js_1.Tags.stencil]: isStencil(dependencies),
+        [types_js_1.Tags.vue]: isVue(dependencies),
+        [types_js_1.Tags.browser]: false,
+        [types_js_1.Tags.node]: false,
+        [types_js_1.Tags.typescript]: isTypescript(dependencies),
+        [types_js_1.Tags.flow]: isFlow(dependencies),
+    };
+}
+exports.guessTargets = guessTargets;
+function isAngular(dependencies) {
+    return dependencies.includes('@angular/core');
+}
+function isReact(dependencies) {
+    return dependencies.includes('react');
+}
+function isStencil(dependencies) {
+    return dependencies.includes('@stencil/core');
+}
+function isVue(dependencies) {
+    return dependencies.includes('vue') || dependencies.includes('nuxt');
+}
+function isTypescript(dependencies) {
+    return dependencies.includes('typescript');
+}
+function isFlow(dependencies) {
+    return dependencies.includes('flow');
+}

package/cjs/init/types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tags = void 0;
+var Tags;
+(function (Tags) {
+    Tags["browser"] = "Browser";
+    Tags["node"] = "Node";
+    Tags["typescript"] = "TypeScript";
+    Tags["flow"] = "Flow";
+    Tags["angular"] = "Angular";
+    Tags["stencil"] = "Stencil";
+    Tags["react"] = "React";
+    Tags["vue"] = "Vue";
+})(Tags = exports.Tags || (exports.Tags = {}));

package/cjs/load.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadDocuments = exports.loadSchema = exports.defaultDocumentsLoadOptions = exports.defaultSchemaLoadOptions = void 0;
+const load_1 = require("@graphql-tools/load");
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const code_file_loader_1 = require("@graphql-tools/code-file-loader");
+const git_loader_1 = require("@graphql-tools/git-loader");
+const github_loader_1 = require("@graphql-tools/github-loader");
+const graphql_file_loader_1 = require("@graphql-tools/graphql-file-loader");
+const json_file_loader_1 = require("@graphql-tools/json-file-loader");
+const url_loader_1 = require("@graphql-tools/url-loader");
+const apollo_engine_loader_1 = require("@graphql-tools/apollo-engine-loader");
+const prisma_loader_1 = require("@graphql-tools/prisma-loader");
+const path_1 = require("path");
+exports.defaultSchemaLoadOptions = {
+    assumeValidSDL: true,
+    sort: true,
+    convertExtensions: true,
+    includeSources: true,
+};
+exports.defaultDocumentsLoadOptions = {
+    sort: true,
+    skipGraphQLImport: true,
+};
+async function loadSchema(schemaPointers, config) {
+    try {
+        const loaders = [
+            new code_file_loader_1.CodeFileLoader(),
+            new git_loader_1.GitLoader(),
+            new github_loader_1.GithubLoader(),
+            new graphql_file_loader_1.GraphQLFileLoader(),
+            new json_file_loader_1.JsonFileLoader(),
+            new url_loader_1.UrlLoader(),
+            new apollo_engine_loader_1.ApolloEngineLoader(),
+            new prisma_loader_1.PrismaLoader(),
+        ];
+        const schema = await (0, load_1.loadSchema)(schemaPointers, {
+            ...exports.defaultSchemaLoadOptions,
+            loaders,
+            ...config,
+            ...config.config,
+        });
+        return schema;
+    }
+    catch (e) {
+        throw new plugin_helpers_1.DetailedError('Failed to load schema', `
+        Failed to load schema from ${Object.keys(schemaPointers).join(',')}:
+
+        ${e.message || e}
+        ${e.stack || ''}
+    
+        GraphQL Code Generator supports:
+          - ES Modules and CommonJS exports (export as default or named export "schema")
+          - Introspection JSON File
+          - URL of GraphQL endpoint
+          - Multiple files with type definitions (glob expression)
+          - String in config file
+    
+        Try to use one of above options and run codegen again.
+    
+      `);
+    }
+}
+exports.loadSchema = loadSchema;
+async function loadDocuments(documentPointers, config) {
+    const loaders = [
+        new code_file_loader_1.CodeFileLoader({
+            pluckConfig: {
+                skipIndent: true,
+            },
+        }),
+        new git_loader_1.GitLoader(),
+        new github_loader_1.GithubLoader(),
+        new graphql_file_loader_1.GraphQLFileLoader(),
+    ];
+    const ignore = [];
+    for (const generatePath of Object.keys(config.generates)) {
+        if ((0, path_1.extname)(generatePath) === '') {
+            // we omit paths that don't resolve to a specific file
+            continue;
+        }
+        ignore.push((0, path_1.join)(process.cwd(), generatePath));
+    }
+    const loadedFromToolkit = await (0, load_1.loadDocuments)(documentPointers, {
+        ...exports.defaultDocumentsLoadOptions,
+        ignore,
+        loaders,
+        ...config,
+        ...config.config,
+    });
+    return loadedFromToolkit;
+}
+exports.loadDocuments = loadDocuments;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/plugins.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPluginByName = void 0;
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const path_1 = require("path");
+async function getPluginByName(name, pluginLoader) {
+    const possibleNames = [
+        `@graphql-codegen/${name}`,
+        `@graphql-codegen/${name}-template`,
+        `@graphql-codegen/${name}-plugin`,
+        `graphql-codegen-${name}`,
+        `graphql-codegen-${name}-template`,
+        `graphql-codegen-${name}-plugin`,
+        `codegen-${name}`,
+        `codegen-${name}-template`,
+        name,
+    ];
+    const possibleModules = possibleNames.concat((0, path_1.resolve)(process.cwd(), name));
+    for (const moduleName of possibleModules) {
+        try {
+            return await pluginLoader(moduleName);
+        }
+        catch (err) {
+            if (err.code !== 'MODULE_NOT_FOUND') {
+                throw new plugin_helpers_1.DetailedError(`Unable to load template plugin matching ${name}`, `
+              Unable to load template plugin matching '${name}'.
+              Reason:
+                ${err.message}
+            `);
+            }
+        }
+    }
+    const possibleNamesMsg = possibleNames
+        .map(name => `
+        - ${name}
+    `.trimRight())
+        .join('');
+    throw new plugin_helpers_1.DetailedError(`Unable to find template plugin matching ${name}`, `
+        Unable to find template plugin matching '${name}'
+        Install one of the following packages:
+
+        ${possibleNamesMsg}
+      `);
+}
+exports.getPluginByName = getPluginByName;

package/cjs/presets.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPresetByName = void 0;
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const path_1 = require("path");
+async function getPresetByName(name, loader) {
+    const possibleNames = [
+        `@graphql-codegen/${name}`,
+        `@graphql-codegen/${name}-preset`,
+        name,
+        (0, path_1.resolve)(process.cwd(), name),
+    ];
+    for (const moduleName of possibleNames) {
+        try {
+            const loaded = await loader(moduleName);
+            if (loaded && loaded.preset) {
+                return loaded.preset;
+            }
+            if (loaded && loaded.default) {
+                return loaded.default;
+            }
+            return loaded;
+        }
+        catch (err) {
+            if (
+            /** CJS Error code */
+            err.code !== 'MODULE_NOT_FOUND' &&
+                /** ESM Error code */
+                err.code !== 'ERR_MODULE_NOT_FOUND') {
+                throw new plugin_helpers_1.DetailedError(`Unable to load preset matching ${name}`, `
+              Unable to load preset matching '${name}'.
+              Reason:
+                ${err.message}
+            `);
+            }
+        }
+    }
+    const possibleNamesMsg = possibleNames
+        .map(name => `
+        - ${name}
+    `.trimRight())
+        .join('');
+    throw new plugin_helpers_1.DetailedError(`Unable to find preset matching ${name}`, `
+        Unable to find preset matching '${name}'
+        Install one of the following packages:
+
+        ${possibleNamesMsg}
+      `);
+}
+exports.getPresetByName = getPresetByName;

package/cjs/utils/cli-error.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cliError = exports.isListrError = void 0;
+function isListrError(err) {
+    return err.name === 'ListrError' && Array.isArray(err.errors) && err.errors.length > 0;
+}
+exports.isListrError = isListrError;
+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);
+    }
+}
+exports.cliError = cliError;

package/cjs/utils/debugging.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetLogs = exports.printLogs = exports.debugLog = void 0;
+const logger_js_1 = require("./logger.js");
+let queue = [];
+function debugLog(message, ...meta) {
+    if (!process.env.GQL_CODEGEN_NODEBUG && process.env.DEBUG !== undefined) {
+        queue.push({
+            message,
+            meta,
+        });
+    }
+}
+exports.debugLog = debugLog;
+function printLogs() {
+    if (!process.env.GQL_CODEGEN_NODEBUG && process.env.DEBUG !== undefined) {
+        queue.forEach(log => {
+            (0, logger_js_1.getLogger)().info(log.message, ...log.meta);
+        });
+        resetLogs();
+    }
+}
+exports.printLogs = printLogs;
+function resetLogs() {
+    queue = [];
+}
+exports.resetLogs = resetLogs;