@mikro-orm/knex 5.9.4-dev.1 → 5.9.4

package/AbstractSqlDriver.js

@@ -357,7 +357,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         options.convertCustomTypes ?? (options.convertCustomTypes = true);
         const meta = this.metadata.get(entityName);
         if (options.upsert) {
-            const uniqueFields = options.onConflictFields ?? (core_1.Utils.isPlainObject(where[0]) ? Object.keys(where[0]) : meta.primaryKeys);
+            const uniqueFields = options.onConflictFields ?? (core_1.Utils.isPlainObject(where[0]) ? Object.keys(where[0]).flatMap(key => core_1.Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
             const returning = (0, core_1.getOnConflictReturningFields)(meta, data[0], uniqueFields, options);
             qb.insert(data)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "5.9.4-dev.1",
+  "version": "5.9.4",
   "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",
@@ -63,12 +63,12 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^5.9.3"
+    "@mikro-orm/core": "^5.9.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "5.9.4-dev.1",
-    "@mikro-orm/entity-generator": "5.9.4-dev.1",
-    "@mikro-orm/migrations": "5.9.4-dev.1",
+    "@mikro-orm/core": "^5.0.0",
+    "@mikro-orm/entity-generator": "^5.0.0",
+    "@mikro-orm/migrations": "^5.0.0",
     "better-sqlite3": "*",
     "mssql": "*",
     "mysql": "*",

package/query/CriteriaNodeFactory.js

@@ -57,15 +57,25 @@ class CriteriaNodeFactory {
             }, {});
             return this.createNode(metadata, entityName, map, node, item);
         }
-        const operator = Object.keys(payload[item]).some(f => core_1.Utils.isOperator(f));
+        // array operators can be used on embedded properties
+        const allowedOperators = ['$contains', '$contained', '$overlap'];
+        const operator = Object.keys(payload[item]).some(f => core_1.Utils.isOperator(f) && !allowedOperators.includes(f));
         if (operator) {
             throw core_1.ValidationError.cannotUseOperatorsInsideEmbeddables(entityName, prop.name, payload);
         }
         const map = Object.keys(payload[item]).reduce((oo, k) => {
-            if (!prop.embeddedProps[k]) {
+            if (!prop.embeddedProps[k] && !allowedOperators.includes(k)) {
                 throw core_1.ValidationError.invalidEmbeddableQuery(entityName, k, prop.type);
             }
-            oo[prop.embeddedProps[k].name] = payload[item][k];
+            if (prop.embeddedProps[k]) {
+                oo[prop.embeddedProps[k].name] = payload[item][k];
+            }
+            else if (typeof payload[item][k] === 'object') {
+                oo[k] = JSON.stringify(payload[item][k]);
+            }
+            else {
+                oo[k] = payload[item][k];
+            }
             return oo;
         }, {});
         return this.createNode(metadata, entityName, map, node, item);

package/query/ObjectCriteriaNode.js

@@ -72,7 +72,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             }
             else if (this.isPrefixed(k) || core_1.Utils.isOperator(k) || !childAlias) {
                 const idx = prop.referencedPKs.indexOf(k);
-                const key = idx !== -1 && !childAlias ? prop.joinColumns[idx] : k;
+                const key = idx !== -1 && !childAlias && ![core_1.ReferenceType.ONE_TO_MANY, core_1.ReferenceType.MANY_TO_MANY].includes(prop.reference) ? prop.joinColumns[idx] : k;
                 if (key in o) {
                     const $and = o.$and ?? [];
                     $and.push({ [key]: o[key] }, { [key]: payload[k] });

package/schema/DatabaseSchema.js

@@ -55,7 +55,7 @@ class DatabaseSchema {
             table.comment = meta.comment;
             meta.props
                 .filter(prop => this.shouldHaveColumn(meta, prop))
-                .forEach(prop => table.addColumnFromProperty(prop, meta));
+                .forEach(prop => table.addColumnFromProperty(prop, meta, config));
             meta.indexes.forEach(index => table.addIndex(meta, index, 'index'));
             meta.uniques.forEach(index => table.addIndex(meta, index, 'unique'));
             table.addIndex(meta, { properties: meta.props.filter(prop => prop.primary).map(prop => prop.name) }, 'primary');

package/schema/DatabaseTable.d.ts

@@ -1,4 +1,4 @@
-import { type Dictionary, type EntityMetadata, type EntityProperty, type NamingStrategy } from '@mikro-orm/core';
+import { type Dictionary, type EntityMetadata, type EntityProperty, type NamingStrategy, type Configuration } from '@mikro-orm/core';
 import type { SchemaHelper } from './SchemaHelper';
 import type { Check, Column, ForeignKey, Index } from '../typings';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -22,7 +22,7 @@ export declare class DatabaseTable {
     getChecks(): Check[];
     init(cols: Column[], indexes: Index[] | undefined, checks: Check<unknown>[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;
     addColumn(column: Column): void;
-    addColumnFromProperty(prop: EntityProperty, meta: EntityMetadata): void;
+    addColumnFromProperty(prop: EntityProperty, meta: EntityMetadata, config: Configuration): void;
     private getIndexName;
     getEntityDeclaration(namingStrategy: NamingStrategy, schemaHelper: SchemaHelper): EntityMetadata;
     /**

package/schema/DatabaseTable.js

@@ -52,7 +52,7 @@ 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];
@@ -99,7 +99,7 @@ class DatabaseTable {
         });
         if ([core_1.ReferenceType.MANY_TO_ONE, core_1.ReferenceType.ONE_TO_ONE].includes(prop.reference)) {
             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;
             }

package/schema/SchemaComparator.d.ts

@@ -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.

package/schema/SchemaComparator.js

@@ -19,7 +19,7 @@ class SchemaComparator {
      * operations to change the schema stored in fromSchema to the schema that is
      * stored in toSchema.
      */
-    compare(fromSchema, toSchema) {
+    compare(fromSchema, toSchema, inverseDiff) {
         const diff = { newTables: {}, removedTables: {}, changedTables: {}, orphanedForeignKeys: [], newNamespaces: new Set(), removedNamespaces: new Set(), fromSchema };
         const foreignKeysToTable = {};
         for (const namespace of toSchema.getNamespaces()) {
@@ -40,7 +40,7 @@ class SchemaComparator {
                 diff.newTables[tableName] = toSchema.getTable(tableName);
             }
             else {
-                const tableDifferences = this.diffTable(fromSchema.getTable(tableName), toSchema.getTable(tableName));
+                const tableDifferences = this.diffTable(fromSchema.getTable(tableName), toSchema.getTable(tableName), inverseDiff?.changedTables[tableName]);
                 if (tableDifferences !== false) {
                     diff.changedTables[tableName] = tableDifferences;
                 }
@@ -88,7 +88,7 @@ class SchemaComparator {
      * Returns the difference between the tables fromTable and toTable.
      * If there are no differences this method returns the boolean false.
      */
-    diffTable(fromTable, toTable) {
+    diffTable(fromTable, toTable, inverseTableDiff) {
         let changes = 0;
         const tableDifferences = {
             name: fromTable.getShortestName(),
@@ -148,7 +148,7 @@ class SchemaComparator {
             this.log(`column ${tableDifferences.name}.${column.name} changed`, { changedProperties });
             changes++;
         }
-        this.detectColumnRenamings(tableDifferences);
+        this.detectColumnRenamings(tableDifferences, inverseTableDiff);
         const fromTableIndexes = fromTable.getIndexes();
         const toTableIndexes = toTable.getIndexes();
         // See if all the indexes in "from" table exist in "to" table
@@ -240,7 +240,7 @@ class SchemaComparator {
      * 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.
      */
-    detectColumnRenamings(tableDifferences) {
+    detectColumnRenamings(tableDifferences, inverseTableDiff) {
         const renameCandidates = {};
         for (const addedColumn of Object.values(tableDifferences.addedColumns)) {
             for (const removedColumn of Object.values(tableDifferences.removedColumns)) {
@@ -248,6 +248,10 @@ class SchemaComparator {
                 if (diff.size !== 0) {
                     continue;
                 }
+                const renamedColumn = inverseTableDiff?.renamedColumns[addedColumn.name];
+                if (renamedColumn && renamedColumn?.name !== removedColumn.name) {
+                    continue;
+                }
                 renameCandidates[addedColumn.name] = renameCandidates[addedColumn.name] ?? [];
                 renameCandidates[addedColumn.name].push([removedColumn, addedColumn]);
             }
@@ -442,8 +446,8 @@ class SchemaComparator {
             return defaultValueFrom === defaultValueTo;
         }
         if (to.mappedType instanceof core_1.JsonType) {
-            const defaultValueFrom = (0, core_1.parseJsonSafe)(from.default.replace(/^'(.*)'$/, '$1'));
-            const defaultValueTo = (0, core_1.parseJsonSafe)(to.default?.replace(/^'(.*)'$/, '$1'));
+            const defaultValueFrom = (0, core_1.parseJsonSafe)(from.default.replace(/^(_\w+\\)?'(.*?)\\?'$/, '$2'));
+            const defaultValueTo = (0, core_1.parseJsonSafe)(to.default?.replace(/^\(?'(.*?)'\)?$/, '$1'));
             return core_1.Utils.equals(defaultValueFrom, defaultValueTo);
         }
         if (to.mappedType instanceof core_1.DateTimeType && from.default && to.default) {

package/schema/SchemaGenerator.js

@@ -149,7 +149,7 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         const { fromSchema, toSchema } = await this.prepareSchemaForComparison(options);
         const comparator = new SchemaComparator_1.SchemaComparator(this.platform);
         const diffUp = comparator.compare(fromSchema, toSchema);
-        const diffDown = comparator.compare(toSchema, fromSchema);
+        const diffDown = comparator.compare(toSchema, fromSchema, diffUp);
         return {
             up: await this.diffToSQL(diffUp, options),
             down: this.platform.supportsDownMigrations() ? await this.diffToSQL(diffDown, options) : '',
@@ -219,7 +219,7 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         if (schema && schemaName === '*') {
             return `${schema}.${referencedTableName.replace(/^\*\./, '')}`;
         }
-        if (schemaName === this.platform.getDefaultSchemaName()) {
+        if (!schemaName || schemaName === this.platform.getDefaultSchemaName()) {
             return tableName;
         }
         return `${schemaName}.${tableName}`;