@vrplatform/kysely 1.3.45-stage.6033 → 1.3.45-stage.604

package/build/migrations-v2/0000000000015-durable-flow-events.ts

@@ -0,0 +1,163 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create type core.flow_event_status as enum (
+      'pending', 'processing', 'succeeded', 'dead', 'canceled'
+    )
+  `.execute(db);
+  await sql`
+    create type core.flow_event_operation_action as enum (
+      'replay', 'abandon'
+    )
+  `.execute(db);
+
+  await sql`
+    create table core.flow_event (
+      id uuid primary key default gen_random_uuid(),
+      tenant_id uuid not null,
+      event_type text not null,
+      entity_type text not null,
+      entity_id uuid not null,
+      data jsonb not null default '{}'::jsonb,
+      sync_id uuid,
+      target_connection_id uuid,
+      target_flow_id uuid,
+      status core.flow_event_status not null default 'pending',
+      available_at timestamptz not null default now(),
+      claimed_at timestamptz,
+      claimed_by text,
+      attempts integer not null default 0,
+      max_attempts integer not null default 10,
+      completed_at timestamptz,
+      last_error_code text,
+      last_error_details jsonb,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      constraint flow_event_attempts_check check (attempts >= 0),
+      constraint flow_event_max_attempts_check check (max_attempts > 0),
+      constraint flow_event_target_check check (
+        target_connection_id is not null
+        or target_flow_id is null
+      )
+    )
+  `.execute(db);
+
+  await sql`
+    create table core.flow_event_delivery (
+      id uuid primary key default gen_random_uuid(),
+      event_id uuid not null
+        references core.flow_event(id) on delete cascade,
+      tenant_id uuid not null,
+      connection_id uuid not null,
+      flow_id uuid not null,
+      status core.flow_event_status not null default 'pending',
+      available_at timestamptz not null default now(),
+      claimed_at timestamptz,
+      claimed_by text,
+      attempts integer not null default 0,
+      max_attempts integer not null default 10,
+      trigger_run_id text,
+      completed_at timestamptz,
+      last_error_code text,
+      last_error_details jsonb,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      constraint flow_event_delivery_attempts_check check (attempts >= 0),
+      constraint flow_event_delivery_max_attempts_check
+        check (max_attempts > 0),
+      constraint flow_event_delivery_listener_key
+        unique (event_id, connection_id, flow_id)
+    )
+  `.execute(db);
+
+  await sql`
+    create table core.flow_event_secret (
+      event_id uuid primary key
+        references core.flow_event(id) on delete cascade,
+      encryption_key_id text not null,
+      encrypted_payload text not null,
+      expires_at timestamptz not null,
+      created_at timestamptz not null default now()
+    )
+  `.execute(db);
+  await sql`
+    create table core.flow_event_operation (
+      id uuid primary key default gen_random_uuid(),
+      event_id uuid not null references core.flow_event(id) on delete cascade,
+      action core.flow_event_operation_action not null,
+      actor text not null,
+      reason_code text not null,
+      previous_status core.flow_event_status not null,
+      created_at timestamptz not null default now()
+    )
+  `.execute(db);
+
+  await sql`
+    create index flow_event_pending_idx
+      on core.flow_event (available_at, created_at, id)
+      where status = 'pending'
+  `.execute(db);
+  await sql`
+    create index flow_event_stale_claim_idx
+      on core.flow_event (claimed_at, id)
+      where status = 'processing'
+  `.execute(db);
+  await sql`
+    create index flow_event_tenant_history_idx
+      on core.flow_event (tenant_id, created_at desc, id desc)
+  `.execute(db);
+  await sql`
+    create index flow_event_sync_idx
+      on core.flow_event (tenant_id, sync_id)
+      where sync_id is not null
+  `.execute(db);
+  await sql`
+    create index flow_event_delivery_pending_idx
+      on core.flow_event_delivery (available_at, created_at, id)
+      where status = 'pending'
+  `.execute(db);
+  await sql`
+    create index flow_event_delivery_stale_claim_idx
+      on core.flow_event_delivery (claimed_at, id)
+      where status = 'processing'
+  `.execute(db);
+  await sql`
+    create index flow_event_delivery_event_idx
+      on core.flow_event_delivery (event_id, status, id)
+  `.execute(db);
+  await sql`
+    create index flow_event_secret_expiry_idx
+      on core.flow_event_secret (expires_at, event_id)
+  `.execute(db);
+  await sql`
+    create index flow_event_operation_history_idx
+      on core.flow_event_operation (event_id, created_at desc, id desc)
+  `.execute(db);
+
+  await sql`
+    do $$
+    begin
+      if exists (select 1 from pg_roles where rolname = 'application') then
+        grant usage on schema core to application;
+        grant select, insert, update, delete
+          on core.flow_event,
+             core.flow_event_delivery,
+             core.flow_event_operation,
+             core.flow_event_secret
+          to application;
+      end if;
+    end
+    $$
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`drop table if exists core.flow_event_operation`.execute(db);
+  await sql`drop table if exists core.flow_event_secret`.execute(db);
+  await sql`drop table if exists core.flow_event_delivery`.execute(db);
+  await sql`drop table if exists core.flow_event`.execute(db);
+  await sql`drop type if exists core.flow_event_operation_action`.execute(db);
+  await sql`drop type if exists core.flow_event_status`.execute(db);
+}

package/build/migrations-v2/0000000000016-billing-listing-facts.ts

@@ -0,0 +1,539 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`create schema if not exists billing`.execute(db);
+  await sql`
+    create type billing.listing_fact_source_type as enum (
+      'listing_insert',
+      'listing_update',
+      'listing_delete',
+      'ownership_insert',
+      'ownership_update',
+      'ownership_delete',
+      'tenant_insert',
+      'tenant_update',
+      'tenant_delete',
+      'daily_reconciliation',
+      'legacy_tracking_import',
+      'baseline_backfill'
+    )
+  `.execute(db);
+  await sql`
+    create table billing.listing_fact (
+      id uuid primary key default gen_random_uuid(),
+      tenant_id uuid not null,
+      billing_partner_id uuid,
+      active_listings integer not null,
+      tenant_name text not null,
+      data_region text not null,
+      effective_at timestamptz not null,
+      recorded_at timestamptz not null default now(),
+      source_type billing.listing_fact_source_type not null,
+      source_id uuid not null,
+      source_revision bigint,
+      reconciliation boolean not null default false,
+      constraint listing_fact_active_listings_check
+        check (active_listings >= 0),
+      constraint listing_fact_source_revision_check
+        check (source_revision is null or source_revision > 0),
+      constraint listing_fact_source_key
+        unique (tenant_id, source_type, source_id)
+    )
+  `.execute(db);
+  await sql`
+    create table billing.listing_fact_readiness (
+      singleton boolean primary key default true,
+      ready_at timestamptz,
+      available_from timestamptz,
+      verified_month timestamptz,
+      legacy_imported_rows integer,
+      legacy_gap_count integer,
+      parity_confirmed boolean not null default false,
+      constraint listing_fact_readiness_singleton_check check (singleton),
+      constraint listing_fact_readiness_count_check check (
+        legacy_imported_rows is null or legacy_imported_rows >= 0
+      ),
+      constraint listing_fact_readiness_gap_count_check check (
+        legacy_gap_count is null or legacy_gap_count >= 0
+      ),
+      constraint listing_fact_readiness_evidence_check check (
+        (
+          ready_at is null
+          and available_from is null
+          and verified_month is null
+          and legacy_imported_rows is null
+          and legacy_gap_count is null
+          and parity_confirmed = false
+        ) or (
+          ready_at is not null
+          and available_from is not null
+          and verified_month is not null
+          and legacy_imported_rows is not null
+          and legacy_gap_count is not null
+          and parity_confirmed = true
+        )
+      )
+    )
+  `.execute(db);
+  await sql`
+    insert into billing.listing_fact_readiness (singleton) values (true)
+  `.execute(db);
+  await sql`
+    create index listing_fact_tenant_effective_idx
+      on billing.listing_fact (tenant_id, effective_at desc, id desc)
+  `.execute(db);
+  await sql`
+    create index listing_fact_partner_effective_idx
+      on billing.listing_fact (billing_partner_id, effective_at, tenant_id)
+  `.execute(db);
+  await sql`
+    create index listing_fact_region_recorded_idx
+      on billing.listing_fact (data_region, recorded_at, id)
+  `.execute(db);
+
+  await sql`
+    create 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);
+  await sql`
+    create function billing.record_listing_facts(
+      selected_tenant_ids uuid[],
+      selected_source_type billing.listing_fact_source_type,
+      selected_source_id uuid,
+      selected_effective_at timestamptz,
+      selected_reconciliation boolean
+    ) returns void
+    language sql
+    as $$
+      with calculated as materialized (
+        select tenant.id as tenant_id,
+               tenant.calculated_billing_partner_id as billing_partner_id,
+               billing.active_listing_count(tenant.id) as active_listings,
+               tenant.name as tenant_name,
+               tenant.data_region as data_region
+        from public.tenant as tenant
+        where tenant.id = any(selected_tenant_ids)
+          and tenant.type = 'propertyManager'
+      ), changed as (
+        select calculated.*
+        from calculated
+        left join lateral (
+          select fact.id,
+                 fact.billing_partner_id,
+                 fact.active_listings,
+                 fact.tenant_name,
+                 fact.data_region
+          from billing.listing_fact as fact
+          where fact.tenant_id = calculated.tenant_id
+          order by fact.effective_at desc, fact.recorded_at desc, fact.id desc
+          limit 1
+        ) as latest on true
+        where latest.id is null
+          or (
+            latest.billing_partner_id,
+            latest.active_listings,
+            latest.tenant_name,
+            latest.data_region
+          ) is distinct from (
+            calculated.billing_partner_id,
+            calculated.active_listings,
+            calculated.tenant_name,
+            calculated.data_region
+          )
+      )
+      insert into billing.listing_fact (
+        tenant_id,
+        billing_partner_id,
+        active_listings,
+        tenant_name,
+        data_region,
+        effective_at,
+        source_type,
+        source_id,
+        reconciliation
+      )
+      select tenant_id,
+             billing_partner_id,
+             active_listings,
+             tenant_name,
+             data_region,
+             selected_effective_at,
+             selected_source_type,
+             selected_source_id,
+             selected_reconciliation
+      from changed
+      on conflict (tenant_id, source_type, source_id) do nothing
+    $$
+  `.execute(db);
+  await sql`
+    create function billing.capture_listing_insert() returns trigger
+    language plpgsql as $$
+    begin
+      perform billing.record_listing_facts(
+        array(select distinct tenant_id from new_rows),
+        'listing_insert',
+        gen_random_uuid(),
+        now(),
+        false
+      );
+      return null;
+    end
+    $$
+  `.execute(db);
+  await sql`
+    create function billing.capture_listing_update() returns trigger
+    language plpgsql as $$
+    begin
+      perform billing.record_listing_facts(
+        array(
+          select new_row.tenant_id
+          from new_rows as new_row
+          inner join old_rows as old_row on old_row.id = new_row.id
+          where (
+            new_row.tenant_id,
+            new_row.parent_id,
+            new_row.calculated_status
+          ) is distinct from (
+            old_row.tenant_id,
+            old_row.parent_id,
+            old_row.calculated_status
+          )
+          union
+          select old_row.tenant_id
+          from new_rows as new_row
+          inner join old_rows as old_row on old_row.id = new_row.id
+          where (
+            new_row.tenant_id,
+            new_row.parent_id,
+            new_row.calculated_status
+          ) is distinct from (
+            old_row.tenant_id,
+            old_row.parent_id,
+            old_row.calculated_status
+          )
+        ),
+        'listing_update',
+        gen_random_uuid(),
+        now(),
+        false
+      );
+      return null;
+    end
+    $$
+  `.execute(db);
+  await sql`
+    create function billing.capture_listing_delete() returns trigger
+    language plpgsql as $$
+    begin
+      perform billing.record_listing_facts(
+        array(select distinct tenant_id from old_rows),
+        'listing_delete',
+        gen_random_uuid(),
+        now(),
+        false
+      );
+      return null;
+    end
+    $$
+  `.execute(db);
+  await sql`
+    create function billing.capture_ownership_insert() returns trigger
+    language plpgsql as $$
+    begin
+      perform billing.record_listing_facts(
+        array(select distinct tenant_id from new_rows),
+        'ownership_insert',
+        gen_random_uuid(),
+        now(),
+        false
+      );
+      return null;
+    end
+    $$
+  `.execute(db);
+  await sql`
+    create function billing.capture_ownership_update() returns trigger
+    language plpgsql as $$
+    begin
+      perform billing.record_listing_facts(
+        array(
+          select new_row.tenant_id
+          from new_rows as new_row
+          inner join old_rows as old_row on old_row.id = new_row.id
+          where (
+            new_row.tenant_id,
+            new_row.listing_id,
+            new_row.set_listing_inactive,
+            new_row.start_at,
+            new_row.end_at
+          ) is distinct from (
+            old_row.tenant_id,
+            old_row.listing_id,
+            old_row.set_listing_inactive,
+            old_row.start_at,
+            old_row.end_at
+          )
+          union
+          select old_row.tenant_id
+          from new_rows as new_row
+          inner join old_rows as old_row on old_row.id = new_row.id
+          where (
+            new_row.tenant_id,
+            new_row.listing_id,
+            new_row.set_listing_inactive,
+            new_row.start_at,
+            new_row.end_at
+          ) is distinct from (
+            old_row.tenant_id,
+            old_row.listing_id,
+            old_row.set_listing_inactive,
+            old_row.start_at,
+            old_row.end_at
+          )
+        ),
+        'ownership_update',
+        gen_random_uuid(),
+        now(),
+        false
+      );
+      return null;
+    end
+    $$
+  `.execute(db);
+  await sql`
+    create function billing.capture_ownership_delete() returns trigger
+    language plpgsql as $$
+    begin
+      perform billing.record_listing_facts(
+        array(select distinct tenant_id from old_rows),
+        'ownership_delete',
+        gen_random_uuid(),
+        now(),
+        false
+      );
+      return null;
+    end
+    $$
+  `.execute(db);
+  await sql`
+    create function billing.capture_tenant_insert() returns trigger
+    language plpgsql as $$
+    begin
+      perform billing.record_listing_facts(
+        array(select distinct id from new_rows),
+        'tenant_insert',
+        gen_random_uuid(),
+        now(),
+        false
+      );
+      return null;
+    end
+    $$
+  `.execute(db);
+  await sql`
+    create function billing.capture_tenant_update() returns trigger
+    language plpgsql as $$
+    begin
+      perform billing.record_listing_facts(
+        array(
+          select new_row.id
+          from new_rows as new_row
+          inner join old_rows as old_row on old_row.id = new_row.id
+          where (
+            new_row.type,
+            new_row.name,
+            new_row.data_region,
+            new_row.calculated_billing_partner_id,
+            new_row.calculated_status,
+            new_row.is_general_ledger
+          ) is distinct from (
+            old_row.type,
+            old_row.name,
+            old_row.data_region,
+            old_row.calculated_billing_partner_id,
+            old_row.calculated_status,
+            old_row.is_general_ledger
+          )
+        ),
+        'tenant_update',
+        gen_random_uuid(),
+        now(),
+        false
+      );
+      return null;
+    end
+    $$
+  `.execute(db);
+  await sql`
+    create function billing.capture_tenant_delete() returns trigger
+    language plpgsql as $$
+    begin
+      if old.type = 'propertyManager' then
+        insert into billing.listing_fact (
+          tenant_id,
+          billing_partner_id,
+          active_listings,
+          tenant_name,
+          data_region,
+          effective_at,
+          source_type,
+          source_id
+        ) values (
+          old.id,
+          old.calculated_billing_partner_id,
+          0,
+          old.name,
+          old.data_region,
+          now(),
+          'tenant_delete',
+          gen_random_uuid()
+        );
+      end if;
+      return old;
+    end
+    $$
+  `.execute(db);
+
+  await sql`
+    create trigger billing_listing_insert
+      after insert on public.listing
+      referencing new table as new_rows
+      for each statement execute function billing.capture_listing_insert()
+  `.execute(db);
+  await sql`
+    create trigger billing_listing_update
+      after update on public.listing
+      referencing old table as old_rows new table as new_rows
+      for each statement execute function billing.capture_listing_update()
+  `.execute(db);
+  await sql`
+    create trigger billing_listing_delete
+      after delete on public.listing
+      referencing old table as old_rows
+      for each statement execute function billing.capture_listing_delete()
+  `.execute(db);
+  await sql`
+    create trigger billing_ownership_insert
+      after insert on public.listing_ownership_period
+      referencing new table as new_rows
+      for each statement execute function billing.capture_ownership_insert()
+  `.execute(db);
+  await sql`
+    create trigger billing_ownership_update
+      after update on public.listing_ownership_period
+      referencing old table as old_rows new table as new_rows
+      for each statement execute function billing.capture_ownership_update()
+  `.execute(db);
+  await sql`
+    create trigger billing_ownership_delete
+      after delete on public.listing_ownership_period
+      referencing old table as old_rows
+      for each statement execute function billing.capture_ownership_delete()
+  `.execute(db);
+  await sql`
+    create trigger billing_tenant_insert
+      after insert on public.tenant
+      referencing new table as new_rows
+      for each statement execute function billing.capture_tenant_insert()
+  `.execute(db);
+  await sql`
+    create trigger billing_tenant_update
+      after update on public.tenant
+      referencing old table as old_rows new table as new_rows
+      for each statement execute function billing.capture_tenant_update()
+  `.execute(db);
+  await sql`
+    create trigger billing_tenant_delete
+      before delete on public.tenant
+      for each row execute function billing.capture_tenant_delete()
+  `.execute(db);
+
+  await sql`
+    do $$
+    begin
+      if exists (select 1 from pg_roles where rolname = 'application') then
+        grant usage on schema billing to application;
+        grant select, insert on billing.listing_fact to application;
+        grant select on billing.listing_fact_readiness to application;
+        grant execute on function billing.active_listing_count(uuid)
+          to application;
+        grant execute on function billing.record_listing_facts(
+          uuid[], billing.listing_fact_source_type, uuid, timestamptz, boolean
+        ) to application;
+      end if;
+    end
+    $$
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`drop trigger if exists billing_tenant_delete on public.tenant`.execute(
+    db
+  );
+  await sql`drop trigger if exists billing_tenant_update on public.tenant`.execute(
+    db
+  );
+  await sql`drop trigger if exists billing_tenant_insert on public.tenant`.execute(
+    db
+  );
+  await sql`drop trigger if exists billing_ownership_delete on public.listing_ownership_period`.execute(
+    db
+  );
+  await sql`drop trigger if exists billing_ownership_update on public.listing_ownership_period`.execute(
+    db
+  );
+  await sql`drop trigger if exists billing_ownership_insert on public.listing_ownership_period`.execute(
+    db
+  );
+  await sql`drop trigger if exists billing_listing_delete on public.listing`.execute(
+    db
+  );
+  await sql`drop trigger if exists billing_listing_update on public.listing`.execute(
+    db
+  );
+  await sql`drop trigger if exists billing_listing_insert on public.listing`.execute(
+    db
+  );
+  await sql`drop schema if exists billing cascade`.execute(db);
+}