@mikro-orm/core 7.0.2 → 7.0.3-dev.1

package/events/EventManager.d.ts

@@ -3,30 +3,18 @@ import type { EventArgs, EventSubscriber, FlushEventArgs, TransactionEventArgs }
 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>);
-  /** 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;
+    #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

@@ -2,90 +2,88 @@ 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);
+        }
     }
-  }
-  /** Registers an event subscriber and indexes its subscribed entities and event types. */
-  registerSubscriber(subscriber) {
-    if (this.#subscribers.has(subscriber)) {
-      return;
+    /** Registers an event subscriber and indexes its subscribed entities and event types. */
+    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);
+        });
     }
-    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));
-      }
+    /** Returns the set of all registered event subscribers. */
+    getSubscribers() {
+        return this.#subscribers;
     }
-    if (event === EventType.onInit) {
-      for (const listener of listeners) {
-        void listener(args);
-      }
-      return;
+    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));
     }
-    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);
+    /** 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);
+        }
+        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;
     }
-    const hasHooks = meta.hooks[event]?.length;
-    if (hasHooks) {
-      this.#cache.set(cacheKey, true);
-      return true;
+    /** Creates a new EventManager with the same set of subscribers. */
+    clone() {
+        return new EventManager(this.#subscribers);
     }
-    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;
-      }
+    getSubscribedEntities(listener) {
+        if (!listener.getSubscribedEntities) {
+            return new Set();
+        }
+        return new Set(listener.getSubscribedEntities().map(name => Utils.className(name)));
     }
-    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

@@ -5,42 +5,42 @@ 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

@@ -3,20 +3,13 @@ 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,
-  );
-  /** Dispatches a transaction lifecycle event to the EventManager. */
-  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,17 +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;
-  }
-  /** 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,
-    });
-  }
+    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,25 +2,28 @@
  * 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.
  *
@@ -28,7 +31,8 @@ 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.
  *
@@ -36,52 +40,65 @@ 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,38 +2,41 @@
  * 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.
  *
@@ -41,7 +44,8 @@ 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.
  *
@@ -49,52 +53,65 @@ 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 {
+}