ts-sql-codegen/dist/cli.js

Generates ts-sql-query table mappings from tbls schema output

#!/usr/bin/env node
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const util_1 = require("util");
const zod_1 = require("zod");
const generator_1 = require("./generator");
const promises_1 = __importDefault(require("fs/promises"));
const path_1 = __importDefault(require("path"));
const handlebars_1 = __importDefault(require("handlebars"));
main().catch((e) => {
    console.error(e);
    if (e instanceof zod_1.ZodError) {
        printHelp();
    }
    process.exit(1);
});
function main() {
    return __awaiter(this, void 0, void 0, function* () {
        var _a;
        const { values: argv } = (0, util_1.parseArgs)({
            options: {
                'help': { type: 'boolean', short: 'h' },
                'version': { type: 'boolean', short: 'v' },
                'dry-run': { type: 'boolean' },
                'schema': { type: 'string', short: 's' },
                'connection-source': { type: 'string', short: 'c' },
                'output-dir': { type: 'string', short: 'o' },
                'output-import-ext': { type: 'string' },
                'remove-extraneous': { type: 'string' },
                'export-table-instances': { type: 'boolean' },
                'export-row-types': { type: 'boolean' },
                'export-table-classes': { type: 'boolean' },
                'export-values-types': { type: 'boolean' },
                'export-extracted-columns': { type: 'boolean' }
            }
        });
        if (argv.help) {
            yield printHelp();
            return;
        }
        if (argv.version) {
            yield printVersion();
            return;
        }
        const generator = new generator_1.Generator({
            dryRun: argv["dry-run"],
            schemaPath: argv["schema"],
            connectionSourcePath: argv["connection-source"],
            outputDirPath: argv["output-dir"],
            removeExtraneous: (_a = argv["remove-extraneous"]) !== null && _a !== void 0 ? _a : "never",
            output: {
                import: {
                    extension: argv["output-import-ext"],
                }
            },
            export: {
                tableInstances: argv['export-table-instances'],
                tableClasses: argv['export-table-classes'],
                rowTypes: argv['export-row-types'],
                valuesTypes: argv['export-values-types'],
                extractedColumns: argv['export-extracted-columns']
            }
        });
        yield generator.generate();
    });
}
function printVersion() {
    return __awaiter(this, void 0, void 0, function* () {
        const manifest = yield readManifest();
        console.log(`${manifest.name} version ${manifest.version}`);
    });
}
function printHelp() {
    return __awaiter(this, void 0, void 0, function* () {
        const helpTemplate = yield compileHelpTemplate();
        const templateInput = yield readManifest();
        console.log(helpTemplate(templateInput));
    });
}
function readManifest() {
    return __awaiter(this, void 0, void 0, function* () {
        const rawManifest = yield promises_1.default.readFile(path_1.default.join(__dirname, "../package.json"), "utf8");
        return JSON.parse(rawManifest);
    });
}
function compileHelpTemplate() {
    return __awaiter(this, void 0, void 0, function* () {
        const templatePath = path_1.default.join(__dirname, "help.hbs");
        const templateContent = yield promises_1.default.readFile(templatePath, 'utf8');
        return handlebars_1.default.compile(templateContent);
    });
}
//# sourceMappingURL=cli.js.map