@defrex/autobuild-postgres-store 0.13.0 → 0.14.0

package/package.json

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

package/src/schema.ts

@@ -16,7 +16,7 @@ import {
   assertAuthSchema,
 } from './auth-schema'
 
-export const SCHEMA_VERSION = 13
+export const SCHEMA_VERSION = 14
 export const MIGRATE_COMMAND = 'bun run postgres:migrate (from a pinned Autobuild release checkout)'
 
 /** The frozen v3 DDL, kept verbatim so a deployed v3 marker's checksum can be
@@ -836,7 +836,11 @@ CREATE TABLE IF NOT EXISTS ticket_grants (
  execution text NOT NULL, kind text NOT NULL CHECK (kind IN ('runner','phase')),
  parent text REFERENCES ticket_grants(id), expires_at timestamptz NOT NULL, revoked_at timestamptz
 );`
-export const SCHEMA_DDL = `${SCHEMA_V12_DDL}\n${TICKET_POLICY_SCHEMA_DDL}\n${TICKET_GRANT_SCHEMA_DDL}`
+export const SCHEMA_V13_DDL = `${SCHEMA_V12_DDL}\n${TICKET_POLICY_SCHEMA_DDL}\n${TICKET_GRANT_SCHEMA_DDL}`
+export const SCHEMA_V13_CHECKSUM = new Bun.CryptoHasher('sha256')
+  .update(SCHEMA_V13_DDL)
+  .digest('hex')
+export const SCHEMA_DDL = `${SCHEMA_V13_DDL}\nALTER TABLE repo_streams ADD COLUMN IF NOT EXISTS tick jsonb;`
 export const SCHEMA_CHECKSUM = new Bun.CryptoHasher('sha256').update(SCHEMA_DDL).digest('hex')
 
 /** Ticket persistence evolves independently so deployed v1 BuildStore markers
@@ -1038,6 +1042,7 @@ const EXPECTED_COLUMNS: Record<string, readonly ExpectedColumn[]> = {
     ['lease_expires_at', 'timestamp with time zone', false],
     ['lease_ttl_ms', 'bigint', false],
     ['heartbeat_at', 'timestamp with time zone', false],
+    ['tick', 'jsonb', false],
   ],
   repo_events: [
     ['repo', 'text', true],
@@ -1660,6 +1665,8 @@ export async function migratePostgres(
             SET version = ${SCHEMA_VERSION}, checksum = ${SCHEMA_CHECKSUM},
               applied_at = ${new Date().toISOString()}
             WHERE singleton = true`
+        } else if (version === 13 && marker.checksum === SCHEMA_V13_CHECKSUM) {
+          await tx`UPDATE ab_schema_migrations SET version = ${SCHEMA_VERSION}, checksum = ${SCHEMA_CHECKSUM}, applied_at = ${new Date().toISOString()} WHERE singleton = true`
         } else if (version === 12 && marker.checksum === SCHEMA_V12_CHECKSUM) {
           await tx`UPDATE ab_schema_migrations SET version = ${SCHEMA_VERSION}, checksum = ${SCHEMA_CHECKSUM},
             applied_at = ${new Date().toISOString()} WHERE singleton = true`

package/src/store.ts

@@ -1,3 +1,17 @@
+import { readPersistedBuildDigests } from '@defrex/autobuild/store-adapter'
+import { assertPublicSnapshotReducer } from '@defrex/autobuild/store-adapter'
+import {
+  readReducerValue,
+  resolveReducerValue,
+  type ReducerValueRequest,
+  type ReducerValue,
+} from '@defrex/autobuild/store-adapter'
+import { validateTickFinish } from '@defrex/autobuild/store-adapter'
+import type {
+  RepoTickCompletion,
+  RepoTickFinish,
+  RepoTickObservation,
+} from '@defrex/autobuild/store-adapter'
 import { SQL } from 'bun'
 import {
   contentHash,
@@ -74,12 +88,9 @@ import {
   revisionsToPrune,
 } from '@defrex/autobuild/store-adapter'
 import {
-  DIGEST_EVENT_TYPES,
-  type DigestEventRow,
   REPOSITORY_STATE_EVENT_TYPES,
   REPOSITORY_LATEST_EVENT_TYPES,
   readRepoStateEventsWithAnchorRecheck,
-  reduceBuildDigest,
 } from '@defrex/autobuild/store-adapter'
 import {
   DEFAULT_TICKET_ASSET_LIMITS,
@@ -214,6 +225,7 @@ export class PostgresBuildStore implements BuildStore {
 
   private repoRecord(row: Row): RepositoryRecord {
     return {
+      ...(row.tick ? { tick: structuredClone(row.tick) as RepoTickObservation } : {}),
       repo: String(row.repo),
       createdAt: iso(row.created_at),
       updatedAt: iso(row.updated_at),
@@ -294,51 +306,12 @@ export class PostgresBuildStore implements BuildStore {
   }
 
   async getRepoBuildDigests(repo: string): Promise<Map<string, BuildDigest>> {
-    // From the builds side (AUT-487), matching the SQLite adapter: the type
-    // filter lives in the ON clause so a build whose log holds none of the
-    // digest-relevant event types still yields its row, and only those
-    // types are fetched. The `events_type_build_seq` index (schema.ts) makes
-    // the join's per-build probes type-leading, so the cost grows with the
-    // 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,
-              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(', ')})
-       WHERE b.repo = $1
-       ORDER BY b.slug, e.seq`,
-        [repo, ...DIGEST_EVENT_TYPES],
-      ),
-    )
-    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)) ?? []
-      events.push({
-        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)
-    }
-    const digests = new Map<string, BuildDigest>()
-    for (const row of rows) {
-      const slug = String(row.slug)
-      if (digests.has(slug)) continue
-      digests.set(slug, { slug, ...reduceBuildDigest(eventsByBuild.get(slug) ?? []) })
-    }
-    return digests
+    const records = await this.run(async (q) => {
+      const rows: Row[] =
+        await q`SELECT * FROM builds WHERE repo = ${repo} ORDER BY created_at, slug`
+      return rows.map((row) => this.record(row))
+    })
+    return readPersistedBuildDigests(this, repo, records)
   }
 
   private async appendLocked(
@@ -586,6 +559,59 @@ export class PostgresBuildStore implements BuildStore {
   async claimLease(slug: string, holder: string, ttlMs: number): Promise<boolean> {
     return this.claim('builds', slug, holder, ttlMs)
   }
+  async beginRepoTick(repo: string, holder: string): Promise<string | null> {
+    return this.tx(async (q) => {
+      const row = await this.lockRepo(q, repo)
+      if (
+        row.lease_holder !== holder ||
+        !row.lease_expires_at ||
+        Date.parse(iso(row.lease_expires_at)) <= this.clock().getTime()
+      )
+        return null
+      const startedAt = this.now()
+      const previous = row.tick as RepoTickObservation | undefined
+      const tick: RepoTickObservation = {
+        run: holder,
+        open: { startedAt },
+        ...(previous?.finished ? { finished: previous.finished } : {}),
+      }
+      await q`UPDATE repo_streams SET tick=${tick}, updated_at=${startedAt} WHERE repo=${repo}`
+      return startedAt
+    })
+  }
+
+  async finishRepoTick(
+    repo: string,
+    holder: string,
+    completion: RepoTickCompletion,
+    events: RepositoryEventWrite[],
+  ): Promise<RepoTickFinish | null> {
+    const validated = validateTickFinish(holder, completion, events)
+    return this.tx(async (q) => {
+      const row = await this.lockRepo(q, repo)
+      if (
+        row.lease_holder !== holder ||
+        !row.lease_expires_at ||
+        Date.parse(iso(row.lease_expires_at)) <= this.clock().getTime()
+      )
+        return null
+      const previous = row.tick as RepoTickObservation | undefined
+      if (previous?.run !== holder || !previous.open) throw new Error('no open repository tick')
+      const completedAt = this.now()
+      const envelopes: RepositoryEvent[] = []
+      for (const event of validated)
+        envelopes.push(
+          (await this.appendRepoLocked(q, repo, event, true, completedAt)) as RepositoryEvent,
+        )
+      const observation: RepoTickObservation = {
+        run: holder,
+        finished: { ...completion, run: holder, startedAt: previous.open.startedAt, completedAt },
+      }
+      await q`UPDATE repo_streams SET tick=${observation}, updated_at=${completedAt} WHERE repo=${repo}`
+      return { observation, events: envelopes }
+    })
+  }
+
   async claimRepoLease(repo: string, holder: string, ttlMs: number): Promise<boolean> {
     return this.claim('repo_streams', repo, holder, ttlMs)
   }
@@ -908,12 +934,12 @@ export class PostgresBuildStore implements BuildStore {
     repo: string,
     event: RepositoryEventWrite,
     alreadyLocked = false,
+    ts = this.now(),
   ): Promise<RepositoryEventEnvelope> {
     if (!alreadyLocked) await this.lockRepo(q, repo)
     const tails: Row[] =
       await q`SELECT COALESCE(MAX(seq), 0) AS seq FROM repo_events WHERE repo=${repo}`
     const seq = num(tails[0]?.seq) + 1
-    const ts = this.now()
     await q`INSERT INTO repo_events (repo, seq, ts, actor, type, payload) VALUES (${repo},${seq},${ts},${event.actor},${event.type},${event.payload})`
     await q`UPDATE repo_streams SET updated_at=${ts} WHERE repo=${repo}`
     return { repo, seq, ts, actor: event.actor, type: event.type, payload: event.payload }
@@ -1032,11 +1058,90 @@ export class PostgresBuildStore implements BuildStore {
     return code === '42P01'
   }
 
+  async getReducerValue(scope: SnapshotScope, request: ReducerValueRequest): Promise<ReducerValue> {
+    // Reject invalid requests before touching storage.
+    resolveReducerValue(scope, request)
+    return readReducerValue(scope, request, {
+      highWater: async () => {
+        const tail = await this.valueTail(scope)
+        if (tail === undefined) throw new Error('unknown reducer scope')
+        return tail
+      },
+      events: async (since, through) => {
+        const key = scope.kind === 'build' ? scope.slug : scope.repo
+        const rows: Row[] =
+          scope.kind === 'build'
+            ? await this.run(
+                (q) =>
+                  q`SELECT * FROM events WHERE build=${key} AND seq>${since} AND seq<=${through} ORDER BY seq`,
+              )
+            : await this.run(
+                (q) =>
+                  q`SELECT * FROM repo_events WHERE repo=${key} AND seq>${since} AND seq<=${through} ORDER BY seq`,
+              )
+        return rows.map((row) => ({
+          ...(scope.kind === 'build' ? { build: key } : { repo: key }),
+          seq: num(row.seq),
+          ts: iso(row.ts),
+          actor: json(row.actor),
+          type: String(row.type),
+          payload: json(row.payload),
+        })) as (AbEvent | RepositoryEvent)[]
+      },
+      put: (key, snapshot) => this.putSnapshot(scope, key, snapshot),
+      read: async (key) => {
+        const scopeKey = scope.kind === 'build' ? scope.slug : scope.repo
+        const rows: Row[] = await this.run(
+          (q) =>
+            q`SELECT version, cursor, state, state::text AS raw FROM reducer_snapshots WHERE scope_kind=${scope.kind} AND scope_key=${scopeKey} AND reducer=${key}`,
+        )
+        const row = rows[0]
+        if (!row) return null
+        let state: unknown = null
+        try {
+          state = json(row.state)
+        } catch {
+          /* malformed JSON cache string */
+        }
+        return {
+          snapshot: { version: num(row.version), cursor: num(row.cursor), state },
+          token: String(row.raw),
+        }
+      },
+      repair: async (key, observed, snapshot) => {
+        const scopeKey = scope.kind === 'build' ? scope.slug : scope.repo
+        const rows: Row[] = await this.run(
+          (q) =>
+            q`UPDATE reducer_snapshots SET version=${snapshot.version}::integer, cursor=${snapshot.cursor}::bigint, state=${JSON.stringify(snapshot.state)}::jsonb, updated_at=${this.now()}::timestamptz WHERE scope_kind=${scope.kind} AND scope_key=${scopeKey} AND reducer=${key} AND version=${observed.snapshot.version}::integer AND cursor=${observed.snapshot.cursor}::bigint AND state::text=${observed.token}
+          AND (${observed.snapshot.cursor}::bigint <= ${snapshot.cursor}::bigint OR ${observed.snapshot.cursor}::bigint > CASE WHEN ${scope.kind}='build' THEN COALESCE((SELECT MAX(seq) FROM events WHERE build=${scopeKey}),0) ELSE COALESCE((SELECT MAX(seq) FROM repo_events WHERE repo=${scopeKey}),0) END)
+          AND ${snapshot.cursor}::bigint <= CASE WHEN ${scope.kind}='build' THEN COALESCE((SELECT MAX(seq) FROM events WHERE build=${scopeKey}),0) ELSE COALESCE((SELECT MAX(seq) FROM repo_events WHERE repo=${scopeKey}),0) END RETURNING 1`,
+        )
+        return rows.length > 0
+      },
+    })
+  }
+
+  private async valueTail(scope: SnapshotScope): Promise<number | undefined> {
+    const key = scope.kind === 'build' ? scope.slug : scope.repo
+    const rows: Row[] =
+      scope.kind === 'build'
+        ? await this.run(
+            (q) =>
+              q`SELECT (SELECT COALESCE(MAX(seq),0) FROM events WHERE build=${key}) AS tail FROM builds WHERE slug=${key}`,
+          )
+        : await this.run(
+            (q) =>
+              q`SELECT (SELECT COALESCE(MAX(seq),0) FROM repo_events WHERE repo=${key}) AS tail FROM repo_streams WHERE repo=${key}`,
+          )
+    return rows[0] ? num(rows[0].tail) : undefined
+  }
+
   async getReducerSnapshot(
     scope: SnapshotScope,
     reducer: string,
     version: number,
   ): Promise<ReducerSnapshot | null> {
+    assertPublicSnapshotReducer(reducer)
     const key = scope.kind === 'build' ? scope.slug : scope.repo
     try {
       const rows: Row[] = await this.run(
@@ -1063,6 +1168,15 @@ export class PostgresBuildStore implements BuildStore {
     scope: SnapshotScope,
     reducer: string,
     snapshot: ReducerSnapshot,
+  ): Promise<boolean> {
+    assertPublicSnapshotReducer(reducer)
+    return this.putSnapshot(scope, reducer, snapshot)
+  }
+
+  private async putSnapshot(
+    scope: SnapshotScope,
+    reducer: string,
+    snapshot: ReducerSnapshot,
   ): Promise<boolean> {
     const key = scope.kind === 'build' ? scope.slug : scope.repo
     const state = JSON.stringify(snapshot.state ?? null)