@anchan828/nest-redlock 0.0.1 → 0.0.4

package/README.md

@@ -3,7 +3,7 @@
 ![npm](https://img.shields.io/npm/v/@anchan828/nest-redlock.svg)
 ![NPM](https://img.shields.io/npm/l/@anchan828/nest-redlock.svg)
 
-This is a [Nest](https://github.com/nestjs/nest) implementation of the redlock algorithm for distributed redis.
+This is a [Nest](https://github.com/nestjs/nest) implementation of the redlock algorithm for distributed redis locks.
 
 This package uses [node-redlock](https://github.com/mike-marcacci/node-redlock).
 
@@ -24,7 +24,17 @@ import Redis from "ioredis";
 @Module({
   imports: [
     RedisRedlockModule.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 RedisRedlock decorator
+      duration: 1000,
     }),
   ],
 })

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { RedisRedlock } from "./redis-redlock.decorator";
+export { GenerateResourceFunc, RedisRedlockModuleOptions } from "./redis-redlock.interface";
+export { RedisRedlockModule } from "./redis-redlock.module";
+export { RedisRedlockService } from "./redis-redlock.service";

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisRedlockService = exports.RedisRedlockModule = 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_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; } });

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

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

package/dist/redis-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/redis-redlock.decorator.d.ts

@@ -0,0 +1,3 @@
+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.decorator.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisRedlock = 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);
+    return (target, propertyKey, descriptor) => {
+        const serviceSymbol = "@redisRedlockService";
+        injectRedisRedlockService(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 resources = getResources(resource, descriptorThis, args);
+            return await redisRedlockService.using(resources, duration || redisRedlockService.options.duration || 5000, settings, async (signal) => {
+                const result = await originalMethod.apply(descriptorThis, args);
+                if (signal.aborted) {
+                    throw signal.error;
+                }
+                return result;
+            });
+        };
+        return descriptor;
+    };
+}
+exports.RedisRedlock = RedisRedlock;
+function getResources(resource, descriptorThis, args) {
+    if (typeof resource === "string") {
+        return [resource];
+    }
+    else if (Array.isArray(resource)) {
+        return resource;
+    }
+    else if (typeof resource === "function") {
+        return [resource(descriptorThis, ...args)].flat();
+    }
+    return [];
+}

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

@@ -0,0 +1,18 @@
+import Redis, { Cluster } from "ioredis";
+import { Settings } from "redlock";
+export declare type RedisRedlockModuleOptions = {
+    clients: Iterable<Redis | Cluster>;
+    settings?: Partial<Settings>;
+    scripts?: {
+        readonly acquireScript?: string | ((script: string) => string);
+        readonly extendScript?: string | ((script: string) => string);
+        readonly releaseScript?: string | ((script: string) => string);
+    };
+    /**
+     * Default duratiuon to use with RedisRedlock decorator
+     *
+     * @type {number}
+     */
+    duration?: number;
+};
+export declare type GenerateResourceFunc = (target: any, ...args: any[]) => string | string[];

package/dist/redis-redlock.interface.js

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

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

@@ -0,0 +1,2 @@
+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-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/redis-redlock.module.d.ts

@@ -0,0 +1,8 @@
+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.module.js

@@ -0,0 +1,44 @@
+"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.RedisRedlockModule = 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 {
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    async onModuleDestroy() {
+        for (const client of this.options.clients) {
+            await client.quit();
+        }
+    }
+};
+RedisRedlockModule = __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),
+            },
+        ],
+        exports: [redis_redlock_service_1.RedisRedlockService],
+    }),
+    __param(0, (0, common_1.Inject)(redis_redlock_module_definition_1.MODULE_OPTIONS_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], RedisRedlockModule);
+exports.RedisRedlockModule = RedisRedlockModule;

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

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

package/dist/redis-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.RedisRedlockService = 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 {
+    constructor(options) {
+        super(options.clients, options.settings, options.scripts);
+        this.options = options;
+    }
+};
+RedisRedlockService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(redis_redlock_module_definition_1.MODULE_OPTIONS_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], RedisRedlockService);
+exports.RedisRedlockService = RedisRedlockService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchan828/nest-redlock",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "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": {
@@ -17,11 +17,14 @@
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "format": "prettier --write '**/*.{js,json,yml,yaml,md}'",
-    "postinstall": "husky install",
+    "prepare": "husky install",
     "lint": "TIMING=1 eslint --ignore-path .eslintignore '**/*.ts'",
     "lint:fix": "npm run lint -- --fix",
     "test": "jest --coverage --runInBand"
   },
+  "dependencies": {
+    "redlock": "^5.0.0-beta.2"
+  },
   "devDependencies": {
     "@commitlint/cli": "17.0.3",
     "@commitlint/config-conventional": "17.0.3",
@@ -42,7 +45,6 @@
     "jest": "28.1.3",
     "lint-staged": "13.0.3",
     "prettier": "2.7.1",
-    "redlock": "5.0.0-beta.2",
     "reflect-metadata": "0.1.13",
     "rxjs": "7.5.6",
     "supertest": "6.2.4",