@vrplatform/kysely 1.3.45-6090 → 1.3.45-61

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

package/build/migrations-v2/0000000000023-line-classification-usage.ts

@@ -0,0 +1,325 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create table public.line_classification_usage (
+      tenant_id uuid not null references public.tenant(id) on delete cascade,
+      kind text not null,
+      name text not null,
+      app_id text,
+      mapping_status text,
+      first_seen_at timestamptz not null default now(),
+      last_seen_at timestamptz not null default now(),
+      revision integer not null default 1,
+      reported_revision integer not null default 0,
+      report_attempts integer not null default 0,
+      last_error text,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      primary key (tenant_id, kind, name),
+      constraint line_classification_usage_kind_check
+        check (kind in ('paymentLine', 'reservationLine')),
+      constraint line_classification_usage_mapping_status_check
+        check (
+          mapping_status is null or
+          mapping_status in ('excluded', 'mapped', 'unmapped')
+        ),
+      constraint line_classification_usage_revision_check check (revision > 0),
+      constraint line_classification_usage_reported_revision_check
+        check (reported_revision >= 0 and reported_revision <= revision),
+      constraint line_classification_usage_report_attempts_check
+        check (report_attempts >= 0)
+    );
+  `.execute(db);
+
+  await sql`
+    create index line_classification_usage_pending_idx
+      on public.line_classification_usage (updated_at, tenant_id, kind, name)
+      where reported_revision < revision;
+  `.execute(db);
+
+  await sql`
+    create table public.line_classification_usage_backfill (
+      source text primary key,
+      cursor_id uuid,
+      completed_at timestamptz,
+      updated_at timestamptz not null default now(),
+      constraint line_classification_usage_backfill_source_check
+        check (source in ('paymentLine', 'transactionLine'))
+    );
+  `.execute(db);
+
+  await sql`
+    insert into public.line_classification_usage_backfill (source)
+    values ('paymentLine'), ('transactionLine');
+  `.execute(db);
+
+  await sql`
+    create or replace function public.capture_line_classification_usage()
+    returns trigger
+    language plpgsql
+    as $$
+    begin
+      insert into public.line_classification_usage (
+        tenant_id,
+        kind,
+        name,
+        app_id,
+        mapping_status,
+        first_seen_at,
+        last_seen_at
+      )
+      select distinct
+        line.tenant_id,
+        case
+          when line.reservation_id is not null and line.payment_id is null
+            then 'reservationLine'
+          when line.payment_id is not null then 'paymentLine'
+          when classification.type in ('paymentLine', 'reservationLine')
+            then classification.type
+        end,
+        coalesce(line.effective_type, line.type),
+        coalesce(
+          classification.app_id,
+          app.id
+        ),
+        case
+          when (
+            line.reservation_id is not null and line.payment_id is null
+          ) or classification.type = 'reservationLine' then
+            case
+              when mapping.id is null then 'unmapped'
+              when mapping.account_id is null then 'excluded'
+              else 'mapped'
+            end
+          else null
+        end,
+        now(),
+        now()
+      from new_payment_lines as line
+      left join public.payment_line_classification as classification
+        on classification.name = coalesce(line.effective_type, line.type)
+      left join public.app as app
+        on lower(app.id) = lower(
+          split_part(coalesce(line.effective_type, line.type), '_', 1)
+        )
+        and app.category = 'propertyManagementSystem'
+      left join accounting.account_reservation_line_type as mapping
+        on mapping.tenant_id = line.tenant_id
+        and mapping.line_type = coalesce(line.effective_type, line.type)
+        and mapping.booking_channel is null
+      where line.tenant_id is not null
+        and coalesce(line.effective_type, line.type) is not null
+        and coalesce(line.effective_type, line.type) != ''
+        and (
+          (line.reservation_id is not null and line.payment_id is null) or
+          line.payment_id is not null or
+          classification.type in ('paymentLine', 'reservationLine')
+        )
+      on conflict (tenant_id, kind, name) do update
+      set
+        app_id = coalesce(
+          excluded.app_id,
+          public.line_classification_usage.app_id
+        ),
+        mapping_status = excluded.mapping_status,
+        last_seen_at = case
+          when public.line_classification_usage.app_id is distinct from
+            coalesce(
+              excluded.app_id,
+              public.line_classification_usage.app_id
+            ) or
+            public.line_classification_usage.mapping_status is distinct from
+              excluded.mapping_status or
+            public.line_classification_usage.last_seen_at <
+              excluded.last_seen_at - interval '1 hour'
+          then greatest(
+            public.line_classification_usage.last_seen_at,
+            excluded.last_seen_at
+          )
+          else public.line_classification_usage.last_seen_at
+        end,
+        revision = case
+          when public.line_classification_usage.app_id is distinct from
+            coalesce(
+              excluded.app_id,
+              public.line_classification_usage.app_id
+            ) or
+            public.line_classification_usage.mapping_status is distinct from
+              excluded.mapping_status or
+            public.line_classification_usage.last_seen_at <
+              excluded.last_seen_at - interval '1 hour'
+          then public.line_classification_usage.revision + 1
+          else public.line_classification_usage.revision
+        end,
+        updated_at = case
+          when public.line_classification_usage.app_id is distinct from
+            coalesce(
+              excluded.app_id,
+              public.line_classification_usage.app_id
+            ) or
+            public.line_classification_usage.mapping_status is distinct from
+              excluded.mapping_status or
+            public.line_classification_usage.last_seen_at <
+              excluded.last_seen_at - interval '1 hour'
+          then now()
+          else public.line_classification_usage.updated_at
+        end;
+      return null;
+    end;
+    $$;
+  `.execute(db);
+
+  await sql`
+    create trigger payment_line_classification_usage_insert
+    after insert on public.payment_line
+    referencing new table as new_payment_lines
+    for each statement
+    execute function public.capture_line_classification_usage();
+  `.execute(db);
+
+  await sql`
+    create trigger payment_line_classification_usage_update
+    after update on public.payment_line
+    referencing new table as new_payment_lines
+    for each statement
+    execute function public.capture_line_classification_usage();
+  `.execute(db);
+
+  await sql`
+    create or replace function public.capture_transaction_line_classification_usage()
+    returns trigger
+    language plpgsql
+    as $$
+    begin
+      insert into public.line_classification_usage (
+        tenant_id,
+        kind,
+        name,
+        app_id,
+        mapping_status,
+        first_seen_at,
+        last_seen_at
+      )
+      select
+        line.tenant_id,
+        'paymentLine',
+        line.match_line_type_classification,
+        coalesce(classification.app_id, app.id),
+        null,
+        min(line.created_at),
+        max(line.updated_at)
+      from new_transaction_lines as line
+      left join public.payment_line_classification as classification
+        on classification.name = line.match_line_type_classification
+      left join public.app as app
+        on lower(app.id) = lower(
+          split_part(line.match_line_type_classification, '_', 1)
+        )
+        and app.category = 'propertyManagementSystem'
+      where line.match_line_type_classification is not null
+        and line.match_line_type_classification != ''
+      group by
+        line.tenant_id,
+        line.match_line_type_classification,
+        coalesce(classification.app_id, app.id)
+      on conflict (tenant_id, kind, name) do update
+      set
+        app_id = coalesce(
+          excluded.app_id,
+          public.line_classification_usage.app_id
+        ),
+        first_seen_at = least(
+          public.line_classification_usage.first_seen_at,
+          excluded.first_seen_at
+        ),
+        last_seen_at = case
+          when public.line_classification_usage.app_id is distinct from
+            coalesce(
+              excluded.app_id,
+              public.line_classification_usage.app_id
+            ) or
+            public.line_classification_usage.last_seen_at <
+              excluded.last_seen_at - interval '1 hour'
+          then greatest(
+            public.line_classification_usage.last_seen_at,
+            excluded.last_seen_at
+          )
+          else public.line_classification_usage.last_seen_at
+        end,
+        revision = case
+          when public.line_classification_usage.app_id is distinct from
+            coalesce(
+              excluded.app_id,
+              public.line_classification_usage.app_id
+            ) or
+            public.line_classification_usage.last_seen_at <
+              excluded.last_seen_at - interval '1 hour'
+          then public.line_classification_usage.revision + 1
+          else public.line_classification_usage.revision
+        end,
+        updated_at = case
+          when public.line_classification_usage.app_id is distinct from
+            coalesce(
+              excluded.app_id,
+              public.line_classification_usage.app_id
+            ) or
+            public.line_classification_usage.last_seen_at <
+              excluded.last_seen_at - interval '1 hour'
+          then now()
+          else public.line_classification_usage.updated_at
+        end;
+      return null;
+    end;
+    $$;
+  `.execute(db);
+
+  await sql`
+    create trigger transaction_line_classification_usage_insert
+    after insert on accounting.transaction_line
+    referencing new table as new_transaction_lines
+    for each statement
+    execute function public.capture_transaction_line_classification_usage();
+  `.execute(db);
+
+  await sql`
+    create trigger transaction_line_classification_usage_update
+    after update on accounting.transaction_line
+    referencing new table as new_transaction_lines
+    for each statement
+    execute function public.capture_transaction_line_classification_usage();
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    drop trigger if exists transaction_line_classification_usage_update
+      on accounting.transaction_line;
+  `.execute(db);
+  await sql`
+    drop trigger if exists transaction_line_classification_usage_insert
+      on accounting.transaction_line;
+  `.execute(db);
+  await sql`
+    drop function if exists
+      public.capture_transaction_line_classification_usage();
+  `.execute(db);
+  await sql`
+    drop trigger if exists payment_line_classification_usage_update
+      on public.payment_line;
+  `.execute(db);
+  await sql`
+    drop trigger if exists payment_line_classification_usage_insert
+      on public.payment_line;
+  `.execute(db);
+  await sql`
+    drop function if exists public.capture_line_classification_usage();
+  `.execute(db);
+  await sql`
+    drop table if exists public.line_classification_usage_backfill;
+  `.execute(db);
+  await sql`
+    drop table if exists public.line_classification_usage;
+  `.execute(db);
+}