@graphql-codegen/cli 2.7.0 → 2.8.0-alpha-c108f8a9c.0

package/esm/init/targets.js

@@ -0,0 +1,40 @@
+import { resolve } from 'path';
+import { readFileSync } from 'fs';
+import { Tags } from './types.js';
+export async function guessTargets() {
+    const pkg = JSON.parse(readFileSync(resolve(process.cwd(), 'package.json'), {
+        encoding: 'utf-8',
+    }));
+    const dependencies = Object.keys({
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+    });
+    return {
+        [Tags.angular]: isAngular(dependencies),
+        [Tags.react]: isReact(dependencies),
+        [Tags.stencil]: isStencil(dependencies),
+        [Tags.vue]: isVue(dependencies),
+        [Tags.browser]: false,
+        [Tags.node]: false,
+        [Tags.typescript]: isTypescript(dependencies),
+        [Tags.flow]: isFlow(dependencies),
+    };
+}
+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/esm/init/types.js

@@ -0,0 +1,11 @@
+export 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 || (Tags = {}));

package/esm/load.js

@@ -0,0 +1,88 @@
+import { loadSchema as loadSchemaToolkit, loadDocuments as loadDocumentsToolkit, } from '@graphql-tools/load';
+import { DetailedError } from '@graphql-codegen/plugin-helpers';
+import { CodeFileLoader } from '@graphql-tools/code-file-loader';
+import { GitLoader } from '@graphql-tools/git-loader';
+import { GithubLoader } from '@graphql-tools/github-loader';
+import { GraphQLFileLoader } from '@graphql-tools/graphql-file-loader';
+import { JsonFileLoader } from '@graphql-tools/json-file-loader';
+import { UrlLoader } from '@graphql-tools/url-loader';
+import { ApolloEngineLoader } from '@graphql-tools/apollo-engine-loader';
+import { PrismaLoader } from '@graphql-tools/prisma-loader';
+import { join, extname } from 'path';
+export const defaultSchemaLoadOptions = {
+    assumeValidSDL: true,
+    sort: true,
+    convertExtensions: true,
+    includeSources: true,
+};
+export const defaultDocumentsLoadOptions = {
+    sort: true,
+    skipGraphQLImport: true,
+};
+export async function loadSchema(schemaPointers, config) {
+    try {
+        const loaders = [
+            new CodeFileLoader(),
+            new GitLoader(),
+            new GithubLoader(),
+            new GraphQLFileLoader(),
+            new JsonFileLoader(),
+            new UrlLoader(),
+            new ApolloEngineLoader(),
+            new PrismaLoader(),
+        ];
+        const schema = await loadSchemaToolkit(schemaPointers, {
+            ...defaultSchemaLoadOptions,
+            loaders,
+            ...config,
+            ...config.config,
+        });
+        return schema;
+    }
+    catch (e) {
+        throw new 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.
+    
+      `);
+    }
+}
+export async function loadDocuments(documentPointers, config) {
+    const loaders = [
+        new CodeFileLoader({
+            pluckConfig: {
+                skipIndent: true,
+            },
+        }),
+        new GitLoader(),
+        new GithubLoader(),
+        new GraphQLFileLoader(),
+    ];
+    const ignore = [];
+    for (const generatePath of Object.keys(config.generates)) {
+        if (extname(generatePath) === '') {
+            // we omit paths that don't resolve to a specific file
+            continue;
+        }
+        ignore.push(join(process.cwd(), generatePath));
+    }
+    const loadedFromToolkit = await loadDocumentsToolkit(documentPointers, {
+        ...defaultDocumentsLoadOptions,
+        ignore,
+        loaders,
+        ...config,
+        ...config.config,
+    });
+    return loadedFromToolkit;
+}

package/esm/plugins.js

@@ -0,0 +1,41 @@
+import { DetailedError } from '@graphql-codegen/plugin-helpers';
+import { resolve } from 'path';
+export 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(resolve(process.cwd(), name));
+    for (const moduleName of possibleModules) {
+        try {
+            return await pluginLoader(moduleName);
+        }
+        catch (err) {
+            if (err.code !== 'MODULE_NOT_FOUND') {
+                throw new 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 DetailedError(`Unable to find template plugin matching ${name}`, `
+        Unable to find template plugin matching '${name}'
+        Install one of the following packages:
+
+        ${possibleNamesMsg}
+      `);
+}

package/esm/presets.js

@@ -0,0 +1,42 @@
+import { DetailedError } from '@graphql-codegen/plugin-helpers';
+import { resolve } from 'path';
+export async function getPresetByName(name, loader) {
+    const possibleNames = [
+        `@graphql-codegen/${name}`,
+        `@graphql-codegen/${name}-preset`,
+        name,
+        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 (err.code !== 'MODULE_NOT_FOUND') {
+                throw new 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 DetailedError(`Unable to find preset matching ${name}`, `
+        Unable to find preset matching '${name}'
+        Install one of the following packages:
+
+        ${possibleNamesMsg}
+      `);
+}

package/esm/utils/cli-error.js

@@ -0,0 +1,20 @@
+export function isListrError(err) {
+    return err.name === 'ListrError' && Array.isArray(err.errors) && err.errors.length > 0;
+}
+export 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);
+    }
+}

package/esm/utils/debugging.js

@@ -0,0 +1,21 @@
+import { getLogger } from './logger.js';
+let queue = [];
+export function debugLog(message, ...meta) {
+    if (!process.env.GQL_CODEGEN_NODEBUG && process.env.DEBUG !== undefined) {
+        queue.push({
+            message,
+            meta,
+        });
+    }
+}
+export function printLogs() {
+    if (!process.env.GQL_CODEGEN_NODEBUG && process.env.DEBUG !== undefined) {
+        queue.forEach(log => {
+            getLogger().info(log.message, ...log.meta);
+        });
+        resetLogs();
+    }
+}
+export function resetLogs() {
+    queue = [];
+}

package/esm/utils/file-system.js

@@ -0,0 +1,19 @@
+import { unlink as fsUnlink, promises } from 'fs';
+const { writeFile: fsWriteFile, readFile: fsReadFile, stat: fsStat } = promises;
+export function writeFile(filepath, content) {
+    return fsWriteFile(filepath, content);
+}
+export function readFile(filepath) {
+    return fsReadFile(filepath, 'utf-8');
+}
+export async function fileExists(filePath) {
+    try {
+        return (await fsStat(filePath)).isFile();
+    }
+    catch (err) {
+        return false;
+    }
+}
+export function unlinkFile(filePath, cb) {
+    fsUnlink(filePath, cb);
+}

package/esm/utils/indentString.js

@@ -0,0 +1,33 @@
+/**
+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'
+```
+*/
+export 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));
+}

package/esm/utils/listr-renderer.js

@@ -0,0 +1,130 @@
+import chalk from 'chalk';
+import { indentString } from './indentString.js';
+import logSymbol from 'log-symbols';
+import ansiEscapes from 'ansi-escapes';
+import wrapAnsi from 'wrap-ansi';
+import { stripIndent } from 'common-tags';
+import { isDetailedError } from '@graphql-codegen/plugin-helpers';
+import { debugLog, printLogs } from './debugging.js';
+import UpdateRenderer from 'listr-update-renderer';
+export 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(`${logSymbol.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();
+        });
+    }
+};
+export 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();

package/esm/utils/logger.js

@@ -0,0 +1,18 @@
+import { dummyLogger } from 'ts-log';
+let logger;
+export function getLogger() {
+    return logger || dummyLogger;
+}
+useWinstonLogger();
+export function setLogger(newLogger) {
+    logger = newLogger;
+}
+export function setSilentLogger() {
+    logger = dummyLogger;
+}
+export function useWinstonLogger() {
+    if (logger && logger.levels) {
+        return;
+    }
+    logger = console;
+}

package/esm/utils/watcher.js

@@ -0,0 +1,135 @@
+import { executeCodegen } from '../codegen.js';
+import { normalizeInstanceOrArray, normalizeOutputParam } from '@graphql-codegen/plugin-helpers';
+import isGlob from 'is-glob';
+import debounce from 'debounce';
+import logSymbols from 'log-symbols';
+import { debugLog } from './debugging.js';
+import { getLogger } from './logger.js';
+import { join } from 'path';
+import { lifecycleHooks } from '../hooks.js';
+import { loadContext } from '../config.js';
+import { isValidPath } from '@graphql-tools/utils';
+function log(msg) {
+    // double spaces to inline the message with Listr
+    getLogger().info(`  ${msg}`);
+}
+function emitWatching() {
+    log(`${logSymbols.info} Watching for changes...`);
+}
+export const createWatcher = (initalContext, onNext) => {
+    debugLog(`[Watcher] Starting watcher...`);
+    let config = initalContext.getConfig();
+    const files = [initalContext.filepath].filter(a => a);
+    const documents = normalizeInstanceOrArray(config.documents);
+    const schemas = normalizeInstanceOrArray(config.schema);
+    // Add schemas and documents from "generates"
+    Object.keys(config.generates)
+        .map(filename => normalizeOutputParam(config.generates[filename]))
+        .forEach(conf => {
+        schemas.push(...normalizeInstanceOrArray(conf.schema));
+        documents.push(...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 (isGlob(schema) || isValidPath(schema)) {
+            files.push(schema);
+        }
+    });
+    if (typeof config.watch !== 'boolean') {
+        files.push(...normalizeInstanceOrArray(config.watch));
+    }
+    let watcher;
+    const runWatcher = async () => {
+        var _a, _b;
+        const chokidar = await import('chokidar');
+        let isShutdown = false;
+        const debouncedExec = debounce(() => {
+            if (!isShutdown) {
+                executeCodegen(initalContext)
+                    .then(onNext, () => Promise.resolve())
+                    .then(() => emitWatching());
+            }
+        }, 100);
+        emitWatching();
+        const ignored = [];
+        Object.keys(config.generates)
+            .map(filename => ({ filename, config: normalizeOutputParam(config.generates[filename]) }))
+            .forEach(entry => {
+            if (entry.config.preset) {
+                const extension = entry.config.presetConfig && entry.config.presetConfig.extension;
+                if (extension) {
+                    ignored.push(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,
+        });
+        debugLog(`[Watcher] Started`);
+        const shutdown = () => {
+            isShutdown = true;
+            debugLog(`[Watcher] Shutting down`);
+            log(`Shutting down watch...`);
+            watcher.close();
+            lifecycleHooks(config.hooks).beforeDone();
+        };
+        // 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(`[Watcher] triggered due to a file ${eventName} event: ${path}`);
+            const fullPath = 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(`${logSymbols.info} Config file has changed, reloading...`);
+                const context = await 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) => {
+        executeCodegen(initalContext)
+            .then(onNext, () => Promise.resolve())
+            .then(runWatcher)
+            .catch(err => {
+            watcher.close();
+            reject(err);
+        });
+    });
+};