@anchan828/nest-redlock 0.2.36 → 0.2.37

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 "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 { EventEmitter } from "events";
+import { ExecutionResult, Lock, RedlockAbortSignal, Settings } from "redlock";
+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,28 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+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: [] };
+    }
+    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: [] }),
+        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 "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 "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 "redlock";
+import { MODULE_OPTIONS_TOKEN } from "./redlock.module-definition";
+let RedlockService = class RedlockService extends Redlock {
+    constructor(options) {
+        super(options.clients, options.settings, options.scripts);
+        this.options = options;
+    }
+};
+RedlockService = __decorate([
+    Injectable(),
+    __param(0, Inject(MODULE_OPTIONS_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], RedlockService);
+export { RedlockService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchan828/nest-redlock",
-  "version": "0.2.36",
+  "version": "0.2.37",
   "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": {
@@ -12,10 +12,10 @@
   },
   "license": "MIT",
   "author": "anchan828 <anchan828@gmail.com>",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/cjs/index.js",
+  "types": "dist/cjs/index.d.ts",
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "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",
@@ -43,5 +43,19 @@
     "access": "public"
   },
   "packageManager": "npm@10.8.2",
-  "gitHead": "a6c74e29685c259d27e16198402f47e686cedf52"
+  "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"
+    }
+  },
+  "gitHead": "aa32d82ce7d4ada796ca510f42a30554cc5b13cd"
 }