tapimo 0.10.2 → 0.12.0

package/src/internal/Webhooks.test.ts

@@ -304,44 +304,6 @@ describe('updateSubscription', () => {
   })
 })
 
-describe('listActive', () => {
-  test('returns only active subscriptions for a stream', async () => {
-    const db = TestApp.database()
-    const a = await Webhooks.createSubscription(db, createInput())
-    const b = await Webhooks.createSubscription(db, createInput({ owner: mppOwner }))
-    await Webhooks.createSubscription(db, createInput({ eventType: 'transaction:included' }))
-
-    let active = await Webhooks.listActive(db, 4217, 'token:transfer')
-    expect(active.map((s) => s.id).sort()).toEqual([a.id, b.id].sort())
-
-    await Webhooks.updateSubscription(db, apiKeyOwner, a.id, { status: 'paused' })
-    active = await Webhooks.listActive(db, 4217, 'token:transfer')
-    expect(active.map((s) => s.id)).toEqual([b.id])
-  })
-
-  test('drops a deleted subscription from the index', async () => {
-    const db = TestApp.database()
-    const a = await Webhooks.createSubscription(db, createInput())
-
-    await Webhooks.deleteSubscription(db, apiKeyOwner, a.id)
-    expect(await Webhooks.listActive(db, 4217, 'token:transfer')).toMatchInlineSnapshot(`[]`)
-  })
-})
-
-describe('listActiveWithCursors', () => {
-  test('pairs each subscription with its stored cursor from one read', async () => {
-    const db = TestApp.database()
-    const anchored = await Webhooks.createSubscription(db, createInput())
-    const fresh = await Webhooks.createSubscription(db, createInput({ owner: mppOwner }))
-    await Webhooks.setCursor(db, anchored.id, Cursor.encode([100, 5]))
-
-    const pairs = await Webhooks.listActiveWithCursors(db, 4217, 'token:transfer')
-    const byId = new Map(pairs.map((pair) => [pair.subscription.id, pair.cursor]))
-    expect(Cursor.decode(byId.get(anchored.id)!, ['int', 'int'])).toEqual([100, 5])
-    expect(byId.get(fresh.id)).toBeNull()
-  })
-})
-
 describe('listActiveForChain', () => {
   test('returns active subscriptions across event types in one read', async () => {
     const db = TestApp.database()
@@ -365,102 +327,6 @@ describe('listActiveForChain', () => {
   })
 })
 
-describe('maxCursorBlock', () => {
-  test('returns the freshest cursor block across event types', async () => {
-    const db = TestApp.database()
-    const transfer = await Webhooks.createSubscription(db, createInput())
-    const tx = await Webhooks.createSubscription(
-      db,
-      createInput({ eventType: 'transaction:included' }),
-    )
-    await Webhooks.setCursor(db, transfer.id, Cursor.encode([100, 5]))
-    await Webhooks.setCursor(db, tx.id, Cursor.encode([250, 0]))
-
-    expect(await Webhooks.maxCursorBlock(db, 4217)).toBe(250)
-  })
-
-  test('counts creation checkpoints at their recorded head', async () => {
-    const db = TestApp.database()
-    await Webhooks.createSubscription(db, createInput(), { startBlockNumber: 900 })
-
-    expect(await Webhooks.maxCursorBlock(db, 4217)).toBe(900)
-  })
-
-  test('ignores other chains and returns null without cursors', async () => {
-    const db = TestApp.database()
-    expect(await Webhooks.maxCursorBlock(db, 4217)).toBeNull()
-
-    const other = await Webhooks.createSubscription(db, createInput({ chainId: 42431 }))
-    await Webhooks.setCursor(db, other.id, Cursor.encode([999, 0]))
-    // A cursorless subscription on the queried chain still reads as null.
-    await Webhooks.createSubscription(db, createInput())
-
-    expect(await Webhooks.maxCursorBlock(db, 4217)).toBeNull()
-    expect(await Webhooks.maxCursorBlock(db, 42431)).toBe(999)
-  })
-})
-
-describe('cursors', () => {
-  test('round-trips a per-subscription cursor', async () => {
-    const db = TestApp.database()
-    // The cursor is a column on the subscription row, so it needs a real
-    // subscription (the old key space allowed orphan cursors).
-    const created = await Webhooks.createSubscription(db, createInput())
-    expect(await Webhooks.getCursor(db, created.id)).toMatchInlineSnapshot(`null`)
-
-    await Webhooks.setCursor(db, created.id, '12345:7')
-    expect(await Webhooks.getCursor(db, created.id)).toMatchInlineSnapshot(`"12345:7"`)
-  })
-
-  test('atomically rejects a stale cursor write', async () => {
-    const db = TestApp.database()
-    const created = await Webhooks.createSubscription(db, createInput())
-    const a = Cursor.encode([100, 1])
-    const b = Cursor.encode([100, 2])
-    const results = await Promise.all([
-      Webhooks.compareAndSetCursor(db, {
-        cursor: a,
-        expectedCursor: null,
-        subscriptionId: created.id,
-      }),
-      Webhooks.compareAndSetCursor(db, {
-        cursor: b,
-        expectedCursor: null,
-        subscriptionId: created.id,
-      }),
-    ])
-
-    expect(results.toSorted((a, b) => Number(a) - Number(b))).toEqual([false, true])
-    expect([a, b]).toContain(await Webhooks.getCursor(db, created.id))
-  })
-})
-
-describe('compareAndSetCursors', () => {
-  test('atomically advances a batch and reports stale rows', async () => {
-    const db = TestApp.database()
-    const initialized = await Webhooks.createSubscription(db, createInput())
-    const stale = await Webhooks.createSubscription(db, createInput())
-    const uninitialized = await Webhooks.createSubscription(db, createInput())
-    const initial = Cursor.encode([100, 1])
-    const next = Cursor.encode([101, 1])
-    await Webhooks.setCursor(db, initialized.id, initial)
-    await Webhooks.setCursor(db, stale.id, initial)
-
-    const committed = await Webhooks.compareAndSetCursors(db, {
-      cursors: [
-        { cursor: next, expectedCursor: initial, subscriptionId: initialized.id },
-        { cursor: next, expectedCursor: null, subscriptionId: stale.id },
-        { cursor: next, expectedCursor: null, subscriptionId: uninitialized.id },
-      ],
-    })
-
-    expect([...committed].toSorted()).toEqual([initialized.id, uninitialized.id].toSorted())
-    expect(await Webhooks.getCursor(db, initialized.id)).toBe(next)
-    expect(await Webhooks.getCursor(db, stale.id)).toBe(initial)
-    expect(await Webhooks.getCursor(db, uninitialized.id)).toBe(next)
-  })
-})
-
 describe('recordSuccess / recordFailure', () => {
   test('recordSuccess resets failures and stamps lastDeliveryAt', async () => {
     const db = TestApp.database()
@@ -482,6 +348,41 @@ describe('recordSuccess / recordFailure', () => {
     expect(read?.lastDeliveryAt).toBe('2026-01-01T00:00:00.000Z')
   })
 
+  test('recordSuccess refreshes the stamp at most once per precision window', async () => {
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput())
+    const stamped = await Webhooks.recordSuccess(db, created, { now: fixedNow })
+    expect(stamped.lastDeliveryAt).toBe(fixedNow().toISOString())
+
+    // A success moments later has nothing to move: the counter is already zero
+    // and the stamp is inside its window, so the row is never rewritten.
+    const soon = new Date(fixedNow().getTime() + 1_000)
+    await Webhooks.recordSuccess(db, stamped, { now: () => soon })
+    const unmoved = await Webhooks.getSubscription(db, apiKeyOwner, created.id)
+    expect(unmoved?.lastDeliveryAt, 'the stored stamp must not move').toBe(fixedNow().toISOString())
+
+    // Past any plausible window; the exact bound is internal.
+    const later = new Date(fixedNow().getTime() + 3_600_000)
+    await Webhooks.recordSuccess(db, stamped, { now: () => later })
+    const moved = await Webhooks.getSubscription(db, apiKeyOwner, created.id)
+    expect(moved?.lastDeliveryAt).toBe(later.toISOString())
+  })
+
+  test('recordSuccess always resets a non-zero failure counter', async () => {
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput())
+    // Stamp first, so only the counter is out of date: the reset must not be
+    // suppressed by a fresh stamp.
+    const stamped = await Webhooks.recordSuccess(db, created, { now: fixedNow })
+    const failed = await Webhooks.recordFailure(db, stamped, { now: fixedNow })
+    expect(failed.failureCount).toBe(1)
+
+    await Webhooks.recordSuccess(db, failed, { now: fixedNow })
+
+    const read = await Webhooks.getSubscription(db, apiKeyOwner, created.id)
+    expect(read?.failureCount, 'a pending reset must never be skipped').toBe(0)
+  })
+
   test('recordFailure auto-disables at the threshold and drops from the active index', async () => {
     const db = TestApp.database()
     let subscription = await Webhooks.createSubscription(db, createInput())
@@ -490,11 +391,13 @@ describe('recordSuccess / recordFailure', () => {
     subscription = await Webhooks.recordFailure(db, subscription, { maxFailures: 3 })
     subscription = await Webhooks.recordFailure(db, subscription, { maxFailures: 3 })
     expect(subscription.status).toMatchInlineSnapshot(`"active"`)
-    expect((await Webhooks.listActive(db, 4217, 'token:transfer')).map((s) => s.id)).toEqual([
-      subscription.id,
-    ])
+    expect(
+      (
+        await Webhooks.listActiveForChain(db, { chainId: 4217, eventTypes: ['token:transfer'] })
+      ).map((pair) => pair.subscription.id),
+    ).toEqual([subscription.id])
 
-    // Hitting the threshold disables it and removes it from the poller's index.
+    // Hitting the threshold disables it and removes it from the active index.
     subscription = await Webhooks.recordFailure(db, subscription, { maxFailures: 3 })
     expect({ failureCount: subscription.failureCount, status: subscription.status })
       .toMatchInlineSnapshot(`
@@ -503,7 +406,40 @@ describe('recordSuccess / recordFailure', () => {
         "status": "disabled",
       }
     `)
-    expect(await Webhooks.listActive(db, 4217, 'token:transfer')).toMatchInlineSnapshot(`[]`)
+    expect(
+      await Webhooks.listActiveForChain(db, { chainId: 4217, eventTypes: ['token:transfer'] }),
+    ).toMatchInlineSnapshot(`[]`)
+  })
+
+  test('recordFailure leaves an already-disabled subscription alone at the cap', async () => {
+    const db = TestApp.database()
+    let subscription = await Webhooks.createSubscription(db, createInput())
+    subscription = await Webhooks.recordFailure(db, subscription, { maxFailures: 2, now: fixedNow })
+    subscription = await Webhooks.recordFailure(db, subscription, { maxFailures: 2, now: fixedNow })
+    expect(subscription.status).toBe('disabled')
+
+    // A straggler failing after the disable has nothing to move: the row is
+    // never rewritten.
+    const later = new Date(fixedNow().getTime() + 1_000)
+    await Webhooks.recordFailure(db, subscription, { maxFailures: 2, now: () => later })
+
+    const read = await Webhooks.getSubscription(db, apiKeyOwner, subscription.id)
+    expect(read?.failureCount, 'the stored counter must not move').toBe(2)
+    expect(read?.updatedAt, 'the stored stamp must not move').toBe(fixedNow().toISOString())
+  })
+
+  test('recordFailure re-disables a re-enabled subscription still at the cap', async () => {
+    const db = TestApp.database()
+    let subscription = await Webhooks.createSubscription(db, createInput())
+    subscription = await Webhooks.recordFailure(db, subscription, { maxFailures: 1, now: fixedNow })
+    expect(subscription.status).toBe('disabled')
+
+    await Webhooks.updateSubscription(db, apiKeyOwner, subscription.id, { status: 'active' })
+
+    // The counter still sits at the cap, so this failure must write again.
+    await Webhooks.recordFailure(db, subscription, { maxFailures: 1, now: fixedNow })
+    const read = await Webhooks.getSubscription(db, apiKeyOwner, subscription.id)
+    expect(read?.status).toBe('disabled')
   })
 })
 
@@ -1014,6 +950,72 @@ describe('ensureQueueEvents', () => {
     expect(histograms.has('webhook_delivery_subscription_read_ms')).toBe(true)
   })
 
+  test('measures observation to attempt from the staged head stamp', async () => {
+    const db = TestApp.database()
+    const subscription = await Webhooks.createSubscription(
+      db,
+      createInput({ eventType: 'transaction:included' }),
+    )
+    const envelope = Webhooks.buildEnvelope({
+      blockNumber: 123,
+      data: {},
+      logIndex: 4,
+      subscription,
+    })
+    const observedAt = Date.now() - 5_000
+    const { references: [reference] } = await Webhooks.ensureQueueEvents(db, [{ envelope, subscription }], { observedAt }) // prettier-ignore
+    const histograms = new Map<string, number>()
+    const metrics = Metrics.from({
+      count() {},
+      flush() {},
+      gauge() {},
+      histogram(name, value) {
+        histograms.set(name, value)
+      },
+    })
+    const fetch = (async () => new Response(null, { status: 200 })) satisfies typeof globalThis.fetch // prettier-ignore
+
+    const result = await Webhooks.deliverQueueEventAndRecord(db, reference!, { fetch, metrics })
+
+    expect(result.status).toBe('delivered')
+    // Measured from the head stamp, so it covers the whole controllable span
+    // rather than only the time since this worker dequeued the message.
+    expect(histograms.get('webhook_observed_to_attempt_ms')).toBeGreaterThanOrEqual(5_000)
+    expect(histograms.has('webhook_delivery_preflight_ms')).toBe(true)
+    expect(histograms.has('webhook_delivery_settle_ms')).toBe(true)
+  })
+
+  test('omits observation timing for a replay with no staged head stamp', async () => {
+    const db = TestApp.database()
+    const subscription = await Webhooks.createSubscription(
+      db,
+      createInput({ eventType: 'transaction:included' }),
+    )
+    const envelope = Webhooks.buildEnvelope({
+      blockNumber: 124,
+      data: {},
+      logIndex: 4,
+      subscription,
+    })
+    const { references: [reference] } = await Webhooks.ensureQueueEvents(db, [{ envelope, subscription }]) // prettier-ignore
+    const histograms = new Map<string, number>()
+    const metrics = Metrics.from({
+      count() {},
+      flush() {},
+      gauge() {},
+      histogram(name, value) {
+        histograms.set(name, value)
+      },
+    })
+    const fetch = (async () => new Response(null, { status: 200 })) satisfies typeof globalThis.fetch // prettier-ignore
+
+    await Webhooks.deliverQueueEventAndRecord(db, reference!, { fetch, metrics })
+
+    // Absent rather than zero: a replay is unattributable, not instant.
+    expect(histograms.has('webhook_observed_to_attempt_ms')).toBe(false)
+    expect(histograms.has('webhook_event_to_attempt_ms')).toBe(true)
+  })
+
   test('skips a staged event after its subscription expires', async () => {
     vi.useFakeTimers({ now: fixedNow(), toFake: ['Date'] })
     try {
@@ -1079,7 +1081,7 @@ describe('ensureQueueEvents', () => {
     expect(await Webhooks.getQueueEvent(db, reference)).toBeNull()
   })
 
-  test('replaces an expired terminal row so replays stay deliverable', async () => {
+  test('stages a replay once its completion has expired', async () => {
     vi.useFakeTimers({ toFake: ['Date'] })
     vi.setSystemTime(fixedNow())
     try {
@@ -1095,9 +1097,9 @@ describe('ensureQueueEvents', () => {
         }),
       ).toBe(true)
 
-      // Past the dedupe window an unpruned terminal row must not suppress a
+      // Past the dedupe window an unpruned completion must not suppress a
       // replay.
-      vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.deliveryRetentionMs + 1_000))
+      vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.dedupeRetentionMs + 1_000))
       const replay = await Webhooks.ensureQueueEvents(db, [{ envelope, subscription }])
       expect(replay.created).toBe(1)
       await expect(Webhooks.claimQueueEvent(db, reference)).resolves.toMatchObject({
@@ -1107,6 +1109,65 @@ describe('ensureQueueEvents', () => {
       vi.useRealTimers()
     }
   })
+
+  test('stamps a fresh observation on a post-expiry replay', async () => {
+    vi.useFakeTimers({ toFake: ['Date'] })
+    vi.setSystemTime(fixedNow())
+    try {
+      const db = TestApp.database()
+      const { envelope, reference, subscription } = await stagedObligation(db)
+      const claim = await Webhooks.claimQueueEvent(db, reference)
+      if (claim.type !== 'claimed') throw new Error(`Unexpected claim: ${claim.type}`)
+      await Webhooks.completeQueueEvent(db, reference, {
+        claimedAt: claim.record.attemptingAt!,
+        status: 'succeeded',
+      })
+
+      vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.dedupeRetentionMs + 1_000))
+      const observedAt = Date.now() - 250
+      await Webhooks.ensureQueueEvents(db, [{ envelope, subscription }], { observedAt })
+
+      // Carrying the replaced row's stamp would measure this delivery against
+      // an observation from the retention window before it.
+      const replayed = await Webhooks.claimQueueEvent(db, reference)
+      if (replayed.type !== 'claimed') throw new Error(`Unexpected claim: ${replayed.type}`)
+      expect(replayed.record.observedAt).toBe(new Date(observedAt).toISOString())
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  test('suppresses only the completed obligation when staging a mixed batch', async () => {
+    const db = TestApp.database()
+    const done = await stagedObligation(db, 4)
+    const claim = await Webhooks.claimQueueEvent(db, done.reference)
+    if (claim.type !== 'claimed') throw new Error(`Unexpected claim: ${claim.type}`)
+    await Webhooks.completeQueueEvent(db, done.reference, {
+      claimedAt: claim.record.attemptingAt!,
+      status: 'failed',
+    })
+
+    const fresh = Webhooks.buildEnvelope({
+      blockNumber: 124,
+      createdAt: new Date(),
+      data: { amount: '1' },
+      logIndex: 5,
+      subscription: done.subscription,
+    })
+    const batch = await Webhooks.ensureQueueEvents(db, [
+      { envelope: done.envelope, subscription: done.subscription },
+      { envelope: fresh, subscription: done.subscription },
+    ])
+
+    expect(batch.created).toBe(1)
+    await expect(Webhooks.claimQueueEvent(db, done.reference)).resolves.toEqual({
+      status: 'failed',
+      type: 'terminal',
+    })
+    await expect(Webhooks.claimQueueEvent(db, batch.references[1]!)).resolves.toMatchObject({
+      type: 'claimed',
+    })
+  })
 })
 
 describe('claimQueueEvent', () => {
@@ -1119,6 +1180,22 @@ describe('claimQueueEvent', () => {
     vi.useRealTimers()
   })
 
+  test('reads an expired completion as missing', async () => {
+    const db = TestApp.database()
+    const { reference } = await stagedObligation(db)
+    const claim = await Webhooks.claimQueueEvent(db, reference)
+    if (claim.type !== 'claimed') throw new Error(`Unexpected claim: ${claim.type}`)
+    await Webhooks.completeQueueEvent(db, reference, {
+      claimedAt: claim.record.attemptingAt!,
+      status: 'succeeded',
+    })
+
+    // Matches a pruned terminal row: past the dedupe window the completion is
+    // invisible everywhere, not only to staging.
+    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.dedupeRetentionMs + 1_000))
+    await expect(Webhooks.claimQueueEvent(db, reference)).resolves.toEqual({ type: 'missing' })
+  })
+
   test('claims a due obligation once and reclaims after staleness', async () => {
     const db = TestApp.database()
     const { reference } = await stagedObligation(db)
@@ -1183,17 +1260,17 @@ describe('claimQueueEvent', () => {
 
     // Pending obligations never expire; only terminal transitions stamp a
     // dedupe deadline.
-    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.deliveryRetentionMs * 3))
+    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.dedupeRetentionMs * 3))
     await expect(Webhooks.claimQueueEvent(db, reference)).resolves.toMatchObject({
       type: 'claimed',
     })
   })
 
-  test('never prunes pending work', async () => {
+  test('leaves pending obligations claimable across a prune', async () => {
     const db = TestApp.database()
     const { reference } = await stagedObligation(db)
 
-    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.deliveryRetentionMs + 1_000))
+    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.dedupeRetentionMs + 1_000))
     await Webhooks.pruneExpired(db)
     const claim = await Webhooks.claimQueueEvent(db, reference)
     expect(claim.type).toBe('claimed')