@mikro-orm/core 7.0.9 → 7.0.10-dev.0

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;
 };
 /** 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,10 +91,7 @@ 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.
  *
@@ -114,20 +111,13 @@ 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, ...).
  *
@@ -141,12 +131,6 @@ 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

@@ -2,85 +2,83 @@ import { Utils } from './Utils.js';
 const rawSymbol = Symbol('RawQueryFragment');
 /** 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;
+    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 };
+    }
 }
 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);
+    return typeof value === 'object' && value !== null && Object.hasOwn(value, rawSymbol);
 }
 /** @internal */
 export const ALIAS_REPLACEMENT = '[::alias::]';
@@ -142,30 +140,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)) {
+    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);
+    }
     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.
@@ -185,19 +183,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, ...).
  *
@@ -212,5 +210,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,57 +3,58 @@ 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 }));
+    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);
     }
-    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;
 }

package/utils/TransactionContext.js

@@ -1,31 +1,31 @@
 import { createAsyncContext } from './AsyncContext.js';
 /** Uses `AsyncLocalStorage` to maintain a transaction-scoped EntityManager context across async operations. */
 export class TransactionContext {
-  em;
-  static storage = createAsyncContext();
-  id;
-  constructor(em) {
-    this.em = em;
-    this.id = this.em._id;
-  }
-  /**
-   * Creates new TransactionContext instance and runs the code inside its domain.
-   */
-  static create(em, next) {
-    const context = new TransactionContext(em);
-    return this.storage.run(context, next);
-  }
-  /**
-   * Returns current TransactionContext (if available).
-   */
-  static currentTransactionContext() {
-    return this.storage.getStore();
-  }
-  /**
-   * Returns current EntityManager (if available).
-   */
-  static getEntityManager(name = 'default') {
-    const context = TransactionContext.currentTransactionContext();
-    return context?.em.name === name ? context.em : undefined;
-  }
+    em;
+    static storage = createAsyncContext();
+    id;
+    constructor(em) {
+        this.em = em;
+        this.id = this.em._id;
+    }
+    /**
+     * Creates new TransactionContext instance and runs the code inside its domain.
+     */
+    static create(em, next) {
+        const context = new TransactionContext(em);
+        return this.storage.run(context, next);
+    }
+    /**
+     * Returns current TransactionContext (if available).
+     */
+    static currentTransactionContext() {
+        return this.storage.getStore();
+    }
+    /**
+     * Returns current EntityManager (if available).
+     */
+    static getEntityManager(name = 'default') {
+        const context = TransactionContext.currentTransactionContext();
+        return context?.em.name === name ? context.em : undefined;
+    }
 }