@vrplatform/kysely 1.3.41 → 1.3.45-1

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/0000000000016-managed-team-access.ts

@@ -0,0 +1,34 @@
+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
+      add column managed_team_access text not null default 'assigned',
+      add constraint tenant_user_managed_team_access_check
+        check (managed_team_access in ('all', 'assigned'))
+  `.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 managed_team_access = 'all'
+    from public.tenant as tenant
+    where tenant.id = tenant_user.tenant_id
+      and tenant.type = 'partner'
+      and tenant_user.role = 'admin'
+  `.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 managed_team_access
+  `.execute(db);
+}

package/build/migrations-v2/0000000000017-drop-trial-until.ts

@@ -0,0 +1,42 @@
+import { type Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    do $$
+    declare
+      definition text;
+      trigger_function regprocedure;
+    begin
+      for trigger_function in
+        select distinct p.oid::regprocedure
+        from pg_trigger as t
+        inner join pg_proc as p on p.oid = t.tgfoid
+        where t.tgrelid = 'public.tenant'::regclass
+          and not t.tgisinternal
+          and p.prosrc ilike '%trial_until%'
+      loop
+        definition := pg_get_functiondef(trigger_function);
+        definition := replace(definition, 'OLD."trial_until" , ', '');
+        definition := replace(definition, 'NEW."trial_until" , ', '');
+
+        if definition ilike '%trial_until%' then
+          raise exception
+            'Could not remove trial_until from tenant trigger function %',
+            trigger_function;
+        end if;
+
+        execute definition;
+      end loop;
+    end;
+    $$;
+  `.execute(db);
+  await sql`
+    alter table public.tenant drop column if exists trial_until
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table public.tenant add column trial_until date
+  `.execute(db);
+}