@blamejs/core 0.6.13 → 0.6.21

package/lib/cache.js

@@ -74,11 +74,6 @@
  *
  * What is NOT in the box:
  *
- *   - Tag invalidation on the cluster backend — invalidating tagged
- *     entries across cluster nodes ties to a future distributed-pubsub
- *     slice. invalidateTag against a cluster-backend cache throws
- *     NOT_SUPPORTED today; operators wanting cluster-scope tag wipe
- *     run their own DELETE against _blamejs_cache.
  *   - maxBytes on the cluster backend — per-row size accounting against
  *     a shared table would mean an aggregate query on every set. The
  *     operator controls cluster-table size with their own pruning if
@@ -509,28 +504,98 @@ function _clusterBackend(cfg) {
     catch (_e) { return undefined; }
   }
 
-  async function set(key, value, expiresAt) {
+  async function set(key, value, expiresAt, meta) {
     var json = JSON.stringify(value);
     var storedExpires = (expiresAt === Infinity) ? Number.MAX_SAFE_INTEGER : expiresAt;
     var now = clock();
+    var ck = _composedKey(key);
     // SQLite + Postgres both honor ON CONFLICT (cacheKey) DO UPDATE.
     await clusterStorage.execute(
       "INSERT INTO _blamejs_cache (cacheKey, valueJson, expiresAt, updatedAt) " +
       "VALUES (?, ?, ?, ?) " +
       "ON CONFLICT (cacheKey) DO UPDATE SET " +
       "valueJson = ?, expiresAt = ?, updatedAt = ?",
-      [_composedKey(key), json, storedExpires, now, json, storedExpires, now]
+      [ck, json, storedExpires, now, json, storedExpires, now]
+    );
+    // Tag handling: drop any prior tags for this key (tags can change
+    // across sets), then INSERT the new ones. The PRIMARY KEY on
+    // (cacheKey, tag) makes the INSERT idempotent if duplicate tags
+    // sneak in.
+    var tags = meta && Array.isArray(meta.tags) ? meta.tags : null;
+    await clusterStorage.execute(
+      "DELETE FROM _blamejs_cache_tags WHERE cacheKey = ?",
+      [ck]
     );
+    if (tags && tags.length > 0) {
+      for (var i = 0; i < tags.length; i++) {
+        await clusterStorage.execute(
+          "INSERT INTO _blamejs_cache_tags (cacheKey, tag) VALUES (?, ?) " +
+          "ON CONFLICT (cacheKey, tag) DO NOTHING",
+          [ck, tags[i]]
+        );
+      }
+    }
   }
 
   async function del(key) {
+    var ck = _composedKey(key);
     var result = await clusterStorage.execute(
       "DELETE FROM _blamejs_cache WHERE cacheKey = ?",
-      [_composedKey(key)]
+      [ck]
     );
+    // Drop any matching tag rows. Best-effort: a stale tag row pointing
+    // at a non-existent cacheKey is dropped on the next invalidateTag
+    // sweep (by the JOIN-shape DELETE) anyway.
+    await clusterStorage.execute(
+      "DELETE FROM _blamejs_cache_tags WHERE cacheKey = ?",
+      [ck]
+    ).catch(function () { /* best-effort */ });
     return !!(result && result.rowCount && result.rowCount > 0);
   }
 
+  async function invalidateTag(tag) {
+    // Find every cacheKey carrying the tag (namespace-scoped via the LIKE
+    // on the composed key), delete from the cache table + the junction.
+    var like = namespace + ":%";
+    var keysResult = await clusterStorage.execute(
+      "SELECT cacheKey FROM _blamejs_cache_tags WHERE tag = ? AND cacheKey LIKE ?",
+      [tag, like]
+    );
+    var keys = (keysResult && keysResult.rows) || [];
+    if (keys.length === 0) {
+      // Nothing to invalidate; still drop any orphan tag rows for
+      // this tag scoped to our namespace.
+      await clusterStorage.execute(
+        "DELETE FROM _blamejs_cache_tags WHERE tag = ? AND cacheKey LIKE ?",
+        [tag, like]
+      );
+      return 0;
+    }
+    var purged = 0;
+    for (var i = 0; i < keys.length; i++) {
+      var ck = keys[i].cacheKey;
+      var r = await clusterStorage.execute(
+        "DELETE FROM _blamejs_cache WHERE cacheKey = ?",
+        [ck]
+      );
+      if (r && r.rowCount > 0) purged += r.rowCount;
+      await clusterStorage.execute(
+        "DELETE FROM _blamejs_cache_tags WHERE cacheKey = ?",
+        [ck]
+      );
+    }
+    return purged;
+  }
+
+  async function getTags(key) {
+    var result = await clusterStorage.execute(
+      "SELECT tag FROM _blamejs_cache_tags WHERE cacheKey = ?",
+      [_composedKey(key)]
+    );
+    if (!result || !result.rows) return [];
+    return result.rows.map(function (r) { return r.tag; });
+  }
+
   async function has(key) {
     // Existence check without recency bump — cluster backend doesn't
     // track LRU at all, so "without bumping" is automatic. Honors
@@ -551,6 +616,11 @@ function _clusterBackend(cfg) {
       "DELETE FROM _blamejs_cache WHERE cacheKey LIKE ?",
       [like]
     );
+    // Drop matching tag rows in the same namespace.
+    await clusterStorage.execute(
+      "DELETE FROM _blamejs_cache_tags WHERE cacheKey LIKE ?",
+      [like]
+    ).catch(function () { /* best-effort */ });
     return (result && result.rowCount) || 0;
   }
 
@@ -568,10 +638,24 @@ function _clusterBackend(cfg) {
   async function _sweep() {
     var now = clock();
     var like = namespace + ":%";
+    // Capture the to-be-purged keys first so we can drop matching tag
+    // rows in the same sweep — keeps the junction table free of orphans
+    // pointing at expired cacheKeys.
+    var expiredResult = await clusterStorage.execute(
+      "SELECT cacheKey FROM _blamejs_cache WHERE cacheKey LIKE ? AND expiresAt <= ?",
+      [like, now]
+    );
+    var expiredKeys = (expiredResult && expiredResult.rows) || [];
     await clusterStorage.execute(
       "DELETE FROM _blamejs_cache WHERE cacheKey LIKE ? AND expiresAt <= ?",
       [like, now]
     );
+    for (var i = 0; i < expiredKeys.length; i++) {
+      await clusterStorage.execute(
+        "DELETE FROM _blamejs_cache_tags WHERE cacheKey = ?",
+        [expiredKeys[i].cacheKey]
+      ).catch(function () { /* best-effort */ });
+    }
   }
 
   function _startSweep(intervalMs) {
@@ -583,15 +667,17 @@ function _clusterBackend(cfg) {
   }
 
   return {
-    name:         "cluster",
-    get:          get,
-    set:          set,
-    del:          del,
-    has:          has,
-    clear:        clear,
-    size:         size,
-    close:        close,
-    _startSweep:  _startSweep,
+    name:           "cluster",
+    get:            get,
+    set:            set,
+    del:            del,
+    has:            has,
+    clear:          clear,
+    size:           size,
+    close:          close,
+    invalidateTag:  invalidateTag,
+    getTags:        getTags,
+    _startSweep:    _startSweep,
   };
 }
 
@@ -865,9 +951,8 @@ function create(opts) {
     if (typeof backend.invalidateTag !== "function") {
       throw _err("NOT_SUPPORTED",
         "cache.invalidateTag: backend '" + (backend.name || "custom") +
-        "' does not support tag invalidation. Tags are memory-backend only " +
-        "in this release; the cluster backend gains tag support alongside " +
-        "the distributed-invalidation slice.");
+        "' does not implement invalidateTag. Operator-supplied custom backends " +
+        "must export invalidateTag(tag) → number to participate in tag-based wipes.");
     }
     var purged;
     try { purged = await backend.invalidateTag(tag); }