@vrplatform/kysely 1.3.45-5991 → 1.3.45-6

package/build/migrations-v2/0000000000017-drop-trial-until.ts

@@ -0,0 +1,42 @@
+import { type Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    do $$
+    declare
+      definition text;
+      trigger_function regprocedure;
+    begin
+      for trigger_function in
+        select distinct p.oid::regprocedure
+        from pg_trigger as t
+        inner join pg_proc as p on p.oid = t.tgfoid
+        where t.tgrelid = 'public.tenant'::regclass
+          and not t.tgisinternal
+          and p.prosrc ilike '%trial_until%'
+      loop
+        definition := pg_get_functiondef(trigger_function);
+        definition := replace(definition, 'OLD."trial_until" , ', '');
+        definition := replace(definition, 'NEW."trial_until" , ', '');
+
+        if definition ilike '%trial_until%' then
+          raise exception
+            'Could not remove trial_until from tenant trigger function %',
+            trigger_function;
+        end if;
+
+        execute definition;
+      end loop;
+    end;
+    $$;
+  `.execute(db);
+  await sql`
+    alter table public.tenant drop column if exists trial_until
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table public.tenant add column trial_until date
+  `.execute(db);
+}

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);
+}