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

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 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 */
@@ -60,9 +62,6 @@ 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.
  */
@@ -164,7 +163,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 = CacheDurationString;
+    type DurationString = DurationString;
     /** 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,37 +3,27 @@ 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;
+  const logger = loggerInput ?? Log.create();
   const redis = new MockRedis();
-  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();
-    }
-  }
+  const lockEmitter = new EventEmitter();
+  const channelPrefix = [keyPrefix, "maestro.events."].join("");
+  const cacheLockChannelName = `${channelPrefix}cache-locks`;
   redis.on("error", (error) => {
-    logger?.error(error);
+    logger.error(error);
+  });
+  redis.on("message", (channel, message) => {
+    if (channel === cacheLockChannelName) {
+      lockEmitter.emit(message);
+    }
   });
   return {
     async has(key) {
@@ -115,7 +105,7 @@ function mockRedisCacheDriver({
           let waitingForAcquire = false;
           const cleanup = () => {
             settled = true;
-            removeWaiter(id, onRelease);
+            lockEmitter.off(id, onRelease);
             clearInterval(fallbackPoll);
           };
           const timeout = setTimeout(() => {
@@ -127,7 +117,7 @@ function mockRedisCacheDriver({
             reject(new Error(`Could not acquire lock: ${name}`));
           }, seconds * 1e3);
           const onRelease = async () => {
-            if (settled || acquiring) return;
+            if (settled) return;
             acquiring = true;
             const acquired = await tryLock();
             acquiring = false;
@@ -142,7 +132,7 @@ function mockRedisCacheDriver({
               reject(new Error(`Could not acquire lock: ${name}`));
             }
           };
-          addWaiter(id, onRelease);
+          lockEmitter.on(id, onRelease);
           const fallbackPoll = setInterval(onRelease, 250);
           onRelease();
         });
@@ -159,12 +149,14 @@ function mockRedisCacheDriver({
           callId
         );
         if (released === 1) {
-          notifyNextWaiter(id);
+          lockEmitter.emit(id);
+          await redis.publish(cacheLockChannelName, id);
         }
       }
       async function forceRelease() {
         await redis.del(id);
-        notifyNextWaiter(id);
+        lockEmitter.emit(id);
+        await redis.publish(cacheLockChannelName, id);
       }
       return { get, release, forceRelease, isAvailable, block };
     }
@@ -172,10 +164,11 @@ function mockRedisCacheDriver({
 }
 
 // src/redis-cache-driver.ts
-import EventEmitter from "events";
+import EventEmitter2 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,
@@ -184,39 +177,26 @@ function redisCacheDriver({
   keyPrefix = "",
   logger: loggerInput
 }) {
-  const logger = loggerInput;
+  const logger = loggerInput ?? Log2.create();
   const redis = new Redis2(port, url, {
     connectTimeout,
     keyPrefix
   });
-  const subscriber = new Redis2(port, url, {
-    connectTimeout,
-    keyPrefix
-  });
-  const lockEmitter = new EventEmitter();
+  const lockEmitter = new EventEmitter2();
   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);
-  });
-  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);
+    logger.error(error);
   });
-  subscriber.on("message", (channel, message) => {
+  redis.on("message", (channel, message) => {
     if (channel === cacheLockChannelName) {
       lockEmitter.emit(message);
     }
@@ -313,7 +293,7 @@ function redisCacheDriver({
             reject(new Error(`Could not acquire lock: ${name}`));
           }, seconds * 1e3);
           const onRelease = async () => {
-            if (settled || acquiring) return;
+            if (settled) return;
             acquiring = true;
             const acquired = await tryLock();
             acquiring = false;

package/package.json

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