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

package/events/EventManager.d.ts

@@ -1,15 +1,32 @@
 import type { EntityMetadata } from '../typings.js';
 import type { EventArgs, EventSubscriber, FlushEventArgs, TransactionEventArgs } from './EventSubscriber.js';
 import { EventType, type TransactionEventType } from '../enums.js';
+/** Manages event subscribers and dispatches entity/flush/transaction lifecycle events. */
 export declare class EventManager {
-    #private;
-    constructor(subscribers: Iterable<EventSubscriber>);
-    registerSubscriber(subscriber: EventSubscriber): void;
-    getSubscribers(): Set<EventSubscriber>;
-    dispatchEvent<T extends object>(event: TransactionEventType, args: TransactionEventArgs, meta?: EntityMetadata<T>): unknown;
-    dispatchEvent<T extends object>(event: EventType.onInit, args: Partial<EventArgs<T>>, meta?: EntityMetadata<T>): unknown;
-    dispatchEvent<T extends object>(event: EventType, args: Partial<EventArgs<T> | FlushEventArgs>, meta?: EntityMetadata<T>): Promise<unknown>;
-    hasListeners<T>(event: EventType, meta: EntityMetadata<T>): boolean;
-    clone(): EventManager;
-    private getSubscribedEntities;
+  #private;
+  constructor(subscribers: Iterable<EventSubscriber>);
+  /** Registers an event subscriber and indexes its subscribed entities and event types. */
+  registerSubscriber(subscriber: EventSubscriber): void;
+  /** Returns the set of all registered event subscribers. */
+  getSubscribers(): Set<EventSubscriber>;
+  dispatchEvent<T extends object>(
+    event: TransactionEventType,
+    args: TransactionEventArgs,
+    meta?: EntityMetadata<T>,
+  ): unknown;
+  dispatchEvent<T extends object>(
+    event: EventType.onInit,
+    args: Partial<EventArgs<T>>,
+    meta?: EntityMetadata<T>,
+  ): unknown;
+  dispatchEvent<T extends object>(
+    event: EventType,
+    args: Partial<EventArgs<T> | FlushEventArgs>,
+    meta?: EntityMetadata<T>,
+  ): Promise<unknown>;
+  /** Checks whether there are any listeners (hooks or subscribers) for the given event type and entity. */
+  hasListeners<T>(event: EventType, meta: EntityMetadata<T>): boolean;
+  /** Creates a new EventManager with the same set of subscribers. */
+  clone(): EventManager;
+  private getSubscribedEntities;
 }

package/events/EventManager.js

@@ -1,84 +1,91 @@
 import { Utils } from '../utils/Utils.js';
 import { EventType, EventTypeMap } from '../enums.js';
+/** Manages event subscribers and dispatches entity/flush/transaction lifecycle events. */
 export class EventManager {
-    #listeners = {};
-    #entities = new Map();
-    #cache = new Map();
-    #subscribers = new Set();
-    constructor(subscribers) {
-        for (const subscriber of subscribers) {
-            this.registerSubscriber(subscriber);
-        }
+  #listeners = {};
+  #entities = new Map();
+  #cache = new Map();
+  #subscribers = new Set();
+  constructor(subscribers) {
+    for (const subscriber of subscribers) {
+      this.registerSubscriber(subscriber);
     }
-    registerSubscriber(subscriber) {
-        if (this.#subscribers.has(subscriber)) {
-            return;
-        }
-        this.#subscribers.add(subscriber);
-        this.#entities.set(subscriber, this.getSubscribedEntities(subscriber));
-        this.#cache.clear();
-        Utils.keys(EventType)
-            .filter(event => event in subscriber)
-            .forEach(event => {
-            this.#listeners[event] ??= new Set();
-            this.#listeners[event].add(subscriber);
-        });
+  }
+  /** Registers an event subscriber and indexes its subscribed entities and event types. */
+  registerSubscriber(subscriber) {
+    if (this.#subscribers.has(subscriber)) {
+      return;
     }
-    getSubscribers() {
-        return this.#subscribers;
+    this.#subscribers.add(subscriber);
+    this.#entities.set(subscriber, this.getSubscribedEntities(subscriber));
+    this.#cache.clear();
+    Utils.keys(EventType)
+      .filter(event => event in subscriber)
+      .forEach(event => {
+        this.#listeners[event] ??= new Set();
+        this.#listeners[event].add(subscriber);
+      });
+  }
+  /** Returns the set of all registered event subscribers. */
+  getSubscribers() {
+    return this.#subscribers;
+  }
+  dispatchEvent(event, args, meta) {
+    const listeners = [];
+    const entity = args.entity;
+    // execute lifecycle hooks first
+    meta ??= entity?.__meta;
+    const hooks = meta?.hooks[event] || [];
+    listeners.push(
+      ...hooks.map(hook => {
+        const prototypeHook = meta?.prototype[hook];
+        const handler = typeof hook === 'function' ? hook : (entity[hook] ?? prototypeHook);
+        return handler.bind(entity);
+      }),
+    );
+    for (const listener of this.#listeners[event] ?? new Set()) {
+      const entities = this.#entities.get(listener);
+      if (entities.size === 0 || !entity || entities.has(entity.constructor.name)) {
+        listeners.push(listener[event].bind(listener));
+      }
     }
-    dispatchEvent(event, args, meta) {
-        const listeners = [];
-        const entity = args.entity;
-        // execute lifecycle hooks first
-        meta ??= entity?.__meta;
-        const hooks = (meta?.hooks[event] || []);
-        listeners.push(...hooks.map(hook => {
-            const prototypeHook = meta?.prototype[hook];
-            const handler = typeof hook === 'function' ? hook : (entity[hook] ?? prototypeHook);
-            return handler.bind(entity);
-        }));
-        for (const listener of this.#listeners[event] ?? new Set()) {
-            const entities = this.#entities.get(listener);
-            if (entities.size === 0 || !entity || entities.has(entity.constructor.name)) {
-                listeners.push(listener[event].bind(listener));
-            }
-        }
-        if (event === EventType.onInit) {
-            for (const listener of listeners) {
-                void listener(args);
-            }
-            return;
-        }
-        return Utils.runSerial(listeners, listener => listener(args));
+    if (event === EventType.onInit) {
+      for (const listener of listeners) {
+        void listener(args);
+      }
+      return;
     }
-    hasListeners(event, meta) {
-        const cacheKey = meta._id + EventTypeMap[event];
-        if (this.#cache.has(cacheKey)) {
-            return this.#cache.get(cacheKey);
-        }
-        const hasHooks = meta.hooks[event]?.length;
-        if (hasHooks) {
-            this.#cache.set(cacheKey, true);
-            return true;
-        }
-        for (const listener of this.#listeners[event] ?? new Set()) {
-            const entities = this.#entities.get(listener);
-            if (entities.size === 0 || entities.has(meta.className)) {
-                this.#cache.set(cacheKey, true);
-                return true;
-            }
-        }
-        this.#cache.set(cacheKey, false);
-        return false;
+    return Utils.runSerial(listeners, listener => listener(args));
+  }
+  /** Checks whether there are any listeners (hooks or subscribers) for the given event type and entity. */
+  hasListeners(event, meta) {
+    const cacheKey = meta._id + EventTypeMap[event];
+    if (this.#cache.has(cacheKey)) {
+      return this.#cache.get(cacheKey);
     }
-    clone() {
-        return new EventManager(this.#subscribers);
+    const hasHooks = meta.hooks[event]?.length;
+    if (hasHooks) {
+      this.#cache.set(cacheKey, true);
+      return true;
     }
-    getSubscribedEntities(listener) {
-        if (!listener.getSubscribedEntities) {
-            return new Set();
-        }
-        return new Set(listener.getSubscribedEntities().map(name => Utils.className(name)));
+    for (const listener of this.#listeners[event] ?? new Set()) {
+      const entities = this.#entities.get(listener);
+      if (entities.size === 0 || entities.has(meta.className)) {
+        this.#cache.set(cacheKey, true);
+        return true;
+      }
     }
+    this.#cache.set(cacheKey, false);
+    return false;
+  }
+  /** Creates a new EventManager with the same set of subscribers. */
+  clone() {
+    return new EventManager(this.#subscribers);
+  }
+  getSubscribedEntities(listener) {
+    if (!listener.getSubscribedEntities) {
+      return new Set();
+    }
+    return new Set(listener.getSubscribedEntities().map(name => Utils.className(name)));
+  }
 }

package/events/EventSubscriber.d.ts

@@ -3,40 +3,44 @@ import type { EntityManager } from '../EntityManager.js';
 import type { UnitOfWork } from '../unit-of-work/UnitOfWork.js';
 import type { ChangeSet } from '../unit-of-work/ChangeSet.js';
 import type { Transaction } from '../connections/Connection.js';
+/** Arguments passed to entity lifecycle event hooks. */
 export interface EventArgs<T> {
-    entity: T;
-    em: EntityManager;
-    meta: EntityMetadata<T>;
-    changeSet?: ChangeSet<T & {}>;
+  entity: T;
+  em: EntityManager;
+  meta: EntityMetadata<T>;
+  changeSet?: ChangeSet<T & {}>;
 }
+/** Arguments passed to flush lifecycle event hooks (beforeFlush, onFlush, afterFlush). */
 export interface FlushEventArgs extends Omit<EventArgs<any>, 'entity' | 'changeSet' | 'meta'> {
-    uow: UnitOfWork;
+  uow: UnitOfWork;
 }
+/** Arguments passed to transaction lifecycle event hooks (start, commit, rollback). */
 export interface TransactionEventArgs extends Omit<EventArgs<any>, 'entity' | 'meta' | 'changeSet'> {
-    transaction?: Transaction & {
-        savepointName?: string;
-    };
-    uow?: UnitOfWork;
+  transaction?: Transaction & {
+    savepointName?: string;
+  };
+  uow?: UnitOfWork;
 }
+/** Interface for subscribing to entity and transaction lifecycle events. */
 export interface EventSubscriber<T = any> {
-    getSubscribedEntities?(): EntityName<T>[];
-    onInit?(args: EventArgs<T>): void;
-    onLoad?(args: EventArgs<T>): void | Promise<void>;
-    beforeCreate?(args: EventArgs<T>): void | Promise<void>;
-    afterCreate?(args: EventArgs<T>): void | Promise<void>;
-    beforeUpdate?(args: EventArgs<T>): void | Promise<void>;
-    afterUpdate?(args: EventArgs<T>): void | Promise<void>;
-    beforeUpsert?(args: EventArgs<T>): void | Promise<void>;
-    afterUpsert?(args: EventArgs<T>): void | Promise<void>;
-    beforeDelete?(args: EventArgs<T>): void | Promise<void>;
-    afterDelete?(args: EventArgs<T>): void | Promise<void>;
-    beforeFlush?(args: FlushEventArgs): void | Promise<void>;
-    onFlush?(args: FlushEventArgs): void | Promise<void>;
-    afterFlush?(args: FlushEventArgs): void | Promise<void>;
-    beforeTransactionStart?(args: TransactionEventArgs): void | Promise<void>;
-    afterTransactionStart?(args: TransactionEventArgs): void | Promise<void>;
-    beforeTransactionCommit?(args: TransactionEventArgs): void | Promise<void>;
-    afterTransactionCommit?(args: TransactionEventArgs): void | Promise<void>;
-    beforeTransactionRollback?(args: TransactionEventArgs): void | Promise<void>;
-    afterTransactionRollback?(args: TransactionEventArgs): void | Promise<void>;
+  getSubscribedEntities?(): EntityName<T>[];
+  onInit?(args: EventArgs<T>): void;
+  onLoad?(args: EventArgs<T>): void | Promise<void>;
+  beforeCreate?(args: EventArgs<T>): void | Promise<void>;
+  afterCreate?(args: EventArgs<T>): void | Promise<void>;
+  beforeUpdate?(args: EventArgs<T>): void | Promise<void>;
+  afterUpdate?(args: EventArgs<T>): void | Promise<void>;
+  beforeUpsert?(args: EventArgs<T>): void | Promise<void>;
+  afterUpsert?(args: EventArgs<T>): void | Promise<void>;
+  beforeDelete?(args: EventArgs<T>): void | Promise<void>;
+  afterDelete?(args: EventArgs<T>): void | Promise<void>;
+  beforeFlush?(args: FlushEventArgs): void | Promise<void>;
+  onFlush?(args: FlushEventArgs): void | Promise<void>;
+  afterFlush?(args: FlushEventArgs): void | Promise<void>;
+  beforeTransactionStart?(args: TransactionEventArgs): void | Promise<void>;
+  afterTransactionStart?(args: TransactionEventArgs): void | Promise<void>;
+  beforeTransactionCommit?(args: TransactionEventArgs): void | Promise<void>;
+  afterTransactionCommit?(args: TransactionEventArgs): void | Promise<void>;
+  beforeTransactionRollback?(args: TransactionEventArgs): void | Promise<void>;
+  afterTransactionRollback?(args: TransactionEventArgs): void | Promise<void>;
 }

package/events/TransactionEventBroadcaster.d.ts

@@ -1,13 +1,22 @@
 import type { Transaction } from '../connections/Connection.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { TransactionEventType } from '../enums.js';
+/** Broadcasts transaction lifecycle events (start, commit, rollback) through the EventManager. */
 export declare class TransactionEventBroadcaster {
-    private readonly em;
-    readonly context?: {
+  private readonly em;
+  readonly context?:
+    | {
         topLevelTransaction?: boolean;
-    } | undefined;
-    constructor(em: EntityManager, context?: {
-        topLevelTransaction?: boolean;
-    } | undefined);
-    dispatchEvent(event: TransactionEventType, transaction?: Transaction): Promise<void>;
+      }
+    | undefined;
+  constructor(
+    em: EntityManager,
+    context?:
+      | {
+          topLevelTransaction?: boolean;
+        }
+      | undefined,
+  );
+  /** Dispatches a transaction lifecycle event to the EventManager. */
+  dispatchEvent(event: TransactionEventType, transaction?: Transaction): Promise<void>;
 }

package/events/TransactionEventBroadcaster.js

@@ -1,15 +1,17 @@
+/** Broadcasts transaction lifecycle events (start, commit, rollback) through the EventManager. */
 export class TransactionEventBroadcaster {
-    em;
-    context;
-    constructor(em, context) {
-        this.em = em;
-        this.context = context;
-    }
-    async dispatchEvent(event, transaction) {
-        await this.em.getEventManager().dispatchEvent(event, {
-            em: this.em,
-            uow: this.em.getUnitOfWork(false),
-            transaction,
-        });
-    }
+  em;
+  context;
+  constructor(em, context) {
+    this.em = em;
+    this.context = context;
+  }
+  /** Dispatches a transaction lifecycle event to the EventManager. */
+  async dispatchEvent(event, transaction) {
+    await this.em.getEventManager().dispatchEvent(event, {
+      em: this.em,
+      uow: this.em.getUnitOfWork(false),
+      transaction,
+    });
+  }
 }

package/exceptions.d.ts

@@ -2,28 +2,25 @@
  * Base class for all errors detected in the driver.
  */
 export declare class DriverException extends Error {
-    code?: string;
-    errno?: number;
-    sqlState?: string;
-    sqlMessage?: string;
-    errmsg?: string;
-    constructor(previous: Error);
+  code?: string;
+  errno?: number;
+  sqlState?: string;
+  sqlMessage?: string;
+  errmsg?: string;
+  constructor(previous: Error);
 }
 /**
  * Base class for all connection related errors detected in the driver.
  */
-export declare class ConnectionException extends DriverException {
-}
+export declare class ConnectionException extends DriverException {}
 /**
  * Base class for all server related errors detected in the driver.
  */
-export declare class ServerException extends DriverException {
-}
+export declare class ServerException extends DriverException {}
 /**
  * Base class for all constraint violation related errors detected in the driver.
  */
-export declare class ConstraintViolationException extends ServerException {
-}
+export declare class ConstraintViolationException extends ServerException {}
 /**
  * Base class for all already existing database object related errors detected in the driver.
  *
@@ -31,8 +28,7 @@ export declare class ConstraintViolationException extends ServerException {
  * such as schemas, tables, views, sequences, triggers,  constraints, indexes,
  * functions, stored procedures etc.
  */
-export declare class DatabaseObjectExistsException extends ServerException {
-}
+export declare class DatabaseObjectExistsException extends ServerException {}
 /**
  * Base class for all unknown database object related errors detected in the driver.
  *
@@ -40,65 +36,52 @@ export declare class DatabaseObjectExistsException extends ServerException {
  * such as schemas, tables, views, sequences, triggers,  constraints, indexes,
  * functions, stored procedures etc.
  */
-export declare class DatabaseObjectNotFoundException extends ServerException {
-}
+export declare class DatabaseObjectNotFoundException extends ServerException {}
 /**
  * Exception for a deadlock error of a transaction detected in the driver.
  */
-export declare class DeadlockException extends ServerException {
-}
+export declare class DeadlockException extends ServerException {}
 /**
  * Exception for a foreign key constraint violation detected in the driver.
  */
-export declare class ForeignKeyConstraintViolationException extends ConstraintViolationException {
-}
+export declare class ForeignKeyConstraintViolationException extends ConstraintViolationException {}
 /**
  * Exception for a check constraint violation detected in the driver.
  */
-export declare class CheckConstraintViolationException extends ConstraintViolationException {
-}
+export declare class CheckConstraintViolationException extends ConstraintViolationException {}
 /**
  * Exception for an invalid specified field name in a statement detected in the driver.
  */
-export declare class InvalidFieldNameException extends ServerException {
-}
+export declare class InvalidFieldNameException extends ServerException {}
 /**
  * Exception for a lock wait timeout error of a transaction detected in the driver.
  */
-export declare class LockWaitTimeoutException extends ServerException {
-}
+export declare class LockWaitTimeoutException extends ServerException {}
 /**
  * Exception for a non-unique/ambiguous specified field name in a statement detected in the driver.
  */
-export declare class NonUniqueFieldNameException extends ServerException {
-}
+export declare class NonUniqueFieldNameException extends ServerException {}
 /**
  * Exception for a NOT NULL constraint violation detected in the driver.
  */
-export declare class NotNullConstraintViolationException extends ConstraintViolationException {
-}
+export declare class NotNullConstraintViolationException extends ConstraintViolationException {}
 /**
  * Exception for a write operation attempt on a read-only database element detected in the driver.
  */
-export declare class ReadOnlyException extends ServerException {
-}
+export declare class ReadOnlyException extends ServerException {}
 /**
  * Exception for a syntax error in a statement detected in the driver.
  */
-export declare class SyntaxErrorException extends ServerException {
-}
+export declare class SyntaxErrorException extends ServerException {}
 /**
  * Exception for an already existing table referenced in a statement detected in the driver.
  */
-export declare class TableExistsException extends DatabaseObjectExistsException {
-}
+export declare class TableExistsException extends DatabaseObjectExistsException {}
 /**
  * Exception for an unknown table referenced in a statement detected in the driver.
  */
-export declare class TableNotFoundException extends DatabaseObjectNotFoundException {
-}
+export declare class TableNotFoundException extends DatabaseObjectNotFoundException {}
 /**
  * Exception for a unique constraint violation detected in the driver.
  */
-export declare class UniqueConstraintViolationException extends ConstraintViolationException {
-}
+export declare class UniqueConstraintViolationException extends ConstraintViolationException {}

package/exceptions.js

@@ -2,41 +2,38 @@
  * Base class for all errors detected in the driver.
  */
 export class DriverException extends Error {
-    code;
-    errno;
-    sqlState;
-    sqlMessage;
-    errmsg;
-    constructor(previous) {
-        super(previous.message);
-        Object.getOwnPropertyNames(previous).forEach(k => (this[k] = previous[k]));
-        this.name = this.constructor.name;
-        Error.captureStackTrace(this, this.constructor);
-        if (previous.stack) {
-            this.stack +=
-                '\n\n' +
-                    previous.stack
-                        .split('\n')
-                        .filter(l => l.trim().startsWith('at '))
-                        .join('\n');
-        }
+  code;
+  errno;
+  sqlState;
+  sqlMessage;
+  errmsg;
+  constructor(previous) {
+    super(previous.message);
+    Object.getOwnPropertyNames(previous).forEach(k => (this[k] = previous[k]));
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+    if (previous.stack) {
+      this.stack +=
+        '\n\n' +
+        previous.stack
+          .split('\n')
+          .filter(l => l.trim().startsWith('at '))
+          .join('\n');
     }
+  }
 }
 /**
  * Base class for all connection related errors detected in the driver.
  */
-export class ConnectionException extends DriverException {
-}
+export class ConnectionException extends DriverException {}
 /**
  * Base class for all server related errors detected in the driver.
  */
-export class ServerException extends DriverException {
-}
+export class ServerException extends DriverException {}
 /**
  * Base class for all constraint violation related errors detected in the driver.
  */
-export class ConstraintViolationException extends ServerException {
-}
+export class ConstraintViolationException extends ServerException {}
 /**
  * Base class for all already existing database object related errors detected in the driver.
  *
@@ -44,8 +41,7 @@ export class ConstraintViolationException extends ServerException {
  * such as schemas, tables, views, sequences, triggers,  constraints, indexes,
  * functions, stored procedures etc.
  */
-export class DatabaseObjectExistsException extends ServerException {
-}
+export class DatabaseObjectExistsException extends ServerException {}
 /**
  * Base class for all unknown database object related errors detected in the driver.
  *
@@ -53,65 +49,52 @@ export class DatabaseObjectExistsException extends ServerException {
  * such as schemas, tables, views, sequences, triggers,  constraints, indexes,
  * functions, stored procedures etc.
  */
-export class DatabaseObjectNotFoundException extends ServerException {
-}
+export class DatabaseObjectNotFoundException extends ServerException {}
 /**
  * Exception for a deadlock error of a transaction detected in the driver.
  */
-export class DeadlockException extends ServerException {
-}
+export class DeadlockException extends ServerException {}
 /**
  * Exception for a foreign key constraint violation detected in the driver.
  */
-export class ForeignKeyConstraintViolationException extends ConstraintViolationException {
-}
+export class ForeignKeyConstraintViolationException extends ConstraintViolationException {}
 /**
  * Exception for a check constraint violation detected in the driver.
  */
-export class CheckConstraintViolationException extends ConstraintViolationException {
-}
+export class CheckConstraintViolationException extends ConstraintViolationException {}
 /**
  * Exception for an invalid specified field name in a statement detected in the driver.
  */
-export class InvalidFieldNameException extends ServerException {
-}
+export class InvalidFieldNameException extends ServerException {}
 /**
  * Exception for a lock wait timeout error of a transaction detected in the driver.
  */
-export class LockWaitTimeoutException extends ServerException {
-}
+export class LockWaitTimeoutException extends ServerException {}
 /**
  * Exception for a non-unique/ambiguous specified field name in a statement detected in the driver.
  */
-export class NonUniqueFieldNameException extends ServerException {
-}
+export class NonUniqueFieldNameException extends ServerException {}
 /**
  * Exception for a NOT NULL constraint violation detected in the driver.
  */
-export class NotNullConstraintViolationException extends ConstraintViolationException {
-}
+export class NotNullConstraintViolationException extends ConstraintViolationException {}
 /**
  * Exception for a write operation attempt on a read-only database element detected in the driver.
  */
-export class ReadOnlyException extends ServerException {
-}
+export class ReadOnlyException extends ServerException {}
 /**
  * Exception for a syntax error in a statement detected in the driver.
  */
-export class SyntaxErrorException extends ServerException {
-}
+export class SyntaxErrorException extends ServerException {}
 /**
  * Exception for an already existing table referenced in a statement detected in the driver.
  */
-export class TableExistsException extends DatabaseObjectExistsException {
-}
+export class TableExistsException extends DatabaseObjectExistsException {}
 /**
  * Exception for an unknown table referenced in a statement detected in the driver.
  */
-export class TableNotFoundException extends DatabaseObjectNotFoundException {
-}
+export class TableNotFoundException extends DatabaseObjectNotFoundException {}
 /**
  * Exception for a unique constraint violation detected in the driver.
  */
-export class UniqueConstraintViolationException extends ConstraintViolationException {
-}
+export class UniqueConstraintViolationException extends ConstraintViolationException {}