@universal-lock/redis 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Lucas Rainett
+
+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,123 @@
+# @universal-lock/redis
+
+Redis backend for [`universal-lock`](https://github.com/lucasrainett/universal-lock). Provides distributed locking across processes and servers using atomic Lua scripts.
+
+## Installation
+
+```bash
+npm install universal-lock @universal-lock/redis
+```
+
+You also need a Redis client library such as [ioredis](https://www.npmjs.com/package/ioredis) or [node-redis](https://www.npmjs.com/package/redis).
+
+## Usage
+
+### ESM with ioredis
+
+```typescript
+import { lockFactory } from "universal-lock";
+import { createBackend } from "@universal-lock/redis";
+import Redis from "ioredis";
+
+const client = new Redis();
+const redisClient = {
+	eval: (script: string, keys: string[], args: string[]) => client.eval(script, keys.length, ...keys, ...args),
+};
+
+const lock = lockFactory(createBackend(redisClient));
+
+const release = await lock.acquire("my-resource");
+try {
+	// critical section — safe across processes and servers
+} finally {
+	await release();
+}
+```
+
+### ESM with node-redis
+
+```typescript
+import { lockFactory } from "universal-lock";
+import { createBackend } from "@universal-lock/redis";
+import { createClient } from "redis";
+
+const client = createClient();
+await client.connect();
+const redisClient = {
+	eval: (script: string, keys: string[], args: string[]) => client.eval(script, { keys, arguments: args }),
+};
+
+const lock = lockFactory(createBackend(redisClient));
+```
+
+### CommonJS
+
+```javascript
+const { lockFactory } = require("universal-lock");
+const { createBackend } = require("@universal-lock/redis");
+const Redis = require("ioredis");
+
+const client = new Redis();
+const redisClient = {
+	eval: (script, keys, args) => client.eval(script, keys.length, ...keys, ...args),
+};
+
+const lock = lockFactory(createBackend(redisClient));
+```
+
+### Browser (IIFE)
+
+```html
+<script src="https://unpkg.com/@universal-lock/redis/dist/index.global.js"></script>
+<script src="https://unpkg.com/universal-lock/dist/index.global.js"></script>
+<script>
+	const backend = UniversalLockRedis.createBackend(redisClient);
+	const lock = UniversalLock.lockFactory(backend);
+</script>
+```
+
+## API
+
+### `createBackend(client, options?)`
+
+Creates a Redis backend instance.
+
+```typescript
+import { createBackend } from "@universal-lock/redis";
+
+const backend = createBackend(redisClient, {
+	prefix: "my-app:", // key prefix (default: "universal-lock:")
+});
+```
+
+### `RedisClient` interface
+
+Any Redis client that implements this interface is supported:
+
+```typescript
+interface RedisClient {
+	eval(script: string, keys: string[], args: string[]): Promise<unknown>;
+}
+```
+
+### Options
+
+| Option   | Type     | Default             | Description                |
+| -------- | -------- | ------------------- | -------------------------- |
+| `prefix` | `string` | `"universal-lock:"` | Prefix for Redis key names |
+
+## How It Works
+
+All operations use atomic Lua scripts executed server-side on Redis:
+
+- **Acquire** — `SET key value NX PX ttl` (set only if not exists, with TTL)
+- **Renew** — Verify ownership, then `PEXPIRE` to extend TTL
+- **Release** — Verify ownership, then `DEL` to remove
+
+## Limitations
+
+- Works with a **single Redis instance** only. For multi-instance quorum locking (Redlock algorithm), a dedicated implementation is needed.
+
+## License
+
+[MIT](https://github.com/lucasrainett/universal-lock/blob/master/LICENSE)

package/dist/index.d.mts

@@ -0,0 +1,11 @@
+import { Backend } from '@universal-lock/types';
+
+interface RedisClient {
+    eval(script: string, keys: string[], args: string[]): Promise<unknown>;
+}
+interface RedisBackendOptions {
+    prefix?: string;
+}
+declare const createBackend: (client: RedisClient, options?: RedisBackendOptions) => Backend;
+
+export { type RedisBackendOptions, type RedisClient, createBackend };

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { Backend } from '@universal-lock/types';
+
+interface RedisClient {
+    eval(script: string, keys: string[], args: string[]): Promise<unknown>;
+}
+interface RedisBackendOptions {
+    prefix?: string;
+}
+declare const createBackend: (client: RedisClient, options?: RedisBackendOptions) => Backend;
+
+export { type RedisBackendOptions, type RedisClient, createBackend };

package/dist/index.global.js

@@ -0,0 +1,96 @@
+"use strict";
+var UniversalLockRedis = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    createBackend: () => createBackend
+  });
+  var DEFAULT_PREFIX = "universal-lock:";
+  var ACQUIRE_SCRIPT = `
+if redis.call('SET', KEYS[1], ARGV[1], 'NX', 'PX', ARGV[2]) then
+  return 1
+end
+return 0
+`;
+  var RENEW_SCRIPT = `
+if redis.call('GET', KEYS[1]) == ARGV[1] then
+  redis.call('PEXPIRE', KEYS[1], ARGV[2])
+  return 1
+end
+return 0
+`;
+  var RELEASE_SCRIPT = `
+if redis.call('GET', KEYS[1]) == ARGV[1] then
+  redis.call('DEL', KEYS[1])
+  return 1
+end
+return 0
+`;
+  var createBackend = (client, options = {}) => {
+    const prefix = options.prefix ?? DEFAULT_PREFIX;
+    const ttls = /* @__PURE__ */ new Map();
+    const key = (lockName) => prefix + lockName;
+    const setup = async () => {
+    };
+    const acquire = async (lockName, stale, lockId) => {
+      const result = await client.eval(
+        ACQUIRE_SCRIPT,
+        [key(lockName)],
+        [lockId, String(stale)]
+      );
+      if (result !== 1) {
+        throw new Error(`${lockName} already locked`);
+      }
+      ttls.set(lockName, stale);
+    };
+    const renew = async (lockName, lockId) => {
+      const ttl = ttls.get(lockName);
+      if (!ttl) throw new Error(`${lockName} not locked`);
+      const result = await client.eval(
+        RENEW_SCRIPT,
+        [key(lockName)],
+        [lockId, String(ttl)]
+      );
+      if (result !== 1) {
+        throw new Error(`${lockName} not owned by caller`);
+      }
+    };
+    const release = async (lockName, lockId) => {
+      const result = await client.eval(
+        RELEASE_SCRIPT,
+        [key(lockName)],
+        [lockId]
+      );
+      ttls.delete(lockName);
+      if (result !== 1) {
+        throw new Error(`${lockName} not owned by caller`);
+      }
+    };
+    return {
+      setup,
+      acquire,
+      renew,
+      release
+    };
+  };
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map

package/dist/index.global.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type {\n\tBackend,\n\tBackendAcquireFunction,\n\tBackendReleaseFunction,\n\tBackendRenewFunction,\n\tBackendSetupFunction,\n} from \"@universal-lock/types\";\n\nexport interface RedisClient {\n\teval(script: string, keys: string[], args: string[]): Promise<unknown>;\n}\n\nexport interface RedisBackendOptions {\n\tprefix?: string;\n}\n\nconst DEFAULT_PREFIX = \"universal-lock:\";\n\n// Atomically set the lock key only if it doesn't exist (NX), with a TTL in ms (PX).\n// This ensures only one client can hold the lock at a time.\nconst ACQUIRE_SCRIPT = `\nif redis.call('SET', KEYS[1], ARGV[1], 'NX', 'PX', ARGV[2]) then\n  return 1\nend\nreturn 0\n`;\n\n// Renew only if the caller still owns the lock (value matches lockId).\n// Resets the TTL to prevent the lock from expiring while still in use.\nconst RENEW_SCRIPT = `\nif redis.call('GET', KEYS[1]) == ARGV[1] then\n  redis.call('PEXPIRE', KEYS[1], ARGV[2])\n  return 1\nend\nreturn 0\n`;\n\n// Delete only if the caller owns the lock, preventing one client from\n// releasing another client's lock after a stale takeover.\nconst RELEASE_SCRIPT = `\nif redis.call('GET', KEYS[1]) == ARGV[1] then\n  redis.call('DEL', KEYS[1])\n  return 1\nend\nreturn 0\n`;\n\nexport const createBackend = (\n\tclient: RedisClient,\n\toptions: RedisBackendOptions = {},\n): Backend => {\n\tconst prefix = options.prefix ?? DEFAULT_PREFIX;\n\t// Cache the stale TTL per lock so renew can re-apply the same expiration\n\tconst ttls = new Map<string, number>();\n\n\tconst key = (lockName: string) => prefix + lockName;\n\n\tconst setup: BackendSetupFunction = async () => {};\n\n\tconst acquire: BackendAcquireFunction = async (lockName, stale, lockId) => {\n\t\tconst result = await client.eval(\n\t\t\tACQUIRE_SCRIPT,\n\t\t\t[key(lockName)],\n\t\t\t[lockId, String(stale)],\n\t\t);\n\t\tif (result !== 1) {\n\t\t\tthrow new Error(`${lockName} already locked`);\n\t\t}\n\t\tttls.set(lockName, stale);\n\t};\n\n\tconst renew: BackendRenewFunction = async (lockName, lockId) => {\n\t\tconst ttl = ttls.get(lockName);\n\t\tif (!ttl) throw new Error(`${lockName} not locked`);\n\t\tconst result = await client.eval(\n\t\t\tRENEW_SCRIPT,\n\t\t\t[key(lockName)],\n\t\t\t[lockId, String(ttl)],\n\t\t);\n\t\tif (result !== 1) {\n\t\t\tthrow new Error(`${lockName} not owned by caller`);\n\t\t}\n\t};\n\n\tconst release: BackendReleaseFunction = async (lockName, lockId) => {\n\t\tconst result = await client.eval(\n\t\t\tRELEASE_SCRIPT,\n\t\t\t[key(lockName)],\n\t\t\t[lockId],\n\t\t);\n\t\tttls.delete(lockName);\n\t\tif (result !== 1) {\n\t\t\tthrow new Error(`${lockName} not owned by caller`);\n\t\t}\n\t};\n\n\treturn {\n\t\tsetup,\n\t\tacquire,\n\t\trenew,\n\t\trelease,\n\t};\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAgBA,MAAM,iBAAiB;AAIvB,MAAM,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AASvB,MAAM,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUrB,MAAM,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQhB,MAAM,gBAAgB,CAC5B,QACA,UAA+B,CAAC,MACnB;AACb,UAAM,SAAS,QAAQ,UAAU;AAEjC,UAAM,OAAO,oBAAI,IAAoB;AAErC,UAAM,MAAM,CAAC,aAAqB,SAAS;AAE3C,UAAM,QAA8B,YAAY;AAAA,IAAC;AAEjD,UAAM,UAAkC,OAAO,UAAU,OAAO,WAAW;AAC1E,YAAM,SAAS,MAAM,OAAO;AAAA,QAC3B;AAAA,QACA,CAAC,IAAI,QAAQ,CAAC;AAAA,QACd,CAAC,QAAQ,OAAO,KAAK,CAAC;AAAA,MACvB;AACA,UAAI,WAAW,GAAG;AACjB,cAAM,IAAI,MAAM,GAAG,QAAQ,iBAAiB;AAAA,MAC7C;AACA,WAAK,IAAI,UAAU,KAAK;AAAA,IACzB;AAEA,UAAM,QAA8B,OAAO,UAAU,WAAW;AAC/D,YAAM,MAAM,KAAK,IAAI,QAAQ;AAC7B,UAAI,CAAC,IAAK,OAAM,IAAI,MAAM,GAAG,QAAQ,aAAa;AAClD,YAAM,SAAS,MAAM,OAAO;AAAA,QAC3B;AAAA,QACA,CAAC,IAAI,QAAQ,CAAC;AAAA,QACd,CAAC,QAAQ,OAAO,GAAG,CAAC;AAAA,MACrB;AACA,UAAI,WAAW,GAAG;AACjB,cAAM,IAAI,MAAM,GAAG,QAAQ,sBAAsB;AAAA,MAClD;AAAA,IACD;AAEA,UAAM,UAAkC,OAAO,UAAU,WAAW;AACnE,YAAM,SAAS,MAAM,OAAO;AAAA,QAC3B;AAAA,QACA,CAAC,IAAI,QAAQ,CAAC;AAAA,QACd,CAAC,MAAM;AAAA,MACR;AACA,WAAK,OAAO,QAAQ;AACpB,UAAI,WAAW,GAAG;AACjB,cAAM,IAAI,MAAM,GAAG,QAAQ,sBAAsB;AAAA,MAClD;AAAA,IACD;AAEA,WAAO;AAAA,MACN;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACD;AAAA,EACD;","names":[]}

package/dist/index.js

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createBackend: () => createBackend
+});
+module.exports = __toCommonJS(index_exports);
+var DEFAULT_PREFIX = "universal-lock:";
+var ACQUIRE_SCRIPT = `
+if redis.call('SET', KEYS[1], ARGV[1], 'NX', 'PX', ARGV[2]) then
+  return 1
+end
+return 0
+`;
+var RENEW_SCRIPT = `
+if redis.call('GET', KEYS[1]) == ARGV[1] then
+  redis.call('PEXPIRE', KEYS[1], ARGV[2])
+  return 1
+end
+return 0
+`;
+var RELEASE_SCRIPT = `
+if redis.call('GET', KEYS[1]) == ARGV[1] then
+  redis.call('DEL', KEYS[1])
+  return 1
+end
+return 0
+`;
+var createBackend = (client, options = {}) => {
+  const prefix = options.prefix ?? DEFAULT_PREFIX;
+  const ttls = /* @__PURE__ */ new Map();
+  const key = (lockName) => prefix + lockName;
+  const setup = async () => {
+  };
+  const acquire = async (lockName, stale, lockId) => {
+    const result = await client.eval(
+      ACQUIRE_SCRIPT,
+      [key(lockName)],
+      [lockId, String(stale)]
+    );
+    if (result !== 1) {
+      throw new Error(`${lockName} already locked`);
+    }
+    ttls.set(lockName, stale);
+  };
+  const renew = async (lockName, lockId) => {
+    const ttl = ttls.get(lockName);
+    if (!ttl) throw new Error(`${lockName} not locked`);
+    const result = await client.eval(
+      RENEW_SCRIPT,
+      [key(lockName)],
+      [lockId, String(ttl)]
+    );
+    if (result !== 1) {
+      throw new Error(`${lockName} not owned by caller`);
+    }
+  };
+  const release = async (lockName, lockId) => {
+    const result = await client.eval(
+      RELEASE_SCRIPT,
+      [key(lockName)],
+      [lockId]
+    );
+    ttls.delete(lockName);
+    if (result !== 1) {
+      throw new Error(`${lockName} not owned by caller`);
+    }
+  };
+  return {
+    setup,
+    acquire,
+    renew,
+    release
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBackend
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type {\n\tBackend,\n\tBackendAcquireFunction,\n\tBackendReleaseFunction,\n\tBackendRenewFunction,\n\tBackendSetupFunction,\n} from \"@universal-lock/types\";\n\nexport interface RedisClient {\n\teval(script: string, keys: string[], args: string[]): Promise<unknown>;\n}\n\nexport interface RedisBackendOptions {\n\tprefix?: string;\n}\n\nconst DEFAULT_PREFIX = \"universal-lock:\";\n\n// Atomically set the lock key only if it doesn't exist (NX), with a TTL in ms (PX).\n// This ensures only one client can hold the lock at a time.\nconst ACQUIRE_SCRIPT = `\nif redis.call('SET', KEYS[1], ARGV[1], 'NX', 'PX', ARGV[2]) then\n  return 1\nend\nreturn 0\n`;\n\n// Renew only if the caller still owns the lock (value matches lockId).\n// Resets the TTL to prevent the lock from expiring while still in use.\nconst RENEW_SCRIPT = `\nif redis.call('GET', KEYS[1]) == ARGV[1] then\n  redis.call('PEXPIRE', KEYS[1], ARGV[2])\n  return 1\nend\nreturn 0\n`;\n\n// Delete only if the caller owns the lock, preventing one client from\n// releasing another client's lock after a stale takeover.\nconst RELEASE_SCRIPT = `\nif redis.call('GET', KEYS[1]) == ARGV[1] then\n  redis.call('DEL', KEYS[1])\n  return 1\nend\nreturn 0\n`;\n\nexport const createBackend = (\n\tclient: RedisClient,\n\toptions: RedisBackendOptions = {},\n): Backend => {\n\tconst prefix = options.prefix ?? DEFAULT_PREFIX;\n\t// Cache the stale TTL per lock so renew can re-apply the same expiration\n\tconst ttls = new Map<string, number>();\n\n\tconst key = (lockName: string) => prefix + lockName;\n\n\tconst setup: BackendSetupFunction = async () => {};\n\n\tconst acquire: BackendAcquireFunction = async (lockName, stale, lockId) => {\n\t\tconst result = await client.eval(\n\t\t\tACQUIRE_SCRIPT,\n\t\t\t[key(lockName)],\n\t\t\t[lockId, String(stale)],\n\t\t);\n\t\tif (result !== 1) {\n\t\t\tthrow new Error(`${lockName} already locked`);\n\t\t}\n\t\tttls.set(lockName, stale);\n\t};\n\n\tconst renew: BackendRenewFunction = async (lockName, lockId) => {\n\t\tconst ttl = ttls.get(lockName);\n\t\tif (!ttl) throw new Error(`${lockName} not locked`);\n\t\tconst result = await client.eval(\n\t\t\tRENEW_SCRIPT,\n\t\t\t[key(lockName)],\n\t\t\t[lockId, String(ttl)],\n\t\t);\n\t\tif (result !== 1) {\n\t\t\tthrow new Error(`${lockName} not owned by caller`);\n\t\t}\n\t};\n\n\tconst release: BackendReleaseFunction = async (lockName, lockId) => {\n\t\tconst result = await client.eval(\n\t\t\tRELEASE_SCRIPT,\n\t\t\t[key(lockName)],\n\t\t\t[lockId],\n\t\t);\n\t\tttls.delete(lockName);\n\t\tif (result !== 1) {\n\t\t\tthrow new Error(`${lockName} not owned by caller`);\n\t\t}\n\t};\n\n\treturn {\n\t\tsetup,\n\t\tacquire,\n\t\trenew,\n\t\trelease,\n\t};\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,IAAM,iBAAiB;AAIvB,IAAM,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AASvB,IAAM,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUrB,IAAM,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQhB,IAAM,gBAAgB,CAC5B,QACA,UAA+B,CAAC,MACnB;AACb,QAAM,SAAS,QAAQ,UAAU;AAEjC,QAAM,OAAO,oBAAI,IAAoB;AAErC,QAAM,MAAM,CAAC,aAAqB,SAAS;AAE3C,QAAM,QAA8B,YAAY;AAAA,EAAC;AAEjD,QAAM,UAAkC,OAAO,UAAU,OAAO,WAAW;AAC1E,UAAM,SAAS,MAAM,OAAO;AAAA,MAC3B;AAAA,MACA,CAAC,IAAI,QAAQ,CAAC;AAAA,MACd,CAAC,QAAQ,OAAO,KAAK,CAAC;AAAA,IACvB;AACA,QAAI,WAAW,GAAG;AACjB,YAAM,IAAI,MAAM,GAAG,QAAQ,iBAAiB;AAAA,IAC7C;AACA,SAAK,IAAI,UAAU,KAAK;AAAA,EACzB;AAEA,QAAM,QAA8B,OAAO,UAAU,WAAW;AAC/D,UAAM,MAAM,KAAK,IAAI,QAAQ;AAC7B,QAAI,CAAC,IAAK,OAAM,IAAI,MAAM,GAAG,QAAQ,aAAa;AAClD,UAAM,SAAS,MAAM,OAAO;AAAA,MAC3B;AAAA,MACA,CAAC,IAAI,QAAQ,CAAC;AAAA,MACd,CAAC,QAAQ,OAAO,GAAG,CAAC;AAAA,IACrB;AACA,QAAI,WAAW,GAAG;AACjB,YAAM,IAAI,MAAM,GAAG,QAAQ,sBAAsB;AAAA,IAClD;AAAA,EACD;AAEA,QAAM,UAAkC,OAAO,UAAU,WAAW;AACnE,UAAM,SAAS,MAAM,OAAO;AAAA,MAC3B;AAAA,MACA,CAAC,IAAI,QAAQ,CAAC;AAAA,MACd,CAAC,MAAM;AAAA,IACR;AACA,SAAK,OAAO,QAAQ;AACpB,QAAI,WAAW,GAAG;AACjB,YAAM,IAAI,MAAM,GAAG,QAAQ,sBAAsB;AAAA,IAClD;AAAA,EACD;AAEA,SAAO;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACD;AACD;","names":[]}

package/dist/index.mjs

@@ -0,0 +1,73 @@
+// src/index.ts
+var DEFAULT_PREFIX = "universal-lock:";
+var ACQUIRE_SCRIPT = `
+if redis.call('SET', KEYS[1], ARGV[1], 'NX', 'PX', ARGV[2]) then
+  return 1
+end
+return 0
+`;
+var RENEW_SCRIPT = `
+if redis.call('GET', KEYS[1]) == ARGV[1] then
+  redis.call('PEXPIRE', KEYS[1], ARGV[2])
+  return 1
+end
+return 0
+`;
+var RELEASE_SCRIPT = `
+if redis.call('GET', KEYS[1]) == ARGV[1] then
+  redis.call('DEL', KEYS[1])
+  return 1
+end
+return 0
+`;
+var createBackend = (client, options = {}) => {
+  const prefix = options.prefix ?? DEFAULT_PREFIX;
+  const ttls = /* @__PURE__ */ new Map();
+  const key = (lockName) => prefix + lockName;
+  const setup = async () => {
+  };
+  const acquire = async (lockName, stale, lockId) => {
+    const result = await client.eval(
+      ACQUIRE_SCRIPT,
+      [key(lockName)],
+      [lockId, String(stale)]
+    );
+    if (result !== 1) {
+      throw new Error(`${lockName} already locked`);
+    }
+    ttls.set(lockName, stale);
+  };
+  const renew = async (lockName, lockId) => {
+    const ttl = ttls.get(lockName);
+    if (!ttl) throw new Error(`${lockName} not locked`);
+    const result = await client.eval(
+      RENEW_SCRIPT,
+      [key(lockName)],
+      [lockId, String(ttl)]
+    );
+    if (result !== 1) {
+      throw new Error(`${lockName} not owned by caller`);
+    }
+  };
+  const release = async (lockName, lockId) => {
+    const result = await client.eval(
+      RELEASE_SCRIPT,
+      [key(lockName)],
+      [lockId]
+    );
+    ttls.delete(lockName);
+    if (result !== 1) {
+      throw new Error(`${lockName} not owned by caller`);
+    }
+  };
+  return {
+    setup,
+    acquire,
+    renew,
+    release
+  };
+};
+export {
+  createBackend
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type {\n\tBackend,\n\tBackendAcquireFunction,\n\tBackendReleaseFunction,\n\tBackendRenewFunction,\n\tBackendSetupFunction,\n} from \"@universal-lock/types\";\n\nexport interface RedisClient {\n\teval(script: string, keys: string[], args: string[]): Promise<unknown>;\n}\n\nexport interface RedisBackendOptions {\n\tprefix?: string;\n}\n\nconst DEFAULT_PREFIX = \"universal-lock:\";\n\n// Atomically set the lock key only if it doesn't exist (NX), with a TTL in ms (PX).\n// This ensures only one client can hold the lock at a time.\nconst ACQUIRE_SCRIPT = `\nif redis.call('SET', KEYS[1], ARGV[1], 'NX', 'PX', ARGV[2]) then\n  return 1\nend\nreturn 0\n`;\n\n// Renew only if the caller still owns the lock (value matches lockId).\n// Resets the TTL to prevent the lock from expiring while still in use.\nconst RENEW_SCRIPT = `\nif redis.call('GET', KEYS[1]) == ARGV[1] then\n  redis.call('PEXPIRE', KEYS[1], ARGV[2])\n  return 1\nend\nreturn 0\n`;\n\n// Delete only if the caller owns the lock, preventing one client from\n// releasing another client's lock after a stale takeover.\nconst RELEASE_SCRIPT = `\nif redis.call('GET', KEYS[1]) == ARGV[1] then\n  redis.call('DEL', KEYS[1])\n  return 1\nend\nreturn 0\n`;\n\nexport const createBackend = (\n\tclient: RedisClient,\n\toptions: RedisBackendOptions = {},\n): Backend => {\n\tconst prefix = options.prefix ?? DEFAULT_PREFIX;\n\t// Cache the stale TTL per lock so renew can re-apply the same expiration\n\tconst ttls = new Map<string, number>();\n\n\tconst key = (lockName: string) => prefix + lockName;\n\n\tconst setup: BackendSetupFunction = async () => {};\n\n\tconst acquire: BackendAcquireFunction = async (lockName, stale, lockId) => {\n\t\tconst result = await client.eval(\n\t\t\tACQUIRE_SCRIPT,\n\t\t\t[key(lockName)],\n\t\t\t[lockId, String(stale)],\n\t\t);\n\t\tif (result !== 1) {\n\t\t\tthrow new Error(`${lockName} already locked`);\n\t\t}\n\t\tttls.set(lockName, stale);\n\t};\n\n\tconst renew: BackendRenewFunction = async (lockName, lockId) => {\n\t\tconst ttl = ttls.get(lockName);\n\t\tif (!ttl) throw new Error(`${lockName} not locked`);\n\t\tconst result = await client.eval(\n\t\t\tRENEW_SCRIPT,\n\t\t\t[key(lockName)],\n\t\t\t[lockId, String(ttl)],\n\t\t);\n\t\tif (result !== 1) {\n\t\t\tthrow new Error(`${lockName} not owned by caller`);\n\t\t}\n\t};\n\n\tconst release: BackendReleaseFunction = async (lockName, lockId) => {\n\t\tconst result = await client.eval(\n\t\t\tRELEASE_SCRIPT,\n\t\t\t[key(lockName)],\n\t\t\t[lockId],\n\t\t);\n\t\tttls.delete(lockName);\n\t\tif (result !== 1) {\n\t\t\tthrow new Error(`${lockName} not owned by caller`);\n\t\t}\n\t};\n\n\treturn {\n\t\tsetup,\n\t\tacquire,\n\t\trenew,\n\t\trelease,\n\t};\n};\n"],"mappings":";AAgBA,IAAM,iBAAiB;AAIvB,IAAM,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AASvB,IAAM,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUrB,IAAM,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQhB,IAAM,gBAAgB,CAC5B,QACA,UAA+B,CAAC,MACnB;AACb,QAAM,SAAS,QAAQ,UAAU;AAEjC,QAAM,OAAO,oBAAI,IAAoB;AAErC,QAAM,MAAM,CAAC,aAAqB,SAAS;AAE3C,QAAM,QAA8B,YAAY;AAAA,EAAC;AAEjD,QAAM,UAAkC,OAAO,UAAU,OAAO,WAAW;AAC1E,UAAM,SAAS,MAAM,OAAO;AAAA,MAC3B;AAAA,MACA,CAAC,IAAI,QAAQ,CAAC;AAAA,MACd,CAAC,QAAQ,OAAO,KAAK,CAAC;AAAA,IACvB;AACA,QAAI,WAAW,GAAG;AACjB,YAAM,IAAI,MAAM,GAAG,QAAQ,iBAAiB;AAAA,IAC7C;AACA,SAAK,IAAI,UAAU,KAAK;AAAA,EACzB;AAEA,QAAM,QAA8B,OAAO,UAAU,WAAW;AAC/D,UAAM,MAAM,KAAK,IAAI,QAAQ;AAC7B,QAAI,CAAC,IAAK,OAAM,IAAI,MAAM,GAAG,QAAQ,aAAa;AAClD,UAAM,SAAS,MAAM,OAAO;AAAA,MAC3B;AAAA,MACA,CAAC,IAAI,QAAQ,CAAC;AAAA,MACd,CAAC,QAAQ,OAAO,GAAG,CAAC;AAAA,IACrB;AACA,QAAI,WAAW,GAAG;AACjB,YAAM,IAAI,MAAM,GAAG,QAAQ,sBAAsB;AAAA,IAClD;AAAA,EACD;AAEA,QAAM,UAAkC,OAAO,UAAU,WAAW;AACnE,UAAM,SAAS,MAAM,OAAO;AAAA,MAC3B;AAAA,MACA,CAAC,IAAI,QAAQ,CAAC;AAAA,MACd,CAAC,MAAM;AAAA,IACR;AACA,SAAK,OAAO,QAAQ;AACpB,QAAI,WAAW,GAAG;AACjB,YAAM,IAAI,MAAM,GAAG,QAAQ,sBAAsB;AAAA,IAClD;AAAA,EACD;AAEA,SAAO;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACD;AACD;","names":[]}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@universal-lock/redis",
+  "version": "1.0.0",
+  "description": "Redis backend for universal-lock — distributed locking via Lua scripts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "browser": "dist/index.global.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "files": [
+    "/dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lucasrainett/universal-lock",
+    "directory": "packages/redis"
+  },
+  "keywords": [
+    "universal-lock",
+    "lock",
+    "mutex",
+    "redis",
+    "distributed-lock",
+    "backend"
+  ],
+  "author": {
+    "name": "Lucas Rainett",
+    "email": "lucas@rainett.dev",
+    "url": "https://github.com/lucasrainett"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@universal-lock/types": "1.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "rm -rf dist"
+  }
+}