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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const changeCase = require("change-case");
const enum_matcher_1 = require("./enums/enum-matcher");
class InterfaceBuilder {
    constructor(settings, mysqlTypes, schema) {
        this.settings = settings;
        this.mysqlTypes = mysqlTypes;
        this.schema = schema;
        this.matcher = new enum_matcher_1.EnumMatcher();
    }
    renderTs(tableClass, table) {
        const extraImports = [];
        const maybeEquals = tableClass.useInterface === "type" ? "=" : "";
        let stringBuilder = `${this.settings.defaultClassModifier} ${tableClass.useInterface} ${tableClass.prefixedClassName} ${maybeEquals} { \n`;
        for (const colName in table) {
            const col = table[colName];
            stringBuilder += this.buildTypeRow(col, colName);
            if (this.isEnum(col)) {
                extraImports.push(col);
            }
        }
        stringBuilder += "}\n";
        const importStatements = new Set();
        if (extraImports.length) {
            // if (tableClass.isTable) {
            //   let relativePath = "../enums/" + changeCase.paramCase(tableClass.tableName) + ".generated";
            //   const tableImportArr = [changeCase.constant(tableClass.tableName)];
            //   importStatements.add(this.importStatement(tableImportArr, relativePath));
            // } else {
            const bestMatches = extraImports.map(c => this.matcher.run(this.schema, c, tableClass.tableName));
            bestMatches.forEach(b => {
                let relativePath = "../enums/" + changeCase.paramCase(b.table) + ".generated";
                importStatements.add(this.importStatement([changeCase.constant(b.table)], relativePath));
            });
            // }
        }
        const importStr = [...importStatements].join("");
        return this.getMetaText() + "\n" + importStr + "\n" + stringBuilder;
    }
    importStatement(fieldNames, relativePath) {
        return `import { ${fieldNames.join(", ")} } from "${relativePath}"\n`;
    }
    getMetaText() {
        let meta = `/**
 * Auto generated, do not modify!
 */
/* eslint-disable */
`;
        return meta;
    }
    buildTypeRow(col, colName) {
        const tabs = "\t";
        const optional = this.settings.optionalParameters ? "?" : "";
        const tsType = this.getTsType(col, colName);
        const field = col.field;
        return `${tabs}${field}${optional}: ${tsType};\n`;
    }
    ;
    isEnum(col) {
        var _a;
        return !!((_a = col.enumValues) === null || _a === void 0 ? void 0 : _a.length);
    }
    getTsType(col, colName) {
        var _a;
        const maybeNull = col.null === "YES" ? " | null" : "";
        if (this.isEnum(col)) {
            const matches = this.matcher.run(this.schema, col, colName);
            if (!matches) {
                throw new Error("No matching column");
            }
            if ((_a = matches.replacementFor) === null || _a === void 0 ? void 0 : _a.length) {
                return changeCase.constantCase(matches.field) + maybeNull;
            }
            return changeCase.constantCase(matches.table) + "." + changeCase.constantCase(matches.field) + maybeNull;
        }
        let ts = this.mysqlTypes[col.type];
        if (!ts) {
            // tslint:disable-next-line:no-console
            console.error("Unknown type " + col.type);
            return "unknown";
        }
        return ts + maybeNull;
    }
}
exports.InterfaceBuilder = InterfaceBuilder;
//# sourceMappingURL=interface-builder.js.map