murlock 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Alex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,107 @@
+# NestJS MurLock
+
+MurLock is a distributed lock solution designed for the NestJS framework. It provides a decorator `@MurLock()` that allows for critical sections of your application to be locked to prevent race conditions. MurLock uses Redis to ensure locks are respected across multiple instances of your application, making it perfect for microservices.
+
+## Features
+
+- **Redis-Based**: Implements a fast and effective lock mechanism using Redis.
+- **Parameter-Based Locking**: Creates locks based on request parameters or bodies.
+- **Highly Customizable**: Customize many parameters, such as lock duration.
+- **Logging Support**: Detailed logging with internal nestjs-logger.
+- **OOP and Generic Structure**: Easily integratable and expandable due to its OOP and generic design.
+
+## Installation
+
+MurLock has a peer dependency on `@nestjs/common` and `reflect-metadata`. These should already be installed in your NestJS project. In addition, you'll also need to install the `redis` package.
+
+```bash
+npm install --save murlock redis reflect-metadata
+```
+
+## Basic Usage
+
+MurLock is primarily used through the `@MurLock()` decorator.
+
+First, you need to import and register the `MurLockModule` in your module:
+
+```typescript
+import { MurLockModule } from 'murlock';
+
+@Module({
+  imports: [
+    MurLockModule.registerSync({
+      redisOptions: { host: 'localhost', port: 6379 },
+      wait: 1000,
+      maxAttempts: 3,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+Then, you can use `@MurLock()` in your services:
+
+```typescript
+import { MurLock } from 'murlock';
+
+@Injectable()
+export class AppService {
+  @MurLock(5000, 'user.id')
+  async someFunction(user: User): Promise<void> {
+    // Some critical section that only one request should be able to execute at a time
+  }
+}
+```
+
+In the example above, the `@MurLock()` decorator will prevent `someFunction()` from being executed concurrently for the same user. If another request comes in for the same user before `someFunction()` has finished executing, it will wait up to 5000 milliseconds (5 seconds) for the lock to be released. If the lock is not released within this time, an `MurLockException` will be thrown.
+
+The parameters to `@MurLock()` are a release time (in milliseconds), followed by any number of key parameters. The key parameters are used to create a unique key for each lock. They should be properties of the parameters of the method. In the example above, 'user.id' is used, which means the lock key will be different for each user ID.
+
+## Advanced Usage
+
+MurLock also supports async configuration. This can be useful if your Redis configuration is not known at compile time.
+
+```typescript
+import { MurLockModule } from 'murlock';
+
+@Module({
+  imports: [
+    MurLockModule.registerAsync({
+      imports: [ConfigModule],
+      useFactory: async (configService: ConfigService) => ({
+        redisOptions: configService.get('REDIS_OPTIONS'),
+        wait: configService.get('MURLOCK_WAIT'),
+        maxAttempts: configService.get('MURLOCK_MAX_ATTEMPTS'),
+      }),
+      inject: [ConfigService],
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+In the example above, the `ConfigModule` and `ConfigService` are used to provide the configuration for MurLock asynchronously.
+
+For more details on usage and configuration, please refer to the API documentation below.
+
+## API Documentation
+
+For more detailed API documentation, please see the source code, which is thoroughly commented and should provide enough information for most use cases. The key classes and interfaces to be aware of are:
+
+- `MurLockService`: A service that provides methods for locking and unlocking. Normally you would not use this directly, but it is provided for more complex use cases.
+
+- `MurLockModuleOptions`: An interface for the options that can be passed to `MurLockModule.registerSync()`.
+
+- `MurLockModuleAsyncOptions`: An interface for the options that can be passed to `MurLockModule.registerAsync()`.
+
+- `MurLock()`: A decorator that provides distributed locking functionality.
+
+- `MurLockMetadata`: An interface for the metadata associated with a `@MurLock()` method.
+
+## License
+
+This project is licensed under the [MIT License](LICENSE_FILE_URL).
+
+## Contact
+
+If you have any questions or feedback, feel free to contact me at ozmen.eyupfurkan@gmail.com.

package/dist/constants/index.d.ts

@@ -0,0 +1,2 @@
+export declare const MURLOCK_KEY_METADATA: unique symbol;
+export declare const MURLOCK_SERVICE_METADATA_KEY: unique symbol;

package/dist/constants/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MURLOCK_SERVICE_METADATA_KEY = exports.MURLOCK_KEY_METADATA = void 0;
+exports.MURLOCK_KEY_METADATA = Symbol('MURLOCK_KEY_METADATA');
+exports.MURLOCK_SERVICE_METADATA_KEY = Symbol('MURLOCK_SERVICE_METADATA_KEY');
+//# sourceMappingURL=index.js.map

package/dist/constants/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/constants/index.ts"],"names":[],"mappings":";;;AAAa,QAAA,oBAAoB,GAAG,MAAM,CAAC,sBAAsB,CAAC,CAAC;AAEtD,QAAA,4BAA4B,GAAG,MAAM,CAAC,8BAA8B,CAAC,CAAC"}

package/dist/decorators/index.d.ts

@@ -0,0 +1 @@
+export * from './murlock.decorator';

package/dist/decorators/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./murlock.decorator"), exports);
+//# sourceMappingURL=index.js.map

package/dist/decorators/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/decorators/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,sDAAoC"}

package/dist/decorators/lock.decorator.d.ts

@@ -0,0 +1 @@
+export declare function Lock(releaseTime: number, ...params: string[]): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/dist/decorators/lock.decorator.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lock = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("../constants");
+const interceptors_1 = require("../interceptors");
+function Lock(releaseTime, ...params) {
+    return (0, common_1.applyDecorators)((0, common_1.SetMetadata)(constants_1.LOCK_KEY_METADATA, { releaseTime, params }), (0, common_1.UseInterceptors)(interceptors_1.LockInterceptor));
+}
+exports.Lock = Lock;
+//# sourceMappingURL=lock.decorator.js.map

package/dist/decorators/lock.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.decorator.js","sourceRoot":"","sources":["../../lib/decorators/lock.decorator.ts"],"names":[],"mappings":";;;AAAA,2CAA+E;AAC/E,4CAAiD;AACjD,kDAAkD;AAElD,SAAgB,IAAI,CAAC,WAAmB,EAAE,GAAG,MAAgB;IAC3D,OAAO,IAAA,wBAAe,EACpB,IAAA,oBAAW,EAAC,6BAAiB,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC,EACvD,IAAA,wBAAe,EAAC,8BAAe,CAAC,CACjC,CAAC;AACJ,CAAC;AALD,oBAKC"}

package/dist/decorators/murlock.decorator.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+export declare function MurLock(releaseTime: number, ...keyParams: string[]): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/decorators/murlock.decorator.js

@@ -0,0 +1,66 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MurLock = void 0;
+require("reflect-metadata");
+const murlock_service_1 = require("../murlock.service");
+const constants_1 = require("../constants");
+const exceptions_1 = require("../exceptions");
+function getParameterNames(func) {
+    const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
+    const ARGUMENT_NAMES = /([^\s,]+)/g;
+    const fnStr = func.toString().replace(STRIP_COMMENTS, '');
+    const result = fnStr.slice(fnStr.indexOf('(') + 1, fnStr.indexOf(')')).match(ARGUMENT_NAMES);
+    return result || [];
+}
+function MurLock(releaseTime, ...keyParams) {
+    return (target, propertyKey, descriptor) => {
+        const originalMethod = descriptor.value;
+        const methodParameterNames = getParameterNames(originalMethod);
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const lockKeyElements = [
+                    target.constructor.name,
+                    propertyKey,
+                    ...keyParams.map((keyParam) => {
+                        const [source, path] = keyParam.split('.');
+                        const parameterIndex = methodParameterNames.indexOf(source);
+                        if (parameterIndex >= 0) {
+                            const parameterValue = args[parameterIndex];
+                            if (path && typeof parameterValue === 'object' && parameterValue !== null && path in parameterValue) {
+                                return parameterValue[path];
+                            }
+                            return parameterValue instanceof Object ? parameterValue.toString() : parameterValue;
+                        }
+                    }),
+                ];
+                const lockKey = lockKeyElements.join(':');
+                const murLockService = Reflect.getMetadata(constants_1.MURLOCK_SERVICE_METADATA_KEY, murlock_service_1.MurLockService);
+                const isLockSuccessful = yield murLockService.lock(lockKey, releaseTime);
+                if (!isLockSuccessful) {
+                    throw new exceptions_1.MurLockException('Could not obtain lock');
+                }
+                let result;
+                try {
+                    result = yield originalMethod.apply(this, args);
+                }
+                finally {
+                    yield murLockService.unlock(lockKey);
+                }
+                return result;
+            });
+        };
+        Reflect.defineMetadata('MURLOCK_KEY_METADATA', { releaseTime, keyParams }, descriptor.value);
+        return descriptor;
+    };
+}
+exports.MurLock = MurLock;
+//# sourceMappingURL=murlock.decorator.js.map

package/dist/decorators/murlock.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"murlock.decorator.js","sourceRoot":"","sources":["../../lib/decorators/murlock.decorator.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,4BAA0B;AAC1B,wDAAoD;AACpD,4CAA4D;AAC5D,8CAAiD;AAEjD,SAAS,iBAAiB,CAAC,IAAI;IAC7B,MAAM,cAAc,GAAG,kCAAkC,CAAC;IAC1D,MAAM,cAAc,GAAG,YAAY,CAAC;IAEpC,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;IAC1D,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;IAC7F,OAAO,MAAM,IAAI,EAAE,CAAC;AACtB,CAAC;AAED,SAAgB,OAAO,CAAC,WAAmB,EAAE,GAAG,SAAmB;IACjE,OAAO,CACL,MAAW,EACX,WAAmB,EACnB,UAA8B,EAC9B,EAAE;QACF,MAAM,cAAc,GAAG,UAAU,CAAC,KAAK,CAAC;QACxC,MAAM,oBAAoB,GAAG,iBAAiB,CAAC,cAAc,CAAC,CAAC;QAG/D,UAAU,CAAC,KAAK,GAAG,UAAgB,GAAG,IAAW;;gBAC/C,MAAM,eAAe,GAAG;oBACtB,MAAM,CAAC,WAAW,CAAC,IAAI;oBACvB,WAAW;oBACX,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE;wBAC5B,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;wBAC3C,MAAM,cAAc,GAAG,oBAAoB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;wBAC5D,IAAI,cAAc,IAAI,CAAC,EAAE;4BACvB,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC;4BAC5C,IAAI,IAAI,IAAI,OAAO,cAAc,KAAK,QAAQ,IAAI,cAAc,KAAK,IAAI,IAAI,IAAI,IAAI,cAAc,EAAE;gCACnG,OAAO,cAAc,CAAC,IAAI,CAAC,CAAC;6BAC7B;4BACD,OAAO,cAAc,YAAY,MAAM,CAAC,CAAC,CAAC,cAAc,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC;yBACtF;oBACH,CAAC,CAAC;iBACH,CAAC;gBACF,MAAM,OAAO,GAAG,eAAe,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBAE1C,MAAM,cAAc,GAAmB,OAAO,CAAC,WAAW,CAAC,wCAA4B,EAAE,gCAAc,CAAC,CAAC;gBAEzG,MAAM,gBAAgB,GAAG,MAAM,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;gBACzE,IAAI,CAAC,gBAAgB,EAAE;oBACrB,MAAM,IAAI,6BAAgB,CAAC,uBAAuB,CAAC,CAAC;iBACrD;gBAED,IAAI,MAAM,CAAC;gBACX,IAAI;oBACF,MAAM,GAAG,MAAM,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;iBACjD;wBAAS;oBACR,MAAM,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;iBACtC;gBAED,OAAO,MAAM,CAAC;YAChB,CAAC;SAAA,CAAC;QAEF,OAAO,CAAC,cAAc,CACpB,sBAAsB,EACtB,EAAE,WAAW,EAAE,SAAS,EAAE,EAC1B,UAAU,CAAC,KAAK,CACjB,CAAC;QAEF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC;AArDD,0BAqDC"}

package/dist/exceptions/index.d.ts

@@ -0,0 +1 @@
+export * from './murlock.exception';

package/dist/exceptions/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./murlock.exception"), exports);
+//# sourceMappingURL=index.js.map

package/dist/exceptions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/exceptions/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,sDAAoC"}

package/dist/exceptions/murlock.exception.d.ts

@@ -0,0 +1,3 @@
+export declare class MurLockException extends Error {
+    constructor(message: string);
+}

package/dist/exceptions/murlock.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MurLockException = void 0;
+class MurLockException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "MurLockException";
+    }
+}
+exports.MurLockException = MurLockException;
+//# sourceMappingURL=murlock.exception.js.map

package/dist/exceptions/murlock.exception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"murlock.exception.js","sourceRoot":"","sources":["../../lib/exceptions/murlock.exception.ts"],"names":[],"mappings":";;;AAAA,MAAa,gBAAiB,SAAQ,KAAK;IACzC,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF;AALD,4CAKC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './murlock.service';
+export * from './murlock.module';
+export * from './decorators';

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./murlock.service"), exports);
+__exportStar(require("./murlock.module"), exports);
+__exportStar(require("./decorators"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oDAAkC;AAClC,mDAAiC;AACjC,+CAA6B"}

package/dist/interceptors/index.d.ts

@@ -0,0 +1 @@
+export * from './lock.interceptor';

package/dist/interceptors/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lock.interceptor"), exports);
+//# sourceMappingURL=index.js.map

package/dist/interceptors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/interceptors/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,qDAAmC"}

package/dist/interceptors/lock.interceptor.d.ts

@@ -0,0 +1,12 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { LockService } from '../lock.service';
+import { PinoLogger } from 'nestjs-pino';
+import { Observable } from 'rxjs';
+export declare class LockInterceptor implements NestInterceptor {
+    private readonly lockService;
+    private readonly reflector;
+    private readonly logger;
+    constructor(lockService: LockService, reflector: Reflector, logger: PinoLogger);
+    intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<any>>;
+}

package/dist/interceptors/lock.interceptor.js

@@ -0,0 +1,66 @@
+"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var LockInterceptor_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const constants_1 = require("../constants");
+const lock_service_1 = require("../lock.service");
+const nestjs_pino_1 = require("nestjs-pino");
+const rxjs_1 = require("rxjs");
+let LockInterceptor = exports.LockInterceptor = LockInterceptor_1 = class LockInterceptor {
+    constructor(lockService, reflector, logger) {
+        this.lockService = lockService;
+        this.reflector = reflector;
+        this.logger = logger;
+        this.logger.setContext(LockInterceptor_1.name);
+    }
+    intercept(context, next) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lockMetadata = this.reflector.get(constants_1.LOCK_KEY_METADATA, context.getHandler());
+            if (!lockMetadata) {
+                return next.handle();
+            }
+            const { releaseTime, params } = lockMetadata;
+            const request = context.switchToHttp().getRequest();
+            const lockKey = params
+                .map((param) => request.params[param] || request.body[param])
+                .join(':');
+            const isLockSuccessful = yield this.lockService.lock(lockKey, releaseTime);
+            if (!isLockSuccessful) {
+                throw new common_1.InternalServerErrorException('Could not obtain lock');
+            }
+            return next.handle().pipe((0, rxjs_1.tap)(() => this.logger.info(`Processing complete, releasing lock for key ${lockKey}`)), (0, rxjs_1.catchError)((error) => {
+                this.logger.error(`Error processing request: ${error.message}`);
+                return (0, rxjs_1.throwError)(error);
+            }), (0, rxjs_1.finalize)(() => __awaiter(this, void 0, void 0, function* () {
+                yield this.lockService.unlock(lockKey);
+            })));
+        });
+    }
+};
+exports.LockInterceptor = LockInterceptor = LockInterceptor_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [lock_service_1.LockService,
+        core_1.Reflector,
+        nestjs_pino_1.PinoLogger])
+], LockInterceptor);
+//# sourceMappingURL=lock.interceptor.js.map

package/dist/interceptors/lock.interceptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.interceptor.js","sourceRoot":"","sources":["../../lib/interceptors/lock.interceptor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,2CAMwB;AACxB,uCAAyC;AACzC,4CAAiD;AAEjD,kDAA8C;AAC9C,6CAAyC;AACzC,+BAAyE;AAGlE,IAAM,eAAe,iDAArB,MAAM,eAAe;IAC1B,YACmB,WAAwB,EACxB,SAAoB,EACpB,MAAkB;QAFlB,gBAAW,GAAX,WAAW,CAAa;QACxB,cAAS,GAAT,SAAS,CAAW;QACpB,WAAM,GAAN,MAAM,CAAY;QAEnC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,iBAAe,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IAEK,SAAS,CACb,OAAyB,EACzB,IAAiB;;YAEjB,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CACrC,6BAAiB,EACjB,OAAO,CAAC,UAAU,EAAE,CACrB,CAAC;YAEF,IAAI,CAAC,YAAY,EAAE;gBACjB,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;aACtB;YAED,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,YAAY,CAAC;YAC7C,MAAM,OAAO,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,UAAU,EAAE,CAAC;YACpD,MAAM,OAAO,GAAG,MAAM;iBACnB,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;iBAC5D,IAAI,CAAC,GAAG,CAAC,CAAC;YAEb,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;YAE3E,IAAI,CAAC,gBAAgB,EAAE;gBACrB,MAAM,IAAI,qCAA4B,CAAC,uBAAuB,CAAC,CAAC;aACjE;YAED,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,IAAI,CACvB,IAAA,UAAG,EAAC,GAAG,EAAE,CACP,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,+CAA+C,OAAO,EAAE,CACzD,CACF,EACD,IAAA,iBAAU,EAAC,CAAC,KAAK,EAAE,EAAE;gBACnB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,6BAA6B,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;gBAChE,OAAO,IAAA,iBAAU,EAAC,KAAK,CAAC,CAAC;YAC3B,CAAC,CAAC,EACF,IAAA,eAAQ,EAAC,GAAS,EAAE;gBAClB,MAAM,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YACzC,CAAC,CAAA,CAAC,CACH,CAAC;QACJ,CAAC;KAAA;CACF,CAAA;0BAjDY,eAAe;IAD3B,IAAA,mBAAU,GAAE;qCAGqB,0BAAW;QACb,gBAAS;QACZ,wBAAU;GAJ1B,eAAe,CAiD3B"}

package/dist/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './murlock-meta-data.interface';
+export * from './murlock-options.interface';

package/dist/interfaces/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./murlock-meta-data.interface"), exports);
+__exportStar(require("./murlock-options.interface"), exports);
+//# sourceMappingURL=index.js.map

package/dist/interfaces/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/interfaces/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,gEAA8C;AAC9C,8DAA4C"}

package/dist/interfaces/lock-meta-data.interface.d.ts

@@ -0,0 +1,4 @@
+export interface LockMetadata {
+    releaseTime: number;
+    params: string[];
+}

package/dist/interfaces/lock-meta-data.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=lock-meta-data.interface.js.map

package/dist/interfaces/lock-meta-data.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-meta-data.interface.js","sourceRoot":"","sources":["../../lib/interfaces/lock-meta-data.interface.ts"],"names":[],"mappings":""}

package/dist/interfaces/lock-options.interface.d.ts

@@ -0,0 +1,4 @@
+import * as Redis from 'ioredis';
+export interface LockModuleOptions {
+    redisOptions: Redis.RedisOptions;
+}

package/dist/interfaces/lock-options.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=lock-options.interface.js.map

package/dist/interfaces/lock-options.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-options.interface.js","sourceRoot":"","sources":["../../lib/interfaces/lock-options.interface.ts"],"names":[],"mappings":""}

package/dist/interfaces/murlock-meta-data.interface.d.ts

@@ -0,0 +1,4 @@
+export interface MurLockMetadata {
+    releaseTime: number;
+    params: string[];
+}

package/dist/interfaces/murlock-meta-data.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=murlock-meta-data.interface.js.map

package/dist/interfaces/murlock-meta-data.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"murlock-meta-data.interface.js","sourceRoot":"","sources":["../../lib/interfaces/murlock-meta-data.interface.ts"],"names":[],"mappings":""}

package/dist/interfaces/murlock-options.interface.d.ts

@@ -0,0 +1,12 @@
+import { ClientOpts } from 'redis';
+export interface MurLockModuleOptions {
+    redisOptions: ClientOpts;
+    ttl: number;
+    wait: number;
+    maxAttempts: number;
+}
+export interface MurLockModuleAsyncOptions {
+    imports?: any[];
+    inject?: any[];
+    useFactory: (...args: any[]) => Promise<MurLockModuleOptions> | MurLockModuleOptions;
+}

package/dist/interfaces/murlock-options.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=murlock-options.interface.js.map

package/dist/interfaces/murlock-options.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"murlock-options.interface.js","sourceRoot":"","sources":["../../lib/interfaces/murlock-options.interface.ts"],"names":[],"mappings":""}

package/dist/lock.module.d.ts

@@ -0,0 +1,5 @@
+import { DynamicModule } from '@nestjs/common';
+import { LockModuleOptions } from './interfaces';
+export declare class LockModule {
+    static register(options: LockModuleOptions): DynamicModule;
+}

package/dist/lock.module.js

@@ -0,0 +1,40 @@
+"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 LockModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockModule = void 0;
+const common_1 = require("@nestjs/common");
+const Redis = require("ioredis");
+const lock_service_1 = require("./lock.service");
+const interceptors_1 = require("./interceptors");
+const nestjs_pino_1 = require("nestjs-pino");
+let LockModule = exports.LockModule = LockModule_1 = class LockModule {
+    static register(options) {
+        const redisClientProvider = {
+            provide: 'REDIS_CLIENT',
+            useFactory: () => {
+                return new Redis.Redis(options.redisOptions);
+            },
+        };
+        return {
+            module: LockModule_1,
+            providers: [
+                lock_service_1.LockService,
+                interceptors_1.LockInterceptor,
+                redisClientProvider,
+                nestjs_pino_1.PinoLogger,
+            ],
+            exports: [lock_service_1.LockService, interceptors_1.LockInterceptor],
+        };
+    }
+};
+exports.LockModule = LockModule = LockModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], LockModule);
+//# sourceMappingURL=lock.module.js.map

package/dist/lock.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.module.js","sourceRoot":"","sources":["../lib/lock.module.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,2CAA+D;AAC/D,iCAAiC;AACjC,iDAA6C;AAC7C,iDAAiD;AACjD,6CAAyC;AAOlC,IAAM,UAAU,uCAAhB,MAAM,UAAU;IACrB,MAAM,CAAC,QAAQ,CAAC,OAA0B;QACxC,MAAM,mBAAmB,GAAG;YAC1B,OAAO,EAAE,cAAc;YACvB,UAAU,EAAE,GAAgB,EAAE;gBAC5B,OAAO,IAAI,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;YAC/C,CAAC;SACF,CAAC;QAEF,OAAO;YACL,MAAM,EAAE,YAAU;YAClB,SAAS,EAAE;gBACT,0BAAW;gBACX,8BAAe;gBACf,mBAAmB;gBACnB,wBAAU;aACX;YACD,OAAO,EAAE,CAAC,0BAAW,EAAE,8BAAe,CAAC;SACxC,CAAC;IACJ,CAAC;CACF,CAAA;qBApBY,UAAU;IAFtB,IAAA,eAAM,GAAE;IACR,IAAA,eAAM,EAAC,EAAE,CAAC;GACE,UAAU,CAoBtB"}

package/dist/lock.service.d.ts

@@ -0,0 +1,9 @@
+import { PinoLogger } from 'nestjs-pino';
+import * as Redis from 'ioredis';
+export declare class LockService {
+    private readonly redisClient;
+    private readonly logger;
+    constructor(redisClient: Redis.Redis, logger: PinoLogger);
+    lock(lockKey: string, releaseTime: number): Promise<boolean>;
+    unlock(lockKey: string): Promise<void>;
+}