experimental-a2 0.9.0 → 0.11.0

package/src/store-redis-core.ts

@@ -44,23 +44,15 @@ export type RedisStoreCoreOptions = {
   clock: Clock
   ids: IdSource
   keyPrefix: string
-  /**
-   * Disposable wake-up fired after a write appends new events to a
-   * watched session — `count` is the session's new event count. The
-   * watched check runs inside the write script, so unwatched sessions
-   * cost no wake-up command at all. Losing one is harmless: live
-   * feeds re-read on a safety cadence, so notifications only affect
-   * latency, never delivery.
-   */
-  notify?: (sessionId: string, count: number) => void
+  presenceSource: string
 }
 
 export type RedisStoreCore = Omit<A2Store, 'stream' | 'presence'> & {
   /**
    * The storage half of the presence capability, shared by both
-   * transports. `set` returns the applied patch — null when every
-   * field lost the LWW race — so a push-capable transport broadcasts
-   * exactly what `read` now reflects; delivery is its business.
+   * transports. `set` returns the applied patch for local loopback,
+   * or null when every field lost the LWW race. The script publishes
+   * the applied fields for remote subscribers.
    */
   presence: {
     set(
@@ -77,7 +69,7 @@ export type RedisStoreCore = Omit<A2Store, 'stream' | 'presence'> & {
     afterIndex: number,
     throughIndex?: number,
   ): Promise<StoredEvent[]>
-  /** XRANGE only — the light catch-up read live feeds use. */
+  /** One bounded XRANGE page of public events for live feeds. */
   readEvents(sessionId: string, afterIndex: number): Promise<Event[]>
   /**
    * Declare the session watched for `ttlMs` — writes publish wake-ups
@@ -96,8 +88,8 @@ const READ_PAGE_SIZE = 256
  * KEYS: store stream, counter, global id hash, metadata, pending, ready,
  * watched.
  * ARGV: sessionId, nowMs, n, then per event:
- * id, type, payloadJson, causeJson, lane, settled.
- * Returns ['empty', hasPending] | ['ok', firstIndex, hasPending, watched] |
+ * id, type, payloadJson, causeJson, lane, settled; finally notify channel.
+ * Returns ['empty', hasPending] | ['ok', firstIndex, hasPending] |
  * ['dup', hasPending, ...indexes] | ['partial', count] |
  * ['foreign', eventId] | ['no_parent', idx] | ['superseded', idx].
  */
@@ -178,8 +170,10 @@ for i = 1, n do
 end
 redis.call('SET', KEYS[2], tostring(base + n))
 has_pending = redis.call('ZCARD', KEYS[5]) > 0 and '1' or '0'
-return { 'ok', tostring(base + 1), has_pending,
-  tostring(redis.call('EXISTS', KEYS[7])) }
+if redis.call('EXISTS', KEYS[7]) == 1 then
+  redis.pcall('PUBLISH', ARGV[4 + n * 6], tostring(base + n))
+end
+return { 'ok', tostring(base + 1), has_pending }
 `
 
 /**
@@ -350,7 +344,7 @@ return result
  * KEYS: store, counter, ids, meta, pending, ready, watched,
  * event snapshot pins, snapshot pin counts.
  * ARGV: sessionId, nowMs, parent index, attempt, n, then per child:
- * id, type, payloadJson, lane, settled.
+ * id, type, payloadJson, lane, settled; finally notify channel.
  */
 const COMPLETE_ATTEMPT_LUA = `
 local function release_snapshot_pins()
@@ -485,8 +479,10 @@ for i = 1, n do
   end
 end
 redis.call('SET', KEYS[2], tostring(total + n))
-return { 'ok', tostring(total + 1),
-  tostring(redis.call('EXISTS', KEYS[7])) }
+if n > 0 and redis.call('EXISTS', KEYS[7]) == 1 then
+  redis.pcall('PUBLISH', ARGV[6 + n * 5], tostring(total + n))
+end
+return { 'ok', tostring(total + 1) }
 `
 
 /**
@@ -549,7 +545,9 @@ return 1
 
 /**
  * KEYS: presence hash. ARGV: atMs, ttlMs, n, then per entry:
- * hashField, valueJson ('' deletes). Field-wise LWW by the sender's
+ * hashField, valueJson ('' deletes), patchFieldJson; finally channel and
+ * message prefix. Wire fragments stay JSON text to preserve arrays
+ * and numeric precision through Lua. Field-wise LWW by the sender's
  * `at`: a stored entry with a strictly newer stamp survives; ties go
  * to the incoming write (memory-tier parity). Returns the applied
  * 1-based entry positions. The whole-key PEXPIRE is the coarse bound,
@@ -561,9 +559,11 @@ return 1
 const PRESENCE_SET_LUA = `
 local at = tonumber(ARGV[1])
 local applied = {}
-for i = 1, tonumber(ARGV[3]) do
-  local field = ARGV[3 + (i - 1) * 2 + 1]
-  local value = ARGV[3 + (i - 1) * 2 + 2]
+local published = {}
+local n = tonumber(ARGV[3])
+for i = 1, n do
+  local field = ARGV[3 + (i - 1) * 3 + 1]
+  local value = ARGV[3 + (i - 1) * 3 + 2]
   local existing = redis.call('HGET', KEYS[1], field)
   if not existing or tonumber(cjson.decode(existing)['a']) <= at then
     if value == '' then
@@ -572,9 +572,13 @@ for i = 1, tonumber(ARGV[3]) do
       redis.call('HSET', KEYS[1], field, value)
     end
     applied[#applied + 1] = tostring(i)
+    published[#published + 1] = ARGV[3 + (i - 1) * 3 + 3]
   end
 end
-if #applied > 0 then redis.call('PEXPIRE', KEYS[1], ARGV[2]) end
+if #applied > 0 then
+  redis.call('PEXPIRE', KEYS[1], ARGV[2])
+  redis.pcall('PUBLISH', ARGV[4 + n * 3], ARGV[5 + n * 3] .. table.concat(published, ',') .. '}}')
+end
 return applied
 `
 
@@ -766,7 +770,7 @@ const wrap = async <T>(fn: () => Promise<T>): Promise<T> => {
 export function createRedisStoreCore(
   options: RedisStoreCoreOptions,
 ): RedisStoreCore {
-  const { call, clock, notify } = options
+  const { call, clock } = options
   const generateId = options.ids
   const prefix = options.keyPrefix
 
@@ -1004,6 +1008,7 @@ export function createRedisStoreCore(
             e.lane ?? '',
             e.settled ? '1' : '0',
           ]),
+          `${prefix}:${sessionId}:notify`,
         ]
         const reply = (await evalScript(
           APPEND_LUA,
@@ -1060,7 +1065,6 @@ export function createRedisStoreCore(
           }
         }
         const base = Number(reply[1]) - 1
-        if (reply[3] === '1') notify?.(sessionId, base + withIds.length)
         return {
           events: withIds.map((e, i) => ({
             id: e.id,
@@ -1187,6 +1191,7 @@ export function createRedisStoreCore(
               event.lane ?? '',
               event.settled === true ? '1' : '0',
             ]),
+            `${prefix}:${sessionId}:notify`,
           ],
         )) as string[]
         const outcome = reply[0]
@@ -1206,9 +1211,6 @@ export function createRedisStoreCore(
         const cause = { index, attempt }
         if (outcome === 'ok') {
           const base = Number(reply[1]) - 1
-          if (events.length > 0 && reply[2] === '1') {
-            notify?.(sessionId, base + events.length)
-          }
           return {
             outcome: 'completed',
             events: events.map((event, i) => ({
@@ -1428,7 +1430,10 @@ export function createRedisStoreCore(
                       a: atMs,
                       e: expiresAtMs,
                     }),
+                `${json(field)}:${json(value)}`,
               ]),
+              presenceKey(ns),
+              `${json({ src: options.presenceSource, participant, seen: meta.seen, at: atMs }).slice(0, -1)},"values":{`,
             ],
           )) as string[]
           if (applied.length === 0) return null
@@ -1492,6 +1497,8 @@ export function createRedisStoreCore(
           storeKey(sessionId),
           `${afterIndex + 1}-0`,
           '+',
+          'COUNT',
+          READ_PAGE_SIZE,
         )) as StreamEntry[]
         return entries.map((entry) => toEvent(sessionId, entry))
       })

package/src/store-redis-http.ts

@@ -1,21 +1,10 @@
-/**
- * experimental-a2/store-redis-http — the same Redis Streams store over a
- * provider REST API (Upstash-shaped: POST one command as a JSON array,
- * receive `{ result }` or `{ error }`). The storage semantics live in
- * store-redis-core.ts, shared with experimental-a2/store-redis.
- *
- * Fully connectionless: every command is one `fetch`, so it works
- * where a Redis-protocol connection cannot exist or cannot be spared.
- * Without a connection there is no push and no pub/sub, so `stream()`
- * is the shared activity-adaptive poll loop (25ms while events flow,
- * backing off to a 250ms idle ceiling), and presence is the degraded
- * tier: `set`/`read` from the shared core, no `subscribe`. No peer
- * dependencies.
- */
-
 import { A2Error } from './errors.ts'
-import { pollingStream } from './store-polling.ts'
-import { createRedisStoreCore } from './store-redis-core.ts'
+import { NOTIFY_TIMINGS } from './internal.ts'
+import { redisHttpSubscriptions } from './redis-http-subscriptions.ts'
+import {
+  createRedisNotifyStore,
+  type RedisConnection,
+} from './store-redis-notify.ts'
 import {
   RANDOM_IDS,
   SYSTEM_CLOCK,
@@ -38,7 +27,7 @@ export type RedisHttpStoreOptions = {
 }
 
 export type RedisHttpStore = A2Store & {
-  /** Nothing to disconnect; present so callers can treat stores uniformly. */
+  /** Close live subscriptions and pending reconnects. */
   close(): Promise<void>
 }
 
@@ -47,6 +36,8 @@ export function redisHttp(options: RedisHttpStoreOptions): RedisHttpStore {
     throw new TypeError('redisHttp() needs a url and a token')
   }
   const { url, token } = options
+  let polling = false
+  let fallbackCheck: Promise<void> | undefined
 
   const call = async (
     command: string,
@@ -61,6 +52,9 @@ export function redisHttp(options: RedisHttpStoreOptions): RedisHttpStore {
           'content-type': 'application/json',
         },
         body: JSON.stringify([command, ...args.map(String)]),
+        ...(command === 'PING'
+          ? { signal: AbortSignal.timeout(NOTIFY_TIMINGS.safetyReadMs) }
+          : {}),
       })
     } catch (err) {
       throw new A2Error('STORE_UNAVAILABLE', 'redis rest request failed', {
@@ -80,36 +74,48 @@ export function redisHttp(options: RedisHttpStoreOptions): RedisHttpStore {
     return body.result
   }
 
-  const core = createRedisStoreCore({
+  let subscriber: RedisConnection | undefined
+  let onReconnect: ((channel: string) => void) | undefined
+  const client: RedisConnection = {
     call,
+    duplicate: () =>
+      (subscriber ??= redisHttpSubscriptions({
+        url,
+        token,
+        onReconnect: (channel) => onReconnect?.(channel),
+        fallback: {
+          enabled: () => polling,
+          enable() {
+            fallbackCheck ??= call('PING')
+              .then((result) => {
+                if (result !== 'PONG')
+                  throw new A2Error(
+                    'STORE_UNAVAILABLE',
+                    'redis rest capability check failed',
+                  )
+                polling = true
+                return undefined
+              })
+              .catch((error: unknown) => {
+                fallbackCheck = undefined
+                throw error
+              })
+            return fallbackCheck
+          },
+        },
+      })),
+    on() {},
+    disconnect: () => subscriber?.disconnect(),
+  }
+  return createRedisNotifyStore({
+    client: () => Promise.resolve(client),
+    closeClient: async () => client.disconnect(),
+    polling: () => polling,
+    onReconnect: (listener) => {
+      onReconnect = listener
+    },
     clock: options.clock ?? SYSTEM_CLOCK,
     ids: options.ids ?? RANDOM_IDS,
     keyPrefix: options.keyPrefix ?? 'a2',
   })
-
-  return {
-    append: core.append,
-    read: core.read,
-    claimAvailable: core.claimAvailable,
-    renewClaims: core.renewClaims,
-    completeAttempt: core.completeAttempt,
-    failAttempt: core.failAttempt,
-    readState: core.readState,
-    putSnapshots: core.putSnapshots,
-    presence: {
-      async set(ns, participant, values, meta) {
-        await core.presence.set(ns, participant, values, meta)
-      },
-      read: core.presence.read,
-    },
-
-    stream(sessionId, opts) {
-      return pollingStream(
-        (afterIndex) => core.readRange(sessionId, afterIndex),
-        opts?.startAfter !== undefined ? { startAfter: opts.startAfter } : {},
-      )
-    },
-
-    async close() {},
-  }
 }