@nestjs-redisx/locks 1.0.0

package/dist/lock/domain/entities/lock.entity.d.ts

@@ -0,0 +1,130 @@
+import { ILockStore } from '../../application/ports/lock-store.port';
+/**
+ * Represents an acquired distributed lock.
+ */
+export interface ILock {
+    /** Lock key */
+    readonly key: string;
+    /** Unique token identifying lock ownership */
+    readonly token: string;
+    /** Lock TTL in milliseconds */
+    readonly ttl: number;
+    /** Timestamp when lock was acquired */
+    readonly acquiredAt: Date;
+    /** Timestamp when lock will expire */
+    readonly expiresAt: Date;
+    /** Whether auto-renewal is active */
+    readonly isAutoRenewing: boolean;
+    /**
+     * Releases the lock.
+     *
+     * @throws {LockNotOwnedError} If lock is not owned by this token
+     */
+    release(): Promise<void>;
+    /**
+     * Extends lock TTL.
+     *
+     * @param ttl - New TTL in milliseconds
+     * @throws {LockNotOwnedError} If lock was already released
+     * @throws {LockExtensionError} If extension fails
+     */
+    extend(ttl: number): Promise<void>;
+    /**
+     * Checks if lock is still held.
+     *
+     * @returns True if lock is held by this token
+     */
+    isHeld(): Promise<boolean>;
+    /**
+     * Stops automatic lock renewal.
+     */
+    stopAutoRenew(): void;
+}
+/**
+ * Lock entity implementation.
+ *
+ * Represents a distributed lock with automatic renewal capability.
+ * The lock maintains ownership through a unique token and can be
+ * extended or released explicitly.
+ *
+ * @example
+ * ```typescript
+ * const lock = new Lock('my-resource', 'token-123', 30000, store);
+ *
+ * // Start auto-renewal every 15 seconds
+ * lock.startAutoRenew(15000);
+ *
+ * try {
+ *   // Do work...
+ *   await performOperation();
+ * } finally {
+ *   await lock.release();
+ * }
+ * ```
+ */
+export declare class Lock implements ILock {
+    private readonly store;
+    readonly key: string;
+    readonly token: string;
+    readonly ttl: number;
+    readonly acquiredAt: Date;
+    private _expiresAt;
+    private autoRenewTimer;
+    private released;
+    /**
+     * Creates a new Lock instance.
+     *
+     * @param key - Lock key in Redis
+     * @param token - Unique ownership token
+     * @param ttl - Time-to-live in milliseconds
+     * @param store - Lock store for persistence operations
+     */
+    constructor(key: string, token: string, ttl: number, store: ILockStore);
+    /**
+     * Gets the expiration timestamp.
+     */
+    get expiresAt(): Date;
+    /**
+     * Checks if auto-renewal is active.
+     */
+    get isAutoRenewing(): boolean;
+    /**
+     * Releases the lock.
+     *
+     * Stops auto-renewal and removes the lock from Redis.
+     * Idempotent - can be called multiple times safely.
+     *
+     * @throws {LockNotOwnedError} If lock is not owned by this token
+     */
+    release(): Promise<void>;
+    /**
+     * Extends the lock TTL.
+     *
+     * @param ttl - New TTL in milliseconds
+     * @throws {LockNotOwnedError} If lock was already released
+     * @throws {LockExtensionError} If extension fails (lock expired or not owned)
+     */
+    extend(ttl: number): Promise<void>;
+    /**
+     * Checks if lock is still held.
+     *
+     * @returns False if released, otherwise checks Redis
+     */
+    isHeld(): Promise<boolean>;
+    /**
+     * Starts automatic lock renewal.
+     *
+     * The lock will be extended at the specified interval
+     * until stopAutoRenew() is called or extension fails.
+     *
+     * @param intervalMs - Renewal interval in milliseconds
+     */
+    startAutoRenew(intervalMs: number): void;
+    /**
+     * Stops automatic lock renewal.
+     *
+     * Safe to call multiple times.
+     */
+    stopAutoRenew(): void;
+}
+//# sourceMappingURL=lock.entity.d.ts.map

package/dist/lock/domain/entities/lock.entity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.entity.d.ts","sourceRoot":"","sources":["../../../../src/lock/domain/entities/lock.entity.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,eAAe;IACf,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,+BAA+B;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB,uCAAuC;IACvC,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC;IAE1B,sCAAsC;IACtC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IAEzB,qCAAqC;IACrC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IAEjC;;;;OAIG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzB;;;;;;OAMG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnC;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAE3B;;OAEG;IACH,aAAa,IAAI,IAAI,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,IAAK,YAAW,KAAK;IAsB9B,OAAO,CAAC,QAAQ,CAAC,KAAK;IArBxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC;IAE1B,OAAO,CAAC,UAAU,CAAO;IACzB,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,QAAQ,CAAS;IAEzB;;;;;;;OAOG;gBAED,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACM,KAAK,EAAE,UAAU;IASpC;;OAEG;IACH,IAAI,SAAS,IAAI,IAAI,CAEpB;IAED;;OAEG;IACH,IAAI,cAAc,IAAI,OAAO,CAE5B;IAED;;;;;;;OAOG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAe9B;;;;;;OAMG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAaxC;;;;OAIG;IACG,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;IAOhC;;;;;;;OAOG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAqBxC;;;;OAIG;IACH,aAAa,IAAI,IAAI;CAMtB"}

package/dist/lock/infrastructure/adapters/redis-lock-store.adapter.d.ts

@@ -0,0 +1,45 @@
+import { OnModuleInit } from '@nestjs/common';
+import { IRedisDriver } from '@nestjs-redisx/core';
+import { ILockStore } from '../../application/ports/lock-store.port';
+/**
+ * Redis-based lock store implementation.
+ *
+ * Uses atomic Redis operations for lock management:
+ * - SET NX PX for acquiring locks
+ * - Lua scripts for safe release and extension
+ */
+export declare class RedisLockStoreAdapter implements ILockStore, OnModuleInit {
+    private readonly driver;
+    private releaseSha;
+    private extendSha;
+    constructor(driver: IRedisDriver);
+    /**
+     * Lifecycle hook: loads Lua scripts into Redis on initialization.
+     */
+    onModuleInit(): Promise<void>;
+    /**
+     * Acquires lock using SET NX PX.
+     */
+    acquire(key: string, token: string, ttlMs: number): Promise<boolean>;
+    /**
+     * Releases lock if owned by token (Lua script).
+     */
+    release(key: string, token: string): Promise<boolean>;
+    /**
+     * Extends lock TTL if owned by token (Lua script).
+     */
+    extend(key: string, token: string, ttlMs: number): Promise<boolean>;
+    /**
+     * Checks if lock key exists.
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * Checks if lock is held by specific token.
+     */
+    isHeldBy(key: string, token: string): Promise<boolean>;
+    /**
+     * Force removes lock without ownership check.
+     */
+    forceRelease(key: string): Promise<boolean>;
+}
+//# sourceMappingURL=redis-lock-store.adapter.d.ts.map

package/dist/lock/infrastructure/adapters/redis-lock-store.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-lock-store.adapter.d.ts","sourceRoot":"","sources":["../../../../src/lock/infrastructure/adapters/redis-lock-store.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,EAAE,YAAY,EAAgB,MAAM,qBAAqB,CAAC;AAEjE,OAAO,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAGrE;;;;;;GAMG;AACH,qBACa,qBAAsB,YAAW,UAAU,EAAE,YAAY;IAIlC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAHzD,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,SAAS,CAAuB;gBAEW,MAAM,EAAE,YAAY;IAEvE;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAMnC;;OAEG;IACG,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQ1E;;OAEG;IACG,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAU3D;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAUzE;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAK3C;;OAEG;IACG,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAK5D;;OAEG;IACG,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAIlD"}

package/dist/lock/infrastructure/scripts/lua-scripts.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Inline Lua scripts for lock operations.
+ *
+ * Scripts are stored as inline strings to avoid issues with file reading
+ * after build (dist directory doesn't contain .lua files).
+ */
+/**
+ * Release lock if owned by token.
+ *
+ * KEYS[1] = lock key
+ * ARGV[1] = owner token
+ * Returns: 1 if released, 0 if not owned or doesn't exist
+ */
+export declare const RELEASE_LOCK_SCRIPT: string;
+/**
+ * Extend lock TTL if owned by token.
+ *
+ * KEYS[1] = lock key
+ * ARGV[1] = owner token
+ * ARGV[2] = TTL in milliseconds
+ * Returns: 1 if extended, 0 if not owned or doesn't exist
+ */
+export declare const EXTEND_LOCK_SCRIPT: string;
+//# sourceMappingURL=lua-scripts.d.ts.map

package/dist/lock/infrastructure/scripts/lua-scripts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lua-scripts.d.ts","sourceRoot":"","sources":["../../../../src/lock/infrastructure/scripts/lua-scripts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,QAMxB,CAAC;AAET;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,QAMvB,CAAC"}

package/dist/locks.plugin.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Locks plugin for NestJS RedisX.
+ * Provides distributed locking with auto-renewal and retry strategies.
+ */
+import { Provider } from '@nestjs/common';
+import { IRedisXPlugin } from '@nestjs-redisx/core';
+import { ILocksPluginOptions } from './shared/types';
+/**
+ * Distributed locks plugin for NestJS RedisX.
+ *
+ * Provides distributed locking with auto-renewal and retry strategies.
+ *
+ * @example
+ * ```typescript
+ * @Module({
+ *   imports: [
+ *     RedisModule.forRoot({
+ *       clients: { host: 'localhost', port: 6379 },
+ *       plugins: [
+ *         new LocksPlugin({
+ *           defaultTtl: 30000,
+ *           keyPrefix: '_lock:',
+ *           autoRenew: { enabled: true },
+ *         }),
+ *       ],
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+export declare class LocksPlugin implements IRedisXPlugin {
+    private readonly options;
+    readonly name = "locks";
+    readonly version = "0.1.0";
+    readonly description = "Distributed locking with auto-renewal and retry strategies";
+    constructor(options?: ILocksPluginOptions);
+    getProviders(): Provider[];
+    getExports(): Array<string | symbol | Provider>;
+}
+//# sourceMappingURL=locks.plugin.d.ts.map

package/dist/locks.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locks.plugin.d.ts","sourceRoot":"","sources":["../src/locks.plugin.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAqBrD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,WAAY,YAAW,aAAa;IAKnC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJpC,QAAQ,CAAC,IAAI,WAAW;IACxB,QAAQ,CAAC,OAAO,WAAW;IAC3B,QAAQ,CAAC,WAAW,gEAAgE;gBAEvD,OAAO,GAAE,mBAAwB;IAE9D,YAAY,IAAI,QAAQ,EAAE;IA2C1B,UAAU,IAAI,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;CAGhD"}

package/dist/shared/constants/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Injection token for locks plugin options
+ */
+export declare const LOCKS_PLUGIN_OPTIONS: unique symbol;
+/**
+ * Injection token for lock service
+ */
+export declare const LOCK_SERVICE: unique symbol;
+/**
+ * Injection token for lock store
+ */
+export declare const LOCK_STORE: unique symbol;
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/constants/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/constants/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,oBAAoB,eAAqC,CAAC;AAEvE;;GAEG;AACH,eAAO,MAAM,YAAY,eAA6B,CAAC;AAEvD;;GAEG;AACH,eAAO,MAAM,UAAU,eAA2B,CAAC"}

package/dist/shared/errors/index.d.ts

@@ -0,0 +1,64 @@
+import { RedisXError, ErrorCode } from '@nestjs-redisx/core';
+/**
+ * Base error class for all lock-related errors.
+ */
+export declare class LockError extends RedisXError {
+    readonly lockKey: string;
+    constructor(message: string, code: ErrorCode, lockKey: string, cause?: Error);
+}
+/**
+ * Error thrown when lock acquisition fails.
+ */
+export declare class LockAcquisitionError extends LockError {
+    readonly reason: 'timeout' | 'held' | 'error';
+    constructor(key: string, reason: 'timeout' | 'held' | 'error', cause?: Error);
+}
+/**
+ * Error thrown when attempting to release or extend a lock not owned by the caller.
+ */
+export declare class LockNotOwnedError extends LockError {
+    readonly token: string;
+    constructor(key: string, token: string);
+    toJSON(): {
+        token: string;
+        name: string;
+        message: string;
+        code: string;
+        timestamp: string;
+        context?: Record<string, unknown>;
+        stack?: string;
+        cause?: {
+            name: string;
+            message: string;
+            stack?: string;
+        };
+    };
+}
+/**
+ * Error thrown when lock extension fails.
+ */
+export declare class LockExtensionError extends LockError {
+    readonly token: string;
+    constructor(key: string, token: string, cause?: Error);
+    toJSON(): {
+        token: string;
+        name: string;
+        message: string;
+        code: string;
+        timestamp: string;
+        context?: Record<string, unknown>;
+        stack?: string;
+        cause?: {
+            name: string;
+            message: string;
+            stack?: string;
+        };
+    };
+}
+/**
+ * Error thrown when a lock has expired.
+ */
+export declare class LockExpiredError extends LockError {
+    constructor(key: string);
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/errors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAE7D;;GAEG;AACH,qBAAa,SAAU,SAAQ,WAAW;aAItB,OAAO,EAAE,MAAM;gBAF/B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,EACC,OAAO,EAAE,MAAM,EAC/B,KAAK,CAAC,EAAE,KAAK;CAIhB;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;aAG/B,MAAM,EAAE,SAAS,GAAG,MAAM,GAAG,OAAO;gBADpD,GAAG,EAAE,MAAM,EACK,MAAM,EAAE,SAAS,GAAG,MAAM,GAAG,OAAO,EACpD,KAAK,CAAC,EAAE,KAAK;CAIhB;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;aAG5B,KAAK,EAAE,MAAM;gBAD7B,GAAG,EAAE,MAAM,EACK,KAAK,EAAE,MAAM;IAKtB,MAAM;;;;;;;;;;;iBAoCijpH,CAAC;;;CA9BlkpH;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,SAAS;aAG7B,KAAK,EAAE,MAAM;gBAD7B,GAAG,EAAE,MAAM,EACK,KAAK,EAAE,MAAM,EAC7B,KAAK,CAAC,EAAE,KAAK;IAKN,MAAM;;;;;;;;;;;iBAgBijpH,CAAC;;;CAVlkpH;AAED;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,SAAS;gBACjC,GAAG,EAAE,MAAM;CAGxB"}

package/dist/shared/types/index.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Configuration options for the Locks plugin
+ * @public
+ */
+export interface ILocksPluginOptions {
+    /**
+     * Default TTL for locks in milliseconds
+     * @default 30000
+     */
+    defaultTtl?: number;
+    /**
+     * Maximum TTL for locks in milliseconds
+     * @default 300000
+     */
+    maxTtl?: number;
+    /**
+     * Key prefix for lock keys
+     * @default '_lock:'
+     */
+    keyPrefix?: string;
+    /**
+     * Retry configuration for lock acquisition
+     */
+    retry?: {
+        /**
+         * Maximum number of retries
+         * @default 3
+         */
+        maxRetries?: number;
+        /**
+         * Initial delay between retries in milliseconds
+         * @default 100
+         */
+        initialDelay?: number;
+        /**
+         * Maximum delay between retries in milliseconds
+         * @default 3000
+         */
+        maxDelay?: number;
+        /**
+         * Multiplier for exponential backoff
+         * @default 2
+         */
+        multiplier?: number;
+    };
+    /**
+     * Auto-renewal configuration
+     */
+    autoRenew?: {
+        /**
+         * Enable auto-renewal
+         * @default true
+         */
+        enabled?: boolean;
+        /**
+         * Fraction of TTL to use as renewal interval
+         * @default 0.5
+         */
+        intervalFraction?: number;
+    };
+}
+/**
+ * Options for lock acquisition
+ */
+export interface ILockOptions {
+    /**
+     * Lock TTL in milliseconds
+     */
+    ttl?: number;
+    /**
+     * Maximum time to wait for lock acquisition in milliseconds
+     */
+    waitTimeout?: number;
+    /**
+     * Enable auto-renewal for this lock
+     */
+    autoRenew?: boolean;
+    /**
+     * Retry configuration for this specific lock
+     */
+    retry?: {
+        /**
+         * Maximum number of retries
+         */
+        maxRetries?: number;
+        /**
+         * Initial delay between retries in milliseconds
+         */
+        initialDelay?: number;
+    };
+}
+/**
+ * Alias for plugin options (for consistency with plugin naming)
+ * @public
+ */
+export type LocksPluginOptions = ILocksPluginOptions;
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/types/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,KAAK,CAAC,EAAE;QACN;;;WAGG;QACH,UAAU,CAAC,EAAE,MAAM,CAAC;QAEpB;;;WAGG;QACH,YAAY,CAAC,EAAE,MAAM,CAAC;QAEtB;;;WAGG;QACH,QAAQ,CAAC,EAAE,MAAM,CAAC;QAElB;;;WAGG;QACH,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;IAEF;;OAEG;IACH,SAAS,CAAC,EAAE;QACV;;;WAGG;QACH,OAAO,CAAC,EAAE,OAAO,CAAC;QAElB;;;WAGG;QACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC3B,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,KAAK,CAAC,EAAE;QACN;;WAEG;QACH,UAAU,CAAC,EAAE,MAAM,CAAC;QAEpB;;WAEG;QACH,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAED;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,mBAAmB,CAAC"}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@nestjs-redisx/locks",
+  "version": "1.0.0",
+  "description": "Distributed locks plugin for NestJS RedisX with auto-renewal and retry strategies",
+  "author": "NestJS RedisX Team",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "SKIP_INTEGRATION=true vitest run",
+    "test:watch": "SKIP_INTEGRATION=true vitest",
+    "test:cov": "SKIP_INTEGRATION=true vitest run --coverage",
+    "test:integration": "vitest run test/integration/locks.integration.spec.ts",
+    "test:integration:watch": "vitest watch test/integration/locks.integration.spec.ts",
+    "docker:up": "docker-compose up -d",
+    "docker:down": "docker-compose down",
+    "docker:logs": "docker-compose logs -f redis",
+    "test:docker": "npm run docker:up && sleep 3 && npm run test:integration; TEST_EXIT=$?; npm run docker:down; exit $TEST_EXIT",
+    "test:all": "npm test && npm run test:integration",
+    "lint": "eslint \"{src,test}/**/*.ts\"",
+    "format": "prettier --write \"{src,test}/**/*.ts\""
+  },
+  "keywords": [
+    "nestjs",
+    "redis",
+    "locks",
+    "distributed",
+    "mutex",
+    "semaphore",
+    "auto-renewal",
+    "retry"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nestjs-redisx/nestjs-redisx.git",
+    "directory": "packages/locks"
+  },
+  "homepage": "https://nestjs-redisx.dev/en/reference/locks/",
+  "bugs": {
+    "url": "https://github.com/nestjs-redisx/nestjs-redisx/issues"
+  },
+  "peerDependencies": {
+    "@nestjs-redisx/core": "^1.0.0",
+    "@nestjs/common": "^10.0.0",
+    "@nestjs/core": "^10.0.0",
+    "reflect-metadata": "^0.2.0",
+    "rxjs": "^7.8.0"
+  },
+  "devDependencies": {
+    "@nestjs/testing": "^10.0.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "prettier": "^3.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.6.0",
+    "@vitest/coverage-v8": "^1.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}