@anchan828/nest-redlock 0.0.6 → 0.0.9

package/README.md

@@ -18,12 +18,12 @@ $ npm i --save @anchan828/nest-redlock ioredis
 ### 1. Import module
 
 ```ts
-import { RedisRedlockModule } from "@anchan828/nest-redlock";
+import { RedlockModule } from "@anchan828/nest-redlock";
 import Redis from "ioredis";
 
 @Module({
   imports: [
-    RedisRedlockModule.register({
+    RedlockModule.register({
       // See https://github.com/mike-marcacci/node-redlock#configuration
       clients: [new Redis({ host: "localhost" })],
       settings: {
@@ -33,7 +33,7 @@ import Redis from "ioredis";
         retryJitter: 200,
         automaticExtensionThreshold: 500,
       },
-      // Default duratiuon to use with RedisRedlock decorator
+      // Default duratiuon to use with Redlock decorator
       duration: 1000,
     }),
   ],
@@ -41,14 +41,14 @@ import Redis from "ioredis";
 export class AppModule {}
 ```
 
-### 2. Add `RedisRedlock` decorator
+### 2. Add `Redlock` decorator
 
 ```ts
-import { RedisRedlock } from "@anchan828/nest-redlock";
+import { Redlock } from "@anchan828/nest-redlock";
 
 @Injectable()
 export class ExampleService {
-  @RedisRedlock("lock-key")
+  @Redlock("lock-key")
   public async addComment(projectId: number, comment: string): Promise<void> {}
 }
 ```
@@ -58,17 +58,17 @@ See [node-redlock](https://github.com/mike-marcacci/node-redlock) for more infor
 
 ## Define complex resources (lock keys)
 
-If you use a constant, it will be locked on all calls. Let's make the range a little smaller.
+Using constants causes the same lock key to be used for all calls. Let's reduce the range a bit more.
 
 In this example, only certain projects are now locked.
 
 ```ts
-import { RedisRedlock } from "@anchan828/nest-redlock";
+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.
-  @RedisRedlock((target: ExampleService, projectId: number, comment: string) => `projects/${projectId}/comments`)
+  @Redlock((target: ExampleService, projectId: number, comment: string) => `projects/${projectId}/comments`)
   public async addComment(projectId: number, comment: string): Promise<void> {}
 }
 ```
@@ -78,7 +78,7 @@ Of course, you can lock multiple keys.
 ```ts
 @Injectable()
 export class ExampleService {
-  @RedisRedlock((target: ExampleService, projectId: number, args: Array<{ commentId: number; comment: string }>) =>
+  @Redlock((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> {}
@@ -87,14 +87,14 @@ export class ExampleService {
 
 ## Using Redlock service
 
-If you want to use node-redlock as is, use RedisRedlockService.
+If you want to use node-redlock as is, use RedlockService.
 
 ```ts
-import { RedisRedlockService } from "@anchan828/nest-redlock";
+import { RedlockService } from "@anchan828/nest-redlock";
 
 @Injectable()
 export class ExampleService {
-  constructor(private readonly redlock: RedisRedlockService) {}
+  constructor(private readonly redlock: RedlockService) {}
 
   public async addComment(projectId: number, comment: string): Promise<void> {
     await this.redlock.using([`projects/${projectId}/comments`], 5000, (signal) => {
@@ -108,29 +108,29 @@ export class ExampleService {
 }
 ```
 
-## Using the RedisRedlockService mock
+## Using the RedlockService mock
 
-If you do not want to use Redis in your Unit tests, define the mock class as RedisRedlockService.
+If you do not want to use Redis in your Unit tests, define the mock class as RedlockService.
 
 ```ts
 const app = await Test.createTestingModule({
-  providers: [TestService, { provide: RedisRedlockService, useClass: MockRedisRedlockService }],
+  providers: [TestService, { provide: RedlockService, useClass: MockRedlockService }],
 }).compile();
 ```
 
 ## Troubleshooting
 
-### Nest can't resolve dependencies of the XXX. Please make sure that the "@redisRedlockService" property is available in the current context.
+### 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 RedisRedlock decorator without importing the RedisRedlockModule.
+This is the error output when using the Redlock decorator without importing the RedlockModule.
 
 ```ts
-import { RedisRedlockModule } from "@anchan828/nest-redlock";
+import { RedlockModule } from "@anchan828/nest-redlock";
 import Redis from "ioredis";
 
 @Module({
   imports: [
-    RedisRedlockModule.register({
+    RedlockModule.register({
       clients: [new Redis({ host: "localhost" })],
     }),
   ],
@@ -140,11 +140,11 @@ export class AppModule {}
 
 #### What should I do with Unit tests, I don't want to use Redis.
 
-Use `MockRedisRedlockService` class. Register MockRedisRedlockService with the provider as RedisRedlockService.
+Use `MockRedlockService` class. Register MockRedlockService with the provider as RedlockService.
 
 ```ts
 const app = await Test.createTestingModule({
-  providers: [TestService, { provide: RedisRedlockService, useClass: MockRedisRedlockService }],
+  providers: [TestService, { provide: RedlockService, useClass: MockRedlockService }],
 }).compile();
 ```
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { RedisRedlock } from "./redis-redlock.decorator";
-export { GenerateResourceFunc, RedisRedlockModuleOptions } from "./redis-redlock.interface";
-export { MockRedisRedlockService } from "./redis-redlock.mock-service";
-export { RedisRedlockModule } from "./redis-redlock.module";
-export { RedisRedlockService } from "./redis-redlock.service";
+export { Redlock } from "./redlock.decorator";
+export { GenerateResourceFunc, RedlockModuleOptions } from "./redlock.interface";
+export { MockRedlockService } from "./redlock.mock-service";
+export { RedlockModule } from "./redlock.module";
+export { RedlockService } from "./redlock.service";

package/dist/index.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisRedlockService = exports.RedisRedlockModule = exports.MockRedisRedlockService = exports.RedisRedlock = void 0;
-var redis_redlock_decorator_1 = require("./redis-redlock.decorator");
-Object.defineProperty(exports, "RedisRedlock", { enumerable: true, get: function () { return redis_redlock_decorator_1.RedisRedlock; } });
-var redis_redlock_mock_service_1 = require("./redis-redlock.mock-service");
-Object.defineProperty(exports, "MockRedisRedlockService", { enumerable: true, get: function () { return redis_redlock_mock_service_1.MockRedisRedlockService; } });
-var redis_redlock_module_1 = require("./redis-redlock.module");
-Object.defineProperty(exports, "RedisRedlockModule", { enumerable: true, get: function () { return redis_redlock_module_1.RedisRedlockModule; } });
-var redis_redlock_service_1 = require("./redis-redlock.service");
-Object.defineProperty(exports, "RedisRedlockService", { enumerable: true, get: function () { return redis_redlock_service_1.RedisRedlockService; } });
+exports.RedlockService = exports.RedlockModule = exports.MockRedlockService = exports.Redlock = void 0;
+var redlock_decorator_1 = require("./redlock.decorator");
+Object.defineProperty(exports, "Redlock", { enumerable: true, get: function () { return redlock_decorator_1.Redlock; } });
+var redlock_mock_service_1 = require("./redlock.mock-service");
+Object.defineProperty(exports, "MockRedlockService", { enumerable: true, get: function () { return redlock_mock_service_1.MockRedlockService; } });
+var redlock_module_1 = require("./redlock.module");
+Object.defineProperty(exports, "RedlockModule", { enumerable: true, get: function () { return redlock_module_1.RedlockModule; } });
+var redlock_service_1 = require("./redlock.service");
+Object.defineProperty(exports, "RedlockService", { enumerable: true, get: function () { return redlock_service_1.RedlockService; } });

package/dist/redlock.decorator.d.ts

@@ -0,0 +1,3 @@
+import { Settings } from "redlock";
+import { GenerateResourceFunc } from "./redlock.interface";
+export declare function Redlock(resource: string | string[] | GenerateResourceFunc, duration?: number, settings?: Partial<Settings>): MethodDecorator;

package/dist/{redis-redlock.decorator.js → redlock.decorator.js}

@@ -1,20 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisRedlock = void 0;
+exports.Redlock = void 0;
 const common_1 = require("@nestjs/common");
-const redis_redlock_service_1 = require("./redis-redlock.service");
-function RedisRedlock(resource, duration, settings = {}) {
-    const injectRedisRedlockService = (0, common_1.Inject)(redis_redlock_service_1.RedisRedlockService);
+const redlock_constants_1 = require("./redlock.constants");
+const redlock_service_1 = require("./redlock.service");
+function Redlock(resource, duration, settings = {}) {
+    const injectRedlockService = (0, common_1.Inject)(redlock_service_1.RedlockService);
     return (target, propertyKey, descriptor) => {
-        const serviceSymbol = "@redisRedlockService";
-        injectRedisRedlockService(target, serviceSymbol);
+        const serviceSymbol = "@redlockService";
+        injectRedlockService(target, serviceSymbol);
         const originalMethod = descriptor.value;
         descriptor.value = async function (...args) {
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             const descriptorThis = this;
-            const redisRedlockService = descriptorThis[serviceSymbol];
+            const redlockService = descriptorThis[serviceSymbol];
             const resources = getResources(resource, descriptorThis, args);
-            return await redisRedlockService.using(resources, duration || redisRedlockService.options.duration || 5000, settings, async (signal) => {
+            return await redlockService.using(resources, duration || redlockService.options?.duration || redlock_constants_1.DEFAULT_DURATION, settings, async (signal) => {
                 const result = await originalMethod.apply(descriptorThis, args);
                 if (signal.aborted) {
                     throw signal.error;
@@ -25,7 +26,7 @@ function RedisRedlock(resource, duration, settings = {}) {
         return descriptor;
     };
 }
-exports.RedisRedlock = RedisRedlock;
+exports.Redlock = Redlock;
 function getResources(resource, descriptorThis, args) {
     if (typeof resource === "string") {
         return [resource];

package/dist/{redis-redlock.interface.d.ts → redlock.interface.d.ts}

@@ -1,6 +1,6 @@
 import Redis, { Cluster } from "ioredis";
 import { Settings } from "redlock";
-export declare type RedisRedlockModuleOptions = {
+export declare type RedlockModuleOptions = {
     clients: Iterable<Redis | Cluster>;
     settings?: Partial<Settings>;
     scripts?: {
@@ -9,7 +9,7 @@ export declare type RedisRedlockModuleOptions = {
         readonly releaseScript?: string | ((script: string) => string);
     };
     /**
-     * Default duratiuon to use with RedisRedlock decorator
+     * Default duratiuon to use with Redlock decorator
      *
      * @type {number}
      */

package/dist/{redis-redlock.mock-service.d.ts → redlock.mock-service.d.ts}

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { ExecutionResult, Lock, RedlockAbortSignal, Settings } from "redlock";
 import { EventEmitter } from "stream";
-export declare class MockRedisRedlockService extends EventEmitter {
+export declare class MockRedlockService extends EventEmitter {
     quit(): Promise<void>;
     acquire(resources: string[], duration: number, settings?: Partial<Settings> | undefined): Promise<Lock>;
     release(lock: Lock, settings?: Partial<Settings> | undefined): Promise<ExecutionResult>;

package/dist/{redis-redlock.mock-service.js → redlock.mock-service.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockRedisRedlockService = void 0;
+exports.MockRedlockService = void 0;
 const stream_1 = require("stream");
-class MockRedisRedlockService extends stream_1.EventEmitter {
+class MockRedlockService extends stream_1.EventEmitter {
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     async quit() { }
     async acquire(resources, duration, settings) {
@@ -19,7 +19,7 @@ class MockRedisRedlockService extends stream_1.EventEmitter {
         return await routineFunc?.({ aborted: false });
     }
 }
-exports.MockRedisRedlockService = MockRedisRedlockService;
+exports.MockRedlockService = MockRedlockService;
 function createLockMock() {
     let lock;
     // eslint-disable-next-line prefer-const

package/dist/redlock.module-definition.d.ts

@@ -0,0 +1,2 @@
+import { RedlockModuleOptions } from "./redlock.interface";
+export declare const ConfigurableModuleClass: import("@nestjs/common").ConfigurableModuleCls<RedlockModuleOptions, "register", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol;

package/dist/redlock.module.d.ts

@@ -0,0 +1,8 @@
+import { OnModuleDestroy } from "@nestjs/common";
+import { RedlockModuleOptions } from "./redlock.interface";
+import { ConfigurableModuleClass } from "./redlock.module-definition";
+export declare class RedlockModule extends ConfigurableModuleClass implements OnModuleDestroy {
+    private readonly options;
+    constructor(options: RedlockModuleOptions);
+    onModuleDestroy(): Promise<void>;
+}

package/dist/{redis-redlock.module.js → redlock.module.js}

@@ -12,11 +12,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisRedlockModule = void 0;
+exports.RedlockModule = void 0;
 const common_1 = require("@nestjs/common");
-const redis_redlock_module_definition_1 = require("./redis-redlock.module-definition");
-const redis_redlock_service_1 = require("./redis-redlock.service");
-let RedisRedlockModule = class RedisRedlockModule extends redis_redlock_module_definition_1.ConfigurableModuleClass {
+const redlock_module_definition_1 = require("./redlock.module-definition");
+const redlock_service_1 = require("./redlock.service");
+let RedlockModule = class RedlockModule extends redlock_module_definition_1.ConfigurableModuleClass {
     constructor(options) {
         super();
         this.options = options;
@@ -36,18 +36,18 @@ let RedisRedlockModule = class RedisRedlockModule extends redis_redlock_module_d
         }
     }
 };
-RedisRedlockModule = __decorate([
+RedlockModule = __decorate([
     (0, common_1.Module)({
         providers: [
             {
-                provide: redis_redlock_service_1.RedisRedlockService,
-                inject: [redis_redlock_module_definition_1.MODULE_OPTIONS_TOKEN],
-                useFactory: (options) => new redis_redlock_service_1.RedisRedlockService(options),
+                provide: redlock_service_1.RedlockService,
+                inject: [redlock_module_definition_1.MODULE_OPTIONS_TOKEN],
+                useFactory: (options) => new redlock_service_1.RedlockService(options),
             },
         ],
-        exports: [redis_redlock_service_1.RedisRedlockService],
+        exports: [redlock_service_1.RedlockService],
     }),
-    __param(0, (0, common_1.Inject)(redis_redlock_module_definition_1.MODULE_OPTIONS_TOKEN)),
+    __param(0, (0, common_1.Inject)(redlock_module_definition_1.MODULE_OPTIONS_TOKEN)),
     __metadata("design:paramtypes", [Object])
-], RedisRedlockModule);
-exports.RedisRedlockModule = RedisRedlockModule;
+], RedlockModule);
+exports.RedlockModule = RedlockModule;

package/dist/redlock.service.d.ts

@@ -0,0 +1,6 @@
+import Redlock from "redlock";
+import { RedlockModuleOptions } from "./redlock.interface";
+export declare class RedlockService extends Redlock {
+    readonly options: RedlockModuleOptions;
+    constructor(options: RedlockModuleOptions);
+}

package/dist/{redis-redlock.service.js → redlock.service.js}

@@ -12,19 +12,19 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisRedlockService = void 0;
+exports.RedlockService = void 0;
 const common_1 = require("@nestjs/common");
 const redlock_1 = require("redlock");
-const redis_redlock_module_definition_1 = require("./redis-redlock.module-definition");
-let RedisRedlockService = class RedisRedlockService extends redlock_1.default {
+const redlock_module_definition_1 = require("./redlock.module-definition");
+let RedlockService = class RedlockService extends redlock_1.default {
     constructor(options) {
         super(options.clients, options.settings, options.scripts);
         this.options = options;
     }
 };
-RedisRedlockService = __decorate([
+RedlockService = __decorate([
     (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Inject)(redis_redlock_module_definition_1.MODULE_OPTIONS_TOKEN)),
+    __param(0, (0, common_1.Inject)(redlock_module_definition_1.MODULE_OPTIONS_TOKEN)),
     __metadata("design:paramtypes", [Object])
-], RedisRedlockService);
-exports.RedisRedlockService = RedisRedlockService;
+], RedlockService);
+exports.RedlockService = RedlockService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchan828/nest-redlock",
-  "version": "0.0.6",
+  "version": "0.0.9",
   "description": "This is a [Nest](https://github.com/nestjs/nest) implementation of the redlock algorithm for distributed redis locks.",
   "homepage": "https://github.com/anchan828/nest-redlock#readme",
   "bugs": {
@@ -41,7 +41,7 @@
     "eslint-config-prettier": "8.5.0",
     "eslint-plugin-prettier": "4.2.1",
     "husky": "8.0.1",
-    "ioredis": "5.2.2",
+    "ioredis": "5.2.3",
     "jest": "28.1.3",
     "lint-staged": "13.0.3",
     "prettier": "2.7.1",

package/dist/redis-redlock.decorator.d.ts

@@ -1,3 +0,0 @@
-import { Settings } from "redlock";
-import { GenerateResourceFunc } from "./redis-redlock.interface";
-export declare function RedisRedlock(resource: string | string[] | GenerateResourceFunc, duration?: number, settings?: Partial<Settings>): MethodDecorator;

package/dist/redis-redlock.module-definition.d.ts

@@ -1,2 +0,0 @@
-import { RedisRedlockModuleOptions } from "./redis-redlock.interface";
-export declare const ConfigurableModuleClass: import("@nestjs/common").ConfigurableModuleCls<RedisRedlockModuleOptions, "register", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol;

package/dist/redis-redlock.module.d.ts

@@ -1,8 +0,0 @@
-import { OnModuleDestroy } from "@nestjs/common";
-import { RedisRedlockModuleOptions } from "./redis-redlock.interface";
-import { ConfigurableModuleClass } from "./redis-redlock.module-definition";
-export declare class RedisRedlockModule extends ConfigurableModuleClass implements OnModuleDestroy {
-    private readonly options;
-    constructor(options: RedisRedlockModuleOptions);
-    onModuleDestroy(): Promise<void>;
-}

package/dist/redis-redlock.service.d.ts

@@ -1,6 +0,0 @@
-import Redlock from "redlock";
-import { RedisRedlockModuleOptions } from "./redis-redlock.interface";
-export declare class RedisRedlockService extends Redlock {
-    readonly options: RedisRedlockModuleOptions;
-    constructor(options: RedisRedlockModuleOptions);
-}