@vrplatform/kysely 1.3.41 → 1.3.45-4444

package/build/migrations/0000000000043-gl-pms-accounting-window-guard.ts

@@ -0,0 +1,125 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`
+    create or replace function public.assert_gl_pms_accounting_window_for_tenant(
+      check_tenant_id uuid
+    )
+    returns void
+    language plpgsql
+    as $$
+    begin
+      if check_tenant_id is null then
+        return;
+      end if;
+
+      if exists (
+        select 1
+        from public.tenant as tenant
+        where tenant.id = check_tenant_id
+          and tenant.is_general_ledger is true
+          and exists (
+            select 1
+            from public.connection as connection
+            inner join public.app as app on app.id = connection.app_id
+            where connection.tenant_id = check_tenant_id
+              and connection.status = 'active'
+              and connection.accounting_start_at is null
+              and app.category = 'propertyManagementSystem'
+          )
+          and not exists (
+            select 1
+            from public.connection as connection
+            inner join public.app as app on app.id = connection.app_id
+            where connection.tenant_id = check_tenant_id
+              and connection.status = 'active'
+              and connection.accounting_start_at is not null
+              and connection.accounting_end_at is null
+              and app.category = 'propertyManagementSystem'
+          )
+      ) then
+        raise exception
+          'Active GL PMS connection is missing accountingStartAt without an open PMS accounting source'
+          using errcode = '23514';
+      end if;
+    end;
+    $$;
+  `.execute(db);
+
+  await sql`
+    create or replace function public.assert_gl_pms_accounting_window_connection_trigger()
+    returns trigger
+    language plpgsql
+    as $$
+    begin
+      if tg_op = 'DELETE' then
+        perform public.assert_gl_pms_accounting_window_for_tenant(old.tenant_id);
+        return null;
+      end if;
+
+      if tg_op = 'UPDATE' and new.tenant_id is distinct from old.tenant_id then
+        perform public.assert_gl_pms_accounting_window_for_tenant(old.tenant_id);
+      end if;
+
+      perform public.assert_gl_pms_accounting_window_for_tenant(new.tenant_id);
+      return null;
+    end;
+    $$;
+  `.execute(db);
+
+  await sql`
+    create or replace function public.assert_gl_pms_accounting_window_tenant_trigger()
+    returns trigger
+    language plpgsql
+    as $$
+    begin
+      if new.is_general_ledger is true then
+        perform public.assert_gl_pms_accounting_window_for_tenant(new.id);
+      end if;
+
+      return null;
+    end;
+    $$;
+  `.execute(db);
+
+  await sql`
+    create constraint trigger connection_gl_pms_accounting_window_guard
+    after insert or update or delete on public.connection
+    deferrable initially deferred
+    for each row
+    execute function public.assert_gl_pms_accounting_window_connection_trigger();
+  `.execute(db);
+
+  await sql`
+    create constraint trigger tenant_gl_pms_accounting_window_guard
+    after insert or update on public.tenant
+    deferrable initially deferred
+    for each row
+    execute function public.assert_gl_pms_accounting_window_tenant_trigger();
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`
+    drop trigger if exists tenant_gl_pms_accounting_window_guard
+    on public.tenant;
+  `.execute(db);
+
+  await sql`
+    drop trigger if exists connection_gl_pms_accounting_window_guard
+    on public.connection;
+  `.execute(db);
+
+  await sql`
+    drop function if exists public.assert_gl_pms_accounting_window_tenant_trigger();
+  `.execute(db);
+
+  await sql`
+    drop function if exists public.assert_gl_pms_accounting_window_connection_trigger();
+  `.execute(db);
+
+  await sql`
+    drop function if exists public.assert_gl_pms_accounting_window_for_tenant(uuid);
+  `.execute(db);
+}

package/build/migrations/0000000000044-tenant-cross-region-fks.ts

@@ -0,0 +1,45 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+// Tenant-to-tenant references (partner, billing partner, chart-of-accounts
+// source) are cross-region: a partner homed in one cell manages tenants in
+// another, so these self-referential FKs cannot hold within a single regional
+// database. The control plane holds the authoritative tenant graph; the
+// regional columns keep the ids as plain references. Drop the FKs.
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`
+    alter table public.tenant
+      drop constraint if exists tenant_partner_id_fkey;
+  `.execute(db);
+  await sql`
+    alter table public.tenant
+      drop constraint if exists tenant_billing_partner_id_fkey;
+  `.execute(db);
+  await sql`
+    alter table public.tenant
+      drop constraint if exists tenant_chart_of_account_tenant_id_fkey;
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  // NOT VALID: cross-region references may already exist; only future writes
+  // are constrained again.
+  await sql`
+    alter table public.tenant
+      add constraint tenant_partner_id_fkey
+        foreign key (partner_id) references public.tenant(id)
+        on update restrict on delete restrict not valid;
+  `.execute(db);
+  await sql`
+    alter table public.tenant
+      add constraint tenant_billing_partner_id_fkey
+        foreign key (billing_partner_id) references public.tenant(id)
+        on update restrict on delete restrict not valid;
+  `.execute(db);
+  await sql`
+    alter table public.tenant
+      add constraint tenant_chart_of_account_tenant_id_fkey
+        foreign key (chart_of_account_tenant_id) references public.tenant(id)
+        on update restrict on delete restrict not valid;
+  `.execute(db);
+}

package/build/migrations/0000000000045-cloudflare-region-env.ts

@@ -0,0 +1,100 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+const regionalApiEnvKeys = sql`array[
+  'staging-ap',
+  'staging-crunchy',
+  'staging-eu',
+  'staging-hostaway',
+  'staging-us',
+  'production-ap',
+  'production-crunchy',
+  'production-eu',
+  'production-hostaway',
+  'production-us'
+]::text[]`;
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`
+    do $$
+    begin
+      if exists (
+        select 1
+        from public.app
+        cross join lateral jsonb_each(
+          coalesce(authentication -> 'defaultConnectParamsByApiEnv', '{}'::jsonb)
+        ) as env(key, value)
+        where env.key = any(${regionalApiEnvKeys})
+          and not (
+            coalesce(authentication -> 'defaultConnectParamsByApiEnv', '{}'::jsonb)
+              ? split_part(env.key, '-', 1)
+          )
+        group by public.app.id, split_part(env.key, '-', 1)
+        having count(distinct env.value::text) > 1
+      ) then
+        raise exception
+          'Regional defaultConnectParamsByApiEnv values disagree; add staging/production explicitly before removing regional keys';
+      end if;
+    end $$;
+  `.execute(db);
+
+  await sql`
+    with base_values as (
+      select
+        public.app.id,
+        split_part(env.key, '-', 1) as base_env,
+        min(env.value::text)::jsonb as params
+      from public.app
+      cross join lateral jsonb_each(
+        coalesce(authentication -> 'defaultConnectParamsByApiEnv', '{}'::jsonb)
+      ) as env(key, value)
+      where env.key = any(${regionalApiEnvKeys})
+        and not (
+          coalesce(authentication -> 'defaultConnectParamsByApiEnv', '{}'::jsonb)
+            ? split_part(env.key, '-', 1)
+        )
+      group by public.app.id, split_part(env.key, '-', 1)
+    ),
+    per_app as (
+      select id, jsonb_object_agg(base_env, params) as params_by_env
+      from base_values
+      group by id
+    )
+    update public.app
+    set authentication = jsonb_set(
+      coalesce(authentication, '{}'::jsonb),
+      '{defaultConnectParamsByApiEnv}',
+      coalesce(authentication -> 'defaultConnectParamsByApiEnv', '{}'::jsonb)
+        || per_app.params_by_env,
+      true
+    )
+    from per_app
+    where public.app.id = per_app.id;
+  `.execute(db);
+
+  await sql`
+    update public.app
+    set authentication = jsonb_set(
+      coalesce(authentication, '{}'::jsonb),
+      '{defaultConnectParamsByApiEnv}',
+      coalesce(authentication -> 'defaultConnectParamsByApiEnv', '{}'::jsonb)
+        - 'staging-ap'
+        - 'staging-crunchy'
+        - 'staging-eu'
+        - 'staging-hostaway'
+        - 'staging-us'
+        - 'production-ap'
+        - 'production-crunchy'
+        - 'production-eu'
+        - 'production-hostaway'
+        - 'production-us',
+      true
+    )
+    where coalesce(authentication -> 'defaultConnectParamsByApiEnv', '{}'::jsonb)
+      ?| ${regionalApiEnvKeys};
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`select 1`.execute(db);
+}

package/build/migrations/0000000000046-control-plane-outbox-alias.ts

@@ -0,0 +1,46 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`
+    create table if not exists public.control_plane_outbox (
+      id uuid primary key default gen_random_uuid(),
+      aggregate_type text not null,
+      aggregate_id text not null,
+      event_type text not null,
+      event_version integer not null,
+      data_region text,
+      payload jsonb not null default jsonb_build_object(),
+      created_at timestamptz not null default now(),
+      published_at timestamptz,
+      attempts integer not null default 0,
+      last_error text,
+      constraint control_plane_outbox_region_check
+        check (
+          data_region is null
+          or data_region in ('ap', 'crunchy', 'eu', 'hostaway', 'us')
+        ),
+      constraint control_plane_outbox_event_version_check
+        check (event_version > 0),
+      constraint control_plane_outbox_aggregate_version_key
+        unique (aggregate_type, aggregate_id, event_version)
+    );
+  `.execute(db);
+
+  await sql`
+    create index if not exists control_plane_outbox_pending_idx
+      on public.control_plane_outbox (created_at, id)
+      where published_at is null;
+  `.execute(db);
+
+  await sql`
+    create index if not exists control_plane_outbox_aggregate_idx
+      on public.control_plane_outbox (aggregate_type, aggregate_id, created_at);
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`
+    drop table if exists public.control_plane_outbox;
+  `.execute(db);
+}

package/build/migrations/0000000000047-ramp-contact-last-4-digits.ts

@@ -0,0 +1,16 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`
+    alter table accounting.contact
+    add column if not exists ramp_last4_digits text;
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`
+    alter table accounting.contact
+    drop column if exists ramp_last4_digits;
+  `.execute(db);
+}

package/build/migrations/0000000000047-tenant-status-backfill.ts

@@ -0,0 +1,40 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+// PRO-16537 part 1/2: tenant.status represents activity only
+// (active | inactive). Onboarding state lives on is_onboarding; 'deleted'
+// rows are legacy data (the delete flow hard-deletes the row) and read as
+// inactive. The DDL (default + constraint) lives in the next migration —
+// tenant has AFTER triggers, so DML and ALTER TABLE cannot share one
+// transaction.
+export async function up(db: Kysely<any>): Promise<void> {
+  // Hasura notify triggers on tenant leave pending trigger events that block
+  // the follow-up ALTER TABLE in the same migration transaction; a data-only
+  // backfill should not emit events anyway.
+  await sql`
+    alter table public.tenant disable trigger user;
+  `.execute(db);
+  await sql`
+    update public.tenant
+    set status = 'active', is_onboarding = true
+    where status = 'onboarding';
+  `.execute(db);
+  await sql`
+    update public.tenant
+    set status = 'inactive'
+    where status = 'deleted';
+  `.execute(db);
+  await sql`
+    update public.tenant
+    set status = 'active'
+    where status is null;
+  `.execute(db);
+  await sql`
+    alter table public.tenant enable trigger user;
+  `.execute(db);
+}
+
+export async function down(): Promise<void> {
+  // Backfill is not reversible; the legacy statuses carry no extra
+  // information worth restoring.
+}

package/build/migrations/0000000000048-tenant-status-constraint.ts

@@ -0,0 +1,24 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+// PRO-16537 part 2/2: default to active and reject anything outside
+// active | inactive (see 0000000000047-tenant-status-backfill).
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`
+    alter table public.tenant alter column status set default 'active';
+  `.execute(db);
+  await sql`
+    alter table public.tenant
+      add constraint tenant_status_check
+      check (status is not null and status in ('active', 'inactive'));
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`
+    alter table public.tenant drop constraint if exists tenant_status_check;
+  `.execute(db);
+  await sql`
+    alter table public.tenant alter column status set default 'onboarding';
+  `.execute(db);
+}

package/build/migrations/0000000000049-health-tenant-issues.ts

@@ -0,0 +1,69 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`create schema if not exists health;`.execute(db);
+
+  await sql`
+    create table health.tenant_issue_snapshot (
+      tenant_id uuid primary key references public.tenant(id) on delete cascade,
+      version bigint not null default 0,
+      content_hash text,
+      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 tenant_issue_snapshot_version_check check (version >= 0)
+    );
+  `.execute(db);
+
+  await sql`
+    create index tenant_issue_snapshot_dirty_idx
+      on health.tenant_issue_snapshot (dirty_at, computed_at);
+  `.execute(db);
+
+  await sql`
+    create table health.tenant_issue (
+      id uuid primary key default gen_random_uuid(),
+      tenant_id uuid not null references public.tenant(id) on delete cascade,
+      code text not null,
+      status text not null,
+      version bigint not null,
+      snapshot_version bigint not null,
+      severity text not null,
+      category text not null,
+      message text not null,
+      affected integer not null,
+      context jsonb not null,
+      content_hash text not null,
+      first_seen_at timestamptz not null,
+      opened_at timestamptz not null,
+      last_changed_at timestamptz not null,
+      resolved_at timestamptz,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      constraint tenant_issue_tenant_code_key unique (tenant_id, code),
+      constraint tenant_issue_status_check check (status in ('open', 'resolved')),
+      constraint tenant_issue_version_check check (version > 0),
+      constraint tenant_issue_snapshot_version_check check (snapshot_version > 0),
+      constraint tenant_issue_severity_check check (severity in ('error', 'warning')),
+      constraint tenant_issue_category_check
+        check (category in ('criticalToUser', 'criticalToSystem')),
+      constraint tenant_issue_affected_check
+        check (
+          (status = 'open' and affected > 0)
+          or (status = 'resolved' and affected = 0)
+        )
+    );
+  `.execute(db);
+
+  await sql`
+    create index tenant_issue_open_idx
+      on health.tenant_issue (tenant_id, code)
+      where status = 'open';
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`drop schema if exists health cascade;`.execute(db);
+}

package/build/migrations/0000000000050-partner-webhooks.ts

@@ -0,0 +1,135 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`create schema if not exists webhook;`.execute(db);
+
+  await sql`
+    create table webhook.subscription (
+      id uuid primary key default gen_random_uuid(),
+      owner_tenant_id uuid not null,
+      scope text not null,
+      url text not null,
+      status text not null default 'pending',
+      api_version text not null,
+      event_types text[] not null,
+      description text,
+      verified_at timestamptz,
+      disabled_at timestamptz,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      constraint webhook_subscription_scope_check
+        check (scope in ('self', 'managedTeams')),
+      constraint webhook_subscription_status_check
+        check (status in ('pending', 'active', 'disabled')),
+      constraint webhook_subscription_event_types_check
+        check (cardinality(event_types) > 0)
+    );
+  `.execute(db);
+
+  await sql`
+    create index webhook_subscription_owner_idx
+      on webhook.subscription (owner_tenant_id, created_at desc);
+  `.execute(db);
+
+  await sql`
+    create table webhook.subscription_secret (
+      id uuid primary key default gen_random_uuid(),
+      subscription_id uuid not null
+        references webhook.subscription(id) on delete cascade,
+      encrypted_secret text not null,
+      encryption_key_id text not null,
+      active_from timestamptz not null default now(),
+      expires_at timestamptz,
+      revoked_at timestamptz,
+      created_at timestamptz not null default now()
+    );
+  `.execute(db);
+
+  await sql`
+    create index webhook_subscription_secret_active_idx
+      on webhook.subscription_secret (subscription_id, active_from desc);
+  `.execute(db);
+
+  await sql`
+    create table webhook.delivery (
+      id uuid primary key default gen_random_uuid(),
+      source_event_key text not null,
+      subscription_id uuid not null
+        references webhook.subscription(id) on delete cascade,
+      source_tenant_id uuid,
+      event_type text not null,
+      api_version text not null,
+      resource_type text,
+      resource_id text,
+      body text not null,
+      status text not null default 'queued',
+      attempt_count integer not null default 0,
+      next_attempt_at timestamptz not null default now(),
+      claimed_at timestamptz,
+      claimed_by text,
+      last_error_code text,
+      delivered_at timestamptz,
+      failed_at timestamptz,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      constraint webhook_delivery_subscription_event_key
+        unique (subscription_id, source_event_key),
+      constraint webhook_delivery_status_check
+        check (
+          status in (
+            'queued',
+            'delivering',
+            'retrying',
+            'succeeded',
+            'failed',
+            'canceled'
+          )
+        ),
+      constraint webhook_delivery_attempt_count_check check (attempt_count >= 0)
+    );
+  `.execute(db);
+
+  await sql`
+    create index webhook_delivery_recovery_idx
+      on webhook.delivery (status, next_attempt_at);
+  `.execute(db);
+  await sql`
+    create index webhook_delivery_subscription_created_idx
+      on webhook.delivery (subscription_id, created_at desc);
+  `.execute(db);
+  await sql`
+    create index webhook_delivery_source_tenant_created_idx
+      on webhook.delivery (source_tenant_id, created_at desc);
+  `.execute(db);
+
+  await sql`
+    create table webhook.delivery_attempt (
+      id uuid primary key default gen_random_uuid(),
+      delivery_id uuid not null references webhook.delivery(id) on delete cascade,
+      subscription_secret_id uuid not null
+        references webhook.subscription_secret(id) on delete restrict,
+      attempt_number integer not null,
+      started_at timestamptz not null,
+      finished_at timestamptz not null,
+      duration_ms integer not null,
+      response_status integer,
+      error_class text,
+      response_excerpt text,
+      created_at timestamptz not null default now(),
+      constraint webhook_delivery_attempt_number_key
+        unique (delivery_id, attempt_number),
+      constraint webhook_delivery_attempt_number_check check (attempt_number > 0),
+      constraint webhook_delivery_attempt_duration_check check (duration_ms >= 0)
+    );
+  `.execute(db);
+
+  await sql`
+    create index webhook_delivery_attempt_delivery_created_idx
+      on webhook.delivery_attempt (delivery_id, created_at);
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`drop schema if exists webhook cascade;`.execute(db);
+}

package/build/migrations/0000000000051-health-webhook-runtime-grants.ts

@@ -0,0 +1,42 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`
+    do $$
+    begin
+      if exists (select 1 from pg_roles where rolname = 'application') then
+        grant usage on schema health, webhook to application;
+        grant select, insert, update, delete
+          on all tables in schema health, webhook to application;
+        grant usage, select, update
+          on all sequences in schema health, webhook to application;
+        alter default privileges in schema health, webhook
+          grant select, insert, update, delete on tables to application;
+        alter default privileges in schema health, webhook
+          grant usage, select, update on sequences to application;
+      end if;
+    end
+    $$;
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`
+    do $$
+    begin
+      if exists (select 1 from pg_roles where rolname = 'application') then
+        alter default privileges in schema health, webhook
+          revoke select, insert, update, delete on tables from application;
+        alter default privileges in schema health, webhook
+          revoke usage, select, update on sequences from application;
+        revoke select, insert, update, delete
+          on all tables in schema health, webhook from application;
+        revoke usage, select, update
+          on all sequences in schema health, webhook from application;
+        revoke usage on schema health, webhook from application;
+      end if;
+    end
+    $$;
+  `.execute(db);
+}

package/build/migrations/0000000000052-feature-approval-team-enablement.ts

@@ -0,0 +1,13 @@
+import type { Kysely } from 'kysely';
+
+// CUS-2503: retained as a no-op because this migration name reached staging.
+// Feature evaluation belongs in /me and must not manufacture team enablements
+// from user approvals. Keeping the file lets environments with an existing
+// migration-ledger entry continue to migrate safely.
+export async function up(db: Kysely<unknown>): Promise<void> {
+  void db;
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  void db;
+}