@mikro-orm/knex 6.3.5-dev.1 → 6.3.5-dev.11

package/dialects/mysql/MySqlSchemaHelper.js

@@ -92,7 +92,7 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
       order by ordinal_position`;
         const allColumns = await connection.execute(sql);
         const str = (val) => val != null ? '' + val : val;
-        const extra = (val) => val.replace(/auto_increment|default_generated|(stored|virtual) generated/i, '').trim();
+        const extra = (val) => val.replace(/auto_increment|default_generated|(stored|virtual) generated/i, '').trim() || undefined;
         const ret = {};
         for (const col of allColumns) {
             const mappedType = this.platform.getMappedType(col.column_type);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.3.5-dev.1",
+  "version": "6.3.5-dev.11",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -66,7 +66,7 @@
     "@mikro-orm/core": "^6.3.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.3.5-dev.1",
+    "@mikro-orm/core": "6.3.5-dev.11",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/schema/DatabaseTable.js

@@ -170,36 +170,46 @@ class DatabaseTable {
         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.
+                || index.deferMode || index.expression // Non-trivial non-composite indexes will be declared at the entity's metadata, though later outputted in the property
+                || !(index.columnNames[0] in columnFks) // Trivial non-composite indexes for scalar props are to be mapped to the column.
             )
             // 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 ret = {
+                name: index.keyName,
+                deferMode: index.deferMode,
+                expression: index.expression,
+            };
+            const isTrivial = !index.deferMode && !index.expression;
+            if (isTrivial) {
+                // 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;
+                    if (typeof map[ret.properties[0]] === 'undefined') {
+                        map[ret.properties[0]] = index;
+                        continue;
+                    }
+                }
             }
-            const properties = this.getIndexProperties(index, columnFks, fksOnColumnProps, fksOnStandaloneProps, namingStrategy);
+            const properties = ret.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);
+            if (typeof properties === 'undefined') {
+                ret.expression ??= schemaHelper.getCreateIndexSQL(this.name, index);
             }
             else {
-                ret.properties = properties;
+                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])) {
+                if (properties.length === 1 && isTrivial && !fksOnStandaloneProps.has(properties[0])) {
                     const map = index.unique ? compositeFkUniques : compositeFkIndexes;
-                    map[properties[0]] = { keyName: index.keyName };
-                    continue;
+                    // Only map one trivial index. If the same column is indexed many times over, output
+                    if (typeof map[properties[0]] === 'undefined') {
+                        map[properties[0]] = index;
+                        continue;
+                    }
                 }
             }
             // Composite indexes that aren't exclusively mapped to FK props get an entity decorator.
@@ -216,18 +226,18 @@ class DatabaseTable {
             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);
+                const { fkIndex, currentFk } = standaloneFkPropBasedOnColumn;
+                const prop = this.getForeignKeyDeclaration(currentFk, namingStrategy, schemaHelper, fkIndex, nullableForeignKeys.has(currentFk), columnName, fksOnColumnProps);
                 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()) {
+        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);
+            const prop = this.getForeignKeyDeclaration(currentFk, namingStrategy, schemaHelper, fkIndex, nullableForeignKeys.has(currentFk), propBaseName, fksOnColumnProps);
             schema.addProperty(prop.name, prop.type, prop);
         }
         const meta = schema.init().meta;
@@ -246,6 +256,7 @@ class DatabaseTable {
         const columnFks = {};
         const fkIndexes = new Map();
         const nullableForeignKeys = new Set();
+        const standaloneFksBasedOnColumnNames = new Map();
         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])) {
@@ -258,12 +269,17 @@ class DatabaseTable {
                 }
                 if (scalarPropertiesForRelations === 'always') {
                     const baseName = this.getSafeBaseNameForFkProp(namingStrategy, currentFk, fks, columnName);
-                    fksOnStandaloneProps.set(baseName, [fkIndex, currentFk]);
-                    fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+                    standaloneFksBasedOnColumnNames.set(baseName, currentFk);
+                    fksOnStandaloneProps.set(baseName, { fkIndex, currentFk });
+                    if (fkIndex) {
+                        fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+                    }
                 }
                 else {
                     fksOnColumnProps.set(columnName, currentFk);
-                    fkIndexes.set(fkIndex, { fk: currentFk, baseName: columnName });
+                    if (fkIndex) {
+                        fkIndexes.set(fkIndex, { fk: currentFk, baseName: columnName });
+                    }
                 }
                 continue;
             }
@@ -290,12 +306,17 @@ class DatabaseTable {
                 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 });
+                    standaloneFksBasedOnColumnNames.set(baseName, currentFk);
+                    fksOnStandaloneProps.set(baseName, { fkIndex, currentFk });
+                    if (fkIndex) {
+                        fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+                    }
                 }
                 else {
                     fksOnColumnProps.set(columnName, currentFk);
-                    fkIndexes.set(fkIndex, { fk: currentFk, baseName: columnName });
+                    if (fkIndex) {
+                        fkIndexes.set(fkIndex, { fk: currentFk, baseName: columnName });
+                    }
                 }
                 continue;
             }
@@ -307,12 +328,17 @@ class DatabaseTable {
                     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 });
+                        standaloneFksBasedOnColumnNames.set(baseName, currentFk);
+                        fksOnStandaloneProps.set(baseName, { fkIndex, currentFk });
+                        if (fkIndex) {
+                            fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+                        }
                     }
                     else {
                         fksOnColumnProps.set(columnName, currentFk);
-                        fkIndexes.set(fkIndex, { fk: currentFk, baseName: columnName });
+                        if (fkIndex) {
+                            fkIndexes.set(fkIndex, { fk: currentFk, baseName: columnName });
+                        }
                     }
                     continue;
                 }
@@ -320,14 +346,19 @@ class DatabaseTable {
                 // 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 });
+                standaloneFksBasedOnColumnNames.set(baseName, currentFk);
+                fksOnStandaloneProps.set(baseName, { fkIndex, currentFk });
+                if (fkIndex) {
+                    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 });
+            fksOnStandaloneProps.set(baseName, { fkIndex, currentFk });
+            if (fkIndex) {
+                fkIndexes.set(fkIndex, { fk: currentFk, baseName });
+            }
         }
         const columnsInFks = Object.keys(columnFks);
         const skippingHandlers = {
@@ -350,17 +381,49 @@ class DatabaseTable {
             },
         };
         const skippedColumnNames = this.getColumns().filter(skippingHandlers[scalarPropertiesForRelations]).map(column => column.name);
+        // Check standalone FKs named after columns for potential conflicts among themselves.
+        // This typically happens when two standalone FKs named after a column resolve to the same prop name
+        // because the respective columns include the referenced table in the name.
+        // Depending on naming strategy and actual names, it may also originate from other scenarios.
+        // We do our best to de-duplicate them here.
+        const safePropNames = new Set();
+        const unsafePropNames = new Map();
+        for (const [unsafeBaseName, currentFk] of standaloneFksBasedOnColumnNames) {
+            const propName = this.getPropertyName(namingStrategy, unsafeBaseName, currentFk);
+            if (safePropNames.has(propName)) {
+                if (!unsafePropNames.has(propName)) {
+                    unsafePropNames.set(propName, []);
+                }
+                unsafePropNames.get(propName).push({ unsafeBaseName, currentFk });
+                continue;
+            }
+            safePropNames.add(propName);
+        }
+        for (const [unsafePropName, affectedBaseNames] of unsafePropNames) {
+            safePropNames.delete(unsafePropName);
+            for (const { unsafeBaseName, currentFk } of affectedBaseNames) {
+                const newBaseName = this.getSafeBaseNameForFkProp(namingStrategy, currentFk, fks);
+                fksOnStandaloneProps.delete(unsafeBaseName);
+                let fkIndex;
+                for (const [indexDef, fkIndexDesc] of fkIndexes) {
+                    if (fkIndexDesc.fk !== currentFk) {
+                        continue;
+                    }
+                    fkIndexDesc.baseName = newBaseName;
+                    fkIndex = indexDef;
+                    break;
+                }
+                fksOnStandaloneProps.set(newBaseName, { fkIndex, currentFk });
+            }
+        }
         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);
+            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;
             }
@@ -369,7 +432,7 @@ class DatabaseTable {
             }
             return a.keyName.localeCompare(b.keyName);
         });
-        return possibleIndexes[0];
+        return possibleIndexes.at(0);
     }
     getIndexProperties(index, columnFks, fksOnColumnProps, fksOnStandaloneProps, namingStrategy) {
         const propBaseNames = new Set();
@@ -381,9 +444,13 @@ class DatabaseTable {
         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)) {
+                // If there is no such column, the "name" is actually an expression.
+                if (!this.hasColumn(columnName)) {
+                    return;
+                }
+                // It has a prop named after it.
+                // Add it and move on.
                 propBaseNames.add(columnName);
                 continue;
             }
@@ -398,7 +465,7 @@ class DatabaseTable {
             // 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) {
+            for (const [propName, { currentFk: fk }] of fksOnStandaloneProps) {
                 if (!columnFks[columnName].includes(fk)) {
                     continue;
                 }
@@ -473,7 +540,7 @@ class DatabaseTable {
     hasPrimaryKey() {
         return !!this.getPrimaryKey();
     }
-    getForeignKeyDeclaration(fk, namingStrategy, schemaHelper, fkIndex, nullable, propNameBase) {
+    getForeignKeyDeclaration(fk, namingStrategy, schemaHelper, fkIndex, nullable, propNameBase, fksOnColumnProps) {
         const prop = this.getPropertyName(namingStrategy, propNameBase, fk);
         const kind = (fkIndex?.unique && !fkIndex.primary) ? this.getReferenceKind(fk, fkIndex) : this.getReferenceKind(fk);
         const runtimeType = this.getPropertyTypeForForeignKey(namingStrategy, fk);
@@ -499,6 +566,7 @@ class DatabaseTable {
             columnOptions.length = column.length;
             columnOptions.precision = column.precision;
             columnOptions.scale = column.scale;
+            columnOptions.extra = column.extra;
             columnOptions.comment = column.comment;
             columnOptions.enum = !!column.enumItems?.length;
             columnOptions.items = column.enumItems;
@@ -556,6 +624,7 @@ class DatabaseTable {
             length: column.length,
             precision: column.precision,
             scale: column.scale,
+            extra: column.extra,
             comment: column.comment,
             index: index ? index.keyName : undefined,
             unique: unique ? unique.keyName : undefined,