typescript-mysql-model/lib/ts-builder.js

"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());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const change_case = require("change-case");
const fs_1 = require("fs");
const pluralize = require("pluralize");
const abstract_handler_builder_1 = require("./abstract-handler-builder");
const definition_builder_1 = require("./definition-builder");
const enum_builder_1 = require("./enums/enum-builder");
const getter_builder_1 = require("./getter-builder");
const graphql_builder_1 = require("./graphql-builder");
const inserter_builder_1 = require("./inserter-builder");
const interface_builder_1 = require("./interface-builder");
const model_builder_1 = require("./model-builder");
const sp_builder_1 = require("./sp-builder");
const table_columns_builder_1 = require("./table-columns-builder");
const update_builder_1 = require("./update-builder");
const enum_writer_1 = require("./enums/enum-writer");
class TsBuilder {
    constructor(folder, schema) {
        this.mysqlTypes = {
            bigint: "number",
            blob: "any",
            char: "string",
            date: "Date | string",
            datetime: "Date | string",
            enum: "string",
            decimal: "number",
            double: "number",
            float: "number",
            int: "number",
            longblob: "any",
            longtext: "string",
            mediumtext: "string",
            set: "string",
            smallint: "number",
            text: "string",
            timestamp: "Date | string",
            tinyint: "boolean",
            varchar: "string"
        };
        this.settings = {
            appendIToDeclaration: true,
            appendIToFileName: true,
            camelCaseFnNames: true,
            defaultClassModifier: "export interface",
            interfaceFolder: "./interfaces/",
            optionalParameters: true,
            singularizeClassNames: true,
            suffixGeneratedToFilenames: true
        };
        this.folder = TsBuilder.normFolder(folder);
        if (schema) {
            this.schema = schema;
        }
    }
    static run(knex, folder) {
        return __awaiter(this, void 0, void 0, function* () {
            const builder = yield new TsBuilder(folder).init(knex);
            builder.renderDefault();
        });
    }
    static normFolder(folder) {
        if (!folder) {
            return "";
        }
        if (!(folder.endsWith("/") || folder.endsWith("\\"))) {
            folder += "/";
        }
        return folder;
    }
    getTypeMap() {
        const map = new Map();
        Object.keys(this.mysqlTypes).forEach((key) => map.set(key, this.mysqlTypes[key]));
        return map;
    }
    init(knex, dbName) {
        return __awaiter(this, void 0, void 0, function* () {
            const builder = new model_builder_1.default(knex, dbName);
            this.schema = yield builder.renderDatabaseSchema();
            return this;
        });
    }
    renderDefault() {
        if (!fs_1.existsSync(this.folder)) {
            fs_1.mkdirSync(this.folder);
        }
        console.log("Generator started");
        if (!fs_1.existsSync(this.intefaceFullPath())) {
            console.log("Mdir:" + this.intefaceFullPath());
            fs_1.mkdirSync(this.intefaceFullPath());
        }
        if (!fs_1.existsSync(this.graphQlFullPath())) {
            console.log("Mdir:" + this.graphQlFullPath());
            fs_1.mkdirSync(this.graphQlFullPath());
        }
        if (!fs_1.existsSync(this.enumsFullPath())) {
            console.log("Mdir:" + this.enumsFullPath());
            fs_1.mkdirSync(this.enumsFullPath());
        }
        if (!fs_1.existsSync(this.enumsQlFullPath())) {
            console.log("Mdir:" + this.enumsQlFullPath());
            fs_1.mkdirSync(this.enumsQlFullPath());
        }
        const enums = new enum_builder_1.EnumBuilder().run(this.schema);
        new enum_writer_1.EnumWriter().run(enums, this.enumsFullPath(), this.enumsQlFullPath());
        console.log("Generating ql files");
        this.renderGraphQlFiles();
        console.log("Generating table file");
        this.renderTableFile();
        console.log("Generating view file");
        this.renderViewFile();
        console.log("Generating column file");
        this.renderColumnsFile();
        console.log("Generating sp file");
        this.renderStoredProcedure();
        console.log("Generating class files");
        this.renderClassFiles();
        console.log("Render view class files");
        this.renderViewClassFiles();
        console.log("Render inserter file");
        this.renderInserter();
        console.log("Render getter file");
        this.renderGetter();
        this.renderSchemaOperator();
        console.log("render abstract handler");
        this.renderAbstractHandler();
    }
    intefaceFullPath() {
        return this.folder + this.settings.interfaceFolder;
    }
    graphQlFullPath() {
        return this.folder + "graphql";
    }
    enumsFullPath() {
        return this.folder + "enums";
    }
    enumsQlFullPath() {
        return this.graphQlFullPath() + "/enums";
    }
    renderTableFile() {
        const start = "export enum TABLE { \n";
        const arr = this.listTables().sort().map(t => `\t${change_case.constantCase(t)} = "${t}",`);
        const content = this.getMetaText() + start + arr.join("\n") + "\n}";
        fs_1.writeFileSync(this.folder + "tables" + this.getFilenameEnding(), content);
    }
    renderViewFile() {
        const start = "export enum VIEW { \n";
        const arr = this.listViews().sort().map(t => `\t${change_case.constantCase(t)} = "${t}",`);
        const content = this.getMetaText() + start + arr.join("\n") + "\n}";
        fs_1.writeFileSync(this.folder + "views" + this.getFilenameEnding(), content);
    }
    renderColumnsFile() {
        const colBuilder = new table_columns_builder_1.TableColumnsBuilder(this.schema);
        const content = colBuilder.renderTemplate();
        fs_1.writeFileSync(this.folder + "columns" + this.getFilenameEnding(), content);
    }
    renderGraphQlFiles() {
        const qlBuilder = new graphql_builder_1.GraphQlBuilder(this.schema);
        let tableClasses = this.renderClasses(this.listTables(), this.folder + "graphql/", true);
        tableClasses.forEach((tc) => {
            const definition = qlBuilder.renderTs(this.schema.tables[tc.tableName], tc);
            fs_1.writeFileSync(tc.fullPath, definition);
        });
        tableClasses = this.renderClasses(this.listViews(), this.folder + "graphql/", false);
        tableClasses.forEach(tc => {
            const definition = qlBuilder.renderTs(this.schema.views[tc.tableName], tc);
            fs_1.writeFileSync(tc.fullPath, definition);
        });
    }
    renderClassFiles() {
        const tables = this.listTables();
        const tableClasses = this.renderClasses(tables, this.intefaceFullPath(), true);
        const interfaceBuilder = new interface_builder_1.InterfaceBuilder(this.settings, this.mysqlTypes, this.schema);
        tableClasses.forEach(tc => {
            const definition = interfaceBuilder.renderTs(tc, this.schema.tables[tc.tableName]);
            fs_1.writeFileSync(tc.fullPath, definition);
        });
    }
    renderViewClassFiles() {
        const views = this.listViews();
        const interfaceBuilder = new interface_builder_1.InterfaceBuilder(this.settings, this.mysqlTypes, this.schema);
        this.renderClasses(views, this.intefaceFullPath(), false).forEach(tc => {
            const definition = interfaceBuilder.renderTs(tc, this.schema.views[tc.tableName]);
            fs_1.writeFileSync(tc.fullPath, definition);
        });
    }
    renderInserter() {
        const tables = this.listTables();
        const tableClasses = this.renderClasses(tables, this.intefaceFullPath(), true);
        const inserterCotent = new inserter_builder_1.InserterBuilder().render(tableClasses, this.settings.interfaceFolder);
        fs_1.writeFileSync(this.folder + this.toFilename("inserter"), inserterCotent);
    }
    renderGetter() {
        const tables = this.listTables();
        const tableClasses = this.renderClasses(tables, this.intefaceFullPath(), true);
        tableClasses.push(...this.renderClasses(this.listViews(), this.intefaceFullPath(), false));
        // tslint:disable-next-line: max-line-length
        const inserterCotent = new getter_builder_1.GettersBuilder(this.schema, this.getTypeMap()).render(tableClasses, this.settings.interfaceFolder);
        fs_1.writeFileSync(this.folder + this.toFilename("getter"), inserterCotent);
    }
    renderSchemaOperator() {
        const schemaClass = new definition_builder_1.DefinitionBuilder(this.schema).renderSchema();
        fs_1.writeFileSync(this.folder + this.toFilename("definition"), schemaClass);
        const tableClasses = this.renderClasses(this.listTables(), this.intefaceFullPath(), true);
        const inserterCotent = new update_builder_1.UpdateBuilder().renderUpdater(tableClasses, this.settings.interfaceFolder);
        fs_1.writeFileSync(this.folder + this.toFilename("updater"), inserterCotent);
    }
    renderStoredProcedure() {
        const spBuiler = new sp_builder_1.default(this.schema.storedProcedures, this.mysqlTypes);
        const filename = "stored-procedures" + this.getFilenameEnding();
        fs_1.writeFileSync(this.folder + filename, spBuiler.renderTemplate());
    }
    renderAbstractHandler() {
        const builder = new abstract_handler_builder_1.AbstractHandlerBuilder();
        fs_1.writeFileSync(this.folder + this.toFilename("abstract-handler"), builder.getFileContent());
    }
    getMetaText() {
        const meta = `/**\n * Autogenerated class containing all the tables, DO NOT MODIFY\n */\n`;
        return meta + "/* tslint:disable */\n";
    }
    renderClasses(tables, folder, isTable) {
        return tables.map(t => {
            let fnName;
            let fnPlural;
            const className = this.getClassName(t);
            if (this.settings.camelCaseFnNames) {
                fnName = change_case.camelCase(className);
                fnPlural = change_case.camelCase(t);
            }
            else {
                fnName = className;
                fnPlural = t;
            }
            const filename = this.toFilename(t);
            return {
                className: this.getClassName(t),
                filename: filename,
                fnName: fnName,
                fnPlural: fnPlural,
                fullPath: folder + filename,
                isTable: isTable,
                prefixedClassName: this.getPrefixedClassName(t),
                tableName: t
            };
        });
    }
    listTables() {
        return Object.keys(this.schema.tables);
    }
    listViews() {
        return Object.keys(this.schema.views);
    }
    getClassName(tableName) {
        const className = this.settings.singularizeClassNames ? pluralize.singular(tableName) : tableName;
        return className;
    }
    getPrefixedClassName(tableName) {
        const preI = this.settings.appendIToDeclaration ? "I" : "";
        return preI + this.getClassName(tableName);
    }
    getFilenameEnding() {
        if (this.settings.suffixGeneratedToFilenames) {
            return ".generated.ts";
        }
        return ".ts";
    }
    toFilename(name) {
        let filename = this.settings.singularizeClassNames ? pluralize.singular(name) : name;
        filename = change_case.paramCase(filename);
        // if (filename.startsWith("i-") && this.settings.appendIToDeclaration) {
        //     filename = filename.replace("i-", "i");
        // }
        return change_case.paramCase(filename) + this.getFilenameEnding();
    }
}
exports.TsBuilder = TsBuilder;
//# sourceMappingURL=ts-builder.js.map