midway-model-gen 0.0.1

package/dist/src/NamingStrategy.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileName = exports.columnName = exports.entityName = exports.relationName = exports.relationIdName = exports.enablePluralization = void 0;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const pluralize_1 = require("pluralize");
+let pluralize;
+function enablePluralization(value) {
+    pluralize = value;
+}
+exports.enablePluralization = enablePluralization;
+function relationIdName(relationId, relation, owner) {
+    const columnOldName = relationId.fieldName;
+    const isRelationToMany = relation.relationType === "OneToMany" ||
+        relation.relationType === "ManyToMany";
+    let newColumnName = columnOldName.replace(/[0-9]$/, "");
+    if (!Number.isNaN(parseInt(newColumnName[newColumnName.length - 1], 10))) {
+        newColumnName = newColumnName.substring(0, newColumnName.length - 1);
+    }
+    if (!Number.isNaN(parseInt(newColumnName[newColumnName.length - 1], 10))) {
+        newColumnName = newColumnName.substring(0, newColumnName.length - 1);
+    }
+    if (isRelationToMany && pluralize) {
+        newColumnName = (0, pluralize_1.plural)(newColumnName);
+    }
+    return newColumnName;
+}
+exports.relationIdName = relationIdName;
+function relationName(relation, owner) {
+    const columnOldName = relation.fieldName;
+    const isRelationToMany = relation.relationType === "OneToMany" ||
+        relation.relationType === "ManyToMany";
+    let newColumnName = columnOldName.replace(/[0-9]$/, "");
+    if (newColumnName.toLowerCase().endsWith("id") &&
+        !newColumnName.toLowerCase().endsWith("guid")) {
+        newColumnName = newColumnName.substring(0, newColumnName.toLowerCase().lastIndexOf("id"));
+    }
+    if (!Number.isNaN(parseInt(newColumnName[newColumnName.length - 1], 10))) {
+        newColumnName = newColumnName.substring(0, newColumnName.length - 1);
+    }
+    if (!Number.isNaN(parseInt(newColumnName[newColumnName.length - 1], 10))) {
+        newColumnName = newColumnName.substring(0, newColumnName.length - 1);
+    }
+    if (isRelationToMany && pluralize) {
+        newColumnName = (0, pluralize_1.plural)(newColumnName);
+    }
+    return newColumnName;
+}
+exports.relationName = relationName;
+function entityName(oldEntityName, entity) {
+    return oldEntityName;
+}
+exports.entityName = entityName;
+function columnName(oldColumnName, column) {
+    return oldColumnName;
+}
+exports.columnName = columnName;
+function fileName(oldFileName) {
+    return oldFileName;
+}
+exports.fileName = fileName;
+//# sourceMappingURL=NamingStrategy.js.map

package/dist/src/Utils.d.ts

@@ -0,0 +1,6 @@
+import { Entity } from "./models/Entity";
+export declare function LogError(errText: string, isABug?: boolean, passedError?: string | ErrorConstructor): void;
+export declare function packageVersion(): string;
+export declare function findNameForNewField(_fieldName: string, entity: Entity, columnOldName?: string): string;
+export declare function requireLocalFile(fileName: string): any;
+export declare function assertUnreachable(x: never): never;

package/dist/src/Utils.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertUnreachable = exports.requireLocalFile = exports.findNameForNewField = exports.packageVersion = exports.LogError = void 0;
+const changeCase = require("change-case");
+const path = require("path");
+const packagejson = require("../package.json");
+function LogError(errText, isABug = true, passedError) {
+    let errObject = passedError;
+    console.error(errText);
+    console.error(`Error occurred in typeorm-model-generator.`);
+    console.error(`${packageVersion()}  node@${process.version}`);
+    console.error(`If you think this is a bug please open an issue including this log on ${packagejson.bugs.url}`);
+    if (isABug && !passedError) {
+        errObject = new Error().stack;
+    }
+    if (errObject) {
+        console.error(errObject);
+    }
+}
+exports.LogError = LogError;
+function packageVersion() {
+    return `${packagejson.name}@${packagejson.version}`;
+}
+exports.packageVersion = packageVersion;
+function findNameForNewField(_fieldName, entity, columnOldName = "") {
+    let fieldName = _fieldName;
+    const validNameCondition = () => (entity.columns.every((v) => changeCase.camelCase(v.tscName) !==
+        changeCase.camelCase(fieldName)) &&
+        entity.relations.every((v) => changeCase.camelCase(v.fieldName) !==
+            changeCase.camelCase(fieldName)) &&
+        entity.relationIds.every((v) => changeCase.camelCase(v.fieldName) !==
+            changeCase.camelCase(fieldName))) ||
+        (columnOldName &&
+            changeCase.camelCase(columnOldName) ===
+                changeCase.camelCase(fieldName));
+    if (!validNameCondition()) {
+        fieldName += "_";
+        for (let i = 2; i <= entity.columns.length + entity.relations.length; i++) {
+            fieldName =
+                fieldName.substring(0, fieldName.length - i.toString().length) +
+                    i.toString();
+            if (validNameCondition()) {
+                break;
+            }
+        }
+    }
+    return fieldName;
+}
+exports.findNameForNewField = findNameForNewField;
+function requireLocalFile(fileName) {
+    try {
+        // eslint-disable-next-line global-require, import/no-dynamic-require, @typescript-eslint/no-var-requires
+        return require(fileName);
+    }
+    catch (err) {
+        if (!path.isAbsolute(fileName)) {
+            // eslint-disable-next-line global-require, import/no-dynamic-require, @typescript-eslint/no-var-requires
+            return require(path.resolve(process.cwd(), fileName));
+        }
+        throw err;
+    }
+}
+exports.requireLocalFile = requireLocalFile;
+function assertUnreachable(x) {
+    throw new Error("Didn't expect to get here");
+}
+exports.assertUnreachable = assertUnreachable;
+//# sourceMappingURL=Utils.js.map

package/dist/src/drivers/AbstractDriver.d.ts

@@ -0,0 +1,30 @@
+import { WithLengthColumnType, WithPrecisionColumnType, WithWidthColumnType } from "typeorm/driver/types/ColumnTypes";
+import { DataTypeDefaults } from "typeorm/driver/types/DataTypeDefaults";
+import IConnectionOptions from "../IConnectionOptions";
+import { Entity } from "../models/Entity";
+import { RelationInternal } from "../models/RelationInternal";
+import IGenerationOptions from "../IGenerationOptions";
+export default abstract class AbstractDriver {
+    abstract standardPort: number;
+    abstract standardSchema: string;
+    abstract standardUser: string;
+    abstract defaultValues: DataTypeDefaults;
+    ColumnTypesWithWidth: WithWidthColumnType[];
+    ColumnTypesWithPrecision: WithPrecisionColumnType[];
+    ColumnTypesWithLength: WithLengthColumnType[];
+    static FindManyToManyRelations(dbModel: Entity[]): Entity[];
+    GetDataFromServer(connectionOptions: IConnectionOptions, generationOptions: IGenerationOptions): Promise<Entity[]>;
+    static FilterGeneratedTables(dbModel: Entity[], skipTables: string[], onlyTables: string[]): Entity[];
+    abstract ConnectToServer(connectionOptons: IConnectionOptions): Promise<void>;
+    abstract GetAllTables(schemas: string[], dbNames: string[]): Promise<Entity[]>;
+    static GetRelationsFromRelationTempInfo(relationsTemp: RelationInternal[], entities: Entity[], generationOptions: IGenerationOptions): Entity[];
+    abstract GetCoulmnsFromEntity(entities: Entity[], schemas: string[], dbNames: string[]): Promise<Entity[]>;
+    abstract GetIndexesFromEntity(entities: Entity[], schemas: string[], dbNames: string[]): Promise<Entity[]>;
+    abstract GetRelations(entities: Entity[], schemas: string[], dbNames: string[], generationOptions: IGenerationOptions): Promise<Entity[]>;
+    static FindPrimaryColumnsFromIndexes(dbModel: Entity[]): void;
+    abstract DisconnectFromServer(): Promise<void>;
+    abstract CreateDB(dbName: string): Promise<void>;
+    abstract DropDB(dbName: string): Promise<void>;
+    abstract CheckIfDBExists(dbName: string): Promise<boolean>;
+    protected static buildEscapedObjectList(dbNames: string[]): string;
+}

package/dist/src/drivers/AbstractDriver.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const TomgUtils = require("../Utils");
+class AbstractDriver {
+    constructor() {
+        this.ColumnTypesWithWidth = [
+            "tinyint",
+            "smallint",
+            "mediumint",
+            "int",
+            "bigint",
+        ];
+        this.ColumnTypesWithPrecision = [
+            "float",
+            "double",
+            "dec",
+            "decimal",
+            "numeric",
+            "real",
+            "double precision",
+            "number",
+            "datetime",
+            "datetime2",
+            "datetimeoffset",
+            "time",
+            "time with time zone",
+            "time without time zone",
+            "timestamp",
+            "timestamp without time zone",
+            "timestamp with time zone",
+            "timestamp with local time zone",
+        ];
+        this.ColumnTypesWithLength = [
+            "character varying",
+            "varying character",
+            "nvarchar",
+            "character",
+            "native character",
+            "varchar",
+            "char",
+            "nchar",
+            "varchar2",
+            "nvarchar2",
+            "raw",
+            "binary",
+            "varbinary",
+        ];
+    }
+    static FindManyToManyRelations(dbModel) {
+        let retVal = dbModel;
+        const manyToManyEntities = retVal.filter((entity) => entity.relations.length === 2 &&
+            entity.relations.every((v) => v.joinColumnOptions && v.relationType !== "ManyToMany") &&
+            entity.relations[0].relatedTable !==
+                entity.relations[1].relatedTable &&
+            entity.relations[0].joinColumnOptions.length ===
+                entity.relations[1].joinColumnOptions.length &&
+            entity.columns.length ===
+                entity.columns.filter((c) => c.primary).length &&
+            entity.columns
+                .map((v) => v.tscName)
+                .filter((v) => !entity.relations[0]
+                .joinColumnOptions.map((x) => x.name)
+                .some((jc) => jc === v) &&
+                !entity.relations[1]
+                    .joinColumnOptions.map((x) => x.name)
+                    .some((jc) => jc === v)).length === 0);
+        manyToManyEntities.forEach((junctionEntity) => {
+            const firstEntity = dbModel.find((v) => v.tscName === junctionEntity.relations[0].relatedTable);
+            const secondEntity = dbModel.find((v) => v.tscName === junctionEntity.relations[1].relatedTable);
+            const firstRelation = firstEntity.relations.find((v) => v.relatedTable === junctionEntity.tscName);
+            const secondRelation = secondEntity.relations.find((v) => v.relatedTable === junctionEntity.tscName);
+            firstRelation.relationType = "ManyToMany";
+            secondRelation.relationType = "ManyToMany";
+            firstRelation.relatedTable = secondEntity.tscName;
+            secondRelation.relatedTable = firstEntity.tscName;
+            firstRelation.fieldName = TomgUtils.findNameForNewField(secondEntity.tscName, firstEntity);
+            secondRelation.fieldName = TomgUtils.findNameForNewField(firstEntity.tscName, secondEntity);
+            firstRelation.relatedField = secondRelation.fieldName;
+            secondRelation.relatedField = firstRelation.fieldName;
+            firstRelation.joinTableOptions = {
+                name: junctionEntity.sqlName,
+                joinColumns: junctionEntity.relations[0].joinColumnOptions.map((v, i) => {
+                    return {
+                        referencedColumnName: v.referencedColumnName,
+                        name: junctionEntity.relations[0]
+                            .joinColumnOptions[i].name,
+                    };
+                }),
+                inverseJoinColumns: junctionEntity.relations[1].joinColumnOptions.map((v, i) => {
+                    return {
+                        referencedColumnName: v.referencedColumnName,
+                        name: junctionEntity.relations[1]
+                            .joinColumnOptions[i].name,
+                    };
+                }),
+            };
+            if (junctionEntity.database) {
+                firstRelation.joinTableOptions.database =
+                    junctionEntity.database;
+            }
+            if (junctionEntity.schema) {
+                firstRelation.joinTableOptions.schema = junctionEntity.schema;
+            }
+            firstRelation.relationOptions = undefined;
+            secondRelation.relationOptions = undefined;
+            firstRelation.joinColumnOptions = undefined;
+            secondRelation.joinColumnOptions = undefined;
+            retVal = retVal.filter((ent) => {
+                return ent.tscName !== junctionEntity.tscName;
+            });
+        });
+        return retVal;
+    }
+    async GetDataFromServer(connectionOptions, generationOptions) {
+        let dbModel = [];
+        await this.ConnectToServer(connectionOptions);
+        dbModel = await this.GetAllTables(connectionOptions.schemaNames, connectionOptions.databaseNames);
+        await this.GetCoulmnsFromEntity(dbModel, connectionOptions.schemaNames, connectionOptions.databaseNames);
+        await this.GetIndexesFromEntity(dbModel, connectionOptions.schemaNames, connectionOptions.databaseNames);
+        AbstractDriver.FindPrimaryColumnsFromIndexes(dbModel);
+        dbModel = await this.GetRelations(dbModel, connectionOptions.schemaNames, connectionOptions.databaseNames, generationOptions);
+        await this.DisconnectFromServer();
+        dbModel = AbstractDriver.FindManyToManyRelations(dbModel);
+        dbModel = AbstractDriver.FilterGeneratedTables(dbModel, connectionOptions.skipTables, connectionOptions.onlyTables);
+        return dbModel;
+    }
+    static FilterGeneratedTables(dbModel, skipTables, onlyTables) {
+        return dbModel
+            .filter((table) => !skipTables.includes(table.sqlName))
+            .filter((table) => onlyTables.length === 0 ||
+            onlyTables.includes(table.sqlName));
+    }
+    static GetRelationsFromRelationTempInfo(relationsTemp, entities, generationOptions) {
+        relationsTemp.forEach((relationTmp) => {
+            const ownerEntity = entities.find((entity) => entity.tscName === relationTmp.ownerTable.tscName);
+            if (!ownerEntity) {
+                TomgUtils.LogError(`Relation between tables ${relationTmp.ownerTable.sqlName} and ${relationTmp.relatedTable.sqlName} didn't found entity model ${relationTmp.ownerTable.sqlName}.`);
+                return;
+            }
+            const referencedEntity = entities.find((entity) => entity.tscName === relationTmp.relatedTable.tscName);
+            if (!referencedEntity) {
+                TomgUtils.LogError(`Relation between tables ${relationTmp.ownerTable.sqlName} and ${relationTmp.relatedTable.sqlName} didn't found entity model ${relationTmp.relatedTable.sqlName}.`);
+                return;
+            }
+            const ownerColumns = [];
+            const relatedColumns = [];
+            for (let relationColumnIndex = 0; relationColumnIndex < relationTmp.ownerColumns.length; relationColumnIndex++) {
+                const ownerColumn = ownerEntity.columns.find((column) => column.tscName ===
+                    relationTmp.ownerColumns[relationColumnIndex]);
+                if (!ownerColumn) {
+                    TomgUtils.LogError(`Relation between tables ${relationTmp.ownerTable.sqlName} and ${relationTmp.relatedTable.sqlName} didn't found entity column ${relationTmp.ownerTable.sqlName}.${ownerColumn}.`);
+                    return;
+                }
+                const relatedColumn = referencedEntity.columns.find((column) => column.tscName ===
+                    relationTmp.relatedColumns[relationColumnIndex]);
+                if (!relatedColumn) {
+                    TomgUtils.LogError(`Relation between tables ${relationTmp.ownerTable.sqlName} and ${relationTmp.relatedTable.sqlName} didn't found entity column ${relationTmp.relatedTable.sqlName}.${relatedColumn}.`);
+                    return;
+                }
+                ownerColumns.push(ownerColumn);
+                relatedColumns.push(relatedColumn);
+            }
+            let isOneToMany;
+            isOneToMany = false;
+            const index = ownerEntity.indices.find((ind) => ind.options.unique &&
+                ind.columns.length === ownerColumns.length &&
+                ownerColumns.every((ownerColumn) => ind.columns.some((col) => col === ownerColumn.tscName)));
+            isOneToMany = !index;
+            ownerColumns.forEach((column) => {
+                column.isUsedInRelationAsOwner = true;
+            });
+            relatedColumns.forEach((column) => {
+                column.isUsedInRelationAsReferenced = true;
+            });
+            let fieldName = "";
+            if (ownerColumns.length === 1) {
+                fieldName = TomgUtils.findNameForNewField(ownerColumns[0].tscName, ownerEntity);
+            }
+            else {
+                fieldName = TomgUtils.findNameForNewField(relationTmp.relatedTable.tscName, ownerEntity);
+            }
+            const relationOptions = {
+                onDelete: relationTmp.onDelete,
+                onUpdate: relationTmp.onUpdate,
+            };
+            const ownerRelation = {
+                fieldName,
+                relatedField: TomgUtils.findNameForNewField(relationTmp.ownerTable.tscName, relationTmp.relatedTable),
+                joinColumnOptions: relationTmp.ownerColumns.map((v, idx) => {
+                    const retVal = {
+                        name: v,
+                        referencedColumnName: relationTmp.relatedColumns[idx],
+                    };
+                    return retVal;
+                }),
+                relatedTable: relationTmp.relatedTable.tscName,
+                relationType: isOneToMany ? "ManyToOne" : "OneToOne",
+            };
+            if (JSON.stringify(relationOptions) !== "{}") {
+                ownerRelation.relationOptions = relationOptions;
+            }
+            const relatedRelation = {
+                fieldName: ownerRelation.relatedField,
+                relatedField: ownerRelation.fieldName,
+                relatedTable: relationTmp.ownerTable.tscName,
+                relationType: isOneToMany ? "OneToMany" : "OneToOne",
+            };
+            ownerEntity.relations.push(ownerRelation);
+            relationTmp.relatedTable.relations.push(relatedRelation);
+            if (generationOptions.relationIds && ownerColumns.length === 1) {
+                let relationIdFieldName = "";
+                relationIdFieldName = TomgUtils.findNameForNewField(ownerColumns[0].tscName, ownerEntity);
+                let fieldType = "";
+                if (ownerRelation.relationType === "OneToMany") {
+                    fieldType = `${ownerColumns[0].tscType}[]`;
+                }
+                else {
+                    fieldType = ownerColumns[0].tscType;
+                    if (ownerColumns[0].options.nullable) {
+                        fieldType += " | null";
+                    }
+                }
+                ownerEntity.relationIds.push({
+                    fieldName: relationIdFieldName,
+                    fieldType,
+                    relationField: ownerRelation.fieldName,
+                });
+                // TODO: RelationId on ManyToMany
+            }
+        });
+        return entities;
+    }
+    static FindPrimaryColumnsFromIndexes(dbModel) {
+        dbModel.forEach((entity) => {
+            const primaryIndex = entity.indices.find((v) => v.primary);
+            entity.columns
+                .filter((col) => primaryIndex &&
+                primaryIndex.columns.some((cIndex) => cIndex === col.tscName))
+                .forEach((col) => {
+                // eslint-disable-next-line no-param-reassign
+                col.primary = true;
+                if (col.options.unique) {
+                    delete col.options.unique;
+                }
+            });
+            if (!entity.columns.some((v) => {
+                return !!v.primary;
+            })) {
+                TomgUtils.LogError(`Table ${entity.tscName} has no PK.`, false);
+            }
+        });
+    }
+    static buildEscapedObjectList(dbNames) {
+        return `'${dbNames.join("','")}'`;
+    }
+}
+exports.default = AbstractDriver;
+//# sourceMappingURL=AbstractDriver.js.map

package/dist/src/drivers/MariaDbDriver.d.ts

@@ -0,0 +1,4 @@
+import MysqlDriver from "./MysqlDriver";
+export default class MariaDbDriver extends MysqlDriver {
+    readonly EngineName: string;
+}

package/dist/src/drivers/MariaDbDriver.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const MysqlDriver_1 = require("./MysqlDriver");
+class MariaDbDriver extends MysqlDriver_1.default {
+    constructor() {
+        super(...arguments);
+        this.EngineName = "MariaDb";
+    }
+}
+exports.default = MariaDbDriver;
+//# sourceMappingURL=MariaDbDriver.js.map

package/dist/src/drivers/MssqlDriver.d.ts

@@ -0,0 +1,25 @@
+import { DataTypeDefaults } from "typeorm/driver/types/DataTypeDefaults";
+import AbstractDriver from "./AbstractDriver";
+import IConnectionOptions from "../IConnectionOptions";
+import { Entity } from "../models/Entity";
+import IGenerationOptions from "../IGenerationOptions";
+export default class MssqlDriver extends AbstractDriver {
+    defaultValues: DataTypeDefaults;
+    readonly standardPort = 1433;
+    readonly standardSchema = "dbo";
+    readonly standardUser = "sa";
+    private MSSQL;
+    private Connection;
+    constructor();
+    GetAllTables(schemas: string[], dbNames: string[]): Promise<Entity[]>;
+    GetCoulmnsFromEntity(entities: Entity[], schemas: string[], dbNames: string[]): Promise<Entity[]>;
+    GetIndexesFromEntity(entities: Entity[], schemas: string[], dbNames: string[]): Promise<Entity[]>;
+    GetRelations(entities: Entity[], schemas: string[], dbNames: string[], generationOptions: IGenerationOptions): Promise<Entity[]>;
+    DisconnectFromServer(): Promise<void>;
+    ConnectToServer(connectionOptons: IConnectionOptions): Promise<void>;
+    CreateDB(dbName: string): Promise<void>;
+    UseDB(dbName: string): Promise<void>;
+    DropDB(dbName: string): Promise<void>;
+    CheckIfDBExists(dbName: string): Promise<boolean>;
+    private static ReturnDefaultValueFunction;
+}