experimental-a2 0.22.0 → 0.24.0

package/src/store-postgres.ts

@@ -29,7 +29,12 @@
  * for the session lock holds, or one a clear left behind.
  */
 
-import { A2Error, supersededAttemptError } from './errors.ts'
+import {
+  A2Error,
+  duplicateBatchError,
+  lastIndexMismatchError,
+  supersededAttemptError,
+} from './errors.ts'
 import { idempotentReplay } from './idempotent-replay.ts'
 import { CLEAR_EVENT_TYPE, sessionClearedError } from './session-clear.ts'
 import {
@@ -574,7 +579,8 @@ const INSERTED_AFTER = `(
  * every event's id belongs to this session already, the batch is a retry: it
  * stops with the committed rows. Some owned aborts, as does scheduled work
  * from at or below the clear marker (`origin`). Rows below the marker own no
- * id.
+ * id. Both id outcomes carry the head, which a conditional append's conflict
+ * reports when it moved.
  */
 const APPEND_CHECKS = `
   with boundary as materialized (
@@ -592,12 +598,12 @@ const APPEND_CHECKS = `
   )
   select case
     when (select count(*) from owned) = ${param.bigint('count')} then
-      jsonb_build_object('stop', 'replay',
+      jsonb_build_object('stop', 'replay', 'head', boundary.base,
         'has_pending', boundary.has_pending,
         'events', (select jsonb_agg(to_jsonb(owned) order by owned.idx)
                      from owned))
     when exists (select 1 from owned) then
-      jsonb_build_object('abort', 'mixed', 'owned',
+      jsonb_build_object('abort', 'mixed', 'head', boundary.base, 'owned',
         (select count(*) from owned))
     when ${param.bigint('origin')} <= boundary.clear_index then
       jsonb_build_object('abort', 'cleared')
@@ -630,6 +636,16 @@ const FENCE = `
     from cause where cause.ord not in (select ord from held)
    order by cause.ord limit 1`
 
+/**
+ * A conditional append's head check, under the session lock and after the
+ * fences: it aborts with the head unless the head is `ifLastIndex`.
+ */
+const IF_LAST_INDEX = `
+  select jsonb_build_object('abort', 'moved', 'index', head.idx)
+    from (select coalesce(max(idx), 0) as idx from a2_events
+           where session_id = ${SESSION}) head
+   where head.idx <> ${param.bigint('ifLastIndex')}`
+
 /**
  * Frees the `ids` this session's rows below its clear marker hold, so the
  * batch can take them. It never waits on a row: a reclaim deleting one may
@@ -1811,6 +1827,11 @@ export function postgres(options: PostgresStoreOptions = {}): PostgresStore {
         ]
         const work = enqueue(events, consumers)
         const originIndex = appendOptions?.originIndex
+        const ifLastIndex = appendOptions?.ifLastIndex
+        const conditionalAt = (head: unknown) =>
+          ifLastIndex === undefined
+            ? undefined
+            : { sessionId, ifLastIndex, head: asNumber(head) }
         // One round trip, holding the session lock only while the server
         // runs it: index assignment must not race across writers.
         const results = await run({
@@ -1819,6 +1840,7 @@ export function postgres(options: PostgresStoreOptions = {}): PostgresStore {
             LOCK_SESSION,
             APPEND_CHECKS,
             causes.length > 0 && FENCE,
+            ifLastIndex !== undefined && IF_LAST_INDEX,
             suppliedIds.length > 0 && REUSE_IDS,
             INSERT_EVENTS,
             ...work.statements,
@@ -1829,6 +1851,7 @@ export function postgres(options: PostgresStoreOptions = {}): PostgresStore {
             ids: suppliedIds,
             count: events.length,
             origin: originIndex ?? null,
+            ifLastIndex: ifLastIndex ?? null,
             // Attempt-currency fence: a fresh consumer append commits only
             // while its causal attempt still owns the cursor's head
             // (store.ts `append`).
@@ -1846,9 +1869,9 @@ export function postgres(options: PostgresStoreOptions = {}): PostgresStore {
             switch (reason['abort']) {
               case 'mixed': {
                 const owned = asNumber(reason['owned'])
-                return new A2Error(
-                  'PARTIAL_DUPLICATE_BATCH',
+                return duplicateBatchError(
                   `batch mixes ${owned} already-appended and ${events.length - owned} fresh events`,
+                  conditionalAt(reason['head']),
                 )
               }
               case 'cleared':
@@ -1860,6 +1883,12 @@ export function postgres(options: PostgresStoreOptions = {}): PostgresStore {
                   sessionId,
                   causes[asNumber(reason['ord']) - 1]!,
                 )
+              case 'moved':
+                return lastIndexMismatchError(
+                  sessionId,
+                  ifLastIndex!,
+                  asNumber(reason['index']),
+                )
               case 'held':
                 return new A2Error(
                   'STORE_UNAVAILABLE',
@@ -1881,6 +1910,7 @@ export function postgres(options: PostgresStoreOptions = {}): PostgresStore {
             events: idempotentReplay(
               events,
               (checked['events'] as Row[]).map(toStored),
+              conditionalAt(checked['head']),
             ),
             hasPending: checked['has_pending'] === true,
           }

package/src/store-redis-core.ts

@@ -53,7 +53,12 @@
  */
 
 import type { PresencePatch } from './contract.ts'
-import { A2Error, supersededAttemptError } from './errors.ts'
+import {
+  A2Error,
+  duplicateBatchError,
+  lastIndexMismatchError,
+  supersededAttemptError,
+} from './errors.ts'
 import { CLEAR_EVENT_TYPE, sessionClearedError } from './session-clear.ts'
 import { idempotentReplay } from './idempotent-replay.ts'
 import { NOTIFY_TIMINGS, nullProtoRecord } from './internal.ts'
@@ -705,11 +710,12 @@ end
 
 /**
  * KEYS: counter.
- * ARGV: sessionId, nowMs, n, served consumers, origin index or '', then per
- * event: id, type, payloadJson, causeJson or '', targets.
+ * ARGV: sessionId, nowMs, n, served consumers, origin index or '',
+ * ifLastIndex or '', then per event: id, type, payloadJson, causeJson or '',
+ * targets.
  * Returns ['empty', hasPending] | ['ok', firstIndex, hasPending] |
- * ['dup', hasPending, ...indexes] | ['partial', count] |
- * ['superseded', position] | ['cleared', originIndex] |
+ * ['dup', hasPending, head, ...indexes] | ['partial', count, head] |
+ * ['superseded', position] | ['cleared', originIndex] | ['moved', head] |
  * ['index', type, after].
  */
 const APPEND_LUA = `${BASE_LUA}${CURSOR_LUA}
@@ -717,7 +723,7 @@ local now, n = ARGV[2], tonumber(ARGV[3])
 use_served(ARGV[4])
 if n == 0 then return { 'empty', has_pending() } end
 local ids = {}
-for i = 1, n do ids[i] = ARGV[5 + (i - 1) * 5 + 1] end
+for i = 1, n do ids[i] = ARGV[6 + (i - 1) * 5 + 1] end
 local owners = owners_of(read_bounds(ids))
 local base = total
 local dups = {}
@@ -725,18 +731,18 @@ for i = 1, n do
   if owners[i] then dups[#dups + 1] = owners[i] end
 end
 if #dups == n then
-  local res = { 'dup', has_pending() }
+  local res = { 'dup', has_pending(), tostring(total) }
   for i = 1, #dups do res[#res + 1] = dups[i] end
   return res
 end
-if #dups > 0 then return { 'partial', tostring(#dups) } end
+if #dups > 0 then return { 'partial', tostring(#dups), tostring(total) } end
 local origin = ARGV[5]
 if origin ~= '' and tonumber(origin) <= boundary then return { 'cleared', origin } end
 -- The attempt-currency fence: a cause's head row must still be its cursor's
 -- head, at that attempt, not dead-lettered.
 local refs, fenced = {}, {}
 for i = 1, n do
-  local raw = ARGV[5 + (i - 1) * 5 + 4]
+  local raw = ARGV[6 + (i - 1) * 5 + 4]
   if raw ~= '' then
     local cause = cjson.decode(raw)
     local index = tonumber(cause.index)
@@ -756,16 +762,18 @@ for k, cause in ipairs(fenced) do
   end
   if served_has(cause.consumer) then pending_fast = true end
 end
+local expected = ARGV[6]
+if expected ~= '' and tonumber(expected) ~= total then return { 'moved', tostring(total) } end
 local batch = {}
 for i = 1, n do
-  local o = 5 + (i - 1) * 5
+  local o = 6 + (i - 1) * 5
   batch[i] = { idx = base + i, type = ARGV[o + 2], targets = targets_of(ARGV[o + 5]) }
 end
 local planned, missing, after = plan(batch, base)
 if not planned then return { 'index', missing, tostring(after) } end
 local marks = {}
 for i = 1, n do
-  local o = 5 + (i - 1) * 5
+  local o = 6 + (i - 1) * 5
   local field = tostring(base + i)
   redis.call('XADD', LOG, field .. '-0',
     'id', ARGV[o + 1], 'type', ARGV[o + 2], 'payload', ARGV[o + 3],
@@ -2408,6 +2416,11 @@ export function createRedisStoreCore(
           )
         }
         const now = clock.now().getTime()
+        const ifLastIndex = appendOptions?.ifLastIndex
+        const conditionalAt = (head: string | undefined) =>
+          ifLastIndex === undefined
+            ? undefined
+            : { sessionId, ifLastIndex, head: Number(head) }
         const withIds = events.map((e) => ({
           id: e.id ?? generateId(),
           type: e.type,
@@ -2427,6 +2440,7 @@ export function createRedisStoreCore(
               withIds.length,
               servedArg(appendOptions?.consumers),
               appendOptions?.originIndex ?? '',
+              ifLastIndex ?? '',
               ...withIds.flatMap((e, i) => [
                 e.id,
                 e.type,
@@ -2453,15 +2467,22 @@ export function createRedisStoreCore(
             withIds[Number(reply[1]) - 1]!.cause!,
           )
         }
+        if (verdict === 'moved') {
+          throw lastIndexMismatchError(
+            sessionId,
+            ifLastIndex!,
+            Number(reply[1]),
+          )
+        }
         if (verdict === 'partial') {
-          throw new A2Error(
-            'PARTIAL_DUPLICATE_BATCH',
+          throw duplicateBatchError(
             `batch mixes ${reply[1]} already-appended and ${events.length - Number(reply[1])} fresh events`,
+            conditionalAt(reply[2]),
           )
         }
         if (verdict === 'dup') {
           const hasPending = reply[1] === '1'
-          const firstIndex = Math.min(...reply.slice(2).map(Number))
+          const firstIndex = Math.min(...reply.slice(3).map(Number))
           // A valid retry occupies exactly events.length consecutive indexes.
           const { rows: existing, clearIndex } = await retryAfterGap(() =>
             readBoundedRange(
@@ -2477,7 +2498,11 @@ export function createRedisStoreCore(
               `session '${sessionId}' was cleared while an append retry replayed; retry it`,
             )
           }
-          const replayed = idempotentReplay(events, existing)
+          const replayed = idempotentReplay(
+            events,
+            existing,
+            conditionalAt(reply[2]),
+          )
           // The first attempt may have committed without publishing.
           await publish(
             notifyChannel(sessionId),

package/src/store-redis-notify.ts

@@ -217,11 +217,17 @@ export function createRedisNotifyStore(options: {
    */
   let subscriberGate: Promise<RedisConnection> | null = null
   const gatedSubscriber = (): Promise<RedisConnection> => {
-    subscriberGate ??= getSubscriber().then(async (conn) => {
+    if (subscriberGate) return subscriberGate
+    const gate = getSubscriber().then(async (conn) => {
       await conn.call('echo', 'ready')
       return conn
     })
-    return subscriberGate
+    subscriberGate = gate
+    // A failed check is retried by the next channel command.
+    void gate.catch(() => {
+      if (subscriberGate === gate) subscriberGate = null
+    })
+    return gate
   }
 
   const acquireChannel = async (channel: string): Promise<void> => {

package/src/store-sqlite.ts

@@ -15,7 +15,12 @@
 import { mkdirSync } from 'node:fs'
 import { dirname, resolve } from 'node:path'
 import { DatabaseSync } from 'node:sqlite'
-import { A2Error, supersededAttemptError } from './errors.ts'
+import {
+  A2Error,
+  duplicateBatchError,
+  lastIndexMismatchError,
+  supersededAttemptError,
+} from './errors.ts'
 import { CLEAR_EVENT_TYPE, sessionClearedError } from './session-clear.ts'
 import { idempotentReplay } from './idempotent-replay.ts'
 import {
@@ -850,18 +855,27 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
               'batch contains the same event id more than once',
             )
           }
+          const ifLastIndex = appendOptions?.ifLastIndex
+          const conditional =
+            ifLastIndex === undefined
+              ? undefined
+              : { sessionId, ifLastIndex, head: headOf(sessionId) }
           if (suppliedIds.length > 0) {
             const existing = liveOwnersOf(sessionId, clearIndex, suppliedIds)
             if (existing.length > 0) {
               if (existing.length === events.length) {
                 return {
-                  events: idempotentReplay(events, existing.map(toStored)),
+                  events: idempotentReplay(
+                    events,
+                    existing.map(toStored),
+                    conditional,
+                  ),
                   hasPending: hasPending(sessionId, clearIndex, consumers),
                 }
               }
-              throw new A2Error(
-                'PARTIAL_DUPLICATE_BATCH',
+              throw duplicateBatchError(
                 `batch mixes ${existing.length} already-appended and ${events.length - existing.length} fresh events`,
+                conditional,
               )
             }
           }
@@ -880,6 +894,13 @@ export function sqlite(options: SqliteStoreOptions = {}): SqliteStore {
             if (e.cause)
               assertCurrentCause({ sessionId, cause: e.cause, clearIndex })
           }
+          if (conditional && conditional.head !== conditional.ifLastIndex) {
+            throw lastIndexMismatchError(
+              sessionId,
+              conditional.ifLastIndex,
+              conditional.head,
+            )
+          }
 
           const inserted = insertBatch({
             sessionId,