@mikro-orm/core 6.4.17-dev.1 → 6.4.17-dev.11

package/decorators/ManyToMany.d.ts

@@ -37,4 +37,6 @@ export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner
     deleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
     /** What to do when the reference to the target entity gets updated. */
     updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
+    /** Enable/disable foreign key constraint creation on this relation */
+    createForeignKeyConstraint?: boolean;
 }

package/decorators/ManyToOne.d.ts

@@ -27,6 +27,8 @@ export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner,
     updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
     /** Set the constraint type. Immediate constraints are checked for each statement, while deferred ones are only checked at the end of the transaction. Only for postgres unique constraints. */
     deferMode?: DeferMode | `${DeferMode}`;
+    /** Enable/disable foreign key constraint creation on this relation */
+    createForeignKeyConstraint?: boolean;
     /** Set a custom foreign key constraint name, overriding NamingStrategy.indexName(). */
     foreignKeyName?: string;
 }

package/decorators/OneToOne.d.ts

@@ -23,4 +23,6 @@ export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOp
     deferMode?: DeferMode | `${DeferMode}`;
     /** Set a custom foreign key constraint name, overriding NamingStrategy.indexName(). */
     foreignKeyName?: string;
+    /** Enable/disable foreign key constraint creation on this relation */
+    createForeignKeyConstraint?: boolean;
 }

package/metadata/EntitySchema.js

@@ -102,6 +102,8 @@ class EntitySchema {
         if (prop.fieldNames && !prop.joinColumns) {
             prop.joinColumns = prop.fieldNames;
         }
+        // By default, the foreign key constraint is created on the relation
+        utils_1.Utils.defaultValue(prop, 'createForeignKeyConstraint', true);
         this.addProperty(name, type, prop);
     }
     addManyToMany(name, type, options) {
@@ -111,6 +113,8 @@ class EntitySchema {
         }
         if (options.owner) {
             utils_1.Utils.renameKey(options, 'mappedBy', 'inversedBy');
+            // By default, the foreign key constraint is created on the relation
+            utils_1.Utils.defaultValue(options, 'createForeignKeyConstraint', true);
         }
         const prop = this.createProperty(enums_1.ReferenceKind.MANY_TO_MANY, options);
         this.addProperty(name, type, prop);
@@ -123,8 +127,12 @@ class EntitySchema {
         const prop = this.createProperty(enums_1.ReferenceKind.ONE_TO_ONE, options);
         utils_1.Utils.defaultValue(prop, 'owner', !!prop.inversedBy || !prop.mappedBy);
         utils_1.Utils.defaultValue(prop, 'unique', prop.owner);
-        if (prop.owner && options.mappedBy) {
-            utils_1.Utils.renameKey(prop, 'mappedBy', 'inversedBy');
+        if (prop.owner) {
+            if (options.mappedBy) {
+                utils_1.Utils.renameKey(prop, 'mappedBy', 'inversedBy');
+            }
+            // By default, the foreign key constraint is created on the relation
+            utils_1.Utils.defaultValue(prop, 'createForeignKeyConstraint', true);
         }
         if (prop.joinColumns && !prop.fieldNames) {
             prop.fieldNames = prop.joinColumns;

package/metadata/MetadataDiscovery.js

@@ -657,6 +657,7 @@ class MetadataDiscovery {
             autoincrement: false,
             updateRule: prop.updateRule,
             deleteRule: prop.deleteRule,
+            createForeignKeyConstraint: prop.createForeignKeyConstraint,
         };
         if (selfReferencing && !this.platform.supportsMultipleCascadePaths()) {
             ret.updateRule ??= 'no action';
@@ -1057,7 +1058,7 @@ class MetadataDiscovery {
             prop.defaultRaw = this.platform.formatQuery(raw.sql, raw.params);
             return;
         }
-        if (prop.customType instanceof types_1.ArrayType && Array.isArray(prop.default)) {
+        if (Array.isArray(prop.default) && prop.customType) {
             val = prop.customType.convertToDatabaseValue(prop.default, this.platform);
         }
         prop.defaultRaw = typeof val === 'string' ? `'${val}'` : '' + val;
@@ -1111,6 +1112,9 @@ class MetadataDiscovery {
         if (prop.kind === enums_1.ReferenceKind.SCALAR && !prop.customType && prop.columnTypes && ['json', 'jsonb'].includes(prop.columnTypes[0])) {
             prop.customType = new types_1.JsonType();
         }
+        if (prop.kind === enums_1.ReferenceKind.EMBEDDED && !prop.customType && (prop.object || prop.array)) {
+            prop.customType = new types_1.JsonType();
+        }
         if (!prop.customType && prop.array && prop.items) {
             prop.customType = new types_1.EnumArrayType(`${meta.className}.${prop.name}`, prop.items);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.4.17-dev.1",
+  "version": "6.4.17-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",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.3.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.4.17-dev.1",
+    "mikro-orm": "6.4.17-dev.11",
     "reflect-metadata": "0.2.2"
   }
 }

package/typings.d.ts

@@ -384,6 +384,7 @@ export interface EntityProperty<Owner = any, Target = any> {
     optional?: boolean;
     ignoreSchemaChanges?: ('type' | 'extra' | 'default')[];
     deferMode?: DeferMode;
+    createForeignKeyConstraint: boolean;
     foreignKeyName?: string;
 }
 export declare class EntityMetadata<T = any> {

package/unit-of-work/ChangeSetComputer.js

@@ -144,7 +144,9 @@ class ChangeSetComputer {
         if (!target.isDirty() && changeSet.type !== ChangeSet_1.ChangeSetType.CREATE) {
             return;
         }
-        this.collectionUpdates.add(target);
+        if (target.isDirty()) {
+            this.collectionUpdates.add(target);
+        }
         if (prop.owner && !this.platform.usesPivotTable()) {
             changeSet.payload[prop.name] = target.getItems(false).map((item) => item.__helper.__identifier ?? item.__helper.getPrimaryKey());
         }

package/unit-of-work/UnitOfWork.d.ts

@@ -102,6 +102,7 @@ export declare class UnitOfWork {
     private commitDeleteChangeSets;
     private commitExtraUpdates;
     private commitCollectionUpdates;
+    private filterCollectionUpdates;
     /**
      * Orders change sets so FK constrains are maintained, ensures stable order (needed for node < 11)
      */

package/unit-of-work/UnitOfWork.js

@@ -303,6 +303,7 @@ class UnitOfWork {
                 cs.entity.__helper.__processing = true;
             }
             await this.eventManager.dispatchEvent(enums_1.EventType.onFlush, { em: this.em, uow: this });
+            this.filterCollectionUpdates();
             // nothing to do, do not start transaction
             if (this.changeSets.size === 0 && this.collectionUpdates.size === 0 && this.extraUpdates.size === 0) {
                 return void await this.eventManager.dispatchEvent(enums_1.EventType.afterFlush, { em: this.em, uow: this });
@@ -886,23 +887,29 @@ class UnitOfWork {
         }
     }
     async commitCollectionUpdates(ctx) {
-        const collectionUpdates = [];
+        this.filterCollectionUpdates();
+        await this.em.getDriver().syncCollections(this.collectionUpdates, { ctx, schema: this.em.schema });
         for (const coll of this.collectionUpdates) {
+            coll.takeSnapshot();
+        }
+    }
+    filterCollectionUpdates() {
+        for (const coll of this.collectionUpdates) {
+            let skip = true;
             if (coll.property.owner || coll.getItems(false).filter(item => !item.__helper.__initialized).length > 0) {
                 if (this.platform.usesPivotTable()) {
-                    collectionUpdates.push(coll);
+                    skip = false;
                 }
             }
             else if (coll.property.kind === enums_1.ReferenceKind.ONE_TO_MANY && coll.getSnapshot() === undefined) {
-                collectionUpdates.push(coll);
+                skip = false;
             }
             else if (coll.property.kind === enums_1.ReferenceKind.MANY_TO_MANY && !coll.property.owner) {
-                collectionUpdates.push(coll);
+                skip = false;
+            }
+            if (skip) {
+                this.collectionUpdates.delete(coll);
             }
-        }
-        await this.em.getDriver().syncCollections(collectionUpdates, { ctx, schema: this.em.schema });
-        for (const coll of this.collectionUpdates) {
-            coll.takeSnapshot();
         }
     }
     /**

package/utils/QueryHelper.js

@@ -121,7 +121,7 @@ class QueryHelper {
                 value = QueryHelper.processCustomType(prop, value, platform, undefined, true);
             }
             const isJsonProperty = prop?.customType instanceof JsonType_1.JsonType && Utils_1.Utils.isPlainObject(value) && !platform.isRaw(value) && Object.keys(value)[0] !== '$eq';
-            if (isJsonProperty) {
+            if (isJsonProperty && prop?.kind !== enums_1.ReferenceKind.EMBEDDED) {
                 return this.processJsonCondition(o, value, [prop.fieldNames[0]], platform, aliased);
             }
             if (Array.isArray(value) && !Utils_1.Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !key.includes('?') && options.type !== 'orderBy') {