@graphql-codegen/cli 2.7.0-alpha-8791d9688.0 → 2.7.1-alpha-23dfe4aea.0

package/esm/codegen.js

@@ -0,0 +1,339 @@
+import { DetailedError, normalizeOutputParam, normalizeInstanceOrArray, normalizeConfig, getCachedDocumentNodeFromSchema, isDetailedError, } from '@graphql-codegen/plugin-helpers';
+import { codegen } from '@graphql-codegen/core';
+import { AggregateError } from '@graphql-tools/utils';
+import { Renderer, ErrorRenderer } from './utils/listr-renderer.js';
+import { GraphQLError } from 'graphql';
+import { getPluginByName } from './plugins.js';
+import { getPresetByName } from './presets.js';
+import { debugLog } from './utils/debugging.js';
+import { ensureContext } from './config.js';
+import fs from 'fs';
+import path from 'path';
+import { cpus } from 'os';
+import { createRequire } from 'module';
+import Listr from 'listr';
+import { isListrError } from './utils/cli-error.js';
+/**
+ * Poor mans ESM detection.
+ * Looking at this and you have a better method?
+ * Send a PR.
+ */
+const isESMModule = (typeof __dirname === 'string') === false;
+const makeDefaultLoader = (from) => {
+    if (fs.statSync(from).isDirectory()) {
+        from = path.join(from, '__fake.js');
+    }
+    const relativeRequire = createRequire(from);
+    return async (mod) => {
+        return import(isESMModule
+            ? /**
+               * For ESM we currently have no "resolve path" solution
+               * as import.meta is unavailable in a CommonJS context
+               * and furthermore unavailable in stable Node.js.
+               **/
+                mod
+            : relativeRequire.resolve(mod));
+    };
+};
+function createCache() {
+    const cache = new Map();
+    return function ensure(namespace, key, factory) {
+        const cacheKey = `${namespace}:${key}`;
+        const cachedValue = cache.get(cacheKey);
+        if (cachedValue) {
+            return cachedValue;
+        }
+        const value = factory();
+        cache.set(cacheKey, value);
+        return value;
+    };
+}
+export async function executeCodegen(input) {
+    const context = ensureContext(input);
+    const config = context.getConfig();
+    const pluginContext = context.getPluginContext();
+    const result = [];
+    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) {
+        return () => {
+            return context.profiler.run(async () => {
+                try {
+                    await Promise.resolve().then(() => task());
+                }
+                catch (error) {
+                    if (source && !(error instanceof GraphQLError)) {
+                        error.source = source;
+                    }
+                    throw error;
+                }
+            }, taskName);
+        };
+    }
+    async function normalize() {
+        /* Load Require extensions */
+        const requireExtensions = normalizeInstanceOrArray(config.require);
+        const loader = makeDefaultLoader(context.cwd);
+        for (const mod of requireExtensions) {
+            await loader(mod);
+        }
+        /* Root plugin  config */
+        rootConfig = config.config || {};
+        /* Normalize root "schema" field */
+        rootSchemas = normalizeInstanceOrArray(config.schema);
+        /* Normalize root "documents" field */
+        rootDocuments = normalizeInstanceOrArray(config.documents);
+        /* Normalize "generators" field */
+        const generateKeys = Object.keys(config.generates || {});
+        if (generateKeys.length === 0) {
+            throw new DetailedError('Invalid Codegen Configuration!', `
+        Please make sure that your codegen config file contains the "generates" field, with a specification for the plugins you need.
+
+        It should looks like that:
+
+        schema:
+          - my-schema.graphql
+        generates:
+          my-file.ts:
+            - plugin1
+            - plugin2
+            - plugin3
+        `);
+        }
+        for (const filename of generateKeys) {
+            const output = (generates[filename] = normalizeOutputParam(config.generates[filename]));
+            if (!output.preset && (!output.plugins || output.plugins.length === 0)) {
+                throw new DetailedError('Invalid Codegen Configuration!', `
+          Please make sure that your codegen config file has defined plugins list for output "${filename}".
+
+          It should looks like that:
+
+          schema:
+            - my-schema.graphql
+          generates:
+            my-file.ts:
+              - plugin1
+              - plugin2
+              - plugin3
+          `);
+            }
+        }
+        if (rootSchemas.length === 0 &&
+            Object.keys(generates).some(filename => !generates[filename].schema || generates[filename].schema.length === 0)) {
+            throw new DetailedError('Invalid Codegen Configuration!', `
+        Please make sure that your codegen config file contains either the "schema" field
+        or every generated file has its own "schema" field.
+
+        It should looks like that:
+        schema:
+          - my-schema.graphql
+
+        or:
+        generates:
+          path/to/output:
+            schema: my-schema.graphql
+      `);
+        }
+    }
+    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}`,
+                    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] = {};
+                                        }
+                                        else if (typeof unnormalizedPtr === 'object') {
+                                            Object.assign(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 = 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,
+                                        };
+                                    });
+                                    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,
+                                                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}`),
+                            },
+                        ], {
+                            // 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,
+            });
+        },
+    });
+    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;
+}

package/esm/config.js

@@ -0,0 +1,290 @@
+import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
+import { resolve } from 'path';
+import { DetailedError, createProfiler, createNoopProfiler, getCachedDocumentNodeFromSchema, } from '@graphql-codegen/plugin-helpers';
+import { env } from 'string-env-interpolation';
+import yargs from 'yargs';
+import { findAndLoadGraphQLConfig } from './graphql-config.js';
+import { loadSchema, loadDocuments, defaultSchemaLoadOptions, defaultDocumentsLoadOptions } from './load.js';
+import { print } from 'graphql';
+import yaml from 'yaml';
+import { createRequire } from 'module';
+import { promises } from 'fs';
+import { createHash } from 'crypto';
+const { lstat } = promises;
+export function generateSearchPlaces(moduleName) {
+    const extensions = ['json', 'yaml', 'yml', 'js', 'config.js'];
+    // gives codegen.json...
+    const regular = extensions.map(ext => `${moduleName}.${ext}`);
+    // gives .codegenrc.json... but no .codegenrc.config.js
+    const dot = extensions.filter(ext => ext !== 'config.js').map(ext => `.${moduleName}rc.${ext}`);
+    return [...regular.concat(dot), 'package.json'];
+}
+function customLoader(ext) {
+    function loader(filepath, content) {
+        if (typeof process !== 'undefined' && 'env' in process) {
+            content = env(content);
+        }
+        if (ext === 'json') {
+            return defaultLoaders['.json'](filepath, content);
+        }
+        if (ext === 'yaml') {
+            try {
+                const result = yaml.parse(content, { prettyErrors: true, merge: true });
+                return result;
+            }
+            catch (error) {
+                error.message = `YAML Error in ${filepath}:\n${error.message}`;
+                throw error;
+            }
+        }
+        if (ext === 'js') {
+            return defaultLoaders['.js'](filepath, content);
+        }
+    }
+    return loader;
+}
+export async function loadCodegenConfig({ configFilePath, moduleName, searchPlaces: additionalSearchPlaces, packageProp, loaders: customLoaders, }) {
+    configFilePath = configFilePath || process.cwd();
+    moduleName = moduleName || 'codegen';
+    packageProp = packageProp || moduleName;
+    const cosmi = cosmiconfig(moduleName, {
+        searchPlaces: generateSearchPlaces(moduleName).concat(additionalSearchPlaces || []),
+        packageProp,
+        loaders: {
+            '.json': customLoader('json'),
+            '.yaml': customLoader('yaml'),
+            '.yml': customLoader('yaml'),
+            '.js': customLoader('js'),
+            noExt: customLoader('yaml'),
+            ...customLoaders,
+        },
+    });
+    const pathStats = await lstat(configFilePath);
+    return pathStats.isDirectory() ? cosmi.search(configFilePath) : cosmi.load(configFilePath);
+}
+export async function loadContext(configFilePath) {
+    const graphqlConfig = await findAndLoadGraphQLConfig(configFilePath);
+    if (graphqlConfig) {
+        return new CodegenContext({
+            graphqlConfig,
+        });
+    }
+    const result = await loadCodegenConfig({ configFilePath });
+    if (!result) {
+        if (configFilePath) {
+            throw new DetailedError(`Config ${configFilePath} does not exist`, `
+        Config ${configFilePath} does not exist.
+
+          $ graphql-codegen --config ${configFilePath}
+
+        Please make sure the --config points to a correct file.
+      `);
+        }
+        throw new DetailedError(`Unable to find Codegen config file!`, `
+        Please make sure that you have a configuration file under the current directory!
+      `);
+    }
+    if (result.isEmpty) {
+        throw new DetailedError(`Found Codegen config file but it was empty!`, `
+        Please make sure that you have a valid configuration file under the current directory!
+      `);
+    }
+    return new CodegenContext({
+        filepath: result.filepath,
+        config: result.config,
+    });
+}
+function getCustomConfigPath(cliFlags) {
+    const configFile = cliFlags.config;
+    return configFile ? resolve(process.cwd(), configFile) : null;
+}
+export function buildOptions() {
+    return {
+        c: {
+            alias: 'config',
+            type: 'string',
+            describe: 'Path to GraphQL codegen YAML config file, defaults to "codegen.yml" on the current directory',
+        },
+        w: {
+            alias: 'watch',
+            describe: 'Watch for changes and execute generation automatically. You can also specify a glob expreession for custom watch list.',
+            coerce: (watch) => {
+                if (watch === 'false') {
+                    return false;
+                }
+                if (typeof watch === 'string' || Array.isArray(watch)) {
+                    return watch;
+                }
+                return !!watch;
+            },
+        },
+        r: {
+            alias: 'require',
+            describe: 'Loads specific require.extensions before running the codegen and reading the configuration',
+            type: 'array',
+            default: [],
+        },
+        o: {
+            alias: 'overwrite',
+            describe: 'Overwrites existing files',
+            type: 'boolean',
+        },
+        s: {
+            alias: 'silent',
+            describe: 'Suppresses printing errors',
+            type: 'boolean',
+        },
+        e: {
+            alias: 'errors-only',
+            describe: 'Only print errors',
+            type: 'boolean',
+        },
+        profile: {
+            describe: 'Use profiler to measure performance',
+            type: 'boolean',
+        },
+        p: {
+            alias: 'project',
+            describe: 'Name of a project in GraphQL Config',
+            type: 'string',
+        },
+    };
+}
+export function parseArgv(argv = process.argv) {
+    return yargs(argv).options(buildOptions()).parse(argv);
+}
+export async function createContext(cliFlags = parseArgv(process.argv)) {
+    if (cliFlags.require && cliFlags.require.length > 0) {
+        const relativeRequire = createRequire(process.cwd());
+        await Promise.all(cliFlags.require.map(mod => import(relativeRequire.resolve(mod, {
+            paths: [process.cwd()],
+        }))));
+    }
+    const customConfigPath = getCustomConfigPath(cliFlags);
+    const context = await loadContext(customConfigPath);
+    updateContextWithCliFlags(context, cliFlags);
+    return context;
+}
+export function updateContextWithCliFlags(context, cliFlags) {
+    const config = {
+        configFilePath: context.filepath,
+    };
+    if (cliFlags.watch) {
+        config.watch = cliFlags.watch;
+    }
+    if (cliFlags.overwrite === true) {
+        config.overwrite = cliFlags.overwrite;
+    }
+    if (cliFlags.silent === true) {
+        config.silent = cliFlags.silent;
+    }
+    if (cliFlags.errorsOnly === true) {
+        config.errorsOnly = cliFlags.errorsOnly;
+    }
+    if (cliFlags.project) {
+        context.useProject(cliFlags.project);
+    }
+    if (cliFlags.profile === true) {
+        context.useProfiler();
+    }
+    context.updateConfig(config);
+}
+export class CodegenContext {
+    constructor({ config, graphqlConfig, filepath, }) {
+        this._pluginContext = {};
+        this._config = config;
+        this._graphqlConfig = graphqlConfig;
+        this.filepath = this._graphqlConfig ? this._graphqlConfig.filepath : filepath;
+        this.cwd = this._graphqlConfig ? this._graphqlConfig.dirpath : process.cwd();
+        this.profiler = createNoopProfiler();
+    }
+    useProject(name) {
+        this._project = name;
+    }
+    getConfig(extraConfig) {
+        if (!this.config) {
+            if (this._graphqlConfig) {
+                const project = this._graphqlConfig.getProject(this._project);
+                this.config = {
+                    ...project.extension('codegen'),
+                    schema: project.schema,
+                    documents: project.documents,
+                    pluginContext: this._pluginContext,
+                };
+            }
+            else {
+                this.config = { ...this._config, pluginContext: this._pluginContext };
+            }
+        }
+        return {
+            ...extraConfig,
+            ...this.config,
+        };
+    }
+    updateConfig(config) {
+        this.config = {
+            ...this.getConfig(),
+            ...config,
+        };
+    }
+    useProfiler() {
+        this.profiler = createProfiler();
+        const now = new Date(); // 2011-10-05T14:48:00.000Z
+        const datetime = now.toISOString().split('.')[0]; // 2011-10-05T14:48:00
+        const datetimeNormalized = datetime.replace(/-|:/g, ''); // 20111005T144800
+        this.profilerOutput = `codegen-${datetimeNormalized}.json`;
+    }
+    getPluginContext() {
+        return this._pluginContext;
+    }
+    async loadSchema(pointer) {
+        const config = this.getConfig(defaultSchemaLoadOptions);
+        if (this._graphqlConfig) {
+            // TODO: SchemaWithLoader won't work here
+            return addHashToSchema(this._graphqlConfig.getProject(this._project).loadSchema(pointer, 'GraphQLSchema', config));
+        }
+        return addHashToSchema(loadSchema(pointer, config));
+    }
+    async loadDocuments(pointer) {
+        const config = this.getConfig(defaultDocumentsLoadOptions);
+        if (this._graphqlConfig) {
+            // TODO: pointer won't work here
+            return addHashToDocumentFiles(this._graphqlConfig.getProject(this._project).loadDocuments(pointer, config));
+        }
+        return addHashToDocumentFiles(loadDocuments(pointer, config));
+    }
+}
+export function ensureContext(input) {
+    return input instanceof CodegenContext ? input : new CodegenContext({ config: input });
+}
+function hashContent(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+function hashSchema(schema) {
+    return hashContent(print(getCachedDocumentNodeFromSchema(schema)));
+}
+function addHashToSchema(schemaPromise) {
+    return schemaPromise.then(schema => {
+        // It's consumed later on. The general purpose is to use it for caching.
+        if (!schema.extensions) {
+            schema.extensions = {};
+        }
+        schema.extensions['hash'] = hashSchema(schema);
+        return schema;
+    });
+}
+function hashDocument(doc) {
+    if (doc.rawSDL) {
+        return hashContent(doc.rawSDL);
+    }
+    if (doc.document) {
+        return hashContent(print(doc.document));
+    }
+    return null;
+}
+function addHashToDocumentFiles(documentFilesPromise) {
+    return documentFilesPromise.then(documentFiles => documentFiles.map(doc => {
+        doc.hash = hashDocument(doc);
+        return doc;
+    }));
+}