@defrex/autobuild-postgres-store 0.9.0 → 0.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defrex/autobuild-postgres-store",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "type": "module",
   "license": "Apache-2.0",
   "engines": {

package/src/index.ts

@@ -19,6 +19,7 @@ export {
   MIGRATE_COMMAND,
   SCHEMA_CHECKSUM,
   SCHEMA_VERSION,
+  SNAPSHOT_SCHEMA_DDL,
   TICKET_SCHEMA_CHECKSUM,
   TICKET_SCHEMA_VERSION,
   assertSchema,

package/src/schema.ts

@@ -807,6 +807,21 @@ export const TICKET_SCHEMA_CHECKSUM = new Bun.CryptoHasher('sha256')
   .update(TICKET_SCHEMA_DDL)
   .digest('hex')
 
+/** Reducer snapshots (core `store/snapshots.ts`): a cache beside the event log.
+ * Deliberately outside `SCHEMA_DDL`, its marker, version and checksum, and
+ * outside `EXPECTED_COLUMNS`: a deployment at the current schema keeps serving
+ * across the upgrade, a new client against a database that lacks the table
+ * degrades to full replay (SQLSTATE 42P01 reads as "no snapshot"), and an older
+ * client never asks for it. Idempotent — `migratePostgres` creates it next to
+ * the ticket tables. */
+export const SNAPSHOT_SCHEMA_DDL = `
+CREATE TABLE IF NOT EXISTS reducer_snapshots (
+  scope_kind text NOT NULL, scope_key text NOT NULL, reducer text NOT NULL,
+  version integer NOT NULL, cursor bigint NOT NULL, state jsonb NOT NULL,
+  updated_at timestamptz NOT NULL,
+  PRIMARY KEY (scope_kind, scope_key, reducer)
+);`.trim()
+
 type ExpectedColumn = readonly [name: string, type: string, notNull: boolean, defaultValue?: string]
 
 const EXPECTED_COLUMNS: Record<string, readonly ExpectedColumn[]> = {
@@ -1235,6 +1250,7 @@ export async function migratePostgres(url: string): Promise<void> {
       await tx`SELECT pg_advisory_xact_lock(470281941)`
       await tx.unsafe(SCHEMA_DDL)
       await tx.unsafe(TICKET_SCHEMA_DDL)
+      await tx.unsafe(SNAPSHOT_SCHEMA_DDL)
       await tx.unsafe(AUTH_SCHEMA_DDL)
       const rows: { version: number; checksum: string }[] =
         await tx`SELECT version, checksum FROM ab_schema_migrations WHERE singleton = true FOR UPDATE`

package/src/store.ts

@@ -75,6 +75,7 @@ import {
 } from '@defrex/autobuild/store-adapter'
 import {
   DIGEST_EVENT_TYPES,
+  type DigestEventRow,
   REPOSITORY_STATE_EVENT_TYPES,
   readRepoStateEventsWithAnchorRecheck,
   reduceBuildDigest,
@@ -92,6 +93,7 @@ import {
   type TicketAssetMeta,
   type TicketAssetSummary,
 } from '@defrex/autobuild/store-adapter'
+import type { ReducerSnapshot, SnapshotScope } from '@defrex/autobuild/store-adapter'
 import { assertSchema } from './schema'
 import { PlanRetryRunner, type Exec, type Row } from './retry'
 
@@ -274,7 +276,11 @@ export class PostgresBuildStore implements BuildStore {
     // actual signal, not with total history.
     const rows: Row[] = await this.run((q) =>
       q.unsafe(
-        `SELECT b.slug AS slug, e.seq AS seq, e.ts AS ts, e.type AS type
+        `SELECT b.slug AS slug, e.seq AS seq, e.ts AS ts, e.type AS type,
+              CASE WHEN e.type = 'pr-attachment.reclaimed'
+                THEN (e.payload->>'hostedSeq')::bigint END AS "hostedSeq",
+              CASE WHEN e.type IN ('execution.started', 'execution.ended')
+                THEN e.payload->>'instance' END AS instance
        FROM builds b
        LEFT JOIN events e
          ON e.build = b.slug AND e.type IN (${DIGEST_EVENT_TYPES.map((_, i) => `$${i + 2}`).join(', ')})
@@ -283,7 +289,7 @@ export class PostgresBuildStore implements BuildStore {
         [repo, ...DIGEST_EVENT_TYPES],
       ),
     )
-    const eventsByBuild = new Map<string, Pick<AbEvent, 'type' | 'seq' | 'ts'>[]>()
+    const eventsByBuild = new Map<string, DigestEventRow[]>()
     for (const row of rows) {
       if (row.seq === null || row.seq === undefined) continue
       const events = eventsByBuild.get(String(row.slug)) ?? []
@@ -291,6 +297,12 @@ export class PostgresBuildStore implements BuildStore {
         type: String(row.type) as AbEvent['type'],
         seq: num(row.seq),
         ts: iso(row.ts),
+        ...(row.hostedSeq !== null && row.hostedSeq !== undefined
+          ? { hostedSeq: num(row.hostedSeq) }
+          : {}),
+        ...(row.instance !== null && row.instance !== undefined
+          ? { instance: String(row.instance) }
+          : {}),
       })
       eventsByBuild.set(String(row.slug), events)
     }
@@ -977,6 +989,86 @@ export class PostgresBuildStore implements BuildStore {
     })
   }
 
+  async getRepoHighWater(repo: string): Promise<number> {
+    if (!(await this.getRepo(repo))) throw new Error(`unknown repo "${repo}"`)
+    const rows: Row[] = await this.run(
+      (q) => q`SELECT COALESCE(MAX(seq), 0) AS seq FROM repo_events WHERE repo=${repo}`,
+    )
+    return num(rows[0]?.seq ?? 0)
+  }
+
+  /** SQLSTATE 42P01: a database that has not run the additive snapshot
+   * migration. Never cached, so a later `postgres:migrate` starts working
+   * without a restart. */
+  private static missingSnapshotTable(error: unknown): boolean {
+    const code =
+      (error as { code?: string; errno?: string }).errno ?? (error as { code?: string }).code
+    return code === '42P01'
+  }
+
+  async getReducerSnapshot(
+    scope: SnapshotScope,
+    reducer: string,
+    version: number,
+  ): Promise<ReducerSnapshot | null> {
+    const key = scope.kind === 'build' ? scope.slug : scope.repo
+    try {
+      const rows: Row[] = await this.run(
+        (q) => q`SELECT s.version, s.cursor, s.state FROM reducer_snapshots s
+          WHERE s.scope_kind=${scope.kind} AND s.scope_key=${key} AND s.reducer=${reducer}
+            AND s.version=${version}
+            AND s.cursor <= CASE WHEN ${scope.kind}='build'
+              THEN COALESCE((SELECT MAX(seq) FROM events WHERE build=${key}), 0)
+              ELSE COALESCE((SELECT MAX(seq) FROM repo_events WHERE repo=${key}), 0) END
+            AND CASE WHEN ${scope.kind}='build'
+              THEN EXISTS (SELECT 1 FROM builds WHERE slug=${key})
+              ELSE EXISTS (SELECT 1 FROM repo_streams WHERE repo=${key}) END`,
+      )
+      const row = rows[0]
+      if (row === undefined) return null
+      return { version: num(row.version), cursor: num(row.cursor), state: json(row.state) }
+    } catch (error) {
+      if (PostgresBuildStore.missingSnapshotTable(error)) return null
+      throw error
+    }
+  }
+
+  async putReducerSnapshot(
+    scope: SnapshotScope,
+    reducer: string,
+    snapshot: ReducerSnapshot,
+  ): Promise<boolean> {
+    const key = scope.kind === 'build' ? scope.slug : scope.repo
+    const state = JSON.stringify(snapshot.state ?? null)
+    try {
+      // One statement: the existence and log-tail guards, and the
+      // never-decrease rule, evaluate atomically against concurrent writers.
+      const rows: Row[] = await this.run(
+        (q) => q`INSERT INTO reducer_snapshots
+            (scope_kind, scope_key, reducer, version, cursor, state, updated_at)
+          SELECT ${scope.kind}, ${key}, ${reducer}, ${snapshot.version}::integer,
+            ${snapshot.cursor}::bigint, ${state}::jsonb, ${this.now()}::timestamptz
+          WHERE ${snapshot.cursor}::bigint <= CASE WHEN ${scope.kind}='build'
+              THEN COALESCE((SELECT MAX(seq) FROM events WHERE build=${key}), 0)
+              ELSE COALESCE((SELECT MAX(seq) FROM repo_events WHERE repo=${key}), 0) END
+            AND CASE WHEN ${scope.kind}='build'
+              THEN EXISTS (SELECT 1 FROM builds WHERE slug=${key})
+              ELSE EXISTS (SELECT 1 FROM repo_streams WHERE repo=${key}) END
+          ON CONFLICT (scope_kind, scope_key, reducer) DO UPDATE SET
+            version = EXCLUDED.version, cursor = EXCLUDED.cursor,
+            state = EXCLUDED.state, updated_at = EXCLUDED.updated_at
+          WHERE EXCLUDED.cursor > reducer_snapshots.cursor
+            OR (EXCLUDED.cursor = reducer_snapshots.cursor
+              AND EXCLUDED.version > reducer_snapshots.version)
+          RETURNING 1 AS written`,
+      )
+      return rows.length > 0
+    } catch (error) {
+      if (PostgresBuildStore.missingSnapshotTable(error)) return false
+      throw error
+    }
+  }
+
   async getRepoStateEvents(repo: string): Promise<RepositoryEvent[]> {
     if (!(await this.getRepo(repo))) throw new Error(`unknown repo "${repo}"`)
     // Two queries, mirroring the oracle's derivation: the latest run-started