@anchan828/nest-redlock v0.4.0

@anchan828/nest-redlock

This is a Nest implementation of the redlock algorithm for distributed redis locks.

This package uses node-redlock.

Installation

$ npm i --save @anchan828/nest-redlock ioredis

Quick Start

1. Import module

import { RedlockModule } from "@anchan828/nest-redlock";
import Redis from "ioredis";

@Module({
  imports: [
    RedlockModule.register({
      // See https://github.com/mike-marcacci/node-redlock#configuration
      clients: [new Redis({ host: "localhost" })],
      settings: {
        driftFactor: 0.01,
        retryCount: 10,
        retryDelay: 200,
        retryJitter: 200,
        automaticExtensionThreshold: 500,
      },
      // Default duratiuon to use with Redlock decorator
      duration: 1000,
    }),
  ],
})
export class AppModule {}

2. Add Redlock decorator

import { Redlock } from "@anchan828/nest-redlock";

@Injectable()
export class ExampleService {
  @Redlock("lock-key")
  public async addComment(projectId: number, comment: string): Promise<void> {}
}

This is complete. redlock is working correctly! See node-redlock for more information on redlock.

Define complex resources (lock keys)

Using constants causes the same lock key to be used for all calls. Let's reduce the scope a bit more.

In this example, only certain projects are now locked.

import { Redlock } from "@anchan828/nest-redlock";

@Injectable()
export class ExampleService {
  // The arguments define the class object to which the decorator is being added and the method arguments in order.
  @Redlock<ExampleService["addComment"]>(
    (target: ExampleService, projectId: number, comment: string) => `projects/${projectId}/comments`,
  )
  public async addComment(projectId: number, comment: string): Promise<void> {}
}

Of course, you can lock multiple keys.

@Injectable()
export class ExampleService {
  @Redlock<ExampleService["updateComments"]>(
    (target: ExampleService, projectId: number, args: Array<{ commentId: number; comment: string }>) =>
      args.map((arg) => `projects/${projectId}/comments/${arg.commentId}`),
  )
  public async updateComments(projectId: number, args: Array<{ commentId: number; comment: string }>): Promise<void> {}
}

Using Redlock service

If you want to use node-redlock as is, use RedlockService.

import { RedlockService } from "@anchan828/nest-redlock";

@Injectable()
export class ExampleService {
  constructor(private readonly redlock: RedlockService) {}

  public async addComment(projectId: number, comment: string): Promise<void> {
    await this.redlock.using([`projects/${projectId}/comments`], 5000, (signal) => {
      // Do something...

      if (signal.aborted) {
        throw signal.error;
      }
    });
  }
}

Using fake RedlockService

If you do not want to use Redis in your Unit tests, define the fake class as RedlockService.

const app = await Test.createTestingModule({
  providers: [TestService, { provide: RedlockService, useClass: FakeRedlockService }],
}).compile();

Troubleshooting

Nest can't resolve dependencies of the XXX. Please make sure that the "@redlockService" property is available in the current context.

This is the error output when using the Redlock decorator without importing the RedlockModule.

import { RedlockModule } from "@anchan828/nest-redlock";
import Redis from "ioredis";

@Module({
  imports: [
    RedlockModule.register({
      clients: [new Redis({ host: "localhost" })],
    }),
  ],
})
export class AppModule {}

What should I do with Unit tests, I don't want to use Redis.

Use FakeRedlockService class. Register FakeRedlockService with the provider as RedlockService.

const app = await Test.createTestingModule({
  providers: [TestService, { provide: RedlockService, useClass: FakeRedlockService }],
}).compile();

License

MIT