@defrex/autobuild-postgres-store 0.8.0 → 0.10.0

package/src/tickets.ts

@@ -10,6 +10,7 @@ import type {
 } from '@defrex/autobuild/plugin-sdk'
 import { validateTicketUpdate } from '@defrex/autobuild/ticket-update'
 import { assertTicketSchema } from './schema'
+import { PlanRetryRunner, type Exec } from './retry'
 
 type Row = Record<string, unknown>
 
@@ -39,6 +40,12 @@ function strings(value: unknown): string[] {
  * repository's team or lifecycle overrides. */
 export class PostgresTicketDatabase {
   readonly lifecycle: PostgresTicketLifecycle
+  /** The shared plan-retry mechanics (`./retry`): one runner per pool owner,
+   * so every source view this database hands out shares one memo — healing
+   * done by one source benefits all sources on the same pool, and the
+   * per-runner marker namespace keeps sources of different databases from
+   * colliding on prepared-statement names. */
+  private readonly retry = new PlanRetryRunner()
 
   constructor(
     readonly sql: SQL,
@@ -56,7 +63,7 @@ export class PostgresTicketDatabase {
   }
 
   source(context: PostgresTicketContext): PostgresTicketSource {
-    return new PostgresTicketSource(this.sql, context, this.lifecycle)
+    return new PostgresTicketSource(this.sql, context, this.lifecycle, this.retry)
   }
 
   close(): Promise<void> {
@@ -94,6 +101,10 @@ export class PostgresTicketSource implements TicketSource {
     private readonly sql: SQL,
     context: PostgresTicketContext,
     private readonly lifecycle: PostgresTicketLifecycle,
+    /** Optional trailing parameter so the exported constructor stays
+     * signature-compatible; a fresh runner keeps the per-instance marker
+     * namespace when no pool owner supplies one. */
+    private readonly retry: PlanRetryRunner = new PlanRetryRunner(),
   ) {
     if (!context.teamKey.trim()) throw new Error('ticket teamKey must be nonblank')
     this.team = context.teamKey
@@ -112,13 +123,13 @@ export class PostgresTicketSource implements TicketSource {
     }
   }
 
-  private async blockers(executor: SQL, id: string): Promise<string[]> {
+  private async blockers(executor: Exec, id: string): Promise<string[]> {
     const rows: Row[] = await executor`SELECT blocker_id FROM ab_ticket_blockers
       WHERE team = ${this.team} AND ticket_id = ${id} ORDER BY blocker_id`
     return rows.map((row) => String(row.blocker_id))
   }
 
-  private async record(executor: SQL, row: Row): Promise<Ticket> {
+  private async record(executor: Exec, row: Row): Promise<Ticket> {
     const id = String(row.id)
     const title = String(row.title)
     const blockedBy = await this.blockers(executor, id)
@@ -135,7 +146,7 @@ export class PostgresTicketSource implements TicketSource {
     }
   }
 
-  private async require(executor: SQL, id: string, operation: string, lock = false): Promise<Row> {
+  private async require(executor: Exec, id: string, operation: string, lock = false): Promise<Row> {
     const rows: Row[] = lock
       ? await executor`SELECT * FROM ab_tickets WHERE team = ${this.team} AND id = ${id} FOR UPDATE`
       : await executor`SELECT * FROM ab_tickets WHERE team = ${this.team} AND id = ${id}`
@@ -146,46 +157,55 @@ export class PostgresTicketSource implements TicketSource {
 
   async listReady(criteria: { labels?: string[]; state?: string }): Promise<TicketListing> {
     const labels = criteria.labels ?? []
-    const rows: Row[] = await this.sql`SELECT * FROM ab_tickets
-      WHERE team = ${this.team}
-        AND (${criteria.state ?? null}::text IS NULL OR state = ${criteria.state ?? null})
-        AND labels @> ${this.sql.array(labels, 'text')}
-      ORDER BY created_at, id`
-    return {
-      tickets: await Promise.all(rows.map((row) => this.record(this.sql, row))),
-      diagnostics: [],
-    }
+    return this.retry.run(this.sql, async (q) => {
+      const rows: Row[] = await q`SELECT * FROM ab_tickets
+        WHERE team = ${this.team}
+          AND (${criteria.state ?? null}::text IS NULL OR state = ${criteria.state ?? null})
+          AND labels @> ${q.array(labels, 'text')}
+        ORDER BY created_at, id`
+      // Sequential, not `Promise.all`: every statement of a body runs on one
+      // pinned connection, and failure attribution (`Attempt.inFlight` in
+      // `./retry`) requires the statements to be ordered.
+      const tickets: Ticket[] = []
+      for (const row of rows) tickets.push(await this.record(q, row))
+      return { tickets, diagnostics: [] }
+    })
   }
 
   async get(id: string): Promise<Ticket | null> {
-    const rows: Row[] = await this
-      .sql`SELECT * FROM ab_tickets WHERE team = ${this.team} AND id = ${id}`
-    return rows[0] ? this.record(this.sql, rows[0]) : null
+    return this.retry.run(this.sql, async (q) => {
+      const rows: Row[] = await q`SELECT * FROM ab_tickets WHERE team = ${this.team} AND id = ${id}`
+      return rows[0] ? this.record(q, rows[0]) : null
+    })
   }
 
   async claim(id: string): Promise<boolean> {
-    const rows: Row[] = await this.sql`UPDATE ab_tickets SET state = ${this.claimedState},
-      updated_at = ${new Date().toISOString()}
-      WHERE team = ${this.team} AND id = ${id}
-        AND state <> ${this.claimedState} AND state <> ${this.lifecycle.done} RETURNING id`
-    return rows.length === 1
+    return this.retry.run(this.sql, async (q) => {
+      const rows: Row[] = await q`UPDATE ab_tickets SET state = ${this.claimedState},
+        updated_at = ${new Date().toISOString()}
+        WHERE team = ${this.team} AND id = ${id}
+          AND state <> ${this.claimedState} AND state <> ${this.lifecycle.done} RETURNING id`
+      return rows.length === 1
+    })
   }
 
   async comment(id: string, body: string): Promise<void> {
-    await this.sql.begin(async (tx) => {
-      await this.require(tx, id, 'comment', true)
-      const tails: Row[] = await tx`SELECT COALESCE(MAX(seq), 0) AS seq FROM ab_ticket_comments
+    await this.retry.tx(this.sql, async (q) => {
+      await this.require(q, id, 'comment', true)
+      const tails: Row[] = await q`SELECT COALESCE(MAX(seq), 0) AS seq FROM ab_ticket_comments
         WHERE team = ${this.team} AND ticket_id = ${id}`
-      await tx`INSERT INTO ab_ticket_comments (team, ticket_id, seq, body, created_at)
+      await q`INSERT INTO ab_ticket_comments (team, ticket_id, seq, body, created_at)
         VALUES (${this.team}, ${id}, ${Number(tails[0]?.seq ?? 0) + 1}, ${body}, ${new Date().toISOString()})`
     })
   }
 
   async transition(id: string, state: string): Promise<void> {
     this.assertState(state)
-    const rows: Row[] = await this.sql`UPDATE ab_tickets SET state = ${state},
-      updated_at = ${new Date().toISOString()} WHERE team = ${this.team} AND id = ${id} RETURNING id`
-    if (!rows[0]) throw new Error(`database ticket source: transition on unknown ticket "${id}"`)
+    await this.retry.run(this.sql, async (q) => {
+      const rows: Row[] = await q`UPDATE ab_tickets SET state = ${state},
+        updated_at = ${new Date().toISOString()} WHERE team = ${this.team} AND id = ${id} RETURNING id`
+      if (!rows[0]) throw new Error(`database ticket source: transition on unknown ticket "${id}"`)
+    })
   }
 
   async create(draft: TicketDraft, options: TicketCreateOptions = {}): Promise<Ticket> {
@@ -193,25 +213,25 @@ export class PostgresTicketSource implements TicketSource {
     if (!draft.body.trim()) throw new Error('database ticket create: body must be nonblank')
     const state = options.state ?? this.createState
     this.assertState(state)
-    return this.sql.begin(async (tx) => {
+    return this.retry.tx(this.sql, async (q) => {
       if (options.idempotencyKey !== undefined) {
-        const adopted: Row[] = await tx`SELECT * FROM ab_tickets
+        const adopted: Row[] = await q`SELECT * FROM ab_tickets
           WHERE team = ${this.team} AND creation_key = ${options.idempotencyKey} FOR UPDATE`
-        if (adopted[0]) return this.record(tx, adopted[0])
+        if (adopted[0]) return this.record(q, adopted[0])
       }
       for (const blocker of draft.blockedBy ?? []) {
-        await this.require(tx, blocker, 'create blocker')
+        await this.require(q, blocker, 'create blocker')
       }
       const id = `ticket-${crypto.randomUUID()}`
       const now = new Date().toISOString()
-      const inserted: Row[] = await tx`INSERT INTO ab_tickets
+      const inserted: Row[] = await q`INSERT INTO ab_tickets
         (team, id, creation_key, title, body, state, labels, created_at, updated_at)
         VALUES (${this.team}, ${id}, ${options.idempotencyKey ?? null}, ${draft.title}, ${draft.body},
-          ${state}, ${tx.array(draft.labels ?? [], 'text')}, ${now}, ${now})
+          ${state}, ${q.array(draft.labels ?? [], 'text')}, ${now}, ${now})
         ON CONFLICT (team, creation_key) DO NOTHING RETURNING *`
       let row = inserted[0]
       if (!row && options.idempotencyKey !== undefined) {
-        const adopted: Row[] = await tx`SELECT * FROM ab_tickets
+        const adopted: Row[] = await q`SELECT * FROM ab_tickets
           WHERE team = ${this.team} AND creation_key = ${options.idempotencyKey} FOR UPDATE`
         row = adopted[0]
       }
@@ -220,57 +240,66 @@ export class PostgresTicketSource implements TicketSource {
         for (const blocker of [...new Set(draft.blockedBy ?? [])]) {
           if (blocker === id)
             throw new Error(`database ticket source: ticket "${id}" cannot block itself`)
-          await tx`INSERT INTO ab_ticket_blockers (team, ticket_id, blocker_id)
+          await q`INSERT INTO ab_ticket_blockers (team, ticket_id, blocker_id)
             VALUES (${this.team}, ${id}, ${blocker}) ON CONFLICT DO NOTHING`
         }
       }
-      return this.record(tx, row)
+      return this.record(q, row)
     })
   }
 
   async update(id: string, patch: TicketUpdate): Promise<void> {
     const validated = validateTicketUpdate(patch)
-    await this.sql.begin(async (tx) => {
-      const row = await this.require(tx, id, 'update', true)
-      await tx`UPDATE ab_tickets SET
+    await this.retry.tx(this.sql, async (q) => {
+      const row = await this.require(q, id, 'update', true)
+      await q`UPDATE ab_tickets SET
         title = ${validated.title ?? String(row.title)},
         body = ${validated.body ?? String(row.body)},
-        labels = ${tx.array(validated.labels ?? strings(row.labels), 'text')},
+        labels = ${q.array(validated.labels ?? strings(row.labels), 'text')},
         updated_at = ${new Date().toISOString()}
         WHERE team = ${this.team} AND id = ${id}`
     })
   }
 
   async addBlocker(id: string, blockerId: string): Promise<void> {
-    await this.sql.begin(async (tx) => {
-      await this.require(tx, id, 'addBlocker', true)
+    await this.retry.tx(this.sql, async (q) => {
+      await this.require(q, id, 'addBlocker', true)
       if (id === blockerId)
         throw new Error(`database ticket source: ticket "${id}" cannot block itself`)
-      await this.require(tx, blockerId, 'addBlocker')
-      await tx`INSERT INTO ab_ticket_blockers (team, ticket_id, blocker_id)
+      await this.require(q, blockerId, 'addBlocker')
+      await q`INSERT INTO ab_ticket_blockers (team, ticket_id, blocker_id)
         VALUES (${this.team}, ${id}, ${blockerId}) ON CONFLICT DO NOTHING`
     })
   }
 
   async removeBlocker(id: string, blockerId: string): Promise<void> {
-    await this.require(this.sql, id, 'removeBlocker')
-    await this.sql`DELETE FROM ab_ticket_blockers
-      WHERE team = ${this.team} AND ticket_id = ${id} AND blocker_id = ${blockerId}`
+    // Require + DELETE are one coherent body on a pinned connection: the
+    // require's `SELECT *` is a migration-poisonable plan, and the pair must
+    // re-run together on the retry.
+    await this.retry.run(this.sql, async (q) => {
+      await this.require(q, id, 'removeBlocker')
+      await q`DELETE FROM ab_ticket_blockers
+        WHERE team = ${this.team} AND ticket_id = ${id} AND blocker_id = ${blockerId}`
+    })
   }
 
   async dependencyStates(ids: string[]): Promise<DependencyState[]> {
     return Promise.all(
-      ids.map(async (id) => {
-        const rows: Row[] = await this.sql`SELECT state FROM ab_tickets
-        WHERE team = ${this.team} AND id = ${id}`
-        if (!rows[0]) return { id, exists: false, resolved: false, blockedBy: [] }
-        return {
-          id,
-          exists: true,
-          resolved: String(rows[0].state) === this.lifecycle.done,
-          blockedBy: await this.blockers(this.sql, id),
-        }
-      }),
+      ids.map((id) =>
+        // One run per id keeps each id's state read + blockers query
+        // sequential on one pinned connection; the ids stay concurrent.
+        this.retry.run(this.sql, async (q) => {
+          const rows: Row[] = await q`SELECT state FROM ab_tickets
+          WHERE team = ${this.team} AND id = ${id}`
+          if (!rows[0]) return { id, exists: false, resolved: false, blockedBy: [] }
+          return {
+            id,
+            exists: true,
+            resolved: String(rows[0].state) === this.lifecycle.done,
+            blockedBy: await this.blockers(q, id),
+          }
+        }),
+      ),
     )
   }
 }

package/src/blobs.test.ts

@@ -1,121 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { GetObjectCommand, PutObjectCommand } from '@aws-sdk/client-s3'
-import { describeBlobStoreContract } from '@defrex/autobuild/plugin-sdk'
-import { Buffer } from 'node:buffer'
-import { S3BlobStore } from './s3'
-import { VercelBlobStore } from './vercel'
-
-function s3Harness(): S3BlobStore {
-  const data = new Map<string, Uint8Array>()
-  const client = {
-    async send(command: unknown): Promise<unknown> {
-      if (command instanceof PutObjectCommand) {
-        data.set(String(command.input.Key), new Uint8Array(command.input.Body as Uint8Array))
-        return {}
-      }
-      if (command instanceof GetObjectCommand) {
-        const value = data.get(String(command.input.Key))
-        if (!value) {
-          const error = new Error('not found') as Error & { $metadata: { httpStatusCode: number } }
-          error.$metadata = { httpStatusCode: 404 }
-          throw error
-        }
-        return { Body: { transformToByteArray: async () => value.slice() } }
-      }
-      throw new Error('unexpected command')
-    },
-  }
-  return new S3BlobStore({ client: client as never, bucket: 'builds', prefix: '/ab//blobs/' })
-}
-
-function vercelHarness(): VercelBlobStore {
-  const data = new Map<string, Uint8Array>()
-  return new VercelBlobStore({
-    access: 'private',
-    prefix: 'ab/blobs',
-    put: (async (pathname: string, body: unknown) => {
-      if (!Buffer.isBuffer(body)) throw new TypeError('Vercel PutBody must be a Buffer')
-      data.set(pathname, Uint8Array.from(body))
-      return {
-        url: pathname,
-        downloadUrl: pathname,
-        pathname,
-        contentType: 'application/octet-stream',
-        contentDisposition: '',
-        size: 0,
-        uploadedAt: new Date(),
-      }
-    }) as never,
-    get: (async (pathname: string) => {
-      const value = data.get(pathname)
-      if (!value) return null
-      return {
-        statusCode: 200,
-        stream: new Blob([Uint8Array.from(value)]).stream(),
-        headers: new Headers(),
-        blob: {
-          url: pathname,
-          downloadUrl: pathname,
-          pathname,
-          contentType: 'application/octet-stream',
-          contentDisposition: '',
-          size: value.length,
-          uploadedAt: new Date(),
-          etag: 'x',
-          cacheControl: 'public',
-        },
-      }
-    }) as never,
-  })
-}
-
-describeBlobStoreContract('S3-compatible', async () => ({ blobs: s3Harness() }))
-describeBlobStoreContract('Vercel Blob', async () => ({ blobs: vercelHarness() }))
-
-describe('provider request mapping', () => {
-  test('S3 uses the configured bucket and normalized deterministic key', async () => {
-    let seen: PutObjectCommand | undefined
-    const blobs = new S3BlobStore({
-      bucket: 'bucket',
-      prefix: '//prefix//',
-      client: {
-        send: async (command: unknown) => {
-          seen = command as PutObjectCommand
-          return {}
-        },
-      } as never,
-    })
-    await blobs.put('abc', new Uint8Array([1]))
-    expect(seen?.input).toMatchObject({ Bucket: 'bucket', Key: 'prefix/abc' })
-  })
-
-  test('Vercel uploads binary bytes as a supported Buffer with deterministic options', async () => {
-    let pathname: string | undefined
-    let body: Buffer | undefined
-    let options: Record<string, unknown> | undefined
-    const blobs = new VercelBlobStore({
-      access: 'public',
-      prefix: '//prefix//',
-      token: 'secret',
-      put: (async (seenPath: string, seenBody: unknown, opts: Record<string, unknown>) => {
-        if (!Buffer.isBuffer(seenBody)) throw new TypeError('Vercel PutBody must be a Buffer')
-        pathname = seenPath
-        body = seenBody
-        options = opts
-        return {}
-      }) as never,
-      get: (async () => null) as never,
-    })
-    const bytes = new Uint8Array([0x00, 0x80, 0xff, 0x41])
-    await blobs.put('abc', bytes)
-    expect(pathname).toBe('prefix/abc')
-    expect(Buffer.isBuffer(body)).toBe(true)
-    expect([...body!]).toEqual([...bytes])
-    expect(options).toMatchObject({
-      access: 'public',
-      token: 'secret',
-      addRandomSuffix: false,
-      allowOverwrite: true,
-    })
-  })
-})

package/src/config.test.ts

@@ -1,174 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { parsePostgresStoreEnv } from './config'
-
-const base = { AB_POSTGRES_URL: 'postgres://db/app' }
-
-describe('PostgreSQL store environment', () => {
-  test('parses explicit S3-compatible configuration', () => {
-    expect(
-      parsePostgresStoreEnv({
-        ...base,
-        AB_BLOB_BACKEND: 's3',
-        AB_S3_BUCKET: 'bucket',
-        AB_S3_REGION: 'region',
-        AB_S3_ENDPOINT: 'https://objects.example',
-        AB_S3_ACCESS_KEY_ID: 'key',
-        AB_S3_SECRET_ACCESS_KEY: 'secret',
-        AB_S3_SESSION_TOKEN: 'session',
-        AB_S3_FORCE_PATH_STYLE: 'true',
-        AB_BLOB_PREFIX: '/builds/',
-      }),
-    ).toEqual({
-      url: 'postgres://db/app',
-      backend: 's3',
-      bucket: 'bucket',
-      region: 'region',
-      endpoint: 'https://objects.example',
-      accessKeyId: 'key',
-      secretAccessKey: 'secret',
-      sessionToken: 'session',
-      forcePathStyle: true,
-      prefix: '/builds/',
-    })
-  })
-
-  test('supports token and complete OIDC Vercel authentication', () => {
-    expect(
-      parsePostgresStoreEnv({
-        ...base,
-        AB_BLOB_BACKEND: 'vercel',
-        AB_VERCEL_BLOB_ACCESS: 'private',
-        BLOB_READ_WRITE_TOKEN: 'rw',
-      }),
-    ).toMatchObject({ backend: 'vercel', access: 'private', token: 'rw' })
-    expect(
-      parsePostgresStoreEnv({
-        ...base,
-        AB_BLOB_BACKEND: 'vercel',
-        AB_VERCEL_BLOB_ACCESS: 'public',
-        VERCEL_OIDC_TOKEN: 'oidc',
-        BLOB_STORE_ID: 'store',
-      }),
-    ).toMatchObject({ backend: 'vercel', access: 'public', oidcToken: 'oidc', storeId: 'store' })
-  })
-
-  test('rejects missing, malformed, and incomplete values', () => {
-    expect(() => parsePostgresStoreEnv({ AB_BLOB_BACKEND: 's3' })).toThrow('AB_POSTGRES_URL')
-    expect(() => parsePostgresStoreEnv({ ...base, AB_BLOB_BACKEND: 'other' })).toThrow('s3')
-    expect(() =>
-      parsePostgresStoreEnv({
-        ...base,
-        AB_BLOB_BACKEND: 's3',
-        AB_S3_BUCKET: 'b',
-        AB_S3_REGION: 'r',
-        AB_S3_ACCESS_KEY_ID: 'k',
-        AB_S3_SECRET_ACCESS_KEY: 's',
-        AB_S3_FORCE_PATH_STYLE: 'yes',
-      }),
-    ).toThrow('true')
-    expect(() =>
-      parsePostgresStoreEnv({
-        ...base,
-        AB_BLOB_BACKEND: 'vercel',
-        AB_VERCEL_BLOB_ACCESS: 'private',
-        VERCEL_OIDC_TOKEN: 'only',
-      }),
-    ).toThrow('BLOB_STORE_ID')
-  })
-
-  test('accepts the conventional DATABASE_URL but never ambient AWS credentials', () => {
-    expect(
-      parsePostgresStoreEnv({
-        DATABASE_URL: 'postgres://ambient',
-        AB_BLOB_BACKEND: 'vercel',
-        AB_VERCEL_BLOB_ACCESS: 'private',
-        BLOB_READ_WRITE_TOKEN: 'token',
-      }).url,
-    ).toBe('postgres://ambient')
-    expect(
-      parsePostgresStoreEnv({
-        ...base,
-        DATABASE_URL: 'postgres://ambient',
-        AB_BLOB_BACKEND: 'vercel',
-        AB_VERCEL_BLOB_ACCESS: 'private',
-        BLOB_READ_WRITE_TOKEN: 'token',
-      }).url,
-    ).toBe('postgres://db/app')
-    expect(() =>
-      parsePostgresStoreEnv({
-        DATABASE_URL: 'postgres://ambient',
-        AB_BLOB_BACKEND: 's3',
-        AB_S3_BUCKET: 'b',
-        AB_S3_REGION: 'r',
-        AWS_ACCESS_KEY_ID: 'ambient',
-        AWS_SECRET_ACCESS_KEY: 'ambient',
-      }),
-    ).toThrow('AB_S3_ACCESS_KEY_ID')
-    expect(() => parsePostgresStoreEnv({ AB_BLOB_BACKEND: 's3' })).toThrow(
-      'AB_POSTGRES_URL or DATABASE_URL',
-    )
-  })
-
-  test('AB_ARTIFACT_RETENTION_MAX_REVISIONS: absent means default, valid flows through, invalid rejected', () => {
-    // Absent ⇒ no retention override; the store's documented default applies.
-    expect(
-      parsePostgresStoreEnv({
-        ...base,
-        AB_BLOB_BACKEND: 'vercel',
-        AB_VERCEL_BLOB_ACCESS: 'private',
-        BLOB_READ_WRITE_TOKEN: 'rw',
-      }).retention,
-    ).toBeUndefined()
-
-    // A valid value flows through to the retention option on either backend.
-    expect(
-      parsePostgresStoreEnv({
-        ...base,
-        AB_BLOB_BACKEND: 's3',
-        AB_S3_BUCKET: 'bucket',
-        AB_S3_REGION: 'region',
-        AB_S3_ACCESS_KEY_ID: 'key',
-        AB_S3_SECRET_ACCESS_KEY: 'secret',
-        AB_ARTIFACT_RETENTION_MAX_REVISIONS: ' 50 ',
-      }).retention,
-    ).toEqual({ maxRevisions: 50 })
-    expect(
-      parsePostgresStoreEnv({
-        ...base,
-        AB_BLOB_BACKEND: 'vercel',
-        AB_VERCEL_BLOB_ACCESS: 'private',
-        BLOB_READ_WRITE_TOKEN: 'rw',
-        AB_ARTIFACT_RETENTION_MAX_REVISIONS: '1',
-      }).retention,
-    ).toEqual({ maxRevisions: 1 })
-
-    // Non-integer, zero, and negative values are rejected with the variable named.
-    // (A blank value is treated as absent, matching this file's optional() convention.)
-    for (const bad of ['zero', '0', '-5', '2.5']) {
-      expect(() =>
-        parsePostgresStoreEnv({
-          ...base,
-          AB_BLOB_BACKEND: 'vercel',
-          AB_VERCEL_BLOB_ACCESS: 'private',
-          BLOB_READ_WRITE_TOKEN: 'rw',
-          AB_ARTIFACT_RETENTION_MAX_REVISIONS: bad,
-        }),
-      ).toThrow('AB_ARTIFACT_RETENTION_MAX_REVISIONS')
-    }
-  })
-
-  test('root full-stack manifest has no blob provider SDK dependency', async () => {
-    const manifest = (await Bun.file('package.json').json()) as {
-      dependencies?: Record<string, string>
-    }
-    const names = Object.keys(manifest.dependencies ?? {})
-    expect(names).not.toContain('@aws-sdk/client-s3')
-    expect(names).not.toContain('@vercel/blob')
-    expect(names).not.toContain('pg')
-    expect(names).not.toContain('postgres')
-    const hosted = (await Bun.file('packages/hosted-store-service/package.json').json()) as {
-      dependencies?: Record<string, string>
-    }
-    expect(hosted.dependencies?.pg).toBe('8.18.0')
-  })
-})

package/src/env.test.ts

@@ -1,48 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { describePostgresTarget, MISSING_POSTGRES_URL_MESSAGE, resolvePostgresUrl } from './env'
-
-describe('PostgreSQL URL resolution', () => {
-  test('prefers the explicit Autobuild variable', () => {
-    expect(
-      resolvePostgresUrl({
-        AB_POSTGRES_URL: ' postgres://explicit ',
-        DATABASE_URL: 'postgres://ambient',
-      }),
-    ).toBe('postgres://explicit')
-  })
-
-  test('falls back to the conventional DATABASE_URL', () => {
-    expect(resolvePostgresUrl({ DATABASE_URL: 'postgres://ambient' })).toBe('postgres://ambient')
-    expect(resolvePostgresUrl({ AB_POSTGRES_URL: '  ', DATABASE_URL: 'postgres://ambient' })).toBe(
-      'postgres://ambient',
-    )
-  })
-
-  test('names both variables when neither is set', () => {
-    expect(() => resolvePostgresUrl({})).toThrow(MISSING_POSTGRES_URL_MESSAGE)
-    expect(() =>
-      resolvePostgresUrl({
-        AB_POSTGRES_URL: '',
-        DATABASE_URL_UNPOOLED: 'postgres://direct',
-        POSTGRES_URL: 'postgres://legacy',
-      }),
-    ).toThrow(MISSING_POSTGRES_URL_MESSAGE)
-  })
-})
-
-describe('PostgreSQL target description', () => {
-  test('names the host and database without credentials', () => {
-    expect(
-      describePostgresTarget(
-        'postgresql://neondb_owner:hunter2@ep-example-pooler.neon.tech/neondb?sslmode=require',
-      ),
-    ).toBe('ep-example-pooler.neon.tech/neondb')
-    expect(describePostgresTarget('postgres://user:secret@db.internal:6432')).toBe(
-      'db.internal:6432',
-    )
-  })
-
-  test('never echoes an unparsable value', () => {
-    expect(describePostgresTarget('not a url with secret')).toBe('the configured database')
-  })
-})

package/src/event-wait-poll-ms.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { EVENT_WAIT_POLL_MS as fromAdapter } from '@defrex/autobuild/store-adapter'
-import { EVENT_WAIT_POLL_MS as fromStore } from './store'
-
-describe('EVENT_WAIT_POLL_MS unification (AUT-388)', () => {
-  const source = readFileSync(join(import.meta.dir, 'store.ts'), 'utf8')
-
-  test('store.ts does not redefine the constant (AUT-388)', () => {
-    expect(source).not.toMatch(/const\s+EVENT_WAIT_POLL_MS\s*=/)
-  })
-
-  test('store.ts imports the core constant via @defrex/autobuild/store-adapter', () => {
-    expect(source).toMatch(
-      /import\s*\{[^}]*\bEVENT_WAIT_POLL_MS\b[^}]*\}\s*from\s*'@defrex\/autobuild\/store-adapter'/s,
-    )
-  })
-
-  test('the postgres-store export is the core binding, not a copy', () => {
-    expect(fromStore).toBe(fromAdapter)
-  })
-})