@vrplatform/kysely 1.3.45-6090 → 1.3.45-61

package/build/migrations-v2/0000000000024-tenant-region-migration.ts

@@ -0,0 +1,108 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<Record<string, never>>): Promise<void> {
+  await sql`
+    alter table public.tenant
+      add column migration_status text not null default 'active',
+      add column migrated_to_region text null,
+      add column migrated_at timestamp with time zone null,
+      add constraint tenant_migration_status_check
+        check (migration_status in ('active', 'frozen', 'migrated')),
+      add constraint tenant_migrated_target_check
+        check (
+          (migration_status = 'migrated' and migrated_to_region is not null and migrated_at is not null)
+          or
+          (migration_status <> 'migrated' and migrated_to_region is null and migrated_at is null)
+        ),
+      add constraint tenant_migrated_to_region_check
+        check (
+          migrated_to_region is null
+          or migrated_to_region in ('ap', 'crunchy', 'eu', 'hostaway', 'us')
+        );
+  `.execute(db);
+
+  await sql`
+    do $$
+    declare
+      constraint_row record;
+    begin
+      for constraint_row in
+        select
+          namespace.nspname as schema_name,
+          class.relname as table_name,
+          constraint_record.conname as constraint_name
+        from pg_constraint constraint_record
+        inner join pg_class class on class.oid = constraint_record.conrelid
+        inner join pg_namespace namespace on namespace.oid = class.relnamespace
+        where constraint_record.contype = 'f'
+          and not constraint_record.condeferrable
+          and namespace.nspname in (
+            'accounting',
+            'audit',
+            'core',
+            'health',
+            'public',
+            'tracking',
+            'webhook'
+          )
+      loop
+        execute format(
+          'alter table %I.%I alter constraint %I deferrable initially immediate',
+          constraint_row.schema_name,
+          constraint_row.table_name,
+          constraint_row.constraint_name
+        );
+      end loop;
+    end
+    $$;
+  `.execute(db);
+}
+
+export async function down(db: Kysely<Record<string, never>>): Promise<void> {
+  await sql`
+    do $$
+    declare
+      constraint_row record;
+    begin
+      for constraint_row in
+        select
+          namespace.nspname as schema_name,
+          class.relname as table_name,
+          constraint_record.conname as constraint_name
+        from pg_constraint constraint_record
+        inner join pg_class class on class.oid = constraint_record.conrelid
+        inner join pg_namespace namespace on namespace.oid = class.relnamespace
+        where constraint_record.contype = 'f'
+          and constraint_record.condeferrable
+          and namespace.nspname in (
+            'accounting',
+            'audit',
+            'core',
+            'health',
+            'public',
+            'tracking',
+            'webhook'
+          )
+      loop
+        execute format(
+          'alter table %I.%I alter constraint %I not deferrable',
+          constraint_row.schema_name,
+          constraint_row.table_name,
+          constraint_row.constraint_name
+        );
+      end loop;
+    end
+    $$;
+  `.execute(db);
+
+  await sql`
+    alter table public.tenant
+      drop constraint tenant_migrated_to_region_check,
+      drop constraint tenant_migrated_target_check,
+      drop constraint tenant_migration_status_check,
+      drop column migrated_at,
+      drop column migrated_to_region,
+      drop column migration_status;
+  `.execute(db);
+}

package/build/migrations-v2/0000000000025-partner-ach-denial-default.ts

@@ -0,0 +1,30 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`set local lock_timeout = '5s'`.execute(db);
+  await sql`
+    alter table public.tenant
+      alter column partner_denied_permissions
+      set default array['ach-payments:execute']::text[]
+  `.execute(db);
+  await sql`alter table public.tenant disable trigger user`.execute(db);
+  await sql`
+    update public.tenant
+    set partner_denied_permissions = array_append(
+      partner_denied_permissions,
+      'ach-payments:execute'
+    )
+    where not ('ach-payments:execute' = any(partner_denied_permissions))
+  `.execute(db);
+  await sql`alter table public.tenant enable trigger user`.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  // Preserve stored denials because migrated defaults and explicit choices
+  // are indistinguishable after the up migration.
+  await sql`
+    alter table public.tenant
+      alter column partner_denied_permissions set default '{}'
+  `.execute(db);
+}

package/build/migrations-v2/0000000000026-line-classification-usage-capture.ts

@@ -0,0 +1,399 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`set local lock_timeout = '5s'`.execute(db);
+  await sql`
+    create table public.line_classification_usage_capture (
+      id uuid primary key default gen_random_uuid(),
+      tenant_id uuid not null references public.tenant(id) on delete cascade,
+      kind text not null,
+      name text not null,
+      first_seen_at timestamptz,
+      last_seen_at timestamptz,
+      created_at timestamptz not null default now(),
+      constraint line_classification_usage_capture_kind_check
+        check (kind in ('paymentLine', 'reservationLine')),
+      constraint line_classification_usage_capture_observation_check
+        check (
+          (first_seen_at is null and last_seen_at is null) or
+          (
+            first_seen_at is not null and
+            last_seen_at is not null and
+            first_seen_at <= last_seen_at
+          )
+        )
+    );
+  `.execute(db);
+
+  await sql`
+    create index line_classification_usage_capture_drain_idx
+    on public.line_classification_usage_capture (created_at, id)
+  `.execute(db);
+  await sql`
+    create index line_classification_usage_capture_tenant_kind_name_idx
+    on public.line_classification_usage_capture (tenant_id, kind, name)
+  `.execute(db);
+
+  await sql`
+    create or replace function public.enqueue_line_classification_usage()
+    returns trigger
+    language plpgsql
+    as $$
+    begin
+      if tg_op = 'INSERT' then
+        insert into public.line_classification_usage_capture (
+          tenant_id,
+          kind,
+          name,
+          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),
+          statement_timestamp(),
+          statement_timestamp()
+        from new_payment_lines as line
+        left join public.payment_line_classification as classification
+          on classification.name = coalesce(line.effective_type, line.type)
+        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')
+          );
+      else
+        insert into public.line_classification_usage_capture (
+          tenant_id,
+          kind,
+          name,
+          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),
+          statement_timestamp(),
+          statement_timestamp()
+        from new_payment_lines as line
+        inner join old_payment_lines as old_line on old_line.id = line.id
+        left join public.payment_line_classification as classification
+          on classification.name = coalesce(line.effective_type, line.type)
+        where row(
+          line.tenant_id,
+          line.effective_type,
+          line.type,
+          line.reservation_id,
+          line.payment_id
+        ) is distinct from row(
+          old_line.tenant_id,
+          old_line.effective_type,
+          old_line.type,
+          old_line.reservation_id,
+          old_line.payment_id
+        )
+          and 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')
+          );
+      end if;
+      return null;
+    end;
+    $$;
+  `.execute(db);
+
+  await sql`
+    create or replace function
+      public.enqueue_transaction_line_classification_usage()
+    returns trigger
+    language plpgsql
+    as $$
+    begin
+      if tg_op = 'INSERT' then
+        insert into public.line_classification_usage_capture (
+          tenant_id,
+          kind,
+          name,
+          first_seen_at,
+          last_seen_at
+        )
+        select distinct
+          line.tenant_id,
+          'paymentLine',
+          line.match_line_type_classification,
+          statement_timestamp(),
+          statement_timestamp()
+        from new_transaction_lines as line
+        where line.match_line_type_classification is not null
+          and line.match_line_type_classification != '';
+      else
+        insert into public.line_classification_usage_capture (
+          tenant_id,
+          kind,
+          name,
+          first_seen_at,
+          last_seen_at
+        )
+        select distinct
+          line.tenant_id,
+          'paymentLine',
+          line.match_line_type_classification,
+          statement_timestamp(),
+          statement_timestamp()
+        from new_transaction_lines as line
+        inner join old_transaction_lines as old_line on old_line.id = line.id
+        where row(
+          line.tenant_id,
+          line.match_line_type_classification
+        ) is distinct from row(
+          old_line.tenant_id,
+          old_line.match_line_type_classification
+        )
+          and line.match_line_type_classification is not null
+          and line.match_line_type_classification != '';
+      end if;
+      return null;
+    end;
+    $$;
+  `.execute(db);
+
+  await sql`
+    create or replace function
+      public.enqueue_reservation_line_mapping_usage()
+    returns trigger
+    language plpgsql
+    as $$
+    begin
+      if tg_op = 'INSERT' then
+        insert into public.line_classification_usage_capture (
+          tenant_id,
+          kind,
+          name,
+          first_seen_at,
+          last_seen_at
+        )
+        select distinct
+          mapping.tenant_id,
+          'reservationLine',
+          mapping.line_type,
+          null::timestamptz,
+          null::timestamptz
+        from new_reservation_line_mappings as mapping
+        where mapping.booking_channel is null
+          and mapping.line_type is not null
+          and mapping.line_type != '';
+      elsif tg_op = 'UPDATE' then
+        insert into public.line_classification_usage_capture (
+          tenant_id,
+          kind,
+          name,
+          first_seen_at,
+          last_seen_at
+        )
+        select distinct
+          changed.tenant_id,
+          'reservationLine',
+          changed.line_type,
+          null::timestamptz,
+          null::timestamptz
+        from (
+          select
+            mapping.tenant_id,
+            mapping.line_type,
+            mapping.booking_channel
+          from new_reservation_line_mappings as mapping
+          inner join old_reservation_line_mappings as old_mapping
+            on old_mapping.id = mapping.id
+          where row(
+            mapping.tenant_id,
+            mapping.line_type,
+            mapping.booking_channel,
+            mapping.account_id
+          ) is distinct from row(
+            old_mapping.tenant_id,
+            old_mapping.line_type,
+            old_mapping.booking_channel,
+            old_mapping.account_id
+          )
+          union
+          select
+            old_mapping.tenant_id,
+            old_mapping.line_type,
+            old_mapping.booking_channel
+          from old_reservation_line_mappings as old_mapping
+          inner join new_reservation_line_mappings as mapping
+            on mapping.id = old_mapping.id
+          where row(
+            mapping.tenant_id,
+            mapping.line_type,
+            mapping.booking_channel,
+            mapping.account_id
+          ) is distinct from row(
+            old_mapping.tenant_id,
+            old_mapping.line_type,
+            old_mapping.booking_channel,
+            old_mapping.account_id
+          )
+        ) as changed
+        where changed.booking_channel is null
+          and changed.line_type is not null
+          and changed.line_type != '';
+      else
+        insert into public.line_classification_usage_capture (
+          tenant_id,
+          kind,
+          name,
+          first_seen_at,
+          last_seen_at
+        )
+        select distinct
+          mapping.tenant_id,
+          'reservationLine',
+          mapping.line_type,
+          null::timestamptz,
+          null::timestamptz
+        from old_reservation_line_mappings as mapping
+        where mapping.booking_channel is null
+          and mapping.line_type is not null
+          and mapping.line_type != '';
+      end if;
+      return null;
+    end;
+    $$;
+  `.execute(db);
+
+  await sql`drop trigger payment_line_classification_usage_insert
+    on public.payment_line`.execute(db);
+  await sql`drop trigger payment_line_classification_usage_update
+    on public.payment_line`.execute(db);
+  await sql`drop trigger transaction_line_classification_usage_insert
+    on accounting.transaction_line`.execute(db);
+  await sql`drop trigger transaction_line_classification_usage_update
+    on accounting.transaction_line`.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.enqueue_line_classification_usage()
+  `.execute(db);
+  await sql`
+    create trigger payment_line_classification_usage_update
+    after update on public.payment_line
+    referencing old table as old_payment_lines new table as new_payment_lines
+    for each statement
+    execute function public.enqueue_line_classification_usage()
+  `.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.enqueue_transaction_line_classification_usage()
+  `.execute(db);
+  await sql`
+    create trigger transaction_line_classification_usage_update
+    after update on accounting.transaction_line
+    referencing old table as old_transaction_lines
+      new table as new_transaction_lines
+    for each statement
+    execute function public.enqueue_transaction_line_classification_usage()
+  `.execute(db);
+  await sql`
+    create trigger reservation_line_mapping_usage_insert
+    after insert on accounting.account_reservation_line_type
+    referencing new table as new_reservation_line_mappings
+    for each statement
+    execute function public.enqueue_reservation_line_mapping_usage()
+  `.execute(db);
+  await sql`
+    create trigger reservation_line_mapping_usage_update
+    after update on accounting.account_reservation_line_type
+    referencing old table as old_reservation_line_mappings
+      new table as new_reservation_line_mappings
+    for each statement
+    execute function public.enqueue_reservation_line_mapping_usage()
+  `.execute(db);
+  await sql`
+    create trigger reservation_line_mapping_usage_delete
+    after delete on accounting.account_reservation_line_type
+    referencing old table as old_reservation_line_mappings
+    for each statement
+    execute function public.enqueue_reservation_line_mapping_usage()
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`set local lock_timeout = '5s'`.execute(db);
+  await sql`drop trigger reservation_line_mapping_usage_delete
+    on accounting.account_reservation_line_type`.execute(db);
+  await sql`drop trigger reservation_line_mapping_usage_update
+    on accounting.account_reservation_line_type`.execute(db);
+  await sql`drop trigger reservation_line_mapping_usage_insert
+    on accounting.account_reservation_line_type`.execute(db);
+  await sql`drop trigger payment_line_classification_usage_insert
+    on public.payment_line`.execute(db);
+  await sql`drop trigger payment_line_classification_usage_update
+    on public.payment_line`.execute(db);
+  await sql`drop trigger transaction_line_classification_usage_insert
+    on accounting.transaction_line`.execute(db);
+  await sql`drop trigger transaction_line_classification_usage_update
+    on accounting.transaction_line`.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 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);
+  await sql`drop function
+    public.enqueue_reservation_line_mapping_usage()`.execute(db);
+  await sql`drop function
+    public.enqueue_transaction_line_classification_usage()`.execute(db);
+  await sql`drop function public.enqueue_line_classification_usage()`.execute(
+    db
+  );
+  await sql`drop table public.line_classification_usage_capture`.execute(db);
+}

package/build/migrations-v2/0000000000027-payout-replacement-chain.ts

@@ -0,0 +1,27 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`set local lock_timeout = '5s'`.execute(db);
+  await sql`set local statement_timeout = '60s'`.execute(db);
+  await sql`
+    alter table accounting.transaction
+      add column recreated_from_transaction_id uuid null
+      references accounting.transaction (id) on delete restrict
+  `.execute(db);
+  await sql`
+    create unique index transaction_recreated_from_unique_idx
+      on accounting.transaction (tenant_id, recreated_from_transaction_id)
+      where recreated_from_transaction_id is not null
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    drop index if exists accounting.transaction_recreated_from_unique_idx
+  `.execute(db);
+  await sql`
+    alter table accounting.transaction
+      drop column if exists recreated_from_transaction_id
+  `.execute(db);
+}

package/build/migrations-v2/0000000000028-accounting-integrity-operator-workflow.ts

@@ -0,0 +1,108 @@
+import { type Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`set local lock_timeout = '5s'`.execute(db);
+  await sql`
+    alter table health.accounting_integrity_case
+      add column assigned_to text,
+      add column assigned_at timestamptz,
+      add column reviewed_by text,
+      add column reviewed_at timestamptz,
+      add column review_rationale text,
+      add constraint accounting_integrity_case_assignment_check check (
+        (assigned_to is null) = (assigned_at is null)
+      ),
+      add constraint accounting_integrity_case_review_metadata_check check (
+        (review_status = 'unreviewed' and reviewed_by is null and
+          reviewed_at is null and review_rationale is null)
+        or
+        (review_status <> 'unreviewed' and reviewed_by is not null and
+          reviewed_at is not null and nullif(trim(review_rationale), '')
+            is not null)
+      ) not valid
+  `.execute(db);
+  await sql`
+    update health.accounting_integrity_case
+    set
+      reviewed_by = 'legacy-monitoring',
+      reviewed_at = last_changed_at,
+      review_rationale = 'Migrated from pre-operator review state.'
+    where review_status <> 'unreviewed'
+  `.execute(db);
+  await sql`
+    alter table health.accounting_integrity_case
+      validate constraint accounting_integrity_case_review_metadata_check
+  `.execute(db);
+  await sql`
+    create table health.accounting_integrity_operator_event (
+      id uuid primary key default gen_random_uuid(),
+      case_id uuid
+        references health.accounting_integrity_case(id) on delete cascade,
+      plan_id uuid
+        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,
+      case_version bigint,
+      type text not null,
+      actor_id text not null,
+      client text not null,
+      request_id text not null,
+      idempotency_key text not null unique,
+      rationale text,
+      payload jsonb not null,
+      created_at timestamptz not null default now(),
+      constraint accounting_integrity_operator_event_scope_check check (
+        case_id is not null or plan_id is not null
+      ),
+      constraint accounting_integrity_operator_event_client_check check (
+        client in ('mcp', 'portal', 'cli_break_glass', 'internal_service')
+      ),
+      constraint accounting_integrity_operator_event_type_check check (
+        type in (
+          'case_claimed',
+          'case_released',
+          'case_reviewed',
+          'repair_plan_created',
+          'repair_approval_requested'
+        )
+      )
+    )
+  `.execute(db);
+  await sql`
+    create index accounting_integrity_operator_event_case_idx
+      on health.accounting_integrity_operator_event (
+        case_id,
+        created_at,
+        id
+      )
+  `.execute(db);
+  await sql`
+    create index accounting_integrity_operator_event_plan_idx
+      on health.accounting_integrity_operator_event (
+        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_operator_event
+  `.execute(db);
+  await sql`
+    alter table health.accounting_integrity_case
+      drop constraint accounting_integrity_case_review_metadata_check,
+      drop constraint accounting_integrity_case_assignment_check,
+      drop column review_rationale,
+      drop column reviewed_at,
+      drop column reviewed_by,
+      drop column assigned_at,
+      drop column assigned_to
+  `.execute(db);
+}