@mikro-orm/core 6.4.17-dev.94 → 6.4.17-dev.95

package/EntityManager.js

@@ -13,6 +13,7 @@ const enums_1 = require("./enums");
 const events_1 = require("./events");
 const errors_1 = require("./errors");
 const utils_2 = require("./entity/utils");
+const TransactionManager_1 = require("./utils/TransactionManager");
 /**
  * The EntityManager is the central access point to ORM functionality. It is a facade to all different ORM subsystems
  * such as UnitOfWork, Query Language, and Repository API.
@@ -970,38 +971,8 @@ class EntityManager {
         if (this.disableTransactions || em.disableTransactions) {
             return cb(em);
         }
-        const fork = em.fork({
-            clear: options.clear ?? false, // state will be merged once resolves
-            flushMode: options.flushMode,
-            cloneEventManager: true,
-            disableTransactions: options.ignoreNestedTransactions,
-            loggerContext: options.loggerContext,
-        });
-        options.ctx ??= em.transactionContext;
-        const propagateToUpperContext = !em.global || this.config.get('allowGlobalContext');
-        return utils_1.TransactionContext.create(fork, async () => {
-            return fork.getConnection().transactional(async (trx) => {
-                fork.transactionContext = trx;
-                if (propagateToUpperContext) {
-                    fork.eventManager.registerSubscriber({
-                        afterFlush(args) {
-                            args.uow.getChangeSets()
-                                .filter(cs => [unit_of_work_1.ChangeSetType.DELETE, unit_of_work_1.ChangeSetType.DELETE_EARLY].includes(cs.type))
-                                .forEach(cs => em.unitOfWork.unsetIdentity(cs.entity));
-                        },
-                    });
-                }
-                const ret = await cb(fork);
-                await fork.flush();
-                if (propagateToUpperContext) {
-                    // ensure all entities from inner context are merged to the upper one
-                    for (const entity of fork.unitOfWork.getIdentityMap()) {
-                        em.merge(entity, { disableContextResolution: true, keepIdentity: true, refresh: true });
-                    }
-                }
-                return ret;
-            }, { ...options, eventBroadcaster: new events_1.TransactionEventBroadcaster(fork, undefined, { topLevelTransaction: !options.ctx }) });
-        });
+        const manager = new TransactionManager_1.TransactionManager(this);
+        return manager.handle(cb, options);
     }
     /**
      * Starts new transaction bound to this EntityManager. Use `ctx` parameter to provide the parent when nesting transactions.

package/enums.d.ts

@@ -158,8 +158,18 @@ export declare enum EventType {
 }
 export declare const EventTypeMap: Record<EventType, number>;
 export type TransactionEventType = EventType.beforeTransactionStart | EventType.afterTransactionStart | EventType.beforeTransactionCommit | EventType.afterTransactionCommit | EventType.beforeTransactionRollback | EventType.afterTransactionRollback;
+export declare enum TransactionPropagation {
+    REQUIRED = "required",
+    REQUIRES_NEW = "requires_new",
+    NESTED = "nested",
+    NOT_SUPPORTED = "not_supported",
+    SUPPORTS = "supports",
+    MANDATORY = "mandatory",
+    NEVER = "never"
+}
 export interface TransactionOptions {
     ctx?: Transaction;
+    propagation?: TransactionPropagation;
     isolationLevel?: IsolationLevel;
     readOnly?: boolean;
     clear?: boolean;

package/enums.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeferMode = exports.PlainObject = exports.EventTypeMap = exports.EventType = exports.IsolationLevel = exports.LockMode = exports.DataloaderType = exports.LoadStrategy = exports.Cascade = exports.ReferenceKind = exports.SCALAR_TYPES = exports.QueryFlag = exports.QueryOrderNumeric = exports.QueryOrder = exports.JSON_KEY_OPERATORS = exports.ARRAY_OPERATORS = exports.QueryOperator = exports.GroupOperator = exports.PopulatePath = exports.PopulateHint = exports.FlushMode = void 0;
+exports.DeferMode = exports.PlainObject = exports.TransactionPropagation = exports.EventTypeMap = exports.EventType = exports.IsolationLevel = exports.LockMode = exports.DataloaderType = exports.LoadStrategy = exports.Cascade = exports.ReferenceKind = exports.SCALAR_TYPES = exports.QueryFlag = exports.QueryOrderNumeric = exports.QueryOrder = exports.JSON_KEY_OPERATORS = exports.ARRAY_OPERATORS = exports.QueryOperator = exports.GroupOperator = exports.PopulatePath = exports.PopulateHint = exports.FlushMode = void 0;
 var FlushMode;
 (function (FlushMode) {
     /** The `EntityManager` delays the flush until the current Transaction is committed. */
@@ -180,6 +180,16 @@ exports.EventTypeMap = Object.keys(EventType).reduce((a, b, i) => {
     a[b] = i;
     return a;
 }, {});
+var TransactionPropagation;
+(function (TransactionPropagation) {
+    TransactionPropagation["REQUIRED"] = "required";
+    TransactionPropagation["REQUIRES_NEW"] = "requires_new";
+    TransactionPropagation["NESTED"] = "nested";
+    TransactionPropagation["NOT_SUPPORTED"] = "not_supported";
+    TransactionPropagation["SUPPORTS"] = "supports";
+    TransactionPropagation["MANDATORY"] = "mandatory";
+    TransactionPropagation["NEVER"] = "never";
+})(TransactionPropagation || (exports.TransactionPropagation = TransactionPropagation = {}));
 class PlainObject {
 }
 exports.PlainObject = PlainObject;

package/errors.d.ts

@@ -67,3 +67,8 @@ export declare class NotFoundError<T extends AnyEntity = AnyEntity> extends Vali
     static findOneFailed(name: string, where: Dictionary | IPrimaryKey): NotFoundError;
     static findExactlyOneFailed(name: string, where: Dictionary | IPrimaryKey): NotFoundError;
 }
+export declare class TransactionStateError extends ValidationError {
+    static requiredTransactionNotFound(propagation: string): TransactionStateError;
+    static transactionNotAllowed(propagation: string): TransactionStateError;
+    static invalidPropagation(propagation: string): TransactionStateError;
+}

package/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotFoundError = exports.MetadataError = exports.OptimisticLockError = exports.CursorError = exports.ValidationError = void 0;
+exports.TransactionStateError = exports.NotFoundError = exports.MetadataError = exports.OptimisticLockError = exports.CursorError = exports.ValidationError = void 0;
 const node_util_1 = require("node:util");
 class ValidationError extends Error {
     entity;
@@ -232,3 +232,15 @@ class NotFoundError extends ValidationError {
     }
 }
 exports.NotFoundError = NotFoundError;
+class TransactionStateError extends ValidationError {
+    static requiredTransactionNotFound(propagation) {
+        return new TransactionStateError(`No existing transaction found for transaction marked with propagation "${propagation}"`);
+    }
+    static transactionNotAllowed(propagation) {
+        return new TransactionStateError(`Existing transaction found for transaction marked with propagation "${propagation}"`);
+    }
+    static invalidPropagation(propagation) {
+        return new TransactionStateError(`Unsupported transaction propagation type: ${propagation}`);
+    }
+}
+exports.TransactionStateError = TransactionStateError;

package/index.mjs

@@ -162,6 +162,9 @@ export const TimeType = mod.TimeType;
 export const TinyIntType = mod.TinyIntType;
 export const TransactionContext = mod.TransactionContext;
 export const TransactionEventBroadcaster = mod.TransactionEventBroadcaster;
+export const TransactionManager = mod.TransactionManager;
+export const TransactionPropagation = mod.TransactionPropagation;
+export const TransactionStateError = mod.TransactionStateError;
 export const Transactional = mod.Transactional;
 export const Type = mod.Type;
 export const Uint8ArrayType = mod.Uint8ArrayType;

package/package.json

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

package/utils/TransactionManager.d.ts

@@ -0,0 +1,65 @@
+import type { EntityManager } from '../EntityManager';
+import { type TransactionOptions } from '../enums';
+/**
+ * Manages transaction lifecycle and propagation for EntityManager.
+ */
+export declare class TransactionManager {
+    private readonly em;
+    constructor(em: EntityManager);
+    /**
+     * Main entry point for handling transactional operations with propagation support.
+     */
+    handle<T>(cb: (em: EntityManager) => T | Promise<T>, options?: TransactionOptions): Promise<T>;
+    /**
+     * Executes the callback with the specified propagation type.
+     */
+    private executeWithPropagation;
+    /**
+     * Suspends the current transaction and returns the suspended resources.
+     */
+    private suspendTransaction;
+    /**
+     * Resumes a previously suspended transaction.
+     */
+    private resumeTransaction;
+    /**
+     * Executes operation without transaction context.
+     */
+    private executeWithoutTransaction;
+    /**
+     * Creates new independent transaction, suspending any existing one.
+     */
+    private executeWithNewTransaction;
+    /**
+     * Creates new transaction context.
+     */
+    private createNewTransaction;
+    /**
+     * Executes nested transaction with savepoint.
+     */
+    private executeNestedTransaction;
+    /**
+     * Creates a fork of the EntityManager with the given options.
+     */
+    private createFork;
+    /**
+     * Determines if changes should be propagated to the upper context.
+     */
+    private shouldPropagateToUpperContext;
+    /**
+     * Merges entities from fork to parent EntityManager.
+     */
+    private mergeEntitiesToParent;
+    /**
+     * Registers a deletion handler to unset entity identities after flush.
+     */
+    private registerDeletionHandler;
+    /**
+     * Processes transaction execution.
+     */
+    private processTransaction;
+    /**
+     * Executes transaction workflow with entity synchronization.
+     */
+    private executeTransactionFlow;
+}

package/utils/TransactionManager.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionManager = void 0;
+const enums_1 = require("../enums");
+const events_1 = require("../events");
+const TransactionContext_1 = require("../utils/TransactionContext");
+const unit_of_work_1 = require("../unit-of-work");
+const errors_1 = require("../errors");
+/**
+ * Manages transaction lifecycle and propagation for EntityManager.
+ */
+class TransactionManager {
+    em;
+    constructor(em) {
+        this.em = em;
+    }
+    /**
+     * Main entry point for handling transactional operations with propagation support.
+     */
+    async handle(cb, options = {}) {
+        const em = this.em.getContext(false);
+        // Set NESTED as the default propagation type
+        options.propagation ??= enums_1.TransactionPropagation.NESTED;
+        // Set the context to the current transaction context if not already set
+        options.ctx ??= em.getTransactionContext();
+        const hasExistingTransaction = !!em.getTransactionContext();
+        return this.executeWithPropagation(options.propagation, em, cb, options, hasExistingTransaction);
+    }
+    /**
+     * Executes the callback with the specified propagation type.
+     */
+    async executeWithPropagation(propagation, em, cb, options, hasExistingTransaction) {
+        switch (propagation) {
+            case enums_1.TransactionPropagation.NOT_SUPPORTED:
+                return this.executeWithoutTransaction(em, cb, options);
+            case enums_1.TransactionPropagation.REQUIRES_NEW:
+                return this.executeWithNewTransaction(em, cb, options, hasExistingTransaction);
+            case enums_1.TransactionPropagation.REQUIRED:
+                if (hasExistingTransaction) {
+                    return cb(em);
+                }
+                return this.createNewTransaction(em, cb, options);
+            case enums_1.TransactionPropagation.NESTED:
+                if (hasExistingTransaction) {
+                    return this.executeNestedTransaction(em, cb, options);
+                }
+                return this.createNewTransaction(em, cb, options);
+            case enums_1.TransactionPropagation.SUPPORTS:
+                if (hasExistingTransaction) {
+                    return cb(em);
+                }
+                return this.executeWithoutTransaction(em, cb, options);
+            case enums_1.TransactionPropagation.MANDATORY:
+                if (!hasExistingTransaction) {
+                    throw errors_1.TransactionStateError.requiredTransactionNotFound(propagation);
+                }
+                return cb(em);
+            case enums_1.TransactionPropagation.NEVER:
+                if (hasExistingTransaction) {
+                    throw errors_1.TransactionStateError.transactionNotAllowed(propagation);
+                }
+                return this.executeWithoutTransaction(em, cb, options);
+            default:
+                throw errors_1.TransactionStateError.invalidPropagation(propagation);
+        }
+    }
+    /**
+     * Suspends the current transaction and returns the suspended resources.
+     */
+    suspendTransaction(em) {
+        const suspended = em.getTransactionContext();
+        em.resetTransactionContext();
+        return suspended;
+    }
+    /**
+     * Resumes a previously suspended transaction.
+     */
+    resumeTransaction(em, suspended) {
+        if (suspended != null) {
+            em.setTransactionContext(suspended);
+        }
+    }
+    /**
+     * Executes operation without transaction context.
+     */
+    async executeWithoutTransaction(em, cb, options) {
+        const suspended = this.suspendTransaction(em);
+        const fork = this.createFork(em, { ...options, disableTransactions: true });
+        const propagateToUpperContext = this.shouldPropagateToUpperContext(em);
+        try {
+            return await this.executeTransactionFlow(fork, cb, propagateToUpperContext, em);
+        }
+        finally {
+            this.resumeTransaction(em, suspended);
+        }
+    }
+    /**
+     * Creates new independent transaction, suspending any existing one.
+     */
+    async executeWithNewTransaction(em, cb, options, hasExistingTransaction) {
+        const fork = this.createFork(em, options);
+        let suspended = null;
+        // Suspend existing transaction if present
+        if (hasExistingTransaction) {
+            suspended = this.suspendTransaction(em);
+        }
+        const newOptions = { ...options, ctx: undefined };
+        try {
+            return await this.processTransaction(em, fork, cb, newOptions);
+        }
+        finally {
+            if (suspended != null) {
+                this.resumeTransaction(em, suspended);
+            }
+        }
+    }
+    /**
+     * Creates new transaction context.
+     */
+    async createNewTransaction(em, cb, options) {
+        const fork = this.createFork(em, options);
+        return this.processTransaction(em, fork, cb, options);
+    }
+    /**
+     * Executes nested transaction with savepoint.
+     */
+    async executeNestedTransaction(em, cb, options) {
+        const fork = this.createFork(em, options);
+        // Pass existing context to create savepoint
+        const nestedOptions = { ...options, ctx: em.getTransactionContext() };
+        return this.processTransaction(em, fork, cb, nestedOptions);
+    }
+    /**
+     * Creates a fork of the EntityManager with the given options.
+     */
+    createFork(em, options) {
+        return em.fork({
+            clear: options.clear ?? false,
+            flushMode: options.flushMode,
+            cloneEventManager: true,
+            disableTransactions: options.ignoreNestedTransactions,
+            loggerContext: options.loggerContext,
+        });
+    }
+    /**
+     * Determines if changes should be propagated to the upper context.
+     */
+    shouldPropagateToUpperContext(em) {
+        return !em.global || this.em.config.get('allowGlobalContext');
+    }
+    /**
+     * Merges entities from fork to parent EntityManager.
+     */
+    mergeEntitiesToParent(fork, parent) {
+        for (const entity of fork.getUnitOfWork(false).getIdentityMap()) {
+            parent.merge(entity, { disableContextResolution: true, keepIdentity: true, refresh: true });
+        }
+    }
+    /**
+     * Registers a deletion handler to unset entity identities after flush.
+     */
+    registerDeletionHandler(fork, parent) {
+        fork.getEventManager().registerSubscriber({
+            afterFlush: (args) => {
+                const deletionChangeSets = args.uow.getChangeSets()
+                    .filter(cs => cs.type === unit_of_work_1.ChangeSetType.DELETE || cs.type === unit_of_work_1.ChangeSetType.DELETE_EARLY);
+                for (const cs of deletionChangeSets) {
+                    parent.getUnitOfWork(false).unsetIdentity(cs.entity);
+                }
+            },
+        });
+    }
+    /**
+     * Processes transaction execution.
+     */
+    async processTransaction(em, fork, cb, options) {
+        const propagateToUpperContext = this.shouldPropagateToUpperContext(em);
+        const eventBroadcaster = new events_1.TransactionEventBroadcaster(fork, undefined, { topLevelTransaction: !options.ctx });
+        return TransactionContext_1.TransactionContext.create(fork, () => fork.getConnection().transactional(async (trx) => {
+            fork.setTransactionContext(trx);
+            return this.executeTransactionFlow(fork, cb, propagateToUpperContext, em);
+        }, { ...options, eventBroadcaster }));
+    }
+    /**
+     * Executes transaction workflow with entity synchronization.
+     */
+    async executeTransactionFlow(fork, cb, propagateToUpperContext, parentEm) {
+        if (!propagateToUpperContext) {
+            const ret = await cb(fork);
+            await fork.flush();
+            return ret;
+        }
+        // Setup: Register deletion handler before execution
+        this.registerDeletionHandler(fork, parentEm);
+        // Execute callback and flush
+        const ret = await cb(fork);
+        await fork.flush();
+        // Synchronization: Merge entities back to the parent
+        this.mergeEntitiesToParent(fork, parentEm);
+        return ret;
+    }
+}
+exports.TransactionManager = TransactionManager;

package/utils/index.d.ts

@@ -5,6 +5,7 @@ export * from './DataloaderUtils';
 export * from './Utils';
 export * from './RequestContext';
 export * from './TransactionContext';
+export * from './TransactionManager';
 export * from './QueryHelper';
 export * from './NullHighlighter';
 export * from './EntityComparator';

package/utils/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./DataloaderUtils"), exports);
 __exportStar(require("./Utils"), exports);
 __exportStar(require("./RequestContext"), exports);
 __exportStar(require("./TransactionContext"), exports);
+__exportStar(require("./TransactionManager"), exports);
 __exportStar(require("./QueryHelper"), exports);
 __exportStar(require("./NullHighlighter"), exports);
 __exportStar(require("./EntityComparator"), exports);