@triagepilot/db 1.1.0

package/dist/kysely.d.ts

@@ -0,0 +1,202 @@
+import type { ColumnType, Generated, Insertable, Selectable, Updateable } from "kysely";
+import type { ActionStatus, PlatformEventV1, ProviderKind, RepositoryMode, ReviewerReplacementOutcome } from "@triagepilot/contracts";
+type Timestamp = ColumnType<Date, Date | string | undefined, Date | string>;
+type NullableTimestamp = ColumnType<Date | null, Date | string | null | undefined, Date | string | null>;
+type Json = ColumnType<unknown, unknown, unknown>;
+type NullableBigInt = ColumnType<string | null, string | null, string | null>;
+type NullableString = ColumnType<string | null, string | null | undefined, string | null>;
+type HumanReviewPolicyCheckState = "not_started" | "in_progress" | "success" | "failure";
+type InheritanceMode = "legacy" | "defaults" | "organization" | "replace" | "inherit";
+export interface WorkspacesTable {
+    id: Generated<string>;
+    external_key: string;
+    created_at: Timestamp;
+}
+export interface ProviderConnectionsTable {
+    id: Generated<string>;
+    workspace_id: string;
+    provider: ProviderKind;
+    external_connection_id: string;
+    workspace_login: string;
+    account_type: string;
+    status: "active" | "suspended" | "revoked";
+    permissions: Json;
+    created_at: Timestamp;
+    updated_at: Timestamp;
+}
+export interface ProviderConnectionRevocationsTable {
+    workspace_id: string;
+    provider: ProviderKind;
+    external_connection_id: string;
+    revoked_connection_id: Generated<string>;
+    physical_connection_id: string | null;
+    revoked_at: Timestamp;
+    cleanup_completed_at: NullableTimestamp;
+}
+export interface RepositoriesTable {
+    id: Generated<string>;
+    workspace_id: string;
+    provider: ProviderKind;
+    provider_connection_id: string;
+    external_repository_id: string;
+    owner: string;
+    name: string;
+    default_branch: string | null;
+    config_state: string;
+    last_config_mode: Generated<RepositoryMode>;
+    created_at: Timestamp;
+    updated_at: Timestamp;
+}
+export interface WebhookReceiptsTable {
+    id: Generated<string>;
+    workspace_id: string;
+    provider: ProviderKind;
+    delivery_id: string;
+    event_name: string;
+    event_action: string | null;
+    hook_id: string | null;
+    external_connection_id: string | null;
+    payload_summary: Json;
+    created_at: Timestamp;
+}
+export interface JobsTable {
+    id: Generated<string>;
+    workspace_id: string;
+    provider: ProviderKind;
+    provider_connection_id: string;
+    kind: string;
+    status: Generated<"queued" | "running" | "succeeded" | "failed">;
+    payload: Json;
+    idempotency_key: string;
+    attempt_count: Generated<number>;
+    max_attempts: Generated<number>;
+    run_at: Timestamp;
+    locked_at: NullableTimestamp;
+    locked_by: string | null;
+    last_error: string | null;
+    created_at: Timestamp;
+    updated_at: Timestamp;
+}
+export interface RoutingDecisionsTable {
+    id: Generated<string>;
+    workspace_id: string;
+    repository_id: string | null;
+    delivery_id: string;
+    routing_key: string;
+    action: string;
+    risk_score: number;
+    selected_reviewer: string | null;
+    selected_reviewers: ColumnType<unknown, unknown | undefined, unknown>;
+    no_human_reason: string | null;
+    pull_number: number | null;
+    change_request_id: string | null;
+    head_sha: string | null;
+    policy_check_run_id: NullableBigInt;
+    policy_check_state: Generated<HumanReviewPolicyCheckState>;
+    details: Json;
+    mode: Generated<RepositoryMode>;
+    action_status: Generated<ActionStatus>;
+    action_error: string | null;
+    action_applied_at: NullableTimestamp;
+    action_failed_at: NullableTimestamp;
+    organization_config_version: string | null;
+    repository_config_path: string | null;
+    repository_config_revision: string | null;
+    effective_config_hash: string;
+    inheritance_mode: InheritanceMode;
+    config_diagnostics: Json;
+    config_sources: Json;
+    created_at: Timestamp;
+}
+export interface WorkspaceOperationalSettingsTable {
+    workspace_id: string;
+    timezone: Generated<string>;
+    updated_at: Timestamp;
+}
+export interface ReviewerAbsencesTable {
+    id: Generated<string>;
+    workspace_id: string;
+    provider: ProviderKind;
+    provider_connection_id: string;
+    external_actor_id: string;
+    start_at: Timestamp;
+    end_at: Timestamp;
+    status: Generated<"scheduled" | "cancelled">;
+    revision: Generated<number>;
+    cancelled_at: NullableTimestamp;
+    created_at: Timestamp;
+    updated_at: Timestamp;
+}
+export interface ReviewerReplacementsTable {
+    id: Generated<string>;
+    workspace_id: string;
+    provider: ProviderKind;
+    provider_connection_id: string;
+    absence_id: string;
+    absence_revision: number;
+    decision_id: string;
+    unavailable_actor_id: string;
+    replacement_actor_id: NullableString;
+    mutation_intent_id: NullableString;
+    outcome: ReviewerReplacementOutcome;
+    reason: string;
+    state: Generated<string>;
+    last_error: NullableString;
+    started_at: Timestamp;
+    completed_at: Timestamp;
+}
+export interface ReviewerMutationIntentsTable {
+    id: Generated<string>;
+    workspace_id: string;
+    provider: ProviderKind;
+    provider_connection_id: string;
+    absence_id: string;
+    absence_revision: number;
+    decision_id: string;
+    repository_record_id: string;
+    repository_id: string;
+    change_request_id: string;
+    expected_head_revision: string;
+    unavailable_actor_id: string;
+    replacement_actor_id: string;
+    created_at: Timestamp;
+}
+export interface DecisionOutboxTable {
+    id: Generated<string>;
+    workspace_id: string;
+    decision_id: NullableString;
+    reviewer_replacement_id: NullableString;
+    event_id: string;
+    event_type: PlatformEventV1["eventType"];
+    schema_version: number;
+    payload: Json;
+    occurred_at: Timestamp;
+    available_at: Timestamp;
+    published_at: NullableTimestamp;
+    attempt_count: Generated<number>;
+    last_error: string | null;
+}
+export interface WorkerHeartbeatTable {
+    id: ColumnType<boolean, boolean | undefined, never>;
+    worker_id: string;
+    heartbeat_at: Timestamp;
+}
+export interface Database {
+    workspaces: WorkspacesTable;
+    provider_connections: ProviderConnectionsTable;
+    provider_connection_revocations: ProviderConnectionRevocationsTable;
+    repositories: RepositoriesTable;
+    webhook_receipts: WebhookReceiptsTable;
+    jobs: JobsTable;
+    routing_decisions: RoutingDecisionsTable;
+    workspace_operational_settings: WorkspaceOperationalSettingsTable;
+    reviewer_absences: ReviewerAbsencesTable;
+    reviewer_mutation_intents: ReviewerMutationIntentsTable;
+    reviewer_replacements: ReviewerReplacementsTable;
+    decision_outbox: DecisionOutboxTable;
+    worker_heartbeat: WorkerHeartbeatTable;
+}
+export type JobRow = Selectable<JobsTable>;
+export type NewJobRow = Insertable<JobsTable>;
+export type JobRowUpdate = Updateable<JobsTable>;
+export {};

package/dist/kysely.js

@@ -0,0 +1 @@
+export {};

package/dist/migrate.d.ts

@@ -0,0 +1 @@
+export declare function runMigrations(databaseUrl: string): Promise<void>;

package/dist/migrate.js

@@ -0,0 +1,45 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import pg from "pg";
+export async function runMigrations(databaseUrl) {
+    const pool = new pg.Pool({ connectionString: databaseUrl });
+    const client = await pool.connect();
+    try {
+        await client.query(`
+      create table if not exists schema_migrations (
+        name text primary key,
+        applied_at timestamptz not null default now()
+      )
+    `);
+        const migrationDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../migrations");
+        const files = (await fs.readdir(migrationDir)).filter((file) => file.endsWith(".sql")).sort();
+        for (const file of files) {
+            const existing = await client.query("select name from schema_migrations where name = $1", [file]);
+            if (existing.rowCount && existing.rowCount > 0)
+                continue;
+            const sql = await fs.readFile(path.join(migrationDir, file), "utf8");
+            await client.query("begin");
+            try {
+                await client.query(sql);
+                await client.query("insert into schema_migrations (name) values ($1)", [file]);
+                await client.query("commit");
+                console.log(`applied: ${file}`);
+            }
+            catch (error) {
+                await client.query("rollback");
+                throw error;
+            }
+        }
+    }
+    finally {
+        client.release();
+        await pool.end();
+    }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const databaseUrl = process.env.DATABASE_URL;
+    if (!databaseUrl)
+        throw new Error("DATABASE_URL is required");
+    await runMigrations(databaseUrl);
+}

package/dist/operations.d.ts

@@ -0,0 +1,77 @@
+import { type Kysely } from "kysely";
+import type { ActionStatus, ProviderConnectionId, RepositoryMode, RepositoryRef, RiskTier, RoutingAction, ScoreComponent, WorkspaceId } from "@triagepilot/contracts";
+import type { Database } from "./kysely.js";
+type PolicyCheckState = "not_started" | "in_progress" | "success" | "failure";
+export interface RepositoryOverview {
+    id: string;
+    owner: string;
+    name: string;
+    configState: string;
+    mode: RepositoryMode;
+}
+export interface DecisionOverview {
+    id: string;
+    repository: string;
+    pullNumber: number | null;
+    mode: RepositoryMode;
+    action: RoutingAction;
+    actionStatus: ActionStatus;
+    actionError: string | null;
+    policyCheckState: PolicyCheckState;
+    riskScore: number;
+    riskBreakdown: RiskBreakdown | null;
+    requestedReviewerCount: number | null;
+    reviewerShortfall: number | null;
+    selectedReviewer: string | null;
+    selectedReviewers: string[];
+    createdAt: string;
+}
+export interface RiskBreakdown {
+    classifierVersion: string;
+    tier: RiskTier;
+    components: ScoreComponent[];
+}
+export interface JobFailureOverview {
+    id: string;
+    error: string;
+    failedAt: string;
+}
+export interface ActionFailureOverview {
+    decisionId: string;
+    repository: string;
+    error: string;
+    failedAt: string;
+}
+export interface OperationsOverview {
+    organization: string;
+    githubApp: {
+        appId: string;
+        configured: boolean;
+        installationId: string | null;
+    };
+    repositories: RepositoryOverview[];
+    decisions: DecisionOverview[];
+    failures: {
+        jobs: JobFailureOverview[];
+        actions: ActionFailureOverview[];
+    };
+    worker: {
+        available: boolean;
+        workerId: string | null;
+        lastHeartbeatAt: string | null;
+    };
+}
+export interface ReadOperationsOverviewInput {
+    githubOrganization: string;
+    githubAppId: string;
+    now: Date;
+    heartbeatStaleAfterMs: number;
+}
+export interface RepositoryConfigurationTarget {
+    providerConnectionId: ProviderConnectionId;
+    externalConnectionId: string;
+    repository: RepositoryRef;
+}
+export declare function findRepositoryConfigurationTarget(db: Kysely<Database>, workspaceId: WorkspaceId, repositoryId: string): Promise<RepositoryConfigurationTarget | null>;
+export declare function readOperationsOverview(db: Kysely<Database>, workspaceId: WorkspaceId, input: ReadOperationsOverviewInput): Promise<OperationsOverview>;
+export {};

package/dist/operations.js

@@ -0,0 +1,256 @@
+import { sql } from "kysely";
+export async function findRepositoryConfigurationTarget(db, workspaceId, repositoryId) {
+    const target = await db
+        .selectFrom("repositories")
+        .innerJoin("provider_connections", (join) => join
+        .onRef("provider_connections.id", "=", "repositories.provider_connection_id")
+        .onRef("provider_connections.workspace_id", "=", "repositories.workspace_id"))
+        .select([
+        "repositories.provider",
+        "repositories.external_repository_id",
+        "repositories.owner",
+        "repositories.name",
+        "repositories.provider_connection_id",
+        "provider_connections.external_connection_id",
+    ])
+        .where("repositories.workspace_id", "=", workspaceId)
+        .where("repositories.id", "=", repositoryId)
+        .where("provider_connections.status", "=", "active")
+        .executeTakeFirst();
+    if (!target)
+        return null;
+    return {
+        providerConnectionId: target.provider_connection_id,
+        externalConnectionId: target.external_connection_id,
+        repository: {
+            provider: target.provider,
+            externalId: target.external_repository_id,
+            owner: target.owner,
+            name: target.name,
+        },
+    };
+}
+export async function readOperationsOverview(db, workspaceId, input) {
+    const configuredOrganization = sql `lower(provider_connections.workspace_login) = lower(${input.githubOrganization})`;
+    const [installation, repositories, decisions, jobFailures, actionFailures, heartbeat] = await Promise.all([
+        db
+            .selectFrom("provider_connections")
+            .select("external_connection_id")
+            .where("workspace_id", "=", workspaceId)
+            .where("provider", "=", "github")
+            .where("status", "=", "active")
+            .where(sql `lower(workspace_login) = lower(${input.githubOrganization})`)
+            .executeTakeFirst(),
+        db
+            .selectFrom("repositories")
+            .innerJoin("provider_connections", "provider_connections.id", "repositories.provider_connection_id")
+            .select([
+            "repositories.id",
+            "repositories.owner",
+            "repositories.name",
+            "repositories.config_state",
+            "repositories.last_config_mode",
+        ])
+            .where("repositories.workspace_id", "=", workspaceId)
+            .whereRef("provider_connections.workspace_id", "=", "repositories.workspace_id")
+            .where("provider_connections.status", "=", "active")
+            .where(configuredOrganization)
+            .orderBy("repositories.owner", "asc")
+            .orderBy("repositories.name", "asc")
+            .execute(),
+        db
+            .selectFrom("routing_decisions")
+            .innerJoin("repositories", "repositories.id", "routing_decisions.repository_id")
+            .innerJoin("provider_connections", "provider_connections.id", "repositories.provider_connection_id")
+            .select([
+            "routing_decisions.id",
+            "repositories.owner",
+            "repositories.name",
+            "routing_decisions.mode",
+            "routing_decisions.action",
+            "routing_decisions.action_status",
+            "routing_decisions.action_error",
+            "routing_decisions.policy_check_state",
+            "routing_decisions.risk_score",
+            "routing_decisions.selected_reviewer",
+            "routing_decisions.selected_reviewers",
+            "routing_decisions.details",
+            "routing_decisions.created_at",
+            sql `case
+            when jsonb_typeof(routing_decisions.details -> 'pullNumber') = 'number'
+              and routing_decisions.details ->> 'pullNumber' ~ '^[1-9][0-9]{0,9}$'
+            then case
+              when (routing_decisions.details ->> 'pullNumber')::numeric <= 2147483647
+              then (routing_decisions.details ->> 'pullNumber')::integer
+              else null
+            end
+            else null
+          end`.as("pull_number"),
+        ])
+            .where("routing_decisions.workspace_id", "=", workspaceId)
+            .whereRef("repositories.workspace_id", "=", "routing_decisions.workspace_id")
+            .whereRef("provider_connections.workspace_id", "=", "repositories.workspace_id")
+            .where("provider_connections.status", "=", "active")
+            .where(configuredOrganization)
+            .orderBy("routing_decisions.created_at", "desc")
+            .orderBy("routing_decisions.id", "desc")
+            .limit(50)
+            .execute(),
+        db
+            .selectFrom("jobs")
+            .select(["id", "last_error", "updated_at"])
+            .where("workspace_id", "=", workspaceId)
+            .where("status", "=", "failed")
+            .orderBy("updated_at", "desc")
+            .orderBy("id", "desc")
+            .limit(25)
+            .execute(),
+        db
+            .selectFrom("routing_decisions")
+            .innerJoin("repositories", "repositories.id", "routing_decisions.repository_id")
+            .innerJoin("provider_connections", "provider_connections.id", "repositories.provider_connection_id")
+            .select([
+            "routing_decisions.id",
+            "repositories.owner",
+            "repositories.name",
+            "routing_decisions.action_error",
+            "routing_decisions.action_failed_at",
+        ])
+            .where("routing_decisions.workspace_id", "=", workspaceId)
+            .whereRef("repositories.workspace_id", "=", "routing_decisions.workspace_id")
+            .whereRef("provider_connections.workspace_id", "=", "repositories.workspace_id")
+            .where("routing_decisions.action_status", "=", "failed")
+            .where("routing_decisions.action_failed_at", "is not", null)
+            .where("provider_connections.status", "=", "active")
+            .where(configuredOrganization)
+            .orderBy("routing_decisions.action_failed_at", "desc")
+            .orderBy("routing_decisions.id", "desc")
+            .limit(25)
+            .execute(),
+        db
+            .selectFrom("worker_heartbeat")
+            .select(["worker_id", "heartbeat_at"])
+            .executeTakeFirst(),
+    ]);
+    return {
+        organization: input.githubOrganization,
+        githubApp: {
+            appId: input.githubAppId,
+            configured: input.githubAppId.length > 0,
+            installationId: installation?.external_connection_id ?? null,
+        },
+        repositories: repositories.map((repository) => ({
+            id: repository.id,
+            owner: repository.owner,
+            name: repository.name,
+            configState: repository.config_state,
+            mode: repository.last_config_mode,
+        })),
+        decisions: decisions.map((decision) => {
+            const selectedReviewers = readSelectedReviewers(decision.selected_reviewers, decision.selected_reviewer);
+            const reviewerQuota = readReviewerQuota(decision.details, selectedReviewers);
+            return {
+                id: decision.id,
+                repository: `${decision.owner}/${decision.name}`,
+                pullNumber: decision.pull_number,
+                mode: decision.mode,
+                action: decision.action,
+                actionStatus: decision.action_status,
+                actionError: decision.action_error,
+                policyCheckState: normalizePolicyCheckState(decision.policy_check_state),
+                riskScore: decision.risk_score,
+                riskBreakdown: readRiskBreakdown(decision.details),
+                ...reviewerQuota,
+                selectedReviewer: decision.selected_reviewer,
+                selectedReviewers,
+                createdAt: decision.created_at.toISOString(),
+            };
+        }),
+        failures: {
+            jobs: jobFailures.map((failure) => ({
+                id: failure.id,
+                error: failure.last_error ?? "Unknown job failure",
+                failedAt: failure.updated_at.toISOString(),
+            })),
+            actions: actionFailures.map((failure) => ({
+                decisionId: failure.id,
+                repository: `${failure.owner}/${failure.name}`,
+                error: failure.action_error ?? "Unknown action failure",
+                failedAt: failure.action_failed_at.toISOString(),
+            })),
+        },
+        worker: {
+            available: heartbeat !== undefined &&
+                input.now.getTime() - heartbeat.heartbeat_at.getTime() <= input.heartbeatStaleAfterMs,
+            workerId: heartbeat?.worker_id ?? null,
+            lastHeartbeatAt: heartbeat?.heartbeat_at.toISOString() ?? null,
+        },
+    };
+}
+function normalizePolicyCheckState(value) {
+    switch (value) {
+        case "in_progress":
+        case "success":
+        case "failure":
+            return value;
+        default:
+            return "not_started";
+    }
+}
+function readRiskBreakdown(details) {
+    const risk = readRecord(readRecord(details)?.risk);
+    if (!risk || !isRiskTier(risk.tier) || typeof risk.classifierVersion !== "string")
+        return null;
+    if (!Array.isArray(risk.components) || !risk.components.every(isScoreComponent))
+        return null;
+    return {
+        classifierVersion: risk.classifierVersion,
+        tier: risk.tier,
+        components: risk.components,
+    };
+}
+function readRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function isRiskTier(value) {
+    return value === "low" || value === "medium" || value === "high";
+}
+function isScoreComponent(value) {
+    const component = readRecord(value);
+    return (component !== null &&
+        typeof component.reason === "string" &&
+        typeof component.detail === "string" &&
+        typeof component.score === "number" &&
+        Number.isFinite(component.score));
+}
+function readSelectedReviewers(value, legacyReviewer) {
+    if (Array.isArray(value)) {
+        return value.filter((reviewer) => typeof reviewer === "string").slice(0, 2);
+    }
+    return legacyReviewer ? [legacyReviewer] : [];
+}
+function readReviewerQuota(details, selectedReviewers) {
+    const routing = readRecord(readRecord(details)?.routing);
+    if (routing === null) {
+        return { requestedReviewerCount: null, reviewerShortfall: null };
+    }
+    if (!isReviewerCount(routing.requestedReviewerCount)) {
+        return { requestedReviewerCount: null, reviewerShortfall: null };
+    }
+    const requestedReviewerCount = routing.requestedReviewerCount;
+    const fallbackShortfall = Math.max(0, requestedReviewerCount - selectedReviewers.length);
+    return {
+        requestedReviewerCount,
+        reviewerShortfall: typeof routing.reviewerShortfall === "number" &&
+            Number.isInteger(routing.reviewerShortfall) &&
+            routing.reviewerShortfall >= 0 &&
+            routing.reviewerShortfall <= requestedReviewerCount
+            ? routing.reviewerShortfall
+            : fallbackShortfall,
+    };
+}
+function isReviewerCount(value) {
+    return value === 0 || value === 1 || value === 2;
+}

package/dist/outbox.d.ts

@@ -0,0 +1,61 @@
+import type { Kysely, Transaction } from "kysely";
+import type { PlatformEventSink, PlatformEventV1, WorkspaceId } from "@triagepilot/contracts";
+import type { Database } from "./kysely.js";
+type DatabaseExecutor = Kysely<Database> | Transaction<Database>;
+export interface PlatformOutboxRecord {
+    id: string;
+    workspaceId: WorkspaceId;
+    decisionId: string | null;
+    reviewerReplacementId: string | null;
+    eventId: string;
+    eventType: PlatformEventV1["eventType"];
+    schemaVersion: number;
+    payload: PlatformEventV1;
+    occurredAt: Date;
+    availableAt: Date;
+    publishedAt: Date | null;
+    attemptCount: number;
+    lastError: string | null;
+}
+export interface PlatformOutboxRepository {
+    claim(input: {
+        limit: number;
+        now: Date;
+    }): Promise<PlatformOutboxRecord[]>;
+    markPublished(input: {
+        id: string;
+        attemptCount: number;
+        now: Date;
+    }): Promise<boolean>;
+    markFailed(input: {
+        id: string;
+        attemptCount: number;
+        error: unknown;
+        now: Date;
+    }): Promise<boolean>;
+    listUnpublished(): Promise<PlatformOutboxRecord[]>;
+}
+export declare function stagePlatformEvent(db: DatabaseExecutor, workspaceId: WorkspaceId, sourceId: string, event: PlatformEventV1): Promise<void>;
+export declare function claimPlatformEvents(input: {
+    db: Kysely<Database>;
+    workspaceId: WorkspaceId;
+    limit: number;
+    now?: Date;
+}): Promise<PlatformOutboxRecord[]>;
+export declare function markPlatformEventPublished(input: {
+    db: Kysely<Database>;
+    workspaceId: WorkspaceId;
+    id: string;
+    attemptCount: number;
+    now?: Date;
+}): Promise<boolean>;
+export declare function createPlatformOutboxRepository(db: Kysely<Database>, workspaceId: WorkspaceId): PlatformOutboxRepository;
+export declare function publishPlatformOutbox(input: {
+    repository: PlatformOutboxRepository;
+    sink: PlatformEventSink;
+    limit: number;
+    now?: Date;
+}): Promise<{
+    published: number;
+}>;
+export {};