@sixb/pg 0.1.16 → 0.1.17

package/src/ontology-storage/shared.ts

@@ -1,6 +1,7 @@
 import { parseSixbFailure } from "@sixb/core/internal/errors"
 import { MaterializationConflictError } from "@sixb/core/internal/materialization"
 import {
+  type ClaimedOutboxDraft,
   sourceAssertionFromColumns,
   sourceEntityFromKey,
 } from "@sixb/core/internal/ontology-storage-provider"
@@ -8,7 +9,6 @@ import type {
   AssertSourceMaterializationExecutionInput,
   OntologyCommitRecord,
   OntologyCommitWrite,
-  OntologyOutboxRecord,
   OntologySourceRecord,
   StageSourceAssertion,
 } from "@sixb/core/storage"
@@ -42,8 +42,6 @@ export interface PgOntologyCommitRow {
   readonly origin_run_id: string | null
   readonly origin_batch_ordinal: number | string | null
   readonly origin: unknown
-  readonly requested_by: unknown | null
-  readonly executor: unknown
   readonly ontology_revision: string
   readonly projection_revision: string | null
   readonly ownership_hash: string | null
@@ -104,7 +102,10 @@ export interface PgStoredOverrideRow {
 }
 
 export interface PgOntologyOutboxRow {
-  readonly envelope: unknown
+  readonly id: string
+  readonly commit_id: string
+  readonly commit_ordinal: number | string
+  readonly event: unknown
   readonly available_at: Date | string
   readonly attempts: number | string
   readonly lease_id: string | null
@@ -194,14 +195,6 @@ export function commitRecord(row: PgOntologyCommitRow): OntologyCommitRecord {
     requestHash: row.request_hash,
     executionId: row.execution_id,
     origin: structuredClone(row.origin) as OntologyCommitWrite["origin"],
-    ...(row.requested_by === null
-      ? {}
-      : {
-          requestedBy: structuredClone(row.requested_by) as NonNullable<
-            OntologyCommitWrite["requestedBy"]
-          >,
-        }),
-    executor: structuredClone(row.executor) as OntologyCommitWrite["executor"],
     ontologyRevision: row.ontology_revision,
     ...(row.projection_revision === null ? {} : { projectionRevision: row.projection_revision }),
     ...(row.ownership_hash === null ? {} : { ownershipHash: row.ownership_hash }),
@@ -212,13 +205,23 @@ export function commitRecord(row: PgOntologyCommitRow): OntologyCommitRecord {
   return { ...base, intent, result } as OntologyCommitRecord
 }
 
-export function outboxRecord(row: PgOntologyOutboxRow): OntologyOutboxRecord {
+/** A claimed row as stored: its draft, to rebuild from its commit. */
+export function claimedOutboxDraft(row: PgOntologyOutboxRow): ClaimedOutboxDraft {
+  if (row.lease_id === null || row.lease_expires_at === null) {
+    throw new MaterializationConflictError(
+      "outbox-lease",
+      "Ontology outbox claim returned an unpaired lease."
+    )
+  }
   return {
-    envelope: structuredClone(row.envelope) as OntologyOutboxRecord["envelope"],
+    id: row.id,
+    commitId: row.commit_id,
+    commitOrdinal: databaseSafeInteger(row.commit_ordinal, "Ontology outbox commit ordinal"),
+    event: structuredClone(row.event) as ClaimedOutboxDraft["event"],
     availableAt: toIsoString(row.available_at),
     attempts: databaseSafeInteger(row.attempts, "Ontology outbox attempts"),
     leaseId: row.lease_id,
-    leaseExpiresAt: optionalIsoString(row.lease_expires_at),
+    leaseExpiresAt: toIsoString(row.lease_expires_at),
     publishedAt: optionalIsoString(row.published_at),
     lastFailure:
       row.last_failure === null
@@ -301,3 +304,12 @@ export async function assertProjectionExecution(
 export function ontologyLockKey(kind: string, ...parts: readonly string[]): string {
   return `ontology:${kind}:${JSON.stringify(parts)}`
 }
+
+export function jsonTupleExpression(parts: readonly string[]): string {
+  return `concat('[', ${parts.join(", ',', ")}, ']')`
+}
+
+/** The canonical JSON key of a row's identity columns, as `objectRefKey`/`linkRefKey` render it. */
+export function columnKeyExpression(columns: readonly string[]): string {
+  return jsonTupleExpression(columns.map((column) => `to_jsonb(${column})::text`))
+}

package/src/ontology-storage/source-cleanup.ts

@@ -5,6 +5,11 @@ import type {
 } from "@sixb/core/storage"
 import type { SQLClient } from "../pg-client"
 
+/** A version outlives its replacement plan, which references it. */
+const PLAN_PURGED = `NOT EXISTS (
+  SELECT 1 FROM ontology_replacement_plans AS plans WHERE plans.version_id = versions.version_id
+)`
+
 /**
  * Superseded versions can still hold live roots (a delta keeps unchanged roots where they were),
  * so they are cleaned root by root once retired. An abandoned candidate was never published:
@@ -19,8 +24,8 @@ export async function purgeAbandonedSourceVersions(
   let materializationsDeleted = 0
   while (remaining > 0) {
     const [candidate] = await sql<{ readonly version_id: string }[]>`
-      SELECT version_id FROM ontology_sources
-      WHERE project_id = ${input.projectId} AND status = 'abandoned'
+      SELECT version_id FROM ontology_sources AS versions
+      WHERE project_id = ${input.projectId} AND status = 'abandoned' AND ${sql.unsafe(PLAN_PURGED)}
       ORDER BY terminal_at, source_id, materialization_id
       LIMIT 1 FOR UPDATE SKIP LOCKED
     `
@@ -75,7 +80,8 @@ export async function cleanupSourceVersions(
   let rowsDeleted = removedRows.length
   remaining -= rowsDeleted
   if (remaining > 0) {
-    const removed = await sql`
+    // Each version's root_count follows its roots down, so a drained version is found by index.
+    const [removed] = await sql<{ readonly count: number }[]>`
       WITH selected AS (
         SELECT roots.ctid FROM ontology_source_roots AS roots
         JOIN ontology_sources AS versions ON versions.version_id = roots.version_id
@@ -83,10 +89,18 @@ export async function cleanupSourceVersions(
           AND NOT EXISTS (SELECT 1 FROM ontology_source_rows AS rows WHERE rows.root_id = roots.id)
         ORDER BY roots.retired_at, roots.id
         LIMIT ${remaining} FOR UPDATE OF roots SKIP LOCKED
-      ) DELETE FROM ontology_source_roots AS roots USING selected WHERE roots.ctid = selected.ctid RETURNING 1
+      ), removed AS (
+        DELETE FROM ontology_source_roots AS roots USING selected WHERE roots.ctid = selected.ctid
+        RETURNING roots.version_id
+      ), drained AS (
+        UPDATE ontology_sources AS versions SET root_count = versions.root_count - counts.count
+        FROM (SELECT version_id, count(*)::int AS count FROM removed GROUP BY version_id) AS counts
+        WHERE versions.version_id = counts.version_id
+        RETURNING counts.count
+      ) SELECT COALESCE(sum(count), 0)::int AS count FROM drained
     `
-    rowsDeleted += removed.length
-    remaining -= removed.length
+    rowsDeleted += removed?.count ?? 0
+    remaining -= removed?.count ?? 0
   }
   const removedManifests =
     remaining === 0
@@ -94,10 +108,8 @@ export async function cleanupSourceVersions(
       : await sql`
     WITH selected AS (
       SELECT versions.ctid FROM ontology_sources AS versions
-      WHERE project_id = ${input.projectId} AND status = 'superseded'
-        AND terminal_at < ${input.terminalBefore}
-        AND NOT EXISTS (SELECT 1 FROM ontology_source_roots AS roots
-          WHERE roots.version_id = versions.version_id)
+      WHERE project_id = ${input.projectId} AND status = 'superseded' AND root_count = 0
+        AND terminal_at < ${input.terminalBefore} AND ${sql.unsafe(PLAN_PURGED)}
       ORDER BY terminal_at, source_id, materialization_id LIMIT ${remaining} FOR UPDATE SKIP LOCKED
     ) DELETE FROM ontology_sources AS versions USING selected WHERE versions.ctid = selected.ctid RETURNING 1
   `

package/src/ontology-storage/source-roots.ts

@@ -11,7 +11,7 @@ import {
 import type { SourceActivationWrite, StageSourceRowsInput } from "@sixb/core/storage"
 import type { SQLClient } from "../pg-client"
 import type { PgOntologySourceAssertionRow } from "./shared"
-import { jsonParameter, type PgOntologySourceRow } from "./shared"
+import { columnKeyExpression, jsonParameter, type PgOntologySourceRow } from "./shared"
 
 /**
  * Source storage in three levels: a version (`ontology_sources`, one per run), its roots (one per
@@ -22,7 +22,7 @@ import { jsonParameter, type PgOntologySourceRow } from "./shared"
  * version; the candidate's own roots are never rewritten. One live root per source and key holds
  * because activation, under the source fence, retires every root the candidate replaces.
  */
-const PUBLISHED = "('active', 'superseded')"
+export const PUBLISHED = "('active', 'superseded')"
 
 /** The columns `sourceAssertion` reads, over `versions`, `roots` and `rows`. */
 export function sourceAssertionColumns(sql: SQLClient) {
@@ -178,7 +178,10 @@ export async function stageSourceRoots(
     )
 }
 
-/** Retires what the candidate replaces; its own roots go live when its version turns active. */
+/**
+ * Retires what the candidate replaces; its own roots go live when its version turns active. Every
+ * link those roots assert changes its live source, which the commit records as touched.
+ */
 export async function activateSourceRoots(
   sql: SQLClient,
   projectId: string,
@@ -199,19 +202,43 @@ export async function activateSourceRoots(
     AND versions.version_id = roots.version_id AND versions.project_id = ${projectId}
     AND versions.source_id = ${activation.source.projectionId}
     AND versions.status IN ${sql.unsafe(PUBLISHED)}`
-  if (candidate.base_materialization_id === null) {
-    await sql`
+  const retired =
+    candidate.base_materialization_id === null
+      ? sql`
       UPDATE ontology_source_roots AS roots SET retired_at = ${activation.updatedAt}
       FROM ontology_sources AS versions WHERE ${live}
+      RETURNING roots.id
     `
-  } else {
-    await sql`
+      : sql`
       UPDATE ontology_source_roots AS roots SET retired_at = ${activation.updatedAt}
       FROM ontology_source_roots AS changed, ontology_sources AS versions
       WHERE changed.version_id = ${candidate.version_id} AND roots.project_id = ${projectId}
         AND roots.root_key = changed.root_key AND ${live}
+      RETURNING roots.id
     `
-  }
+  await sql`
+    WITH retired AS (${retired}), changed AS (
+      SELECT id FROM retired
+      UNION ALL
+      SELECT id FROM ontology_source_roots WHERE version_id = ${candidate.version_id}
+    )
+    INSERT INTO ontology_commit_touches (project_id, entity_kind, identity_key)
+    SELECT DISTINCT ${projectId}, 'link', ${sql.unsafe(
+      columnKeyExpression([
+        "rows.source_type_id",
+        "rows.source_primary_id",
+        "rows.link_id",
+        "rows.target_type_id",
+        "rows.target_primary_id",
+      ])
+    )}
+    FROM changed
+    CROSS JOIN LATERAL (
+      SELECT * FROM ontology_source_rows AS rows
+      WHERE rows.root_id = changed.id AND rows.entity_kind = 'link'
+      OFFSET 0
+    ) AS rows
+  `
   // Deletions are never live; retiring them lets cleanup remove them with their version.
   await sql`
     UPDATE ontology_source_roots SET retired_at = ${activation.updatedAt}

package/src/ontology-storage/sources.ts

@@ -32,8 +32,6 @@ import type {
   PurgeAbandonedSourceMaterializationsInput,
   StageSourceRowsInput,
   StageSourceRowsResult,
-  SummarizeTerminalSourceMaterializationsInput,
-  TerminalSourceMaterializationSummary,
 } from "@sixb/core/storage"
 import type { SQLClient } from "../pg-client"
 import { lockAdvisoryKeys } from "../transactions"
@@ -307,29 +305,6 @@ export class PgOntologySourceStorage implements OntologySourceStorage {
     })
   }
 
-  async summarizeTerminal(
-    input: SummarizeTerminalSourceMaterializationsInput
-  ): Promise<TerminalSourceMaterializationSummary> {
-    return this.runRootOperation(async (sql) => {
-      assertNonblank(input.projectId, "Terminal source summary project id")
-      const [summary] = await sql<
-        {
-          readonly terminal_count: number
-          readonly oldest_terminal_at: Date | string | null
-        }[]
-      >`
-        SELECT COUNT(*)::int AS terminal_count, MIN(terminal_at) AS oldest_terminal_at
-        FROM ontology_sources
-        WHERE project_id = ${input.projectId}
-          AND status IN ('superseded', 'abandoned')
-      `
-      return {
-        count: summary?.terminal_count ?? 0,
-        oldestTerminalAt: toOptionalIsoString(summary?.oldest_terminal_at),
-      }
-    })
-  }
-
   private async abandonCandidate(
     sql: SQLClient,
     input: AbandonSourceMaterializationCandidateInput
@@ -642,11 +617,6 @@ export class PgOntologySourceStorage implements OntologySourceStorage {
   }
 }
 
-function toOptionalIsoString(value: Date | string | null | undefined): string | null {
-  if (value === null || value === undefined) return null
-  return value instanceof Date ? value.toISOString() : new Date(value).toISOString()
-}
-
 function numberOrNull(value: number | string | null): number | null {
   return value === null ? null : Number(value)
 }

package/src/pg-ai-cost-storage.ts

@@ -111,6 +111,7 @@ export class PgAiCostStorage implements AiCostStorage {
           usage.cache_write_input_tokens,
           usage.text_output_tokens,
           usage.reasoning_output_tokens,
+          usage.audio_duration_ms,
           usage.reporting_status,
           CASE
             WHEN direct_agent.kind = 'conversation' THEN 'agent'
@@ -204,6 +205,8 @@ export class PgAiCostStorage implements AiCostStorage {
         SUM(text_output_tokens)::text AS text_output_tokens_sum,
         COUNT(reasoning_output_tokens)::text AS reasoning_output_tokens_count,
         SUM(reasoning_output_tokens)::text AS reasoning_output_tokens_sum,
+        COUNT(audio_duration_ms)::text AS audio_duration_ms_count,
+        SUM(audio_duration_ms)::text AS audio_duration_ms_sum,
         COUNT(*) FILTER (WHERE valuation_status = 'rated')::text AS rated_call_count,
         COUNT(*) FILTER (WHERE valuation_status = 'unpriceable')::text
           AS unpriceable_call_count,
@@ -331,6 +334,7 @@ interface UsageRow {
   readonly call_id: string
   readonly provider_id: string
   readonly requested_model_id: string
+  readonly model_kind: AiModelCallUsageRecord["modelKind"] | null
   readonly requested_reasoning: string | Record<string, unknown> | null
   readonly response_model_id: string | null
   readonly response_id: string
@@ -342,6 +346,7 @@ interface UsageRow {
   readonly cache_write_input_tokens: number | string | null
   readonly text_output_tokens: number | string | null
   readonly reasoning_output_tokens: number | string | null
+  readonly audio_duration_ms: number | string | null
   readonly reporting_status: AiModelCallUsageRecord["usage"]["reportingStatus"]
   readonly raw_usage: ReadonlyJsonObject | string | null
   readonly provider_ids: Record<string, unknown> | string | null
@@ -396,6 +401,8 @@ interface AggregateRow {
   readonly text_output_tokens_sum: string | null
   readonly reasoning_output_tokens_count: string
   readonly reasoning_output_tokens_sum: string | null
+  readonly audio_duration_ms_count: string
+  readonly audio_duration_ms_sum: string | null
   readonly rated_call_count: string
   readonly unpriceable_call_count: string
   readonly unvalued_call_count: string
@@ -478,6 +485,7 @@ function aggregateFragmentFromRow(row: AggregateRow): AiAccountingAggregateFragm
         row.reasoning_output_tokens_count,
         row.reasoning_output_tokens_sum
       ),
+      audioDurationMs: meterFragment(row.audio_duration_ms_count, row.audio_duration_ms_sum),
     },
     costs: {
       ...(row.amount_currency === null || row.amount_nanos === null
@@ -549,6 +557,7 @@ function usageFromRow(row: UsageRow, requesterGroupIds: readonly string[]): AiMo
           ),
         }),
     requestedModelId: row.requested_model_id,
+    ...(row.model_kind === null ? {} : { modelKind: row.model_kind }),
     ...(row.requested_reasoning === null
       ? {}
       : { requestedReasoning: requestedReasoningFromRow(row.requested_reasoning) }),
@@ -575,6 +584,9 @@ function usageFromRow(row: UsageRow, requesterGroupIds: readonly string[]): AiMo
       ...(number(row.reasoning_output_tokens) === undefined
         ? {}
         : { reasoningOutputTokens: number(row.reasoning_output_tokens) }),
+      ...(number(row.audio_duration_ms) === undefined
+        ? {}
+        : { audioDurationMs: number(row.audio_duration_ms) }),
       reportingStatus: row.reporting_status,
     },
     ...(row.raw_usage === null ? {} : { rawUsage: parseJsonObject(row.raw_usage) }),

package/src/pg-ai-limit-storage.ts

@@ -2,6 +2,7 @@ import {
   type AiLimitAccountingEntry,
   AiLimitOperationLock,
   aiLimitAmountKey,
+  aiLimitMeterApplies,
   aiLimitQuantityFromAmount,
   aiLimitReservationBuckets,
   aiLimitReservationRequestKey,
@@ -172,7 +173,12 @@ export class PgAiLimitStorage implements AiLimitStorage {
       const unavailablePolicies: AiLimitPolicyStatus[] = []
       const unavailableReasons = new Set<"missingEstimate" | "incompleteAccounting">()
       for (const policy of enabledPolicies) {
-        if (!subjectKeys.has(aiLimitSubjectKey(policy.subject))) continue
+        if (
+          !subjectKeys.has(aiLimitSubjectKey(policy.subject)) ||
+          !aiLimitMeterApplies(policy.limit.meter, request.modelKind)
+        ) {
+          continue
+        }
         const limit = normalizeAiLimitAmount(policy.limit)
         const estimate = estimates.get(aiLimitAmountKey(limit))
         const status = await this.statusForPolicy(tx, policy, request.period)
@@ -212,7 +218,8 @@ export class PgAiLimitStorage implements AiLimitStorage {
       const buckets = aiLimitReservationBuckets(
         enabledPolicies,
         request.subjects,
-        request.estimates
+        request.estimates,
+        request.modelKind
       )
       if (buckets.length === 0) return { status: "notRequired" }
       for (const bucket of buckets) {
@@ -587,6 +594,7 @@ export class PgAiLimitStorage implements AiLimitStorage {
       SELECT usage.project_id, usage.id AS usage_record_id, usage.execution_id,
              usage.attempt, usage.call_id, usage.occurred_at,
              usage.total_tokens::text AS total_tokens,
+             usage.model_kind,
              executions.requested_by_user_id,
              executions.requested_by_service_account_id,
              valuations.status AS valuation_status,
@@ -632,6 +640,7 @@ export class PgAiLimitStorage implements AiLimitStorage {
       SELECT usage.project_id, usage.id AS usage_record_id, usage.execution_id,
              usage.attempt, usage.call_id, usage.occurred_at,
              usage.total_tokens::text AS total_tokens,
+             usage.model_kind,
              executions.requested_by_user_id,
              executions.requested_by_service_account_id,
              valuations.status AS valuation_status,
@@ -717,6 +726,7 @@ interface AiLimitAccountingRow {
   readonly call_id: string
   readonly occurred_at: Date | string
   readonly total_tokens: string | null
+  readonly model_kind: AiLimitAccountingEntry["modelKind"] | null
   readonly requested_by_user_id: string | null
   readonly requested_by_service_account_id: string | null
   readonly valuation_status: "rated" | "unpriceable" | null
@@ -804,6 +814,7 @@ function accountingEntryFromRow(
     attempt: Number(row.attempt),
     callId: row.call_id,
     occurredAt: new Date(row.occurred_at),
+    ...(row.model_kind === null ? {} : { modelKind: row.model_kind }),
     ...(totalTokens !== undefined && Number.isSafeInteger(totalTokens) ? { totalTokens } : {}),
     requesterGroupIds,
     ...(requester ? { requester } : {}),

package/src/pg-ai-usage-storage.ts

@@ -38,6 +38,7 @@ export class PgAiUsageStorage implements AiUsageStorage {
           provider_id,
           provider_ids,
           requested_model_id,
+          model_kind,
           requested_reasoning,
           response_model_id,
           response_id,
@@ -49,6 +50,7 @@ export class PgAiUsageStorage implements AiUsageStorage {
           cache_write_input_tokens,
           text_output_tokens,
           reasoning_output_tokens,
+          audio_duration_ms,
           reporting_status,
           raw_usage,
           occurred_at,
@@ -62,6 +64,7 @@ export class PgAiUsageStorage implements AiUsageStorage {
           ${record.providerId},
           ${record.providerIds === undefined ? null : JSON.stringify(record.providerIds)}::jsonb,
           ${record.requestedModelId},
+          ${record.modelKind ?? null},
           ${
             record.requestedReasoning === undefined
               ? null
@@ -77,6 +80,7 @@ export class PgAiUsageStorage implements AiUsageStorage {
           ${record.usage.cacheWriteInputTokens ?? null},
           ${record.usage.textOutputTokens ?? null},
           ${record.usage.reasoningOutputTokens ?? null},
+          ${record.usage.audioDurationMs ?? null},
           ${record.usage.reportingStatus},
           ${record.rawUsage === undefined ? null : JSON.stringify(record.rawUsage)}::text::jsonb,
           ${record.occurredAt},
@@ -197,6 +201,7 @@ export class PgAiUsageStorage implements AiUsageStorage {
             ),
           }),
       requestedModelId: row.requested_model_id,
+      ...(row.model_kind === null ? {} : { modelKind: row.model_kind }),
       ...(row.requested_reasoning === null
         ? {}
         : { requestedReasoning: requestedReasoningFromRow(row.requested_reasoning) }),
@@ -257,6 +262,7 @@ interface AiUsageRow {
   readonly provider_id: string
   readonly provider_ids: Record<string, unknown> | string | null
   readonly requested_model_id: string
+  readonly model_kind: AiModelCallUsageRecord["modelKind"] | null
   readonly requested_reasoning: string | Record<string, unknown> | null
   readonly response_model_id: string | null
   readonly response_id: string
@@ -268,6 +274,7 @@ interface AiUsageRow {
   readonly cache_write_input_tokens: number | string | null
   readonly text_output_tokens: number | string | null
   readonly reasoning_output_tokens: number | string | null
+  readonly audio_duration_ms: number | string | null
   readonly reporting_status: AiModelCallUsageRecord["usage"]["reportingStatus"]
   readonly raw_usage: ReadonlyJsonObject | string | null
   readonly occurred_at: Date | string
@@ -311,6 +318,7 @@ function usageFromRow(row: AiUsageRow): AiModelCallUsageInput {
     ...(row.reasoning_output_tokens === null
       ? {}
       : { reasoningOutputTokens: Number(row.reasoning_output_tokens) }),
+    ...(row.audio_duration_ms === null ? {} : { audioDurationMs: Number(row.audio_duration_ms) }),
   }
 }
 

package/src/pg-execution-storage.ts

@@ -87,7 +87,7 @@ export class PgExecutionStorage implements ExecutionStorage {
       if (!created) {
         throw new Error("[SixbPg] Execution insert returned no row.")
       }
-      return executionRecordFromStorageRow(toStorageRow(created))
+      return pgExecutionRecord(created)
     } catch (error) {
       if (isUniqueViolation(error)) {
         throw new ExecutionStorageError(
@@ -109,10 +109,15 @@ export class PgExecutionStorage implements ExecutionStorage {
       FROM executions
       WHERE project_id = ${params.projectId} AND id = ${params.id}
     `
-    return row ? executionRecordFromStorageRow(toStorageRow(row)) : null
+    return row ? pgExecutionRecord(row) : null
   }
 }
 
+/** An `executions` row as its record, for any store that reads executions alongside its own rows. */
+export function pgExecutionRecord(row: PgExecutionRow): ExecutionRecord {
+  return executionRecordFromStorageRow(toStorageRow(row))
+}
+
 function toStorageRow(row: PgExecutionRow): ExecutionStorageRow {
   return {
     projectId: row.project_id,
@@ -141,7 +146,7 @@ function toStorageRow(row: PgExecutionRow): ExecutionStorageRow {
   }
 }
 
-interface PgExecutionRow {
+export interface PgExecutionRow {
   readonly project_id: string
   readonly id: string
   readonly executor_kind: ExecutionStorageRow["executorKind"]

package/src/pg-file-download-grant-storage.ts

@@ -0,0 +1,76 @@
+import { parseFileDownloadGrantRow } from "@sixb/core/internal/storage"
+import type {
+  DeleteExpiredFileDownloadGrantsInput,
+  FileDownloadGrantRecord,
+  FileDownloadGrantStorage,
+  FindFileDownloadGrantInput,
+  RevokeFileDownloadGrantInput,
+} from "@sixb/core/storage"
+import type { PgStoreClient } from "./transactions"
+
+export class PgFileDownloadGrantStorage implements FileDownloadGrantStorage {
+  constructor(private readonly sql: PgStoreClient) {}
+
+  async create(record: FileDownloadGrantRecord): Promise<void> {
+    await this.sql`
+      INSERT INTO file_download_grants (
+        project_id, id, token_hash, file, execution_id, created_at, expires_at
+      ) VALUES (
+        ${record.projectId}, ${record.id}, ${record.tokenHash},
+        ${JSON.stringify(record.file)}::text::jsonb, ${record.executionId},
+        ${record.createdAt}, ${record.expiresAt}
+      )
+    `
+  }
+
+  async findByTokenHash(
+    input: FindFileDownloadGrantInput
+  ): Promise<FileDownloadGrantRecord | null> {
+    const [row] = await this.sql<PgFileDownloadGrantRow[]>`
+      SELECT * FROM file_download_grants
+      WHERE project_id = ${input.projectId} AND token_hash = ${input.tokenHash}
+    `
+    return row ? grantFromRow(row) : null
+  }
+
+  async revoke(input: RevokeFileDownloadGrantInput): Promise<FileDownloadGrantRecord | null> {
+    const [row] = await this.sql<PgFileDownloadGrantRow[]>`
+      UPDATE file_download_grants
+      SET revoked_at = COALESCE(revoked_at, ${input.revokedAt})
+      WHERE project_id = ${input.projectId} AND id = ${input.id}
+      RETURNING *
+    `
+    return row ? grantFromRow(row) : null
+  }
+
+  async deleteExpired(input: DeleteExpiredFileDownloadGrantsInput): Promise<number> {
+    const rows = await this.sql`
+      DELETE FROM file_download_grants
+      WHERE project_id = ${input.projectId} AND id IN (
+        SELECT id FROM file_download_grants
+        WHERE project_id = ${input.projectId} AND expires_at < ${input.expiredBefore}
+        ORDER BY expires_at
+        LIMIT ${input.limit}
+      )
+      RETURNING id
+    `
+    return rows.length
+  }
+}
+
+interface PgFileDownloadGrantRow {
+  readonly [column: string]: unknown
+}
+
+function grantFromRow(row: PgFileDownloadGrantRow): FileDownloadGrantRecord {
+  return parseFileDownloadGrantRow({
+    id: row.id,
+    projectId: row.project_id,
+    tokenHash: row.token_hash,
+    file: row.file,
+    executionId: row.execution_id,
+    createdAt: row.created_at,
+    expiresAt: row.expires_at,
+    revokedAt: row.revoked_at,
+  })
+}

package/src/pg-projection-run-storage.ts

@@ -348,7 +348,7 @@ export class PgProjectionRunStorage implements ProjectionRunStorage {
   async list(input: ListProjectionRunsInput): Promise<ListProjectionRunsResult> {
     assertProjectionRunNonEmpty(input.projectId, "projectId")
 
-    if (input.statuses && input.statuses.length === 0) {
+    if (input.statuses?.length === 0 || input.errorCodes?.length === 0) {
       return { runs: [], hasMore: false, total: 0 }
     }
 
@@ -394,6 +394,11 @@ export class PgProjectionRunStorage implements ProjectionRunStorage {
       whereClauses.push(`status IN (${placeholders.join(", ")})`)
       params.push(...input.statuses)
     }
+    if (input.errorCodes) {
+      const placeholders = input.errorCodes.map(() => `$${index++}`)
+      whereClauses.push(`error->>'code' IN (${placeholders.join(", ")})`)
+      params.push(...input.errorCodes)
+    }
     if (input.startedAfter) {
       whereClauses.push(`COALESCE(started_at, queued_at) >= $${index++}`)
       params.push(input.startedAfter)

package/src/pg-rules-storage.ts

@@ -151,7 +151,11 @@ export class PgRulesStorage implements RulesStorage {
   ): Promise<ListRuleStatesReconciliationPageResult> {
     assertPositiveLimit(input.limit)
     const params: SqlParameter[] = [input.projectId]
-    const cursor = input.after ? "AND (rule_id, object_type_id, primary_id) > ($2, $3, $4)" : ""
+    // The cursor follows the primary key column for column, so the index scan starts at the
+    // cursor instead of at the cursor's rule. `subject_kind` is always 'object' (CHECK).
+    const cursor = input.after
+      ? "AND (rule_id, subject_kind, object_type_id, primary_id) > ($2, 'object', $3, $4)"
+      : ""
     if (input.after) {
       params.push(input.after.ruleId, input.after.objectTypeId, input.after.primaryId)
     }
@@ -161,8 +165,8 @@ export class PgRulesStorage implements RulesStorage {
       `
         SELECT project_id, rule_id, subject_kind, object_type_id, primary_id, triggered_at
         FROM rule_states
-        WHERE project_id = $1 AND subject_kind = 'object' ${cursor}
-        ORDER BY rule_id ASC, object_type_id ASC, primary_id ASC
+        WHERE project_id = $1 ${cursor}
+        ORDER BY rule_id ASC, subject_kind ASC, object_type_id ASC, primary_id ASC
         LIMIT ${limitParameter}
       `,
       params

package/src/transactions.ts

@@ -71,13 +71,15 @@ export async function runPgTransaction<T>(
 }
 
 /**
- * Hold one pool connection for `run`, and hand it back to the pool only while it is still usable.
+ * Hold one pool connection for `run`, or reuse a caller-owned reserved connection.
+ * Hand an owned connection back to the pool only while it is still usable.
  * A connection whose session is gone stays out of the pool, which replaces it on its own.
  */
 export async function withReservedPgConnection<T>(
-  sql: SQL,
+  sql: SQL | ReservedSQL,
   run: (connection: ReservedSQL) => Promise<T>
 ): Promise<T> {
+  if (!("reserve" in sql)) return run(sql)
   const connection = await sql.reserve()
   let usable = true
   try {
@@ -184,7 +186,12 @@ function advisoryLockParts(key: string): readonly [number, number] {
   return [hash.readInt32BE(0), hash.readInt32BE(4)]
 }
 
-function canStartPgTransaction(sql: PgStoreClient): sql is SQL {
+/** Whether `sql` already runs within a transaction, provider-owned or external. */
+export function isWithinPgTransaction(sql: PgStoreClient): boolean {
+  return !canStartPgTransaction(sql)
+}
+
+export function canStartPgTransaction(sql: PgStoreClient): sql is SQL {
   return (
     !pgTransactionClients.has(sql) &&
     typeof (sql as { readonly reserve?: unknown }).reserve === "function"