@yandjin-mikro-orm/knex 6.1.4-rc-sti-changes-1

package/schema/DatabaseTable.js

@@ -0,0 +1,727 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseTable = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+/**
+ * @internal
+ */
+class DatabaseTable {
+    platform;
+    name;
+    schema;
+    columns = {};
+    indexes = [];
+    checks = [];
+    foreignKeys = {};
+    nativeEnums = {}; // for postgres
+    comment;
+    constructor(platform, name, schema) {
+        this.platform = platform;
+        this.name = name;
+        this.schema = schema;
+        Object.defineProperties(this, {
+            platform: { enumerable: false, writable: true },
+        });
+    }
+    getColumns() {
+        return Object.values(this.columns);
+    }
+    getColumn(name) {
+        return this.columns[name];
+    }
+    removeColumn(name) {
+        delete this.columns[name];
+    }
+    getIndexes() {
+        return core_1.Utils.removeDuplicates(this.indexes);
+    }
+    getChecks() {
+        return this.checks;
+    }
+    init(cols, indexes = [], checks = [], pks, fks = {}, enums = {}) {
+        this.indexes = indexes;
+        this.checks = checks;
+        this.foreignKeys = fks;
+        this.columns = cols.reduce((o, v) => {
+            const index = indexes.filter((i) => i.columnNames[0] === v.name);
+            v.primary = v.primary || pks.includes(v.name);
+            v.unique = index.some((i) => i.unique && !i.primary);
+            const type = v.name in enums ? "enum" : v.type;
+            v.mappedType = this.platform.getMappedType(type);
+            v.default = v.default?.toString().startsWith("nextval(")
+                ? null
+                : v.default;
+            v.enumItems ??= enums[v.name] || [];
+            o[v.name] = v;
+            return o;
+        }, {});
+    }
+    addColumn(column) {
+        this.columns[column.name] = column;
+    }
+    addColumnFromProperty(prop, meta, config) {
+        prop.fieldNames.forEach((field, idx) => {
+            const type = prop.enum ? "enum" : prop.columnTypes[idx];
+            const mappedType = this.platform.getMappedType(type);
+            if (mappedType instanceof core_1.DecimalType) {
+                const match = prop.columnTypes[idx].match(/\w+\((\d+), ?(\d+)\)/);
+                /* istanbul ignore else */
+                if (match) {
+                    prop.precision ??= +match[1];
+                    prop.scale ??= +match[2];
+                    prop.length = undefined;
+                }
+            }
+            if (mappedType instanceof core_1.DateTimeType ||
+                mappedType instanceof core_1.IntervalType) {
+                const match = prop.columnTypes[idx].match(/\w+\((\d+)\)/);
+                if (match) {
+                    prop.length ??= +match[1];
+                }
+                else {
+                    prop.length ??= this.platform.getDefaultDateTimeLength();
+                }
+            }
+            const nullable = !(prop.name in meta.root.properties)
+                ? true
+                : (this.columns[field]?.nullable ?? !!prop.nullable);
+            const primary = !meta.compositePK &&
+                !!prop.primary &&
+                prop.kind === core_1.ReferenceKind.SCALAR &&
+                this.platform.isNumericColumn(mappedType);
+            this.columns[field] = {
+                name: prop.fieldNames[idx],
+                type: prop.columnTypes[idx],
+                generated: prop.generated,
+                mappedType,
+                unsigned: prop.unsigned && this.platform.isNumericColumn(mappedType),
+                autoincrement: prop.autoincrement ?? primary,
+                primary,
+                nullable,
+                nativeEnumName: prop.nativeEnumName,
+                length: prop.length,
+                precision: prop.precision,
+                scale: prop.scale,
+                default: prop.defaultRaw,
+                enumItems: prop.nativeEnumName || prop.items?.every(core_1.Utils.isString)
+                    ? prop.items
+                    : undefined,
+                comment: prop.comment,
+                extra: prop.extra,
+                ignoreSchemaChanges: prop.ignoreSchemaChanges,
+            };
+            this.columns[field].unsigned ||= this.columns[field].autoincrement;
+            const defaultValue = this.platform
+                .getSchemaHelper()
+                .normalizeDefaultValue(prop.defaultRaw, prop.length);
+            this.columns[field].default = defaultValue;
+        });
+        if ([core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+            const constraintName = this.getIndexName(true, prop.fieldNames, "foreign");
+            let schema = prop.targetMeta.root.schema === "*"
+                ? this.schema
+                : (prop.targetMeta.root.schema ??
+                    config.get("schema", this.platform.getDefaultSchemaName()));
+            if (prop.referencedTableName.includes(".")) {
+                schema = undefined;
+            }
+            this.foreignKeys[constraintName] = {
+                constraintName,
+                columnNames: prop.fieldNames,
+                localTableName: this.getShortestName(),
+                referencedColumnNames: prop.referencedColumnNames,
+                referencedTableName: schema
+                    ? `${schema}.${prop.referencedTableName}`
+                    : prop.referencedTableName,
+            };
+            const cascade = prop.cascade.includes(core_1.Cascade.REMOVE) ||
+                prop.cascade.includes(core_1.Cascade.ALL);
+            if (prop.deleteRule || cascade || prop.nullable) {
+                this.foreignKeys[constraintName].deleteRule =
+                    prop.deleteRule || (cascade ? "cascade" : "set null");
+            }
+            if (prop.updateRule ||
+                prop.cascade.includes(core_1.Cascade.PERSIST) ||
+                prop.cascade.includes(core_1.Cascade.ALL)) {
+                this.foreignKeys[constraintName].updateRule =
+                    prop.updateRule || "cascade";
+            }
+        }
+        if (prop.index) {
+            const keyName = this.getIndexName(prop.index, prop.fieldNames, "index");
+            // const indexExists = this.indexes.find(index => index.keyName === keyName);
+            // if (!indexExists) {
+            this.indexes.push({
+                columnNames: prop.fieldNames,
+                composite: prop.fieldNames.length > 1,
+                keyName,
+                constraint: false,
+                primary: false,
+                unique: false,
+            });
+            // }
+        }
+        if (prop.unique && !(prop.primary && !meta.compositePK)) {
+            const keyName = this.getIndexName(prop.unique, prop.fieldNames, "unique");
+            // const indexExists = this.indexes.find(index => index.keyName === keyName);
+            // if (!indexExists) {
+            this.indexes.push({
+                columnNames: prop.fieldNames,
+                composite: prop.fieldNames.length > 1,
+                keyName,
+                constraint: !prop.fieldNames.some((d) => d.includes(".")),
+                primary: false,
+                unique: true,
+            });
+            // }
+        }
+    }
+    getIndexName(value, columnNames, type) {
+        if (core_1.Utils.isString(value)) {
+            return value;
+        }
+        return this.platform.getIndexName(this.name, columnNames, type);
+    }
+    getEntityDeclaration(namingStrategy, schemaHelper, scalarPropertiesForRelations) {
+        const { fksOnColumnProps, fksOnStandaloneProps, columnFks, fkIndexes, nullableForeignKeys, skippedColumnNames, } = this.foreignKeysToProps(namingStrategy, scalarPropertiesForRelations);
+        let name = namingStrategy.getEntityName(this.name, this.schema);
+        name = name.match(/^\d/) ? "E" + name : name;
+        const schema = new core_1.EntitySchema({
+            name,
+            collection: this.name,
+            schema: this.schema,
+        });
+        const compositeFkIndexes = {};
+        const compositeFkUniques = {};
+        const potentiallyUnmappedIndexes = this.indexes.filter((index) => !index.primary && // Skip primary index. Whether it's in use by scalar column or FK, it's already mapped.
+            (index.columnNames.length > 1 || // All composite indexes are to be mapped to entity decorators or FK props.
+                !(index.columnNames[0] in columnFks) || // Non-composite indexes for scalar props are to be mapped to the column.
+                skippedColumnNames.includes(index.columnNames[0])) && // Non-composite indexes for skipped columns are to be mapped as entity decorators.
+            // ignore indexes that don't have all column names (this can happen in sqlite where there is no way to infer this for expressions)
+            !(index.columnNames.some((col) => !col) && !index.expression));
+        for (const index of potentiallyUnmappedIndexes) {
+            const ret = { name: index.keyName };
+            // Index is for FK. Map to the FK prop and move on.
+            const fkForIndex = fkIndexes.get(index);
+            if (fkForIndex &&
+                !fkForIndex.fk.columnNames.some((col) => !index.columnNames.includes(col))) {
+                ret.properties = [
+                    this.getPropertyName(namingStrategy, fkForIndex.baseName, fkForIndex.fk),
+                ];
+                const map = index.unique ? compositeFkUniques : compositeFkIndexes;
+                map[ret.properties[0]] = { keyName: index.keyName };
+                continue;
+            }
+            const properties = this.getIndexProperties(index, columnFks, fksOnColumnProps, fksOnStandaloneProps, namingStrategy);
+            // If there is a column that cannot be unambiguously mapped to a prop, render an expression.
+            if (index.expression) {
+                ret.expression = index.expression;
+            }
+            else if (typeof properties === "undefined") {
+                ret.expression = schemaHelper.getCreateIndexSQL(this.name, index);
+            }
+            else {
+                ret.properties = properties;
+                // If the index is for one property that is not a FK prop, map to the column prop and move on.
+                if (properties.length === 1 &&
+                    !fksOnStandaloneProps.has(properties[0])) {
+                    const map = index.unique ? compositeFkUniques : compositeFkIndexes;
+                    map[properties[0]] = { keyName: index.keyName };
+                    continue;
+                }
+            }
+            // Composite indexes that aren't exclusively mapped to FK props get an entity decorator.
+            if (index.unique) {
+                schema.addUnique(ret);
+                continue;
+            }
+            schema.addIndex(ret);
+        }
+        const addedStandaloneFkPropsBasedOnColumn = new Set();
+        const nonSkippedColumns = this.getColumns().filter((column) => !skippedColumnNames.includes(column.name));
+        for (const column of nonSkippedColumns) {
+            const columnName = column.name;
+            const standaloneFkPropBasedOnColumn = fksOnStandaloneProps.get(columnName);
+            if (standaloneFkPropBasedOnColumn && !fksOnColumnProps.get(columnName)) {
+                addedStandaloneFkPropsBasedOnColumn.add(columnName);
+                const [fkIndex, currentFk] = standaloneFkPropBasedOnColumn;
+                const prop = this.getForeignKeyDeclaration(currentFk, namingStrategy, schemaHelper, fkIndex, nullableForeignKeys.has(currentFk), columnName);
+                schema.addProperty(prop.name, prop.type, prop);
+            }
+            const prop = this.getPropertyDeclaration(column, namingStrategy, schemaHelper, compositeFkIndexes, compositeFkUniques, columnFks, fksOnColumnProps.get(columnName));
+            schema.addProperty(prop.name, prop.type, prop);
+        }
+        for (const [propBaseName, [fkIndex, currentFk],] of fksOnStandaloneProps.entries()) {
+            if (addedStandaloneFkPropsBasedOnColumn.has(propBaseName)) {
+                continue;
+            }
+            const prop = this.getForeignKeyDeclaration(currentFk, namingStrategy, schemaHelper, fkIndex, nullableForeignKeys.has(currentFk), propBaseName);
+            schema.addProperty(prop.name, prop.type, prop);
+        }
+        const meta = schema.init().meta;
+        const oneToOneCandidateProperties = meta.relations.filter((prop) => prop.primary && prop.kind === core_1.ReferenceKind.MANY_TO_ONE);
+        if (oneToOneCandidateProperties.length === 1 &&
+            oneToOneCandidateProperties[0].fieldNames.length ===
+                new Set(meta.getPrimaryProps().flatMap((prop) => prop.fieldNames)).size) {
+            oneToOneCandidateProperties[0].kind = core_1.ReferenceKind.ONE_TO_ONE;
+        }
+        return meta;
+    }
+    foreignKeysToProps(namingStrategy, scalarPropertiesForRelations) {
+        const fks = Object.values(this.getForeignKeys());
+        const fksOnColumnProps = new Map();
+        const fksOnStandaloneProps = new Map();
+        const columnFks = {};
+        const fkIndexes = new Map();
+        const nullableForeignKeys = new Set();
+        for (const currentFk of fks) {
+            const fkIndex = this.findFkIndex(currentFk);
+            if (currentFk.columnNames.length === 1 &&
+                !fks.some((fk) => fk !== currentFk &&
+                    fk.columnNames.length === 1 &&
+                    currentFk.columnNames[0] === fk.columnNames[0])) {
+                // Non-composite FK is the only possible one for a column. Render the column with it.
+                const columnName = currentFk.columnNames[0];
+                columnFks[columnName] ??= [];
+                columnFks[columnName].push(currentFk);
+                if (this.getColumn(columnName)?.nullable) {
+                    nullableForeignKeys.add(currentFk);
+                }
+                if (scalarPropertiesForRelations === "always") {
+                    const baseName = this.getSafeBaseNameForFkProp(namingStrategy, currentFk, fks, columnName);
+                    fksOnStandaloneProps.set(baseName, [fkIndex, currentFk]);
+                    fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+                }
+                else {
+                    fksOnColumnProps.set(columnName, currentFk);
+                    fkIndexes.set(fkIndex, { fk: currentFk, baseName: columnName });
+                }
+                continue;
+            }
+            const specificColumnNames = [];
+            const nullableColumnsInFk = [];
+            for (const columnName of currentFk.columnNames) {
+                columnFks[columnName] ??= [];
+                columnFks[columnName].push(currentFk);
+                if (!fks.some((fk) => fk !== currentFk && fk.columnNames.includes(columnName))) {
+                    specificColumnNames.push(columnName);
+                }
+                if (this.getColumn(columnName)?.nullable) {
+                    nullableColumnsInFk.push(columnName);
+                }
+            }
+            if (nullableColumnsInFk.length > 0) {
+                nullableForeignKeys.add(currentFk);
+            }
+            if (specificColumnNames.length === 1 &&
+                (nullableColumnsInFk.length === currentFk.columnNames.length ||
+                    nullableColumnsInFk.length === 0 ||
+                    (nullableColumnsInFk.length === 1 &&
+                        nullableColumnsInFk[0] === specificColumnNames[0]))) {
+                // Composite FK has exactly one column which is not used in any other FK.
+                // The FK also doesn't have a mix of nullable and non-nullable columns,
+                // or its only nullable column is this very one.
+                // It is safe to just render this FK attached to the specific column.
+                const columnName = specificColumnNames[0];
+                if (scalarPropertiesForRelations === "always") {
+                    const baseName = this.getSafeBaseNameForFkProp(namingStrategy, currentFk, fks, columnName);
+                    fksOnStandaloneProps.set(baseName, [fkIndex, currentFk]);
+                    fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+                }
+                else {
+                    fksOnColumnProps.set(columnName, currentFk);
+                    fkIndexes.set(fkIndex, { fk: currentFk, baseName: columnName });
+                }
+                continue;
+            }
+            if (specificColumnNames.length === currentFk.columnNames.length) {
+                // All columns involved with this FK are only covered by this one FK.
+                if (nullableColumnsInFk.length <= 1) {
+                    // Also, this FK is either not nullable, or has only one nullable column.
+                    // It is safe to name the FK after the nullable column, or any non-nullable one (the first one is picked).
+                    const columnName = nullableColumnsInFk.at(0) ?? currentFk.columnNames[0];
+                    if (scalarPropertiesForRelations === "always") {
+                        const baseName = this.getSafeBaseNameForFkProp(namingStrategy, currentFk, fks, columnName);
+                        fksOnStandaloneProps.set(baseName, [fkIndex, currentFk]);
+                        fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+                    }
+                    else {
+                        fksOnColumnProps.set(columnName, currentFk);
+                        fkIndexes.set(fkIndex, { fk: currentFk, baseName: columnName });
+                    }
+                    continue;
+                }
+                // If the first nullable column's name with FK is different from the name without FK,
+                // name a standalone prop after the column, but treat the column prop itself as not having FK.
+                const columnName = nullableColumnsInFk[0];
+                const baseName = this.getSafeBaseNameForFkProp(namingStrategy, currentFk, fks, columnName);
+                fksOnStandaloneProps.set(baseName, [fkIndex, currentFk]);
+                fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+                continue;
+            }
+            // FK is not unambiguously mappable to a column. Pick another name for a standalone FK prop.
+            const baseName = this.getSafeBaseNameForFkProp(namingStrategy, currentFk, fks);
+            fksOnStandaloneProps.set(baseName, [fkIndex, currentFk]);
+            fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+        }
+        const columnsInFks = Object.keys(columnFks);
+        const skippingHandlers = {
+            // Never generate scalar props for composite keys,
+            // i.e. always skip columns if they are covered by foreign keys.
+            never: (column) => columnsInFks.includes(column.name) &&
+                !fksOnColumnProps.has(column.name),
+            // Always generate scalar props for composite keys,
+            // i.e. do not skip columns, even if they are covered by foreign keys.
+            always: (column) => false,
+            // Smart scalar props generation.
+            // Skips columns if they are covered by foreign keys.
+            // But also does not skip if the column is not nullable, and yet all involved FKs are nullable,
+            // or if one or more FKs involved has multiple nullable columns.
+            smart: (column) => {
+                return (columnsInFks.includes(column.name) &&
+                    !fksOnColumnProps.has(column.name) &&
+                    (column.nullable
+                        ? columnFks[column.name].some((fk) => !fk.columnNames.some((fkColumnName) => fkColumnName !== column.name &&
+                            this.getColumn(fkColumnName)?.nullable))
+                        : columnFks[column.name].some((fk) => !nullableForeignKeys.has(fk))));
+            },
+        };
+        const skippedColumnNames = this.getColumns()
+            .filter(skippingHandlers[scalarPropertiesForRelations])
+            .map((column) => column.name);
+        return {
+            fksOnColumnProps,
+            fksOnStandaloneProps,
+            columnFks,
+            fkIndexes,
+            nullableForeignKeys,
+            skippedColumnNames,
+        };
+    }
+    findFkIndex(currentFk) {
+        const fkColumnsLength = currentFk.columnNames.length;
+        const possibleIndexes = this.indexes.filter((index) => {
+            return (index.columnNames.length >= fkColumnsLength &&
+                !currentFk.columnNames.some((columnName, i) => index.columnNames[i] !== columnName));
+        });
+        possibleIndexes.sort((a, b) => {
+            if (a.columnNames.length !== b.columnNames.length) {
+                return a.columnNames.length < b.columnNames.length ? -1 : 1;
+            }
+            if (a.primary !== b.primary) {
+                return a.primary ? -1 : 1;
+            }
+            if (a.unique !== b.unique) {
+                return a.unique ? -1 : 1;
+            }
+            return a.keyName.localeCompare(b.keyName);
+        });
+        return possibleIndexes[0];
+    }
+    getIndexProperties(index, columnFks, fksOnColumnProps, fksOnStandaloneProps, namingStrategy) {
+        const propBaseNames = new Set();
+        const columnNames = index.columnNames;
+        const l = columnNames.length;
+        if (columnNames.some((col) => !col)) {
+            return;
+        }
+        for (let i = 0; i < l; ++i) {
+            const columnName = columnNames[i];
+            // The column is not involved with FKs.
+            // It has a prop named after it.
+            // Add it and move on.
+            if (!(columnName in columnFks)) {
+                propBaseNames.add(columnName);
+                continue;
+            }
+            // If the prop named after the column has a FK and the FK's columns are a subset of this index,
+            // include this prop and move on.
+            const columnPropFk = fksOnColumnProps.get(columnName);
+            if (columnPropFk &&
+                !columnPropFk.columnNames.some((fkColumnName) => !columnNames.includes(fkColumnName))) {
+                propBaseNames.add(columnName);
+                continue;
+            }
+            // If there is at least one standalone FK featuring this column,
+            // and all of its columns are a subset of this index,
+            // include that FK, and consider mapping of this column to a prop a success.
+            let propAdded = false;
+            for (const [propName, [, fk]] of fksOnStandaloneProps) {
+                if (!columnFks[columnName].includes(fk)) {
+                    continue;
+                }
+                if (!fk.columnNames.some((fkColumnName) => !columnNames.includes(fkColumnName))) {
+                    propBaseNames.add(propName);
+                    propAdded = true;
+                }
+            }
+            if (propAdded) {
+                continue;
+            }
+            // If we have reached this point, it means the column is not mappable to a prop name.
+            // Break the whole prop creation.
+            return;
+        }
+        return Array.from(propBaseNames).map((baseName) => this.getPropertyName(namingStrategy, baseName, fksOnColumnProps.get(baseName)));
+    }
+    getSafeBaseNameForFkProp(namingStrategy, currentFk, fks, columnName) {
+        if (columnName &&
+            this.getPropertyName(namingStrategy, columnName, currentFk) !==
+                this.getPropertyName(namingStrategy, columnName)) {
+            // The eligible scalar column name is different from the name of the FK prop of the same column.
+            // Both can be safely rendered.
+            // Use the column name as a base for the FK prop.
+            return columnName;
+        }
+        if (!fks.some((fk) => fk !== currentFk &&
+            fk.referencedTableName === currentFk.referencedTableName) &&
+            !this.getColumn(currentFk.referencedTableName)) {
+            // FK is the only one in this table that references this other table.
+            // The name of the referenced table is not shared with a column in this table,
+            // so it is safe to output prop name based on the referenced entity.
+            return currentFk.referencedTableName;
+        }
+        // Any ambiguous FK is rendered with a name based on the FK constraint name
+        let finalPropBaseName = currentFk.constraintName;
+        while (this.getColumn(finalPropBaseName)) {
+            // In the unlikely event that the FK constraint name is shared by a column name, generate a name by
+            // continuously prefixing with "fk_", until a non-existent column is hit.
+            // The worst case scenario is a very long name with several repeated "fk_"
+            // that is not really a valid DB identifier but a valid JS variable name.
+            finalPropBaseName = `fk_${finalPropBaseName}`;
+        }
+        return finalPropBaseName;
+    }
+    /**
+     * The shortest name is stripped of the default namespace. All other namespaced elements are returned as full-qualified names.
+     */
+    getShortestName() {
+        if (!this.schema || this.name.startsWith(this.schema + ".")) {
+            return this.name;
+        }
+        return `${this.schema}.${this.name}`;
+    }
+    getForeignKeys() {
+        return this.foreignKeys;
+    }
+    hasColumn(columnName) {
+        return columnName in this.columns;
+    }
+    getIndex(indexName) {
+        return this.indexes.find((i) => i.keyName === indexName);
+    }
+    hasIndex(indexName) {
+        return !!this.getIndex(indexName);
+    }
+    getCheck(checkName) {
+        return this.checks.find((i) => i.name === checkName);
+    }
+    hasCheck(checkName) {
+        return !!this.getCheck(checkName);
+    }
+    getPrimaryKey() {
+        return this.indexes.find((i) => i.primary);
+    }
+    hasPrimaryKey() {
+        return !!this.getPrimaryKey();
+    }
+    getForeignKeyDeclaration(fk, namingStrategy, schemaHelper, fkIndex, nullable, propNameBase) {
+        const prop = this.getPropertyName(namingStrategy, propNameBase, fk);
+        const kind = fkIndex.unique && !fkIndex.primary
+            ? this.getReferenceKind(fk, fkIndex)
+            : this.getReferenceKind(fk);
+        const type = this.getPropertyTypeForForeignKey(namingStrategy, fk);
+        const fkOptions = {};
+        fkOptions.fieldNames = fk.columnNames;
+        fkOptions.referencedTableName = fk.referencedTableName;
+        fkOptions.referencedColumnNames = fk.referencedColumnNames;
+        fkOptions.updateRule = fk.updateRule?.toLowerCase();
+        fkOptions.deleteRule = fk.deleteRule?.toLowerCase();
+        fkOptions.columnTypes = fk.columnNames.map((c) => this.getColumn(c).type);
+        const columnOptions = {};
+        if (fk.columnNames.length === 1) {
+            const column = this.getColumn(fk.columnNames[0]);
+            columnOptions.default = this.getPropertyDefaultValue(schemaHelper, column, type);
+            columnOptions.defaultRaw = this.getPropertyDefaultValue(schemaHelper, column, type, true);
+            columnOptions.generated = column.generated;
+            columnOptions.nullable = column.nullable;
+            columnOptions.primary = column.primary;
+            columnOptions.length = column.length;
+            columnOptions.precision = column.precision;
+            columnOptions.scale = column.scale;
+            columnOptions.enum = !!column.enumItems?.length;
+            columnOptions.items = column.enumItems;
+        }
+        return {
+            name: prop,
+            type,
+            kind,
+            ...columnOptions,
+            nullable,
+            primary: fkIndex.primary ||
+                !fk.columnNames.some((columnName) => !this.getPrimaryKey()?.columnNames.includes(columnName)),
+            index: !fkIndex.unique ? fkIndex.keyName : undefined,
+            unique: fkIndex.unique && !fkIndex.primary ? fkIndex.keyName : undefined,
+            ...fkOptions,
+        };
+    }
+    getPropertyDeclaration(column, namingStrategy, schemaHelper, compositeFkIndexes, compositeFkUniques, columnFks, fk) {
+        const prop = this.getPropertyName(namingStrategy, column.name, fk);
+        const persist = !(column.name in columnFks && typeof fk === "undefined");
+        const index = compositeFkIndexes[prop] ||
+            this.indexes.find((idx) => idx.columnNames[0] === column.name &&
+                !idx.composite &&
+                !idx.unique &&
+                !idx.primary);
+        const unique = compositeFkUniques[prop] ||
+            this.indexes.find((idx) => idx.columnNames[0] === column.name &&
+                !idx.composite &&
+                idx.unique &&
+                !idx.primary);
+        const kind = this.getReferenceKind(fk, unique);
+        const type = this.getPropertyTypeForColumn(namingStrategy, column, fk);
+        const fkOptions = {};
+        if (fk) {
+            fkOptions.fieldNames = fk.columnNames;
+            fkOptions.referencedTableName = fk.referencedTableName;
+            fkOptions.referencedColumnNames = fk.referencedColumnNames;
+            fkOptions.updateRule = fk.updateRule?.toLowerCase();
+            fkOptions.deleteRule = fk.deleteRule?.toLowerCase();
+        }
+        return {
+            name: prop,
+            type,
+            kind,
+            generated: column.generated,
+            columnType: column.type,
+            default: this.getPropertyDefaultValue(schemaHelper, column, type),
+            defaultRaw: this.getPropertyDefaultValue(schemaHelper, column, type, true),
+            nullable: column.nullable,
+            primary: column.primary && persist,
+            autoincrement: column.autoincrement,
+            fieldName: column.name,
+            length: column.length,
+            precision: column.precision,
+            scale: column.scale,
+            index: index ? index.keyName : undefined,
+            unique: unique ? unique.keyName : undefined,
+            enum: !!column.enumItems?.length,
+            items: column.enumItems,
+            persist,
+            ...fkOptions,
+        };
+    }
+    getReferenceKind(fk, unique) {
+        if (fk && unique) {
+            return core_1.ReferenceKind.ONE_TO_ONE;
+        }
+        if (fk) {
+            return core_1.ReferenceKind.MANY_TO_ONE;
+        }
+        return core_1.ReferenceKind.SCALAR;
+    }
+    getPropertyName(namingStrategy, baseName, fk) {
+        let field = baseName;
+        if (fk) {
+            const idx = fk.columnNames.indexOf(baseName);
+            let replacedFieldName = field.replace(new RegExp(`_${fk.referencedColumnNames[idx]}$`), "");
+            if (replacedFieldName === field) {
+                replacedFieldName = field.replace(new RegExp(`_${namingStrategy.referenceColumnName()}$`), "");
+            }
+            field = replacedFieldName;
+        }
+        if (field.startsWith("_")) {
+            return field;
+        }
+        return namingStrategy.columnNameToProperty(field);
+    }
+    getPropertyTypeForForeignKey(namingStrategy, fk) {
+        const parts = fk.referencedTableName.split(".", 2);
+        return namingStrategy.getEntityName(...parts.reverse());
+    }
+    getPropertyTypeForColumn(namingStrategy, column, fk) {
+        if (fk) {
+            return this.getPropertyTypeForForeignKey(namingStrategy, fk);
+        }
+        // If this column is using an enum.
+        if (column.enumItems?.length) {
+            // We will create a new enum name for this type and set it as the property type as well.
+            // The enum name will be a concatenation of the table name and the column name.
+            return namingStrategy.getClassName(this.name + "_" + column.name, "_");
+        }
+        return column.mappedType?.compareAsType() ?? "unknown";
+    }
+    getPropertyDefaultValue(schemaHelper, column, propType, raw = false) {
+        const empty = raw ? "null" : undefined;
+        if (!column.default) {
+            return empty;
+        }
+        const val = schemaHelper.normalizeDefaultValue(column.default, column.length);
+        if (column.nullable && val === "null") {
+            return empty;
+        }
+        if (propType === "boolean" && !raw) {
+            return !["0", "false", "f", "n", "no", "off"].includes("" + column.default);
+        }
+        if (propType === "number") {
+            return +column.default;
+        }
+        // unquote string defaults if `raw = false`
+        const match = ("" + val).match(/^'(.*)'$/);
+        if (!raw && match) {
+            return match[1];
+        }
+        return "" + val;
+    }
+    addIndex(meta, index, type) {
+        const properties = core_1.Utils.unique(core_1.Utils.flatten(core_1.Utils.asArray(index.properties).map((prop) => {
+            const root = prop.replace(/\..+$/, "");
+            if (meta.properties[prop]) {
+                if (meta.properties[prop].embeddedPath) {
+                    return [meta.properties[prop].embeddedPath.join(".")];
+                }
+                return meta.properties[prop].fieldNames;
+            }
+            // json index, we need to rename the column only
+            if (meta.properties[root]) {
+                return [prop.replace(root, meta.properties[root].fieldNames[0])];
+            }
+            /* istanbul ignore next */
+            return [prop];
+        })));
+        if (properties.length === 0 && !index.expression) {
+            return;
+        }
+        const name = this.getIndexName(index.name, properties, type);
+        // const indexExists = this.indexes.find(i => i.keyName === name);
+        // if (indexExists) {
+        //   return;
+        // }
+        this.indexes.push({
+            keyName: name,
+            columnNames: properties,
+            composite: properties.length > 1,
+            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
+            constraint: type !== "index" && !properties.some((d) => d.includes(".")),
+            primary: type === "primary",
+            unique: type !== "index",
+            type: index.type,
+            expression: index.expression,
+            options: index.options,
+        });
+    }
+    addCheck(check) {
+        this.checks.push(check);
+    }
+    toJSON() {
+        const { platform, columns, ...rest } = this;
+        const columnsMapped = core_1.Utils.keys(columns).reduce((o, col) => {
+            const { mappedType, ...restCol } = columns[col];
+            o[col] = restCol;
+            o[col].mappedType = core_1.Utils.keys(core_1.t).find((k) => core_1.t[k] === mappedType.constructor);
+            return o;
+        }, {});
+        return { columns: columnsMapped, ...rest };
+    }
+}
+exports.DatabaseTable = DatabaseTable;