@mikro-orm/core 6.4.1-dev.8 → 6.4.1

package/entity/EntityAssigner.d.ts

@@ -17,14 +17,63 @@ export declare class EntityAssigner {
 }
 export declare const assign: typeof EntityAssigner.assign;
 export interface AssignOptions<Convert extends boolean> {
+    /**
+     * Allows disabling processing of nested relations. When disabled, an object payload in place of a relation always
+     * results in an `INSERT` query. To assign a value of the relation, use the foreign key instead of an object.
+     * Defaults to `true`.
+     */
     updateNestedEntities?: boolean;
+    /**
+     * When assigning to a relation property with object payload and `updateNestedEntities` enabled (default), you can
+     * control how a payload without a primary key is handled. By default, it is considered as a new object, resulting
+     * in an `INSERT` query. Use `updateByPrimaryKey: false` to allow assigning the data on an existing relation instead.
+     * Defaults to `true`.
+     */
     updateByPrimaryKey?: boolean;
+    /**
+     * When you have some properties in the payload that are not represented by an entity property mapping, you can skip
+     * such unknown properties via `onlyProperties: true`. Defaults to `false`.
+     */
     onlyProperties?: boolean;
+    /**
+     * With `onlyOwnProperties` enabled, to-many relations are skipped, and payloads of to-one relations are converted
+     * to foreign keys. Defaults to `false`.
+     */
     onlyOwnProperties?: boolean;
+    /**
+     * `assign` excepts runtime values for properties using custom types. To be able to assign raw database values, you
+     * can enable the `convertCustomTypes` option. Defaults to `false`.
+     */
     convertCustomTypes?: Convert;
+    /**
+     * When assigning to a JSON property, the value is replaced. Use `mergeObjectProperties: true` to enable deep merging
+     * of the payload with the existing value. Defaults to `false`.
+     */
     mergeObjectProperties?: boolean;
+    /**
+     * When assigning to an embedded property, the values are deeply merged with the existing data.
+     * Use `mergeEmbeddedProperties: false` to replace them instead. Defaults to `true`.
+     */
     mergeEmbeddedProperties?: boolean;
+    /**
+     * When assigning to a relation property, if the value is a POJO and `updateByPrimaryKey` is enabled, we check if
+     * the target exists in the identity map based on its primary key and call `assign` on it recursively. If there is
+     * no primary key provided, or the entity is not present in the context, such an entity is considered as new
+     * (resulting in `INSERT` query), created via `em.create()`. You can use `merge: true` to use `em.merge()` instead,
+     * which means there won't be any query used for persisting the relation. Defaults to `false`.
+     */
     merge?: boolean;
+    /**
+     * When assigning to a to-many relation properties (`Collection`) with `updateNestedEntities` and `updateByPrimaryKey`
+     * enabled (default), you can use this option to override the relation schema. This is used only when trying to find
+     * the entity reference in the current context. If it is not found, we create the relation entity using the target
+     * entity schema. The value is automatically inferred from the target entity.
+     */
     schema?: string;
+    /**
+     * When using the static `assign()` helper, you can pass the EntityManager instance explicitly via the `em` option.
+     * This is only needed when you try to assign a relation property. The value is automatically inferred from the target
+     * entity when it is managed, or when you use `em.assign()` instead.
+     */
     em?: EntityManager;
 }

package/entity/EntityFactory.js

@@ -283,18 +283,21 @@ class EntityFactory {
     extractConstructorParams(meta, data, options) {
         return meta.constructorParams.map(k => {
             if (meta.properties[k] && [enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(meta.properties[k].kind) && data[k]) {
-                const entity = this.unitOfWork.getById(meta.properties[k].type, data[k], options.schema);
+                const pk = Reference_1.Reference.unwrapReference(data[k]);
+                const entity = this.unitOfWork.getById(meta.properties[k].type, pk, options.schema);
                 if (entity) {
                     return entity;
                 }
                 if (Utils_1.Utils.isEntity(data[k])) {
                     return data[k];
                 }
-                if (Utils_1.Utils.isObject(data[k]) && !Utils_1.Utils.extractPK(data[k], meta.properties[k].targetMeta, true)) {
+                const nakedPk = Utils_1.Utils.extractPK(data[k], meta.properties[k].targetMeta, true);
+                if (Utils_1.Utils.isObject(data[k]) && !nakedPk) {
                     return this.create(meta.properties[k].type, data[k], options);
                 }
                 const { newEntity, initialized, ...rest } = options;
-                return this.createReference(meta.properties[k].type, data[k], rest);
+                const target = this.createReference(meta.properties[k].type, nakedPk, rest);
+                return Reference_1.Reference.wrapReference(target, meta.properties[k]);
             }
             if (meta.properties[k]?.kind === enums_1.ReferenceKind.EMBEDDED && data[k]) {
                 /* istanbul ignore next */

package/metadata/MetadataDiscovery.js

@@ -56,13 +56,13 @@ class MetadataDiscovery {
         this.logger.log('discovery', `ORM entity discovery started, using ${colors_1.colors.cyan(this.metadataProvider.constructor.name)} in sync mode`);
         this.findEntities(preferTsNode, true);
         for (const meta of this.discovered) {
-            this.config.get('discovery').onMetadata?.(meta, this.platform);
+            void this.config.get('discovery').onMetadata?.(meta, this.platform);
         }
         this.processDiscoveredEntities(this.discovered);
         const diff = Date.now() - startTime;
         this.logger.log('discovery', `- entity discovery finished, found ${colors_1.colors.green('' + this.discovered.length)} entities, took ${colors_1.colors.green(`${diff} ms`)}`);
         const storage = this.mapDiscoveredEntities();
-        this.config.get('discovery').afterDiscovered?.(storage, this.platform);
+        void this.config.get('discovery').afterDiscovered?.(storage, this.platform);
         return storage;
     }
     mapDiscoveredEntities() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.4.1-dev.8",
+  "version": "6.4.1",
   "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",
@@ -59,12 +59,12 @@
     "access": "public"
   },
   "dependencies": {
-    "dataloader": "2.2.2",
-    "dotenv": "16.4.5",
+    "dataloader": "2.2.3",
+    "dotenv": "16.4.7",
     "esprima": "4.0.1",
     "fs-extra": "11.2.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.4.1-dev.8",
+    "mikro-orm": "6.4.1",
     "reflect-metadata": "0.2.2"
   }
 }

package/typings.d.ts

@@ -388,6 +388,7 @@ export declare class EntityMetadata<T = any> {
     addProperty(prop: Partial<EntityProperty<T>>, sync?: boolean): void;
     removeProperty(name: string, sync?: boolean): void;
     getPrimaryProps(): EntityProperty<T>[];
+    getPrimaryProp(): EntityProperty<T>;
     get tableName(): string;
     set tableName(name: string);
     sync(initIndexes?: boolean): void;

package/typings.js

@@ -50,6 +50,9 @@ class EntityMetadata {
     getPrimaryProps() {
         return this.primaryKeys.map(pk => this.properties[pk]);
     }
+    getPrimaryProp() {
+        return this.properties[this.primaryKeys[0]];
+    }
     get tableName() {
         return this.collection;
     }

package/unit-of-work/ChangeSet.js

@@ -31,6 +31,14 @@ class ChangeSet {
         else {
             this.primaryKey = this.originalEntity[this.meta.primaryKeys[0]];
         }
+        if (!this.meta.compositePK
+            && this.meta.getPrimaryProp().targetMeta?.compositePK
+            && typeof this.primaryKey === 'object'
+            && this.primaryKey !== null) {
+            this.primaryKey = this.meta.getPrimaryProp().targetMeta.primaryKeys.map(childPK => {
+                return this.primaryKey[childPK];
+            });
+        }
         if (object && this.primaryKey != null) {
             return Utils_1.Utils.primaryKeyToObject(this.meta, this.primaryKey);
         }

package/unit-of-work/UnitOfWork.js

@@ -774,7 +774,7 @@ class UnitOfWork {
     findExtraUpdates(changeSet, props) {
         for (const prop of props) {
             const ref = changeSet.entity[prop.name];
-            if (!ref) {
+            if (!ref || prop.deferMode === enums_1.DeferMode.INITIALLY_DEFERRED) {
                 continue;
             }
             if (Utils_1.Utils.isCollection(ref)) {

package/utils/EntityComparator.js

@@ -74,7 +74,19 @@ class EntityComparator {
         else {
             const pk = meta.primaryKeys[0];
             if (meta.properties[pk].kind !== enums_1.ReferenceKind.SCALAR) {
-                lines.push(`  if (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) return entity${this.wrap(pk)}.__helper.getPrimaryKey();`);
+                lines.push(`  if (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) {`);
+                lines.push(`    const pk = entity${this.wrap(pk)}.__helper.getPrimaryKey();`);
+                if (meta.properties[pk].targetMeta.compositePK) {
+                    lines.push(`    if (typeof pk === 'object') {`);
+                    lines.push(`      return [`);
+                    for (const childPK of meta.properties[pk].targetMeta.primaryKeys) {
+                        lines.push(`        pk${this.wrap(childPK)},`);
+                    }
+                    lines.push(`      ];`);
+                    lines.push(`    }`);
+                }
+                lines.push(`    return pk;`);
+                lines.push(`  }`);
             }
             lines.push(`  return entity${this.wrap(pk)};`);
         }