@vrplatform/kysely 1.3.45-stage.6066 → 1.3.45-stage.607

package/build/migrations-v2/0000000000047-public-audit-completion.ts

@@ -0,0 +1,77 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create type audit.actor_organization_type as enum (
+      'vrplatform', 'partner', 'team', 'system'
+    )
+  `.execute(db);
+  await sql`
+    alter type audit.source_type add value if not exists 'embedded'
+  `.execute(db);
+  await sql`
+    alter type webhook.subscription_event_type
+      add value if not exists 'audit.event.changed'
+  `.execute(db);
+  await sql`
+    alter type webhook.event_type
+      add value if not exists 'audit.event.changed'
+  `.execute(db);
+  await sql`
+    alter type webhook.resource_type
+      add value if not exists 'auditEvent'
+  `.execute(db);
+  await sql`
+    alter table audit.action
+      add column actor_organization_type audit.actor_organization_type,
+      add column actor_organization_id uuid,
+      add column actor_organization_name text
+  `.execute(db);
+  await sql`
+    alter table audit.mutation
+      add column public_outcome jsonb
+  `.execute(db);
+  await sql`
+    alter table audit.public_event
+      add column actor_organization_type audit.actor_organization_type,
+      add column actor_organization_id uuid,
+      add column actor_organization_name text,
+      add column attempted_entity_changes jsonb not null default '[]'::jsonb,
+      add column blocked_by jsonb not null default '[]'::jsonb,
+      add column recovery jsonb not null default '[]'::jsonb
+  `.execute(db);
+  await sql`
+    create index if not exists public_event_tenant_occurred_idx
+      on audit.public_event (tenant_id, occurred_at, updated_at, id)
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    drop index if exists audit.public_event_tenant_occurred_idx
+  `.execute(db);
+  await sql`
+    alter table audit.public_event
+      drop column if exists recovery,
+      drop column if exists blocked_by,
+      drop column if exists attempted_entity_changes,
+      drop column if exists actor_organization_name,
+      drop column if exists actor_organization_id,
+      drop column if exists actor_organization_type
+  `.execute(db);
+  await sql`
+    alter table audit.action
+      drop column if exists actor_organization_name,
+      drop column if exists actor_organization_id,
+      drop column if exists actor_organization_type
+  `.execute(db);
+  await sql`
+    alter table audit.mutation
+      drop column if exists public_outcome
+  `.execute(db);
+  await sql`
+    drop type if exists audit.actor_organization_type
+  `.execute(db);
+  // PostgreSQL enum values cannot be removed safely without rebuilding source_type.
+}

package/build/migrations-v2/0000000000048-reservation-journal-full-refresh-repair.ts

@@ -0,0 +1,136 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create temporary table reservation_journal_full_refresh_repair_scope (
+      invalidation_id uuid primary key,
+      tenant_id uuid not null,
+      reservation_id uuid not null,
+      applied_at timestamptz not null,
+      covering_effect_id uuid not null
+    ) on commit drop
+  `.execute(db);
+
+  await sql`
+    insert into reservation_journal_full_refresh_repair_scope (
+      invalidation_id,
+      tenant_id,
+      reservation_id,
+      applied_at,
+      covering_effect_id
+    )
+    select
+      pending.id,
+      pending.tenant_id,
+      pending.reservation_id,
+      covering.applied_at,
+      covering.effect_id
+    from accounting.reservation_journal_invalidation as pending
+    inner join lateral (
+      select
+        applied.applied_at,
+        applied.effect_id
+      from accounting.reservation_journal_invalidation as applied
+      inner join audit.effect as effect
+        on effect.tenant_id = applied.tenant_id
+        and effect.id = applied.effect_id
+      where applied.tenant_id = pending.tenant_id
+        and applied.reservation_id = pending.reservation_id
+        and applied.revision >= pending.revision
+        and applied.applied_at is not null
+        and applied.covered_by_effect_id = applied.effect_id
+        and effect.status = 'completed'
+        and coalesce(effect.payload ->> 'mode', 'full') = 'full'
+        and (
+          select attempt.status
+          from audit.effect_attempt as attempt
+          where attempt.tenant_id = effect.tenant_id
+            and attempt.effect_id = effect.id
+          order by attempt.attempt_num desc
+          limit 1
+        ) is distinct from 'skipped_locked'
+      order by applied.revision desc
+      limit 1
+    ) as covering on true
+    where pending.applied_at is null
+  `.execute(db);
+
+  await sql`
+    update accounting.reservation_journal_invalidation as invalidation
+    set
+      applied_at = scope.applied_at,
+      covered_by_effect_id = scope.covering_effect_id
+    from reservation_journal_full_refresh_repair_scope as scope
+    where invalidation.id = scope.invalidation_id
+      and invalidation.applied_at is null
+  `.execute(db);
+
+  await sql`
+    select state.tenant_id
+    from accounting.reservation_journal_state as state
+    inner join (
+      select distinct tenant_id, reservation_id
+      from reservation_journal_full_refresh_repair_scope
+    ) as scope
+      on scope.tenant_id = state.tenant_id
+      and scope.reservation_id = state.reservation_id
+    order by state.tenant_id, state.reservation_id
+    for update of state
+  `.execute(db);
+
+  await sql`
+    with advancement as (
+      select
+        state.tenant_id,
+        state.reservation_id,
+        coalesce(
+          min(invalidation.revision) filter (
+            where invalidation.applied_at is null
+          ) - 1,
+          max(invalidation.revision),
+          state.applied_revision
+        ) as applied_revision,
+        min(invalidation.created_at) filter (
+          where invalidation.applied_at is null
+        ) as stale_since,
+        max(invalidation.applied_at) as calculated_at
+      from accounting.reservation_journal_state as state
+      inner join (
+        select distinct tenant_id, reservation_id
+        from reservation_journal_full_refresh_repair_scope
+      ) as scope
+        on scope.tenant_id = state.tenant_id
+        and scope.reservation_id = state.reservation_id
+      left join accounting.reservation_journal_invalidation as invalidation
+        on invalidation.tenant_id = state.tenant_id
+        and invalidation.reservation_id = state.reservation_id
+      group by
+        state.tenant_id,
+        state.reservation_id,
+        state.applied_revision
+    )
+    update accounting.reservation_journal_state as state
+    set
+      applied_revision = greatest(
+        state.applied_revision,
+        advancement.applied_revision
+      ),
+      stale_since = advancement.stale_since,
+      calculated_at = case
+        when advancement.applied_revision > state.applied_revision
+          then greatest(state.calculated_at, advancement.calculated_at)
+        else state.calculated_at
+      end,
+      updated_at = now()
+    from advancement
+    where state.tenant_id = advancement.tenant_id
+      and state.reservation_id = advancement.reservation_id
+      and (
+        state.applied_revision < advancement.applied_revision
+        or state.stale_since is distinct from advancement.stale_since
+      )
+  `.execute(db);
+}
+
+export async function down(_db: Kysely<unknown>): Promise<void> {}

package/build/migrations-v2/0000000000049-queued-journal-operation-failures.ts

@@ -0,0 +1,60 @@
+import { type Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  // Preserve the source lifecycle and failure precedence; ID format is not a failure policy.
+  await sql`
+    do $$
+    declare
+      definition text;
+    begin
+      definition := pg_get_functiondef('core.refresh_operation_state(uuid)'::regprocedure);
+      if position('and target_public_id_format = ''action''' in definition) = 0 then
+        raise exception 'Journal operation failure projection has an unexpected definition';
+      end if;
+      execute replace(definition, 'and target_public_id_format = ''action''', '');
+    end;
+    $$
+  `.execute(db);
+
+  await sql`
+    select core.refresh_operation_state(operation.id)
+    from core.operation as operation
+    where operation.type = 'reservation-journal-refresh'
+      and operation.public_id_format = 'legacy'
+      and operation.status = 'failed'
+      and exists (
+        select 1 from core.operation_source as source
+        where source.operation_id = operation.id
+          and source.source_type = 'audit-action'
+      )
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    do $$
+    declare
+      definition text;
+    begin
+      definition := pg_get_functiondef('core.refresh_operation_state(uuid)'::regprocedure);
+      if position('and target_public_id_format = ''action''' in definition) > 0
+        or position('and target_action_id is not null then' in definition) = 0 then
+        raise exception 'Journal operation failure projection has an unexpected definition';
+      end if;
+      execute replace(
+        definition,
+        'and target_action_id is not null then',
+        'and target_public_id_format = ''action'' and target_action_id is not null then'
+      );
+    end;
+    $$
+  `.execute(db);
+
+  await sql`
+    select core.refresh_operation_state(operation.id)
+    from core.operation as operation
+    where operation.type = 'reservation-journal-refresh'
+      and operation.public_id_format = 'legacy'
+      and operation.status = 'failed'
+  `.execute(db);
+}

package/build/migrations-v2/0000000000050-connection-oauth-state.ts

@@ -0,0 +1,43 @@
+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 table public.connection_oauth_state (
+      state_hash text primary key,
+      tenant_id uuid not null references public.tenant (id) on delete cascade,
+      user_id uuid not null,
+      app_id text not null,
+      connection_id uuid,
+      params jsonb not null,
+      redirect_uri text not null,
+      expires_at timestamptz not null,
+      constraint connection_oauth_state_hash_shape check (state_hash ~ '^[0-9a-f]{64}$'),
+      constraint connection_oauth_state_params_object check (jsonb_typeof(params) = 'object')
+    )
+  `.execute(db);
+  await sql`create index connection_oauth_state_expiry_idx on public.connection_oauth_state (expires_at)`.execute(
+    db
+  );
+  await sql`create index connection_oauth_state_tenant_idx on public.connection_oauth_state (tenant_id)`.execute(
+    db
+  );
+  await sql`
+    do $$
+    begin
+      if exists (select 1 from pg_roles where rolname = 'application') then
+        grant select, insert, delete on public.connection_oauth_state to application;
+        -- SELECT FOR UPDATE SKIP LOCKED needs UPDATE on at least one column.
+        -- State bindings, parameters, and expiry remain non-updatable at runtime.
+        grant update (state_hash) on public.connection_oauth_state to application;
+      end if;
+    end;
+    $$
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`drop table public.connection_oauth_state`.execute(db);
+}

package/build/migrations-v2/0000000000051-owner-statement-email-delivery.ts

@@ -0,0 +1,134 @@
+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 type core.email_notification_status as enum (
+      'queued', 'processing', 'completed', 'failed', 'canceled'
+    )
+  `.execute(db);
+  await sql`
+    create type core.email_delivery_status as enum (
+      'queued', 'sending', 'retrying', 'accepted', 'rejected', 'failed',
+      'canceled'
+    )
+  `.execute(db);
+  await sql`
+    create type core.email_delivery_failure_code as enum (
+      'inactive_recipient',
+      'invalid_provider_response',
+      'postmark_not_configured',
+      'provider_rejected',
+      'task_failed',
+      'transport_failed'
+    )
+  `.execute(db);
+
+  await sql`
+    create table core.email_notification (
+      id uuid primary key references audit.effect(id) on delete cascade,
+      tenant_id uuid not null references public.tenant(id) on delete cascade,
+      owner_statement_id uuid not null,
+      status core.email_notification_status not null default 'queued',
+      trigger_run_id text,
+      recipients_resolved_at timestamptz,
+      started_at timestamptz,
+      finished_at timestamptz,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      constraint email_notification_terminal_check check (
+        (status in ('completed', 'failed', 'canceled') and finished_at is not null)
+        or (status in ('queued', 'processing') and finished_at is null)
+      )
+    )
+  `.execute(db);
+  await sql`
+    create index email_notification_statement_history_idx
+      on core.email_notification (
+        tenant_id, owner_statement_id, created_at desc, id desc
+      )
+  `.execute(db);
+
+  await sql`
+    create table core.email_delivery (
+      id uuid primary key default gen_random_uuid(),
+      notification_id uuid not null
+        references core.email_notification(id) on delete cascade,
+      tenant_id uuid not null references public.tenant(id) on delete cascade,
+      user_id uuid not null,
+      status core.email_delivery_status not null default 'queued',
+      attempt_count integer not null default 0,
+      trigger_run_id text,
+      postmark_message_id text,
+      postmark_error_code integer,
+      http_status integer,
+      failure_code core.email_delivery_failure_code,
+      submitted_at timestamptz,
+      last_attempt_at timestamptz,
+      finished_at timestamptz,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now(),
+      constraint email_delivery_notification_user_key
+        unique (notification_id, user_id),
+      constraint email_delivery_attempt_count_check check (attempt_count >= 0),
+      constraint email_delivery_postmark_error_code_check check (
+        postmark_error_code is null or postmark_error_code >= 0
+      ),
+      constraint email_delivery_http_status_check check (
+        http_status is null or http_status between 100 and 599
+      ),
+      constraint email_delivery_terminal_check check (
+        (status in ('accepted', 'rejected', 'failed', 'canceled')
+          and finished_at is not null)
+        or (status in ('queued', 'sending', 'retrying') and finished_at is null)
+      ),
+      constraint email_delivery_accepted_check check (
+        status != 'accepted'
+        or (
+          postmark_message_id is not null
+          and submitted_at is not null
+          and failure_code is null
+        )
+      ),
+      constraint email_delivery_failure_check check (
+        status not in ('rejected', 'failed') or failure_code is not null
+      )
+    )
+  `.execute(db);
+  await sql`
+    create index email_delivery_notification_status_idx
+      on core.email_delivery (notification_id, status, id)
+  `.execute(db);
+  await sql`
+    create index email_delivery_tenant_created_idx
+      on core.email_delivery (tenant_id, created_at desc, id desc)
+  `.execute(db);
+  await sql`
+    create unique index email_delivery_postmark_message_idx
+      on core.email_delivery (postmark_message_id)
+      where postmark_message_id is not null
+  `.execute(db);
+
+  await sql`
+    do $$
+    begin
+      if exists (select 1 from pg_roles where rolname = 'application') then
+        grant select, insert, update
+          on core.email_notification, core.email_delivery
+          to application;
+      end if;
+    end;
+    $$
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`drop table core.email_delivery`.execute(db);
+  await sql`drop table core.email_notification`.execute(db);
+  await sql`drop type core.email_delivery_failure_code`.execute(db);
+  await sql`drop type core.email_delivery_status`.execute(db);
+  await sql`drop type core.email_notification_status`.execute(db);
+}

package/build/migrations-v2/0000000000052-fee-journal-lock-skip-operations.ts

@@ -0,0 +1,59 @@
+import { type Kysely, sql } from 'kysely';
+
+const original = `invalidation.id is null
+                  and effect.status = 'completed'`;
+const corrected = `(invalidation.id is null or (
+                    exists (
+                      select 1 from audit.action as action
+                      where action.id = effect.action_id
+                        and action.tenant_id = effect.tenant_id
+                        and action.root_entity_type = 'recurringFee'
+                    )
+                    and (
+                      select attempt.status from audit.effect_attempt as attempt
+                      where attempt.effect_id = effect.id
+                        and attempt.tenant_id = effect.tenant_id
+                      order by attempt.attempt_num desc limit 1
+                    ) = 'skipped_locked'
+                  ))
+                  and effect.status = 'completed'`;
+
+async function replaceFeeLockSkipProjection<Database>(
+  db: Kysely<Database>,
+  before: string,
+  after: string
+) {
+  const { rows } = await sql<{ definition: string }>`
+    select pg_get_functiondef('core.refresh_audit_action_source(uuid)'::regprocedure)
+      as definition
+  `.execute(db);
+  const definition = rows[0]?.definition;
+  if (!definition || definition.split(before).length !== 2) {
+    throw new Error(
+      'Journal operation source projection has an unexpected definition'
+    );
+  }
+  await sql.raw(definition.replace(before, after)).execute(db);
+  // Reproject derived operation state only. Preserve original attempts and journal invalidations.
+  await sql`
+    select core.refresh_audit_action_source(action.id)
+    from audit.action as action
+    where action.root_entity_type = 'recurringFee'
+      and exists (
+        select 1 from core.operation_source as source
+        inner join core.operation as operation on operation.id = source.operation_id
+        where source.source_type = 'audit-action'
+          and source.source_id = action.id
+          and operation.tenant_id = action.tenant_id
+          and operation.type = 'reservation-journal-refresh'
+      )
+  `.execute(db);
+}
+
+export async function up<Database>(db: Kysely<Database>): Promise<void> {
+  await replaceFeeLockSkipProjection(db, original, corrected);
+}
+
+export async function down<Database>(db: Kysely<Database>): Promise<void> {
+  await replaceFeeLockSkipProjection(db, corrected, original);
+}

package/build/migrations-v2/0000000000053-fee-journal-lock-skip-null-attempt.ts

@@ -0,0 +1,44 @@
+import { type Kysely, sql } from 'kysely';
+
+async function replaceNullableLockSkip<Database>(
+  db: Kysely<Database>,
+  before: string,
+  after: string
+) {
+  const { rows } = await sql<{ definition: string }>`
+    select pg_get_functiondef('core.refresh_audit_action_source(uuid)'::regprocedure) as definition
+  `.execute(db);
+  const definition = rows[0]?.definition;
+  if (!definition || definition.split(before).length !== 2) {
+    throw new Error('Fee lock skip projection has an unexpected definition');
+  }
+  await sql.raw(definition.replace(before, after)).execute(db);
+  await sql`
+    select core.refresh_audit_action_source(action.id)
+    from audit.action as action
+    where action.root_entity_type = 'recurringFee'
+      and exists (
+        select 1 from core.operation_source as source
+        inner join core.operation as operation on operation.id = source.operation_id
+        where source.source_type = 'audit-action' and source.source_id = action.id
+          and operation.tenant_id = action.tenant_id
+          and operation.type = 'reservation-journal-refresh'
+      )
+  `.execute(db);
+}
+
+export async function up<Database>(db: Kysely<Database>): Promise<void> {
+  await replaceNullableLockSkip(
+    db,
+    ") = 'skipped_locked'",
+    ") is not distinct from 'skipped_locked'"
+  );
+}
+
+export async function down<Database>(db: Kysely<Database>): Promise<void> {
+  await replaceNullableLockSkip(
+    db,
+    ") is not distinct from 'skipped_locked'",
+    ") = 'skipped_locked'"
+  );
+}

package/build/migrations-v2/0000000000054-journal-refresh-issue-codes.ts

@@ -0,0 +1,16 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  // Expand storage only. New codes must be readable on every channel before
+  // issue collectors begin writing them to shared regional databases.
+  await sql`alter type health.tenant_issue_code add value if not exists 'journalLocked'`.execute(
+    db
+  );
+  await sql`alter type health.tenant_issue_code add value if not exists 'journalConfigurationInvalid'`.execute(
+    db
+  );
+  await sql`alter type health.tenant_issue_code add value if not exists 'journalUnbalanced'`.execute(
+    db
+  );
+}

package/build/migrations-v2/0000000000055-tenant-billing-subscription.ts

@@ -0,0 +1,8 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`alter table public.tenant add column billing_subscription_id text`.execute(
+    db
+  );
+}