fix(stripe, hasura): forRootAsync dynamic controllers

packages/hasura/src/hasura.module.ts

@@ -22,6 +22,7 @@ import {
 
 @Module({
   imports: [DiscoveryModule],
+  controllers: [EventHandlerController],
 })
 export class HasuraModule
   extends createConfigurableDynamicRootModule<HasuraModule, HasuraModuleConfig>(
@@ -44,7 +45,6 @@ export class HasuraModule
         EventHandlerService,
         HasuraEventHandlerHeaderGuard,
       ],
-      controllers: [EventHandlerController],
     }
   )
   implements OnModuleInit {

packages/hasura/src/tests/hasura.module.spec.ts

@@ -38,23 +38,38 @@ const eventPayloadMissingTable = {
   table: { schema: 'public', name: 'userz' },
 };
 
-describe.each([undefined, 'customEndpoint'])(
-  'Hasura Module (e2e)',
-  (controllerPrefix) => {
+type ModuleType = 'forRoot' | 'forRootAsync';
+const cases: [ModuleType, string | undefined][] = [
+  ['forRoot', undefined],
+  ['forRoot', 'customEndpoint'],
+  ['forRootAsync', undefined],
+  ['forRootAsync', 'customEndpoint'],
+];
+
+describe.each(cases)(
+  'Hasura Module %p with controller prefix %p (e2e)',
+  (moduleType, controllerPrefix) => {
     let app;
     const hasuraEndpoint = controllerPrefix
       ? `/${controllerPrefix}/events`
       : defaultHasuraEndpoint;
 
+    const moduleConfig = {
+      secretFactory: secret,
+      secretHeader: secretHeader,
+      controllerPrefix,
+    };
+
     beforeEach(async () => {
+      const moduleImport =
+        moduleType === 'forRootAsync'
+          ? HasuraModule.forRootAsync(HasuraModule, {
+              useFactory: () => moduleConfig,
+            })
+          : HasuraModule.forRoot(HasuraModule, moduleConfig);
+
       const moduleFixture: TestingModule = await Test.createTestingModule({
-        imports: [
-          HasuraModule.forRoot(HasuraModule, {
-            secretFactory: secret,
-            secretHeader: secretHeader,
-            controllerPrefix,
-          }),
-        ],
+        imports: [moduleImport],
         providers: [UserEventService],
       }).compile();
 

packages/stripe/src/stripe.module.ts

@@ -17,13 +17,14 @@ import { StripePayloadService } from './stripe.payload.service';
 import { StripeWebhookController } from './stripe.webhook.controller';
 import { StripeWebhookService } from './stripe.webhook.service';
 
-@Module({})
+@Module({
+  controllers: [StripeWebhookController],
+})
 export class StripeModule
   extends createConfigurableDynamicRootModule<StripeModule, StripeModuleConfig>(
     STRIPE_MODULE_CONFIG_TOKEN,
     {
       imports: [DiscoveryModule],
-      controllers: [StripeWebhookController],
       providers: [
         {
           provide: Symbol('CONTROLLER_HACK'),

packages/stripe/src/tests/stripe.webhook.e2e.spec.ts

@@ -20,74 +20,89 @@ class PaymentCreatedService {
   }
 }
 
-const baseScenario: StripeModuleConfig['webhookConfig'] = {
-  stripeWebhookSecret: '123',
-  loggingConfiguration: {
-    logMatchingEventHandlers: true,
-  },
-};
-
-const scenarios: StripeModuleConfig['webhookConfig'][] = [
-  baseScenario,
-  { ...baseScenario, controllerPrefix: 'stripez' },
+type ModuleType = 'forRoot' | 'forRootAsync';
+const cases: [ModuleType, string | undefined][] = [
+  ['forRoot', undefined],
+  ['forRoot', 'stripez'],
+  ['forRootAsync', undefined],
+  ['forRootAsync', 'stripez'],
 ];
 
-describe.each(scenarios)('Stripe Module (e2e)', (scenario) => {
-  let app: INestApplication;
-  let hydratePayloadFn: jest.Mock<
-    {
-      type: string;
-    },
-    [string, Buffer]
-  >;
+describe.each(cases)(
+  'Stripe Module %p with controller prefix %p (e2e)',
+  (moduleType, controllerPrefix) => {
+    let app: INestApplication;
+    let hydratePayloadFn: jest.Mock<
+      {
+        type: string;
+      },
+      [string, Buffer]
+    >;
+
+    const stripeWebhookEndpoint = controllerPrefix
+      ? `/${controllerPrefix}/webhook`
+      : defaultStripeWebhookEndpoint;
 
-  const stripeWebhookEndpoint = scenario?.controllerPrefix
-    ? `/${scenario?.controllerPrefix}/webhook`
-    : defaultStripeWebhookEndpoint;
+    const moduleConfig: StripeModuleConfig = {
+      apiKey: '123',
+      webhookConfig: {
+        stripeWebhookSecret: '123',
+        loggingConfiguration: {
+          logMatchingEventHandlers: true,
+        },
+        controllerPrefix,
+      },
+    };
 
-  beforeEach(async () => {
-    const moduleFixture: TestingModule = await Test.createTestingModule({
-      imports: [
-        StripeModule.forRoot(StripeModule, {
-          apiKey: '123',
-          webhookConfig: scenario,
-        }),
-      ],
-      providers: [PaymentCreatedService],
-    }).compile();
+    beforeEach(async () => {
+      const moduleImport =
+        moduleType === 'forRoot'
+          ? StripeModule.forRoot(StripeModule, moduleConfig)
+          : StripeModule.forRootAsync(StripeModule, {
+              useFactory: () => moduleConfig,
+            });
 
-    app = moduleFixture.createNestApplication();
-    await app.init();
+      const moduleFixture: TestingModule = await Test.createTestingModule({
+        imports: [moduleImport],
+        providers: [PaymentCreatedService],
+      }).compile();
 
-    const stripePayloadService = app.get<StripePayloadService>(
-      StripePayloadService
-    );
+      app = moduleFixture.createNestApplication();
+      await app.init();
 
-    hydratePayloadFn = jest
-      .spyOn(stripePayloadService, 'tryHydratePayload')
-      .mockImplementationOnce((sig, buff) => buff as any);
-  });
+      const stripePayloadService = app.get<StripePayloadService>(
+        StripePayloadService
+      );
 
-  afterEach(() => jest.resetAllMocks());
+      hydratePayloadFn = jest
+        .spyOn(stripePayloadService, 'tryHydratePayload')
+        .mockImplementationOnce((sig, buff) => buff as any);
+    });
 
-  it('returns an error if the stripe signature is missing', () => {
-    return request(app.getHttpServer())
-      .post(stripeWebhookEndpoint)
-      .send(expectedEvent)
-      .expect(500);
-  });
+    it('returns an error if the stripe signature is missing', () => {
+      return request(app.getHttpServer())
+        .post(stripeWebhookEndpoint)
+        .send(expectedEvent)
+        .expect(500);
+    });
 
-  it('routes incoming events to their handlers based on event type', () => {
-    return request(app.getHttpServer())
-      .post(stripeWebhookEndpoint)
-      .send(expectedEvent)
-      .set('stripe-signature', stripeSig)
-      .expect(201)
-      .then(() => {
-        expect(testReceiveStripeFn).toHaveBeenCalledTimes(1);
-        expect(hydratePayloadFn).toHaveBeenCalledTimes(1);
-        expect(hydratePayloadFn).toHaveBeenCalledWith(stripeSig, expectedEvent);
-        expect(testReceiveStripeFn).toHaveBeenCalledWith(expectedEvent);
-      });
-  });
-});
+    it('routes incoming events to their handlers based on event type', () => {
+      return request(app.getHttpServer())
+        .post(stripeWebhookEndpoint)
+        .send(expectedEvent)
+        .set('stripe-signature', stripeSig)
+        .expect(201)
+        .then(() => {
+          expect(testReceiveStripeFn).toHaveBeenCalledTimes(1);
+          expect(hydratePayloadFn).toHaveBeenCalledTimes(1);
+          expect(hydratePayloadFn).toHaveBeenCalledWith(
+            stripeSig,
+            expectedEvent
+          );
+          expect(testReceiveStripeFn).toHaveBeenCalledWith(expectedEvent);
+        });
+    });
+
+    afterEach(() => jest.resetAllMocks());
+  }
+);