@mikro-orm/core 7.0.10-dev.9 → 7.0.10

package/utils/RawQueryFragment.d.ts

@@ -2,40 +2,40 @@ import type { AnyString, Dictionary, EntityKey } from '../typings.js';
 declare const rawFragmentSymbolBrand: unique symbol;
 /** Branded symbol type used as a unique key for tracking raw SQL fragments in object properties. */
 export type RawQueryFragmentSymbol = symbol & {
-    readonly [rawFragmentSymbolBrand]: true;
+  readonly [rawFragmentSymbolBrand]: true;
 };
+/** Checks whether the given value is a `RawQueryFragment` instance. */
+export declare function isRaw(value: unknown): value is RawQueryFragment;
 /** Represents a raw SQL fragment with optional parameters, usable as both a value and an object key via Symbol coercion. */
 export declare class RawQueryFragment<Alias extends string = string> {
-    #private;
-    readonly sql: string;
-    readonly params: unknown[];
-    /** @internal Type-level only - used to track the alias for type inference */
-    private readonly __alias?;
-    constructor(sql: string, params?: unknown[]);
-    /** Returns a unique symbol key for this fragment, creating and caching it on first access. */
-    get key(): RawQueryFragmentSymbol;
-    /** Creates a new fragment with an alias appended via `as ??`. */
-    as<A extends string>(alias: A): RawQueryFragment<A>;
-    [Symbol.toPrimitive](hint: 'string'): RawQueryFragmentSymbol;
-    get [Symbol.toStringTag](): string;
-    toJSON(): string;
-    clone(): this;
-    /** Checks whether the given value is a symbol that maps to a known raw query fragment. */
-    static isKnownFragmentSymbol(key: unknown): key is RawQueryFragmentSymbol;
-    /** Checks whether an object has any symbol keys that are known raw query fragments. */
-    static hasObjectFragments(object: unknown): boolean;
-    /** Checks whether the given value is a RawQueryFragment instance or a known fragment symbol. */
-    static isKnownFragment(key: unknown): key is RawQueryFragment | symbol;
-    /** Retrieves the RawQueryFragment associated with the given key (instance or symbol). */
-    static getKnownFragment(key: unknown): RawQueryFragment | undefined;
+  #private;
+  readonly sql: string;
+  readonly params: unknown[];
+  /** @internal Type-level only - used to track the alias for type inference */
+  private readonly __alias?;
+  constructor(sql: string, params?: unknown[]);
+  /** Returns a unique symbol key for this fragment, creating and caching it on first access. */
+  get key(): RawQueryFragmentSymbol;
+  /** Creates a new fragment with an alias appended via `as ??`. */
+  as<A extends string>(alias: A): RawQueryFragment<A>;
+  [Symbol.toPrimitive](hint: 'string'): RawQueryFragmentSymbol;
+  get [Symbol.toStringTag](): string;
+  toJSON(): string;
+  clone(): this;
+  /** Checks whether the given value is a symbol that maps to a known raw query fragment. */
+  static isKnownFragmentSymbol(key: unknown): key is RawQueryFragmentSymbol;
+  /** Checks whether an object has any symbol keys that are known raw query fragments. */
+  static hasObjectFragments(object: unknown): boolean;
+  /** Checks whether the given value is a RawQueryFragment instance or a known fragment symbol. */
+  static isKnownFragment(key: unknown): key is RawQueryFragment | symbol;
+  /** Retrieves the RawQueryFragment associated with the given key (instance or symbol). */
+  static getKnownFragment(key: unknown): RawQueryFragment | undefined;
 }
 export { RawQueryFragment as Raw };
-/** Checks whether the given value is a `RawQueryFragment` instance. */
-export declare function isRaw(value: unknown): value is RawQueryFragment;
 /** @internal */
-export declare const ALIAS_REPLACEMENT = "[::alias::]";
+export declare const ALIAS_REPLACEMENT = '[::alias::]';
 /** @internal */
-export declare const ALIAS_REPLACEMENT_RE = "\\[::alias::\\]";
+export declare const ALIAS_REPLACEMENT_RE = '\\[::alias::\\]';
 /**
  * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
  * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
@@ -91,7 +91,10 @@ export declare const ALIAS_REPLACEMENT_RE = "\\[::alias::\\]";
  * export class Author { ... }
  * ```
  */
-export declare function raw<R = RawQueryFragment & symbol, T extends object = any>(sql: EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): R;
+export declare function raw<R = RawQueryFragment & symbol, T extends object = any>(
+  sql: EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment,
+  params?: readonly unknown[] | Dictionary<unknown>,
+): R;
 /**
  * Alternative to the `raw()` helper allowing to use it as a tagged template function for the simple cases.
  *
@@ -111,13 +114,20 @@ export declare function raw<R = RawQueryFragment & symbol, T extends object = an
  */
 export declare function sql<R = RawQueryFragment & symbol>(sql: readonly string[], ...values: unknown[]): R;
 export declare namespace sql {
-    var ref: <T extends object = any>(...keys: string[]) => RawQueryFragment & symbol;
-    var now: (length?: number) => RawQueryFragment & symbol;
-    var lower: <R = RawQueryFragment<string> & symbol, T extends object = any>(key: string | ((alias: string) => string)) => R;
-    var upper: <R = RawQueryFragment<string> & symbol, T extends object = any>(key: string | ((alias: string) => string)) => R;
+  var ref: <T extends object = any>(...keys: string[]) => RawQueryFragment & symbol;
+  var now: (length?: number) => RawQueryFragment & symbol;
+  var lower: <R = RawQueryFragment<string> & symbol, T extends object = any>(
+    key: string | ((alias: string) => string),
+  ) => R;
+  var upper: <R = RawQueryFragment<string> & symbol, T extends object = any>(
+    key: string | ((alias: string) => string),
+  ) => R;
 }
 /** Creates a raw SQL function expression wrapping the given key (e.g., `lower(name)`). */
-export declare function createSqlFunction<R = RawQueryFragment & symbol, T extends object = any>(func: string, key: string | ((alias: string) => string)): R;
+export declare function createSqlFunction<R = RawQueryFragment & symbol, T extends object = any>(
+  func: string,
+  key: string | ((alias: string) => string),
+): R;
 /**
  * Tag function providing quoting of db identifiers (table name, columns names, index names, ...).
  *
@@ -131,6 +141,12 @@ export declare function createSqlFunction<R = RawQueryFragment & symbol, T exten
  * export class Author { ... }
  * ```
  */
-export declare function quote(expParts: readonly string[], ...values: (string | {
-    toString(): string;
-})[]): RawQueryFragment & symbol;
+export declare function quote(
+  expParts: readonly string[],
+  ...values: (
+    | string
+    | {
+        toString(): string;
+      }
+  )[]
+): RawQueryFragment & symbol;

package/utils/RawQueryFragment.js

@@ -1,85 +1,123 @@
 import { Utils } from './Utils.js';
-const rawSymbol = Symbol('RawQueryFragment');
+// Brand lives on the prototype so JSON payloads — whose proto is
+// `Object.prototype` — cannot forge it. String key, not a `Symbol.for(...)`,
+// so each CJS/ESM copy of this module independently installs it on its own
+// prototype without publishing a global key for the marker that controls raw
+// SQL assembly. The string is namespaced so it does not collide with property
+// names users might independently install on their own prototypes.
+const RAW_FRAGMENT_BRAND = '__mikroOrmRawFragment';
+// Back-references from a fragment's symbol key to the fragment itself, shared
+// across CJS/ESM module copies via globalThis: when one copy creates a fragment
+// via `raw('…')` and stores its symbol in a where-clause object key, the other
+// copy still needs to recover the original fragment to assemble SQL.
+const REGISTRY_KEY = Symbol.for('@mikro-orm/core/RawQueryFragment.references');
+const rawQueryReferences = (globalThis[REGISTRY_KEY] ??= new WeakMap());
+/** Checks whether the given value is a `RawQueryFragment` instance. */
+export function isRaw(value) {
+  if (value == null || typeof value !== 'object') {
+    return false;
+  }
+  // Fast path: intra-module instances and their subclasses.
+  // eslint-disable-next-line no-use-before-define
+  if (value instanceof RawQueryFragment) {
+    return true;
+  }
+  // Walk the prototype chain starting from the *prototype* (not the value) so
+  // own-property spoofing from JSON payloads cannot forge the brand. Stop at
+  // `Object.prototype`, which is never branded — that bails plain objects,
+  // JSON payloads, and built-ins like `Date`/`Array`/`Map` at depth 1.
+  for (let p = Object.getPrototypeOf(value); p != null && p !== Object.prototype; p = Object.getPrototypeOf(p)) {
+    if (Object.hasOwn(p, RAW_FRAGMENT_BRAND)) {
+      return true;
+    }
+  }
+  return false;
+}
 /** Represents a raw SQL fragment with optional parameters, usable as both a value and an object key via Symbol coercion. */
 export class RawQueryFragment {
-    sql;
-    params;
-    static #rawQueryReferences = new WeakMap();
-    #key;
-    constructor(sql, params = []) {
-        this.sql = sql;
-        this.params = params;
-        Object.defineProperty(this, rawSymbol, { value: true, enumerable: false });
-    }
-    /** Returns a unique symbol key for this fragment, creating and caching it on first access. */
-    get key() {
-        if (!this.#key) {
-            this.#key = Symbol(this.toJSON());
-            RawQueryFragment.#rawQueryReferences.set(this.#key, this);
-        }
-        return this.#key;
-    }
-    /** Creates a new fragment with an alias appended via `as ??`. */
-    as(alias) {
-        return new RawQueryFragment(`${this.sql} as ??`, [...this.params, alias]);
-    }
-    [Symbol.toPrimitive](hint) {
-        // if a fragment is converted to string (used as an object key), return a unique symbol
-        // and save a weak reference to map so we can retrieve it when compiling the query
-        if (hint === 'string') {
-            return this.key;
-        }
-        throw new Error(`Trying to modify raw SQL fragment: '${this.sql}'`);
-    }
-    get [Symbol.toStringTag]() {
-        return this.toJSON();
-    }
-    toJSON() {
-        return `raw('${this.sql}')`;
-    }
-    clone() {
-        return this;
-    }
-    /** Checks whether the given value is a symbol that maps to a known raw query fragment. */
-    static isKnownFragmentSymbol(key) {
-        return typeof key === 'symbol' && this.#rawQueryReferences.has(key);
-    }
-    /** Checks whether an object has any symbol keys that are known raw query fragments. */
-    static hasObjectFragments(object) {
-        return (Utils.isPlainObject(object) &&
-            Object.getOwnPropertySymbols(object).some(symbol => this.isKnownFragmentSymbol(symbol)));
-    }
-    /** Checks whether the given value is a RawQueryFragment instance or a known fragment symbol. */
-    static isKnownFragment(key) {
-        if (key instanceof RawQueryFragment) {
-            return true;
-        }
-        return this.isKnownFragmentSymbol(key);
-    }
-    /** Retrieves the RawQueryFragment associated with the given key (instance or symbol). */
-    static getKnownFragment(key) {
-        if (key instanceof RawQueryFragment) {
-            return key;
-        }
-        if (typeof key !== 'symbol') {
-            return;
-        }
-        return this.#rawQueryReferences.get(key);
-    }
-    /** @ignore */
-    /* v8 ignore next */
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        if (this.params) {
-            return { sql: this.sql, params: this.params };
-        }
-        return { sql: this.sql };
-    }
+  sql;
+  params;
+  #key;
+  constructor(sql, params = []) {
+    this.sql = sql;
+    this.params = params;
+  }
+  /** Returns a unique symbol key for this fragment, creating and caching it on first access. */
+  get key() {
+    if (!this.#key) {
+      this.#key = Symbol(this.toJSON());
+      rawQueryReferences.set(this.#key, this);
+    }
+    return this.#key;
+  }
+  /** Creates a new fragment with an alias appended via `as ??`. */
+  as(alias) {
+    return new RawQueryFragment(`${this.sql} as ??`, [...this.params, alias]);
+  }
+  [Symbol.toPrimitive](hint) {
+    // if a fragment is converted to string (used as an object key), return a unique symbol
+    // and save a weak reference to map so we can retrieve it when compiling the query
+    if (hint === 'string') {
+      return this.key;
+    }
+    throw new Error(`Trying to modify raw SQL fragment: '${this.sql}'`);
+  }
+  get [Symbol.toStringTag]() {
+    return this.toJSON();
+  }
+  toJSON() {
+    return `raw('${this.sql}')`;
+  }
+  clone() {
+    return this;
+  }
+  /** Checks whether the given value is a symbol that maps to a known raw query fragment. */
+  static isKnownFragmentSymbol(key) {
+    return typeof key === 'symbol' && rawQueryReferences.has(key);
+  }
+  /** Checks whether an object has any symbol keys that are known raw query fragments. */
+  static hasObjectFragments(object) {
+    return (
+      Utils.isPlainObject(object) &&
+      Object.getOwnPropertySymbols(object).some(symbol => this.isKnownFragmentSymbol(symbol))
+    );
+  }
+  /** Checks whether the given value is a RawQueryFragment instance or a known fragment symbol. */
+  static isKnownFragment(key) {
+    return isRaw(key) || this.isKnownFragmentSymbol(key);
+  }
+  /** Retrieves the RawQueryFragment associated with the given key (instance or symbol). */
+  static getKnownFragment(key) {
+    if (isRaw(key)) {
+      return key;
+    }
+    if (typeof key !== 'symbol') {
+      return;
+    }
+    return rawQueryReferences.get(key);
+  }
+  /** @ignore */
+  /* v8 ignore next */
+  [Symbol.for('nodejs.util.inspect.custom')]() {
+    if (this.params) {
+      return { sql: this.sql, params: this.params };
+    }
+    return { sql: this.sql };
+  }
 }
+// Non-enumerable so the brand is skipped by JSON/Object.keys/for-in, and locked
+// down (non-writable, non-configurable) so in-process code cannot delete or
+// overwrite it and thereby silently disable `isRaw` recognition for every
+// fragment in the process. Subclasses don't need mutability here — they inherit
+// the brand via the prototype chain, and sibling-copy classes install their own
+// brand on their own prototype (a different object), so lockdown only blocks
+// tampering with the canonical marker.
+Object.defineProperty(RawQueryFragment.prototype, RAW_FRAGMENT_BRAND, {
+  value: true,
+  writable: false,
+  configurable: false,
+});
 export { RawQueryFragment as Raw };
-/** Checks whether the given value is a `RawQueryFragment` instance. */
-export function isRaw(value) {
-    return typeof value === 'object' && value !== null && Object.hasOwn(value, rawSymbol);
-}
 /** @internal */
 export const ALIAS_REPLACEMENT = '[::alias::]';
 /** @internal */
@@ -140,30 +178,30 @@ export const ALIAS_REPLACEMENT_RE = '\\[::alias::\\]';
  * ```
  */
 export function raw(sql, params) {
-    if (sql instanceof RawQueryFragment) {
-        return sql;
-    }
-    if (sql instanceof Function) {
-        sql = sql(ALIAS_REPLACEMENT);
-    }
-    if (sql === '??' && Array.isArray(params)) {
-        return new RawQueryFragment(sql, params);
-    }
-    if (Array.isArray(sql)) {
-        // for composite FK we return just a simple string
-        return Utils.getPrimaryKeyHash(sql);
-    }
-    if (typeof params === 'object' && !Array.isArray(params)) {
-        const pairs = Object.entries(params);
-        const objectParams = [];
-        for (const [key, value] of pairs) {
-            sql = sql.replace(`:${key}:`, '??');
-            sql = sql.replace(`:${key}`, '?');
-            objectParams.push(value);
-        }
-        return new RawQueryFragment(sql, objectParams);
-    }
+  if (isRaw(sql)) {
+    return sql;
+  }
+  if (sql instanceof Function) {
+    sql = sql(ALIAS_REPLACEMENT);
+  }
+  if (sql === '??' && Array.isArray(params)) {
     return new RawQueryFragment(sql, params);
+  }
+  if (Array.isArray(sql)) {
+    // for composite FK we return just a simple string
+    return Utils.getPrimaryKeyHash(sql);
+  }
+  if (typeof params === 'object' && !Array.isArray(params)) {
+    const pairs = Object.entries(params);
+    const objectParams = [];
+    for (const [key, value] of pairs) {
+      sql = sql.replace(`:${key}:`, '??');
+      sql = sql.replace(`:${key}`, '?');
+      objectParams.push(value);
+    }
+    return new RawQueryFragment(sql, objectParams);
+  }
+  return new RawQueryFragment(sql, params);
 }
 /**
  * Alternative to the `raw()` helper allowing to use it as a tagged template function for the simple cases.
@@ -183,19 +221,19 @@ export function raw(sql, params) {
  * ```
  */
 export function sql(sql, ...values) {
-    return raw(sql.join('?'), values);
+  return raw(sql.join('?'), values);
 }
 /** Creates a raw SQL function expression wrapping the given key (e.g., `lower(name)`). */
 export function createSqlFunction(func, key) {
-    if (typeof key === 'string') {
-        return raw(`${func}(${key})`);
-    }
-    return raw(a => `${func}(${key(a)})`);
+  if (typeof key === 'string') {
+    return raw(`${func}(${key})`);
+  }
+  return raw(a => `${func}(${key(a)})`);
 }
 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);
+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, ...).
  *
@@ -210,5 +248,5 @@ sql.upper = (key) => createSqlFunction('upper', key);
  * ```
  */
 export function quote(expParts, ...values) {
-    return raw(expParts.join('??'), values);
+  return raw(expParts.join('??'), values);
 }

package/utils/RequestContext.d.ts

@@ -4,39 +4,39 @@ import { type LoggingOptions } from '../logging/Logger.js';
  * Uses `AsyncLocalStorage` to create async context that holds the current EM fork.
  */
 export declare class RequestContext {
-    readonly map: Map<string, EntityManager>;
-    private static storage;
-    private static counter;
-    readonly id: number;
-    constructor(map: Map<string, EntityManager>);
-    /**
-     * Returns default EntityManager.
-     */
-    get em(): EntityManager | undefined;
-    /**
-     * Creates new RequestContext instance and runs the code inside its domain.
-     * If the handler is async, the return value needs to be awaited.
-     * Uses `AsyncLocalStorage.run()`, suitable for regular express style middlewares with a `next` callback.
-     */
-    static create<T>(em: EntityManager | EntityManager[], next: (...args: any[]) => T, options?: CreateContextOptions): T;
-    /**
-     * Creates new RequestContext instance and runs the code inside its domain.
-     * If the handler is async, the return value needs to be awaited.
-     * Uses `AsyncLocalStorage.enterWith()`, suitable for elysia style middlewares without a `next` callback.
-     */
-    static enter(em: EntityManager | EntityManager[], options?: CreateContextOptions): void;
-    /**
-     * Returns current RequestContext (if available).
-     */
-    static currentRequestContext(): RequestContext | undefined;
-    /**
-     * Returns current EntityManager (if available).
-     */
-    static getEntityManager(name?: string): EntityManager | undefined;
-    private static createContext;
+  readonly map: Map<string, EntityManager>;
+  private static storage;
+  private static counter;
+  readonly id: number;
+  constructor(map: Map<string, EntityManager>);
+  /**
+   * Returns default EntityManager.
+   */
+  get em(): EntityManager | undefined;
+  /**
+   * Creates new RequestContext instance and runs the code inside its domain.
+   * If the handler is async, the return value needs to be awaited.
+   * Uses `AsyncLocalStorage.run()`, suitable for regular express style middlewares with a `next` callback.
+   */
+  static create<T>(em: EntityManager | EntityManager[], next: (...args: any[]) => T, options?: CreateContextOptions): T;
+  /**
+   * Creates new RequestContext instance and runs the code inside its domain.
+   * If the handler is async, the return value needs to be awaited.
+   * Uses `AsyncLocalStorage.enterWith()`, suitable for elysia style middlewares without a `next` callback.
+   */
+  static enter(em: EntityManager | EntityManager[], options?: CreateContextOptions): void;
+  /**
+   * Returns current RequestContext (if available).
+   */
+  static currentRequestContext(): RequestContext | undefined;
+  /**
+   * Returns current EntityManager (if available).
+   */
+  static getEntityManager(name?: string): EntityManager | undefined;
+  private static createContext;
 }
 /** Options for creating a new RequestContext, allowing schema and logger overrides. */
 export interface CreateContextOptions {
-    schema?: string;
-    loggerContext?: LoggingOptions;
+  schema?: string;
+  loggerContext?: LoggingOptions;
 }

package/utils/RequestContext.js

@@ -3,58 +3,57 @@ import { createAsyncContext } from './AsyncContext.js';
  * Uses `AsyncLocalStorage` to create async context that holds the current EM fork.
  */
 export class RequestContext {
-    map;
-    static storage = createAsyncContext();
-    static counter = 1;
-    id = RequestContext.counter++;
-    constructor(map) {
-        this.map = map;
-    }
-    /**
-     * Returns default EntityManager.
-     */
-    get em() {
-        return this.map.get('default');
-    }
-    /**
-     * Creates new RequestContext instance and runs the code inside its domain.
-     * If the handler is async, the return value needs to be awaited.
-     * Uses `AsyncLocalStorage.run()`, suitable for regular express style middlewares with a `next` callback.
-     */
-    static create(em, next, options = {}) {
-        const ctx = this.createContext(em, options);
-        return this.storage.run(ctx, next);
-    }
-    /**
-     * Creates new RequestContext instance and runs the code inside its domain.
-     * If the handler is async, the return value needs to be awaited.
-     * Uses `AsyncLocalStorage.enterWith()`, suitable for elysia style middlewares without a `next` callback.
-     */
-    static enter(em, options = {}) {
-        const ctx = this.createContext(em, options);
-        this.storage.enterWith(ctx);
-    }
-    /**
-     * Returns current RequestContext (if available).
-     */
-    static currentRequestContext() {
-        return this.storage.getStore();
-    }
-    /**
-     * Returns current EntityManager (if available).
-     */
-    static getEntityManager(name = 'default') {
-        const context = RequestContext.currentRequestContext();
-        return context ? context.map.get(name) : undefined;
-    }
-    static createContext(em, options = {}) {
-        const forks = new Map();
-        if (Array.isArray(em)) {
-            em.forEach(em => forks.set(em.name, em.fork({ useContext: true, ...options })));
-        }
-        else {
-            forks.set(em.name, em.fork({ useContext: true, ...options }));
-        }
-        return new RequestContext(forks);
+  map;
+  static storage = createAsyncContext();
+  static counter = 1;
+  id = RequestContext.counter++;
+  constructor(map) {
+    this.map = map;
+  }
+  /**
+   * Returns default EntityManager.
+   */
+  get em() {
+    return this.map.get('default');
+  }
+  /**
+   * Creates new RequestContext instance and runs the code inside its domain.
+   * If the handler is async, the return value needs to be awaited.
+   * Uses `AsyncLocalStorage.run()`, suitable for regular express style middlewares with a `next` callback.
+   */
+  static create(em, next, options = {}) {
+    const ctx = this.createContext(em, options);
+    return this.storage.run(ctx, next);
+  }
+  /**
+   * Creates new RequestContext instance and runs the code inside its domain.
+   * If the handler is async, the return value needs to be awaited.
+   * Uses `AsyncLocalStorage.enterWith()`, suitable for elysia style middlewares without a `next` callback.
+   */
+  static enter(em, options = {}) {
+    const ctx = this.createContext(em, options);
+    this.storage.enterWith(ctx);
+  }
+  /**
+   * Returns current RequestContext (if available).
+   */
+  static currentRequestContext() {
+    return this.storage.getStore();
+  }
+  /**
+   * Returns current EntityManager (if available).
+   */
+  static getEntityManager(name = 'default') {
+    const context = RequestContext.currentRequestContext();
+    return context ? context.map.get(name) : undefined;
+  }
+  static createContext(em, options = {}) {
+    const forks = new Map();
+    if (Array.isArray(em)) {
+      em.forEach(em => forks.set(em.name, em.fork({ useContext: true, ...options })));
+    } else {
+      forks.set(em.name, em.fork({ useContext: true, ...options }));
     }
+    return new RequestContext(forks);
+  }
 }

package/utils/TransactionContext.d.ts

@@ -1,20 +1,20 @@
 import type { EntityManager } from '../EntityManager.js';
 /** Uses `AsyncLocalStorage` to maintain a transaction-scoped EntityManager context across async operations. */
 export declare class TransactionContext {
-    readonly em: EntityManager;
-    private static storage;
-    readonly id: number;
-    constructor(em: EntityManager);
-    /**
-     * Creates new TransactionContext instance and runs the code inside its domain.
-     */
-    static create<T>(em: EntityManager, next: (...args: any[]) => T): T;
-    /**
-     * Returns current TransactionContext (if available).
-     */
-    static currentTransactionContext(): TransactionContext | undefined;
-    /**
-     * Returns current EntityManager (if available).
-     */
-    static getEntityManager(name?: string): EntityManager | undefined;
+  readonly em: EntityManager;
+  private static storage;
+  readonly id: number;
+  constructor(em: EntityManager);
+  /**
+   * Creates new TransactionContext instance and runs the code inside its domain.
+   */
+  static create<T>(em: EntityManager, next: (...args: any[]) => T): T;
+  /**
+   * Returns current TransactionContext (if available).
+   */
+  static currentTransactionContext(): TransactionContext | undefined;
+  /**
+   * Returns current EntityManager (if available).
+   */
+  static getEntityManager(name?: string): EntityManager | undefined;
 }