@test-graphql-cli/generate/dist/index.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const code_file_loader_1 = require("@graphql-toolkit/code-file-loader");
const git_loader_1 = require("@graphql-toolkit/git-loader");
const github_loader_1 = require("@graphql-toolkit/github-loader");
const apollo_engine_loader_1 = require("@graphql-toolkit/apollo-engine-loader");
const prisma_loader_1 = require("@graphql-toolkit/prisma-loader");
const fs_extra_1 = require("fs-extra");
const fs_1 = require("fs");
const path_1 = require("path");
const core_1 = require("@graphback/core");
const graphql_migrations_1 = require("graphql-migrations");
const codegen_client_1 = require("@graphback/codegen-client");
const codegen_resolvers_1 = require("@graphback/codegen-resolvers");
const codegen_schema_1 = require("@graphback/codegen-schema");
const listr_1 = tslib_1.__importDefault(require("listr"));
const inquirer_1 = require("inquirer");
const chokidar_1 = tslib_1.__importDefault(require("chokidar"));
const debounce_1 = tslib_1.__importDefault(require("debounce"));
const graphql_1 = require("graphql");
const FormatExtensionMap = {
    'ts': 'ts',
    'js': 'js',
    'gql': 'graphql',
};
function writeFile(path, data) {
    return new Promise(async (resolve, reject) => {
        await fs_extra_1.ensureFile(path);
        fs_1.writeFile(path, data, err => {
            if (err) {
                reject(err);
            }
            resolve();
        });
    });
}
exports.writeFile = writeFile;
function globPromise(glob, options = {}) {
    return new Promise(async (resolve, reject) => {
        const { default: globAsync } = await Promise.resolve().then(() => tslib_1.__importStar(require('glob')));
        globAsync(glob, options, (err, data) => {
            if (err) {
                reject(err);
            }
            resolve(data);
        });
    });
}
exports.globPromise = globPromise;
async function createSchemaFile(cwd, generatedSchema, config) {
    const extension = FormatExtensionMap[config.generator.schema.format];
    return writeFile(path_1.join(cwd, config.folders.schema, 'generated.' + extension), generatedSchema);
}
exports.createSchemaFile = createSchemaFile;
async function createResolversFiles(cwd, resolvers, config) {
    const extension = FormatExtensionMap[config.generator.resolvers.format];
    return Promise.all(resolvers.types.map(typeResolver => writeFile(path_1.join(cwd, config.folders.resolvers, 'generated', typeResolver.name + '.' + extension), typeResolver.output)));
}
exports.createResolversFiles = createResolversFiles;
async function createBackendFiles(cwd, inputContext, config) {
    const resolvers = codegen_resolvers_1.createResolvers(inputContext, config.generator.resolvers);
    const schema = codegen_schema_1.createSchema(inputContext, config.generator.schema);
    await Promise.all([
        createSchemaFile(cwd, schema, config),
        createResolversFiles(cwd, resolvers, config)
    ]);
}
exports.createBackendFiles = createBackendFiles;
async function createFragments(cwd, generated, config) {
    const extension = FormatExtensionMap[config.generator.client.format];
    return Promise.all(generated.fragments.map((fragment) => writeFile(path_1.join(cwd, config.folders.client, 'generated', 'fragments', fragment.name + '.' + extension), fragment.implementation)));
}
exports.createFragments = createFragments;
async function createQueries(cwd, generated, config) {
    const extension = FormatExtensionMap[config.generator.client.format];
    return Promise.all(generated.queries.map(query => writeFile(path_1.join(cwd, config.folders.client, 'generated', 'queries', query.name + '.' + extension), query.implementation)));
}
exports.createQueries = createQueries;
async function createMutations(cwd, generated, config) {
    const extension = FormatExtensionMap[config.generator.client.format];
    return Promise.all(generated.mutations.map(mutation => writeFile(path_1.join(cwd, config.folders.client, 'generated', 'mutations', mutation.name + '.' + extension), mutation.implementation)));
}
exports.createMutations = createMutations;
async function createSubscriptions(cwd, generated, config) {
    const extension = FormatExtensionMap[config.generator.client.format];
    return Promise.all(generated.subscriptions.map(subscription => writeFile(path_1.join(cwd, config.folders.client, 'generated', 'subscriptions', subscription.name + '.' + extension), subscription.implementation)));
}
exports.createSubscriptions = createSubscriptions;
async function createClientFiles(cwd, inputContext, config) {
    const generated = await codegen_client_1.createClient(inputContext, { output: config.generator.client.format });
    await Promise.all([
        createFragments(cwd, generated, config),
        createQueries(cwd, generated, config),
        createMutations(cwd, generated, config),
        createSubscriptions(cwd, generated, config),
    ]);
}
exports.createClientFiles = createClientFiles;
async function createDatabaseMigration(schema, config) {
    const dbConfig = {
        client: config.db.database,
        connection: config.db.dbConfig,
    };
    await graphql_migrations_1.migrateDB(dbConfig, schema);
}
exports.createDatabaseMigration = createDatabaseMigration;
exports.runGeneration = async ({ db, client, backend, silent }, cwd, generateConfig, schemaString) => {
    const tasks = [];
    if (backend || client) {
        // Creates model context that is shared with all generators to provide results
        const inputContext = core_1.graphQLInputContext.createModelContext(schemaString, generateConfig.graphqlCRUD);
        if (backend) {
            tasks.push({
                title: 'Generating Backend Schema and Resolvers',
                task: () => createBackendFiles(cwd, inputContext, generateConfig),
            });
        }
        if (client) {
            tasks.push({
                title: 'Generating Client-side Operations',
                task: () => createClientFiles(cwd, inputContext, generateConfig),
            });
        }
    }
    if (db) {
        tasks.push({
            title: 'Running Database Migration',
            task: () => createDatabaseMigration(schemaString, generateConfig),
        });
    }
    const listr = new listr_1.default(tasks, {
        renderer: silent ? 'silent' : 'default',
        // it doesn't stop when one of tasks failed, to finish at least some of outputs
        exitOnError: false,
        // run 4 at once
        concurrent: 4,
    });
    await listr.run();
};
const GenerateExtension = api => {
    // Schema
    api.loaders.schema.register(new code_file_loader_1.CodeFileLoader());
    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());
    return {
        name: 'generate'
    };
};
exports.plugin = {
    init({ program, loadProjectConfig, reportError }) {
        program
            .command('generate')
            .option('--db')
            .option('--client')
            .option('--backend')
            .option('--silent')
            .option('-w, --watch', 'Watch for changes and execute generation automatically')
            .action(async (cliFlags) => {
            try {
                const config = await loadProjectConfig({
                    extensions: [GenerateExtension]
                });
                const generateConfig = await config.extension('generate');
                if (!generateConfig) {
                    throw new Error(`You should provide a valid 'generate' config to generate schema from data model`);
                }
                if (!generateConfig.folders) {
                    throw new Error(`'generate' config missing 'folders' section that is required`);
                }
                if (!cliFlags.db && !cliFlags.client && !cliFlags.backend) {
                    const { selections } = await inquirer_1.prompt([
                        {
                            type: 'checkbox',
                            name: 'selections',
                            message: 'What do you want to generate?',
                            choices: [
                                {
                                    value: 'backend',
                                    name: 'Backend Schema and Resolvers',
                                },
                                {
                                    value: 'client',
                                    name: 'Client-Side Operation',
                                }, {
                                    value: 'db',
                                    name: 'Database Creation and Migration',
                                }
                            ]
                        }
                    ]);
                    cliFlags.db = selections.includes('db');
                    cliFlags.client = selections.includes('client');
                    cliFlags.backend = selections.includes('backend');
                }
                const debouncedExec = debounce_1.default(async () => {
                    try {
                        const schemaDocument = await config.loadSchema(path_1.join(config.dirpath, generateConfig.folders.model + '/**/*.graphql'), 'DocumentNode');
                        const schemaString = graphql_1.print(schemaDocument);
                        await exports.runGeneration(cliFlags, config.dirpath, generateConfig, schemaString);
                    }
                    catch (e) {
                        reportError(e);
                    }
                    console.info('Watching for changes...');
                }, 100);
                if (cliFlags.watch) {
                    chokidar_1.default.watch(generateConfig.folders.model, {
                        persistent: true,
                        cwd: config.dirpath,
                    }).on('all', debouncedExec);
                }
                else {
                    const schemaDocument = await config.loadSchema(path_1.join(config.dirpath, generateConfig.folders.model + '/**/*.graphql'), 'DocumentNode');
                    const schemaString = graphql_1.print(schemaDocument);
                    await exports.runGeneration(cliFlags, config.dirpath, generateConfig, schemaString);
                    process.exit(0);
                }
            }
            catch (e) {
                reportError(e);
            }
        });
    }
};
//# sourceMappingURL=index.js.map