feat: added durable support for event subscriber

devly-tal · devly-tal · commit 8dedefb9176f · 2024-11-25T17:07:03.000+02:00
diff --git a/lib/event-subscribers.loader.ts b/lib/event-subscribers.loader.ts
@@ -11,10 +11,7 @@ import {
   ModuleRef,
 } from '@nestjs/core';
 import { Injector } from '@nestjs/core/injector/injector';
-import {
-  ContextId,
-  InstanceWrapper,
-} from '@nestjs/core/injector/instance-wrapper';
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
 import { Module } from '@nestjs/core/injector/module';
 import { EventEmitter2 } from 'eventemitter2';
 import { EventEmitterReadinessWatcher } from './event-emitter-readiness.watcher';
@@ -140,9 +137,10 @@ export class EventSubscribersLoader
     listenerMethod(
       event,
       async (...args: unknown[]) => {
-        const contextId = ContextIdFactory.create();
+        const request = this.getRequestFromEventPayload(args);
+        const contextId = ContextIdFactory.getByRequest({ payload: request });
 
-        this.registerEventPayloadByContextId(args, contextId);
+        this.moduleRef.registerRequestByContextId(request, contextId);
 
         const contextInstance = await this.injector.loadPerContext(
           eventListenerInstance,
@@ -161,10 +159,7 @@ export class EventSubscribersLoader
     );
   }
 
-  private registerEventPayloadByContextId(
-    eventPayload: unknown[],
-    contextId: ContextId,
-  ) {
+  private getRequestFromEventPayload(eventPayload: unknown[]): unknown {
     /*
       **Required explanation for the ternary below**
 
@@ -179,11 +174,7 @@ export class EventSubscribersLoader
       However, whoever is using this library would certainly expect the event payload to be a single string 'payload', not an array,
       since this is what we emitted above.
     */
-
-    const payloadObjectOrArray =
-      eventPayload.length > 1 ? eventPayload : eventPayload[0];
-
-    this.moduleRef.registerRequestByContextId(payloadObjectOrArray, contextId);
+    return eventPayload.length > 1 ? eventPayload : eventPayload[0];
   }
 
   private async wrapFunctionInTryCatchBlocks(
diff --git a/tests/e2e/module-e2e.spec.ts b/tests/e2e/module-e2e.spec.ts
@@ -1,4 +1,5 @@
 import { INestApplication } from '@nestjs/common';
+import { ContextIdFactory, createContextId } from '@nestjs/core';
 import { Test } from '@nestjs/testing';
 import { EventEmitter2 } from 'eventemitter2';
 import { EventEmitterReadinessWatcher } from '../../lib';
@@ -14,11 +15,21 @@ import { EventsControllerConsumer } from '../src/events-controller.consumer';
 import { EventsProviderAliasedConsumer } from '../src/events-provider-aliased.consumer';
 import { EventsProviderPrependConsumer } from '../src/events-provider-prepend.consumer';
 import { EventsProviderConsumer } from '../src/events-provider.consumer';
+import { EventsProviderDurableRequestScopedConsumer } from '../src/events-provider.durable-request-scoped.consumer';
 import { EventsProviderRequestScopedConsumer } from '../src/events-provider.request-scoped.consumer';
 import { TEST_PROVIDER_TOKEN } from '../src/test-provider';
 
 describe('EventEmitterModule - e2e', () => {
   let app: INestApplication;
+  const durableContextId = createContextId();
+
+  beforeAll(() => {
+    ContextIdFactory.apply({
+      attach: (contextId, _request) => info => {
+        return info.isTreeDurable ? durableContextId : contextId;
+      },
+    });
+  });
 
   beforeEach(async () => {
     const module = await Test.createTestingModule({
@@ -95,6 +106,15 @@ describe('EventEmitterModule - e2e', () => {
     ).toEqual(TEST_EVENT_PAYLOAD);
   });
 
+  it('should be able to emit a durable request-scoped event with a single payload', async () => {
+    await app.init();
+
+    expect(
+      EventsProviderDurableRequestScopedConsumer.injectedEventPayload
+        .objectValue,
+    ).toEqual(TEST_EVENT_PAYLOAD);
+  });
+
   it('should be able to emit a request-scoped event with a string payload', async () => {
     await app.init();
 
@@ -103,6 +123,15 @@ describe('EventEmitterModule - e2e', () => {
     ).toEqual(TEST_EVENT_STRING_PAYLOAD);
   });
 
+  it('should be able to emit a durable request-scoped event with a string payload', async () => {
+    await app.init();
+
+    expect(
+      EventsProviderDurableRequestScopedConsumer.injectedEventPayload
+        .stringValue,
+    ).toEqual(TEST_EVENT_STRING_PAYLOAD);
+  });
+
   it('should be able to emit a request-scoped event with multiple payloads', async () => {
     await app.init();
 
@@ -111,6 +140,15 @@ describe('EventEmitterModule - e2e', () => {
     ).toEqual(TEST_EVENT_MULTIPLE_PAYLOAD);
   });
 
+  it('should be able to emit a durable request-scoped event with multiple payloads', async () => {
+    await app.init();
+
+    expect(
+      EventsProviderDurableRequestScopedConsumer.injectedEventPayload
+        .arrayValue,
+    ).toEqual(TEST_EVENT_MULTIPLE_PAYLOAD);
+  });
+
   it('should work with non array metadata', async () => {
     await app.init();
 
@@ -192,6 +230,39 @@ describe('EventEmitterModule - e2e', () => {
     expect(eventsConsumerRef.eventPayload).toEqual(TEST_EVENT_PAYLOAD);
   });
 
+  it('should throw when an unexpected error occurs from durable request scoped and suppressErrors is false', async () => {
+    await app.init();
+
+    const eventEmitter = app.get(EventEmitter2);
+    expect(
+      eventEmitter.emitAsync('error-throwing.durable-request-scoped'),
+    ).rejects.toThrow('This is a test error');
+  });
+
+  it('should load durable provider once for different event emissions', async () => {
+    await app.init();
+    const eventEmitter = app.get(EventEmitter2);
+    const [durableInstance] = await eventEmitter.emitAsync('durable');
+    const [durableInstance2] = await eventEmitter.emitAsync('durable');
+    expect(durableInstance).toBe(durableInstance2);
+  });
+
+  it('should load durable provider once for different event emissions', async () => {
+    await app.init();
+    const eventEmitter = app.get(EventEmitter2);
+    const [durableInstance] = await eventEmitter.emitAsync('durable');
+    const [durableInstance2] = await eventEmitter.emitAsync('durable');
+    expect(durableInstance).toBe(durableInstance2);
+  });
+
+  it('should load non-durable provider anew for different event emissions', async () => {
+    await app.init();
+    const eventEmitter = app.get(EventEmitter2);
+    const [notDurableInstance] = await eventEmitter.emitAsync('not-durable');
+    const [notDurableInstance2] = await eventEmitter.emitAsync('not-durable');
+    expect(notDurableInstance).not.toBe(notDurableInstance2);
+  });
+
   afterEach(async () => {
     await app.close();
   });
diff --git a/tests/src/app.module.ts b/tests/src/app.module.ts
@@ -5,6 +5,7 @@ import { EventsControllerConsumer } from './events-controller.consumer';
 import { EventsProviderAliasedConsumer } from './events-provider-aliased.consumer';
 import { EventsProviderPrependConsumer } from './events-provider-prepend.consumer';
 import { EventsProviderConsumer } from './events-provider.consumer';
+import { EventsProviderDurableRequestScopedConsumer } from './events-provider.durable-request-scoped.consumer';
 import { EventsProviderRequestScopedConsumer } from './events-provider.request-scoped.consumer';
 import { EventsProducer } from './events.producer';
 import { TestProvider } from './test-provider';
@@ -22,6 +23,7 @@ import { TestProvider } from './test-provider';
     EventsProducer,
     TestProvider,
     EventsProviderRequestScopedConsumer,
+    EventsProviderDurableRequestScopedConsumer,
     EventsProviderAliasedConsumer,
     {
       provide: 'AnAliasedConsumer',
diff --git a/tests/src/events-provider.durable-request-scoped.consumer.ts b/tests/src/events-provider.durable-request-scoped.consumer.ts
@@ -0,0 +1,57 @@
+import { Inject, Injectable, Scope } from '@nestjs/common';
+import { OnEvent } from '../../lib';
+import { EVENT_PAYLOAD } from '../../lib';
+import { RequestScopedEventPayload } from './request-scoped-event-payload';
+
+@Injectable({ scope: Scope.REQUEST, durable: true })
+export class EventsProviderDurableRequestScopedConsumer {
+  constructor(@Inject(EVENT_PAYLOAD) public eventRef: any) {}
+
+  public static injectedEventPayload = new RequestScopedEventPayload();
+
+  private transformPayload = (payload: unknown[]) =>
+    payload.length === 1 ? payload[0] : payload;
+
+  @OnEvent('test.*')
+  onTestEvent(...payload: unknown[]) {
+    EventsProviderDurableRequestScopedConsumer.injectedEventPayload.setPayload(
+      this.transformPayload(payload),
+    );
+  }
+
+  @OnEvent('multiple.*')
+  onMultiplePayloadEvent(...payload: unknown[]) {
+    EventsProviderDurableRequestScopedConsumer.injectedEventPayload.setPayload(
+      this.transformPayload(payload),
+    );
+  }
+
+  @OnEvent('string.*')
+  onStringPayloadEvent(payload: string) {
+    EventsProviderDurableRequestScopedConsumer.injectedEventPayload.setPayload(
+      payload,
+    );
+  }
+
+  @OnEvent('error-handling.durable-request-scoped')
+  onErrorHandlingEvent() {
+    throw new Error('This is a test error');
+  }
+
+  @OnEvent('error-handling-suppressed.durable-request-scoped', {
+    suppressErrors: true,
+  })
+  onErrorHandlingSuppressedEvent() {
+    throw new Error('This is a test error');
+  }
+
+  @OnEvent('error-throwing.durable-request-scoped', { suppressErrors: false })
+  onErrorThrowingEvent() {
+    throw new Error('This is a test error');
+  }
+
+  @OnEvent('durable')
+  onDurableTest() {
+    return this;
+  }
+}
diff --git a/tests/src/events-provider.request-scoped.consumer.ts b/tests/src/events-provider.request-scoped.consumer.ts
@@ -36,4 +36,9 @@ export class EventsProviderRequestScopedConsumer {
   onErrorThrowingEvent() {
     throw new Error('This is a test error');
   }
+
+  @OnEvent('not-durable')
+  onDurableTest() {
+    return this;
+  }
 }

Original file line number	Diff line number	Diff line change
`@@ -36,4 +36,9 @@ export class EventsProviderRequestScopedConsumer {`
`36`	`36`	`onErrorThrowingEvent() {`
`37`	`37`	`throw new Error('This is a test error');`
`38`	`38`	`}`
	`39`	`+`
	`40`	`+ @OnEvent('not-durable')`
	`41`	`+ onDurableTest() {`
	`42`	`+ return this;`
	`43`	`+ }`
`39`	`44`	`}`