@mikro-orm/core 6.4.17-dev.20 → 6.4.17-dev.22

package/decorators/Transactional.d.ts

@@ -2,6 +2,7 @@ import type { TransactionOptions } from '../enums';
 import type { ContextProvider } from '../typings';
 type TransactionalOptions<T> = TransactionOptions & {
     context?: ContextProvider<T>;
+    contextName?: string;
 };
 /**
  * This decorator wraps the method with `em.transactional()`, so you can provide `TransactionOptions` just like with `em.transactional()`.

package/decorators/Transactional.js

@@ -17,10 +17,10 @@ function Transactional(options = {}) {
             throw new Error('@Transactional() should be use with async functions');
         }
         descriptor.value = async function (...args) {
-            const { context, ...txOptions } = options;
+            const { context, contextName, ...txOptions } = options;
             const em = await (0, resolveContextProvider_1.resolveContextProvider)(this, context)
-                || TransactionContext_1.TransactionContext.getEntityManager()
-                || RequestContext_1.RequestContext.getEntityManager();
+                || TransactionContext_1.TransactionContext.getEntityManager(contextName)
+                || RequestContext_1.RequestContext.getEntityManager(contextName);
             if (!em) {
                 throw new Error(`@Transactional() decorator can only be applied to methods of classes with \`orm: MikroORM\` property, \`em: EntityManager\` property, or with a callback parameter like \`@Transactional(() => orm)\` that returns one of those types. The parameter will contain a reference to current \`this\`. Returning an EntityRepository from it is also supported.`);
             }

package/entity/EntityFactory.js

@@ -74,7 +74,7 @@ class EntityFactory {
                             continue;
                         }
                         if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isPlainObject(data[prop.name])) {
-                            data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
+                            data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                         }
                         data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, { key: prop.name, mode: 'hydration' });
                     }

package/entity/EntityHelper.js

@@ -155,7 +155,7 @@ class EntityHelper {
                 wrapped.__data[prop.name] = Reference_1.Reference.wrapReference(val, prop);
                 // when propagation from inside hydration, we set the FK to the entity data immediately
                 if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
-                    wrapped.__originalEntityData[prop.name] = Utils_1.Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta.primaryKeys, true);
+                    wrapped.__originalEntityData[prop.name] = Utils_1.Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta, true);
                 }
                 else {
                     wrapped.__touched = !hydrator.isRunning();

package/entity/EntityLoader.js

@@ -154,7 +154,7 @@ class EntityLoader {
     }
     async populateScalar(meta, filtered, options) {
         const pk = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
-        const ids = Utils_1.Utils.unique(filtered.map(e => Utils_1.Utils.getPrimaryKeyValues(e, meta.primaryKeys, true)));
+        const ids = Utils_1.Utils.unique(filtered.map(e => Utils_1.Utils.getPrimaryKeyValues(e, meta, true)));
         const where = this.mergePrimaryCondition(ids, pk, options, meta, this.metadata, this.driver.getPlatform());
         const { filters, convertCustomTypes, lockMode, strategy, populateWhere, connectionType, logging, fields } = options;
         await this.em.find(meta.className, where, {

package/entity/WrappedEntity.js

@@ -153,7 +153,7 @@ class WrappedEntity {
         return this.__em?.config ?? this.entity.__config;
     }
     get __primaryKeys() {
-        return Utils_1.Utils.getPrimaryKeyValues(this.entity, this.__meta.primaryKeys);
+        return Utils_1.Utils.getPrimaryKeyValues(this.entity, this.__meta);
     }
     /** @ignore */
     [node_util_1.inspect.custom]() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.4.17-dev.20",
+  "version": "6.4.17-dev.22",
   "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.20",
+    "mikro-orm": "6.4.17-dev.22",
     "reflect-metadata": "0.2.2"
   }
 }

package/typings.js

@@ -115,7 +115,7 @@ class EntityMetadata {
                         wrapped.__data[prop.name] = entity_1.Reference.wrapReference(val, prop);
                         // when propagation from inside hydration, we set the FK to the entity data immediately
                         if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
-                            wrapped.__originalEntityData[prop.name] = Utils_1.Utils.getPrimaryKeyValues(val, prop.targetMeta.primaryKeys, true);
+                            wrapped.__originalEntityData[prop.name] = Utils_1.Utils.getPrimaryKeyValues(val, prop.targetMeta, true);
                         }
                         else {
                             wrapped.__touched = !hydrator.isRunning();

package/unit-of-work/UnitOfWork.js

@@ -88,7 +88,7 @@ class UnitOfWork {
                 }
                 wrapped.__loadedProperties.add(key);
                 if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isPlainObject(data[prop.name])) {
-                    data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
+                    data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                 }
                 else if (prop.kind === enums_1.ReferenceKind.EMBEDDED && !prop.object && Utils_1.Utils.isPlainObject(data[prop.name])) {
                     for (const p of prop.targetMeta.props) {
@@ -96,7 +96,7 @@ class UnitOfWork {
                         const prefix = prop.prefix === false ? '' : prop.prefix === true ? prop.name + '_' : prop.prefix;
                         data[prefix + p.name] = data[prop.name][p.name];
                     }
-                    data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
+                    data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                 }
                 if (forceUndefined) {
                     if (data[key] === null) {

package/utils/QueryHelper.js

@@ -40,7 +40,7 @@ class QueryHelper {
         if (Array.isArray(where)) {
             where.forEach((item, i) => {
                 if (this.inlinePrimaryKeyObjects(item, meta, metadata, key)) {
-                    where[i] = Utils_1.Utils.getPrimaryKeyValues(item, meta.primaryKeys, false);
+                    where[i] = Utils_1.Utils.getPrimaryKeyValues(item, meta, false);
                 }
             });
         }
@@ -61,7 +61,7 @@ class QueryHelper {
         Object.keys(where).forEach(k => {
             const meta2 = metadata.find(meta.properties[k]?.type) || meta;
             if (this.inlinePrimaryKeyObjects(where[k], meta2, metadata, k)) {
-                where[k] = Utils_1.Utils.getPrimaryKeyValues(where[k], meta2.primaryKeys, true);
+                where[k] = Utils_1.Utils.getPrimaryKeyValues(where[k], meta2, true);
             }
         });
         return false;

package/utils/Utils.d.ts

@@ -134,14 +134,14 @@ export declare class Utils {
     static getCompositeKeyHash<T>(data: EntityData<T>, meta: EntityMetadata<T>, convertCustomTypes?: boolean, platform?: Platform, flat?: boolean): string;
     static getPrimaryKeyHash(pks: (string | Buffer | Date)[]): string;
     static splitPrimaryKeys<T extends object>(key: string): EntityKey<T>[];
-    static getPrimaryKeyValues<T>(entity: T, primaryKeys: string[], allowScalar?: boolean, convertCustomTypes?: boolean): any;
+    static getPrimaryKeyValues<T>(entity: T, primaryKeys: string[] | EntityMetadata<T>, allowScalar?: boolean, convertCustomTypes?: boolean): any;
     static getPrimaryKeyCond<T>(entity: T, primaryKeys: EntityKey<T>[]): Record<string, Primary<T>> | null;
     /**
      * Maps nested FKs from `[1, 2, 3]` to `[1, [2, 3]]`.
      */
     static mapFlatCompositePrimaryKey(fk: Primary<any>[], prop: EntityProperty, fieldNames?: string[], idx?: number): Primary<any> | Primary<any>[];
     static getPrimaryKeyCondFromArray<T extends object>(pks: Primary<T>[], meta: EntityMetadata<T>): Record<string, Primary<T>>;
-    static getOrderedPrimaryKeys<T>(id: Primary<T> | Record<string, Primary<T>>, meta: EntityMetadata<T>, platform?: Platform, convertCustomTypes?: boolean): Primary<T>[];
+    static getOrderedPrimaryKeys<T>(id: Primary<T> | Record<string, Primary<T>>, meta: EntityMetadata<T>, platform?: Platform, convertCustomTypes?: boolean, allowScalar?: boolean): Primary<T>[];
     /**
      * Checks whether given object is an entity instance.
      */

package/utils/Utils.js

@@ -498,6 +498,7 @@ class Utils {
     static splitPrimaryKeys(key) {
         return key.split(this.PK_SEPARATOR);
     }
+    // TODO v7: remove support for `primaryKeys: string[]`
     static getPrimaryKeyValues(entity, primaryKeys, allowScalar = false, convertCustomTypes = false) {
         /* istanbul ignore next */
         if (entity == null) {
@@ -509,9 +510,24 @@ class Utils {
             }
             return val;
         }
-        const pk = Utils.isEntity(entity, true)
-            ? (0, wrap_1.helper)(entity).getPrimaryKey(convertCustomTypes)
-            : primaryKeys.reduce((o, pk) => { o[pk] = entity[pk]; return o; }, {});
+        const meta = Array.isArray(primaryKeys) ? undefined : primaryKeys;
+        primaryKeys = Array.isArray(primaryKeys) ? primaryKeys : meta.primaryKeys;
+        let pk;
+        if (Utils.isEntity(entity, true)) {
+            pk = (0, wrap_1.helper)(entity).getPrimaryKey(convertCustomTypes);
+        }
+        else {
+            pk = primaryKeys.reduce((o, pk) => {
+                const targetMeta = meta?.properties[pk].targetMeta;
+                if (targetMeta && Utils.isPlainObject(entity[pk])) {
+                    o[pk] = Utils.getPrimaryKeyValues(entity[pk], targetMeta, allowScalar, convertCustomTypes);
+                }
+                else {
+                    o[pk] = entity[pk];
+                }
+                return o;
+            }, {});
+        }
         if (primaryKeys.length > 1) {
             return toArray(pk);
         }
@@ -561,7 +577,7 @@ class Utils {
             return o;
         }, {});
     }
-    static getOrderedPrimaryKeys(id, meta, platform, convertCustomTypes = false) {
+    static getOrderedPrimaryKeys(id, meta, platform, convertCustomTypes = false, allowScalar = false) {
         const data = (Utils.isPrimaryKey(id) ? { [meta.primaryKeys[0]]: id } : id);
         const pks = meta.primaryKeys.map((pk, idx) => {
             const prop = meta.properties[pk];
@@ -571,11 +587,14 @@ class Utils {
                 value = prop.customType.convertToJSValue(value, platform);
             }
             if (prop.kind !== enums_1.ReferenceKind.SCALAR && prop.targetMeta) {
-                const value2 = this.getOrderedPrimaryKeys(value, prop.targetMeta, platform, convertCustomTypes);
+                const value2 = this.getOrderedPrimaryKeys(value, prop.targetMeta, platform, convertCustomTypes, allowScalar);
                 value = value2.length > 1 ? value2 : value2[0];
             }
             return value;
         });
+        if (allowScalar && pks.length === 1) {
+            return pks[0];
+        }
         // we need to flatten the PKs as composite PKs can be build from another composite PKs
         // and this method is used to get the PK hash in identity map, that expects flat array
         return Utils.flatten(pks);