@mikro-orm/core 7.0.0-dev.8 → 7.0.0-dev.81

package/utils/TransactionManager.d.ts

@@ -0,0 +1,65 @@
+import type { EntityManager } from '../EntityManager.js';
+import { type TransactionOptions } from '../enums.js';
+/**
+ * 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,223 @@
+import { ReferenceKind, TransactionPropagation } from '../enums.js';
+import { TransactionEventBroadcaster } from '../events/TransactionEventBroadcaster.js';
+import { TransactionContext } from '../utils/TransactionContext.js';
+import { ChangeSetType } from '../unit-of-work/ChangeSet.js';
+import { TransactionStateError } from '../errors.js';
+import { helper } from '../entity/wrap.js';
+/**
+ * Manages transaction lifecycle and propagation for EntityManager.
+ */
+export 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);
+        options.propagation ??= TransactionPropagation.NESTED;
+        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 TransactionPropagation.NOT_SUPPORTED:
+                return this.executeWithoutTransaction(em, cb, options);
+            case TransactionPropagation.REQUIRES_NEW:
+                return this.executeWithNewTransaction(em, cb, options, hasExistingTransaction);
+            case TransactionPropagation.REQUIRED:
+                if (hasExistingTransaction) {
+                    return cb(em);
+                }
+                return this.createNewTransaction(em, cb, options);
+            case TransactionPropagation.NESTED:
+                if (hasExistingTransaction) {
+                    return this.executeNestedTransaction(em, cb, options);
+                }
+                return this.createNewTransaction(em, cb, options);
+            case TransactionPropagation.SUPPORTS:
+                if (hasExistingTransaction) {
+                    return cb(em);
+                }
+                return this.executeWithoutTransaction(em, cb, options);
+            case TransactionPropagation.MANDATORY:
+                if (!hasExistingTransaction) {
+                    throw TransactionStateError.requiredTransactionNotFound(propagation);
+                }
+                return cb(em);
+            case TransactionPropagation.NEVER:
+                if (hasExistingTransaction) {
+                    throw TransactionStateError.transactionNotAllowed(propagation);
+                }
+                return this.executeWithoutTransaction(em, cb, options);
+            default:
+                throw 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) {
+        const parentUoW = parent.getUnitOfWork(false);
+        // perf: if parent is empty, we can just move all entities from the fork to skip the `em.merge` overhead
+        if (parentUoW.getIdentityMap().keys().length === 0) {
+            for (const entity of fork.getUnitOfWork(false).getIdentityMap()) {
+                parentUoW.getIdentityMap().store(entity);
+                helper(entity).__em = parent;
+            }
+            return;
+        }
+        for (const entity of fork.getUnitOfWork(false).getIdentityMap()) {
+            const wrapped = helper(entity);
+            const meta = wrapped.__meta;
+            // eslint-disable-next-line dot-notation
+            const parentEntity = parentUoW.getById(meta.className, wrapped.getPrimaryKey(), parent['_schema'], true);
+            if (parentEntity && parentEntity !== entity) {
+                const parentWrapped = helper(parentEntity);
+                parentWrapped.__data = wrapped.__data;
+                parentWrapped.__originalEntityData = wrapped.__originalEntityData;
+                for (const prop of meta.hydrateProps) {
+                    if (prop.kind === ReferenceKind.SCALAR) {
+                        parentEntity[prop.name] = entity[prop.name];
+                    }
+                }
+            }
+            else {
+                parentUoW.merge(entity, new Set([entity]));
+            }
+        }
+    }
+    /**
+     * 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 === ChangeSetType.DELETE || cs.type === 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 TransactionEventBroadcaster(fork, undefined);
+        return 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;
+    }
+}

package/utils/Utils.d.ts

@@ -1,9 +1,7 @@
-import { type GlobbyOptions } from 'globby';
-import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, IMetadataStorage, Primary } from '../typings.js';
+import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, Primary } from '../typings.js';
 import type { Collection } from '../entity/Collection.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { ScalarReference } from '../entity/Reference.js';
-export declare const ObjectBindingPattern: unique symbol;
 export declare function compareObjects(a: any, b: any): boolean;
 export declare function compareArrays(a: any[] | string, b: any[] | string): boolean;
 export declare function compareBooleans(a: unknown, b: unknown): boolean;
@@ -16,32 +14,14 @@ export declare function parseJsonSafe<T = unknown>(value: unknown): T;
 export declare class Utils {
     static readonly PK_SEPARATOR = "~~~";
     static dynamicImportProvider: (id: string) => Promise<any>;
-    /**
-     * Checks if the argument is not undefined
-     */
-    static isDefined<T = Record<string, unknown>>(data: any): data is T;
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
     static isObject<T = Dictionary>(o: any): o is T;
-    /**
-     * Relation decorators allow using two signatures
-     * - using first parameter as options object
-     * - using all parameters
-     *
-     * This function validates those two ways are not mixed and returns the final options object.
-     * If the second way is used, we always consider the last parameter as options object.
-     * @internal
-     */
-    static processDecoratorParameters<T>(params: Dictionary): T;
-    /**
-     * Checks if the argument is instance of `Object`, but not one of the blacklisted types. Returns false for arrays.
-     */
-    static isNotObject<T = Dictionary>(o: any, not: any[]): o is T;
     /**
      * Removes `undefined` properties (recursively) so they are not saved as nulls
      */
-    static dropUndefinedProperties<T = Dictionary | unknown[]>(o: any, value?: undefined | null, visited?: Set<unknown>): void;
+    static dropUndefinedProperties(o: any, value?: undefined | null, visited?: Set<unknown>): void;
     /**
      * Returns the number of properties on `obj`. This is 20x faster than Object.keys(obj).length.
      * @see https://github.com/deepkit/deepkit-framework/blob/master/packages/core/src/core.ts
@@ -52,14 +32,6 @@ export declare class Utils {
      * @see https://github.com/deepkit/deepkit-framework/blob/master/packages/core/src/core.ts
      */
     static hasObjectKeys(object: Dictionary): boolean;
-    /**
-     * Checks if the argument is string
-     */
-    static isString(s: any): s is string;
-    /**
-     * Checks if the argument is number
-     */
-    static isNumber<T = number>(s: any): s is T;
     /**
      * Checks if arguments are deeply (but not strictly) equal.
      */
@@ -80,11 +52,6 @@ export declare class Utils {
      * Merges all sources into the target recursively.
      */
     private static _merge;
-    static getRootEntity(metadata: IMetadataStorage, meta: EntityMetadata): EntityMetadata;
-    /**
-     * Computes difference between two objects, ignoring items missing in `b`.
-     */
-    static diff(a: Dictionary, b: Dictionary): Record<keyof (typeof a & typeof b), any>;
     /**
      * Creates deep copy of given object.
      */
@@ -102,26 +69,11 @@ export declare class Utils {
      */
     static renameKey<T>(payload: T, from: string | keyof T, to: string): void;
     /**
-     * Returns array of functions argument names. Uses `esprima` for source code analysis.
-     */
-    static tokenize(func: {
-        toString(): string;
-    } | string | {
-        type: string;
-        value: string;
-    }[]): {
-        type: string;
-        value: string;
-    }[];
-    /**
-     * Returns array of functions argument names. Uses `esprima` for source code analysis.
+     * Returns array of functions argument names. Uses basic regex for source code analysis, might not work with advanced syntax.
      */
-    static getParamNames(func: {
+    static getConstructorParams(func: {
         toString(): string;
-    } | string | {
-        type: string;
-        value: string;
-    }[], methodName?: string): string[];
+    }): string[] | undefined;
     /**
      * Checks whether the argument looks like primary key (string, number or ObjectId).
      */
@@ -134,14 +86,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, meta: 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.
      */
@@ -150,12 +102,6 @@ export declare class Utils {
      * Checks whether given object is a scalar reference.
      */
     static isScalarReference<T = unknown>(data: any, allowReference?: boolean): data is ScalarReference<any> & {};
-    /**
-     * Checks whether the argument is ObjectId instance
-     */
-    static isObjectID(key: any): key is {
-        toHexString: () => string;
-    };
     /**
      * Checks whether the argument is empty (array without items, object without keys or falsy value).
      */
@@ -169,11 +115,6 @@ export declare class Utils {
      * Tries to detect TypeScript support.
      */
     static detectTypeScriptSupport(): boolean;
-    /**
-     * Uses some dark magic to get source path to caller where decorator is used.
-     * Analyses stack trace of error created inside the function call.
-     */
-    static lookupPathFromDecorator(name: string, stack?: string[]): string;
     /**
      * Gets the type of the argument.
      */
@@ -212,53 +153,23 @@ export declare class Utils {
     static findDuplicates<T>(items: T[]): T[];
     static removeDuplicates<T>(items: T[]): T[];
     static randomInt(min: number, max: number): number;
-    static pathExists(path: string, options?: GlobbyOptions): Promise<boolean>;
     /**
      * Extracts all possible values of a TS enum. Works with both string and numeric enums.
      */
     static extractEnumValues(target: Dictionary): (string | number)[];
     static flatten<T>(arrays: T[][]): T[];
     static isOperator(key: PropertyKey, includeGroupOperators?: boolean): boolean;
-    static isGroupOperator(key: PropertyKey): boolean;
-    static isArrayOperator(key: PropertyKey): boolean;
-    static isJsonKeyOperator(key: PropertyKey): boolean;
     static hasNestedKey(object: unknown, key: string): boolean;
-    static getGlobalStorage(namespace: string): Dictionary;
-    /**
-     * Require a module from a specific location
-     * @param id The module to require
-     * @param [from] Location to start the node resolution
-     */
-    static requireFrom<T extends Dictionary>(id: string, from?: string): T;
     static dynamicImport<T = any>(id: string): Promise<T>;
-    static setDynamicImportProvider(provider: (id: string) => Promise<unknown>): void;
-    static ensureDir(path: string): void;
-    static pathExistsSync(path: string): boolean;
-    static readJSONSync(path: string): Dictionary;
     static getORMVersion(): string;
     static createFunction(context: Map<string, any>, code: string): any;
     static callCompiledFunction<T extends unknown[], R>(fn: (...args: T) => R, ...args: T): R;
-    /**
-     * @see https://github.com/mikro-orm/mikro-orm/issues/840
-     */
-    static propertyDecoratorReturnValue(): any;
     static unwrapProperty<T>(entity: T, meta: EntityMetadata<T>, prop: EntityProperty<T>, payload?: boolean): [unknown, number[]][];
     static setPayloadProperty<T>(entity: EntityDictionary<T>, meta: EntityMetadata<T>, prop: EntityProperty<T>, value: unknown, idx: number[]): void;
-    static tryRequire<T extends Dictionary = any>({ module, from, allowError, warning }: {
-        module: string;
-        warning: string;
-        from?: string;
-        allowError?: string;
-    }): T | undefined;
     static tryImport<T extends Dictionary = any>({ module, warning }: {
         module: string;
-        warning: string;
+        warning?: string;
     }): Promise<T | undefined>;
-    static stripRelativePath(str: string): string;
-    /**
-     * simple process.argv parser, supports only properties with long names, prefixed with `--`
-     */
-    static parseArgs<T extends Dictionary = Dictionary>(): T;
     static xor(a: boolean, b: boolean): boolean;
     static keys<T extends object>(obj: T): (keyof T)[];
     static values<T extends object>(obj: T): T[keyof T][];