experimental-a2 0.23.0 → 0.24.0

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-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,

package/src/store.ts

@@ -326,12 +326,22 @@ export interface A2Store {
    * a `cause` at or below the latest clear marker throws
    * `SUPERSEDED_ATTEMPT`, an `originIndex` there throws `SESSION_CLEARED`,
    * and ids whose rows lie below the marker are free to reuse.
+   *
+   * `ifLastIndex` conditions a non-empty batch on the session's head, the
+   * last index including any clear marker: when the head is anything else,
+   * throw `lastIndexMismatchError` carrying the head and write nothing. It is
+   * checked last, after the replay path and both fences, inside the same
+   * atomic operation, never as a read before it. A conditional batch whose
+   * ids conflict (mixed, or not matching their rows) reports that head
+   * instead of `PARTIAL_DUPLICATE_BATCH` when it isn't `ifLastIndex`
+   * (`duplicateBatchError`).
    */
   append(
     sessionId: string,
     events: AppendEvent[],
     options?: {
       originIndex?: number
+      ifLastIndex?: number
       consumers?: readonly StoreConsumer[]
     },
   ): Promise<StoreAppendResult>

package/src/wire.ts

@@ -309,6 +309,7 @@ const ERROR_STATUS: Record<A2ServerErrorCode, number> = {
   PARTIAL_DUPLICATE_BATCH: 400,
   SUPERSEDED_ATTEMPT: 409,
   SESSION_CLEARED: 409,
+  LAST_INDEX_MISMATCH: 409,
   CLAIM_EXPIRED: 409,
   STORE_UNAVAILABLE: 503,
   STORE_NOT_CONFIGURED: 500,

package/dist/initial-snapshot-D3Lve43o.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"initial-snapshot-D3Lve43o.d.ts","names":[],"sources":["../src/errors.ts","../src/initial-snapshot.ts"],"mappings":";;KAAY;KAcA,cACV;cAEW,gBAAgB;WAClB,MAAM;;WAEN;EAET,YACE,MAAM,aACN,iBACA;IAAY;IAAmB;;;;;;;;;;;cA6CtB,0BAA0B;EACrC,YAAY,iBAAiB;IAAY;;;;;KCrE/B,gBAAgB,KACxB,cAAc,wBAGd,QAAQ,cAAc"}