@brust/cache-redis 2.0.0-alpha.4 → 2.0.0-alpha.5

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "@brust/cache-redis",
-  "version": "2.0.0-alpha.4",
+  "version": "2.0.0-alpha.5",
   "description": "brust cache adapter for Redis and Dragonfly (Bun RedisClient, no npm dependency)",
   "license": "MIT",
+  "homepage": "https://brust.dev",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/AssetsArt/brust.git"
+    "url": "git+https://github.com/AssetsArt/brust.git",
+    "directory": "packages/cache-redis"
+  },
+  "bugs": {
+    "url": "https://github.com/AssetsArt/brust/issues"
   },
   "type": "module",
   "exports": {
@@ -24,10 +29,10 @@
   },
   "dependencies": {},
   "peerDependencies": {
-    "@brust/core": "2.0.0-alpha.4"
+    "@brust/core": "2.0.0-alpha.5"
   },
   "devDependencies": {
-    "@brust/core": "2.0.0-alpha.4",
+    "@brust/core": "2.0.0-alpha.5",
     "@types/bun": "^1.4.0",
     "typescript": "^7.0.2"
   },

package/src/adapter.ts

@@ -8,10 +8,13 @@ import { parseOptions, type ResolvedOptions } from './options'
 import { type SubscriberState, startSubscriber } from './subscriber'
 
 const STAGE_TTL_MS = 30_000
+const MAX_ORPHAN_BATCHES = 64
 
 export interface RedisAdapterTest {
   /** Close the subscriber socket as a network loss would. */
   dropSubscriber(): void
+  /** Close the command socket as a network loss would (the loop reconnects). */
+  dropCommands(): void
   state(): { connected: boolean; subscribed: boolean; last: number | null; reconnects: number }
   /** The command client (raw access for tests). */
   client(): import('bun').RedisClient
@@ -30,7 +33,9 @@ export function createAdapter(name: 'redis' | 'dragonfly', raw: Record<string, u
     throw new Error('cache-redis: used before init')
   }
   const sub: SubscriberState = { link: null, subscribed: false, last: null }
-  const pairing = new Pairing(() => link().c, k, o.markerTtlMs)
+  const pairing = new Pairing(() => link().c, k, o.markerTtlMs, () => k().channel)
+  // N2: page batches whose UNLINK failed (the link dropped between the script and the delete); retried once on reconnect.
+  const orphaned: string[][] = []
 
   const store = {
     maxBodyBytes: o.maxBodyBytes,
@@ -70,16 +75,21 @@ export function createAdapter(name: 'redis' | 'dragonfly', raw: Record<string, u
       if (!members.length) return
       const c = link().c
       // UNLINK frees off the main thread (Dragonfly too); batched so one call never carries every key.
-      const jobs: Promise<number>[] = []
-      for (let i = 0; i < members.length; i += o.unlinkBatch) jobs.push(c.unlink(...members.slice(i, i + o.unlinkBatch)))
-      await Promise.all(jobs)
+      const batches: string[][] = []
+      for (let i = 0; i < members.length; i += o.unlinkBatch) batches.push(members.slice(i, i + o.unlinkBatch))
+      const done = await Promise.allSettled(batches.map((b) => c.unlink(...b)))
+      // A failed batch is kept (at most MAX_ORPHAN_BATCHES, then the page TTL is the bound) and retried once on reconnect.
+      const failed = done.flatMap((d, i) => (d.status === 'rejected' ? [i] : []))
+      for (const i of failed) if (orphaned.length < MAX_ORPHAN_BATCHES) orphaned.push(batches[i]!)
+      const first = done.find((d): d is PromiseRejectedResult => d.status === 'rejected')
+      if (first) throw first.reason
     },
   }
 
   const broadcast = {
     async publish(args: InvalidateArgs, origin: string): Promise<number> {
-      const { seq } = await pairing.run(args, 'publish')
-      await link().c.publish(k().channel, JSON.stringify({ seq, origin, args }))
+      // The event is published by the script itself (N1): a failure here means no seq was taken and no event went out.
+      const { seq } = await pairing.run(args, 'publish', origin)
       return seq
     },
     async subscribe(on: (e: InvalidationEvent) => void, onGap: () => void): Promise<() => Promise<void>> {
@@ -94,7 +104,9 @@ export function createAdapter(name: 'redis' | 'dragonfly', raw: Record<string, u
     broadcast,
     async init(ctx: CacheAdapterInit) {
       ks = makeKeys(ctx.namespace)
-      cmd = new Link(o, 'commands')
+      cmd = new Link(o, 'commands', async (cl) => {
+        for (const b of orphaned.splice(0)) await cl.unlink(...b).catch(() => 0) // once: a second failure leaves it to the TTL
+      })
       await cmd.start()
     },
     async close() {
@@ -103,6 +115,7 @@ export function createAdapter(name: 'redis' | 'dragonfly', raw: Record<string, u
     },
     __test: {
       dropSubscriber: () => sub.link?.drop(),
+      dropCommands: () => cmd?.drop(),
       state: () => ({ connected: !!cmd?.connected, subscribed: sub.subscribed, last: sub.last, reconnects: (cmd?.reconnects ?? 0) + (sub.link?.reconnects ?? 0) }),
       client: () => link().c,
       keys: () => k(),

package/src/lua.ts

@@ -20,7 +20,10 @@ for i = 1, n do
 end
 return 1`
 
-// INVAL_LUA  KEYS = [seq, idx_1..idx_n, mark_1..mark_n]  ARGV = [mode ('both'|'delete'|'publish'), n, marker_ttl_ms]
+// INVAL_LUA  KEYS = [seq, idx_1..idx_n, mark_1..mark_n]
+//            ARGV = [mode ('both'|'delete'|'publish'), n, marker_ttl_ms, channel, origin_json, args_json]
+// The `publish` and `both` modes PUBLISH {seq, origin, args} from INSIDE the script (N1): scripts run one at a time, so
+// the order of events on the channel is the order of seq, however many processes invalidate at once.
 export const INVAL_LUA = `local unpack = table.unpack or unpack  -- Lua 5.1 (Redis) and 5.4 (Dragonfly)
 local mode = ARGV[1]; local n = tonumber(ARGV[2]); local mttl = tonumber(ARGV[3])
 local v
@@ -35,6 +38,9 @@ if mode ~= 'publish' and n > 0 then
   for _, m in ipairs(redis.call('SUNION', unpack(idx))) do out[#out + 1] = m end
   redis.call('DEL', unpack(idx))
 end
+if mode ~= 'delete' then
+  redis.call('PUBLISH', ARGV[4], '{"seq":' .. string.format('%d', v) .. ',"origin":' .. ARGV[5] .. ',"args":' .. ARGV[6] .. '}')
+end
 return out`
 
 const sha1 = (s: string) => new Bun.CryptoHasher('sha1').update(s).digest('hex')

package/src/pairing.ts

@@ -1,7 +1,8 @@
 // Pairs the two halves of one invalidation (cache-redis R4). lane A issues `store.invalidate` and
 // `broadcast.publish` for the same args; when both arrive in the same tick ONE INVAL_LUA run does
 // INCR + markers + SUNION/DEL atomically (mode `both`). Otherwise each half runs alone: `delete`
-// (markers at seq+1, seq untouched, so it never jumps without an event) or `publish` (INCR + markers).
+// (markers at seq+1, seq untouched, so it never jumps without an event) or `publish` (INCR + markers). The two
+// modes that publish do it inside the script, so the event order is the seq order (N1).
 import type { RedisClient } from 'bun'
 import type { InvalidateArgs } from '@brust/core/cache-adapter'
 import { canonical, hasStoreWork, type Keys } from './keys'
@@ -15,6 +16,8 @@ export interface InvalResult {
 
 interface Entry {
   sides: Set<Side>
+  /** The publishing side's origin (set by `run(…, 'publish', origin)`; read when the entry executes). */
+  origin?: string
   promise: Promise<InvalResult>
 }
 
@@ -25,9 +28,10 @@ export class Pairing {
     private readonly c: () => RedisClient,
     private readonly keys: () => Keys,
     private readonly markerTtlMs: number,
+    private readonly channel: () => string,
   ) {}
 
-  run(args: InvalidateArgs, side: Side): Promise<InvalResult> {
+  run(args: InvalidateArgs, side: Side, origin?: string): Promise<InvalResult> {
     if (side === 'invalidate' && !hasStoreWork(args)) return Promise.resolve({ seq: 0, members: [] })
     const id = canonical(args)
     const list = this.pending.get(id) ?? []
@@ -35,9 +39,10 @@ export class Pairing {
     const open = list.find((e) => !e.sides.has(side))
     if (open) {
       open.sides.add(side)
+      if (origin !== undefined) open.origin = origin
       return open.promise
     }
-    const entry: Entry = { sides: new Set([side]), promise: undefined as never }
+    const entry: Entry = { sides: new Set([side]), ...(origin !== undefined && { origin }), promise: undefined as never }
     entry.promise = new Promise<InvalResult>((resolve, reject) => {
       queueMicrotask(() => {
         const l = this.pending.get(id)
@@ -46,7 +51,7 @@ export class Pairing {
           if (!l.length) this.pending.delete(id)
         }
         const mode = entry.sides.size === 2 ? 'both' : side === 'invalidate' ? 'delete' : 'publish'
-        this.exec(args, mode).then(resolve, reject)
+        this.exec(args, mode, entry.origin ?? '').then(resolve, reject)
       })
     })
     list.push(entry)
@@ -54,7 +59,7 @@ export class Pairing {
     return entry.promise
   }
 
-  private async exec(args: InvalidateArgs, mode: 'both' | 'delete' | 'publish'): Promise<InvalResult> {
+  private async exec(args: InvalidateArgs, mode: 'both' | 'delete' | 'publish', origin: string): Promise<InvalResult> {
     const K = this.keys()
     const method = args.method
     const tags = [...new Set(args.tags ?? [])]
@@ -69,7 +74,7 @@ export class Pairing {
       idx.push(K.path(method, args.path))
       marks.push(K.markPath(method, args.path))
     }
-    const r = (await evalsha(this.c(), INVAL_SCRIPT, [K.seq, ...idx, ...marks], [mode, idx.length, this.markerTtlMs])) as (number | string)[]
+    const r = (await evalsha(this.c(), INVAL_SCRIPT, [K.seq, ...idx, ...marks], [mode, idx.length, this.markerTtlMs, this.channel(), JSON.stringify(origin), JSON.stringify(args)])) as (number | string)[]
     return { seq: Number(r[0]), members: r.slice(1).map(String) }
   }
 }