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

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

package/build/migrations-v2/0000000000017-webhook-secret-reencryption-failures.ts

@@ -0,0 +1,18 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table webhook.subscription_secret
+      add column reencryption_failed_at timestamptz,
+      add column reencryption_failure_code text
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table webhook.subscription_secret
+      drop column reencryption_failure_code,
+      drop column reencryption_failed_at
+  `.execute(db);
+}

package/build/migrations-v2/0000000000018-accounting-integrity-monitoring.ts

@@ -0,0 +1,276 @@
+import { type Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create type health.accounting_integrity_run_status as enum (
+      'running',
+      'completed',
+      'failed',
+      'skipped'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_case_status as enum (
+      'open',
+      'resolved'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_review_status as enum (
+      'unreviewed',
+      'confirmed_issue',
+      'expected',
+      'false_positive'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_actionability as enum (
+      'automatically_repairable',
+      'manual_repair',
+      'blocked',
+      'code_fix_required',
+      'unknown'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_resolution_classification as enum (
+      'code_fix',
+      'configuration',
+      'data_repair',
+      'expected',
+      'false_positive',
+      'monitor_fix',
+      'unknown'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_severity as enum (
+      'info',
+      'warning',
+      'error',
+      'critical'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_transition_type as enum (
+      'opened',
+      'changed',
+      'reopened',
+      'resolved',
+      'reviewed'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_delivery_channel as enum (
+      'sentry',
+      'slack'
+    )
+  `.execute(db);
+  await sql`
+    create type health.accounting_integrity_delivery_status as enum (
+      'suppressed',
+      'pending',
+      'processing',
+      'delivered',
+      'failed',
+      'dead_letter'
+    )
+  `.execute(db);
+
+  await sql`
+    create table health.accounting_integrity_run (
+      id uuid primary key default gen_random_uuid(),
+      evaluation_id uuid not null,
+      code text not null,
+      definition_version integer not null,
+      git_revision text not null,
+      environment text not null,
+      data_region text not null,
+      status health.accounting_integrity_run_status not null,
+      started_at timestamptz not null,
+      completed_at timestamptz,
+      rows_scanned bigint not null default 0,
+      finding_row_count bigint not null default 0,
+      case_count bigint not null default 0,
+      opened_case_count bigint not null default 0,
+      changed_case_count bigint not null default 0,
+      reopened_case_count bigint not null default 0,
+      resolved_case_count bigint not null default 0,
+      unchanged_case_count bigint not null default 0,
+      error jsonb,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      constraint accounting_integrity_run_evaluation_region_code_key
+        unique (evaluation_id, data_region, code)
+    );
+  `.execute(db);
+
+  await sql`
+    create index accounting_integrity_run_metrics_idx
+      on health.accounting_integrity_run (
+        environment,
+        started_at desc
+      );
+  `.execute(db);
+
+  await sql`
+    create table health.accounting_integrity_case (
+      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,
+      case_key text not null,
+      version bigint not null default 1,
+      status health.accounting_integrity_case_status not null,
+      review_status health.accounting_integrity_review_status
+        not null default 'unreviewed',
+      actionability health.accounting_integrity_actionability not null,
+      resolution_classification
+        health.accounting_integrity_resolution_classification not null,
+      severity health.accounting_integrity_severity not null,
+      title text not null,
+      root_cause text not null,
+      expected jsonb not null,
+      actual jsonb not null,
+      impact jsonb not null,
+      lock_assessment jsonb not null,
+      evidence jsonb not null,
+      evidence_complete boolean not null,
+      portal_urls jsonb not null,
+      historical_issue_refs jsonb not null,
+      verification jsonb not null,
+      repair jsonb not null,
+      content_hash text not null,
+      run_id uuid not null
+        references health.accounting_integrity_run(id) on delete restrict,
+      definition_version integer not null,
+      git_revision text not null,
+      first_seen_at timestamptz not null,
+      last_seen_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 accounting_integrity_case_identity_key
+        unique (data_region, code, tenant_id, case_key),
+      constraint accounting_integrity_case_version_check check (version > 0)
+    );
+  `.execute(db);
+
+  await sql`
+    create index accounting_integrity_case_tenant_idx
+      on health.accounting_integrity_case (tenant_id)
+  `.execute(db);
+  await sql`
+    create index accounting_integrity_case_run_idx
+      on health.accounting_integrity_case (run_id)
+  `.execute(db);
+  await sql`
+    create index accounting_integrity_case_open_idx
+      on health.accounting_integrity_case (
+        data_region,
+        code,
+        severity,
+        tenant_id,
+        last_changed_at desc
+      )
+      where status = 'open';
+  `.execute(db);
+
+  await sql`
+    create table health.accounting_integrity_transition (
+      id uuid primary key default gen_random_uuid(),
+      run_id uuid not null
+        references health.accounting_integrity_run(id) on delete cascade,
+      case_id uuid not null
+        references health.accounting_integrity_case(id) on delete cascade,
+      case_version bigint not null,
+      type health.accounting_integrity_transition_type not null,
+      payload jsonb not null,
+      created_at timestamptz not null default now(),
+      constraint accounting_integrity_transition_case_version_type_key
+        unique (case_id, case_version, type)
+    );
+  `.execute(db);
+
+  await sql`
+    create index accounting_integrity_transition_run_idx
+      on health.accounting_integrity_transition (run_id)
+  `.execute(db);
+  await sql`
+    create table health.accounting_integrity_delivery (
+      id uuid primary key default gen_random_uuid(),
+      run_id uuid not null
+        references health.accounting_integrity_run(id) on delete cascade,
+      case_id uuid
+        references health.accounting_integrity_case(id) on delete cascade,
+      channel health.accounting_integrity_delivery_channel not null,
+      event_type text not null,
+      dedupe_key text not null unique,
+      payload jsonb not null,
+      status health.accounting_integrity_delivery_status
+        not null default 'pending',
+      attempts integer not null default 0,
+      claim_id uuid,
+      claimed_at timestamptz,
+      next_attempt_at timestamptz not null default now(),
+      delivered_at timestamptz,
+      result jsonb,
+      last_error jsonb,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now()
+    );
+  `.execute(db);
+
+  await sql`
+    create index accounting_integrity_delivery_run_idx
+      on health.accounting_integrity_delivery (run_id)
+  `.execute(db);
+  await sql`
+    create index accounting_integrity_delivery_case_idx
+      on health.accounting_integrity_delivery (case_id)
+  `.execute(db);
+  await sql`
+    create index accounting_integrity_delivery_pending_idx
+      on health.accounting_integrity_delivery (next_attempt_at, created_at, id)
+      where status in ('pending', 'processing', 'failed');
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`drop table if exists health.accounting_integrity_delivery;`.execute(
+    db
+  );
+  await sql`drop table if exists health.accounting_integrity_transition;`.execute(
+    db
+  );
+  await sql`drop table if exists health.accounting_integrity_case;`.execute(db);
+  await sql`drop table if exists health.accounting_integrity_run;`.execute(db);
+  await sql`drop type if exists health.accounting_integrity_delivery_status`.execute(
+    db
+  );
+  await sql`drop type if exists health.accounting_integrity_delivery_channel`.execute(
+    db
+  );
+  await sql`drop type if exists health.accounting_integrity_transition_type`.execute(
+    db
+  );
+  await sql`drop type if exists health.accounting_integrity_severity`.execute(
+    db
+  );
+  await sql`drop type if exists health.accounting_integrity_resolution_classification`.execute(
+    db
+  );
+  await sql`drop type if exists health.accounting_integrity_actionability`.execute(
+    db
+  );
+  await sql`drop type if exists health.accounting_integrity_review_status`.execute(
+    db
+  );
+  await sql`drop type if exists health.accounting_integrity_case_status`.execute(
+    db
+  );
+  await sql`drop type if exists health.accounting_integrity_run_status`.execute(
+    db
+  );
+}

package/build/migrations-v2/0000000000018-durable-flow-event-sensitive-input.ts

@@ -0,0 +1,28 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table core.flow_event
+      add column requires_sensitive_input boolean not null default false
+  `.execute(db);
+  await sql`drop index core.flow_event_sync_idx`.execute(db);
+  await sql`
+    create index flow_event_sync_idx
+      on core.flow_event (sync_id, status)
+      where sync_id is not null
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`drop index core.flow_event_sync_idx`.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`
+    alter table core.flow_event
+      drop column requires_sensitive_input
+  `.execute(db);
+}

package/build/migrations-v2/0000000000019-accounting-integrity-run-shards.ts

@@ -0,0 +1,26 @@
+import { type Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table health.accounting_integrity_run
+      add column shard_key text not null default 'regional'
+  `.execute(db);
+
+  await sql`
+    alter table health.accounting_integrity_run
+      drop constraint accounting_integrity_run_evaluation_region_code_key,
+      add constraint accounting_integrity_run_evaluation_region_code_shard_key
+        unique (evaluation_id, data_region, code, shard_key)
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    alter table health.accounting_integrity_run
+      drop constraint
+        accounting_integrity_run_evaluation_region_code_shard_key,
+      drop column shard_key,
+      add constraint accounting_integrity_run_evaluation_region_code_key
+        unique (evaluation_id, data_region, code)
+  `.execute(db);
+}