@anchan828/nest-sesamecare-redlock 0.2.44

package/README.md

@@ -0,0 +1,159 @@
+# @anchan828/nest-sesamecare-redlock
+
+![npm](https://img.shields.io/npm/v/@anchan828/nest-sesamecare-redlock.svg)
+![NPM](https://img.shields.io/npm/l/@anchan828/nest-sesamecare-redlock.svg)
+
+This is a [Nest](https://github.com/nestjs/nest) implementation of the redlock algorithm for distributed redis locks.
+
+This package uses [@sesamecare-oss/redlock](https://github.com/sesamecare/redlock).
+
+> [!NOTE]
+> This is one of the solutions to provisionally address the various issues with node-redlock that don't seem likely to be resolved soon. For details, please see https://github.com/anchan828/nest-redlock/pull/723.
+
+## Installation
+
+```bash
+$ npm i --save @anchan828/nest-sesamecare-redlock ioredis
+```
+
+## Quick Start
+
+### 1. Import module
+
+```ts
+import { RedlockModule } from "@anchan828/nest-sesamecare-redlock";
+import Redis from "ioredis";
+
+@Module({
+  imports: [
+    RedlockModule.register({
+      // See https://github.com/sesamecare/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
+
+```ts
+import { Redlock } from "@anchan828/nest-sesamecare-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](https://github.com/sesamecare/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.
+
+```ts
+import { Redlock } from "@anchan828/nest-sesamecare-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.
+
+```ts
+@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.
+
+```ts
+import { RedlockService } from "@anchan828/nest-sesamecare-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.
+
+```ts
+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.
+
+```ts
+import { RedlockModule } from "@anchan828/nest-sesamecare-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.
+
+```ts
+const app = await Test.createTestingModule({
+  providers: [TestService, { provide: RedlockService, useClass: FakeRedlockService }],
+}).compile();
+```
+
+## License
+
+[MIT](LICENSE)

package/dist/cjs/index.d.ts

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

package/dist/cjs/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedlockService = exports.RedlockModule = exports.FakeRedlockService = 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_fake_service_1 = require("./redlock.fake-service");
+Object.defineProperty(exports, "FakeRedlockService", { enumerable: true, get: function () { return redlock_fake_service_1.FakeRedlockService; } });
+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/cjs/redlock.constants.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_DURATION = 5000;

package/dist/cjs/redlock.constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DURATION = void 0;
+exports.DEFAULT_DURATION = 5000;

package/dist/cjs/redlock.decorator.d.ts

@@ -0,0 +1,3 @@
+import { Settings } from "@sesamecare-oss/redlock";
+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/cjs/redlock.decorator.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Redlock = Redlock;
+const common_1 = require("@nestjs/common");
+const redlock_constants_1 = require("./redlock.constants");
+const redlock_service_1 = require("./redlock.service");
+function Redlock(key, duration, settings = {}) {
+    const injectRedlockService = (0, common_1.Inject)(redlock_service_1.RedlockService);
+    return (target, propertyKey, descriptor) => {
+        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 redlockService = descriptorThis[serviceSymbol];
+            if (redlockService?.options?.decoratorEnabled !== undefined && !redlockService.options.decoratorEnabled) {
+                return await originalMethod.apply(descriptorThis, args);
+            }
+            const keys = getKeys(key, descriptorThis, args);
+            const useDuration = duration || redlockService.options?.duration || redlock_constants_1.DEFAULT_DURATION;
+            await redlockService.options?.decoratorHooks?.preLockKeys?.({ keys, duration: useDuration });
+            const startTime = Date.now();
+            return await redlockService
+                .using(keys, useDuration, settings, async (signal) => {
+                if (signal.aborted) {
+                    throw signal.error;
+                }
+                await redlockService.options?.decoratorHooks?.lockedKeys?.({
+                    keys,
+                    duration: useDuration,
+                    elapsedTime: Date.now() - startTime,
+                });
+                const result = await originalMethod.apply(descriptorThis, args);
+                return result;
+            })
+                .finally(async () => {
+                await redlockService.options?.decoratorHooks?.unlockedKeys?.({
+                    keys,
+                    duration: useDuration,
+                    elapsedTime: Date.now() - startTime,
+                });
+            });
+        };
+        return descriptor;
+    };
+}
+function getKeys(key, descriptorThis, args) {
+    const keys = new Set();
+    if (typeof key === "string") {
+        keys.add(key);
+    }
+    else if (Array.isArray(key)) {
+        key.forEach((k) => keys.add(k));
+    }
+    else if (typeof key === "function") {
+        [key(descriptorThis, ...args)].flat().forEach((k) => keys.add(k));
+    }
+    return Array.from(keys);
+}

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

@@ -0,0 +1,10 @@
+import { ExecutionResult, Lock, RedlockAbortSignal, Settings } from "@sesamecare-oss/redlock";
+import { EventEmitter } from "events";
+export declare class FakeRedlockService extends EventEmitter {
+    quit(): Promise<void>;
+    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>(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/cjs/redlock.fake-service.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeRedlockService = void 0;
+const events_1 = require("events");
+class FakeRedlockService extends events_1.EventEmitter {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    async quit() { }
+    async acquire(keys, duration, settings) {
+        return createLockFake();
+    }
+    async release(lock, settings) {
+        return { attempts: [], start: Date.now() };
+    }
+    async extend(existing, duration, settings) {
+        return createLockFake();
+    }
+    async using(keys, duration, settingsOrRoutine, routine) {
+        const routineFunc = typeof settingsOrRoutine === "function" ? settingsOrRoutine : routine;
+        return await routineFunc?.({ aborted: false });
+    }
+}
+exports.FakeRedlockService = FakeRedlockService;
+function createLockFake() {
+    let lock;
+    // eslint-disable-next-line prefer-const
+    lock = {
+        release: async () => ({ attempts: [], start: Date.now() }),
+        extend: async (duration) => lock,
+    };
+    return lock;
+}

package/dist/cjs/redlock.interface.d.ts

@@ -0,0 +1,54 @@
+import Redis, { Cluster } from "ioredis";
+import { Settings } from "@sesamecare-oss/redlock";
+export type PreLockedKeysHookArgs = {
+    keys: string[];
+    duration: number;
+};
+export type LockedKeysHookArgs = {
+    keys: string[];
+    duration: number;
+    elapsedTime: number;
+};
+export type UnlockedKeysHookArgs = {
+    keys: string[];
+    duration: number;
+    elapsedTime: number;
+};
+export type RedlockModuleOptions = {
+    clients: Iterable<Redis | Cluster>;
+    /**
+     * Default: true
+     * Used only with @Redlock decorator.
+     */
+    decoratorEnabled?: boolean;
+    settings?: Partial<Settings>;
+    scripts?: {
+        readonly acquireScript?: string | ((script: string) => string);
+        readonly extendScript?: string | ((script: string) => string);
+        readonly releaseScript?: string | ((script: string) => string);
+    };
+    /**
+     * Hooks called when using @Redlock decorator.
+     */
+    decoratorHooks?: {
+        /**
+         * Called before redlock.using
+         */
+        readonly preLockKeys?: (args: PreLockedKeysHookArgs) => void | Promise<void>;
+        /**
+         * Called first when the redlock.using callback is invoked.
+         */
+        readonly lockedKeys?: (args: LockedKeysHookArgs) => void | Promise<void>;
+        /**
+         * Called after when the redlock.using callback is finished.
+         */
+        readonly unlockedKeys?: (args: UnlockedKeysHookArgs) => void | Promise<void>;
+    };
+    /**
+     * Default duratiuon to use with Redlock decorator
+     *
+     * @type {number}
+     */
+    duration?: number;
+};
+export type RedlockKeyFunction<T extends (...args: any) => any = (...args: any) => any> = (target: any, ...args: Parameters<T>) => string[] | string;

package/dist/cjs/redlock.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/redlock.module-definition.js

@@ -0,0 +1,6 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODULE_OPTIONS_TOKEN = exports.ConfigurableModuleClass = void 0;
+const common_1 = require("@nestjs/common");
+_a = new common_1.ConfigurableModuleBuilder().build(), exports.ConfigurableModuleClass = _a.ConfigurableModuleClass, exports.MODULE_OPTIONS_TOKEN = _a.MODULE_OPTIONS_TOKEN;

package/dist/cjs/redlock.module.d.ts

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

package/dist/cjs/redlock.module.js

@@ -0,0 +1,53 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedlockModule = void 0;
+const common_1 = require("@nestjs/common");
+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;
+    }
+    async onApplicationShutdown() {
+        for (const client of this.options.clients) {
+            switch (client.status) {
+                case "end":
+                    continue;
+                case "ready":
+                    await client.quit();
+                    break;
+                default:
+                    client.disconnect();
+                    break;
+            }
+        }
+    }
+};
+exports.RedlockModule = RedlockModule;
+exports.RedlockModule = RedlockModule = __decorate([
+    (0, common_1.Module)({
+        providers: [
+            {
+                provide: redlock_service_1.RedlockService,
+                inject: [redlock_module_definition_1.MODULE_OPTIONS_TOKEN],
+                useFactory: (options) => new redlock_service_1.RedlockService(options),
+            },
+        ],
+        exports: [redlock_service_1.RedlockService],
+    }),
+    __param(0, (0, common_1.Inject)(redlock_module_definition_1.MODULE_OPTIONS_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], RedlockModule);

package/dist/cjs/redlock.service.d.ts

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

package/dist/cjs/redlock.service.js

@@ -0,0 +1,30 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedlockService = void 0;
+const common_1 = require("@nestjs/common");
+const redlock_1 = require("@sesamecare-oss/redlock");
+const redlock_module_definition_1 = require("./redlock.module-definition");
+let RedlockService = class RedlockService extends redlock_1.Redlock {
+    constructor(options) {
+        super(options.clients, options.settings);
+        this.options = options;
+    }
+};
+exports.RedlockService = RedlockService;
+exports.RedlockService = RedlockService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(redlock_module_definition_1.MODULE_OPTIONS_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], RedlockService);

package/dist/esm/index.d.ts

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

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export { Redlock } from "./redlock.decorator";
+export { FakeRedlockService } from "./redlock.fake-service";
+export { RedlockModule } from "./redlock.module";
+export { RedlockService } from "./redlock.service";

package/dist/esm/redlock.constants.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_DURATION = 5000;

package/dist/esm/redlock.constants.js

@@ -0,0 +1 @@
+export const DEFAULT_DURATION = 5000;

package/dist/esm/redlock.decorator.d.ts

@@ -0,0 +1,3 @@
+import { Settings } from "@sesamecare-oss/redlock";
+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/esm/redlock.decorator.js

@@ -0,0 +1,57 @@
+import { Inject } from "@nestjs/common";
+import { DEFAULT_DURATION } from "./redlock.constants";
+import { RedlockService } from "./redlock.service";
+export function Redlock(key, duration, settings = {}) {
+    const injectRedlockService = Inject(RedlockService);
+    return (target, propertyKey, descriptor) => {
+        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 redlockService = descriptorThis[serviceSymbol];
+            if (redlockService?.options?.decoratorEnabled !== undefined && !redlockService.options.decoratorEnabled) {
+                return await originalMethod.apply(descriptorThis, args);
+            }
+            const keys = getKeys(key, descriptorThis, args);
+            const useDuration = duration || redlockService.options?.duration || DEFAULT_DURATION;
+            await redlockService.options?.decoratorHooks?.preLockKeys?.({ keys, duration: useDuration });
+            const startTime = Date.now();
+            return await redlockService
+                .using(keys, useDuration, settings, async (signal) => {
+                if (signal.aborted) {
+                    throw signal.error;
+                }
+                await redlockService.options?.decoratorHooks?.lockedKeys?.({
+                    keys,
+                    duration: useDuration,
+                    elapsedTime: Date.now() - startTime,
+                });
+                const result = await originalMethod.apply(descriptorThis, args);
+                return result;
+            })
+                .finally(async () => {
+                await redlockService.options?.decoratorHooks?.unlockedKeys?.({
+                    keys,
+                    duration: useDuration,
+                    elapsedTime: Date.now() - startTime,
+                });
+            });
+        };
+        return descriptor;
+    };
+}
+function getKeys(key, descriptorThis, args) {
+    const keys = new Set();
+    if (typeof key === "string") {
+        keys.add(key);
+    }
+    else if (Array.isArray(key)) {
+        key.forEach((k) => keys.add(k));
+    }
+    else if (typeof key === "function") {
+        [key(descriptorThis, ...args)].flat().forEach((k) => keys.add(k));
+    }
+    return Array.from(keys);
+}

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

@@ -0,0 +1,10 @@
+import { ExecutionResult, Lock, RedlockAbortSignal, Settings } from "@sesamecare-oss/redlock";
+import { EventEmitter } from "events";
+export declare class FakeRedlockService extends EventEmitter {
+    quit(): Promise<void>;
+    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>(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/esm/redlock.fake-service.js

@@ -0,0 +1,27 @@
+import { EventEmitter } from "events";
+export class FakeRedlockService extends EventEmitter {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    async quit() { }
+    async acquire(keys, duration, settings) {
+        return createLockFake();
+    }
+    async release(lock, settings) {
+        return { attempts: [], start: Date.now() };
+    }
+    async extend(existing, duration, settings) {
+        return createLockFake();
+    }
+    async using(keys, duration, settingsOrRoutine, routine) {
+        const routineFunc = typeof settingsOrRoutine === "function" ? settingsOrRoutine : routine;
+        return await routineFunc?.({ aborted: false });
+    }
+}
+function createLockFake() {
+    let lock;
+    // eslint-disable-next-line prefer-const
+    lock = {
+        release: async () => ({ attempts: [], start: Date.now() }),
+        extend: async (duration) => lock,
+    };
+    return lock;
+}

package/dist/esm/redlock.interface.d.ts

@@ -0,0 +1,54 @@
+import Redis, { Cluster } from "ioredis";
+import { Settings } from "@sesamecare-oss/redlock";
+export type PreLockedKeysHookArgs = {
+    keys: string[];
+    duration: number;
+};
+export type LockedKeysHookArgs = {
+    keys: string[];
+    duration: number;
+    elapsedTime: number;
+};
+export type UnlockedKeysHookArgs = {
+    keys: string[];
+    duration: number;
+    elapsedTime: number;
+};
+export type RedlockModuleOptions = {
+    clients: Iterable<Redis | Cluster>;
+    /**
+     * Default: true
+     * Used only with @Redlock decorator.
+     */
+    decoratorEnabled?: boolean;
+    settings?: Partial<Settings>;
+    scripts?: {
+        readonly acquireScript?: string | ((script: string) => string);
+        readonly extendScript?: string | ((script: string) => string);
+        readonly releaseScript?: string | ((script: string) => string);
+    };
+    /**
+     * Hooks called when using @Redlock decorator.
+     */
+    decoratorHooks?: {
+        /**
+         * Called before redlock.using
+         */
+        readonly preLockKeys?: (args: PreLockedKeysHookArgs) => void | Promise<void>;
+        /**
+         * Called first when the redlock.using callback is invoked.
+         */
+        readonly lockedKeys?: (args: LockedKeysHookArgs) => void | Promise<void>;
+        /**
+         * Called after when the redlock.using callback is finished.
+         */
+        readonly unlockedKeys?: (args: UnlockedKeysHookArgs) => void | Promise<void>;
+    };
+    /**
+     * Default duratiuon to use with Redlock decorator
+     *
+     * @type {number}
+     */
+    duration?: number;
+};
+export type RedlockKeyFunction<T extends (...args: any) => any = (...args: any) => any> = (target: any, ...args: Parameters<T>) => string[] | string;

package/dist/esm/redlock.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/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/esm/redlock.module-definition.js

@@ -0,0 +1,2 @@
+import { ConfigurableModuleBuilder } from "@nestjs/common";
+export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } = new ConfigurableModuleBuilder().build();

package/dist/esm/redlock.module.d.ts

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

package/dist/esm/redlock.module.js

@@ -0,0 +1,50 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Module } from "@nestjs/common";
+import { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } from "./redlock.module-definition";
+import { RedlockService } from "./redlock.service";
+let RedlockModule = class RedlockModule extends ConfigurableModuleClass {
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    async onApplicationShutdown() {
+        for (const client of this.options.clients) {
+            switch (client.status) {
+                case "end":
+                    continue;
+                case "ready":
+                    await client.quit();
+                    break;
+                default:
+                    client.disconnect();
+                    break;
+            }
+        }
+    }
+};
+RedlockModule = __decorate([
+    Module({
+        providers: [
+            {
+                provide: RedlockService,
+                inject: [MODULE_OPTIONS_TOKEN],
+                useFactory: (options) => new RedlockService(options),
+            },
+        ],
+        exports: [RedlockService],
+    }),
+    __param(0, Inject(MODULE_OPTIONS_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], RedlockModule);
+export { RedlockModule };

package/dist/esm/redlock.service.d.ts

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

package/dist/esm/redlock.service.js

@@ -0,0 +1,27 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "@nestjs/common";
+import { Redlock } from "@sesamecare-oss/redlock";
+import { MODULE_OPTIONS_TOKEN } from "./redlock.module-definition";
+let RedlockService = class RedlockService extends Redlock {
+    constructor(options) {
+        super(options.clients, options.settings);
+        this.options = options;
+    }
+};
+RedlockService = __decorate([
+    Injectable(),
+    __param(0, Inject(MODULE_OPTIONS_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], RedlockService);
+export { RedlockService };

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@anchan828/nest-sesamecare-redlock",
+  "version": "0.2.44",
+  "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": {
+    "url": "https://github.com/anchan828/nest-redlock/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anchan828/nest-redlock.git"
+  },
+  "license": "MIT",
+  "author": "anchan828 <anchan828@gmail.com>",
+  "main": "dist/cjs/index.js",
+  "types": "dist/cjs/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.cjs.json && tsc -p tsconfig.esm.json",
+    "copy:license": "cp ../../LICENSE ./",
+    "lint": "TIMING=1 eslint '**/*.ts'",
+    "lint:fix": "npm run lint -- --fix",
+    "test": "jest --coverage --runInBand --detectOpenHandles",
+    "test:debug": "node --inspect-brk ../../node_modules/jest/bin/jest --runInBand --logHeapUsage",
+    "test:watch": "npm run test -- --watch",
+    "watch": "tsc --watch"
+  },
+  "dependencies": {
+    "@sesamecare-oss/redlock": "^1.3.1"
+  },
+  "devDependencies": {
+    "@nestjs/common": "10.4.4",
+    "@nestjs/core": "10.4.4",
+    "@nestjs/platform-express": "10.4.4",
+    "@nestjs/testing": "10.4.4",
+    "ioredis": "5.4.1",
+    "reflect-metadata": "0.2.2",
+    "rxjs": "7.8.1"
+  },
+  "volta": {
+    "node": "20.17.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "packageManager": "npm@10.8.3",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      },
+      "types": "./dist/cjs/index.d.ts",
+      "default": "./dist/cjs/index.js"
+    }
+  }
+}