@vrplatform/kysely 1.3.45-4997 → 1.3.45-5

package/build/migrations/0000000000055-outbound-webhooks-v1.ts

@@ -1,221 +0,0 @@
-import type { Kysely } from 'kysely';
-import { sql } from 'kysely';
-
-const subscriptionEventTypes = [
-  'connection.changed',
-  'sync.status.changed',
-  'reservation.changed',
-  'listing.changed',
-  'statement.status.changed',
-  'transaction.changed',
-] as const;
-
-const resourceTypes = [
-  'connection',
-  'sync',
-  'reservation',
-  'listing',
-  'statement',
-  'transaction',
-] as const;
-
-export async function up(db: Kysely<any>): Promise<void> {
-  for (const eventType of subscriptionEventTypes) {
-    await sql`
-      alter type webhook.subscription_event_type add value if not exists ${sql.lit(
-        eventType
-      )}
-    `.execute(db);
-    await sql`
-      alter type webhook.event_type add value if not exists ${sql.lit(eventType)}
-    `.execute(db);
-  }
-  for (const resourceType of resourceTypes) {
-    await sql`
-      alter type webhook.resource_type add value if not exists ${sql.lit(
-        resourceType
-      )}
-    `.execute(db);
-  }
-
-  await sql`
-    alter table webhook.subscription
-      add column revision bigint not null default 1,
-      add constraint webhook_subscription_revision_check check (revision > 0)
-  `.execute(db);
-  await sql`
-    alter table webhook.delivery
-      add column subscription_revision bigint,
-      add column retry_attempt_count integer not null default 0,
-      add constraint webhook_delivery_subscription_revision_check
-        check (subscription_revision > 0),
-      add constraint webhook_delivery_retry_attempt_count_check
-        check (retry_attempt_count >= 0)
-  `.execute(db);
-  await sql`
-    update webhook.delivery delivery
-    set subscription_revision = subscription.revision
-    from webhook.subscription subscription
-    where subscription.id = delivery.subscription_id
-  `.execute(db);
-  await sql`
-    update webhook.delivery
-    set retry_attempt_count = least(attempt_count, 7)
-  `.execute(db);
-  await sql`
-    alter table webhook.delivery
-      alter column subscription_revision set not null
-  `.execute(db);
-
-  await sql`
-    create table webhook.delivery_attempt_secret (
-      delivery_attempt_id uuid not null
-        references webhook.delivery_attempt(id) on delete cascade,
-      subscription_secret_id uuid not null
-        references webhook.subscription_secret(id) on delete restrict,
-      position text not null,
-      primary key (delivery_attempt_id, subscription_secret_id),
-      constraint webhook_delivery_attempt_secret_position_check
-        check (position in ('primary', 'overlap')),
-      constraint webhook_delivery_attempt_secret_position_key
-        unique (delivery_attempt_id, position)
-    )
-  `.execute(db);
-  await sql`
-    insert into webhook.delivery_attempt_secret (
-      delivery_attempt_id,
-      subscription_secret_id,
-      position
-    )
-    select id, subscription_secret_id, 'primary'
-    from webhook.delivery_attempt
-  `.execute(db);
-  await sql`
-    alter table webhook.delivery_attempt drop column subscription_secret_id
-  `.execute(db);
-
-  await sql`
-    create table webhook.rate_limit (
-      owner_tenant_id uuid not null,
-      key text not null,
-      window_started_at timestamptz not null,
-      request_count integer not null,
-      primary key (owner_tenant_id, key, window_started_at),
-      constraint webhook_rate_limit_request_count_check
-        check (request_count > 0)
-    )
-  `.execute(db);
-
-  await sql`
-    drop index webhook.webhook_delivery_recovery_idx
-  `.execute(db);
-  await sql`
-    create index webhook_delivery_recovery_idx
-      on webhook.delivery (next_attempt_at, id)
-      where status in ('queued', 'retrying', 'delivering')
-  `.execute(db);
-  await sql`
-    create index webhook_delivery_retention_idx
-      on webhook.delivery (updated_at, id)
-      where status in ('succeeded', 'failed', 'canceled')
-  `.execute(db);
-
-  await sql`
-    do $$
-    begin
-      if exists (select 1 from pg_roles where rolname = 'application') then
-        grant select, insert, update, delete
-          on webhook.delivery_attempt_secret, webhook.rate_limit
-          to application;
-      end if;
-    end
-    $$
-  `.execute(db);
-}
-
-export async function down(db: Kysely<any>): Promise<void> {
-  await sql`drop table webhook.rate_limit`.execute(db);
-  await sql`
-    alter table webhook.delivery_attempt add column subscription_secret_id uuid
-  `.execute(db);
-  await sql`
-    update webhook.delivery_attempt attempt
-    set subscription_secret_id = attempt_secret.subscription_secret_id
-    from webhook.delivery_attempt_secret attempt_secret
-    where attempt_secret.delivery_attempt_id = attempt.id
-      and attempt_secret.position = 'primary'
-  `.execute(db);
-  await sql`
-    alter table webhook.delivery_attempt
-      alter column subscription_secret_id set not null,
-      add constraint delivery_attempt_subscription_secret_id_fkey
-        foreign key (subscription_secret_id)
-        references webhook.subscription_secret(id) on delete restrict
-  `.execute(db);
-  await sql`drop table webhook.delivery_attempt_secret`.execute(db);
-
-  await sql`
-    drop index webhook.webhook_delivery_retention_idx
-  `.execute(db);
-  await sql`
-    drop index webhook.webhook_delivery_recovery_idx
-  `.execute(db);
-  await sql`
-    create index webhook_delivery_recovery_idx
-      on webhook.delivery (status, next_attempt_at)
-  `.execute(db);
-  await sql`
-    alter table webhook.delivery
-      drop constraint webhook_delivery_subscription_revision_check,
-      drop constraint webhook_delivery_retry_attempt_count_check,
-      drop column subscription_revision,
-      drop column retry_attempt_count
-  `.execute(db);
-  await sql`
-    alter table webhook.subscription
-      drop constraint webhook_subscription_revision_check,
-      drop column revision
-  `.execute(db);
-
-  await sql`
-    alter table webhook.subscription
-      drop constraint webhook_subscription_event_types_check,
-      alter column event_types type text[] using event_types::text::text[]
-  `.execute(db);
-  await sql`
-    alter table webhook.delivery
-      alter column event_type type text using event_type::text,
-      alter column resource_type type text using resource_type::text
-  `.execute(db);
-  await sql`
-    drop type webhook.subscription_event_type,
-      webhook.event_type,
-      webhook.resource_type
-  `.execute(db);
-  await sql`
-    create type webhook.subscription_event_type as enum ('team.issues.changed')
-  `.execute(db);
-  await sql`
-    create type webhook.event_type as enum (
-      'webhook.test',
-      'team.issues.changed'
-    )
-  `.execute(db);
-  await sql`
-    create type webhook.resource_type as enum ('webhook', 'team')
-  `.execute(db);
-  await sql`
-    alter table webhook.subscription
-      alter column event_types type webhook.subscription_event_type[]
-        using event_types::text::webhook.subscription_event_type[],
-      add constraint webhook_subscription_event_types_check
-        check (cardinality(event_types) > 0)
-  `.execute(db);
-  await sql`
-    alter table webhook.delivery
-      alter column event_type type webhook.event_type
-        using event_type::webhook.event_type,
-      alter column resource_type type webhook.resource_type
-        using resource_type::webhook.resource_type
-  `.execute(db);
-}

package/build/migrations/0000000000056-connection-webhook-version.ts

@@ -1,18 +0,0 @@
-import type { Kysely } from 'kysely';
-import { sql } from 'kysely';
-
-export async function up(db: Kysely<any>): Promise<void> {
-  await sql`
-    alter table public.connection
-      add column webhook_version bigint not null default 1,
-      add constraint connection_webhook_version_check check (webhook_version > 0)
-  `.execute(db);
-}
-
-export async function down(db: Kysely<any>): Promise<void> {
-  await sql`
-    alter table public.connection
-      drop constraint connection_webhook_version_check,
-      drop column webhook_version
-  `.execute(db);
-}

package/build/migrations/0000000000057-sync-webhook-version.ts

@@ -1,18 +0,0 @@
-import type { Kysely } from 'kysely';
-import { sql } from 'kysely';
-
-export async function up(db: Kysely<any>): Promise<void> {
-  await sql`
-    alter table core.sync
-      add column webhook_version bigint not null default 1,
-      add constraint sync_webhook_version_check check (webhook_version > 0)
-  `.execute(db);
-}
-
-export async function down(db: Kysely<any>): Promise<void> {
-  await sql`
-    alter table core.sync
-      drop constraint sync_webhook_version_check,
-      drop column webhook_version
-  `.execute(db);
-}

package/build/migrations/0000000000058-reservation-webhook-version.ts

@@ -1,18 +0,0 @@
-import type { Kysely } from 'kysely';
-import { sql } from 'kysely';
-
-export async function up(db: Kysely<any>): Promise<void> {
-  await sql`
-    alter table public.reservation
-      add column webhook_version bigint not null default 1,
-      add constraint reservation_webhook_version_check check (webhook_version > 0)
-  `.execute(db);
-}
-
-export async function down(db: Kysely<any>): Promise<void> {
-  await sql`
-    alter table public.reservation
-      drop constraint reservation_webhook_version_check,
-      drop column webhook_version
-  `.execute(db);
-}

package/build/migrations/0000000000059-listing-webhook-version.ts

@@ -1,18 +0,0 @@
-import type { Kysely } from 'kysely';
-import { sql } from 'kysely';
-
-export async function up(db: Kysely<any>): Promise<void> {
-  await sql`
-    alter table public.listing
-      add column webhook_version bigint not null default 1,
-      add constraint listing_webhook_version_check check (webhook_version > 0)
-  `.execute(db);
-}
-
-export async function down(db: Kysely<any>): Promise<void> {
-  await sql`
-    alter table public.listing
-      drop constraint listing_webhook_version_check,
-      drop column webhook_version
-  `.execute(db);
-}

package/build/migrations/0000000000060-owner-statement-webhook-version.ts

@@ -1,19 +0,0 @@
-import type { Kysely } from 'kysely';
-import { sql } from 'kysely';
-
-export async function up(db: Kysely<any>): Promise<void> {
-  await sql`
-    alter table public.owner_statement
-      add column webhook_version bigint not null default 1,
-      add constraint owner_statement_webhook_version_check
-        check (webhook_version > 0)
-  `.execute(db);
-}
-
-export async function down(db: Kysely<any>): Promise<void> {
-  await sql`
-    alter table public.owner_statement
-      drop constraint owner_statement_webhook_version_check,
-      drop column webhook_version
-  `.execute(db);
-}

package/build/migrations/0000000000061-transaction-webhook-version.ts

@@ -1,18 +0,0 @@
-import type { Kysely } from 'kysely';
-import { sql } from 'kysely';
-
-export async function up(db: Kysely<any>): Promise<void> {
-  await sql`
-    alter table accounting.transaction
-      add column webhook_version bigint not null default 1,
-      add constraint transaction_webhook_version_check check (webhook_version > 0)
-  `.execute(db);
-}
-
-export async function down(db: Kysely<any>): Promise<void> {
-  await sql`
-    alter table accounting.transaction
-      drop constraint transaction_webhook_version_check,
-      drop column webhook_version
-  `.execute(db);
-}

package/build/migrations/0000000000062-plaid-connect-session.ts

@@ -1,102 +0,0 @@
-import type { Kysely } from 'kysely';
-import { sql } from 'kysely';
-
-export async function up(db: Kysely<any>): Promise<void> {
-  await sql`
-    create type public.plaid_connect_mode as enum (
-      'create',
-      'update',
-      'replace'
-    )
-  `.execute(db);
-  await sql`
-    create type public.plaid_connect_status as enum (
-      'pendingLink',
-      'exchanging',
-      'credentialsStored',
-      'discoveringAccounts',
-      'awaitingConfiguration',
-      'configuring',
-      'completed',
-      'expired',
-      'exchangeOutcomeUnknown',
-      'failed'
-    )
-  `.execute(db);
-
-  await sql`
-    alter table accounting.bank_account
-      add column persistent_ref text
-  `.execute(db);
-  await sql`
-    create index bank_account_connection_persistent_ref_idx
-      on accounting.bank_account (connection_id, persistent_ref)
-      where persistent_ref is not null
-  `.execute(db);
-
-  await sql`
-    create table public.plaid_connect_session (
-      id uuid primary key default gen_random_uuid(),
-      tenant_id uuid not null references public.tenant(id) on delete cascade,
-      mode public.plaid_connect_mode not null,
-      status public.plaid_connect_status not null default 'pendingLink',
-      environment text not null,
-      connection_id uuid references public.connection(id) on delete set null,
-      expires_at timestamptz not null,
-      lease_expires_at timestamptz,
-      link_session_id text,
-      item_id text,
-      result jsonb,
-      sync_id uuid references core.sync(id) on delete set null,
-      error_code text,
-      error_retryable boolean,
-      created_at timestamptz not null default now(),
-      updated_at timestamptz not null default now(),
-      constraint plaid_connect_session_environment_check
-        check (environment in ('sandbox', 'production'))
-    )
-  `.execute(db);
-  await sql`
-    create index plaid_connect_session_tenant_created_idx
-      on public.plaid_connect_session (tenant_id, created_at desc)
-  `.execute(db);
-  await sql`
-    create index plaid_connect_session_recovery_idx
-      on public.plaid_connect_session (status, lease_expires_at)
-      where status in (
-        'exchanging',
-        'credentialsStored',
-        'discoveringAccounts',
-        'configuring'
-      )
-  `.execute(db);
-
-  await sql`
-    do $$
-    begin
-      if exists (select 1 from pg_roles where rolname = 'application') then
-        grant usage on type
-          public.plaid_connect_mode,
-          public.plaid_connect_status
-        to application;
-        grant select, insert, update, delete
-          on public.plaid_connect_session
-          to application;
-      end if;
-    end
-    $$
-  `.execute(db);
-}
-
-export async function down(db: Kysely<any>): Promise<void> {
-  await sql`drop table if exists public.plaid_connect_session`.execute(db);
-  await sql`
-    drop index if exists accounting.bank_account_connection_persistent_ref_idx
-  `.execute(db);
-  await sql`
-    alter table accounting.bank_account
-      drop column if exists persistent_ref
-  `.execute(db);
-  await sql`drop type if exists public.plaid_connect_status`.execute(db);
-  await sql`drop type if exists public.plaid_connect_mode`.execute(db);
-}

package/build/migrations/0000000000063-pgcrypto.ts

@@ -1,27 +0,0 @@
-import type { Kysely } from 'kysely';
-import { sql } from 'kysely';
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await sql`
-    do $$
-    begin
-      if to_regprocedure('gen_random_bytes(integer)') is null
-        or to_regprocedure('digest(text,text)') is null
-      then
-        create extension if not exists pgcrypto;
-      end if;
-
-      if to_regprocedure('gen_random_bytes(integer)') is null
-        or to_regprocedure('digest(text,text)') is null
-      then
-        raise exception 'pgcrypto functions are unavailable';
-      end if;
-    end
-    $$
-  `.execute(db);
-}
-
-export async function down(): Promise<void> {
-  // Existing databases require pgcrypto for baseline functions, so rollback
-  // must not remove the extension.
-}

package/build/migrations/0000000000064-partner-api-foundation.ts

@@ -1,36 +0,0 @@
-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 unique_ref text;
-  `.execute(db);
-
-  await sql`
-    create unique index tenant_partner_unique_ref_unique_idx
-      on public.tenant (partner_id, unique_ref)
-      where partner_id is not null and unique_ref is not null;
-  `.execute(db);
-
-  await sql`
-    create unique index token_partner_secret_unique_idx
-      on public.token (nano_id)
-      where type in ('partner_api_key', 'embedded_bootstrap');
-  `.execute(db);
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await sql`
-    drop index if exists public.token_partner_secret_unique_idx;
-  `.execute(db);
-
-  await sql`
-    drop index if exists public.tenant_partner_unique_ref_unique_idx;
-  `.execute(db);
-
-  await sql`
-    alter table public.tenant
-      drop column unique_ref;
-  `.execute(db);
-}