Deprecate Events for Hooks

Author: CarsonF

src/core/events/constants.ts

@@ -1,91 +1,21 @@
-import { Injectable, type OnApplicationBootstrap } from '@nestjs/common';
-import {
-  type FnLike,
-  groupToMapBy,
-  mapValues,
-  sortBy,
-} from '@seedcompany/common';
-import { stripIndent } from 'common-tags';
-import { type ID, ServerException } from '~/common';
-import { MetadataDiscovery } from '~/core/discovery';
-import { ILogger, Logger } from '../logger';
-import { EVENT_METADATA } from './constants';
-import { EventsHandler, type IEventHandler } from './event-handler.decorator';
+import { Injectable } from '@nestjs/common';
+import { Hooks } from '../hooks';
 
 /**
  * An event bus for internal use.
  * This should be used to de-couple logic between different modules.
+ *
+ * @deprecated use {@link Hooks} instead.
  */
-export abstract class IEventBus {
-  publish: (event: object) => Promise<void>;
-  publishAll: (events: object[]) => Promise<void>;
-}
-
 @Injectable()
-export class SyncEventBus implements IEventBus, OnApplicationBootstrap {
-  private listenerMap: Record<ID, FnLike[]> = {};
-
-  constructor(
-    private readonly discovery: MetadataDiscovery,
-    @Logger('event-bus') private readonly logger: ILogger,
-  ) {}
+export class IEventBus {
+  constructor(private readonly hooks: Hooks) {}
 
   async publish(event: object): Promise<void> {
-    let id;
-    try {
-      id = Reflect.getMetadata(EVENT_METADATA, event.constructor).id;
-    } catch (e) {
-      // Fails when event doesn't have an ID in its metadata,
-      // which is created upon first registration with a handler.
-      if (process.env.NODE_ENV === 'production') {
-        return;
-      }
-      this.logger.warning(
-        `It appears that ${event.constructor.name} does not have any registered handlers. Are you sure this is right?`,
-      );
-      return;
-    }
-    for (const handler of this.listenerMap[id] || []) {
-      await handler(event);
-    }
+    await this.hooks.run(event);
   }
 
   async publishAll(events: any[]): Promise<void> {
     await Promise.all(events.map((e) => this.publish(e)));
   }
-
-  async onApplicationBootstrap() {
-    const discovered = this.discovery
-      .discover(EventsHandler)
-      .classes<IEventHandler<any>>();
-
-    if (process.env.NODE_ENV !== 'production') {
-      const defined = new Set<string>();
-      for (const entry of discovered) {
-        const name = entry.instance.constructor.name;
-        if (defined.has(name)) {
-          throw new ServerException(stripIndent`
-            Event handler "${name}" has already been defined.
-            Event handlers have to have unique class names for DX sanity.
-          `);
-        }
-        defined.add(name);
-      }
-    }
-
-    const flat = discovered.flatMap(({ instance, meta }) => {
-      const handler = instance.handle.bind(instance);
-      return [...meta].map(([id, priority]) => ({
-        id,
-        priority,
-        handler,
-      }));
-    });
-    const grouped = groupToMapBy(flat, (entry) => entry.id);
-    this.listenerMap = mapValues(grouped, (_, entries) =>
-      sortBy(entries, [(entry) => entry.priority, 'desc']).map(
-        (e) => e.handler,
-      ),
-    ).asRecord;
-  }
 }

src/core/events/event-bus.service.ts

@@ -1,8 +1,5 @@
 import { type Type } from '@nestjs/common';
-import { createMetadataDecorator } from '@seedcompany/nest';
-import { nanoid } from 'nanoid';
-import { type ID } from '~/common';
-import { EVENT_METADATA, type Priority } from './constants';
+import { OnHook } from '../hooks';
 
 /**
  * Subscribe to these given events.
@@ -20,41 +17,33 @@ import { EVENT_METADATA, type Priority } from './constants';
  *   Event2
  * )
  * ```
+ *
+ * @deprecated use {@link OnHook} instead.
  */
-export const EventsHandler = createMetadataDecorator({
-  types: ['class'],
-  setter: (...events: Array<Type | [...Type[], Priority]>) => {
-    const metadata = new Map<ID, Priority>();
-
+export const EventsHandler =
+  (...events: Array<Type | [...Type[], priority: number]>): ClassDecorator =>
+  (target) => {
     for (const arg of events) {
-      let priority: Priority = 0;
+      let priority = 0;
       let eventTypes: Type[] = [];
       if (!Array.isArray(arg)) {
         eventTypes = [arg];
       } else {
-        priority = arg.pop() as Priority;
+        priority = arg.pop() as number;
         eventTypes = arg as Type[];
       }
 
       for (const event of eventTypes) {
-        metadata.set(getOrDefineEventId(event), priority);
+        OnHook(event, priority * -1)(target);
       }
     }
+  };
 
-    return metadata;
-  },
-});
-
+/**
+ * @deprecated IMO this adds little value. It is just a small hint
+ * that "hey this class's handle() method is called indirectly".
+ */
 // eslint-disable-next-line @typescript-eslint/naming-convention
 export interface IEventHandler<T> {
   handle: (event: T) => Promise<void>;
 }
-
-const getOrDefineEventId = (event: Type): ID => {
-  if (!Reflect.hasMetadata(EVENT_METADATA, event)) {
-    const id: ID = nanoid();
-    Reflect.defineMetadata(EVENT_METADATA, { id }, event);
-    return id;
-  }
-  return Reflect.getMetadata(EVENT_METADATA, event).id;
-};

src/core/events/event-handler.decorator.ts

@@ -1,8 +1,8 @@
 import { Module } from '@nestjs/common';
-import { IEventBus, SyncEventBus } from './event-bus.service';
+import { IEventBus } from './event-bus.service';
 
 @Module({
-  providers: [SyncEventBus, { provide: IEventBus, useExisting: SyncEventBus }],
+  providers: [IEventBus],
   exports: [IEventBus],
 })
 export class EventsModule {}