@maestro-js/cache 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/index.d.ts

@@ -1,8 +1,6 @@
 import { Log } from '@maestro-js/log';
 import Redis$1, { Redis } from 'ioredis';
 
-type DurationString = `${number} ${'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds'}`;
-
 /** Contract that every cache backend (Redis, MockRedis, etc.) must implement */
 interface CacheDriver {
     /** Checks whether `key` exists in the store */
@@ -62,6 +60,9 @@ declare function redisCacheDriver({ url, port, operationTimeout, connectTimeout,
     connection: Redis$1;
 };
 
+type DurationString = `${number} ${'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds'}`;
+
+type CacheDurationString = DurationString;
 /**
  * Creates a new Cache service instance with the provided driver configuration.
  */
@@ -163,7 +164,7 @@ declare namespace Cache {
     /** Pluggable backend implementation — see `Cache.drivers` for built-in options */
     type Driver = CacheDriver;
     /** Duration string like `'5 minutes'` or `'1 hour'` */
-    type DurationString = DurationString;
+    type DurationString = CacheDurationString;
     /** TTL options for `remember` — a number (seconds), `null` (forever), a duration string, or an object with `ttl` and `swr` */
     type RememberOptions = number | null | DurationString | {
         ttl: number | DurationString | null;

package/dist/index.js

@@ -3,27 +3,37 @@ import assert from "assert";
 import { ServiceRegistry } from "@maestro-js/service-registry";
 
 // src/mock-redis-cache-driver.ts
-import EventEmitter from "events";
 import { randomUUID } from "crypto";
-import { Log } from "@maestro-js/log";
 import MockRedis from "ioredis-mock";
 import "ioredis";
 function mockRedisCacheDriver({
   logger: loggerInput,
   keyPrefix = ""
 }) {
-  const logger = loggerInput ?? Log.create();
+  const logger = loggerInput;
   const redis = new MockRedis();
-  const lockEmitter = new EventEmitter();
-  const channelPrefix = [keyPrefix, "maestro.events."].join("");
-  const cacheLockChannelName = `${channelPrefix}cache-locks`;
-  redis.on("error", (error) => {
-    logger.error(error);
-  });
-  redis.on("message", (channel, message) => {
-    if (channel === cacheLockChannelName) {
-      lockEmitter.emit(message);
+  const lockWaiters = /* @__PURE__ */ new Map();
+  function addWaiter(lockId, callback) {
+    const queue = lockWaiters.get(lockId) ?? [];
+    queue.push(callback);
+    lockWaiters.set(lockId, queue);
+  }
+  function removeWaiter(lockId, callback) {
+    const queue = lockWaiters.get(lockId);
+    if (queue) {
+      const index = queue.indexOf(callback);
+      if (index >= 0) queue.splice(index, 1);
+    }
+  }
+  function notifyNextWaiter(lockId) {
+    const queue = lockWaiters.get(lockId);
+    if (queue && queue.length > 0) {
+      const next = queue.shift();
+      next();
     }
+  }
+  redis.on("error", (error) => {
+    logger?.error(error);
   });
   return {
     async has(key) {
@@ -105,7 +115,7 @@ function mockRedisCacheDriver({
           let waitingForAcquire = false;
           const cleanup = () => {
             settled = true;
-            lockEmitter.off(id, onRelease);
+            removeWaiter(id, onRelease);
             clearInterval(fallbackPoll);
           };
           const timeout = setTimeout(() => {
@@ -117,7 +127,7 @@ function mockRedisCacheDriver({
             reject(new Error(`Could not acquire lock: ${name}`));
           }, seconds * 1e3);
           const onRelease = async () => {
-            if (settled) return;
+            if (settled || acquiring) return;
             acquiring = true;
             const acquired = await tryLock();
             acquiring = false;
@@ -132,7 +142,7 @@ function mockRedisCacheDriver({
               reject(new Error(`Could not acquire lock: ${name}`));
             }
           };
-          lockEmitter.on(id, onRelease);
+          addWaiter(id, onRelease);
           const fallbackPoll = setInterval(onRelease, 250);
           onRelease();
         });
@@ -149,14 +159,12 @@ function mockRedisCacheDriver({
           callId
         );
         if (released === 1) {
-          lockEmitter.emit(id);
-          await redis.publish(cacheLockChannelName, id);
+          notifyNextWaiter(id);
         }
       }
       async function forceRelease() {
         await redis.del(id);
-        lockEmitter.emit(id);
-        await redis.publish(cacheLockChannelName, id);
+        notifyNextWaiter(id);
       }
       return { get, release, forceRelease, isAvailable, block };
     }
@@ -164,11 +172,10 @@ function mockRedisCacheDriver({
 }
 
 // src/redis-cache-driver.ts
-import EventEmitter2 from "events";
+import EventEmitter from "events";
 import { randomUUID as randomUUID2 } from "crypto";
 import Redis2 from "ioredis";
 import RedisTimeout from "ioredis-timeout";
-import { Log as Log2 } from "@maestro-js/log";
 function redisCacheDriver({
   url,
   port,
@@ -177,26 +184,39 @@ function redisCacheDriver({
   keyPrefix = "",
   logger: loggerInput
 }) {
-  const logger = loggerInput ?? Log2.create();
+  const logger = loggerInput;
   const redis = new Redis2(port, url, {
     connectTimeout,
     keyPrefix
   });
-  const lockEmitter = new EventEmitter2();
+  const subscriber = new Redis2(port, url, {
+    connectTimeout,
+    keyPrefix
+  });
+  const lockEmitter = new EventEmitter();
   const channelPrefix = [keyPrefix, "maestro.events."].join("");
   const cacheLockChannelName = `${channelPrefix}cache-locks`;
   redis.on("connect", () => {
-    logger.info("connected!");
+    logger?.info("connected!");
     RedisTimeout.timeout("set", operationTimeout, redis);
     RedisTimeout.timeout("get", operationTimeout, redis);
     RedisTimeout.timeout("exists", operationTimeout, redis);
     RedisTimeout.timeout("del", operationTimeout, redis);
     RedisTimeout.timeout("publish", operationTimeout, redis);
+    RedisTimeout.timeout("eval", operationTimeout, redis);
   });
   redis.on("error", (error) => {
-    logger.error(error);
+    logger?.error(error);
+  });
+  subscriber.on("connect", () => {
+    subscriber.subscribe(cacheLockChannelName).catch((err) => {
+      logger?.error(`Failed to subscribe to ${cacheLockChannelName}: %s`, err.message);
+    });
+  });
+  subscriber.on("error", (error) => {
+    logger?.error(error);
   });
-  redis.on("message", (channel, message) => {
+  subscriber.on("message", (channel, message) => {
     if (channel === cacheLockChannelName) {
       lockEmitter.emit(message);
     }
@@ -293,7 +313,7 @@ function redisCacheDriver({
             reject(new Error(`Could not acquire lock: ${name}`));
           }, seconds * 1e3);
           const onRelease = async () => {
-            if (settled) return;
+            if (settled || acquiring) return;
             acquiring = true;
             const acquired = await tryLock();
             acquiring = false;

package/package.json

@@ -13,13 +13,16 @@
     "ioredis-timeout": "^1.5.0",
     "ioredis-mock": "^8.2.0",
     "@types/ioredis-mock": "^8.2.6",
-    "@maestro-js/log": "1.0.0-alpha.2",
-    "@maestro-js/service-registry": "1.0.0-alpha.2"
+    "@maestro-js/service-registry": "1.0.0-alpha.21"
+  },
+  "peerDependencies": {
+    "@maestro-js/log": "1.0.0-alpha.21"
   },
   "devDependencies": {
-    "@types/node": "^22.19.11"
+    "@types/node": "^22.19.11",
+    "@maestro-js/log": "1.0.0-alpha.21"
   },
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.21",
   "publishConfig": {
     "access": "restricted"
   },