@mikro-orm/core 7.0.0-dev.6 → 7.0.0-dev.61

package/utils/RawQueryFragment.js

@@ -8,7 +8,6 @@ export class RawQueryFragment {
     static #storage = new AsyncLocalStorage();
     static #index = 0n;
     static cloneRegistry;
-    #assigned = false;
     #used = 0;
     #key;
     constructor(sql, params = []) {
@@ -17,11 +16,6 @@ export class RawQueryFragment {
         this.#key = `[raw]: ${this.sql} (#${RawQueryFragment.#index++})`;
     }
     as(alias) {
-        // TODO: to be removed in v7
-        /* istanbul ignore next */
-        if (alias.startsWith('`') || alias.startsWith('"')) {
-            return new RawQueryFragment(`${this.sql} as ${alias}`, this.params);
-        }
         return new RawQueryFragment(`${this.sql} as ??`, [...this.params, alias]);
     }
     valueOf() {
@@ -35,13 +29,6 @@ export class RawQueryFragment {
         this.#used++;
         return this.#key;
     }
-    /** @internal */
-    assign() {
-        if (this.#assigned) {
-            throw new Error(`Cannot reassign already used RawQueryFragment: '${this.sql}'`);
-        }
-        this.#assigned = true;
-    }
     clone() {
         RawQueryFragment.cloneRegistry?.add(this.#key);
         return new RawQueryFragment(this.sql, this.params);
@@ -147,6 +134,24 @@ export const ALIAS_REPLACEMENT_RE = '\\[::alias::\\]';
  * ```ts
  * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
  * ```
+ *
+ * The `raw` helper can be used within indexes and uniques to write database-agnostic SQL expressions. In that case, you can use `'??'` to tag your database identifiers (table name, column names, index name, ...) inside your expression, and pass those identifiers as a second parameter to the `raw` helper. Internally, those will automatically be quoted according to the database in use:
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("country")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`country`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => raw(`create index ?? on ?? (??)`, ['custom_idx_on_name', table, columns.name]) })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ *
+ * You can also use the `quote` tag function to write database-agnostic SQL expressions. The end-result is the same as using the `raw` function regarding database identifiers quoting, only to have a more elegant expression syntax:
+ *
+ * ```ts
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
  */
 export function raw(sql, params) {
     if (sql instanceof RawQueryFragment) {
@@ -205,3 +210,19 @@ sql.ref = (...keys) => raw('??', [keys.join('.')]);
 sql.now = (length) => raw('current_timestamp' + (length == null ? '' : `(${length})`));
 sql.lower = (key) => createSqlFunction('lower', key);
 sql.upper = (key) => createSqlFunction('upper', key);
+/**
+ * Tag function providing quoting of db identifiers (table name, columns names, index names, ...).
+ *
+ * Within the template literal on which the tag function is applied, all placeholders are considered to be database identifiers, and will thus be quoted as so according to the database in use.
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("name")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`name`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ */
+export function quote(expParts, ...values) {
+    return raw(expParts.join('??'), values);
+}

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 { 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;
@@ -102,26 +100,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.
+     * Returns array of functions argument names. Uses basic regex for source code analysis, might not work with advanced syntax.
      */
-    static tokenize(func: {
+    static getConstructorParams(func: {
         toString(): string;
-    } | string | {
-        type: string;
-        value: string;
-    }[]): {
-        type: string;
-        value: string;
-    }[];
-    /**
-     * Returns array of functions argument names. Uses `esprima` for source code analysis.
-     */
-    static getParamNames(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 +117,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.
      */
@@ -206,13 +189,14 @@ 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 glob(input: string | string[], cwd?: string): string[];
+    static pathExists(path: string): boolean;
     /**
      * Extracts all possible values of a TS enum. Works with both string and numeric enums.
      */
@@ -230,10 +214,15 @@ 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;
     static getORMVersion(): string;
     static createFunction(context: Map<string, any>, code: string): any;
@@ -246,19 +235,15 @@ export declare class Utils {
     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;
+        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][];