@fewer/cli/lib/commands/db/schema.js

The CLI to scaffold and perform operations for Fewer.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const path_1 = __importDefault(require("path"));
const command_1 = require("@oclif/command");
const commonFlags_1 = __importDefault(require("../../commonFlags"));
const getConfig_1 = __importDefault(require("../../getConfig"));
const utils_1 = require("../../utils");
class GenerateSchema extends command_1.Command {
    async run() {
        const { flags } = this.parse(GenerateSchema);
        const config = await getConfig_1.default();
        // Include the TS transpiler to allow TS syntax inside of migration files:
        require('ts-node/register/transpile-only');
        const databases = config.databases.map(dbFile => ({
            module: require(path_1.default.join(process.cwd(), dbFile)),
            ident: utils_1.resolve(config.schema, dbFile),
            // TODO: Dedupe to ensure we don't have multiple of these:
            importName: path_1.default.basename(dbFile, path_1.default.extname(dbFile)),
        }));
        let tables = [];
        if (flags.offline) {
            let tableMap = {};
            const migrations = await utils_1.getMigrations();
            for (const migrationFile of migrations) {
                const migrationModule = require(migrationFile);
                const migration = migrationModule.default || migrationModule;
                migration.prepare('up');
                migration.operations.forEach(operation => {
                    if (operation.type === 'createTable') {
                        tableMap[operation.name] = {
                            name: operation.name,
                            database: databases.find(db => db.module === migration.database ||
                                db.module.default === migration.database),
                            columns: Object.entries(operation.columns).map(([key, value]) => ({
                                name: key,
                                method: value.reflectName,
                                arguments: [value.config],
                            })),
                        };
                    }
                    else if (operation.type === 'dropTable') {
                        delete tableMap[operation.name];
                    }
                });
            }
            tables = Object.values(tableMap);
        }
        else {
            for (const db of databases) {
                const database = db.module.default || db.module;
                await database.connect();
                const infos = await database.adapter.getInfos();
                Object.keys(infos).forEach(key => {
                    tables.push({
                        name: key,
                        database: db,
                        columns: infos[key].columns,
                    });
                });
                await database.disconnect();
            }
        }
        utils_1.createFile('schema', config.schema, {
            databases,
            tables,
        }, config.cjs);
    }
}
GenerateSchema.description = 'Re-generates the schema file based on the current state of the database.';
GenerateSchema.flags = Object.assign({}, commonFlags_1.default, { offline: command_1.flags.boolean({
        description: '',
    }) });
exports.default = GenerateSchema;
//# sourceMappingURL=schema.js.map