@depup/graphql-codegen__cli 6.2.1-depup.0

package/esm/config.js

@@ -0,0 +1,357 @@
+import { createHash } from 'crypto';
+import { promises } from 'fs';
+import { createRequire } from 'module';
+import { resolve } from 'path';
+import { createNoopProfiler, createProfiler, getCachedDocumentNodeFromSchema, } from '@graphql-codegen/plugin-helpers';
+import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
+import { createJiti } from 'jiti';
+import { print } from 'graphql';
+import { env } from 'string-env-interpolation';
+import yaml from 'yaml';
+import yargs from 'yargs';
+import { findAndLoadGraphQLConfig } from './graphql-config.js';
+import { defaultDocumentsLoadOptions, defaultSchemaLoadOptions, loadDocuments, loadSchema } from './load.js';
+const { lstat } = promises;
+export function generateSearchPlaces(moduleName) {
+    const extensions = ['json', 'yaml', 'yml', 'js', 'ts', '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) {
+    return async 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);
+        }
+        if (ext === 'ts') {
+            const jitiLoader = createJiti('');
+            return jitiLoader.import(filepath, { default: true });
+        }
+    };
+}
+export async function loadCodegenConfig({ configFilePath, moduleName, searchPlaces: additionalSearchPlaces, packageProp, loaders: customLoaders, }) {
+    configFilePath ||= process.cwd();
+    moduleName ||= 'codegen';
+    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'),
+            '.ts': customLoader('ts'),
+            '.mts': customLoader('ts'),
+            '.cts': customLoader('ts'),
+            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 Error(`
+        Config ${configFilePath} does not exist.
+
+          $ graphql-codegen --config ${configFilePath}
+
+        Please make sure the --config points to a correct file.
+      `);
+        }
+        throw new Error(`Unable to find Codegen config file! \n
+        Please make sure that you have a configuration file under the current directory!
+      `);
+    }
+    if (result.isEmpty) {
+        throw new Error(`Found Codegen config file but it was empty! \n
+        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 expression 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',
+        },
+        v: {
+            alias: 'verbose',
+            describe: 'output more detailed information about performed tasks',
+            type: 'boolean',
+            default: false,
+        },
+        d: {
+            alias: 'debug',
+            describe: 'Print debug logs to stdout',
+            type: 'boolean',
+            default: false,
+        },
+        'emit-legacy-common-js-imports': {
+            describe: 'Emit legacy CommonJS imports (deprecated, use import-extension instead)',
+            type: 'boolean',
+        },
+        'import-extension': {
+            describe: 'Extension to append to imports (e.g., .js, .mjs, or empty string for no extension)',
+            type: 'string',
+        },
+        'ignore-no-documents': {
+            describe: 'Suppress errors for no documents',
+            type: 'boolean',
+        },
+    };
+}
+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 !== undefined) {
+        config.watch = cliFlags.watch;
+    }
+    if (cliFlags.overwrite === true) {
+        config.overwrite = cliFlags.overwrite;
+    }
+    if (cliFlags.silent === true) {
+        config.silent = cliFlags.silent;
+    }
+    if (cliFlags.verbose === true || process.env.VERBOSE) {
+        config.verbose = true;
+    }
+    if (cliFlags.debug === true || process.env.DEBUG) {
+        config.debug = true;
+    }
+    if (cliFlags.errorsOnly === true) {
+        config.errorsOnly = cliFlags.errorsOnly;
+    }
+    if (cliFlags['ignore-no-documents'] !== undefined) {
+        // for some reason parsed value is `'false'` string so this ensure it always is a boolean.
+        config.ignoreNoDocuments = cliFlags['ignore-no-documents'] === true;
+    }
+    if (cliFlags['emit-legacy-common-js-imports'] !== undefined) {
+        // for some reason parsed value is `'false'` string so this ensure it always is a boolean.
+        config.emitLegacyCommonJSImports = cliFlags['emit-legacy-common-js-imports'] === true;
+    }
+    if (cliFlags['import-extension'] !== undefined) {
+        config.importExtension = cliFlags['import-extension'];
+    }
+    if (cliFlags.project) {
+        context.useProject(cliFlags.project);
+    }
+    if (cliFlags.profile === true) {
+        context.useProfiler();
+    }
+    if (cliFlags.check === true) {
+        context.enableCheckMode();
+    }
+    context.updateConfig(config);
+}
+export class CodegenContext {
+    _config;
+    _graphqlConfig;
+    config;
+    _project;
+    _checkMode = false;
+    _pluginContext = {};
+    cwd;
+    filepath;
+    profiler;
+    profilerOutput;
+    checkModeStaleFiles = [];
+    constructor({ config, graphqlConfig, filepath, }) {
+        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,
+        };
+    }
+    enableCheckMode() {
+        this._checkMode = true;
+    }
+    get checkMode() {
+        return this._checkMode;
+    }
+    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, ...config.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, ...config.config }));
+        }
+        return addHashToDocumentFiles(loadDocuments(pointer, config));
+    }
+}
+export function ensureContext(input) {
+    return input instanceof CodegenContext ? input : new CodegenContext({ config: input });
+}
+function hashContent(content, encoding = 'hex') {
+    return createHash('sha256').update(content).digest(encoding);
+}
+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;
+    }));
+}

package/esm/documentTransforms.js

@@ -0,0 +1,59 @@
+import { resolve } from 'path';
+export async function getDocumentTransform(documentTransform, loader, defaultName) {
+    if (typeof documentTransform === 'string') {
+        const transformObject = await getDocumentTransformByName(documentTransform, loader);
+        return { name: documentTransform, transformObject };
+    }
+    if (isTransformObject(documentTransform)) {
+        return { name: defaultName, transformObject: documentTransform };
+    }
+    if (isTransformFileConfig(documentTransform)) {
+        const name = Object.keys(documentTransform)[0];
+        const transformObject = await getDocumentTransformByName(name, loader);
+        return { name, transformObject, config: Object.values(documentTransform)[0] };
+    }
+    throw new Error(`
+        An unknown format document transform: '${defaultName}'.
+    `);
+}
+function isTransformObject(config) {
+    return typeof config === 'object' && config.transform && typeof config.transform === 'function';
+}
+function isTransformFileConfig(config) {
+    const keys = Object.keys(config);
+    return keys.length === 1 && typeof keys[0] === 'string';
+}
+export async function getDocumentTransformByName(name, loader) {
+    const possibleNames = [
+        `@graphql-codegen/${name}`,
+        `@graphql-codegen/${name}-document-transform`,
+        name,
+        resolve(process.cwd(), name),
+    ];
+    const possibleModules = possibleNames.concat(resolve(process.cwd(), name));
+    for (const moduleName of possibleModules) {
+        try {
+            return await loader(moduleName);
+        }
+        catch (err) {
+            if (err.code !== 'MODULE_NOT_FOUND' && err.code !== 'ERR_MODULE_NOT_FOUND') {
+                throw new Error(`
+              Unable to load document transform matching '${name}'.
+              Reason:
+                ${err.message}
+            `);
+            }
+        }
+    }
+    const possibleNamesMsg = possibleNames
+        .map(name => `
+        - ${name}
+    `.trimEnd())
+        .join('');
+    throw new Error(`
+        Unable to find document transform matching '${name}'
+        Install one of the following packages:
+
+        ${possibleNamesMsg}
+      `);
+}

package/esm/generate-and-save.js

@@ -0,0 +1,149 @@
+import { createHash } from 'crypto';
+import { dirname, isAbsolute, join } from 'path';
+import logSymbols from 'log-symbols';
+import { executeCodegen } from './codegen.js';
+import { ensureContext } from './config.js';
+import { lifecycleHooks } from './hooks.js';
+import { debugLog } from './utils/debugging.js';
+import { mkdirp, readFile, unlinkFile, writeFile } from './utils/file-system.js';
+import { createWatcher } from './utils/watcher.js';
+import { getLogger } from './utils/logger.js';
+const hash = (content) => createHash('sha1').update(content).digest('base64');
+export async function generate(input, saveToFile = true) {
+    const context = ensureContext(input);
+    const config = context.getConfig();
+    await context.profiler.run(() => lifecycleHooks(config.hooks).afterStart(), 'Lifecycle: afterStart');
+    let previouslyGeneratedFilenames = [];
+    function removeStaleFiles(config, generationResult) {
+        const filenames = generationResult.map(o => o.filename);
+        // find stale files from previous build which are not present in current build
+        const staleFilenames = previouslyGeneratedFilenames.filter(f => !filenames.includes(f));
+        for (const filename of staleFilenames) {
+            if (shouldOverwrite(config, filename)) {
+                unlinkFile(filename, err => {
+                    const prettyFilename = filename.replace(`${input.cwd || process.cwd()}/`, '');
+                    if (err) {
+                        debugLog(`Cannot remove stale file: ${prettyFilename}\n${err}`);
+                    }
+                    else {
+                        debugLog(`Removed stale file: ${prettyFilename}`);
+                    }
+                });
+            }
+        }
+        previouslyGeneratedFilenames = filenames;
+    }
+    const recentOutputHash = new Map();
+    async function writeOutput(generationResult) {
+        if (!saveToFile) {
+            return generationResult;
+        }
+        if (config.watch) {
+            removeStaleFiles(config, generationResult);
+        }
+        await context.profiler.run(async () => {
+            await lifecycleHooks(config.hooks).beforeAllFileWrite(generationResult.map(r => r.filename));
+        }, 'Lifecycle: beforeAllFileWrite');
+        await context.profiler.run(() => Promise.all(generationResult.map(async (result) => {
+            const previousHash = recentOutputHash.get(result.filename) || (await hashFile(result.filename));
+            const exists = previousHash !== null;
+            // Store previous hash to avoid reading from disk again
+            if (previousHash) {
+                recentOutputHash.set(result.filename, previousHash);
+            }
+            if (!shouldOverwrite(config, result.filename) && exists) {
+                return;
+            }
+            let content = result.content || '';
+            const currentHash = hash(content);
+            if (previousHash && currentHash === previousHash) {
+                debugLog(`Skipping file (${result.filename}) writing due to indentical hash...`);
+                return;
+            }
+            // skip updating file in dry mode
+            if (context.checkMode) {
+                context.checkModeStaleFiles.push(result.filename);
+                return;
+            }
+            if (content.length === 0) {
+                return;
+            }
+            const absolutePath = isAbsolute(result.filename)
+                ? result.filename
+                : join(input.cwd || process.cwd(), result.filename);
+            const basedir = dirname(absolutePath);
+            await mkdirp(basedir);
+            content = await lifecycleHooks(result.hooks).beforeOneFileWrite(absolutePath, content);
+            content = await lifecycleHooks(config.hooks).beforeOneFileWrite(absolutePath, content);
+            if (content !== result.content) {
+                result.content = content;
+                // compare the prettified content with the previous hash
+                // to compare the content with an existing prettified file
+                if (hash(content) === previousHash) {
+                    debugLog(`Skipping file (${result.filename}) writing due to indentical hash after prettier...`);
+                    // the modified content is NOT stored in recentOutputHash
+                    // so a diff can already be detected before executing the hook
+                    return;
+                }
+            }
+            await writeFile(absolutePath, result.content);
+            recentOutputHash.set(result.filename, currentHash);
+            await lifecycleHooks(result.hooks).afterOneFileWrite(result.filename);
+            await lifecycleHooks(config.hooks).afterOneFileWrite(result.filename);
+        })), 'Write files');
+        await context.profiler.run(() => lifecycleHooks(config.hooks).afterAllFileWrite(generationResult.map(r => r.filename)), 'Lifecycle: afterAllFileWrite');
+        return generationResult;
+    }
+    // watch mode
+    if (config.watch) {
+        return createWatcher(context, writeOutput).runningWatcher;
+    }
+    const { result: outputFiles, error } = await context.profiler.run(() => executeCodegen(context), 'executeCodegen');
+    if (error) {
+        // If all generation failed, just throw to return non-zero code.
+        if (outputFiles.length === 0) {
+            throw error;
+        }
+        // If partial success, but partial output is not allowed, throw to return non-zero code.
+        if (!config.allowPartialOutputs) {
+            getLogger().error(`  ${logSymbols.error} One or more errors occurred, no files were generated. To allow output on errors, set config.allowPartialOutputs=true`);
+            throw error;
+        }
+        // If partial success, and partial output is allowed, warn and proceed to write to files.
+        getLogger().warn(`  ${logSymbols.warning} One or more errors occurred, some files were generated. To prevent any output on errors, set config.allowPartialOutputs=false`);
+    }
+    await context.profiler.run(() => writeOutput(outputFiles), 'writeOutput');
+    await context.profiler.run(() => lifecycleHooks(config.hooks).beforeDone(), 'Lifecycle: beforeDone');
+    if (context.profilerOutput) {
+        await writeFile(join(context.cwd, context.profilerOutput), JSON.stringify(context.profiler.collect()));
+    }
+    return outputFiles;
+}
+function shouldOverwrite(config, outputPath) {
+    const globalValue = config.overwrite === undefined ? true : !!config.overwrite;
+    const outputConfig = config.generates[outputPath];
+    if (!outputConfig) {
+        debugLog(`Couldn't find a config of ${outputPath}`);
+        return globalValue;
+    }
+    if (isConfiguredOutput(outputConfig) && typeof outputConfig.overwrite === 'boolean') {
+        return outputConfig.overwrite;
+    }
+    return globalValue;
+}
+function isConfiguredOutput(output) {
+    return typeof output.plugins !== 'undefined';
+}
+async function hashFile(filePath) {
+    try {
+        return hash(await readFile(filePath));
+    }
+    catch (err) {
+        if (err && err.code === 'ENOENT') {
+            // return null if file does not exist
+            return null;
+        }
+        // rethrow unexpected errors
+        throw err;
+    }
+}

package/esm/graphql-config.js

@@ -0,0 +1,62 @@
+import { ApolloEngineLoader } from '@graphql-tools/apollo-engine-loader';
+import { CodeFileLoader } from '@graphql-tools/code-file-loader';
+import { GitLoader } from '@graphql-tools/git-loader';
+import { GithubLoader } from '@graphql-tools/github-loader';
+import { loadConfig } from 'graphql-config';
+export const CodegenExtension = (api) => {
+    // Schema
+    api.loaders.schema.register(new CodeFileLoader({
+        pluckConfig: {
+            skipIndent: true,
+        },
+    }));
+    api.loaders.schema.register(new GitLoader());
+    api.loaders.schema.register(new GithubLoader());
+    api.loaders.schema.register(new ApolloEngineLoader());
+    // Documents
+    api.loaders.documents.register(new CodeFileLoader({
+        pluckConfig: {
+            skipIndent: true,
+        },
+    }));
+    api.loaders.documents.register(new GitLoader());
+    api.loaders.documents.register(new GithubLoader());
+    return {
+        name: 'codegen',
+    };
+};
+export async function findAndLoadGraphQLConfig(filepath) {
+    const config = await loadConfig({
+        filepath,
+        rootDir: process.cwd(),
+        extensions: [CodegenExtension],
+        throwOnEmpty: false,
+        throwOnMissing: false,
+    });
+    if (isGraphQLConfig(config)) {
+        return config;
+    }
+}
+// Kamil: user might load a config that is not GraphQL Config
+//        so we need to check if it's a regular config or not
+function isGraphQLConfig(config) {
+    if (!config) {
+        return false;
+    }
+    try {
+        return config.getDefault().hasExtension('codegen');
+    }
+    catch { }
+    try {
+        for (const projectName in config.projects) {
+            if (Object.prototype.hasOwnProperty.call(config.projects, projectName)) {
+                const project = config.projects[projectName];
+                if (project.hasExtension('codegen')) {
+                    return true;
+                }
+            }
+        }
+    }
+    catch { }
+    return false;
+}