@anchan828/nest-redlock 0.0.12 → 0.1.2

package/README.md

@@ -68,7 +68,9 @@ 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((target: ExampleService, projectId: number, comment: string) => `projects/${projectId}/comments`)
+  @Redlock<ExampleService["addComment"]>(
+    (target: ExampleService, projectId: number, comment: string) => `projects/${projectId}/comments`,
+  )
   public async addComment(projectId: number, comment: string): Promise<void> {}
 }
 ```
@@ -78,8 +80,9 @@ Of course, you can lock multiple keys.
 ```ts
 @Injectable()
 export class ExampleService {
-  @Redlock((target: ExampleService, projectId: number, args: Array<{ commentId: number; comment: string }>) =>
-    args.map((arg) => `projects/${projectId}/comments/${arg.commentId}`),
+  @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> {}
 }
@@ -108,7 +111,7 @@ export class ExampleService {
 }
 ```
 
-## Using fake RedlockService 
+## Using fake RedlockService
 
 If you do not want to use Redis in your Unit tests, define the fake class as RedlockService.
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { Redlock } from "./redlock.decorator";
 export { FakeRedlockService } from "./redlock.fake-service";
-export { GenerateResourceFunc, RedlockModuleOptions } from "./redlock.interface";
+export { RedlockKeyFunction, RedlockModuleOptions } from "./redlock.interface";
 export { RedlockModule } from "./redlock.module";
 export { RedlockService } from "./redlock.service";

package/dist/redlock.decorator.d.ts

@@ -1,3 +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;
+import { RedlockKeyFunction } from "./redlock.interface";
+export declare function Redlock<T extends (...args: any) => any = (...args: any) => any>(key: string | string[] | RedlockKeyFunction<T>, duration?: number, settings?: Partial<Settings>): MethodDecorator;

package/dist/redlock.decorator.js

@@ -4,7 +4,7 @@ exports.Redlock = void 0;
 const common_1 = require("@nestjs/common");
 const redlock_constants_1 = require("./redlock.constants");
 const redlock_service_1 = require("./redlock.service");
-function Redlock(resource, duration, settings = {}) {
+function Redlock(key, duration, settings = {}) {
     const injectRedlockService = (0, common_1.Inject)(redlock_service_1.RedlockService);
     return (target, propertyKey, descriptor) => {
         const serviceSymbol = "@redlockService";
@@ -14,8 +14,8 @@ function Redlock(resource, duration, settings = {}) {
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             const descriptorThis = this;
             const redlockService = descriptorThis[serviceSymbol];
-            const resources = getResources(resource, descriptorThis, args);
-            return await redlockService.using(resources, duration || redlockService.options?.duration || redlock_constants_1.DEFAULT_DURATION, settings, async (signal) => {
+            const keys = getKeys(key, descriptorThis, args);
+            return await redlockService.using(keys, 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;
@@ -27,15 +27,15 @@ function Redlock(resource, duration, settings = {}) {
     };
 }
 exports.Redlock = Redlock;
-function getResources(resource, descriptorThis, args) {
-    if (typeof resource === "string") {
-        return [resource];
+function getKeys(key, descriptorThis, args) {
+    if (typeof key === "string") {
+        return [key];
     }
-    else if (Array.isArray(resource)) {
-        return resource;
+    else if (Array.isArray(key)) {
+        return key;
     }
-    else if (typeof resource === "function") {
-        return [resource(descriptorThis, ...args)].flat();
+    else if (typeof key === "function") {
+        return [key(descriptorThis, ...args)].flat();
     }
     return [];
 }

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

@@ -3,9 +3,9 @@ import { EventEmitter } from "events";
 import { ExecutionResult, Lock, RedlockAbortSignal, Settings } from "redlock";
 export declare class FakeRedlockService extends EventEmitter {
     quit(): Promise<void>;
-    acquire(resources: string[], duration: number, settings?: Partial<Settings> | undefined): Promise<Lock>;
+    acquire(keys: string[], duration: number, settings?: Partial<Settings> | undefined): Promise<Lock>;
     release(lock: Lock, settings?: Partial<Settings> | undefined): Promise<ExecutionResult>;
     extend(existing: Lock, duration: number, settings?: Partial<Settings> | undefined): Promise<Lock>;
-    using<T>(resources: string[], duration: number, settings: Partial<Settings>, routine?: ((signal: RedlockAbortSignal) => Promise<T>) | undefined): Promise<T>;
-    using<T>(resources: string[], duration: number, routine: (signal: RedlockAbortSignal) => Promise<T>): Promise<T>;
+    using<T>(keys: string[], duration: number, settings: Partial<Settings>, routine?: ((signal: RedlockAbortSignal) => Promise<T>) | undefined): Promise<T>;
+    using<T>(keys: string[], duration: number, routine: (signal: RedlockAbortSignal) => Promise<T>): Promise<T>;
 }

package/dist/redlock.fake-service.js

@@ -6,7 +6,7 @@ const events_1 = require("events");
 class FakeRedlockService extends events_1.EventEmitter {
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     async quit() { }
-    async acquire(resources, duration, settings) {
+    async acquire(keys, duration, settings) {
         return createLockFake();
     }
     async release(lock, settings) {
@@ -15,7 +15,7 @@ class FakeRedlockService extends events_1.EventEmitter {
     async extend(existing, duration, settings) {
         return createLockFake();
     }
-    async using(resources, duration, settingsOrRoutine, routine) {
+    async using(keys, duration, settingsOrRoutine, routine) {
         const routineFunc = typeof settingsOrRoutine === "function" ? settingsOrRoutine : routine;
         return await routineFunc?.({ aborted: false });
     }

package/dist/redlock.interface.d.ts

@@ -15,4 +15,4 @@ export declare type RedlockModuleOptions = {
      */
     duration?: number;
 };
-export declare type GenerateResourceFunc = (target: any, ...args: any[]) => string | string[];
+export declare type RedlockKeyFunction<T extends (...args: any) => any = (...args: any) => any> = (target: any, ...args: Parameters<T>) => string[] | string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchan828/nest-redlock",
-  "version": "0.0.12",
+  "version": "0.1.2",
   "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": {
@@ -33,24 +33,24 @@
     "@nestjs/platform-express": "^9.0.11",
     "@nestjs/testing": "^9.0.11",
     "@types/jest": "^29.0.0",
-    "@types/node": "^18.7.14",
+    "@types/node": "^18.7.16",
     "@types/supertest": "^2.0.12",
-    "@typescript-eslint/eslint-plugin": "^5.36.1",
-    "@typescript-eslint/parser": "^5.36.1",
+    "@typescript-eslint/eslint-plugin": "^5.36.2",
+    "@typescript-eslint/parser": "^5.36.2",
     "eslint": "^8.23.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-prettier": "^4.2.1",
     "husky": "^8.0.1",
     "ioredis": "^5.2.3",
-    "jest": "^29.0.2",
+    "jest": "^29.0.3",
     "lint-staged": "^13.0.3",
     "prettier": "^2.7.1",
     "reflect-metadata": "^0.1.13",
     "rxjs": "^7.5.6",
     "supertest": "^6.2.4",
-    "ts-jest": "^29.0.0-next.1",
+    "ts-jest": "^29.0.0",
     "ts-node": "^10.9.1",
-    "typescript": "^4.8.2"
+    "typescript": "^4.8.3"
   },
   "volta": {
     "node": "18.4.0"