@zauru-sdk/services 6.15.1 → 6.16.0

package/dist/esm/redis/redisQueue.js

@@ -1,26 +1,97 @@
 import { Redis } from "@upstash/redis";
 import { config } from "@zauru-sdk/config";
-const redis = new Redis({
-    url: config.redisBaseURL,
-    token: config.redisToken,
-});
-// Función para intentar adquirir el lock
-export async function acquireLock(key, lockValue, expiration) {
-    // Usamos SET con NX (solo si no existe) y PX para expirar el lock en milisegundos
-    const result = await redis.set(key, lockValue, {
-        nx: true,
-        pxat: Date.now() + expiration,
-    });
-    return result === "OK";
-}
-// Función para liberar el lock de forma segura usando un script Lua
-export async function releaseLock(key, lockValue) {
-    const script = `
-    if redis.call("get", KEYS[1]) == ARGV[1] then
-      return redis.call("del", KEYS[1])
-    else
-      return 0
-    end
-  `;
-    await redis.eval(script, [key], [lockValue]);
-}
+const EXTEND_LOCK_SCRIPT = `
+  if redis.call("get", KEYS[1]) == ARGV[1] then
+    return redis.call("pexpire", KEYS[1], ARGV[2])
+  else
+    return 0
+  end
+`;
+const RELEASE_LOCK_SCRIPT = `
+  if redis.call("get", KEYS[1]) == ARGV[1] then
+    return redis.call("del", KEYS[1])
+  else
+    return 0
+  end
+`;
+let defaultRedis;
+const getDefaultRedis = () => {
+    if (!defaultRedis) {
+        defaultRedis = new Redis({
+            url: config.redisBaseURL,
+            token: config.redisToken,
+        });
+    }
+    return defaultRedis;
+};
+const isSuccessfulEval = (result) => result === 1 || result === "1";
+export const createLockClient = (redis) => {
+    const acquireLock = async (key, lockValue, expiration) => {
+        const result = await redis.set(key, lockValue, {
+            nx: true,
+            px: expiration,
+        });
+        return result === "OK";
+    };
+    const extendLock = async (key, lockValue, expiration) => {
+        const result = await redis.eval(EXTEND_LOCK_SCRIPT, [key], [
+            lockValue,
+            expiration,
+        ]);
+        return isSuccessfulEval(result);
+    };
+    const releaseLock = async (key, lockValue) => {
+        await redis.eval(RELEASE_LOCK_SCRIPT, [key], [lockValue]);
+    };
+    const startLockHeartbeat = (key, lockValue, expiration, intervalMs = Math.max(1_000, Math.floor(expiration / 3))) => {
+        const timer = setInterval(() => {
+            void extendLock(key, lockValue, expiration).catch((error) => {
+                console.error("extendLock failed", error);
+            });
+        }, intervalMs);
+        timer.unref?.();
+        return () => clearInterval(timer);
+    };
+    const runWithLock = async (options, fn) => {
+        const retryMs = options.retryMs ?? 10_000;
+        const startedAt = Date.now();
+        let acquired = false;
+        while (!acquired) {
+            if (Date.now() - startedAt >= options.waitMs) {
+                return { acquired: false };
+            }
+            acquired = await acquireLock(options.key, options.lockValue, options.ttlMs);
+            if (!acquired) {
+                await new Promise((resolve) => setTimeout(resolve, retryMs));
+            }
+        }
+        const stopHeartbeat = startLockHeartbeat(options.key, options.lockValue, options.ttlMs);
+        try {
+            const result = await fn();
+            return { acquired: true, result };
+        }
+        finally {
+            stopHeartbeat();
+            await releaseLock(options.key, options.lockValue);
+        }
+    };
+    return {
+        acquireLock,
+        extendLock,
+        releaseLock,
+        startLockHeartbeat,
+        runWithLock,
+    };
+};
+let defaultLockClient;
+const getDefaultLockClient = () => {
+    if (!defaultLockClient) {
+        defaultLockClient = createLockClient(getDefaultRedis());
+    }
+    return defaultLockClient;
+};
+export const acquireLock = (key, lockValue, expiration) => getDefaultLockClient().acquireLock(key, lockValue, expiration);
+export const extendLock = (key, lockValue, expiration) => getDefaultLockClient().extendLock(key, lockValue, expiration);
+export const releaseLock = (key, lockValue) => getDefaultLockClient().releaseLock(key, lockValue);
+export const startLockHeartbeat = (key, lockValue, expiration, intervalMs) => getDefaultLockClient().startLockHeartbeat(key, lockValue, expiration, intervalMs);
+export const runWithLock = (options, fn) => getDefaultLockClient().runWithLock(options, fn);

package/dist/redis/redisQueue.d.ts

@@ -1,2 +1,32 @@
-export declare function acquireLock(key: string, lockValue: string, expiration: number): Promise<boolean>;
-export declare function releaseLock(key: string, lockValue: string): Promise<void>;
+export type RedisLockClient = {
+    set: (key: string, value: string, opts: {
+        nx: true;
+        px: number;
+    }) => Promise<string | null>;
+    eval: (script: string, keys: string[], args: (string | number)[]) => Promise<unknown>;
+};
+export type RunWithLockOptions = {
+    key: string;
+    lockValue: string;
+    ttlMs: number;
+    waitMs: number;
+    retryMs?: number;
+};
+export type RunWithLockResult<T> = {
+    acquired: false;
+} | {
+    acquired: true;
+    result: T;
+};
+export declare const createLockClient: (redis: RedisLockClient) => {
+    acquireLock: (key: string, lockValue: string, expiration: number) => Promise<boolean>;
+    extendLock: (key: string, lockValue: string, expiration: number) => Promise<boolean>;
+    releaseLock: (key: string, lockValue: string) => Promise<void>;
+    startLockHeartbeat: (key: string, lockValue: string, expiration: number, intervalMs?: number) => (() => void);
+    runWithLock: <T>(options: RunWithLockOptions, fn: () => Promise<T>) => Promise<RunWithLockResult<T>>;
+};
+export declare const acquireLock: (key: string, lockValue: string, expiration: number) => Promise<boolean>;
+export declare const extendLock: (key: string, lockValue: string, expiration: number) => Promise<boolean>;
+export declare const releaseLock: (key: string, lockValue: string) => Promise<void>;
+export declare const startLockHeartbeat: (key: string, lockValue: string, expiration: number, intervalMs?: number) => () => void;
+export declare const runWithLock: <T>(options: RunWithLockOptions, fn: () => Promise<T>) => Promise<RunWithLockResult<T>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zauru-sdk/services",
-  "version": "6.15.1",
+  "version": "6.16.0",
   "description": "Servicios de consulta a Zauru",
   "main": "./dist/esm/index.js",
   "module": "./dist/esm/index.js",
@@ -13,7 +13,7 @@
   "scripts": {
     "build": "npm run build:esm",
     "build:esm": "tsc -p tsconfig.esm.json",
-    "test": "tsx --test src/zauru/*.test.ts"
+    "test": "tsx --test src/zauru/*.test.ts src/redis/*.test.ts"
   },
   "files": [
     "dist"
@@ -29,11 +29,11 @@
     "@upstash/redis": "^1.34.5",
     "@zauru-sdk/common": "^6.12.0",
     "@zauru-sdk/config": "^6.0.0",
-    "@zauru-sdk/graphql": "^6.9.0",
+    "@zauru-sdk/graphql": "^6.9.1",
     "@zauru-sdk/types": "^6.28.0",
     "axios": "^1.6.7",
     "chalk": "5.3.0",
     "moment": "^2.30.1"
   },
-  "gitHead": "2fda4a18e3f62d22c38fbb91052869db9ebc16f4"
+  "gitHead": "91be71ebd8225a82f533d4e62ec5fbf5aeab09c8"
 }