@mikro-orm/knex 6.0.0-dev.18 → 6.0.0-dev.181

package/schema/DatabaseTable.js

@@ -6,14 +6,19 @@ const core_1 = require("@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;
-        this.columns = {};
-        this.indexes = [];
-        this.checks = [];
-        this.foreignKeys = {};
         Object.defineProperties(this, {
             platform: { enumerable: false, writable: true },
         });
@@ -24,8 +29,11 @@ class DatabaseTable {
     getColumn(name) {
         return this.columns[name];
     }
+    removeColumn(name) {
+        delete this.columns[name];
+    }
     getIndexes() {
-        return this.indexes;
+        return core_1.Utils.removeDuplicates(this.indexes);
     }
     getChecks() {
         return this.checks;
@@ -41,7 +49,7 @@ class DatabaseTable {
             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] || [];
+            v.enumItems ??= enums[v.name] || [];
             o[v.name] = v;
             return o;
         }, {});
@@ -49,48 +57,55 @@ class DatabaseTable {
     addColumn(column) {
         this.columns[column.name] = column;
     }
-    addColumnFromProperty(prop, meta) {
+    addColumnFromProperty(prop, meta, config) {
         prop.fieldNames.forEach((field, idx) => {
-            var _a;
             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.precision ??= +match[1];
+                    prop.scale ??= +match[2];
                     prop.length = undefined;
                 }
             }
             if (mappedType instanceof core_1.DateTimeType) {
-                prop.length ?? (prop.length = this.platform.getDefaultDateTimeLength());
+                const match = prop.columnTypes[idx].match(/\w+\((\d+)\)/);
+                if (match) {
+                    prop.length ??= +match[1];
+                }
+                else {
+                    prop.length ??= this.platform.getDefaultDateTimeLength();
+                }
             }
-            const primary = !meta.compositePK && !!prop.primary && prop.reference === core_1.ReferenceType.SCALAR && this.platform.isNumericColumn(mappedType);
+            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: !!prop.nullable,
+                nullable: this.columns[field]?.nullable ?? !!prop.nullable,
+                nativeEnumName: prop.nativeEnumName,
                 length: prop.length,
                 precision: prop.precision,
                 scale: prop.scale,
                 default: prop.defaultRaw,
-                enumItems: prop.items?.every(core_1.Utils.isString) ? prop.items : undefined,
+                enumItems: prop.nativeEnumName || prop.items?.every(core_1.Utils.isString) ? prop.items : undefined,
                 comment: prop.comment,
                 extra: prop.extra,
                 ignoreSchemaChanges: prop.ignoreSchemaChanges,
             };
-            (_a = this.columns[field]).unsigned || (_a.unsigned = this.columns[field].autoincrement);
+            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.ReferenceType.MANY_TO_ONE, core_1.ReferenceType.ONE_TO_ONE].includes(prop.reference)) {
+        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.schema === '*' ? this.schema : prop.targetMeta.schema ?? this.schema;
+            let schema = prop.targetMeta.root.schema === '*' ? this.schema : (prop.targetMeta.root.schema ?? config.get('schema', this.platform.getDefaultSchemaName()));
             if (prop.referencedTableName.includes('.')) {
                 schema = undefined;
             }
@@ -102,11 +117,11 @@ class DatabaseTable {
                 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.onDelete || cascade || prop.nullable) {
-                this.foreignKeys[constraintName].deleteRule = prop.onDelete || (cascade ? 'cascade' : 'set null');
+            if (prop.deleteRule || cascade || prop.nullable) {
+                this.foreignKeys[constraintName].deleteRule = prop.deleteRule || (cascade ? 'cascade' : 'set null');
             }
-            if (prop.onUpdateIntegrity || prop.cascade.includes(core_1.Cascade.PERSIST) || prop.cascade.includes(core_1.Cascade.ALL)) {
-                this.foreignKeys[constraintName].updateRule = prop.onUpdateIntegrity || 'cascade';
+            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) {
@@ -114,6 +129,7 @@ class DatabaseTable {
                 columnNames: prop.fieldNames,
                 composite: prop.fieldNames.length > 1,
                 keyName: this.getIndexName(prop.index, prop.fieldNames, 'index'),
+                constraint: false,
                 primary: false,
                 unique: false,
             });
@@ -123,6 +139,7 @@ class DatabaseTable {
                 columnNames: prop.fieldNames,
                 composite: prop.fieldNames.length > 1,
                 keyName: this.getIndexName(prop.unique, prop.fieldNames, 'unique'),
+                constraint: !prop.fieldNames.some((d) => d.includes('.')),
                 primary: false,
                 unique: true,
             });
@@ -134,40 +151,282 @@ class DatabaseTable {
         }
         return this.platform.getIndexName(this.name, columnNames, type);
     }
-    getEntityDeclaration(namingStrategy, schemaHelper) {
+    getEntityDeclaration(namingStrategy, schemaHelper, scalarPropertiesForRelations) {
+        const { fksOnColumnProps, fksOnStandaloneProps, columnFks, fkIndexes, nullableForeignKeys, skippedColumnNames, } = this.foreignKeysToProps(namingStrategy, scalarPropertiesForRelations);
         let name = namingStrategy.getClassName(this.name, '_');
         name = name.match(/^\d/) ? 'E' + name : name;
         const schema = new core_1.EntitySchema({ name, collection: this.name, schema: this.schema });
         const compositeFkIndexes = {};
         const compositeFkUniques = {};
-        for (const index of this.indexes.filter(index => index.columnNames.length > 1)) {
-            const properties = index.columnNames.map(col => this.getPropertyName(namingStrategy, this.getColumn(col)));
-            const ret = { name: index.keyName, properties: core_1.Utils.unique(properties) };
-            if (ret.properties.length === 1) {
+        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 === null));
+        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) {
+                ret.properties = [this.getPropertyName(namingStrategy, fkForIndex.baseName, fkForIndex.fk)];
                 const map = index.unique ? compositeFkUniques : compositeFkIndexes;
                 map[ret.properties[0]] = { keyName: index.keyName };
                 continue;
             }
-            if (index.primary) {
-                //
+            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 (index.unique) {
-                schema.addUnique(ret);
+            else if (typeof properties === 'undefined') {
+                ret.expression = schemaHelper.getCreateIndexSQL(this.name, index);
             }
             else {
-                schema.addIndex(ret);
+                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);
         }
-        for (const column of this.getColumns()) {
-            const prop = this.getPropertyDeclaration(column, namingStrategy, schemaHelper, compositeFkIndexes, compositeFkUniques);
+        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;
-        meta.relations
-            .filter(prop => prop.primary && prop.reference === core_1.ReferenceType.MANY_TO_ONE && !meta.compositePK)
-            .forEach(prop => prop.reference = core_1.ReferenceType.ONE_TO_ONE);
+        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.primary !== b.primary) {
+                return a.primary ? -1 : 1;
+            }
+            if (a.unique !== b.unique) {
+                return a.unique ? -1 : 1;
+            }
+            if (a.columnNames.length !== b.columnNames.length) {
+                return a.columnNames.length < b.columnNames.length ? -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;
+        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.
      */
@@ -201,61 +460,108 @@ class DatabaseTable {
     hasPrimaryKey() {
         return !!this.getPrimaryKey();
     }
-    getPropertyDeclaration(column, namingStrategy, schemaHelper, compositeFkIndexes, compositeFkUniques) {
-        const fk = Object.values(this.foreignKeys).find(fk => fk.columnNames.includes(column.name));
-        const prop = this.getPropertyName(namingStrategy, column);
+    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();
+        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.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 reference = this.getReferenceType(fk, unique);
-        const type = this.getPropertyType(namingStrategy, column, fk);
+        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.onUpdateIntegrity = fk.updateRule?.toLowerCase();
-            fkOptions.onDelete = fk.deleteRule?.toLowerCase();
+            fkOptions.updateRule = fk.updateRule?.toLowerCase();
+            fkOptions.deleteRule = fk.deleteRule?.toLowerCase();
         }
         return {
             name: prop,
             type,
-            reference,
+            kind,
             columnType: column.type,
             default: this.getPropertyDefaultValue(schemaHelper, column, type),
             defaultRaw: this.getPropertyDefaultValue(schemaHelper, column, type, true),
             nullable: column.nullable,
-            primary: column.primary,
+            primary: column.primary && persist,
             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,
         };
     }
-    getReferenceType(fk, unique) {
+    getReferenceKind(fk, unique) {
         if (fk && unique) {
-            return core_1.ReferenceType.ONE_TO_ONE;
+            return core_1.ReferenceKind.ONE_TO_ONE;
         }
         if (fk) {
-            return core_1.ReferenceType.MANY_TO_ONE;
+            return core_1.ReferenceKind.MANY_TO_ONE;
         }
-        return core_1.ReferenceType.SCALAR;
+        return core_1.ReferenceKind.SCALAR;
     }
-    getPropertyName(namingStrategy, column) {
-        const fk = Object.values(this.foreignKeys).find(fk => fk.columnNames.includes(column.name));
-        let field = column.name;
+    getPropertyName(namingStrategy, baseName, fk) {
+        let field = baseName;
         if (fk) {
-            const idx = fk.columnNames.indexOf(column.name);
-            field = field.replace(new RegExp(`_${fk.referencedColumnNames[idx]}$`), '');
+            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);
     }
-    getPropertyType(namingStrategy, column, fk) {
+    getPropertyTypeForForeignKey(namingStrategy, fk) {
+        const parts = fk.referencedTableName.split('.', 2);
+        return namingStrategy.getClassName(parts.length > 1 ? parts[1] : parts[0], '_');
+    }
+    getPropertyTypeForColumn(namingStrategy, column, fk) {
         if (fk) {
-            const parts = fk.referencedTableName.split('.', 2);
-            return namingStrategy.getClassName(parts.length > 1 ? parts[1] : parts[0], '_');
+            return this.getPropertyTypeForForeignKey(namingStrategy, fk);
         }
         // If this column is using an enum.
         if (column.enumItems?.length) {
@@ -288,7 +594,20 @@ class DatabaseTable {
         return '' + val;
     }
     addIndex(meta, index, type) {
-        const properties = core_1.Utils.flatten(core_1.Utils.asArray(index.properties).map(prop => meta.properties[prop].fieldNames));
+        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])];
+            }
+            return [prop];
+        })));
         if (properties.length === 0 && !index.expression) {
             return;
         }
@@ -297,10 +616,13 @@ class DatabaseTable {
             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) {
@@ -308,10 +630,10 @@ class DatabaseTable {
     }
     toJSON() {
         const { platform, columns, ...rest } = this;
-        const columnsMapped = Object.keys(columns).reduce((o, col) => {
+        const columnsMapped = core_1.Utils.keys(columns).reduce((o, col) => {
             const { mappedType, ...restCol } = columns[col];
             o[col] = restCol;
-            o[col].mappedType = Object.keys(core_1.t).find(k => core_1.t[k] === mappedType.constructor);
+            o[col].mappedType = core_1.Utils.keys(core_1.t).find(k => core_1.t[k] === mappedType.constructor);
             return o;
         }, {});
         return { columns: columnsMapped, ...rest };

package/schema/SchemaComparator.d.ts

@@ -1,4 +1,4 @@
-import type { CheckDef, Column, ForeignKey, IndexDef, SchemaDifference, TableDifference } from '../typings';
+import type { Column, ForeignKey, IndexDef, SchemaDifference, TableDifference } from '../typings';
 import type { DatabaseSchema } from './DatabaseSchema';
 import type { DatabaseTable } from './DatabaseTable';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -17,12 +17,12 @@ export declare class SchemaComparator {
      * operations to change the schema stored in fromSchema to the schema that is
      * stored in toSchema.
      */
-    compare(fromSchema: DatabaseSchema, toSchema: DatabaseSchema): SchemaDifference;
+    compare(fromSchema: DatabaseSchema, toSchema: DatabaseSchema, inverseDiff?: SchemaDifference): SchemaDifference;
     /**
      * Returns the difference between the tables fromTable and toTable.
      * If there are no differences this method returns the boolean false.
      */
-    diffTable(fromTable: DatabaseTable, toTable: DatabaseTable): TableDifference | false;
+    diffTable(fromTable: DatabaseTable, toTable: DatabaseTable, inverseTableDiff?: TableDifference): TableDifference | false;
     /**
      * Try to find columns that only changed their name, rename operations maybe cheaper than add/drop
      * however ambiguities between different possibilities should not lead to renaming at all.
@@ -38,7 +38,7 @@ export declare class SchemaComparator {
      * Returns the difference between the columns
      * If there are differences this method returns field2, otherwise the boolean false.
      */
-    diffColumn(column1: Column, column2: Column, tableName?: string): Set<string>;
+    diffColumn(fromColumn: Column, toColumn: Column, tableName?: string): Set<string>;
     diffEnumItems(items1?: string[], items2?: string[]): boolean;
     diffComment(comment1?: string, comment2?: string): boolean;
     /**
@@ -50,7 +50,7 @@ export declare class SchemaComparator {
      * Checks if the other index already fulfills all the indexing and constraint needs of the current one.
      */
     isIndexFulfilledBy(index1: IndexDef, index2: IndexDef): boolean;
-    diffCheck(check1: CheckDef, check2: CheckDef): boolean;
+    diffExpression(expr1: string, expr2: string): boolean;
     hasSameDefaultValue(from: Column, to: Column): boolean;
     private mapColumnToProperty;
     private log;