@vrplatform/kysely 1.3.45-stage.4897 → 1.3.45-stage.490

package/build/migrations-v2/0000000000004-audit-event-projected-at.ts

@@ -0,0 +1,15 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table audit.public_event
+      add column projected_at timestamptz not null default now();
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table audit.public_event drop column projected_at;
+  `.execute(db);
+}

package/build/migrations-v2/0000000000005-audit-recovery-indexes.ts

@@ -0,0 +1,63 @@
+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 audit_action_created_at_idx
+      on audit.action (created_at);
+  `.execute(db);
+  await sql`
+    create index if not exists audit_mutation_created_at_idx
+      on audit.mutation (created_at)
+      where capture_order is not null;
+  `.execute(db);
+  await sql`
+    create index if not exists audit_effect_created_at_idx
+      on audit.effect (created_at);
+  `.execute(db);
+  await sql`
+    create index if not exists audit_effect_completed_at_idx
+      on audit.effect (completed_at)
+      where completed_at is not null;
+  `.execute(db);
+  await sql`
+    create index if not exists audit_effect_last_attempt_at_idx
+      on audit.effect (last_attempt_at)
+      where last_attempt_at is not null;
+  `.execute(db);
+  await sql`
+    create index if not exists audit_journal_delta_changed_at_idx
+      on audit.journal_delta (changed_at);
+  `.execute(db);
+
+  const indexes = await sql<{ count: number }>`
+    select count(*)::int as count
+    from pg_index i
+    inner join pg_class c on c.oid = i.indexrelid
+    inner join pg_namespace n on n.oid = c.relnamespace
+    where n.nspname = 'audit'
+      and c.relname in (
+        'audit_action_created_at_idx',
+        'audit_mutation_created_at_idx',
+        'audit_effect_created_at_idx',
+        'audit_effect_completed_at_idx',
+        'audit_effect_last_attempt_at_idx',
+        'audit_journal_delta_changed_at_idx'
+      )
+      and i.indisvalid
+      and i.indisready
+      and i.indislive
+  `.execute(db);
+  if (Number(indexes.rows[0]?.count) !== 6) {
+    throw new Error('Audit recovery indexes are unavailable');
+  }
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`drop index audit.audit_journal_delta_changed_at_idx;`.execute(db);
+  await sql`drop index audit.audit_effect_last_attempt_at_idx;`.execute(db);
+  await sql`drop index audit.audit_effect_completed_at_idx;`.execute(db);
+  await sql`drop index audit.audit_effect_created_at_idx;`.execute(db);
+  await sql`drop index audit.audit_mutation_created_at_idx;`.execute(db);
+  await sql`drop index audit.audit_action_created_at_idx;`.execute(db);
+}

package/build/migrations-v2/0000000000006-audit-action-public-event-projected-at.ts

@@ -0,0 +1,22 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`set local lock_timeout = '180s';`.execute(db);
+  await sql`set local statement_timeout = '240s';`.execute(db);
+  await sql`
+    select pg_advisory_xact_lock(
+      hashtextextended('public_audit_event_recovery', 0)
+    );
+  `.execute(db);
+  await sql`
+    alter table audit.action
+      add column public_event_projected_at timestamptz default null;
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table audit.action drop column public_event_projected_at;
+  `.execute(db);
+}

package/build/migrations-v2/0000000000007-audit-action-public-event-projected-at-backfill.ts

@@ -0,0 +1,35 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`set local lock_timeout = '180s';`.execute(db);
+  await sql`set local statement_timeout = '240s';`.execute(db);
+  await sql`
+    select pg_advisory_xact_lock(
+      hashtextextended('public_audit_event_recovery', 0)
+    );
+  `.execute(db);
+  await sql`
+    update audit.action as action
+    set public_event_projected_at = event.projected_at
+    from (
+      select tenant_id, action_id, max(projected_at) as projected_at
+      from audit.public_event
+      group by tenant_id, action_id
+    ) as event
+    where action.tenant_id = event.tenant_id
+      and action.id = event.action_id
+      and action.public_event_projected_at is null
+      and action.created_at >= (
+        select cutover_at
+        from audit.public_event_projection_state
+        where singleton = true
+      );
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    update audit.action set public_event_projected_at = null;
+  `.execute(db);
+}

package/build/migrations-v2/0000000000008-global-user-attribution.ts

@@ -0,0 +1,33 @@
+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 core.sync
+      drop constraint if exists sync_user_id_fkey
+  `.execute(db);
+  await sql`
+    alter table public.audit_log
+      drop constraint if exists audit_log_actor_user_id_fkey
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table core.sync
+      add constraint sync_user_id_fkey
+      foreign key (user_id)
+      references public."user"(id)
+      on update restrict
+      on delete set null
+  `.execute(db);
+  await sql`
+    alter table public.audit_log
+      add constraint audit_log_actor_user_id_fkey
+      foreign key (actor_user_id)
+      references public."user"(id)
+      on update restrict
+      on delete set null
+  `.execute(db);
+}

package/build/migrations-v2/0000000000008-team-issue-rule-state.ts

@@ -0,0 +1,52 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create table health.tenant_issue_rule_state (
+      tenant_id uuid not null
+        references public.tenant(id) on delete cascade,
+      code health.tenant_issue_code not null,
+      dirty_at timestamptz not null,
+      computed_at timestamptz,
+      dirty_version bigint not null default 1,
+      computed_version bigint not null default 0,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      primary key (tenant_id, code)
+    );
+  `.execute(db);
+  await sql`
+    create index tenant_issue_rule_state_dirty_idx
+      on health.tenant_issue_rule_state (dirty_at, tenant_id, code)
+      where dirty_version > computed_version;
+  `.execute(db);
+  await sql`
+    insert into health.tenant_issue_rule_state (
+      tenant_id,
+      code,
+      dirty_at,
+      computed_at,
+      computed_version,
+      created_at,
+      updated_at
+    )
+    select
+      snapshot.tenant_id,
+      code,
+      snapshot.dirty_at,
+      snapshot.computed_at,
+      case
+        when snapshot.computed_at >= snapshot.dirty_at then 1
+        else 0
+      end,
+      snapshot.created_at,
+      snapshot.updated_at
+    from health.tenant_issue_snapshot as snapshot
+    cross join unnest(enum_range(null::health.tenant_issue_code)) as code;
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`drop table health.tenant_issue_rule_state;`.execute(db);
+}

package/build/migrations-v2/0000000000009-reservation-issue-projections.ts

@@ -0,0 +1,45 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create table health.reservation_issue_snapshot (
+      reservation_id uuid primary key
+        references public.reservation(id) on delete cascade,
+      tenant_id uuid not null references public.tenant(id) on delete cascade,
+      version bigint not null default 0,
+      issues jsonb not null default '[]'::jsonb,
+      dirty_version bigint not null default 1,
+      computed_version bigint not null default 0,
+      dirty_at timestamptz not null default now(),
+      computed_at timestamptz,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      constraint reservation_issue_snapshot_version_check check (version >= 0),
+      constraint reservation_issue_snapshot_dirty_version_check
+        check (dirty_version >= 0),
+      constraint reservation_issue_snapshot_computed_version_check
+        check (computed_version >= 0)
+    );
+  `.execute(db);
+
+  await sql`
+    create index reservation_issue_snapshot_tenant_idx
+      on health.reservation_issue_snapshot (tenant_id, reservation_id);
+  `.execute(db);
+
+  await sql`
+    create index reservation_issue_snapshot_reconciliation_idx
+      on health.reservation_issue_snapshot (
+        ((dirty_version > computed_version)::int) desc,
+        computed_at,
+        reservation_id
+      );
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`drop table if exists health.reservation_issue_snapshot;`.execute(
+    db
+  );
+}

package/build/migrations-v2/0000000000010-bank-rule-application-bank-record-delete-cascade.ts

@@ -0,0 +1,26 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table accounting.bank_rule_application
+      drop constraint bank_rule_application_bank_record_id_fkey,
+      add constraint bank_rule_application_bank_record_id_fkey
+        foreign key (bank_record_id)
+        references accounting.bank_record(id)
+        on update restrict
+        on delete cascade
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table accounting.bank_rule_application
+      drop constraint bank_rule_application_bank_record_id_fkey,
+      add constraint bank_rule_application_bank_record_id_fkey
+        foreign key (bank_record_id)
+        references accounting.bank_record(id)
+        on update restrict
+        on delete restrict
+  `.execute(db);
+}

package/build/migrations-v2/0000000000011-guest-balance-journal-entry-lookup-index.ts

@@ -0,0 +1,25 @@
+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`
+    create index if not exists
+      journal_entry_transaction_reservation_tenant_idx
+      on accounting.journal_entry (
+        transaction_id,
+        reservation_id,
+        tenant_id
+      )
+      where transaction_id is not null
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    drop index if exists
+      accounting.journal_entry_transaction_reservation_tenant_idx
+  `.execute(db);
+}

package/build/migrations-v2/0000000000012-trial-free-analytics-billing-status.ts

@@ -0,0 +1,72 @@
+import { type Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create or replace function public.tenant_calculated_analytics_billing_status(
+      row_t public.tenant
+    ) returns text
+    language sql stable
+    as $$
+      with norm as (
+        select
+          lower(nullif(row_t.billing_subscription_status, '')) as sub_status,
+          nullif(trim(row_t.billing_payment_method_type), '') as pm_type,
+          coalesce(row_t.is_onboarding, false) as is_onboarding
+      )
+      select
+        case
+          when sub_status in ('cancelled', 'voided') then 'cancelled'
+          when sub_status = 'errored' then 'errored'
+          when is_onboarding then 'onboarding'
+          when sub_status is null then 'partner'
+          when sub_status = 'draft' then 'pending'
+          when sub_status = 'active' and pm_type is null then 'pending'
+          when sub_status = 'active' and pm_type is not null then 'active'
+          else 'unknown'
+        end
+      from norm;
+    $$;
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create or replace function public.tenant_calculated_analytics_billing_status(
+      row_t public.tenant
+    ) returns text
+    language sql stable
+    as $$
+      with norm as (
+        select
+          lower(nullif(row_t.billing_subscription_status, '')) as sub_status,
+          nullif(trim(row_t.billing_payment_method_type), '') as pm_type,
+          row_t.trial_until as trial_until_date,
+          coalesce(row_t.is_onboarding, false) as is_onboarding
+      ),
+      flags as (
+        select
+          trial_until_date is not null
+            and trial_until_date > current_date as trial_active,
+          sub_status,
+          pm_type,
+          is_onboarding
+        from norm
+      )
+      select
+        case
+          when sub_status in ('cancelled', 'voided') then 'cancelled'
+          when sub_status = 'errored' then 'errored'
+          when is_onboarding then 'onboarding'
+          when sub_status is null then 'partner'
+          when sub_status = 'draft' then 'pending'
+          when sub_status = 'active' and trial_active then 'trial'
+          when sub_status = 'active'
+            and not trial_active
+            and pm_type is null then 'pending'
+          when sub_status = 'active' and pm_type is not null then 'active'
+          else 'unknown'
+        end
+      from flags;
+    $$;
+  `.execute(db);
+}

package/build/migrations-v2/0000000000013-ui-permission-bundles.ts

@@ -0,0 +1,45 @@
+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
+      add column partner_denied_permissions text[] not null default '{}'
+  `.execute(db);
+  await sql`
+    alter table public.tenant_user
+      add column permission_bundles text[] not null default '{}'
+  `.execute(db);
+  await sql`
+    alter table public.tenant_user
+      disable trigger set_public_tenant_user_updated_at
+  `.execute(db);
+  await sql`
+    update public.tenant_user as tenant_user
+    set permission_bundles = case
+      when tenant_user.role = 'admin' and tenant.type = 'partner'
+        then array['ui:team-admin:v1', 'ui:partner-admin:v1']::text[]
+      when tenant_user.role = 'admin'
+        then array['ui:team-admin:v1']::text[]
+      when tenant_user.role = 'user'
+        then array['ui:accounting:v1']::text[]
+      else array[]::text[]
+    end
+    from public.tenant as tenant
+    where tenant.id = tenant_user.tenant_id
+  `.execute(db);
+  await sql`
+    alter table public.tenant_user
+      enable trigger set_public_tenant_user_updated_at
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table public.tenant_user drop column permission_bundles
+  `.execute(db);
+  await sql`
+    alter table public.tenant drop column partner_denied_permissions
+  `.execute(db);
+}

package/build/migrations-v2/0000000000014-ui-permission-bundle-top-up.ts

@@ -0,0 +1,32 @@
+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_user
+      disable trigger set_public_tenant_user_updated_at
+  `.execute(db);
+  await sql`
+    update public.tenant_user as tenant_user
+    set permission_bundles = case
+      when tenant_user.role = 'admin' and tenant.type = 'partner'
+        then array['ui:team-admin:v1', 'ui:partner-admin:v1']::text[]
+      when tenant_user.role = 'admin'
+        then array['ui:team-admin:v1']::text[]
+      when tenant_user.role = 'user'
+        then array['ui:accounting:v1']::text[]
+      else tenant_user.permission_bundles
+    end
+    from public.tenant as tenant
+    where tenant.id = tenant_user.tenant_id
+      and cardinality(tenant_user.permission_bundles) = 0
+      and tenant_user.role in ('admin', 'user')
+  `.execute(db);
+  await sql`
+    alter table public.tenant_user
+      enable trigger set_public_tenant_user_updated_at
+  `.execute(db);
+}
+
+export async function down(_db: Kysely<unknown>): Promise<void> {}

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