Golevelup Nestjs

https://golevelup.github.io/nestjs/
Admin
Golevelup Nestjs is a collection of modules and utilities designed to enhance NestJS applications,...
Tokens:17,973
Snippets:121
Trust Score:8.3
Update:11 months ago
Show doc for...
Tokens:
Raw
### Install @golevelup/nestjs-webhooks with pnpm

Source: https://golevelup.github.io/nestjs/webhooks

Installs the @golevelup/nestjs-webhooks package using pnpm. This command is another package manager option for installing the library.

```bash
pnpm add @golevelup/nestjs-webhooks

```

--------------------------------

### Install @golevelup/nestjs-modules with npm

Source: https://golevelup.github.io/nestjs/modules

Installs the @golevelup/nestjs-modules package using npm. This is the first step to using the dynamic module creation utilities.

```bash
npm install ---save @golevelup/nestjs-modules
```

--------------------------------

### Install @golevelup/nestjs-discovery

Source: https://golevelup.github.io/nestjs/discovery

Installs the @golevelup/nestjs-discovery package using npm, yarn, or pnpm. This package provides the DiscoveryService for NestJS applications.

```bash
npm install ---save @golevelup/nestjs-discovery
```

```bash
yarn add @golevelup/nestjs-discovery
```

```bash
pnpm add @golevelup/nestjs-discovery
```

--------------------------------

### Install @golevelup/nestjs-rabbitmq with npm, yarn, or pnpm

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

These code snippets demonstrate how to install the @golevelup/nestjs-rabbitmq package using different package managers: npm, yarn, and pnpm. Ensure you have the respective package manager installed and configured in your project.

```bash
npm install ---save @golevelup/nestjs-rabbitmq
```

```bash
yarn add @golevelup/nestjs-rabbitmq
```

```bash
pnpm add @golevelup/nestjs-rabbitmq
```

--------------------------------

### Install Golevelup NestJS Stripe Module

Source: https://golevelup.github.io/nestjs/modules/stripe

Installs the Golevelup NestJS Stripe module and the Stripe SDK using npm, yarn, or pnpm.

```bash
npm install ---save @golevelup/nestjs-stripe stripe

```

```bash
yarn add @golevelup/nestjs-stripe stripe

```

```bash
pnpm add @golevelup/nestjs-stripe stripe

```

--------------------------------

### Install @golevelup/nestjs-webhooks with npm

Source: https://golevelup.github.io/nestjs/webhooks

Installs the @golevelup/nestjs-webhooks package using npm. This is the first step to integrating webhook handling into your NestJS application.

```bash
npm install ---save @golevelup/nestjs-webhooks

```

--------------------------------

### Install @golevelup/nestjs-modules with yarn

Source: https://golevelup.github.io/nestjs/modules

Installs the @golevelup/nestjs-modules package using yarn. This is an alternative to npm for package installation.

```bash
yarn add @golevelup/nestjs-modules
```

--------------------------------

### Install @golevelup/nestjs-modules with pnpm

Source: https://golevelup.github.io/nestjs/modules

Installs the @golevelup/nestjs-modules package using pnpm. This is another alternative package manager.

```bash
pnpm add @golevelup/nestjs-modules
```

--------------------------------

### Install @golevelup/nestjs-webhooks with yarn

Source: https://golevelup.github.io/nestjs/webhooks

Installs the @golevelup/nestjs-webhooks package using yarn. This command is an alternative to npm for managing project dependencies.

```bash
yarn add @golevelup/nestjs-webhooks

```

--------------------------------

### Install ts-sinon for NestJS Testing

Source: https://golevelup.github.io/nestjs/testing/ts-sinon

Installs the ts-sinon package as a development dependency for NestJS testing. This package provides utilities for easier mocking.

```bash
npm install @golevelup/ts-sinon -D
```

```bash
yarn add @golevelup/ts-sinon -D
```

```bash
pnpm add @golevelup/ts-sinon -D
```

--------------------------------

### Install GraphQLRequestModule for NestJS (npm)

Source: https://golevelup.github.io/nestjs/graphql-request

Installs the @golevelup/nestjs-graphql-request package using npm. This is the first step to integrating the library into your NestJS application.

```bash
npm install ---save @golevelup/nestjs-graphql-request
```

--------------------------------

### Install @golevelup/ts-vitest with npm, yarn, or pnpm

Source: https://golevelup.github.io/nestjs/testing/ts-vitest

Installation instructions for the `@golevelup/ts-vitest` package as a development dependency using different package managers (npm, yarn, pnpm). This package provides utilities for mocking in Vitest.

```bash
npm install @golevelup/ts-vitest -D
```

```bash
yarn add @golevelup/ts-vitest -D
```

```bash
pnpm add @golevelup/ts-vitest -D
```

--------------------------------

### Install GraphQLRequestModule for NestJS (yarn)

Source: https://golevelup.github.io/nestjs/graphql-request

Installs the @golevelup/nestjs-graphql-request package using yarn. This is an alternative package manager for adding the library to your NestJS project.

```bash
yarn add @golevelup/nestjs-graphql-request
```

--------------------------------

### Query Controller Methods with Metadata in NestJS

Source: https://golevelup.github.io/nestjs/discovery

An example of how to use the DiscoveryService to find all controller methods decorated with a specific metadata key ('exampleKey') and retrieve the associated metadata value. This assumes a custom decorator like ExampleDecorator has been defined and used.

```typescript
// Assuming a custom decorator like:
// const ExampleDecorator = (meta: string) => SetMetadata('exampleKey', meta);

const exampleMethodsMeta = await this.discover.controllerMethodsWithMetaAtKey<string>('exampleKey');
```

--------------------------------

### Install @golevelup/nestjs-hasura Package

Source: https://golevelup.github.io/nestjs/modules/hasura

Install the Hasura module for NestJS using npm, yarn, or pnpm. This package facilitates integration between Hasura events and your NestJS application.

```bash
npm install ---save @golevelup/nestjs-hasura
```

```bash
yarn add @golevelup/nestjs-hasura
```

```bash
pnpm add @golevelup/nestjs-hasura
```

--------------------------------

### Install GraphQLRequestModule for NestJS (pnpm)

Source: https://golevelup.github.io/nestjs/graphql-request

Installs the @golevelup/nestjs-graphql-request package using pnpm. This is another package manager option for integrating the library into your NestJS application.

```bash
pnpm add @golevelup/nestjs-graphql-request
```

--------------------------------

### Install @golevelup/ts-jest for Development

Source: https://golevelup.github.io/nestjs/testing/ts-jest

Installs the @golevelup/ts-jest package as a development dependency using npm, yarn, or pnpm. This package provides utilities for mocking in TypeScript with Jest.

```bash
npm install @golevelup/ts-jest -D
```

```bash
yarn add @golevelup/ts-jest -D
```

```bash
pnpm add @golevelup/ts-jest -D
```

--------------------------------

### Setup Typesafe GraphQL Access with Codegen in NestJS

Source: https://golevelup.github.io/nestjs/graphql-request

Illustrates setting up typesafe GraphQL access in NestJS by integrating with GraphQL code generation. It uses a provider factory to wire up the generated SDK with the injected GraphQLClient.

```typescript
import {
  GraphQLRequestModule,
  GraphQLClientInject,
} from '@golevelup/nestjs-graphql-request';
import { getSdk } from './your-codegen-location';

@Module({
  imports: [
    GraphQLRequestModule.forRoot({
      // Exposes configuration options based on the graphql-request package
      endpoint: config.get('endpoint'),
      options: {
        headers: {
          'content-type': 'application/json',
          'x-hasura-admin-secret': config.get('secret'),
        },
      },
    }),
  ],
  providers: [
    {
      // you can provide whatever key you want. use it in conjunction with @Inject("TypeSafeGqlSdk") to get the SDK instance in your controllers/services
      provide: 'TypeSafeGqlSdk',
      inject: [GraphQLClientInject],
      useFactory: (client: GraphQLClient) => getSdk(client),
    },
  ],
})
export class AppModule {
  // ...
}
```

--------------------------------

### Configure RabbitMQModule with Connection Resiliency (NestJS)

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

This TypeScript example shows how to configure the RabbitMQModule in a NestJS application with connection resiliency enabled. By setting `wait: false` in `connectionInitOptions`, the application can bootstrap even if the RabbitMQ broker is unavailable, establishing connections and setting up channels dynamically.

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

@Module({
  imports: [
    RabbitMQModule.forRoot({
      exchanges: [
        {
          name: 'exchange1',
          type: 'topic',
        },
      ],
      uri: 'amqp://rabbitmq:rabbitmq@localhost:5672',
      connectionInitOptions: { wait: false },
    }),
  ],
})
export class RabbitExampleModule {}
```

--------------------------------

### Create a Configurable Dynamic Root Module in NestJS

Source: https://golevelup.github.io/nestjs/modules

Demonstrates how to create a dynamic module using `createConfigurableDynamicRootModule`. It requires the module's name, options, and a token for providing options via injection. This example shows setting up a `ConfigModule`.

```typescript
import { createConfigurableDynamicRootModule } from '@golevelup/nestjs-modules';
import { Module } from '@nestjs/common';
import { CONFIG_MODULE_OPTIONS } from './config.constants'; // the constant string/symbol/token
import { ConfigModuleOptions } from './config.options'; // the options to provide to the service
import { ConfigService } from './config.service'; // the service to be provided to the rest of the server

@Module({
  providers: [ConfigService],
  exports: [ConfigService],
})
export class ConfigModule extends createConfigurableDynamicRootModule<
  ConfigModule,
  ConfigModuleOptions
>(CONFIG_MODULE_OPTIONS) {}

```

--------------------------------

### Using Deferred NestJS Dynamic Module Configuration

Source: https://golevelup.github.io/nestjs/modules

This TypeScript code demonstrates how to import and use a NestJS dynamic module that has been configured for deferred initialization via a static property. The `ConfigModule.deferred()` call is used within the `imports` array of another module, simplifying the setup process.

```typescript
@Module({
  imports: [ConfigModule.deferred()],
})
export class ConfigModuleDependentModule {}
```

--------------------------------

### Mock nested methods of ExecutionContext with Vitest

Source: https://golevelup.github.io/nestjs/testing/ts-vitest

This TypeScript example shows how to create a mock for `ExecutionContext` and access its deeply nested methods like `switchToHttp().getRequest()`. It verifies that these mocked methods are defined and accessible.

```typescript
import { createMock } from '@golevelup/ts-vitest';
import { ExecutionContext } from '@nestjs/common';

describe('Mocked Execution Context', () => {
  it('should have a fully mocked Execution Context', () => {
    const mockExecutionContext = createMock<ExecutionContext>();
    expect(mockExecutionContext.switchToHttp().getRequest()).toBeDefined();
    expect(mockExecutionContext.switchToRPC().getContext()).toBeDefined();
    expect(mockExecutionContext.switchToWs().getClient()).toBeDefined();
  });
});
```

--------------------------------

### Create a fully mocked ExecutionContext in TypeScript with Vitest

Source: https://golevelup.github.io/nestjs/testing/ts-vitest

Example demonstrating how to create a basic mock of NestJS's `ExecutionContext` using `createMock` from `@golevelup/ts-vitest`. This mock is type-safe and allows for initial assertions on nested methods.

```typescript
import { createMock } from '@golevelup/ts-vitest';
import { ExecutionContext } from '@nestjs/common';

describe('Mocked Execution Context', () => {
  it('should have a fully mocked Execution Context', () => {
    const mockExecutionContext = createMock<ExecutionContext>();
    expect(mockExecutionContext.switchToHttp()).toBeDefined();
  });
});
```

--------------------------------

### Expose Pub/Sub Handlers with RabbitSubscribe Decorator in NestJS

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

This example demonstrates how to expose a Publish/Subscribe (Pub/Sub) handler in NestJS using the `@RabbitSubscribe` decorator. When a message matching the defined exchange, routing key, and queue is received, the decorated service method is automatically invoked to handle the message. It requires `RabbitSubscribe` from the library and `Injectable` from NestJS.

```typescript
import {
  RabbitSubscribe,
} from '@golevelup/nestjs-rabbitmq';
import { Injectable } from '@nestjs/common';

@Injectable()
export class MessagingService {
  @RabbitSubscribe({
    exchange: 'exchange1',
    routingKey: 'subscribe-route',
    queue: 'subscribe-queue',
  })
  public async pubSubHandler(msg: {}) {
    console.log(`Received message: ${JSON.stringify(msg)}`);
  }
}
```

--------------------------------

### Apply NestJS Decorators to RabbitMQ Controller Methods

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

This example demonstrates applying NestJS decorators like `@UseInterceptors` to controller methods acting as RabbitMQ handlers. By importing the controller as a provider in the module, standard NestJS enhancers can be used for specific RPC endpoints. This requires the `RabbitRPC` decorator and `UseInterceptors` from NestJS.

```typescript
@RabbitRPC({
  routingKey: 'intercepted-rpc-2',
  exchange: 'exchange2',
  queue: 'intercepted-rpc-2',
})
@UseInterceptors(TransformInterceptor)
interceptedRpc() {
  return {
    message: 42,
  };
}
```

--------------------------------

### Customize and Assert Mocked ExecutionContext with Jest

Source: https://golevelup.github.io/nestjs/testing/ts-jest

Illustrates how to provide custom mock implementations for specific methods of NestJS's ExecutionContext using `createMock`. This example demonstrates setting mock return values, asserting mock call counts, and checking deeply nested request/response objects.

```typescript
import { createMock } from '@golevelup/ts-jest';
import { ExecutionContext } from '@nestjs/common';

describe('Mocked Execution Context', () => {
  it('should have a fully mocked Execution Context', () => {
    const mockExecutionContext = createMock<ExecutionContext>({
      switchToHttp: () => ({
        getRequest: () => ({
          headers: {
            authorization: 'auth',
          },
        }),
      }),
    });
    mockExecutionContext
      .switchToHttp() 
      .getResponse.mockReturnValue({ data: 'res return data' });
    expect(mockExecutionContext.switchToHttp().getRequest()).toEqual({
      headers: {
        authorization: 'auth',
      },
    });
    expect(mockExecutionContext.switchToHttp().getResponse()).toEqual({
      data: 'res return data',
    });
    expect(mockExecutionContext.switchToHttp).toBeCalledTimes(3);
    expect(mockExecutionContext.switchToRPC().getContext()).toBeDefined();
    expect(mockExecutionContext.switchToWs().getClient()).toBeDefined();
  });
});
```

--------------------------------

### Alternative RabbitMQ Context Identification with isRabbitContext

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

This example shows an alternative method to identify RabbitMQ contexts in NestJS interceptors using the `isRabbitContext` utility function. This provides a cleaner way to check if the current context is a RabbitMQ event, allowing for specific handling or skipping of logic for non-RabbitMQ contexts. It requires the ExecutionContext and CallHandler from NestJS and isRabbitContext from the library.

```typescript
import {
  isRabbitContext,
} from '@golevelup/nestjs-rabbitmq';
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';

@Injectable()
class ExampleInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler<any>) {
    // Do nothing if this is a RabbitMQ event
    if (isRabbitContext(context)) {
      return next.handle();
    }

    // Execute custom interceptor logic for HTTP request/response
    return next.handle();
  }
}
```

--------------------------------

### Provide custom mocks and assertions for ExecutionContext with Vitest

Source: https://golevelup.github.io/nestjs/testing/ts-vitest

Demonstrates advanced mocking with `createMock` where custom mock implementations are provided for specific methods of `ExecutionContext`. It includes assertions for request data, response return values, and call counts, showcasing type-safe chaining and modification.

```typescript
import { createMock } from '@golevelup/ts-vitest';
import { ExecutionContext } from '@nestjs/common';

describe('Mocked Execution Context', () => {
  it('should have a fully mocked Execution Context', () => {
    const mockExecutionContext = createMock<ExecutionContext>({
      switchToHttp: () => ({
        getRequest: () => ({
          headers: {
            authorization: 'auth',
          },
        }),
      }),
    });
    mockExecutionContext
      .switchToHttp()
      .getResponse.mockReturnValue({ data: 'res return data' });
    expect(mockExecutionContext.switchToHttp().getRequest()).toEqual({
      headers: {
        authorization: 'auth',
      },
    });
    expect(mockExecutionContext.switchToHttp().getResponse()).toEqual({ data: 'res return data' });
    expect(mockExecutionContext.switchToHttp).toBeCalledTimes(3);
    expect(mockExecutionContext.switchToRPC().getContext()).toBeDefined();
    expect(mockExecutionContext.switchToWs().getClient()).toBeDefined();
  });
});
```

--------------------------------

### Configure Dynamic Module Synchronously in NestJS

Source: https://golevelup.github.io/nestjs/modules

Shows how to configure the dynamically created `ConfigModule` synchronously within the root `AppModule`. The `forRoot` method requires the module class and configuration options.

```typescript
@Module({
  imports: [ConfigModule.forRoot(ConfigModule, synchronousConfigModuleOptions)],
})
export class AppModule {}

```

--------------------------------

### Create a Basic Mocked ExecutionContext with Jest

Source: https://golevelup.github.io/nestjs/testing/ts-jest

Demonstrates creating a deeply nested mock object for NestJS's ExecutionContext using the `createMock` utility from `@golevelup/ts-jest`. It verifies that basic methods like `switchToHttp` are defined.

```typescript
import { createMock } from '@golevelup/ts-jest';
import { ExecutionContext } from '@nestjs/common';

describe('Mocked Execution Context', () => {
  it('should have a fully mocked Execution Context', () => {
    const mockExecutionContext = createMock<ExecutionContext>();
    expect(mockExecutionContext.switchToHttp()).toBeDefined();
  });
});
```

--------------------------------

### Create Mocked ExecutionContext in NestJS with ts-sinon

Source: https://golevelup.github.io/nestjs/testing/ts-sinon

Demonstrates how to create a fully mocked NestJS ExecutionContext using the `createMock` function from `@golevelup/ts-sinon`. This allows for easier testing of controllers and services that depend on `ExecutionContext`.

```typescript
import { createMock } from '@golevelup/ts-sinon';
import { ExecutionContext } from '@nestjs/common';

describe('Mocked Execution Context', () => {
  it('should have a fully mocked Execution Context', () => {
    const mockExecutionContext = createMock<ExecutionContext>();
    expect(mockExecutionContext.switchToHttp()).toBeDefined();
  });
});
```

--------------------------------

### Inject Stripe Client and Module Configuration

Source: https://golevelup.github.io/nestjs/modules/stripe

Demonstrates how to inject the Stripe API client for making API calls and the StripeModule configuration object into NestJS controllers or providers using decorators.

```typescript
// injects the instantiated Stripe client which can be used to make API calls
@InjectStripeClient() stripeClient: Stripe

```

```typescript
// injects the module configuration
@InjectStripeModuleConfig() config: StripeModuleConfig

```

--------------------------------

### Configure RabbitMQModule with Exchanges and Channels (NestJS)

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

This TypeScript code illustrates how to configure the RabbitMQModule with both exchanges and custom channels in a NestJS application. It defines specific exchanges and configures channels with prefetch counts, allowing for granular control over message consumption.

```typescript
import { RabbitMQModule } from '@golevelup/nestjs-rabbitmq';
import { Module } from '@nestjs/common';
import { MessagingController } from './messaging/messaging.controller';
import { MessagingService } from './messaging/messaging.service';

@Module({
  imports: [
    RabbitMQModule.forRoot({
      exchanges: [
        {
          name: 'exchange1',
          type: 'topic',
        },
      ],
      uri: 'amqp://rabbitmq:rabbitmq@localhost:5672',
      channels: {
        'channel-1': {
          prefetchCount: 15,
          default: true,
        },
        'channel-2': {
          prefetchCount: 2,
        },
      },
    }),
    RabbitExampleModule,
  ],
  providers: [MessagingService],
  controllers: [MessagingController],
})
export class RabbitExampleModule {}
```

--------------------------------

### Publishing Messages with AmqpConnection in NestJS

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

Shows how to publish a message to a RabbitMQ exchange using the 'publish' method of the AmqpConnection. This is a 'fire and forget' operation.

```typescript
public publish(
  exchange: string,
  routingKey: string,
  message: any,
  options?: amqplib.Options.Publish
)
amqpConnection.publish('some-exchange', 'routing-key', { msg: 'hello world' });
```

--------------------------------

### Provide Custom Mocks with ts-sinon

Source: https://golevelup.github.io/nestjs/testing/ts-sinon

Shows how to provide custom mock implementations when using `createMock` from `@golevelup/ts-sinon`. This allows fine-grained control over specific mock behaviors and their return values.

```typescript
const mockExecutionContext = createMock<ExecutionContext>({
  switchToHttp: () => ({
    getRequest: () => ({
      headers: {
        authorization: 'auth',
      },
    }),
    getResponse: sinon.stub().returns({ data: 'res return data' }),
  }),
});
```

--------------------------------

### NestJS DiscoveryService Interfaces

Source: https://golevelup.github.io/nestjs/discovery

Defines the interfaces DiscoveredModule, DiscoveredClass, and DiscoveredMethod used by the NestJS DiscoveryService to represent discovered application components and their metadata. These interfaces provide access to instances, parent modules, dependency types, and method handlers.

```typescript
export interface DiscoveredModule {
  name: string;
  instance: {};
  injectType?: Type<{}>;
  dependencyType: Type<{}>;
}

export interface DiscoveredClass extends DiscoveredModule {
  parentModule: DiscoveredModule;
}

export interface DiscoveredMethod {
  handler: (...args: any[]) => any;
  methodName: string;
  parentClass: DiscoveredClass;
}
```

--------------------------------

### NestJS DiscoveryService Metadata Interfaces

Source: https://golevelup.github.io/nestjs/discovery

Defines interfaces for discovered components with associated metadata, DiscoveredMethodWithMeta and DiscoveredClassWithMeta. These are returned when querying for components decorated with specific metadata keys.

```typescript
export interface DiscoveredMethodWithMeta<T> {
  discoveredMethod: DiscoveredMethod;
  meta: T;
}

export interface DiscoveredClassWithMeta<T> {
  discoveredClass: DiscoveredClass;
  meta: T;
}
```

--------------------------------

### Mocking AmqpConnection in NestJS for Testing

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

This TypeScript code demonstrates how to set up a mock module to provide a mocked AmqpConnection. It uses `@nestjs/testing` and `@golevelup/ts-jest` to override the real RabbitMqModule with a mock version during testing. This is crucial for preventing actual RabbitMQ connections and ensuring dependency injection works with mocked instances.

```typescript
// 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();
});

```

--------------------------------

### Import and Configure GraphQLRequestModule in NestJS

Source: https://golevelup.github.io/nestjs/graphql-request

Demonstrates how to import and configure the GraphQLRequestModule within a NestJS module. It sets up the GraphQL client with a specified endpoint and headers.

```typescript
import { GraphQLRequestModule } from '@golevelup/nestjs-graphql-request';

@Module({
  imports: [
    GraphQLRequestModule.forRoot({
      // Exposes configuration options based on the graphql-request package
      endpoint: config.get('endpoint'),
      options: {
        headers: {
          'content-type': 'application/json',
          'x-hasura-admin-secret': config.get('secret'),
        },
      },
    }),
  ],
})
export class AppModule {
  // ...
}
```

--------------------------------

### Enable NestJS Controller Discovery for RabbitMQ

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

This configuration snippet shows how to enable controller discovery in NestJS for RabbitMQ message handling by setting `enableControllerDiscovery: true` within the `RabbitMQModule.forRoot` options. This allows NestJS controllers to be used as message handlers. It requires `RabbitMQModule` from the library and standard NestJS `Module` and `Injectable` decorators. Note that no HTTP context is available when using controllers as handlers.

```typescript
import {
  RabbitMQModule,
} from '@golevelup/nestjs-rabbitmq';
import { Module } from '@nestjs/common';
import { MessagingController } from './messaging/messaging.controller';
import { MessagingService } from './messaging/messaging.service';

@Module({
  imports: [
    RabbitMQModule.forRoot({
      exchanges: [
        {
          name: 'exchange1',
          type: 'topic',
        },
      ],
      uri: 'amqp://rabbitmq:rabbitmq@localhost:5672',
      enableControllerDiscovery: true,
    }),
    RabbitExampleModule,
  ],
  providers: [MessagingService, MessagingController],
  controllers: [MessagingController],
})
export class RabbitExampleModule {}
```

--------------------------------

### Import DiscoveryModule in NestJS

Source: https://golevelup.github.io/nestjs/discovery

Demonstrates how to import and add the DiscoveryModule to a NestJS module's imports. It also shows how to inject DiscoveryService into the module's constructor to use it during the onModuleInit lifecycle hook.

```typescript
import { DiscoveryModule } from '@golevelup/nestjs-discovery';
import { Module } from '@nestjs/common';

@Module({
  imports: [DiscoveryModule],
})
export class ExampleModule implements OnModuleInit {
  constructor(private readonly discover: DiscoveryService) {}

  public async onModuleInit() {
    // const providers = await this.discover.providersWithMetaAtKey<number>('metaKey')
  }
}
```

--------------------------------

### Configure StripeModule with API Key and Webhook Secrets

Source: https://golevelup.github.io/nestjs/modules/stripe

Imports and configures the StripeModule in the AppModule, providing the Stripe API key and webhook signing secrets for event validation. Supports forRoot and forRootAsync patterns.

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

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

```

--------------------------------

### Injecting AmqpConnection in NestJS

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

Demonstrates how to inject the AmqpConnection object into a NestJS controller or service using dependency injection, which is necessary for all RabbitMQ interactions.

```typescript
@Controller()
export class AppController {
  constructor(private readonly amqpConnection: AmqpConnection) {}

  ...
}
```

--------------------------------

### Chain Mocked Methods with ts-sinon

Source: https://golevelup.github.io/nestjs/testing/ts-sinon

Illustrates how to chain method calls on mocks created with `createMock` from `@golevelup/ts-sinon`. It shows how to stub nested methods like `switchToHttp` and `getRequest` to control mock behavior.

```typescript
it('should correctly resolve mocked providers', async () => {
  const request = {
    key: 'val',
  };

  mockExecutionContext.switchToHttp.returns(
    createMock<HttpArgumentsHost>({
      getRequest: () => request,
    }),
  );

  const mockResult = mockExecutionContext.switchToHttp().getRequest();
  expect(mockResult).toBe(request);
});
```

--------------------------------

### Requesting Data via RPC with AmqpConnection in NestJS

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

Illustrates making RPC requests to another service using the 'request' method of AmqpConnection. Allows specifying expected return types and request timeouts.

```typescript
const response = await amqpConnection.request<ExpectedReturnType>({
  exchange: 'exchange1',
  routingKey: 'rpc',
  payload: {
    request: 'val',
  },
  timeout: 10000, // optional timeout for how long the request
  // should wait before failing if no response is received
});
```

--------------------------------

### Implement Competing Consumers with NestJS RabbitMQ

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

Demonstrates the competing consumer pattern using `@golevelup/nestjs-rabbitmq`. The `competingPubSubHandler` uses a named queue for round-robin message distribution among instances. The `messagePerInstanceHandler` omits a queue name, ensuring each instance receives a unique copy of the message. This pattern is crucial for RPC and Work Queues where only one handler should process a message.

```typescript
import { RabbitSubscribe } from '@golevelup/nestjs-rabbitmq';
import { Injectable } from '@nestjs/common';

@Injectable()
export class MessagingService {
  @RabbitSubscribe({
    exchange: 'exchange1',
    routingKey: 'subscribe-route1',
    queue: 'subscribe-queue',
  })
  public async competingPubSubHandler(msg: {}) {
    console.log(`Received message: ${JSON.stringify(msg)}`);
  }

  @RabbitSubscribe({
    exchange: 'exchange1',
    routingKey: 'subscribe-route2',
  })
  public async messagePerInstanceHandler(msg: {}) {
    console.log(`Received message: ${JSON.stringify(msg)}`);
  }
}
```

--------------------------------

### RPC Request Correlation in Distributed Systems with NestJS

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

Demonstrates how to correlate RPC requests in a distributed system using 'correlationId' and 'X-Request-ID' headers for transaction management. Requires AmqpConnection.

```typescript
// To create a transaction in the distributed system,
// multiple request correlated by an correlationId
const correlationId = randomUUID();
const response = await amqpConnection.request<ExpectedReturnType>({
  exchange: 'exchange1',
  routingKey: 'rpc',
  correlationId,
  // Each request in the transaction has its own requestId
  headers: { 'X-Request-ID': randomUUID() },
  payload: {
    request: 'val',
  },
});
```

--------------------------------

### NestJS Dynamic Module Configuration with Static Property

Source: https://golevelup.github.io/nestjs/modules

This TypeScript code defines a dynamic module in NestJS using `@golevelup/nestjs-modules`. It leverages a static property `deferred` to call the `externallyConfigured` method, allowing for deferred configuration of the module. This approach simplifies the import statement in dependent modules.

```typescript
import { createConfigurableDynamicRootModule } from '@golevelup/nestjs-modules';
import { Module } from '@nestjs/common';
import { CONFIG_MODULE_OPTIONS } from './config.constants'; // the constant string/symbol/token
import { ConfigModuleOptions } from './config.options'; // the options to provide to the service
import { ConfigService } from './config.service'; // the service to be provided to the rest of the server

@Module({
  providers: [ConfigService],
  exports: [ConfigService],
})
export class ConfigModule extends createConfigurableDynamicRootModule<
  ConfigModule,
  ConfigModuleOptions
>(CONFIG_MODULE_OPTIONS) {
  static deferred = () => ConfigModule.externallyConfigured(ConfigModule, 0);
}
```

--------------------------------

### Use NestJS Pipes and Error Handling with RabbitMQ RPC

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

This code shows how to apply NestJS pipes, such as `ValidationPipe`, and configure error handling for RabbitMQ RPC handlers using decorators. The `RabbitRPC` decorator allows specifying `errorBehavior` and `errorHandler` for robust message processing. It requires `@RabbitRPC`, `RabbitPayload`, `UsePipes`, `ValidationPipe`, and custom error handling logic.

```typescript
@RabbitRPC({
  routingKey: 'intercepted-rpc-2',
  exchange: 'exchange2',
  queue: 'intercepted-rpc-2',
  errorBehavior: MessageHandlerErrorBehavior.ACK,
  errorHandler: ReplyErrorCallback,
})
@UsePipes(ValidationPipe)
interceptedRpc(@RabbitPayload()  message:messageDto) {
  return {
    message: 42,
  };
}
```

--------------------------------

### Configure Dynamic Module Asynchronously in NestJS

Source: https://golevelup.github.io/nestjs/modules

Illustrates how to configure the dynamically created `ConfigModule` asynchronously within the root `AppModule`. The `forRootAsync` method is used when configuration depends on asynchronous operations.

```typescript
@Module({
  imports: [ConfigModule.forRootAsync(ConfigModule, asyncConfigModuleOptions)],
})
export class AppModule {}

```

--------------------------------

### Apply Hasura Metadata Changes

Source: https://golevelup.github.io/nestjs/modules/hasura

Apply generated Hasura metadata changes to your Hasura instance using the Hasura CLI. This command is typically used after opting into automatic metadata synchronization in the NestJS application.

```bash
hasura metadata apply
```

--------------------------------

### Inject GraphQLClient into NestJS Service

Source: https://golevelup.github.io/nestjs/graphql-request

Shows how to inject the configured GraphQLClient instance into a NestJS service using the @InjectGraphQLClient decorator. This allows for making GraphQL requests within the service.

```typescript
import { InjectGraphQLClient } from '@golevelup/nestjs-graphql-request';
import { GraphQLClient } from 'graphql-request';

@Injectable()
export class ExampleService {
  constructor(@InjectGraphQLClient() private readonly client: GraphQLClient) {}
}
```

--------------------------------

### Mock Nested Methods of ExecutionContext with Jest

Source: https://golevelup.github.io/nestjs/testing/ts-jest

Shows how to create a more comprehensive mock of NestJS's ExecutionContext, including mocking nested methods like `getRequest`, `getContext`, and `getClient`. This allows for testing interactions with different contexts (HTTP, RPC, WebSocket).

```typescript
import { createMock } from '@golevelup/ts-jest';
import { ExecutionContext } from '@nestjs/common';

describe('Mocked Execution Context', () => {
  it('should have a fully mocked Execution Context', () => {
    const mockExecutionContext = createMock<ExecutionContext>();
    expect(mockExecutionContext.switchToHttp().getRequest()).toBeDefined();
    expect(mockExecutionContext.switchToRPC().getContext()).toBeDefined();
    expect(mockExecutionContext.switchToWs().getClient()).toBeDefined();
  });
});
```

--------------------------------

### Configure Raw Body Parsing Middleware in NestJS

Source: https://golevelup.github.io/nestjs/webhooks

Configures middleware for a NestJS application to apply raw body parsing exclusively to specified routes, using the `applyRawBodyOnlyTo` utility. This ensures that the raw request body is available for validation on webhook endpoints.

```typescript
import { applyRawBodyOnlyTo } from '@golevelup/nestjs-webhooks';

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

```

--------------------------------

### Consumer Message Batching with NestJS RabbitMQ

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

Configures a consumer to process messages in batches, either by size or timeout. Supports custom error handling for batches. Requires @golevelup/nestjs-rabbitmq.

```typescript
import { RabbitSubscribe } from '@golevelup/nestjs-rabbitmq';

const batchErrorHandler = (channel, messages, error) => {
  console.log(`Received message batch of length: ${messages.length}`);
};

@Injectable()
export class MessagingService {
  @RabbitSubscribe({
    exchange: 'exchange1',
    routingKey: 'batch-route',
    queue: 'batch-queue',
    batchOptions: {
      size: 10,
      timeout: 200,
      errorHandler: batchErrorHandler,
    },
  })
  public async batchHandler(messages) {
    console.log(`Received message batch of length: ${messages.length}`);
  }
}
```

--------------------------------

### Expose RPC Handlers with RabbitRPC Decorator in NestJS

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

This snippet illustrates how to expose a Remote Procedure Call (RPC) handler in NestJS using the `@RabbitRPC` decorator. When a message matches the specified exchange, routing key, and queue, the decorated service method is invoked, and its return value is sent back to the requester. It requires `RabbitRPC` from the library and `Injectable` from NestJS.

```typescript
import {
  RabbitRPC,
} from '@golevelup/nestjs-rabbitmq';
import { Injectable } from '@nestjs/common';

@Injectable()
export class MessagingService {
  @RabbitRPC({
    exchange: 'exchange1',
    routingKey: 'rpc-route',
    queue: 'rpc-queue',
  })
  public async rpcHandler(msg: {}) {
    return {
      response: 42,
    };
  }
}
```

--------------------------------

### Prevent RabbitMQ Connection During NestJS Tests

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

Demonstrates how to prevent RabbitMQ connections during testing in a NestJS application. By passing `undefined` as the configuration object to `RabbitMQModule.forRoot` when `process.env.NODE_ENV` is 'test', the connection process is effectively ignored. This is essential for running unit tests without requiring a live RabbitMQ broker.

```typescript
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 {}
```

--------------------------------

### Configure HasuraModule with NestJS

Source: https://golevelup.github.io/nestjs/modules/hasura

Configure the HasuraModule within your NestJS application's AppModule. This includes setting up webhook security with a secret factory and header, and optionally managing Hasura metadata automatically.

```typescript
import { HasuraModule } from '@golevelup/nestjs-hasura';
import { join } from 'path';

@Module({
  imports: [
    HasuraModule.forRoot({
      webhookConfig: {
        secretFactory: secret,
        secretHeader: secretHeader,
      },
      managedMetaDataConfig: {
        dirPath: join(process.cwd(), 'hasura/metadata'),
        secretHeaderEnvName: 'HASURA_NESTJS_WEBHOOK_SECRET_HEADER_VALUE',
        nestEndpointEnvName: 'NESTJS_EVENT_WEBHOOK_ENDPOINT',
        defaultEventRetryConfig: {
          intervalInSeconds: 15,
          numRetries: 3,
          timeoutInSeconds: 100,
          toleranceSeconds: 21600,
        },
      },
    }),
  ],
})
export class AppModule {
  // ...
}
```

--------------------------------

### Re-Use Configured Dynamic Module in NestJS

Source: https://golevelup.github.io/nestjs/modules

Demonstrates how to re-use a configured dynamic module in another module using the `externallyConfigured` static method. This method takes the module class and an optional timeout for asynchronous configurations.

```typescript
@Module({
  imports: [ConfigModule.externallyConfigured(ConfigModule, 0)],
})
export class ConfigModuleDependentModule {}

```

--------------------------------

### Configure Stripe Webhook Decorators in NestJS

Source: https://golevelup.github.io/nestjs/modules/stripe

Demonstrates how to apply class decorators, such as `@SkipThrottle` from `@nestjs/throttler`, to Stripe webhook handlers using the `decorators` property within the `webhookConfig` object during module initialization. This is useful for selectively disabling features like throttling for specific webhook endpoints.

```typescript
StripeModule.forRoot({
  apiKey: 'sk_***',
  webhookConfig: {
    stripeSecrets: { ... },
    decorators: [SkipThrottle()],
  },
}),
```

--------------------------------

### Custom Message Serialization and Deserialization in NestJS RabbitMQ

Source: https://golevelup.github.io/nestjs/modules/rabbitmq

Customize how messages are serialized before publishing and deserialized upon receiving by providing custom functions to the `serializer` and `deserializer` options in the RabbitMQModule configuration. This allows for handling formats other than JSON.

```typescript
import {
  RabbitMQModule,
} from '@golevelup/nestjs-rabbitmq';
import { Module } from '@nestjs/common';
import { MessagingController } from './messaging/messaging.controller';
import { MessagingService } from './messaging/messaging.service';
import { ConsumeMessage } from 'amqplib';

@Module({
  imports: [
    RabbitMQModule.forRoot({
      // ...
      deserializer: (message: Buffer, msg: ConsumeMessage) => {
        const decodedMessage = myCustomDeserializer(
          msg.toString(),
          msg.properties.headers,
        );
        return decodedMessage;
      },
      serializer: (msg: any) => {
        const encodedMessage = myCustomSerializer(msg);
        return Buffer.from(encodedMessage);
      },
    }),
  ],
  // ...
})
export class RabbitExampleModule {}
```

--------------------------------

### Enable Raw Request Body for Webhook Processing

Source: https://golevelup.github.io/nestjs/modules/stripe

Configures the NestJS application to handle raw request bodies, which is essential for Stripe's webhook event validation. This involves setting the `rawBody` option when creating the Nest application and configuring `requestBodyProperty` in the StripeModule.

```typescript
// main.ts
const app = await NestFactory.create<NestExpressApplication>(AppModule, {
  rawBody: true,
});

```

```typescript
StripeModule.forRoot({
  apiKey: 'sk_***',
  webhookConfig: {
    stripeSecrets: { ... },
    requestBodyProperty: 'rawBody', // <-- Set to 'rawBody'
  },
});

```

--------------------------------

### Conditional Enhancer Logic for Stripe Webhook Contexts in NestJS

Source: https://golevelup.github.io/nestjs/modules/stripe

Shows how to implement conditional logic within NestJS enhancers (Interceptors, Guards, Filters) to differentiate between standard HTTP contexts and Stripe webhook contexts. It utilizes the `STRIPE_WEBHOOK_CONTEXT_TYPE` constant to identify Stripe webhook events and allows for custom logic execution only for non-Stripe webhook contexts.

```typescript
import { STRIPE_WEBHOOK_CONTEXT_TYPE } from '@golevelup/stripe';

@Injectable()
class ExampleInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler<any>) {
    const contextType = context.getType<
      'http' | typeof STRIPE_WEBHOOK_CONTEXT_TYPE
    >();

    // Do nothing if this is a Stripe webhook event
    if (contextType === STRIPE_WEBHOOK_CONTEXT_TYPE) {
      return next.handle();
    }

    // Execute custom interceptor logic for HTTP request/response
    return next.handle();
  }
}
```
Tokens:
Raw