midway-model-gen 0.0.1

package/dist/src/Engine.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataCollectionPhase = exports.createModelFromDatabase = exports.createDriver = void 0;
+const TomgUtils = require("./Utils");
+const MssqlDriver_1 = require("./drivers/MssqlDriver");
+const MariaDbDriver_1 = require("./drivers/MariaDbDriver");
+const PostgresDriver_1 = require("./drivers/PostgresDriver");
+const MysqlDriver_1 = require("./drivers/MysqlDriver");
+const OracleDriver_1 = require("./drivers/OracleDriver");
+const SqliteDriver_1 = require("./drivers/SqliteDriver");
+const ModelCustomization_1 = require("./ModelCustomization");
+const ModelGeneration_1 = require("./ModelGeneration");
+function createDriver(driverName) {
+    switch (driverName) {
+        case "mssql":
+            return new MssqlDriver_1.default();
+        case "postgres":
+            return new PostgresDriver_1.default();
+        case "mysql":
+            return new MysqlDriver_1.default();
+        case "mariadb":
+            return new MariaDbDriver_1.default();
+        case "oracle":
+            return new OracleDriver_1.default();
+        case "sqlite":
+            return new SqliteDriver_1.default();
+        default:
+            TomgUtils.LogError("Database engine not recognized.", false);
+            throw new Error("Database engine not recognized.");
+    }
+}
+exports.createDriver = createDriver;
+async function createModelFromDatabase(driver, connectionOptions, generationOptions) {
+    let dbModel = await dataCollectionPhase(driver, connectionOptions, generationOptions);
+    if (dbModel.length === 0) {
+        TomgUtils.LogError("Tables not found in selected database. Skipping creation of typeorm model.", false);
+        return;
+    }
+    dbModel = (0, ModelCustomization_1.default)(dbModel, generationOptions, driver.defaultValues);
+    (0, ModelGeneration_1.default)(connectionOptions, generationOptions, dbModel);
+}
+exports.createModelFromDatabase = createModelFromDatabase;
+async function dataCollectionPhase(driver, connectionOptions, generationOptions) {
+    return driver.GetDataFromServer(connectionOptions, generationOptions);
+}
+exports.dataCollectionPhase = dataCollectionPhase;
+//# sourceMappingURL=Engine.js.map

package/dist/src/IConnectionOptions.d.ts

@@ -0,0 +1,14 @@
+export default interface IConnectionOptions {
+    host: string;
+    port: number;
+    databaseNames: string[];
+    user: string;
+    password: string;
+    databaseType: "mssql" | "postgres" | "mysql" | "mariadb" | "oracle" | "sqlite";
+    schemaNames: string[];
+    instanceName?: string;
+    ssl: boolean;
+    skipTables: string[];
+    onlyTables: string[];
+}
+export declare function getDefaultConnectionOptions(): IConnectionOptions;

package/dist/src/IConnectionOptions.js

@@ -0,0 +1,22 @@
+"use strict";
+// TODO: change name
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultConnectionOptions = void 0;
+function getDefaultConnectionOptions() {
+    const connectionOptions = {
+        host: "127.0.0.1",
+        port: 0,
+        databaseNames: [""],
+        user: "",
+        password: "",
+        databaseType: undefined,
+        schemaNames: [""],
+        instanceName: undefined,
+        ssl: false,
+        skipTables: [],
+        onlyTables: [],
+    };
+    return connectionOptions;
+}
+exports.getDefaultConnectionOptions = getDefaultConnectionOptions;
+//# sourceMappingURL=IConnectionOptions.js.map

package/dist/src/IGenerationOptions.d.ts

@@ -0,0 +1,24 @@
+export default interface IGenerationOptions {
+    resultsPath: string;
+    pluralizeNames: boolean;
+    noConfigs: boolean;
+    convertCaseFile: "pascal" | "param" | "camel" | "none";
+    convertCaseEntity: "pascal" | "camel" | "none";
+    convertCaseProperty: "pascal" | "camel" | "snake" | "none";
+    convertEol: "LF" | "CRLF";
+    propertyVisibility: "public" | "protected" | "private" | "none";
+    lazy: boolean;
+    activeRecord: boolean;
+    generateConstructor: boolean;
+    customNamingStrategyPath: string;
+    relationIds: boolean;
+    strictMode: "none" | "?" | "!";
+    skipSchema: boolean;
+    indexFile: boolean;
+    exportType: "named" | "default";
+}
+export declare const eolConverter: {
+    LF: string;
+    CRLF: string;
+};
+export declare function getDefaultGenerationOptions(): IGenerationOptions;

package/dist/src/IGenerationOptions.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultGenerationOptions = exports.eolConverter = void 0;
+const os_1 = require("os");
+const path = require("path");
+exports.eolConverter = {
+    LF: "\n",
+    CRLF: "\r\n",
+};
+function getDefaultGenerationOptions() {
+    const generationOptions = {
+        resultsPath: path.resolve(process.cwd(), "output"),
+        pluralizeNames: true,
+        noConfigs: false,
+        convertCaseFile: "param",
+        convertCaseEntity: "pascal",
+        convertCaseProperty: "camel",
+        convertEol: os_1.EOL === "\n" ? "LF" : "CRLF",
+        propertyVisibility: "none",
+        lazy: false,
+        activeRecord: false,
+        generateConstructor: false,
+        customNamingStrategyPath: "",
+        relationIds: false,
+        strictMode: "none",
+        skipSchema: false,
+        indexFile: false,
+        exportType: "named",
+    };
+    return generationOptions;
+}
+exports.getDefaultGenerationOptions = getDefaultGenerationOptions;
+//# sourceMappingURL=IGenerationOptions.js.map

package/dist/src/ModelCustomization.d.ts

@@ -0,0 +1,4 @@
+import { DataTypeDefaults } from "typeorm/driver/types/DataTypeDefaults";
+import { Entity } from "./models/Entity";
+import IGenerationOptions from "./IGenerationOptions";
+export default function modelCustomizationPhase(dbModel: Entity[], generationOptions: IGenerationOptions, defaultValues: DataTypeDefaults): Entity[];

package/dist/src/ModelCustomization.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DefaultNamingStrategy_1 = require("typeorm/naming-strategy/DefaultNamingStrategy");
+const NamingStrategy = require("./NamingStrategy");
+const TomgUtils = require("./Utils");
+function modelCustomizationPhase(dbModel, generationOptions, defaultValues) {
+    const namingStrategy = {
+        enablePluralization: NamingStrategy.enablePluralization,
+        columnName: NamingStrategy.columnName,
+        entityName: NamingStrategy.entityName,
+        relationIdName: NamingStrategy.relationIdName,
+        relationName: NamingStrategy.relationName,
+        fileName: NamingStrategy.fileName,
+    };
+    if (generationOptions.customNamingStrategyPath &&
+        generationOptions.customNamingStrategyPath !== "") {
+        // TODO: change form of logging
+        const req = TomgUtils.requireLocalFile(generationOptions.customNamingStrategyPath);
+        if (req.columnName) {
+            console.log(`[${new Date().toLocaleTimeString()}] Using custom naming strategy for column names.`);
+            namingStrategy.columnName = req.columnName;
+        }
+        else {
+            console.log(`[${new Date().toLocaleTimeString()}] Using standard naming strategy for column names.`);
+        }
+        if (req.entityName) {
+            console.log(`[${new Date().toLocaleTimeString()}] Using custom naming strategy for entity names.`);
+            namingStrategy.entityName = req.entityName;
+        }
+        else {
+            console.log(`[${new Date().toLocaleTimeString()}] Using standard naming strategy for entity names.`);
+        }
+        if (req.relationIdName) {
+            console.log(`[${new Date().toLocaleTimeString()}] Using custom naming strategy for relationId field names.`);
+            namingStrategy.relationIdName = req.relationIdName;
+        }
+        else {
+            console.log(`[${new Date().toLocaleTimeString()}] Using standard naming strategy for relationId field names.`);
+        }
+        if (req.relationName) {
+            console.log(`[${new Date().toLocaleTimeString()}] Using custom naming strategy for relation field names.`);
+            namingStrategy.relationName = req.relationName;
+        }
+        else {
+            console.log(`[${new Date().toLocaleTimeString()}] Using standard naming strategy for relation field names.`);
+        }
+        if (req.fileName) {
+            console.log(`[${new Date().toLocaleTimeString()}] Using custom naming strategy for entity file names.`);
+            namingStrategy.fileName = req.fileName;
+        }
+        else {
+            console.log(`[${new Date().toLocaleTimeString()}] Using standard naming strategy for entity file names.`);
+        }
+        if (req.enablePluralization) {
+            console.log(`[${new Date().toLocaleTimeString()}] Using custom pluralization method for OneToMany, ManyToMany relation field names.`);
+            namingStrategy.enablePluralization = req.enablePluralization;
+        }
+        else {
+            console.log(`[${new Date().toLocaleTimeString()}] Using custom pluralization method for OneToMany, ManyToMany relation field names.`);
+        }
+    }
+    namingStrategy.enablePluralization(generationOptions.pluralizeNames);
+    let retVal = removeIndicesGeneratedByTypeorm(dbModel);
+    retVal = removeColumnsInRelation(dbModel);
+    retVal = applyNamingStrategy(namingStrategy, dbModel);
+    retVal = addImportsAndGenerationOptions(retVal, generationOptions);
+    retVal = removeColumnDefaultProperties(retVal, defaultValues);
+    return retVal;
+}
+exports.default = modelCustomizationPhase;
+function removeIndicesGeneratedByTypeorm(dbModel) {
+    // TODO: Support typeorm CustomNamingStrategy
+    const namingStrategy = new DefaultNamingStrategy_1.DefaultNamingStrategy();
+    dbModel.forEach((entity) => {
+        entity.indices = entity.indices.filter((v) => !(v.name.startsWith(`sqlite_autoindex_`) ||
+            (v.primary && v.name === "PRIMARY")));
+        const primaryColumns = entity.columns
+            .filter((v) => v.primary)
+            .map((v) => v.tscName);
+        entity.indices = entity.indices.filter((v) => !(v.primary &&
+            v.name ===
+                namingStrategy.primaryKeyName(entity.tscName, primaryColumns)));
+        entity.relations
+            .filter((v) => v.joinColumnOptions)
+            .forEach((rel) => {
+            const columnNames = rel.joinColumnOptions.map((v) => v.name);
+            const idxName = namingStrategy.relationConstraintName(entity.tscName, columnNames);
+            const fkName = namingStrategy.foreignKeyName(entity.tscName, columnNames);
+            entity.indices = entity.indices.filter((v) => v.name !== idxName && v.name !== fkName);
+        });
+    });
+    return dbModel;
+}
+function removeColumnsInRelation(dbModel) {
+    dbModel.forEach((entity) => {
+        entity.columns = entity.columns.filter((col) => !col.isUsedInRelationAsOwner ||
+            col.isUsedInRelationAsReferenced ||
+            entity.indices.some((idx) => idx.columns.some((v) => v === col.tscName)) ||
+            col.primary);
+    });
+    return dbModel;
+}
+function removeColumnDefaultProperties(dbModel, defaultValues) {
+    if (!defaultValues) {
+        return dbModel;
+    }
+    dbModel.forEach((entity) => {
+        entity.columns.forEach((column) => {
+            const defVal = defaultValues[column.tscType];
+            if (defVal) {
+                if (column.options.length &&
+                    defVal.length &&
+                    column.options.length === defVal.length) {
+                    column.options.length = undefined;
+                }
+                if (column.options.precision &&
+                    defVal.precision &&
+                    column.options.precision === defVal.precision &&
+                    column.options.scale &&
+                    defVal.scale &&
+                    column.options.scale === defVal.scale) {
+                    column.options.precision = undefined;
+                    column.options.scale = undefined;
+                }
+                if (column.options.width &&
+                    defVal.width &&
+                    column.options.width === defVal.width) {
+                    column.options.width = undefined;
+                }
+            }
+        });
+    });
+    return dbModel;
+}
+function findFileImports(dbModel) {
+    dbModel.forEach((entity) => {
+        entity.relations.forEach((relation) => {
+            if (relation.relatedTable !== entity.tscName &&
+                !entity.fileImports.some((v) => v.entityName === relation.relatedTable)) {
+                let relatedTable = dbModel.find((related) => related.tscName == relation.relatedTable);
+                entity.fileImports.push({
+                    entityName: relatedTable.tscName,
+                    fileName: relatedTable.fileName,
+                });
+            }
+        });
+    });
+    return dbModel;
+}
+function addImportsAndGenerationOptions(dbModel, generationOptions) {
+    dbModel = findFileImports(dbModel);
+    dbModel.forEach((entity) => {
+        entity.relations.forEach((relation) => {
+            if (generationOptions.lazy) {
+                if (!relation.relationOptions) {
+                    relation.relationOptions = {};
+                }
+                relation.relationOptions.lazy = true;
+            }
+        });
+        if (generationOptions.skipSchema) {
+            entity.schema = undefined;
+            entity.database = undefined;
+        }
+        if (generationOptions.activeRecord) {
+            entity.activeRecord = true;
+        }
+        if (generationOptions.generateConstructor) {
+            entity.generateConstructor = true;
+        }
+    });
+    return dbModel;
+}
+function applyNamingStrategy(namingStrategy, dbModel) {
+    let retVal = changeRelationNames(dbModel);
+    retVal = changeRelationIdNames(retVal);
+    retVal = changeEntityNames(retVal);
+    retVal = changeColumnNames(retVal);
+    retVal = changeFileNames(retVal);
+    return retVal;
+    function changeRelationIdNames(model) {
+        model.forEach((entity) => {
+            entity.relationIds.forEach((relationId) => {
+                const oldName = relationId.fieldName;
+                const relation = entity.relations.find((v) => v.fieldName === relationId.relationField);
+                let newName = namingStrategy.relationIdName(relationId, relation, entity);
+                newName = TomgUtils.findNameForNewField(newName, entity, oldName);
+                entity.indices.forEach((index) => {
+                    index.columns = index.columns.map((column2) => column2 === oldName ? newName : column2);
+                });
+                relationId.fieldName = newName;
+            });
+        });
+        return dbModel;
+    }
+    function changeRelationNames(model) {
+        model.forEach((entity) => {
+            entity.relations.forEach((relation) => {
+                const oldName = relation.fieldName;
+                let newName = namingStrategy.relationName(relation, entity);
+                newName = TomgUtils.findNameForNewField(newName, entity, oldName);
+                const relatedEntity = model.find((v) => v.tscName === relation.relatedTable);
+                const relation2 = relatedEntity.relations.find((v) => v.fieldName === relation.relatedField);
+                entity.relationIds
+                    .filter((v) => v.relationField === oldName)
+                    .forEach((v) => {
+                    v.relationField = newName;
+                });
+                relation.fieldName = newName;
+                relation2.relatedField = newName;
+                if (relation.relationOptions) {
+                    entity.indices.forEach((ind) => {
+                        ind.columns.map((column2) => column2 === oldName ? newName : column2);
+                    });
+                }
+            });
+        });
+        return dbModel;
+    }
+    function changeColumnNames(model) {
+        model.forEach((entity) => {
+            entity.columns.forEach((column) => {
+                const oldName = column.tscName;
+                let newName = namingStrategy.columnName(column.tscName, column);
+                newName = TomgUtils.findNameForNewField(newName, entity, oldName);
+                entity.indices.forEach((index) => {
+                    index.columns = index.columns.map((column2) => column2 === oldName ? newName : column2);
+                });
+                column.tscName = newName;
+            });
+        });
+        return model;
+    }
+    function changeEntityNames(entities) {
+        entities.forEach((entity) => {
+            const newName = namingStrategy.entityName(entity.tscName, entity);
+            entities.forEach((entity2) => {
+                entity2.relations.forEach((relation) => {
+                    if (relation.relatedTable === entity.tscName) {
+                        relation.relatedTable = newName;
+                    }
+                });
+            });
+            entity.tscName = newName;
+            entity.fileName = newName;
+        });
+        return entities;
+    }
+    function changeFileNames(entities) {
+        entities.forEach((entity) => {
+            entity.fileName = namingStrategy.fileName(entity.fileName);
+        });
+        return entities;
+    }
+}
+//# sourceMappingURL=ModelCustomization.js.map

package/dist/src/ModelGeneration.d.ts

@@ -0,0 +1,4 @@
+import IConnectionOptions from "./IConnectionOptions";
+import IGenerationOptions from "./IGenerationOptions";
+import { Entity } from "./models/Entity";
+export default function modelGenerationPhase(connectionOptions: IConnectionOptions, generationOptions: IGenerationOptions, databaseModel: Entity[]): void;

package/dist/src/ModelGeneration.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Handlebars = require("handlebars");
+const Prettier = require("prettier");
+const changeCase = require("change-case");
+const fs = require("fs");
+const path = require("path");
+const os_1 = require("os");
+const IGenerationOptions_1 = require("./IGenerationOptions");
+const prettierOptions = {
+    parser: "typescript",
+    endOfLine: "auto",
+};
+function modelGenerationPhase(connectionOptions, generationOptions, databaseModel) {
+    createHandlebarsHelpers(generationOptions);
+    const resultPath = generationOptions.resultsPath;
+    if (!fs.existsSync(resultPath)) {
+        fs.mkdirSync(resultPath);
+    }
+    let entitiesPath = resultPath;
+    if (!generationOptions.noConfigs) {
+        const tsconfigPath = path.resolve(resultPath, "tsconfig.json");
+        const typeormConfigPath = path.resolve(resultPath, "ormconfig.json");
+        createTsConfigFile(tsconfigPath);
+        createTypeOrmConfig(typeormConfigPath, connectionOptions);
+        entitiesPath = path.resolve(resultPath, "./entities");
+        if (!fs.existsSync(entitiesPath)) {
+            fs.mkdirSync(entitiesPath);
+        }
+    }
+    if (generationOptions.indexFile) {
+        createIndexFile(databaseModel, generationOptions, entitiesPath);
+    }
+    generateModels(databaseModel, generationOptions, entitiesPath);
+}
+exports.default = modelGenerationPhase;
+function generateModels(databaseModel, generationOptions, entitiesPath) {
+    const entityTemplatePath = path.resolve(__dirname, "templates", "entity.mst");
+    const entityTemplate = fs.readFileSync(entityTemplatePath, "utf-8");
+    const entityCompliedTemplate = Handlebars.compile(entityTemplate, {
+        noEscape: true,
+    });
+    databaseModel.forEach((element) => {
+        let casedFileName = "";
+        switch (generationOptions.convertCaseFile) {
+            case "camel":
+                casedFileName = changeCase.camelCase(element.fileName);
+                break;
+            case "param":
+                casedFileName = changeCase.paramCase(element.fileName);
+                break;
+            case "pascal":
+                casedFileName = changeCase.pascalCase(element.fileName);
+                break;
+            case "none":
+                casedFileName = element.fileName;
+                break;
+            default:
+                throw new Error("Unknown case style");
+        }
+        const resultFilePath = path.resolve(entitiesPath, `${casedFileName}.entity.ts`);
+        const rendered = entityCompliedTemplate(element);
+        const withImportStatements = removeUnusedImports(os_1.EOL !== IGenerationOptions_1.eolConverter[generationOptions.convertEol]
+            ? rendered.replace(/(\r\n|\n|\r)/gm, IGenerationOptions_1.eolConverter[generationOptions.convertEol])
+            : rendered);
+        let formatted = "";
+        try {
+            formatted = Prettier.format(withImportStatements, prettierOptions);
+        }
+        catch (error) {
+            console.error("There were some problems with model generation for table: ", element.sqlName);
+            console.error(error);
+            formatted = withImportStatements;
+        }
+        fs.writeFileSync(resultFilePath, formatted, {
+            encoding: "utf-8",
+            flag: "w",
+        });
+    });
+}
+function createIndexFile(databaseModel, generationOptions, entitiesPath) {
+    const templatePath = path.resolve(__dirname, "templates", "index.mst");
+    const template = fs.readFileSync(templatePath, "utf-8");
+    const compliedTemplate = Handlebars.compile(template, {
+        noEscape: true,
+    });
+    const rendered = compliedTemplate({ entities: databaseModel });
+    const formatted = Prettier.format(rendered, prettierOptions);
+    let fileName = "index";
+    switch (generationOptions.convertCaseFile) {
+        case "camel":
+            fileName = changeCase.camelCase(fileName);
+            break;
+        case "param":
+            fileName = changeCase.paramCase(fileName);
+            break;
+        case "pascal":
+            fileName = changeCase.pascalCase(fileName);
+            break;
+        default:
+    }
+    const resultFilePath = path.resolve(entitiesPath, `${fileName}.entity.ts`);
+    fs.writeFileSync(resultFilePath, formatted, {
+        encoding: "utf-8",
+        flag: "w",
+    });
+}
+function removeUnusedImports(rendered) {
+    const openBracketIndex = rendered.indexOf("{") + 1;
+    const closeBracketIndex = rendered.indexOf("}");
+    const imports = rendered
+        .substring(openBracketIndex, closeBracketIndex)
+        .split(",");
+    const restOfEntityDefinition = rendered.substring(closeBracketIndex);
+    const distinctImports = imports.filter((v) => restOfEntityDefinition.indexOf(`@${v}(`) !== -1 ||
+        (v === "BaseEntity" && restOfEntityDefinition.indexOf(v) !== -1));
+    return `${rendered.substring(0, openBracketIndex)}${distinctImports.join(",")}${restOfEntityDefinition}`;
+}
+function createHandlebarsHelpers(generationOptions) {
+    Handlebars.registerHelper("json", (context) => {
+        const json = JSON.stringify(context);
+        const withoutQuotes = json.replace(/"([^(")"]+)":/g, "$1:");
+        return withoutQuotes.slice(1, withoutQuotes.length - 1);
+    });
+    Handlebars.registerHelper("toEntityName", (str) => {
+        let retStr = "";
+        switch (generationOptions.convertCaseEntity) {
+            case "camel":
+                retStr = changeCase.camelCase(str);
+                break;
+            case "pascal":
+                retStr = changeCase.pascalCase(str);
+                break;
+            case "none":
+                retStr = str;
+                break;
+            default:
+                throw new Error("Unknown case style");
+        }
+        return retStr + 'Entity';
+    });
+    Handlebars.registerHelper("toFileName", (str) => {
+        let retStr = "";
+        switch (generationOptions.convertCaseFile) {
+            case "camel":
+                retStr = changeCase.camelCase(str);
+                break;
+            case "param":
+                retStr = changeCase.paramCase(str);
+                break;
+            case "pascal":
+                retStr = changeCase.pascalCase(str);
+                break;
+            case "none":
+                retStr = str;
+                break;
+            default:
+                throw new Error("Unknown case style");
+        }
+        return retStr;
+    });
+    Handlebars.registerHelper("printPropertyVisibility", () => generationOptions.propertyVisibility !== "none"
+        ? `${generationOptions.propertyVisibility} `
+        : "");
+    Handlebars.registerHelper("toPropertyName", (str) => {
+        let retStr = "";
+        switch (generationOptions.convertCaseProperty) {
+            case "camel":
+                retStr = changeCase.camelCase(str);
+                break;
+            case "pascal":
+                retStr = changeCase.pascalCase(str);
+                break;
+            case "none":
+                retStr = str;
+                break;
+            case "snake":
+                retStr = changeCase.snakeCase(str);
+                break;
+            default:
+                throw new Error("Unknown case style");
+        }
+        return retStr;
+    });
+    Handlebars.registerHelper("toRelation", (entityType, relationType) => {
+        let retVal = entityType;
+        if (relationType === "ManyToMany" || relationType === "OneToMany") {
+            retVal = `${retVal}[]`;
+        }
+        if (generationOptions.lazy) {
+            retVal = `Promise<${retVal}>`;
+        }
+        return retVal;
+    });
+    Handlebars.registerHelper("defaultExport", () => generationOptions.exportType === "default" ? "default" : "");
+    Handlebars.registerHelper("localImport", (entityName) => generationOptions.exportType === "default"
+        ? entityName
+        : `{${entityName}}`);
+    Handlebars.registerHelper("strictMode", () => generationOptions.strictMode !== "none"
+        ? generationOptions.strictMode
+        : "");
+    Handlebars.registerHelper({
+        and: (v1, v2) => v1 && v2,
+        eq: (v1, v2) => v1 === v2,
+        gt: (v1, v2) => v1 > v2,
+        gte: (v1, v2) => v1 >= v2,
+        lt: (v1, v2) => v1 < v2,
+        lte: (v1, v2) => v1 <= v2,
+        ne: (v1, v2) => v1 !== v2,
+        or: (v1, v2) => v1 || v2,
+    });
+}
+function createTsConfigFile(tsconfigPath) {
+    if (fs.existsSync(tsconfigPath)) {
+        console.warn(`\x1b[33m[${new Date().toLocaleTimeString()}] WARNING: Skipping generation of tsconfig.json file. File already exists. \x1b[0m`);
+        return;
+    }
+    const templatePath = path.resolve(__dirname, "templates", "tsconfig.mst");
+    const template = fs.readFileSync(templatePath, "utf-8");
+    const compliedTemplate = Handlebars.compile(template, {
+        noEscape: true,
+    });
+    const rendered = compliedTemplate({});
+    const formatted = Prettier.format(rendered, { parser: "json" });
+    fs.writeFileSync(tsconfigPath, formatted, {
+        encoding: "utf-8",
+        flag: "w",
+    });
+}
+function createTypeOrmConfig(typeormConfigPath, connectionOptions) {
+    if (fs.existsSync(typeormConfigPath)) {
+        console.warn(`\x1b[33m[${new Date().toLocaleTimeString()}] WARNING: Skipping generation of ormconfig.json file. File already exists. \x1b[0m`);
+        return;
+    }
+    const templatePath = path.resolve(__dirname, "templates", "ormconfig.mst");
+    const template = fs.readFileSync(templatePath, "utf-8");
+    const compiledTemplate = Handlebars.compile(template, {
+        noEscape: true,
+    });
+    const rendered = compiledTemplate(connectionOptions);
+    const formatted = Prettier.format(rendered, { parser: "json" });
+    fs.writeFileSync(typeormConfigPath, formatted, {
+        encoding: "utf-8",
+        flag: "w",
+    });
+}
+//# sourceMappingURL=ModelGeneration.js.map

package/dist/src/NamingStrategy.d.ts

@@ -0,0 +1,10 @@
+import { Relation } from "./models/Relation";
+import { RelationId } from "./models/RelationId";
+import { Entity } from "./models/Entity";
+import { Column } from "./models/Column";
+export declare function enablePluralization(value: boolean): void;
+export declare function relationIdName(relationId: RelationId, relation: Relation, owner?: Entity): string;
+export declare function relationName(relation: Relation, owner?: Entity): string;
+export declare function entityName(oldEntityName: string, entity?: Entity): string;
+export declare function columnName(oldColumnName: string, column?: Column): string;
+export declare function fileName(oldFileName: string): string;