@graphql-codegen/cli 2.7.0 → 2.7.1-alpha-223b75f49.0

package/cjs/config.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureContext = exports.CodegenContext = exports.updateContextWithCliFlags = exports.createContext = exports.parseArgv = exports.buildOptions = exports.loadContext = exports.loadCodegenConfig = exports.generateSearchPlaces = void 0;
+const tslib_1 = require("tslib");
+const cosmiconfig_1 = require("cosmiconfig");
+const path_1 = require("path");
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const string_env_interpolation_1 = require("string-env-interpolation");
+const yargs_1 = tslib_1.__importDefault(require("yargs"));
+const graphql_config_js_1 = require("./graphql-config.js");
+const load_js_1 = require("./load.js");
+const graphql_1 = require("graphql");
+const yaml_1 = tslib_1.__importDefault(require("yaml"));
+const module_1 = require("module");
+const fs_1 = require("fs");
+const crypto_1 = require("crypto");
+const { lstat } = fs_1.promises;
+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'];
+}
+exports.generateSearchPlaces = generateSearchPlaces;
+function customLoader(ext) {
+    function loader(filepath, content) {
+        if (typeof process !== 'undefined' && 'env' in process) {
+            content = (0, string_env_interpolation_1.env)(content);
+        }
+        if (ext === 'json') {
+            return cosmiconfig_1.defaultLoaders['.json'](filepath, content);
+        }
+        if (ext === 'yaml') {
+            try {
+                const result = yaml_1.default.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 cosmiconfig_1.defaultLoaders['.js'](filepath, content);
+        }
+    }
+    return loader;
+}
+async function loadCodegenConfig({ configFilePath, moduleName, searchPlaces: additionalSearchPlaces, packageProp, loaders: customLoaders, }) {
+    configFilePath = configFilePath || process.cwd();
+    moduleName = moduleName || 'codegen';
+    packageProp = packageProp || moduleName;
+    const cosmi = (0, cosmiconfig_1.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);
+}
+exports.loadCodegenConfig = loadCodegenConfig;
+async function loadContext(configFilePath) {
+    const graphqlConfig = await (0, graphql_config_js_1.findAndLoadGraphQLConfig)(configFilePath);
+    if (graphqlConfig) {
+        return new CodegenContext({
+            graphqlConfig,
+        });
+    }
+    const result = await loadCodegenConfig({ configFilePath });
+    if (!result) {
+        if (configFilePath) {
+            throw new plugin_helpers_1.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 plugin_helpers_1.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 plugin_helpers_1.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,
+    });
+}
+exports.loadContext = loadContext;
+function getCustomConfigPath(cliFlags) {
+    const configFile = cliFlags.config;
+    return configFile ? (0, path_1.resolve)(process.cwd(), configFile) : null;
+}
+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',
+        },
+    };
+}
+exports.buildOptions = buildOptions;
+function parseArgv(argv = process.argv) {
+    return (0, yargs_1.default)(argv).options(buildOptions()).parse(argv);
+}
+exports.parseArgv = parseArgv;
+async function createContext(cliFlags = parseArgv(process.argv)) {
+    if (cliFlags.require && cliFlags.require.length > 0) {
+        const relativeRequire = (0, module_1.createRequire)(process.cwd());
+        await Promise.all(cliFlags.require.map(mod => Promise.resolve().then(() => tslib_1.__importStar(require(relativeRequire.resolve(mod, {
+            paths: [process.cwd()],
+        }))))));
+    }
+    const customConfigPath = getCustomConfigPath(cliFlags);
+    const context = await loadContext(customConfigPath);
+    updateContextWithCliFlags(context, cliFlags);
+    return context;
+}
+exports.createContext = createContext;
+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);
+}
+exports.updateContextWithCliFlags = updateContextWithCliFlags;
+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 = (0, plugin_helpers_1.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 = (0, plugin_helpers_1.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(load_js_1.defaultSchemaLoadOptions);
+        if (this._graphqlConfig) {
+            // TODO: SchemaWithLoader won't work here
+            return addHashToSchema(this._graphqlConfig.getProject(this._project).loadSchema(pointer, 'GraphQLSchema', config));
+        }
+        return addHashToSchema((0, load_js_1.loadSchema)(pointer, config));
+    }
+    async loadDocuments(pointer) {
+        const config = this.getConfig(load_js_1.defaultDocumentsLoadOptions);
+        if (this._graphqlConfig) {
+            // TODO: pointer won't work here
+            return addHashToDocumentFiles(this._graphqlConfig.getProject(this._project).loadDocuments(pointer, config));
+        }
+        return addHashToDocumentFiles((0, load_js_1.loadDocuments)(pointer, config));
+    }
+}
+exports.CodegenContext = CodegenContext;
+function ensureContext(input) {
+    return input instanceof CodegenContext ? input : new CodegenContext({ config: input });
+}
+exports.ensureContext = ensureContext;
+function hashContent(content) {
+    return (0, crypto_1.createHash)('sha256').update(content).digest('hex');
+}
+function hashSchema(schema) {
+    return hashContent((0, graphql_1.print)((0, plugin_helpers_1.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((0, graphql_1.print)(doc.document));
+    }
+    return null;
+}
+function addHashToDocumentFiles(documentFilesPromise) {
+    return documentFilesPromise.then(documentFiles => documentFiles.map(doc => {
+        doc.hash = hashDocument(doc);
+        return doc;
+    }));
+}

package/cjs/generate-and-save.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = void 0;
+const tslib_1 = require("tslib");
+const hooks_js_1 = require("./hooks.js");
+const codegen_js_1 = require("./codegen.js");
+const watcher_js_1 = require("./utils/watcher.js");
+const file_system_js_1 = require("./utils/file-system.js");
+const mkdirp_1 = tslib_1.__importDefault(require("mkdirp"));
+const path_1 = require("path");
+const debugging_js_1 = require("./utils/debugging.js");
+const config_js_1 = require("./config.js");
+const crypto_1 = require("crypto");
+const hash = (content) => (0, crypto_1.createHash)('sha1').update(content).digest('base64');
+async function generate(input, saveToFile = true) {
+    const context = (0, config_js_1.ensureContext)(input);
+    const config = context.getConfig();
+    await context.profiler.run(() => (0, hooks_js_1.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));
+        staleFilenames.forEach(filename => {
+            if (shouldOverwrite(config, filename)) {
+                return (0, file_system_js_1.unlinkFile)(filename, err => {
+                    const prettyFilename = filename.replace(`${input.cwd || process.cwd()}/`, '');
+                    if (err) {
+                        (0, debugging_js_1.debugLog)(`Cannot remove stale file: ${prettyFilename}\n${err}`);
+                    }
+                    else {
+                        (0, debugging_js_1.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 (0, hooks_js_1.lifecycleHooks)(config.hooks).beforeAllFileWrite(generationResult.map(r => r.filename));
+        }, 'Lifecycle: beforeAllFileWrite');
+        await context.profiler.run(() => Promise.all(generationResult.map(async (result) => {
+            const exists = await (0, file_system_js_1.fileExists)(result.filename);
+            if (!shouldOverwrite(config, result.filename) && exists) {
+                return;
+            }
+            const content = result.content || '';
+            const currentHash = hash(content);
+            let previousHash = recentOutputHash.get(result.filename);
+            if (!previousHash && exists) {
+                previousHash = hash(await (0, file_system_js_1.readFile)(result.filename));
+            }
+            if (previousHash && currentHash === previousHash) {
+                (0, debugging_js_1.debugLog)(`Skipping file (${result.filename}) writing due to indentical hash...`);
+                return;
+            }
+            if (content.length === 0) {
+                return;
+            }
+            recentOutputHash.set(result.filename, currentHash);
+            const basedir = (0, path_1.dirname)(result.filename);
+            await (0, hooks_js_1.lifecycleHooks)(result.hooks).beforeOneFileWrite(result.filename);
+            await (0, hooks_js_1.lifecycleHooks)(config.hooks).beforeOneFileWrite(result.filename);
+            await (0, mkdirp_1.default)(basedir);
+            const absolutePath = (0, path_1.isAbsolute)(result.filename)
+                ? result.filename
+                : (0, path_1.join)(input.cwd || process.cwd(), result.filename);
+            await (0, file_system_js_1.writeFile)(absolutePath, result.content);
+            await (0, hooks_js_1.lifecycleHooks)(result.hooks).afterOneFileWrite(result.filename);
+            await (0, hooks_js_1.lifecycleHooks)(config.hooks).afterOneFileWrite(result.filename);
+        })), 'Write files');
+        await context.profiler.run(() => (0, hooks_js_1.lifecycleHooks)(config.hooks).afterAllFileWrite(generationResult.map(r => r.filename)), 'Lifecycle: afterAllFileWrite');
+        return generationResult;
+    }
+    // watch mode
+    if (config.watch) {
+        return (0, watcher_js_1.createWatcher)(context, writeOutput);
+    }
+    const outputFiles = await context.profiler.run(() => (0, codegen_js_1.executeCodegen)(context), 'executeCodegen');
+    await context.profiler.run(() => writeOutput(outputFiles), 'writeOutput');
+    await context.profiler.run(() => (0, hooks_js_1.lifecycleHooks)(config.hooks).beforeDone(), 'Lifecycle: beforeDone');
+    if (context.profilerOutput) {
+        await (0, file_system_js_1.writeFile)((0, path_1.join)(context.cwd, context.profilerOutput), JSON.stringify(context.profiler.collect()));
+    }
+    return outputFiles;
+}
+exports.generate = generate;
+function shouldOverwrite(config, outputPath) {
+    const globalValue = config.overwrite === undefined ? true : !!config.overwrite;
+    const outputConfig = config.generates[outputPath];
+    if (!outputConfig) {
+        (0, debugging_js_1.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';
+}

package/cjs/graphql-config.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findAndLoadGraphQLConfig = exports.CodegenExtension = void 0;
+const graphql_config_1 = require("graphql-config");
+const apollo_engine_loader_1 = require("@graphql-tools/apollo-engine-loader");
+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 prisma_loader_1 = require("@graphql-tools/prisma-loader");
+const CodegenExtension = (api) => {
+    // Schema
+    api.loaders.schema.register(new code_file_loader_1.CodeFileLoader({
+        pluckConfig: {
+            skipIndent: true,
+        },
+    }));
+    api.loaders.schema.register(new git_loader_1.GitLoader());
+    api.loaders.schema.register(new github_loader_1.GithubLoader());
+    api.loaders.schema.register(new apollo_engine_loader_1.ApolloEngineLoader());
+    api.loaders.schema.register(new prisma_loader_1.PrismaLoader());
+    // Documents
+    api.loaders.documents.register(new code_file_loader_1.CodeFileLoader({
+        pluckConfig: {
+            skipIndent: true,
+        },
+    }));
+    api.loaders.documents.register(new git_loader_1.GitLoader());
+    api.loaders.documents.register(new github_loader_1.GithubLoader());
+    return {
+        name: 'codegen',
+    };
+};
+exports.CodegenExtension = CodegenExtension;
+async function findAndLoadGraphQLConfig(filepath) {
+    const config = await (0, graphql_config_1.loadConfig)({
+        filepath,
+        rootDir: process.cwd(),
+        extensions: [exports.CodegenExtension],
+        throwOnEmpty: false,
+        throwOnMissing: false,
+    });
+    if (isGraphQLConfig(config)) {
+        return config;
+    }
+}
+exports.findAndLoadGraphQLConfig = findAndLoadGraphQLConfig;
+// 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 (e) { }
+    try {
+        for (const projectName in config.projects) {
+            if (config.projects.hasOwnProperty(projectName)) {
+                const project = config.projects[projectName];
+                if (project.hasExtension('codegen')) {
+                    return true;
+                }
+            }
+        }
+    }
+    catch (e) { }
+    return false;
+}

package/cjs/hooks.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lifecycleHooks = void 0;
+const debugging_js_1 = require("./utils/debugging.js");
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const DEFAULT_HOOKS = {
+    afterStart: [],
+    beforeDone: [],
+    onWatchTriggered: [],
+    onError: [],
+    afterOneFileWrite: [],
+    afterAllFileWrite: [],
+    beforeOneFileWrite: [],
+    beforeAllFileWrite: [],
+};
+function normalizeHooks(_hooks) {
+    const keys = Object.keys({
+        ...DEFAULT_HOOKS,
+        ..._hooks,
+    });
+    return keys.reduce((prev, hookName) => {
+        if (typeof _hooks[hookName] === 'string') {
+            return {
+                ...prev,
+                [hookName]: [_hooks[hookName]],
+            };
+        }
+        if (typeof _hooks[hookName] === 'function') {
+            return {
+                ...prev,
+                [hookName]: [_hooks[hookName]],
+            };
+        }
+        if (Array.isArray(_hooks[hookName])) {
+            return {
+                ...prev,
+                [hookName]: _hooks[hookName],
+            };
+        }
+        return prev;
+    }, {});
+}
+function execShellCommand(cmd) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(cmd, {
+            env: {
+                ...process.env,
+                PATH: `${process.env.PATH}${path_1.delimiter}${process.cwd()}${path_1.sep}node_modules${path_1.sep}.bin`,
+            },
+        }, (error, stdout, stderr) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(stdout || stderr);
+            }
+        });
+    });
+}
+async function executeHooks(hookName, scripts = [], args = []) {
+    (0, debugging_js_1.debugLog)(`Running lifecycle hook "${hookName}" scripts...`);
+    for (const script of scripts) {
+        if (typeof script === 'string') {
+            (0, debugging_js_1.debugLog)(`Running lifecycle hook "${hookName}" script: ${script} with args: ${args.join(' ')}...`);
+            await execShellCommand(`${script} ${args.join(' ')}`);
+        }
+        else {
+            (0, debugging_js_1.debugLog)(`Running lifecycle hook "${hookName}" script: ${script.name} with args: ${args.join(' ')}...`);
+            await script(...args);
+        }
+    }
+}
+const lifecycleHooks = (_hooks = {}) => {
+    const hooks = normalizeHooks(_hooks);
+    return {
+        afterStart: async () => executeHooks('afterStart', hooks.afterStart),
+        onWatchTriggered: async (event, path) => executeHooks('onWatchTriggered', hooks.onWatchTriggered, [event, path]),
+        onError: async (error) => executeHooks('onError', hooks.onError, [`"${error}"`]),
+        afterOneFileWrite: async (path) => executeHooks('afterOneFileWrite', hooks.afterOneFileWrite, [path]),
+        afterAllFileWrite: async (paths) => executeHooks('afterAllFileWrite', hooks.afterAllFileWrite, paths),
+        beforeOneFileWrite: async (path) => executeHooks('beforeOneFileWrite', hooks.beforeOneFileWrite, [path]),
+        beforeAllFileWrite: async (paths) => executeHooks('beforeAllFileWrite', hooks.beforeAllFileWrite, paths),
+        beforeDone: async () => executeHooks('beforeDone', hooks.beforeDone),
+    };
+};
+exports.lifecycleHooks = lifecycleHooks;

package/cjs/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = exports.executeCodegen = void 0;
+const tslib_1 = require("tslib");
+var codegen_js_1 = require("./codegen.js");
+Object.defineProperty(exports, "executeCodegen", { enumerable: true, get: function () { return codegen_js_1.executeCodegen; } });
+var generate_and_save_js_1 = require("./generate-and-save.js");
+Object.defineProperty(exports, "generate", { enumerable: true, get: function () { return generate_and_save_js_1.generate; } });
+tslib_1.__exportStar(require("./config.js"), exports);
+tslib_1.__exportStar(require("./init/index.js"), exports);
+tslib_1.__exportStar(require("./utils/cli-error.js"), exports);
+tslib_1.__exportStar(require("./cli.js"), exports);
+tslib_1.__exportStar(require("./graphql-config.js"), exports);

package/cjs/init/helpers.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.italic = exports.grey = exports.bold = exports.writePackage = exports.writeConfig = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const path_1 = require("path");
+const fs_1 = require("fs");
+const detect_indent_1 = tslib_1.__importDefault(require("detect-indent"));
+const latest_version_1 = tslib_1.__importDefault(require("latest-version"));
+// Parses config and writes it to a file
+async function writeConfig(answers, config) {
+    const YAML = await Promise.resolve().then(() => tslib_1.__importStar(require('json-to-pretty-yaml'))).then(m => ('default' in m ? m.default : m));
+    const ext = answers.config.toLocaleLowerCase().endsWith('.json') ? 'json' : 'yml';
+    const content = ext === 'json' ? JSON.stringify(config) : YAML.stringify(config);
+    const fullPath = (0, path_1.resolve)(process.cwd(), answers.config);
+    const relativePath = (0, path_1.relative)(process.cwd(), answers.config);
+    (0, fs_1.writeFileSync)(fullPath, content, {
+        encoding: 'utf-8',
+    });
+    return {
+        relativePath,
+        fullPath,
+    };
+}
+exports.writeConfig = writeConfig;
+// Updates package.json (script and plugins as dependencies)
+async function writePackage(answers, configLocation) {
+    // script
+    const pkgPath = (0, path_1.resolve)(process.cwd(), 'package.json');
+    const pkgContent = (0, fs_1.readFileSync)(pkgPath, {
+        encoding: 'utf-8',
+    });
+    const pkg = JSON.parse(pkgContent);
+    const { indent } = (0, detect_indent_1.default)(pkgContent);
+    if (!pkg.scripts) {
+        pkg.scripts = {};
+    }
+    pkg.scripts[answers.script] = `graphql-codegen --config ${configLocation}`;
+    // plugin
+    if (!pkg.devDependencies) {
+        pkg.devDependencies = {};
+    }
+    await Promise.all(answers.plugins.map(async (plugin) => {
+        pkg.devDependencies[plugin.package] = await (0, latest_version_1.default)(plugin.package);
+    }));
+    if (answers.introspection) {
+        pkg.devDependencies['@graphql-codegen/introspection'] = await (0, latest_version_1.default)('@graphql-codegen/introspection');
+    }
+    pkg.devDependencies['@graphql-codegen/cli'] = await (0, latest_version_1.default)('@graphql-codegen/cli');
+    (0, fs_1.writeFileSync)(pkgPath, JSON.stringify(pkg, null, indent));
+}
+exports.writePackage = writePackage;
+function bold(str) {
+    return chalk_1.default.bold(str);
+}
+exports.bold = bold;
+function grey(str) {
+    return chalk_1.default.grey(str);
+}
+exports.grey = grey;
+function italic(str) {
+    return chalk_1.default.italic(str);
+}
+exports.italic = italic;