@vrplatform/kysely 1.3.45-stage.5710 → 1.3.45-stage.573

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