@vrplatform/kysely 1.3.45-stage.11 → 1.3.45-stage.1104

package/build/migrations-v2/0000000000056-journal-operation-failure-precedence.ts

@@ -0,0 +1,306 @@
+import { type Kysely, sql } from 'kysely';
+
+// The served `core.operation.failure_code` projection must agree with the
+// TypeScript classifier in `packages/repository/src/journal-freshness/load.ts`:
+// a governing accounting lock wins over a retained failure (CUS-2936), and a
+// retained unbalanced attempt is recognized by its message prefix as well as by
+// the typed result code (CUS-2894).
+const failureProjection = (ordering: 'lock-first' | 'failure-first') => sql`
+  create or replace function core.refresh_operation_state(
+    target_operation_id uuid
+  ) returns void
+  language plpgsql
+  as $$
+  declare
+    next_status core.operation_status;
+    next_started_at timestamptz;
+    next_finished_at timestamptz;
+    next_failure_code text;
+    next_failure_message text;
+    target_operation_type core.operation_type;
+    target_public_id_format core.operation_public_id_format;
+    target_action_id uuid;
+  begin
+    select
+      operation.type,
+      operation.public_id_format,
+      source.source_id
+    into
+      target_operation_type,
+      target_public_id_format,
+      target_action_id
+    from core.operation as operation
+    left join core.operation_source as source
+      on source.operation_id = operation.id
+      and source.source_type = 'audit-action'
+    where operation.id = target_operation_id;
+
+    select
+      case
+        when count(*) filter (where required) = 0 then 'queued'
+        when bool_and(status = 'completed') filter (where required)
+          then 'completed'
+        when bool_and(status in ('completed', 'failed')) filter (where required)
+          then 'failed'
+        when bool_or(status = 'running') filter (where required)
+          or bool_or(status in ('completed', 'failed')) filter (where required)
+          then 'running'
+        else 'queued'
+      end::core.operation_status,
+      min(started_at) filter (where required),
+      max(finished_at) filter (where required)
+    into next_status, next_started_at, next_finished_at
+    from core.operation_source
+    where operation_id = target_operation_id;
+
+    if next_status = 'failed' then
+      if target_operation_type = 'reservation-journal-refresh'
+        and target_action_id is not null then
+        select
+          case
+            ${sql.raw(
+              ordering === 'lock-first'
+                ? `when core.journal_refresh_all_outstanding_locked(
+                      bool_and(
+                        case
+                          when invalidation.id is not null
+                            and invalidation.applied_at is null
+                          then effect.status = 'completed'
+                            and attempt.status is not distinct from 'skipped_locked'
+                        end
+                      ),
+                      bool_and(
+                        case
+                          when invalidation.id is not null
+                            and invalidation.applied_at is null
+                          then core.journal_reservation_refresh_locked(
+                            invalidation.tenant_id,
+                            invalidation.reservation_id
+                          )
+                        end
+                      )
+                    ) then 'journalLocked'
+                    when bool_or(
+                      invalidation.applied_at is null
+                      and attempt.result_code = 'journal_configuration_invalid'
+                    ) then 'journalConfigurationInvalid'
+                    when bool_or(
+                      invalidation.applied_at is null
+                      and (
+                        attempt.result_code = 'journal_unbalanced'
+                        or attempt.error_message like 'Journal refresh produced unbalanced%'
+                      )
+                    ) then 'journalUnbalanced'`
+                : `when bool_or(
+                      invalidation.applied_at is null
+                      and attempt.result_code = 'journal_unbalanced'
+                    ) then 'journalUnbalanced'
+                    when bool_or(
+                      invalidation.applied_at is null
+                      and attempt.result_code = 'journal_configuration_invalid'
+                    ) then 'journalConfigurationInvalid'
+                    when bool_or(
+                      invalidation.applied_at is null
+                      and attempt.result_code in (
+                        'statement_period_locked',
+                        'skipped_locked'
+                      )
+                    ) then 'journalLocked'`
+            )}
+            else 'journalRefreshFailed'
+          end,
+          case
+            ${sql.raw(
+              ordering === 'lock-first'
+                ? `when core.journal_refresh_all_outstanding_locked(
+                      bool_and(
+                        case
+                          when invalidation.id is not null
+                            and invalidation.applied_at is null
+                          then effect.status = 'completed'
+                            and attempt.status is not distinct from 'skipped_locked'
+                        end
+                      ),
+                      bool_and(
+                        case
+                          when invalidation.id is not null
+                            and invalidation.applied_at is null
+                          then core.journal_reservation_refresh_locked(
+                            invalidation.tenant_id,
+                            invalidation.reservation_id
+                          )
+                        end
+                      )
+                    ) then 'Journal refresh is blocked by accounting locks'
+                    when bool_or(
+                      invalidation.applied_at is null
+                      and attempt.result_code = 'journal_configuration_invalid'
+                    ) then 'Journal configuration is invalid'
+                    when bool_or(
+                      invalidation.applied_at is null
+                      and (
+                        attempt.result_code = 'journal_unbalanced'
+                        or attempt.error_message like 'Journal refresh produced unbalanced%'
+                      )
+                    ) then 'Journal refresh produced unbalanced entries'`
+                : `when bool_or(
+                      invalidation.applied_at is null
+                      and attempt.result_code = 'journal_unbalanced'
+                    ) then 'Journal refresh produced unbalanced entries'
+                    when bool_or(
+                      invalidation.applied_at is null
+                      and attempt.result_code = 'journal_configuration_invalid'
+                    ) then 'Journal configuration is invalid'
+                    when bool_or(
+                      invalidation.applied_at is null
+                      and attempt.result_code in (
+                        'statement_period_locked',
+                        'skipped_locked'
+                      )
+                    ) then 'Journal refresh is blocked by accounting locks'`
+            )}
+            else 'Journal refresh failed'
+          end
+        into next_failure_code, next_failure_message
+        from audit.effect as effect
+        left join accounting.reservation_journal_invalidation as invalidation
+          on invalidation.tenant_id = effect.tenant_id
+          and invalidation.effect_id = effect.id
+        left join lateral (
+          select
+            effect_attempt.status,
+            effect_attempt.result_code,
+            effect_attempt.error_message
+          from audit.effect_attempt as effect_attempt
+          where effect_attempt.tenant_id = effect.tenant_id
+            and effect_attempt.effect_id = effect.id
+          order by effect_attempt.attempt_num desc
+          limit 1
+        ) as attempt on true
+        where effect.action_id = target_action_id
+          and effect.effect_type = 'REFRESH_RESERVATION_JOURNAL'
+          and effect.entity_type = 'reservation';
+      else
+        next_failure_code := 'operation_failed';
+        next_failure_message := 'Operation failed';
+      end if;
+    else
+      next_failure_code := null;
+      next_failure_message := null;
+    end if;
+
+    update core.operation
+    set
+      status = next_status,
+      started_at = coalesce(core.operation.started_at, next_started_at),
+      finished_at = case
+        when next_status in ('completed', 'failed')
+          then coalesce(next_finished_at, now())
+        else null
+      end,
+      failure_code = next_failure_code,
+      failure_message = next_failure_message,
+      updated_at = now(),
+      source_version = source_version + 1
+    where id = target_operation_id
+      and (
+        status is distinct from next_status
+        or started_at is distinct from coalesce(started_at, next_started_at)
+        or finished_at is distinct from case
+          when next_status in ('completed', 'failed')
+            then coalesce(next_finished_at, finished_at, now())
+          else null
+        end
+        or failure_code is distinct from next_failure_code
+        or failure_message is distinct from next_failure_message
+      );
+  end;
+  $$
+`;
+
+// The reservation lock driver from `isReservationRefreshLocked`: the refresh is
+// locked when every active reservation entry sits in a published statement or
+// in closed books.
+const reservationRefreshLocked = sql`
+  create or replace function core.journal_reservation_refresh_locked(
+    target_tenant_id uuid,
+    target_reservation_id uuid
+  ) returns boolean
+  language sql
+  stable
+  as $$
+    select exists (
+      select 1
+      from accounting.journal_entry as entry
+      inner join public.tenant as tenant on tenant.id = entry.tenant_id
+      where entry.tenant_id = target_tenant_id
+        and entry.reservation_id = target_reservation_id
+        and entry.status = 'active'
+        and (entry.entity_type is null or entry.entity_type = 'reservation')
+        and (
+          entry.attached_to_owner_statement_id is not null
+          or entry.transfer_owner_statement_id is not null
+          or entry.txn_at < tenant.books_closed_at
+        )
+    )
+  $$
+`;
+
+// `bool_and` over no outstanding invalidation returns null; the classifier
+// treats that as "not locked".
+const allOutstandingLocked = sql`
+  create or replace function core.journal_refresh_all_outstanding_locked(
+    all_lock_skipped boolean,
+    all_reservations_locked boolean
+  ) returns boolean
+  language sql
+  immutable
+  as $$
+    select coalesce(all_lock_skipped, false) or coalesce(all_reservations_locked, false)
+  $$
+`;
+
+async function recomputeFailedJournalOperations(db: Kysely<unknown>) {
+  // Derived operation state only. Attempts, invalidations and journals are untouched.
+  await sql`
+    select core.refresh_operation_state(operation.id)
+    from core.operation as operation
+    where operation.type = 'reservation-journal-refresh'
+      and operation.status = 'failed'
+      and exists (
+        select 1 from core.operation_source as source
+        where source.operation_id = operation.id
+          and source.source_type = 'audit-action'
+      )
+  `.execute(db);
+}
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    do $$
+    begin
+      if position(
+        'and target_public_id_format = ''action'''
+        in pg_get_functiondef('core.refresh_operation_state(uuid)'::regprocedure)
+      ) > 0 then
+        raise exception 'Journal operation failure projection has an unexpected definition';
+      end if;
+    end;
+    $$
+  `.execute(db);
+  await reservationRefreshLocked.execute(db);
+  await allOutstandingLocked.execute(db);
+  await failureProjection('lock-first').execute(db);
+  await recomputeFailedJournalOperations(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await failureProjection('failure-first').execute(db);
+  await recomputeFailedJournalOperations(db);
+  await sql`drop function if exists core.journal_refresh_all_outstanding_locked(boolean, boolean)`.execute(
+    db
+  );
+  await sql`drop function if exists core.journal_reservation_refresh_locked(uuid, uuid)`.execute(
+    db
+  );
+}

package/build/migrations-v2/0000000000057-journal-invalidation-failure-code.ts

@@ -0,0 +1,28 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+// An inline reservation journal refresh has no effect row, so a refresh that
+// completes without writing the reservation's postings had nowhere to record
+// why. Storage only: nullable column, no default, no backfill, no rewrite.
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create type accounting.reservation_journal_invalidation_failure as enum (
+      'journal_configuration_invalid'
+    )
+  `.execute(db);
+  await sql`
+    alter table accounting.reservation_journal_invalidation
+      add column failure_code
+        accounting.reservation_journal_invalidation_failure
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table accounting.reservation_journal_invalidation
+      drop column if exists failure_code
+  `.execute(db);
+  await sql`
+    drop type if exists accounting.reservation_journal_invalidation_failure
+  `.execute(db);
+}

package/build/migrations-v2/0000000000058-journal-invalidation-locked-failure.ts

@@ -0,0 +1,16 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+// An inline reservation journal refresh refused by an accounting lock records
+// why on its invalidation, like a discarded build does. Storage only: the
+// value must be readable on every channel before the writer starts using it.
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter type accounting.reservation_journal_invalidation_failure
+      add value if not exists 'journal_locked'
+  `.execute(db);
+}
+
+export async function down(_db: Kysely<unknown>): Promise<void> {
+  // PostgreSQL enum values cannot be removed safely without rebuilding the type.
+}

package/build/migrations-v2/0000000000059-billing-active-listing-cross-region-partner.ts

@@ -0,0 +1,135 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+// CUS-2977: a billing partner homed in another data region has no row in this
+// regional database. That absence is valid and must not make the team count
+// zero active listings. Only a locally present, non-active billing partner
+// does, matching kysely `whereTenantActive` (PRO-17712). `create or replace`
+// keeps the existing grants.
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create or replace function billing.active_listing_count(
+      selected_tenant_id uuid
+    ) returns integer
+    language sql
+    stable
+    as $$
+      select count(*)::integer
+      from public.listing as listing
+      inner join public.tenant as tenant
+        on tenant.id = listing.tenant_id
+      where listing.tenant_id = selected_tenant_id
+        and tenant.calculated_status = 'active'
+        and not exists (
+          select 1
+          from public.tenant as billing_partner
+          where billing_partner.id = coalesce(
+            tenant.calculated_billing_partner_id,
+            '7bfec41f-aa3f-4602-95d2-f7996e4f0e59'::uuid
+          )
+            and billing_partner.calculated_status is distinct from 'active'
+        )
+        and (
+          (
+            tenant.is_general_ledger = false
+            and listing.calculated_status = 'active'
+          ) or (
+            tenant.is_general_ledger = true
+            and not exists (
+              select 1
+              from public.listing_ownership_period as ownership
+              where ownership.listing_id = coalesce(
+                listing.parent_id,
+                listing.id
+              )
+                and ownership.tenant_id = listing.tenant_id
+                and ownership.set_listing_inactive = true
+                and ownership.start_at <= current_date
+                and (
+                  ownership.end_at is null
+                  or ownership.end_at >= current_date
+                )
+            )
+          )
+        )
+    $$
+  `.execute(db);
+
+  // Append a corrected fact, effective now, for every active team whose
+  // billing partner has no local row. These are the only teams whose count
+  // changes. Completed-month billing reads the latest fact before the month
+  // ends, so applying this before the month closes corrects that month.
+  // Earlier wrong facts stay as recorded history.
+  await sql`
+    select billing.record_listing_facts(
+      array(
+        select tenant.id
+        from public.tenant as tenant
+        where tenant.type = 'propertyManager'
+          and tenant.calculated_status = 'active'
+          and tenant.calculated_billing_partner_id is not null
+          and not exists (
+            select 1
+            from public.tenant as billing_partner
+            where billing_partner.id = tenant.calculated_billing_partner_id
+          )
+          and exists (
+            select 1
+            from billing.listing_fact as fact
+            where fact.tenant_id = tenant.id
+          )
+      ),
+      'daily_reconciliation',
+      gen_random_uuid(),
+      now(),
+      true
+    )
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create or replace function billing.active_listing_count(
+      selected_tenant_id uuid
+    ) returns integer
+    language sql
+    stable
+    as $$
+      select count(*)::integer
+      from public.listing as listing
+      inner join public.tenant as tenant
+        on tenant.id = listing.tenant_id
+      left join public.tenant as billing_partner
+        on billing_partner.id = tenant.calculated_billing_partner_id
+      where listing.tenant_id = selected_tenant_id
+        and tenant.calculated_status = 'active'
+        and (
+          tenant.calculated_billing_partner_id is null
+          or billing_partner.calculated_status = 'active'
+        )
+        and (
+          (
+            tenant.is_general_ledger = false
+            and listing.calculated_status = 'active'
+          ) or (
+            tenant.is_general_ledger = true
+            and not exists (
+              select 1
+              from public.listing_ownership_period as ownership
+              where ownership.listing_id = coalesce(
+                listing.parent_id,
+                listing.id
+              )
+                and ownership.tenant_id = listing.tenant_id
+                and ownership.set_listing_inactive = true
+                and ownership.start_at <= current_date
+                and (
+                  ownership.end_at is null
+                  or ownership.end_at >= current_date
+                )
+            )
+          )
+        )
+    $$
+  `.execute(db);
+}

package/build/migrations-v2/0000000000060-accounting-integrity-change-driven.ts

@@ -0,0 +1,99 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create type health.accounting_integrity_dirty_record_type as enum (
+      'reservation',
+      'transaction'
+    )
+  `.execute(db);
+
+  await sql`
+    create table health.accounting_integrity_dirty_record (
+      tenant_id uuid not null references public.tenant(id) on delete cascade,
+      record_type health.accounting_integrity_dirty_record_type not null,
+      record_id uuid not null,
+      dirty_version bigint not null default 1,
+      computed_version bigint not null default 0,
+      dirty_at timestamptz not null default now(),
+      computed_at timestamptz,
+      claimed_until timestamptz,
+      claim_token uuid,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      constraint accounting_integrity_dirty_record_identity_key
+        primary key (tenant_id, record_type, record_id),
+      constraint accounting_integrity_dirty_record_version_check
+        check (dirty_version >= 0 and computed_version >= 0)
+    )
+  `.execute(db);
+
+  await sql`
+    create index accounting_integrity_dirty_record_pending_idx
+      on health.accounting_integrity_dirty_record (
+        dirty_at,
+        tenant_id,
+        record_type,
+        record_id,
+        claimed_until
+      )
+      where dirty_version > computed_version
+  `.execute(db);
+
+  await sql`
+    create table health.accounting_integrity_sweep_cursor (
+      record_type health.accounting_integrity_dirty_record_type primary key,
+      last_tenant_id uuid,
+      last_record_id uuid,
+      cycle_started_at timestamptz not null default now(),
+      last_cycle_completed_at timestamptz,
+      definitions_hash text,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now()
+    )
+  `.execute(db);
+
+  await sql`
+    create table health.accounting_integrity_comparison_finding (
+      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,
+      record_type health.accounting_integrity_dirty_record_type not null,
+      record_id uuid not null,
+      case_key text not null,
+      severity health.accounting_integrity_severity not null,
+      content_hash text not null,
+      first_seen_at timestamptz not null,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      constraint accounting_integrity_comparison_finding_identity_key
+        unique (data_region, code, tenant_id, case_key)
+    )
+  `.execute(db);
+
+  await sql`
+    create index accounting_integrity_comparison_finding_report_idx
+      on health.accounting_integrity_comparison_finding (
+        data_region,
+        code,
+        case_key
+      )
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    drop table if exists health.accounting_integrity_comparison_finding
+  `.execute(db);
+  await sql`
+    drop table if exists health.accounting_integrity_sweep_cursor
+  `.execute(db);
+  await sql`
+    drop table if exists health.accounting_integrity_dirty_record
+  `.execute(db);
+  await sql`
+    drop type if exists health.accounting_integrity_dirty_record_type
+  `.execute(db);
+}

package/build/migrations-v2/0000000000061-tenant-pending-onboarding-status.ts

@@ -0,0 +1,37 @@
+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 public.tenant
+    alter column calculated_status set expression as (
+      case
+        when status = 'active' and (
+          billing_subscription_status = 'active'
+          or billing_subscription_status is null
+          or (billing_subscription_status = 'pending' and is_onboarding = true)
+        ) then 'active'
+        else 'inactive'
+      end
+    )
+  `.execute(db);
+}
+
+export async function down(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 public.tenant
+    alter column calculated_status set expression as (
+      case
+        when status = 'active' and (
+          billing_subscription_status = 'active'
+          or billing_subscription_status is null
+        ) then 'active'
+        else 'inactive'
+      end
+    )
+  `.execute(db);
+}

package/build/migrations-v2/0000000000062-statement-payout-operations.ts

@@ -0,0 +1,16 @@
+import { type Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`alter table core.async_operation_result add column checkpoint jsonb`.execute(
+    db
+  );
+  await sql`alter type core.operation_type add value if not exists 'statement-payout'`.execute(
+    db
+  );
+  await sql`alter type core.operation_type add value if not exists 'statement-payout-preview'`.execute(
+    db
+  );
+}
+
+// PostgreSQL enum additions are retained so historical operations remain readable.
+export async function down(_db: Kysely<unknown>): Promise<void> {}

package/build/migrations-v2/0000000000063-missing-account-assignments-issue-code.ts

@@ -0,0 +1,13 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  // Expand storage only. The code must be writable on every channel before
+  // API producers mark it dirty in shared regional databases.
+  await sql`alter type health.tenant_issue_code add value if not exists 'missingAccountAssignments'`.execute(
+    db
+  );
+}
+
+// PostgreSQL enum additions are retained so historical issues remain readable.
+export async function down(_db: Kysely<unknown>): Promise<void> {}