@mikro-orm/core 6.3.14-dev.31 → 6.3.14-dev.33

package/decorators/CreateRequestContext.d.ts

@@ -1,9 +1,3 @@
-import { MikroORM } from '../MikroORM';
-import { EntityManager } from '../EntityManager';
-import { EntityRepository } from '../entity/EntityRepository';
-export declare function CreateRequestContext<T>(getContext?: MikroORM | Promise<MikroORM> | ((type: T) => MikroORM | Promise<MikroORM> | EntityManager | EntityRepository<any> | {
-    getEntityManager(): EntityManager;
-}), respectExistingContext?: boolean): MethodDecorator;
-export declare function EnsureRequestContext<T>(getContext?: MikroORM | Promise<MikroORM> | ((type: T) => MikroORM | Promise<MikroORM> | EntityManager | EntityRepository<any> | {
-    getEntityManager(): EntityManager;
-})): MethodDecorator;
+import type { ContextProvider } from '../typings';
+export declare function CreateRequestContext<T extends object>(context?: ContextProvider<T>, respectExistingContext?: boolean): MethodDecorator;
+export declare function EnsureRequestContext<T extends object>(context?: ContextProvider<T>): MethodDecorator;

package/decorators/CreateRequestContext.js

@@ -2,59 +2,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateRequestContext = CreateRequestContext;
 exports.EnsureRequestContext = EnsureRequestContext;
-const MikroORM_1 = require("../MikroORM");
 const RequestContext_1 = require("../utils/RequestContext");
-const EntityManager_1 = require("../EntityManager");
-const EntityRepository_1 = require("../entity/EntityRepository");
+const resolveContextProvider_1 = require("../utils/resolveContextProvider");
 const TransactionContext_1 = require("../utils/TransactionContext");
-function CreateRequestContext(getContext, respectExistingContext = false) {
+function CreateRequestContext(context, respectExistingContext = false) {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
         descriptor.value = async function (...args) {
-            // Otherwise, the outer tx context would be preferred.
-            const txContext = TransactionContext_1.TransactionContext.currentTransactionContext();
-            const provider = txContext ? TransactionContext_1.TransactionContext : RequestContext_1.RequestContext;
-            let orm;
-            let em;
-            if (typeof getContext === 'function') {
-                const context = await getContext(this);
-                orm = context ?? await this.orm;
-                em = context ?? await this.em;
-            }
-            else if (getContext) {
-                orm = em = await getContext;
-            }
-            else {
-                orm = await this.orm;
-                em = await this.em;
-            }
-            const create = async (em) => {
-                // reuse existing context if available for given respect `contextName`
-                if (respectExistingContext && RequestContext_1.RequestContext.getEntityManager(em.name)) {
-                    return originalMethod.apply(this, args);
-                }
-                if (txContext) {
-                    em = em.fork({ useContext: true });
-                }
-                return await provider.create(em, () => {
-                    return originalMethod.apply(this, args);
-                });
-            };
-            if (em instanceof EntityManager_1.EntityManager) {
-                return await create(em);
-            }
-            if (orm instanceof EntityRepository_1.EntityRepository) {
-                return await create(orm.getEntityManager());
-            }
-            if (!(orm instanceof MikroORM_1.MikroORM)) {
+            const em = await (0, resolveContextProvider_1.resolveContextProvider)(this, context);
+            if (!em) {
                 const name = respectExistingContext ? 'EnsureRequestContext' : 'CreateRequestContext';
                 throw new Error(`@${name}() decorator can only be applied to methods of classes with \`orm: MikroORM\` property, \`em: EntityManager\` property, or with a callback parameter like \`@${name}(() => orm)\` that returns one of those types. The parameter will contain a reference to current \`this\`. Returning an EntityRepository from it is also supported.`);
             }
-            return await create(orm.em);
+            // reuse existing context if available for given respect `contextName`
+            if (respectExistingContext && RequestContext_1.RequestContext.getEntityManager(em.name)) {
+                return originalMethod.apply(this, args);
+            }
+            // Otherwise, the outer tx context would be preferred.
+            const txContext = TransactionContext_1.TransactionContext.currentTransactionContext();
+            const provider = txContext ? TransactionContext_1.TransactionContext : RequestContext_1.RequestContext;
+            return txContext
+                ? provider.create(em.fork({ useContext: true }), () => originalMethod.apply(this, args))
+                : provider.create(em, () => originalMethod.apply(this, args));
         };
         return descriptor;
     };
 }
-function EnsureRequestContext(getContext) {
-    return CreateRequestContext(getContext, true);
+function EnsureRequestContext(context) {
+    return CreateRequestContext(context, true);
 }

package/decorators/Transactional.d.ts

@@ -0,0 +1,13 @@
+import type { TransactionOptions } from '../enums';
+import type { ContextProvider } from '../typings';
+type TransactionalOptions<T> = TransactionOptions & {
+    context?: ContextProvider<T>;
+};
+/**
+ * This decorator wraps the method with `em.transactional()`, so you can provide `TransactionOptions` just like with `em.transactional()`.
+ * The difference is that you can specify the context in which the transaction begins by providing `context` option,
+ * and if omitted, the transaction will begin in the current context implicitly.
+ * It works on async functions and can be nested with `em.transactional()`.
+ */
+export declare function Transactional<T extends object>(options?: TransactionalOptions<T>): MethodDecorator;
+export {};

package/decorators/Transactional.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transactional = Transactional;
+const RequestContext_1 = require("../utils/RequestContext");
+const resolveContextProvider_1 = require("../utils/resolveContextProvider");
+const TransactionContext_1 = require("../utils/TransactionContext");
+/**
+ * This decorator wraps the method with `em.transactional()`, so you can provide `TransactionOptions` just like with `em.transactional()`.
+ * The difference is that you can specify the context in which the transaction begins by providing `context` option,
+ * and if omitted, the transaction will begin in the current context implicitly.
+ * It works on async functions and can be nested with `em.transactional()`.
+ */
+function Transactional(options = {}) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        if (originalMethod.constructor.name !== 'AsyncFunction') {
+            throw new Error('@Transactional() should be use with async functions');
+        }
+        descriptor.value = async function (...args) {
+            const { context, ...txOptions } = options;
+            const em = await (0, resolveContextProvider_1.resolveContextProvider)(this, context)
+                || TransactionContext_1.TransactionContext.getEntityManager()
+                || RequestContext_1.RequestContext.getEntityManager();
+            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.`);
+            }
+            return em.transactional(() => originalMethod.apply(this, args), txOptions);
+        };
+        return descriptor;
+    };
+}

package/decorators/index.d.ts

@@ -14,3 +14,4 @@ export * from './Embedded';
 export * from './Filter';
 export * from './CreateRequestContext';
 export * from './hooks';
+export * from './Transactional';

package/decorators/index.js

@@ -33,3 +33,4 @@ __exportStar(require("./Embedded"), exports);
 __exportStar(require("./Filter"), exports);
 __exportStar(require("./CreateRequestContext"), exports);
 __exportStar(require("./hooks"), exports);
+__exportStar(require("./Transactional"), exports);

package/index.mjs

@@ -162,6 +162,7 @@ export const TimeType = mod.TimeType;
 export const TinyIntType = mod.TinyIntType;
 export const TransactionContext = mod.TransactionContext;
 export const TransactionEventBroadcaster = mod.TransactionEventBroadcaster;
+export const Transactional = mod.Transactional;
 export const Type = mod.Type;
 export const Uint8ArrayType = mod.Uint8ArrayType;
 export const UnderscoreNamingStrategy = mod.UnderscoreNamingStrategy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.3.14-dev.31",
+  "version": "6.3.14-dev.33",
   "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.2.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.3.14-dev.31",
+    "mikro-orm": "6.3.14-dev.33",
     "reflect-metadata": "0.2.2"
   }
 }

package/serialization/EntitySerializer.js

@@ -111,7 +111,7 @@ class EntitySerializer {
         const parts = prop.split('.');
         prop = parts[0];
         const wrapped = (0, wrap_1.helper)(entity);
-        const property = wrapped.__meta.properties[prop];
+        const property = wrapped.__meta.properties[prop] ?? { name: prop };
         const serializer = property?.serializer;
         const value = entity[prop];
         // getter method
@@ -127,10 +127,10 @@ class EntitySerializer {
             return serializer(value);
         }
         if (Utils_1.Utils.isCollection(value)) {
-            return this.processCollection(prop, entity, options);
+            return this.processCollection(property, entity, options);
         }
         if (Utils_1.Utils.isEntity(value, true)) {
-            return this.processEntity(prop, entity, wrapped.__platform, options);
+            return this.processEntity(property, entity, wrapped.__platform, options);
         }
         if (Utils_1.Utils.isScalarReference(value)) {
             return value.unwrap();
@@ -158,17 +158,20 @@ class EntitySerializer {
         };
     }
     static processEntity(prop, entity, platform, options) {
-        const child = Reference_1.Reference.unwrapReference(entity[prop]);
+        const child = Reference_1.Reference.unwrapReference(entity[prop.name]);
         const wrapped = (0, wrap_1.helper)(child);
-        const populated = isPopulated(prop, options) && wrapped.isInitialized();
+        const populated = isPopulated(prop.name, options) && wrapped.isInitialized();
         const expand = populated || !wrapped.__managed;
         const meta = wrapped.__meta;
-        const childOptions = this.extractChildOptions(options, prop);
+        const childOptions = this.extractChildOptions(options, prop.name);
         const visible = meta.primaryKeys.filter(prop => isVisible(meta, prop, childOptions));
         if (expand) {
             return this.serialize(child, childOptions);
         }
-        const pk = wrapped.getPrimaryKey(true);
+        let pk = wrapped.getPrimaryKey();
+        if (prop.customType) {
+            pk = prop.customType.toJSON(pk, wrapped.__platform);
+        }
         if (options.forceObject || wrapped.__config.get('serialization').forceObject) {
             return Utils_1.Utils.primaryKeyToObject(meta, pk, visible);
         }
@@ -182,20 +185,24 @@ class EntitySerializer {
         return platform.normalizePrimaryKey(pk);
     }
     static processCollection(prop, entity, options) {
-        const col = entity[prop];
+        const col = entity[prop.name];
         if (!col.isInitialized()) {
             return undefined;
         }
         return col.getItems(false).map(item => {
-            const populated = isPopulated(prop, options);
+            const populated = isPopulated(prop.name, options);
             const wrapped = (0, wrap_1.helper)(item);
             if (populated || !wrapped.__managed) {
-                return this.serialize(item, this.extractChildOptions(options, prop));
+                return this.serialize(item, this.extractChildOptions(options, prop.name));
+            }
+            let pk = wrapped.getPrimaryKey();
+            if (prop.customType) {
+                pk = prop.customType.toJSON(pk, wrapped.__platform);
             }
             if (options.forceObject || wrapped.__config.get('serialization').forceObject) {
-                return Utils_1.Utils.primaryKeyToObject(wrapped.__meta, wrapped.getPrimaryKey(true));
+                return Utils_1.Utils.primaryKeyToObject(wrapped.__meta, pk);
             }
-            return (0, wrap_1.helper)(item).getPrimaryKey();
+            return pk;
         });
     }
 }

package/serialization/EntityTransformer.js

@@ -108,7 +108,7 @@ class EntityTransformer {
     }
     static processProperty(prop, entity, raw, populated) {
         const wrapped = (0, wrap_1.helper)(entity);
-        const property = wrapped.__meta.properties[prop];
+        const property = wrapped.__meta.properties[prop] ?? { name: prop };
         const serializer = property?.serializer;
         const value = entity[prop];
         // getter method
@@ -123,10 +123,10 @@ class EntityTransformer {
             return serializer(value);
         }
         if (Utils_1.Utils.isCollection(value)) {
-            return EntityTransformer.processCollection(prop, entity, raw, populated);
+            return EntityTransformer.processCollection(property, entity, raw, populated);
         }
         if (Utils_1.Utils.isEntity(value, true)) {
-            return EntityTransformer.processEntity(prop, entity, wrapped.__platform, raw, populated);
+            return EntityTransformer.processEntity(property, entity, wrapped.__platform, raw, populated);
         }
         if (Utils_1.Utils.isScalarReference(value)) {
             return value.unwrap();
@@ -151,7 +151,7 @@ class EntityTransformer {
         return value;
     }
     static processEntity(prop, entity, platform, raw, populated) {
-        const child = entity[prop];
+        const child = entity[prop.name];
         const wrapped = (0, wrap_1.helper)(child);
         const meta = wrapped.__meta;
         const visible = meta.primaryKeys.filter(prop => isVisible(meta, prop));
@@ -170,7 +170,10 @@ class EntityTransformer {
         if (wrapped.isInitialized() && isPopulated() && child !== entity) {
             return (0, wrap_1.wrap)(child).toJSON();
         }
-        const pk = wrapped.getPrimaryKey(true);
+        let pk = wrapped.getPrimaryKey();
+        if (prop.customType) {
+            pk = prop.customType.toJSON(pk, wrapped.__platform);
+        }
         if (wrapped.__config.get('serialization').forceObject) {
             return Utils_1.Utils.primaryKeyToObject(meta, pk, visible);
         }
@@ -184,7 +187,7 @@ class EntityTransformer {
         return platform.normalizePrimaryKey(pk);
     }
     static processCollection(prop, entity, raw, populated) {
-        const col = entity[prop];
+        const col = entity[prop.name];
         if (raw && col.isInitialized(true)) {
             return col.map(item => (0, wrap_1.helper)(item).toPOJO());
         }
@@ -193,13 +196,18 @@ class EntityTransformer {
         }
         if (col.isInitialized()) {
             const wrapped = (0, wrap_1.helper)(entity);
-            if (wrapped.__config.get('serialization').forceObject) {
-                return col.map(item => {
-                    const wrapped = (0, wrap_1.helper)(item);
-                    return Utils_1.Utils.primaryKeyToObject(wrapped.__meta, wrapped.getPrimaryKey(true));
-                });
-            }
-            return col.map(i => (0, wrap_1.helper)(i).getPrimaryKey(true));
+            const forceObject = wrapped.__config.get('serialization').forceObject;
+            return col.map(item => {
+                const wrapped = (0, wrap_1.helper)(item);
+                const pk = wrapped.getPrimaryKey();
+                if (prop.customType) {
+                    return prop.customType.toJSON(pk, wrapped.__platform);
+                }
+                if (forceObject) {
+                    return Utils_1.Utils.primaryKeyToObject(wrapped.__meta, pk);
+                }
+                return pk;
+            });
         }
         return undefined;
     }

package/typings.d.ts

@@ -1,6 +1,7 @@
 import type { Transaction } from './connections';
 import { type Cascade, type DeferMode, type EventType, type LoadStrategy, type PopulatePath, type QueryOrderMap, ReferenceKind } from './enums';
 import { type AssignOptions, type Collection, type EntityFactory, type EntityIdentifier, type EntityLoaderOptions, type EntityRepository, Reference, type ScalarReference } from './entity';
+import type { MikroORM } from './MikroORM';
 import type { SerializationContext, SerializeOptions } from './serialization';
 import type { EntitySchema, MetadataStorage } from './metadata';
 import type { Type, types } from './types';
@@ -786,4 +787,10 @@ export interface Seeder<T extends Dictionary = Dictionary> {
 }
 export type ConnectionType = 'read' | 'write';
 export type MetadataProcessor = (metadata: EntityMetadata[], platform: Platform) => MaybePromise<void>;
+/**
+ * The type of context that the user intends to inject.
+ */
+export type ContextProvider<T> = MaybePromise<MikroORM> | ((type: T) => MaybePromise<MikroORM | EntityManager | EntityRepository<any> | {
+    getEntityManager(): EntityManager;
+}>);
 export {};

package/utils/resolveContextProvider.d.ts

@@ -0,0 +1,10 @@
+import { EntityManager } from '../EntityManager';
+import { MikroORM } from '../MikroORM';
+import type { ContextProvider, MaybePromise } from '../typings';
+/**
+ * Find `EntityManager` in provided context, or else in instance's `orm` or `em` properties.
+ */
+export declare function resolveContextProvider<T>(caller: T & {
+    orm?: MaybePromise<MikroORM>;
+    em?: MaybePromise<EntityManager>;
+}, provider?: ContextProvider<T>): Promise<EntityManager | undefined>;

package/utils/resolveContextProvider.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveContextProvider = resolveContextProvider;
+const EntityRepository_1 = require("../entity/EntityRepository");
+const EntityManager_1 = require("../EntityManager");
+const MikroORM_1 = require("../MikroORM");
+function getEntityManager(caller, context) {
+    if (context instanceof EntityManager_1.EntityManager) {
+        return context;
+    }
+    if (context instanceof EntityRepository_1.EntityRepository) {
+        return context.getEntityManager();
+    }
+    if (context instanceof MikroORM_1.MikroORM) {
+        return context.em;
+    }
+    if (caller.em instanceof EntityManager_1.EntityManager) {
+        return caller.em;
+    }
+    if (caller.orm instanceof MikroORM_1.MikroORM) {
+        return caller.orm.em;
+    }
+    return undefined;
+}
+/**
+ * Find `EntityManager` in provided context, or else in instance's `orm` or `em` properties.
+ */
+async function resolveContextProvider(caller, provider) {
+    const context = typeof provider === 'function' ? await provider(caller) : await provider;
+    return getEntityManager({ orm: await caller.orm, em: await caller.em }, context);
+}