@tachybase/cache 1.6.9-alpha.2 → 1.6.10-alpha.1

package/lib/cache.d.ts

@@ -3,12 +3,22 @@ export declare class Cache {
     name: string;
     prefix?: string;
     store: BasicCache;
+    /**
+     * Per prefixed key: serializes memory `store.set` / `store.get`+`store.set` so `set` and
+     * `setIfNotExists` cannot interleave for the same key (single-process).
+     */
+    private memoryWriteQueues;
     constructor({ name, prefix, store }: {
         name: string;
         store: BasicCache;
         prefix?: string;
     });
     key(key: string): string;
+    /**
+     * For memory store, waits on the same per-key queue as `setIfNotExists` so another writer
+     * cannot run `this.store.set` between that method's `get` and `set`.
+     */
+    private runWithMemoryWriteLock;
     set(key: string, value: unknown, ttl?: Milliseconds): Promise<void>;
     get<T>(key: string): Promise<T>;
     del(key: string): Promise<void>;
@@ -27,4 +37,14 @@ export declare class Cache {
     setValueInObject(key: string, objectKey: string, value: unknown): Promise<void>;
     getValueInObject(key: string, objectKey: string): Promise<any>;
     delValueInObject(key: string, objectKey: string): Promise<void>;
+    /**
+     * Atomically set `key` to `value` with expiry `ttl` (ms) only if `key` is absent.
+     * Returns `true` if the key was set, `false` if it already existed.
+     *
+     * - **Redis**: `SET` with `NX` and `PX` (safe across processes/instances).
+     * - **Memory**: `this.store.get` / `this.store.set` run under the same per-key `memoryWriteQueues`
+     *   lock as `set`, so another `cache.set` cannot interleave between get and set (single-process;
+     *   multi-instance locks still require Redis).
+     */
+    setIfNotExists(key: string, value: unknown, ttl: number): Promise<boolean>;
 }

package/lib/cache.js

@@ -21,8 +21,37 @@ __export(cache_exports, {
   Cache: () => Cache
 });
 module.exports = __toCommonJS(cache_exports);
+var import_cache_manager_redis_yet = require("cache-manager-redis-yet");
+function serializeRedisValue(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    if (serialized === void 0) {
+      throw new import_cache_manager_redis_yet.NoCacheableError(`"${String(value)}" is not a cacheable value`);
+    }
+    return serialized;
+  } catch (e) {
+    if (e instanceof import_cache_manager_redis_yet.NoCacheableError) {
+      throw e;
+    }
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new import_cache_manager_redis_yet.NoCacheableError(`"${String(value)}" is not a cacheable value: ${msg}`);
+  }
+}
+__name(serializeRedisValue, "serializeRedisValue");
+function isRedisLikeStore(store) {
+  var _a;
+  if (!store || typeof store !== "object") return false;
+  const s = store;
+  return typeof ((_a = s.client) == null ? void 0 : _a.set) === "function";
+}
+__name(isRedisLikeStore, "isRedisLikeStore");
 const _Cache = class _Cache {
   constructor({ name, prefix, store }) {
+    /**
+     * Per prefixed key: serializes memory `store.set` / `store.get`+`store.set` so `set` and
+     * `setIfNotExists` cannot interleave for the same key (single-process).
+     */
+    this.memoryWriteQueues = /* @__PURE__ */ new Map();
     this.name = name;
     this.prefix = prefix;
     this.store = store;
@@ -30,8 +59,38 @@ const _Cache = class _Cache {
   key(key) {
     return this.prefix ? `${this.prefix}:${key}` : key;
   }
+  /**
+   * For memory store, waits on the same per-key queue as `setIfNotExists` so another writer
+   * cannot run `this.store.set` between that method's `get` and `set`.
+   */
+  async runWithMemoryWriteLock(k, fn) {
+    const previous = this.memoryWriteQueues.get(k) ?? Promise.resolve();
+    let release;
+    const next = new Promise((res) => {
+      release = res;
+    });
+    const current = previous.then(() => next);
+    this.memoryWriteQueues.set(k, current);
+    await previous;
+    try {
+      return await fn();
+    } finally {
+      release();
+      if (this.memoryWriteQueues.get(k) === current) {
+        this.memoryWriteQueues.delete(k);
+      }
+    }
+  }
   async set(key, value, ttl) {
-    await this.store.set(this.key(key), value, ttl);
+    const k = this.key(key);
+    const raw = this.store.store;
+    if (isRedisLikeStore(raw)) {
+      await this.store.set(k, value, ttl);
+      return;
+    }
+    await this.runWithMemoryWriteLock(k, async () => {
+      await this.store.set(k, value, ttl);
+    });
   }
   async get(key) {
     return await this.store.get(this.key(key));
@@ -97,6 +156,36 @@ const _Cache = class _Cache {
     delete object[objectKey];
     await this.set(key, object);
   }
+  /**
+   * Atomically set `key` to `value` with expiry `ttl` (ms) only if `key` is absent.
+   * Returns `true` if the key was set, `false` if it already existed.
+   *
+   * - **Redis**: `SET` with `NX` and `PX` (safe across processes/instances).
+   * - **Memory**: `this.store.get` / `this.store.set` run under the same per-key `memoryWriteQueues`
+   *   lock as `set`, so another `cache.set` cannot interleave between get and set (single-process;
+   *   multi-instance locks still require Redis).
+   */
+  async setIfNotExists(key, value, ttl) {
+    if (value === void 0 || value === null) {
+      throw new import_cache_manager_redis_yet.NoCacheableError(`"${value}" is not a cacheable value`);
+    }
+    const k = this.key(key);
+    const raw = this.store.store;
+    if (isRedisLikeStore(raw)) {
+      const payload = serializeRedisValue(value);
+      const opts = ttl !== void 0 && ttl !== 0 ? { NX: true, PX: ttl } : { NX: true };
+      const reply = await raw.client.set(k, payload, opts);
+      return reply === "OK";
+    }
+    return this.runWithMemoryWriteLock(k, async () => {
+      const existing = await this.store.get(k);
+      if (existing !== void 0) {
+        return false;
+      }
+      await this.store.set(k, value, ttl);
+      return true;
+    });
+  }
 };
 __name(_Cache, "Cache");
 let Cache = _Cache;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tachybase/cache",
-  "version": "1.6.9-alpha.2",
+  "version": "1.6.10-alpha.1",
   "description": "",
   "homepage": "https://github.com/tegojs/tego#readme",
   "bugs": {