Initial commit - Event Planner application

node_modules/@mikro-orm/core/events/EventManager.d.ts

@@ -0,0 +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>);
+  /** 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;
+}

node_modules/@mikro-orm/core/events/EventManager.js

@@ -0,0 +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);
+    }
+  }
+  /** 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);
+      });
+  }
+  /** 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));
+      }
+    }
+    if (event === EventType.onInit) {
+      for (const listener of listeners) {
+        void listener(args);
+      }
+      return;
+    }
+    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);
+    }
+    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;
+  }
+  /** 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)));
+  }
+}

node_modules/@mikro-orm/core/events/EventSubscriber.d.ts

@@ -0,0 +1,46 @@
+import type { EntityName, EntityMetadata } from '../typings.js';
+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 & {}>;
+}
+/** Arguments passed to flush lifecycle event hooks (beforeFlush, onFlush, afterFlush). */
+export interface FlushEventArgs extends Omit<EventArgs<any>, 'entity' | 'changeSet' | 'meta'> {
+  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;
+}
+/** 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>;
+}

node_modules/@mikro-orm/core/events/EventSubscriber.js

@@ -0,0 +1 @@
+export {};

node_modules/@mikro-orm/core/events/TransactionEventBroadcaster.d.ts

@@ -0,0 +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?:
+    | {
+        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>;
+}

node_modules/@mikro-orm/core/events/TransactionEventBroadcaster.js

@@ -0,0 +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,
+    });
+  }
+}

node_modules/@mikro-orm/core/events/index.d.ts

@@ -0,0 +1,3 @@
+export type * from './EventSubscriber.js';
+export * from './EventManager.js';
+export * from './TransactionEventBroadcaster.js';

node_modules/@mikro-orm/core/events/index.js

@@ -0,0 +1,2 @@
+export * from './EventManager.js';
+export * from './TransactionEventBroadcaster.js';