@vrplatform/kysely 1.3.40 → 1.3.41-4245

package/build/migrations/0000000000030-pms-accounting-windows.ts

@@ -0,0 +1,50 @@
+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 accounting_start_at date,
+    add column accounting_end_at date,
+    add constraint connection_accounting_window_check
+      check (
+        (
+          accounting_start_at is null
+          and accounting_end_at is null
+        )
+        or accounting_end_at is null
+        or accounting_start_at < accounting_end_at
+      );
+  `.execute(db);
+
+  await sql`
+    update public.connection as connection
+    set accounting_start_at = date '1900-01-01'
+    from public.app as app
+    where app.id = connection.app_id
+      and app.category = 'propertyManagementSystem'
+      and connection.status = 'active';
+  `.execute(db);
+
+  await sql`
+    create index connection_tenant_accounting_window_idx
+    on public.connection (
+      tenant_id,
+      accounting_start_at,
+      accounting_end_at
+    );
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`
+    drop index if exists public.connection_tenant_accounting_window_idx;
+  `.execute(db);
+
+  await sql`
+    alter table public.connection
+    drop constraint if exists connection_accounting_window_check,
+    drop column if exists accounting_end_at,
+    drop column if exists accounting_start_at;
+  `.execute(db);
+}

package/build/migrations/0000000000031-owner-statement-projection-listing-revision.ts

@@ -0,0 +1,20 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`
+    create table accounting.owner_statement_projection_listing_revision (
+      tenant_id uuid not null,
+      listing_id uuid not null,
+      revision bigint default 0 not null,
+      updated_at timestamp with time zone default now() not null,
+      primary key (tenant_id, listing_id)
+    );
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`
+    drop table accounting.owner_statement_projection_listing_revision;
+  `.execute(db);
+}

package/build/migrations/0000000000032-flow-event-listening.ts

@@ -0,0 +1,28 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`
+    alter table core.flow
+    add column event_listening jsonb not null default '[]'::jsonb,
+    add constraint flow_event_listening_array_check
+      check (jsonb_typeof(event_listening) = 'array');
+  `.execute(db);
+
+  await sql`
+    create index flow_event_listening_idx
+    on core.flow using gin (event_listening);
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`
+    drop index if exists core.flow_event_listening_idx;
+  `.execute(db);
+
+  await sql`
+    alter table core.flow
+    drop constraint if exists flow_event_listening_array_check,
+    drop column if exists event_listening;
+  `.execute(db);
+}

package/build/migrations/0000000000033-opening-trial-balance-transaction.ts

@@ -0,0 +1,272 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+const EQUITY_CATEGORY_ID = '62de7391-5fb2-4789-a782-feb2c6ce95eb';
+const JOURNAL_BATCH_TYPE = 'journalBatch';
+const OPENING_TRIAL_BALANCE_JOURNAL_ENTRY_TYPE = 'opening_trial_balance';
+const OPENING_TRIAL_BALANCE_REF = 'openingTrialBalance';
+const OPENING_TRIAL_BALANCE_REF_PREFIX = 'openingTrialBalance_';
+const LEGACY_OPENING_TRIAL_BALANCE_REF_PREFIX =
+  'openingTrialBalance_operating_manual_';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`
+    insert into accounting.transaction_type (name)
+    values (${JOURNAL_BATCH_TYPE})
+    on conflict (name) do nothing;
+  `.execute(db);
+
+  await sql`
+    with tenants_with_opening_trial_balance as (
+      select
+        tenant.id,
+        lower(coalesce(tenant.default_currency, 'usd')) as currency,
+        (tenant.statement_start_at::date - interval '1 day')::date as opening_date
+      from public.tenant
+      where tenant.statement_start_at is not null
+        and not exists (
+          select 1
+          from accounting.transaction existing_transaction
+          where existing_transaction.tenant_id = tenant.id
+            and existing_transaction.unique_ref = ${OPENING_TRIAL_BALANCE_REF}
+        )
+        and (
+          exists (
+            select 1
+            from accounting.account
+            inner join accounting.account_category category
+              on category.id = account.category_id
+            left join accounting.account_assignment opening_balance_assignment
+              on opening_balance_assignment.account_id = account.id
+              and opening_balance_assignment.tenant_id = account.tenant_id
+              and opening_balance_assignment.type = 'openingBalance'
+            where account.tenant_id = tenant.id
+              and account.status = 'active'
+              and account.type in ('ledger', 'bank')
+              and category.classification is not null
+              and (
+                category.classification in ('asset', 'liability')
+                or category.id = ${EQUITY_CATEGORY_ID}
+              )
+              and opening_balance_assignment.id is null
+              and account.opening_trial_balance_combined_cent_total <> 0
+          )
+          or exists (
+            select 1
+            from accounting.journal_entry
+            where journal_entry.tenant_id = tenant.id
+              and journal_entry.type = ${OPENING_TRIAL_BALANCE_JOURNAL_ENTRY_TYPE}
+              and (
+                journal_entry.unique_ref like ${`${OPENING_TRIAL_BALANCE_REF_PREFIX}%`}
+                or journal_entry.unique_ref like ${`${LEGACY_OPENING_TRIAL_BALANCE_REF_PREFIX}%`}
+              )
+          )
+        )
+    )
+    insert into accounting.transaction (
+      id,
+      tenant_id,
+      description,
+      type,
+      date,
+      currency,
+      cent_total,
+      unique_ref,
+      status,
+      paid_status,
+      paid_at,
+      is_opening_balance
+    )
+    select
+      gen_random_uuid(),
+      tenant.id,
+      'Opening Trial Balance',
+      ${JOURNAL_BATCH_TYPE},
+      tenant.opening_date,
+      tenant.currency,
+      0,
+      ${OPENING_TRIAL_BALANCE_REF},
+      'active',
+      'paid',
+      tenant.opening_date,
+      true
+    from tenants_with_opening_trial_balance tenant;
+  `.execute(db);
+
+  await sql`
+    insert into accounting.transaction_line (
+      id,
+      transaction_id,
+      tenant_id,
+      description,
+      account_id,
+      cent_total,
+      party,
+      unique_ref
+    )
+    select
+      gen_random_uuid(),
+      transaction.id,
+      account.tenant_id,
+      'Opening Account Balance',
+      account.id,
+      account.opening_trial_balance_combined_cent_total,
+      'manager',
+      ${OPENING_TRIAL_BALANCE_REF_PREFIX} || 'account_' || account.id
+    from accounting.transaction
+    inner join accounting.account
+      on account.tenant_id = transaction.tenant_id
+    inner join accounting.account_category category
+      on category.id = account.category_id
+    left join accounting.account_assignment opening_balance_assignment
+      on opening_balance_assignment.account_id = account.id
+      and opening_balance_assignment.tenant_id = account.tenant_id
+      and opening_balance_assignment.type = 'openingBalance'
+    where transaction.type = ${JOURNAL_BATCH_TYPE}
+      and transaction.unique_ref = ${OPENING_TRIAL_BALANCE_REF}
+      and transaction.is_opening_balance = true
+      and account.status = 'active'
+      and account.type in ('ledger', 'bank')
+      and category.classification is not null
+      and (
+        category.classification in ('asset', 'liability')
+        or category.id = ${EQUITY_CATEGORY_ID}
+      )
+      and opening_balance_assignment.id is null
+      and not exists (
+        select 1
+        from accounting.transaction_line existing_line
+        where existing_line.tenant_id = transaction.tenant_id
+          and existing_line.transaction_id = transaction.id
+          and existing_line.unique_ref =
+            ${OPENING_TRIAL_BALANCE_REF_PREFIX} || 'account_' || account.id
+      );
+  `.execute(db);
+
+  await sql`
+    with assignment_account as (
+      select distinct on (account.tenant_id)
+        account.tenant_id,
+        account.id
+      from accounting.account
+      inner join accounting.account_assignment assignment
+        on assignment.account_id = account.id
+        and assignment.tenant_id = account.tenant_id
+        and assignment.type = 'openingBalance'
+      where account.status = 'active'
+      order by account.tenant_id, account.title, account.id
+    ),
+    source_total as (
+      select
+        transaction_line.tenant_id,
+        transaction_line.transaction_id,
+        coalesce(sum(transaction_line.cent_total), 0) as cent_total
+      from accounting.transaction_line
+      where transaction_line.unique_ref like ${`${OPENING_TRIAL_BALANCE_REF_PREFIX}account_%`}
+      group by transaction_line.tenant_id, transaction_line.transaction_id
+    )
+    insert into accounting.transaction_line (
+      id,
+      transaction_id,
+      tenant_id,
+      description,
+      account_id,
+      cent_total,
+      party,
+      unique_ref
+    )
+    select
+      gen_random_uuid(),
+      transaction.id,
+      transaction.tenant_id,
+      case
+        when coalesce(source_total.cent_total, 0) > 0
+          then 'Opening Balance Surplus'
+        else 'Opening Balance Deficit'
+      end,
+      assignment_account.id,
+      coalesce(source_total.cent_total, 0) * -1,
+      'manager',
+      ${OPENING_TRIAL_BALANCE_REF_PREFIX} || 'assignment_' || assignment_account.id
+    from accounting.transaction
+    inner join assignment_account
+      on assignment_account.tenant_id = transaction.tenant_id
+    left join source_total
+      on source_total.tenant_id = transaction.tenant_id
+      and source_total.transaction_id = transaction.id
+    where transaction.type = ${JOURNAL_BATCH_TYPE}
+      and transaction.unique_ref = ${OPENING_TRIAL_BALANCE_REF}
+      and transaction.is_opening_balance = true
+      and not exists (
+        select 1
+        from accounting.transaction_line existing_line
+        where existing_line.tenant_id = transaction.tenant_id
+          and existing_line.transaction_id = transaction.id
+          and existing_line.unique_ref =
+            ${OPENING_TRIAL_BALANCE_REF_PREFIX} || 'assignment_' || assignment_account.id
+      );
+  `.execute(db);
+
+  await sql`
+    update accounting.journal_entry journal_entry
+    set
+      entity_type = 'transaction',
+      transaction_id = transaction_line.transaction_id,
+      line_id = transaction_line.id,
+      unique_ref = transaction_line.unique_ref
+    from accounting.transaction
+    inner join accounting.transaction_line
+      on transaction_line.transaction_id = transaction.id
+      and transaction_line.tenant_id = transaction.tenant_id
+    where journal_entry.tenant_id = transaction.tenant_id
+      and journal_entry.account_id = transaction_line.account_id
+      and transaction.type = ${JOURNAL_BATCH_TYPE}
+      and transaction.unique_ref = ${OPENING_TRIAL_BALANCE_REF}
+      and transaction.is_opening_balance = true
+      and journal_entry.type = ${OPENING_TRIAL_BALANCE_JOURNAL_ENTRY_TYPE}
+      and (
+        journal_entry.unique_ref like ${`${OPENING_TRIAL_BALANCE_REF_PREFIX}%`}
+        or journal_entry.unique_ref like ${`${LEGACY_OPENING_TRIAL_BALANCE_REF_PREFIX}%`}
+      );
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`
+    update accounting.journal_entry journal_entry
+    set
+      transaction_id = null,
+      line_id = null
+    from accounting.transaction
+    where journal_entry.transaction_id = transaction.id
+      and transaction.type = ${JOURNAL_BATCH_TYPE}
+      and transaction.unique_ref = ${OPENING_TRIAL_BALANCE_REF}
+      and transaction.is_opening_balance = true;
+  `.execute(db);
+
+  await sql`
+    delete from accounting.transaction_line
+    using accounting.transaction
+    where transaction_line.transaction_id = transaction.id
+      and transaction.type = ${JOURNAL_BATCH_TYPE}
+      and transaction.unique_ref = ${OPENING_TRIAL_BALANCE_REF}
+      and transaction.is_opening_balance = true;
+  `.execute(db);
+
+  await sql`
+    delete from accounting.transaction
+    where type = ${JOURNAL_BATCH_TYPE}
+      and unique_ref = ${OPENING_TRIAL_BALANCE_REF}
+      and is_opening_balance = true;
+  `.execute(db);
+
+  await sql`
+    delete from accounting.transaction_type
+    where name = ${JOURNAL_BATCH_TYPE}
+      and not exists (
+        select 1
+        from accounting.transaction
+        where transaction.type = ${JOURNAL_BATCH_TYPE}
+      );
+  `.execute(db);
+}

package/build/migrations/0000000000034-historic-general-ledger.ts

@@ -0,0 +1,24 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+const HISTORIC_GENERAL_LEDGER_JOURNAL_ENTRY_TYPE = 'historical_general_ledger';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`
+    insert into accounting.journal_entry_type (name)
+    values (${HISTORIC_GENERAL_LEDGER_JOURNAL_ENTRY_TYPE})
+    on conflict (name) do nothing;
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`
+    delete from accounting.journal_entry_type
+    where name = ${HISTORIC_GENERAL_LEDGER_JOURNAL_ENTRY_TYPE}
+      and not exists (
+        select 1
+        from accounting.journal_entry
+        where type = ${HISTORIC_GENERAL_LEDGER_JOURNAL_ENTRY_TYPE}
+      );
+  `.execute(db);
+}

package/build/migrations/0000000000035-tenant-regional-placement.ts

@@ -0,0 +1,37 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`
+    alter table public.tenant
+      add column data_region text not null default 'eu',
+      add column storage_realm text not null default 'vrtrust';
+  `.execute(db);
+
+  await sql`
+    update public.tenant
+    set storage_realm = 'vrintegration'
+    where coalesce(is_general_ledger, false) = false;
+  `.execute(db);
+
+  await sql`
+    alter table public.tenant
+      add constraint tenant_data_region_check
+        check (data_region in ('eu', 'us', 'ap')),
+      add constraint tenant_storage_realm_check
+        check (storage_realm in ('vrintegration', 'vrtrust')),
+      add constraint tenant_vrintegration_region_check
+        check (storage_realm <> 'vrintegration' or data_region = 'eu');
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`
+    alter table public.tenant
+      drop constraint tenant_vrintegration_region_check,
+      drop constraint tenant_storage_realm_check,
+      drop constraint tenant_data_region_check,
+      drop column storage_realm,
+      drop column data_region;
+  `.execute(db);
+}

package/build/migrations/0000000000036-control-plane-projection-events.ts

@@ -0,0 +1,43 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`
+    create table public.control_plane_projection_event (
+      event_id uuid primary key,
+      aggregate_type text not null,
+      aggregate_id text not null,
+      event_type text not null,
+      event_version integer not null,
+      data_region text not null,
+      payload jsonb not null default jsonb_build_object(),
+      applied_at timestamptz not null default now(),
+      constraint control_plane_projection_event_region_check
+        check (data_region in ('eu', 'us', 'ap')),
+      constraint control_plane_projection_event_version_check
+        check (event_version > 0),
+      constraint control_plane_projection_event_aggregate_version_key
+        unique (aggregate_type, aggregate_id, event_version)
+    );
+  `.execute(db);
+
+  await sql`
+    create index control_plane_projection_event_aggregate_idx
+      on public.control_plane_projection_event (
+        aggregate_type,
+        aggregate_id,
+        applied_at
+      );
+  `.execute(db);
+
+  await sql`
+    create index control_plane_projection_event_applied_at_idx
+      on public.control_plane_projection_event (applied_at);
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`
+    drop table if exists public.control_plane_projection_event;
+  `.execute(db);
+}

package/build/migrations/0000000000037-tenant-guide-onboarding.ts

@@ -0,0 +1,21 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`
+    alter table public.tenant
+    add column guide_onboarding jsonb;
+  `.execute(db);
+
+  await sql`
+    comment on column public.tenant.guide_onboarding is
+      'JSON column for explicit VRPilot onboarding guide state.';
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`
+    alter table public.tenant
+    drop column guide_onboarding;
+  `.execute(db);
+}

package/build/migrations/0000000000038-ramp-staging-connect-params.ts

@@ -0,0 +1,35 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`
+    update public.app
+    set authentication = jsonb_set(
+      coalesce(authentication, '{}'::jsonb),
+      '{defaultConnectParamsByApiEnv}',
+      coalesce(
+        authentication -> 'defaultConnectParamsByApiEnv',
+        '{}'::jsonb
+      ) || jsonb_build_object(
+        'staging',
+        jsonb_build_object('environment', 'demo')
+      ),
+      true
+    )
+    where id = 'ramp';
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`
+    update public.app
+    set authentication = jsonb_set(
+      coalesce(authentication, '{}'::jsonb),
+      '{defaultConnectParamsByApiEnv}',
+      coalesce(authentication -> 'defaultConnectParamsByApiEnv', '{}'::jsonb)
+        - 'staging',
+      true
+    )
+    where id = 'ramp';
+  `.execute(db);
+}

package/build/migrations/0000000000038-tracking-event-analytics-sink.ts

@@ -0,0 +1,31 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  // tracking.event is an append-only analytics sink consumed from a queue.
+  // FKs into OLTP buy nothing here and poison whole consumer batches when a
+  // referenced tenant/user row is deleted while events are in flight.
+  await sql`
+    alter table tracking.event
+    drop constraint if exists event_tenant_id_fkey;
+  `.execute(db);
+
+  await sql`
+    alter table tracking.event
+    drop constraint if exists event_user_id_fkey;
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`
+    alter table tracking.event
+    add constraint event_tenant_id_fkey
+    foreign key (tenant_id) references public.tenant(id) on delete cascade;
+  `.execute(db);
+
+  await sql`
+    alter table tracking.event
+    add constraint event_user_id_fkey
+    foreign key (user_id) references public."user"(id);
+  `.execute(db);
+}

package/build/migrations/0000000000039-crunchy-region.ts

@@ -0,0 +1,86 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+// 'crunchy' becomes its own region: the legacy Crunchy Postgres is no longer
+// pretending to be the eu cell. All existing tenants physically live there,
+// so their placement flips from 'eu' to 'crunchy'; 'eu' stays a valid region
+// for the future Neon Frankfurt cell. vrintegration tenants pin to crunchy.
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`
+    alter table public.tenant
+      drop constraint tenant_data_region_check,
+      drop constraint tenant_vrintegration_region_check;
+  `.execute(db);
+
+  await sql`
+    update public.tenant
+    set data_region = 'crunchy'
+    where data_region = 'eu';
+  `.execute(db);
+
+  await sql`
+    alter table public.tenant
+      alter column data_region set default 'crunchy',
+      add constraint tenant_data_region_check
+        check (data_region in ('ap', 'crunchy', 'eu', 'us')),
+      add constraint tenant_vrintegration_region_check
+        check (storage_realm <> 'vrintegration' or data_region = 'crunchy');
+  `.execute(db);
+
+  await sql`
+    alter table public.control_plane_projection_event
+      drop constraint control_plane_projection_event_region_check;
+  `.execute(db);
+
+  await sql`
+    update public.control_plane_projection_event
+    set data_region = 'crunchy'
+    where data_region = 'eu';
+  `.execute(db);
+
+  await sql`
+    alter table public.control_plane_projection_event
+      add constraint control_plane_projection_event_region_check
+        check (data_region in ('ap', 'crunchy', 'eu', 'us'));
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`
+    alter table public.control_plane_projection_event
+      drop constraint control_plane_projection_event_region_check;
+  `.execute(db);
+
+  await sql`
+    update public.control_plane_projection_event
+    set data_region = 'eu'
+    where data_region = 'crunchy';
+  `.execute(db);
+
+  await sql`
+    alter table public.control_plane_projection_event
+      add constraint control_plane_projection_event_region_check
+        check (data_region in ('eu', 'us', 'ap'));
+  `.execute(db);
+
+  await sql`
+    alter table public.tenant
+      drop constraint tenant_data_region_check,
+      drop constraint tenant_vrintegration_region_check;
+  `.execute(db);
+
+  await sql`
+    update public.tenant
+    set data_region = 'eu'
+    where data_region = 'crunchy';
+  `.execute(db);
+
+  await sql`
+    alter table public.tenant
+      alter column data_region set default 'eu',
+      add constraint tenant_data_region_check
+        check (data_region in ('eu', 'us', 'ap')),
+      add constraint tenant_vrintegration_region_check
+        check (storage_realm <> 'vrintegration' or data_region = 'eu');
+  `.execute(db);
+}