@vrplatform/kysely 1.3.41 → 1.3.45-1

package/build/migrations-v2/0000000000018-accounting-integrity-monitoring.ts

@@ -0,0 +1,276 @@
+import { type Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create type health.accounting_integrity_run_status as enum (
+      'running',
+      'completed',
+      'failed',
+      'skipped'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_case_status as enum (
+      'open',
+      'resolved'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_review_status as enum (
+      'unreviewed',
+      'confirmed_issue',
+      'expected',
+      'false_positive'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_actionability as enum (
+      'automatically_repairable',
+      'manual_repair',
+      'blocked',
+      'code_fix_required',
+      'unknown'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_resolution_classification as enum (
+      'code_fix',
+      'configuration',
+      'data_repair',
+      'expected',
+      'false_positive',
+      'monitor_fix',
+      'unknown'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_severity as enum (
+      'info',
+      'warning',
+      'error',
+      'critical'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_transition_type as enum (
+      'opened',
+      'changed',
+      'reopened',
+      'resolved',
+      'reviewed'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_delivery_channel as enum (
+      'sentry',
+      'slack'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_delivery_status as enum (
+      'suppressed',
+      'pending',
+      'processing',
+      'delivered',
+      'failed',
+      'dead_letter'
+    )
+  `.execute(db);
+
+  await sql`
+    create table health.accounting_integrity_run (
+      id uuid primary key default gen_random_uuid(),
+      evaluation_id uuid not null,
+      code text not null,
+      definition_version integer not null,
+      git_revision text not null,
+      environment text not null,
+      data_region text not null,
+      status health.accounting_integrity_run_status not null,
+      started_at timestamptz not null,
+      completed_at timestamptz,
+      rows_scanned bigint not null default 0,
+      finding_row_count bigint not null default 0,
+      case_count bigint not null default 0,
+      opened_case_count bigint not null default 0,
+      changed_case_count bigint not null default 0,
+      reopened_case_count bigint not null default 0,
+      resolved_case_count bigint not null default 0,
+      unchanged_case_count bigint not null default 0,
+      error jsonb,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      constraint accounting_integrity_run_evaluation_region_code_key
+        unique (evaluation_id, data_region, code)
+    );
+  `.execute(db);
+
+  await sql`
+    create index accounting_integrity_run_metrics_idx
+      on health.accounting_integrity_run (
+        environment,
+        started_at desc
+      );
+  `.execute(db);
+
+  await sql`
+    create table health.accounting_integrity_case (
+      id uuid primary key default gen_random_uuid(),
+      data_region text not null,
+      code text not null,
+      tenant_id uuid not null references public.tenant(id) on delete cascade,
+      case_key text not null,
+      version bigint not null default 1,
+      status health.accounting_integrity_case_status not null,
+      review_status health.accounting_integrity_review_status
+        not null default 'unreviewed',
+      actionability health.accounting_integrity_actionability not null,
+      resolution_classification
+        health.accounting_integrity_resolution_classification not null,
+      severity health.accounting_integrity_severity not null,
+      title text not null,
+      root_cause text not null,
+      expected jsonb not null,
+      actual jsonb not null,
+      impact jsonb not null,
+      lock_assessment jsonb not null,
+      evidence jsonb not null,
+      evidence_complete boolean not null,
+      portal_urls jsonb not null,
+      historical_issue_refs jsonb not null,
+      verification jsonb not null,
+      repair jsonb not null,
+      content_hash text not null,
+      run_id uuid not null
+        references health.accounting_integrity_run(id) on delete restrict,
+      definition_version integer not null,
+      git_revision text not null,
+      first_seen_at timestamptz not null,
+      last_seen_at timestamptz not null,
+      last_changed_at timestamptz not null,
+      resolved_at timestamptz,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      constraint accounting_integrity_case_identity_key
+        unique (data_region, code, tenant_id, case_key),
+      constraint accounting_integrity_case_version_check check (version > 0)
+    );
+  `.execute(db);
+
+  await sql`
+    create index accounting_integrity_case_tenant_idx
+      on health.accounting_integrity_case (tenant_id)
+  `.execute(db);
+  await sql`
+    create index accounting_integrity_case_run_idx
+      on health.accounting_integrity_case (run_id)
+  `.execute(db);
+  await sql`
+    create index accounting_integrity_case_open_idx
+      on health.accounting_integrity_case (
+        data_region,
+        code,
+        severity,
+        tenant_id,
+        last_changed_at desc
+      )
+      where status = 'open';
+  `.execute(db);
+
+  await sql`
+    create table health.accounting_integrity_transition (
+      id uuid primary key default gen_random_uuid(),
+      run_id uuid not null
+        references health.accounting_integrity_run(id) on delete cascade,
+      case_id uuid not null
+        references health.accounting_integrity_case(id) on delete cascade,
+      case_version bigint not null,
+      type health.accounting_integrity_transition_type not null,
+      payload jsonb not null,
+      created_at timestamptz not null default now(),
+      constraint accounting_integrity_transition_case_version_type_key
+        unique (case_id, case_version, type)
+    );
+  `.execute(db);
+
+  await sql`
+    create index accounting_integrity_transition_run_idx
+      on health.accounting_integrity_transition (run_id)
+  `.execute(db);
+  await sql`
+    create table health.accounting_integrity_delivery (
+      id uuid primary key default gen_random_uuid(),
+      run_id uuid not null
+        references health.accounting_integrity_run(id) on delete cascade,
+      case_id uuid
+        references health.accounting_integrity_case(id) on delete cascade,
+      channel health.accounting_integrity_delivery_channel not null,
+      event_type text not null,
+      dedupe_key text not null unique,
+      payload jsonb not null,
+      status health.accounting_integrity_delivery_status
+        not null default 'pending',
+      attempts integer not null default 0,
+      claim_id uuid,
+      claimed_at timestamptz,
+      next_attempt_at timestamptz not null default now(),
+      delivered_at timestamptz,
+      result jsonb,
+      last_error jsonb,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now()
+    );
+  `.execute(db);
+
+  await sql`
+    create index accounting_integrity_delivery_run_idx
+      on health.accounting_integrity_delivery (run_id)
+  `.execute(db);
+  await sql`
+    create index accounting_integrity_delivery_case_idx
+      on health.accounting_integrity_delivery (case_id)
+  `.execute(db);
+  await sql`
+    create index accounting_integrity_delivery_pending_idx
+      on health.accounting_integrity_delivery (next_attempt_at, created_at, id)
+      where status in ('pending', 'processing', 'failed');
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`drop table if exists health.accounting_integrity_delivery;`.execute(
+    db
+  );
+  await sql`drop table if exists health.accounting_integrity_transition;`.execute(
+    db
+  );
+  await sql`drop table if exists health.accounting_integrity_case;`.execute(db);
+  await sql`drop table if exists health.accounting_integrity_run;`.execute(db);
+  await sql`drop type if exists health.accounting_integrity_delivery_status`.execute(
+    db
+  );
+  await sql`drop type if exists health.accounting_integrity_delivery_channel`.execute(
+    db
+  );
+  await sql`drop type if exists health.accounting_integrity_transition_type`.execute(
+    db
+  );
+  await sql`drop type if exists health.accounting_integrity_severity`.execute(
+    db
+  );
+  await sql`drop type if exists health.accounting_integrity_resolution_classification`.execute(
+    db
+  );
+  await sql`drop type if exists health.accounting_integrity_actionability`.execute(
+    db
+  );
+  await sql`drop type if exists health.accounting_integrity_review_status`.execute(
+    db
+  );
+  await sql`drop type if exists health.accounting_integrity_case_status`.execute(
+    db
+  );
+  await sql`drop type if exists health.accounting_integrity_run_status`.execute(
+    db
+  );
+}

package/build/migrations-v2/0000000000019-accounting-integrity-run-shards.ts

@@ -0,0 +1,26 @@
+import { type Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table health.accounting_integrity_run
+      add column shard_key text not null default 'regional'
+  `.execute(db);
+
+  await sql`
+    alter table health.accounting_integrity_run
+      drop constraint accounting_integrity_run_evaluation_region_code_key,
+      add constraint accounting_integrity_run_evaluation_region_code_shard_key
+        unique (evaluation_id, data_region, code, shard_key)
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table health.accounting_integrity_run
+      drop constraint
+        accounting_integrity_run_evaluation_region_code_shard_key,
+      drop column shard_key,
+      add constraint accounting_integrity_run_evaluation_region_code_key
+        unique (evaluation_id, data_region, code)
+  `.execute(db);
+}

package/build/migrations-v2/0000000000020-accounting-integrity-case-classification.ts

@@ -0,0 +1,52 @@
+import { type Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create type health.accounting_integrity_urgency as enum (
+      'immediate',
+      'next_triage',
+      'backlog',
+      'none'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_confidence as enum (
+      'proven',
+      'probable',
+      'unknown'
+    )
+  `.execute(db);
+  await sql`
+    alter table health.accounting_integrity_case
+      add column urgency health.accounting_integrity_urgency,
+      add column confidence health.accounting_integrity_confidence
+  `.execute(db);
+  await sql`
+    update health.accounting_integrity_case
+    set
+      urgency = case
+        when severity = 'info'
+          then 'none'::health.accounting_integrity_urgency
+        when nullif(impact -> 'modifiedAt' ->> 'latest', '')::timestamptz >=
+          now() - interval '28 days'
+          then 'next_triage'::health.accounting_integrity_urgency
+        else 'backlog'::health.accounting_integrity_urgency
+      end,
+      confidence = 'probable'::health.accounting_integrity_confidence
+  `.execute(db);
+  await sql`
+    alter table health.accounting_integrity_case
+      alter column urgency set not null,
+      alter column confidence set not null
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table health.accounting_integrity_case
+      drop column confidence,
+      drop column urgency
+  `.execute(db);
+  await sql`drop type health.accounting_integrity_confidence`.execute(db);
+  await sql`drop type health.accounting_integrity_urgency`.execute(db);
+}

package/build/migrations-v2/0000000000021-payment-line-classification-monitor-indexes.ts

@@ -0,0 +1,31 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create index if not exists payment_line_recent_classification_idx
+      on public.payment_line (updated_at, type2)
+      include (payment_id, reservation_id)
+      where type2 is not null and type2 != 'deviation'
+  `.execute(db);
+
+  await sql`
+    create index if not exists transaction_line_recent_classification_idx
+      on accounting.transaction_line (
+        updated_at,
+        match_line_type_classification
+      )
+      where match_line_type_classification is not null
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    drop index if exists
+      accounting.transaction_line_recent_classification_idx
+  `.execute(db);
+
+  await sql`
+    drop index if exists public.payment_line_recent_classification_idx
+  `.execute(db);
+}

package/build/migrations-v2/0000000000022-accounting-integrity-controlled-repairs.ts

@@ -0,0 +1,281 @@
+import { type Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table health.accounting_integrity_run
+      add column scope_tenant_ids uuid[],
+      add column resolves_cases boolean not null default true,
+      add constraint accounting_integrity_run_scope_tenant_ids_check
+        check (
+          scope_tenant_ids is null or cardinality(scope_tenant_ids) > 0
+        )
+  `.execute(db);
+
+  await sql`
+    create type health.accounting_integrity_repair_plan_status as enum (
+      'draft',
+      'active',
+      'paused',
+      'failed',
+      'completed',
+      'canceled'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_repair_stage_status as enum (
+      'planned',
+      'dry_run_passed',
+      'approved',
+      'applying',
+      'verifying',
+      'verified',
+      'paused',
+      'failed',
+      'canceled'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_repair_scope_type as enum (
+      'case',
+      'tenant'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_repair_target_status as enum (
+      'pending',
+      'applying',
+      'applied',
+      'verifying',
+      'verified',
+      'paused',
+      'failed',
+      'canceled'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_repair_transition_type as enum (
+      'plan_created',
+      'plan_activated',
+      'dry_run_passed',
+      'approval_granted',
+      'approval_invalidated',
+      'stage_applying',
+      'target_applying',
+      'target_applied',
+      'target_verifying',
+      'target_verified',
+      'stage_verified',
+      'paused',
+      'failed',
+      'canceled',
+      'completed'
+    )
+  `.execute(db);
+
+  await sql`
+    create table health.accounting_integrity_repair_plan (
+      id uuid primary key default gen_random_uuid(),
+      data_region text not null,
+      environment text not null,
+      code text not null,
+      recipe_version integer not null,
+      git_revision text not null,
+      status health.accounting_integrity_repair_plan_status
+        not null default 'draft',
+      title text not null,
+      linear_ref text,
+      created_by text not null,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      completed_at timestamptz,
+      canceled_at timestamptz,
+      constraint accounting_integrity_repair_plan_recipe_version_check
+        check (recipe_version > 0),
+      constraint accounting_integrity_repair_plan_completion_check
+        check ((status = 'completed') = (completed_at is not null)),
+      constraint accounting_integrity_repair_plan_cancellation_check
+        check ((status = 'canceled') = (canceled_at is not null))
+    )
+  `.execute(db);
+
+  await sql`
+    create index accounting_integrity_repair_plan_status_idx
+      on health.accounting_integrity_repair_plan (
+        data_region,
+        environment,
+        status,
+        updated_at desc
+      )
+  `.execute(db);
+
+  await sql`
+    create table health.accounting_integrity_repair_stage (
+      id uuid primary key default gen_random_uuid(),
+      plan_id uuid not null
+        references health.accounting_integrity_repair_plan(id)
+        on delete cascade,
+      ordinal integer not null,
+      scope_type health.accounting_integrity_repair_scope_type not null,
+      tenant_id uuid not null,
+      status health.accounting_integrity_repair_stage_status
+        not null default 'planned',
+      manifest jsonb not null,
+      manifest_hash text not null,
+      limits jsonb not null,
+      dry_run_result jsonb,
+      approved_by text,
+      approved_at timestamptz,
+      approval_ref text,
+      apply_result jsonb,
+      verification_result jsonb,
+      started_at timestamptz,
+      completed_at timestamptz,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      constraint accounting_integrity_repair_stage_plan_ordinal_key
+        unique (plan_id, ordinal),
+      constraint accounting_integrity_repair_stage_ordinal_check
+        check (ordinal > 0),
+      constraint accounting_integrity_repair_stage_approval_check check (
+        (approved_by is null and approved_at is null and approval_ref is null)
+        or
+        (approved_by is not null and approved_at is not null and
+          approval_ref is not null)
+      ),
+      constraint accounting_integrity_repair_stage_completion_check check (
+        (status = 'verified') = (completed_at is not null)
+      )
+    )
+  `.execute(db);
+
+  await sql`
+    create index accounting_integrity_repair_stage_plan_status_idx
+      on health.accounting_integrity_repair_stage (
+        plan_id,
+        status,
+        ordinal
+      )
+  `.execute(db);
+
+  await sql`
+    create table health.accounting_integrity_repair_target (
+      id uuid primary key default gen_random_uuid(),
+      stage_id uuid not null
+        references health.accounting_integrity_repair_stage(id)
+        on delete cascade,
+      ordinal integer not null,
+      case_id uuid not null,
+      case_version bigint not null,
+      case_content_hash text not null,
+      tenant_id uuid not null,
+      target_key text not null,
+      action jsonb not null,
+      before_state jsonb not null,
+      before_hash text not null,
+      expected_result jsonb not null,
+      lock_assessment jsonb not null,
+      effect_plan jsonb not null,
+      status health.accounting_integrity_repair_target_status
+        not null default 'pending',
+      idempotency_key text not null unique,
+      audit_action_id uuid,
+      apply_result jsonb,
+      verification_result jsonb,
+      started_at timestamptz,
+      completed_at timestamptz,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      constraint accounting_integrity_repair_target_stage_key
+        unique (stage_id, target_key),
+      constraint accounting_integrity_repair_target_stage_ordinal_key
+        unique (stage_id, ordinal),
+      constraint accounting_integrity_repair_target_ordinal_check
+        check (ordinal > 0),
+      constraint accounting_integrity_repair_target_case_version_check
+        check (case_version > 0),
+      constraint accounting_integrity_repair_target_completion_check check (
+        (status = 'verified') = (completed_at is not null)
+      )
+    )
+  `.execute(db);
+
+  await sql`
+    create index accounting_integrity_repair_target_stage_status_idx
+      on health.accounting_integrity_repair_target (
+        stage_id,
+        status,
+        ordinal
+      )
+  `.execute(db);
+  await sql`
+    create index accounting_integrity_repair_target_case_idx
+      on health.accounting_integrity_repair_target (case_id)
+  `.execute(db);
+
+  await sql`
+    create table health.accounting_integrity_repair_transition (
+      id uuid primary key default gen_random_uuid(),
+      plan_id uuid not null
+        references health.accounting_integrity_repair_plan(id)
+        on delete cascade,
+      stage_id uuid
+        references health.accounting_integrity_repair_stage(id)
+        on delete cascade,
+      target_id uuid
+        references health.accounting_integrity_repair_target(id)
+        on delete cascade,
+      type health.accounting_integrity_repair_transition_type not null,
+      actor text not null,
+      payload jsonb not null,
+      created_at timestamptz not null default now(),
+      constraint accounting_integrity_repair_transition_target_stage_check
+        check (target_id is null or stage_id is not null)
+    )
+  `.execute(db);
+
+  await sql`
+    create index accounting_integrity_repair_transition_plan_idx
+      on health.accounting_integrity_repair_transition (
+        plan_id,
+        created_at,
+        id
+      )
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    drop table if exists health.accounting_integrity_repair_transition
+  `.execute(db);
+  await sql`
+    drop table if exists health.accounting_integrity_repair_target
+  `.execute(db);
+  await sql`
+    drop table if exists health.accounting_integrity_repair_stage
+  `.execute(db);
+  await sql`
+    drop table if exists health.accounting_integrity_repair_plan
+  `.execute(db);
+  await sql`
+    drop type if exists
+      health.accounting_integrity_repair_transition_type
+  `.execute(db);
+  await sql`
+    drop type if exists health.accounting_integrity_repair_target_status
+  `.execute(db);
+  await sql`
+    drop type if exists health.accounting_integrity_repair_scope_type
+  `.execute(db);
+  await sql`
+    drop type if exists health.accounting_integrity_repair_stage_status
+  `.execute(db);
+  await sql`
+    drop type if exists health.accounting_integrity_repair_plan_status
+  `.execute(db);
+  await sql`
+    alter table health.accounting_integrity_run
+      drop constraint accounting_integrity_run_scope_tenant_ids_check,
+      drop column resolves_cases,
+      drop column scope_tenant_ids
+  `.execute(db);
+}