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

package/esm/generate-and-save.js

@@ -0,0 +1,105 @@
+import { lifecycleHooks } from './hooks.js';
+import { executeCodegen } from './codegen.js';
+import { createWatcher } from './utils/watcher.js';
+import { fileExists, readFile, writeFile, unlinkFile } from './utils/file-system.js';
+import mkdirp from 'mkdirp';
+import { dirname, join, isAbsolute } from 'path';
+import { debugLog } from './utils/debugging.js';
+import { ensureContext } from './config.js';
+import { createHash } from 'crypto';
+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));
+        staleFilenames.forEach(filename => {
+            if (shouldOverwrite(config, filename)) {
+                return 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 exists = await 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 readFile(result.filename));
+            }
+            if (previousHash && currentHash === previousHash) {
+                debugLog(`Skipping file (${result.filename}) writing due to indentical hash...`);
+                return;
+            }
+            if (content.length === 0) {
+                return;
+            }
+            recentOutputHash.set(result.filename, currentHash);
+            const basedir = dirname(result.filename);
+            await lifecycleHooks(result.hooks).beforeOneFileWrite(result.filename);
+            await lifecycleHooks(config.hooks).beforeOneFileWrite(result.filename);
+            await mkdirp(basedir);
+            const absolutePath = isAbsolute(result.filename)
+                ? result.filename
+                : join(input.cwd || process.cwd(), result.filename);
+            await writeFile(absolutePath, result.content);
+            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);
+    }
+    const outputFiles = await context.profiler.run(() => executeCodegen(context), 'executeCodegen');
+    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';
+}

package/esm/graphql-config.js

@@ -0,0 +1,64 @@
+import { loadConfig } from 'graphql-config';
+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 { PrismaLoader } from '@graphql-tools/prisma-loader';
+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());
+    api.loaders.schema.register(new PrismaLoader());
+    // 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 (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/esm/hooks.js

@@ -0,0 +1,83 @@
+import { debugLog } from './utils/debugging.js';
+import { exec } from 'child_process';
+import { delimiter, sep } from '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) => {
+        exec(cmd, {
+            env: {
+                ...process.env,
+                PATH: `${process.env.PATH}${delimiter}${process.cwd()}${sep}node_modules${sep}.bin`,
+            },
+        }, (error, stdout, stderr) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(stdout || stderr);
+            }
+        });
+    });
+}
+async function executeHooks(hookName, scripts = [], args = []) {
+    debugLog(`Running lifecycle hook "${hookName}" scripts...`);
+    for (const script of scripts) {
+        if (typeof script === 'string') {
+            debugLog(`Running lifecycle hook "${hookName}" script: ${script} with args: ${args.join(' ')}...`);
+            await execShellCommand(`${script} ${args.join(' ')}`);
+        }
+        else {
+            debugLog(`Running lifecycle hook "${hookName}" script: ${script.name} with args: ${args.join(' ')}...`);
+            await script(...args);
+        }
+    }
+}
+export 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),
+    };
+};

package/esm/index.js

@@ -0,0 +1,7 @@
+export { executeCodegen } from './codegen.js';
+export { generate } from './generate-and-save.js';
+export * from './config.js';
+export * from './init/index.js';
+export * from './utils/cli-error.js';
+export * from './cli.js';
+export * from './graphql-config.js';

package/esm/init/helpers.js

@@ -0,0 +1,55 @@
+import chalk from 'chalk';
+import { resolve, relative } from 'path';
+import { writeFileSync, readFileSync } from 'fs';
+import detectIndent from 'detect-indent';
+import { getLatestVersion } from '../utils/get-latest-version.js';
+// Parses config and writes it to a file
+export async function writeConfig(answers, config) {
+    const YAML = await import('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 = resolve(process.cwd(), answers.config);
+    const relativePath = relative(process.cwd(), answers.config);
+    writeFileSync(fullPath, content, {
+        encoding: 'utf-8',
+    });
+    return {
+        relativePath,
+        fullPath,
+    };
+}
+// Updates package.json (script and plugins as dependencies)
+export async function writePackage(answers, configLocation) {
+    // script
+    const pkgPath = resolve(process.cwd(), 'package.json');
+    const pkgContent = readFileSync(pkgPath, {
+        encoding: 'utf-8',
+    });
+    const pkg = JSON.parse(pkgContent);
+    const { indent } = detectIndent(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 getLatestVersion(plugin.package);
+    }));
+    if (answers.introspection) {
+        pkg.devDependencies['@graphql-codegen/introspection'] = await getLatestVersion('@graphql-codegen/introspection');
+    }
+    pkg.devDependencies['@graphql-codegen/cli'] = await getLatestVersion('@graphql-codegen/cli');
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, indent));
+}
+export function bold(str) {
+    return chalk.bold(str);
+}
+export function grey(str) {
+    return chalk.grey(str);
+}
+export function italic(str) {
+    return chalk.italic(str);
+}

package/esm/init/index.js

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

package/esm/init/plugins.js

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

package/esm/init/questions.js

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