@mikro-orm/core 7.0.0-dev.3 → 7.0.0-dev.31

package/utils/TransactionManager.js

@@ -0,0 +1,220 @@
+import { 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);
+        // Set NESTED as the default propagation type
+        options.propagation ??= 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 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 = helper(entity).__data;
+                parentWrapped.__originalEntityData = helper(entity).__originalEntityData;
+            }
+            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,4 +1,4 @@
-import { type GlobbyOptions } from 'globby';
+import { type GlobOptions } from 'tinyglobby';
 import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, IMetadataStorage, Primary } from '../typings.js';
 import type { Collection } from '../entity/Collection.js';
 import type { Platform } from '../platforms/Platform.js';
@@ -15,7 +15,6 @@ export declare function equals(a: any, b: any): boolean;
 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
      */
@@ -134,14 +133,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.
      */
@@ -206,13 +205,13 @@ export declare class Utils {
      * If either `path` or `baseDir` are `file:` URLs, they are converted to local paths.
      */
     static absolutePath(path: string, baseDir?: string): string;
-    static hash(data: string, length?: number): string;
+    static hash(data: string, length?: number, algorithm?: 'md5' | 'sha256'): string;
     static runIfNotEmpty(clause: () => any, data: any): void;
     static defaultValue<T extends Dictionary>(prop: T, option: keyof T, defaultValue: any): void;
     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>;
+    static pathExists(path: string, options?: GlobOptions): Promise<boolean>;
     /**
      * Extracts all possible values of a TS enum. Works with both string and numeric enums.
      */
@@ -230,8 +229,13 @@ export declare class Utils {
      * @param [from] Location to start the node resolution
      */
     static requireFrom<T extends Dictionary>(id: string, from?: string): T;
+    /**
+     * Resolve path to a module.
+     * @param id The module to require
+     * @param [from] Location to start the node resolution
+     */
+    static resolveModulePath(id: string, from?: string): string;
     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;

package/utils/Utils.js

@@ -1,7 +1,6 @@
 import { createRequire } from 'node:module';
-import globby from 'globby';
+import { glob, isDynamicPattern } from 'tinyglobby';
 import { extname, isAbsolute, join, normalize, relative, resolve } from 'node:path';
-import { platform } from 'node:os';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
@@ -132,8 +131,6 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    /* v8 ignore next */
-    static dynamicImportProvider = (id) => import(id);
     /**
      * Checks if the argument is not undefined
      */
@@ -435,7 +432,11 @@ export class Utils {
             return data;
         }
         if (Utils.isEntity(data, true)) {
-            return helper(data).getPrimaryKey();
+            const wrapped = helper(data);
+            if (wrapped.__meta.compositePK) {
+                return wrapped.getPrimaryKeys();
+            }
+            return wrapped.getPrimaryKey();
         }
         if (strict && meta && Utils.getObjectKeysSize(data) !== meta.primaryKeys.length) {
             return null;
@@ -483,6 +484,7 @@ export 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) {
         /* v8 ignore next 3 */
         if (entity == null) {
@@ -494,9 +496,24 @@ export class Utils {
             }
             return val;
         }
-        const pk = Utils.isEntity(entity, true)
-            ? 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 = 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);
         }
@@ -546,7 +563,7 @@ export 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];
@@ -556,11 +573,14 @@ export class Utils {
                 value = prop.customType.convertToJSValue(value, platform);
             }
             if (prop.kind !== 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);
@@ -625,8 +645,12 @@ export class Utils {
             || !!process.env.TS_JEST // check if ts-jest is used (works only with v27.0.4+)
             || !!process.env.VITEST // check if vitest is used
             || !!process.versions.bun // check if bun is used
-            || process.argv.slice(1).some(arg => arg.includes('ts-node')) // registering ts-node runner
-            || process.execArgv.some(arg => arg === 'ts-node/esm'); // check for ts-node/esm module loader
+            || process.argv.slice(1).some(arg => arg.match(/\.([mc]?ts|tsx)$/)) // executing `.ts` file
+            || process.execArgv.some(arg => {
+                return arg.includes('ts-node') // check for ts-node loader
+                    || arg.includes('@swc-node/register') // check for swc-node/register loader
+                    || arg.includes('node_modules/tsx/'); // check for tsx loader
+            });
     }
     /**
      * Uses some dark magic to get source path to caller where decorator is used.
@@ -644,7 +668,8 @@ export class Utils {
         // but those are also present in node, so we need to check this only if they weren't found.
         if (line === -1) {
             // here we handle bun which stack is different from nodejs so we search for reflect-metadata
-            const reflectLine = stack.findIndex(line => Utils.normalizePath(line).includes('node_modules/reflect-metadata/Reflect.js'));
+            // Different bun versions might have different stack traces. The "last index" works for both 1.2.6 and 1.2.7.
+            const reflectLine = stack.findLastIndex(line => Utils.normalizePath(line).includes('node_modules/reflect-metadata/Reflect.js'));
             if (reflectLine === -1 || reflectLine + 2 >= stack.length || !stack[reflectLine + 1].includes('bun:wrap')) {
                 return name;
             }
@@ -761,8 +786,9 @@ export class Utils {
         }
         return Utils.normalizePath(path);
     }
-    static hash(data, length) {
-        const hash = createHash('md5').update(data).digest('hex');
+    static hash(data, length, algorithm) {
+        const hashAlgorithm = algorithm || 'sha256';
+        const hash = createHash(hashAlgorithm).update(data).digest('hex');
         if (length) {
             return hash.substring(0, length);
         }
@@ -795,8 +821,8 @@ export class Utils {
         return Math.round(Math.random() * (max - min)) + min;
     }
     static async pathExists(path, options = {}) {
-        if (globby.hasMagic(path)) {
-            const found = await globby(path, options);
+        if (isDynamicPattern(path)) {
+            const found = await glob(path, options);
             return found.length > 0;
         }
         return this.pathExistsSync(path);
@@ -863,22 +889,25 @@ export class Utils {
         }
         return createRequire(resolve(from))(id);
     }
-    static async dynamicImport(id) {
-        /* v8 ignore next 7 */
-        if (platform() === 'win32') {
-            try {
-                id = pathToFileURL(id).toString();
-            }
-            catch {
-                // ignore
-            }
+    /**
+     * Resolve path to a module.
+     * @param id The module to require
+     * @param [from] Location to start the node resolution
+     */
+    static resolveModulePath(id, from = process.cwd()) {
+        if (!extname(from)) {
+            from = join(from, '__fake.js');
         }
-        /* v8 ignore next */
-        return this.dynamicImportProvider(id);
+        const path = Utils.normalizePath(createRequire(resolve(from)).resolve(id));
+        const parts = path.split('/');
+        const idx = parts.lastIndexOf(id) + 1;
+        parts.splice(idx, parts.length - idx);
+        return parts.join('/');
     }
-    /* v8 ignore next 3 */
-    static setDynamicImportProvider(provider) {
-        this.dynamicImportProvider = provider;
+    static async dynamicImport(id) {
+        /* v8 ignore next */
+        const specifier = id.startsWith('file://') ? id : pathToFileURL(id).href;
+        return import(specifier);
     }
     static ensureDir(path) {
         if (!existsSync(path)) {
@@ -899,8 +928,13 @@ export class Utils {
             /* v8 ignore next 5 */
         }
         catch {
-            // this works in production build where we do not have the `src` folder
-            return this.requireFrom('../package.json', import.meta.dirname).version;
+            try {
+                // this works in production build where we do not have the `src` folder
+                return this.requireFrom('../package.json', import.meta.dirname).version;
+            }
+            catch {
+                return 'N/A';
+            }
         }
     }
     static createFunction(context, code) {

package/utils/index.d.ts

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

package/utils/index.js

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

package/utils/upsert-utils.js

@@ -71,7 +71,15 @@ export function getOnConflictReturningFields(meta, data, uniqueFields, options)
     if (!meta) {
         return '*';
     }
-    const keys = meta.comparableProps.filter(p => !p.lazy && !p.embeddable && Array.isArray(uniqueFields) && !uniqueFields.includes(p.name)).map(p => p.name);
+    const keys = meta.comparableProps.filter(p => {
+        if (p.lazy || p.embeddable) {
+            return false;
+        }
+        if (p.autoincrement) {
+            return true;
+        }
+        return Array.isArray(uniqueFields) && !uniqueFields.includes(p.name);
+    }).map(p => p.name);
     if (meta.versionProperty) {
         keys.push(meta.versionProperty);
     }