@mikro-orm/core 6.3.14-dev.30 → 6.3.14-dev.32

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.30",
+  "version": "6.3.14-dev.32",
   "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.30",
+    "mikro-orm": "6.3.14-dev.32",
     "reflect-metadata": "0.2.2"
   }
 }

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);
+}