golevelup/nestjs

Import StripeModule into your module (e.g., AppModule). You must provide an apiKey. If you intend to consume webhooks, you must also provide webhookConfig containing your stripeSecrets.

Snapshot Event Secrets:

• account: Webhook secret for your account.
• accountTest: Webhook secret for test mode.
• connect: Webhook secret for Connected accounts.
• connectTest: Webhook secret for Connected accounts in test mode.

Thin Event Secrets (Optional):

• stripeThinSecrets: Separate secrets for Stripe's v2 thin events (required if using @StripeThinWebhookHandler).

import { StripeModule } from '@golevelup/nestjs-stripe';

@Module({
  imports: [
    StripeModule.forRoot({
      apiKey: 'sk_***',
      webhookConfig: {
        // Snapshot event secrets
        stripeSecrets: {
          account: 'whsec_***',
          accountTest: 'whsec_***',
          connect: 'whsec_***',
          connectTest: 'whsec_***',
        },
        // Thin event secrets (optional)
        stripeThinSecrets: {
          account: 'whsec_***',
          accountTest: 'whsec_***',
          connect: 'whsec_***',
          connectTest: 'whsec_***',
        },
      },
    }),
  ],
})
export class AppModule {}

To avoid attempting to connect to a real RabbitMQ broker during unit or integration tests, pass undefined to RabbitMQModule.forRoot. This causes the connection process to be ignored.

Common pattern: Use a conditional check on process.env.NODE_ENV to provide the configuration object only when not in a test environment.

import { RabbitMQModule } from '@golevelup/nestjs-rabbitmq';

@Module({
  imports: [
    RabbitMQModule.forRoot(
      RabbitMQModule,
      /** Not sending config object makes the connection process to be ignored */
      process.env.NODE_ENV !== 'test'
        ? {
            exchanges: [
              {
                name: 'exchange1',
                type: 'topic',
              },
            ],
            uri: 'amqp://rabbitmq:rabbitmq@localhost:5672',
            connectionInitOptions: { wait: false },
          }
        : undefined,
    ),
  ],
})
export class RabbitExampleModule {}

To validate webhooks, you often need access to the unmodified raw request body. Because NestJS enables JSON parsing by default, you must follow these two steps to preserve the raw body on specific routes:

1. Disable global body parsing

In your application bootstrap function (usually main.ts), set bodyParser: false when creating the Nest application.

2. Apply raw body parsing to specific routes

Use the applyRawBodyOnlyTo utility function within your AppModule (implementing NestModule) to specify which routes should receive the raw body. This utility automatically applies JSON parsing to all other routes while excluding the routes you specify.

// Step 1: In main.ts
const app = await NestFactory.create(AppModule, {
  bodyParser: false,
});

// Step 2: In AppModule
import { applyRawBodyOnlyTo } from '@golevelup/nestjs-webhooks';
import { Module, NestModule, MiddlewareConsumer, RequestMethod } from '@nestjs/common';

@Module({})
class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    applyRawBodyOnlyTo(consumer, {
      method: RequestMethod.ALL,
      path: 'webhook',
    });
  }
}

When testing modules that depend on AmqpConnection, you can mock the connection to satisfy publishers without requiring a real RabbitMQ broker.

1. Create a mock module that provides a mocked instance of AmqpConnection and exports it.
2. Use NestJS Test.createTestingModule to override your real RabbitMQ module with the mock module using .overrideModule().useModule().

// In your test setup...

import { Module } from '@nestjs/common';
import { AmqpConnection } from '@golevelup/nestjs-rabbitmq';
import { createMock } from '@golevelup/ts-jest';
import { Test } from '@nestjs/testing';
import { AppModule } from 'where your root module is located';
import { RabbitExampleModule } from 'where your rabbitmq module is located';

// Create a valid mock module
@Module({
  providers: [
    {
      provide: AmqpConnection,
      useValue: createMock<AmqpConnection>(),
    },
  ],
  exports: [AmqpConnection],
})
class MockRabbitExampleModule {}

// Then override the real `RabbitMqModule` with the mocked one
beforeAll(async () => {
  const moduleFixture = await Test.createTestingModule({
    imports: [AppModule],
  })
    .overrideModule(RabbitExampleModule)
    .useModule(MockRabbitExampleModule)
    .compile();

  const app = moduleFixture.createNestApplication();

  await app.init();
});