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

package/build/migrations-v2/0000000000043-reservation-journal-freshness.ts

@@ -0,0 +1,149 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create table accounting.reservation_journal_freshness_control (
+      tenant_id uuid primary key references public.tenant(id) on delete cascade,
+      guards_enabled_at timestamptz,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now()
+    )
+  `.execute(db);
+  await sql`
+    create table accounting.reservation_journal_state (
+      tenant_id uuid not null references public.tenant(id) on delete cascade,
+      reservation_id uuid primary key references public.reservation(id) on delete cascade,
+      desired_revision bigint not null default 0,
+      applied_revision bigint not null default 0,
+      stale_since timestamptz,
+      calculated_at timestamptz,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now()
+    )
+  `.execute(db);
+  await sql`
+    create index reservation_journal_state_tenant_stale_idx
+      on accounting.reservation_journal_state (
+        tenant_id,
+        stale_since,
+        reservation_id
+      )
+      where desired_revision > applied_revision
+  `.execute(db);
+  await sql`
+    create function accounting.initialize_reservation_journal_state()
+    returns trigger
+    language plpgsql
+    as $$
+    begin
+      if new.tenant_id is not null then
+        insert into accounting.reservation_journal_state (
+          tenant_id,
+          reservation_id
+        ) values (
+          new.tenant_id,
+          new.id
+        )
+        on conflict (reservation_id) do nothing;
+      end if;
+      return new;
+    end;
+    $$
+  `.execute(db);
+  await sql`
+    create table accounting.reservation_journal_invalidation (
+      id uuid primary key default gen_random_uuid(),
+      tenant_id uuid not null references public.tenant(id) on delete cascade,
+      reservation_id uuid not null references public.reservation(id) on delete cascade,
+      revision bigint not null,
+      action_id uuid references audit.action(id) on delete set null,
+      effect_id uuid references audit.effect(id) on delete set null,
+      source_resource_type core.operation_resource_type,
+      source_resource_id uuid,
+      applied_at timestamptz,
+      covered_by_effect_id uuid references audit.effect(id) on delete set null,
+      created_at timestamptz not null default now(),
+      unique (tenant_id, reservation_id, revision),
+      unique (effect_id)
+    )
+  `.execute(db);
+  await sql`
+    create index reservation_journal_invalidation_reservation_pending_idx
+      on accounting.reservation_journal_invalidation (
+        tenant_id,
+        reservation_id,
+        revision,
+        effect_id
+      )
+      where applied_at is null
+  `.execute(db);
+  await sql`
+    create index reservation_journal_invalidation_source_pending_idx
+      on accounting.reservation_journal_invalidation (
+        tenant_id,
+        source_resource_type,
+        source_resource_id,
+        revision
+      )
+      where applied_at is null
+  `.execute(db);
+
+  await sql`
+    create table accounting.reservation_journal_statement_impact (
+      invalidation_id uuid not null
+        references accounting.reservation_journal_invalidation(id) on delete cascade,
+      tenant_id uuid not null references public.tenant(id) on delete cascade,
+      listing_id uuid not null references public.listing(id) on delete cascade,
+      listing_ownership_period_id uuid not null
+        references public.listing_ownership_period(id) on delete cascade,
+      month date not null,
+      currency text not null,
+      created_at timestamptz not null default now(),
+      primary key (
+        invalidation_id,
+        listing_id,
+        listing_ownership_period_id,
+        month,
+        currency
+      )
+    )
+  `.execute(db);
+  await sql`
+    create index reservation_journal_statement_impact_scope_idx
+      on accounting.reservation_journal_statement_impact (
+        tenant_id,
+        listing_ownership_period_id,
+        month,
+        currency,
+        invalidation_id
+      )
+  `.execute(db);
+  await sql`
+    create trigger initialize_reservation_journal_state
+    after insert on public.reservation
+    for each row execute function accounting.initialize_reservation_journal_state()
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    drop table if exists accounting.reservation_journal_statement_impact
+  `.execute(db);
+  await sql`
+    drop table if exists accounting.reservation_journal_invalidation
+  `.execute(db);
+  await sql`
+    drop trigger if exists initialize_reservation_journal_state
+      on public.reservation
+  `.execute(db);
+  await sql`
+    drop function if exists accounting.initialize_reservation_journal_state
+  `.execute(db);
+  await sql`
+    drop table if exists accounting.reservation_journal_state
+  `.execute(db);
+  await sql`
+    drop table if exists accounting.reservation_journal_freshness_control
+  `.execute(db);
+}

package/build/migrations-v2/0000000000044-reservation-journal-freshness-backfill.ts

@@ -0,0 +1,254 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    insert into accounting.reservation_journal_state (
+      tenant_id,
+      reservation_id,
+      calculated_at
+    )
+    select reservation.tenant_id, reservation.id, now()
+    from public.reservation as reservation
+    where reservation.tenant_id is not null
+    on conflict (reservation_id) do nothing
+  `.execute(db);
+
+  await sql`
+    with outstanding as (
+      select
+        effect.tenant_id,
+        effect.entity_id::uuid as reservation_id,
+        effect.action_id,
+        effect.id as effect_id,
+        effect.root_entity_type,
+        effect.root_entity_id,
+        effect.created_at,
+        effect.completed_at,
+        effect.status,
+        (
+          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
+        ) as latest_attempt_status,
+        row_number() over (
+          partition by effect.tenant_id, effect.entity_id
+          order by effect.created_at, effect.id
+        ) as revision
+      from audit.effect as effect
+      inner join public.reservation as reservation
+        on reservation.id = effect.entity_id
+        and reservation.tenant_id = effect.tenant_id
+      where effect.effect_type = 'REFRESH_RESERVATION_JOURNAL'
+        and effect.entity_type = 'reservation'
+    )
+    insert into accounting.reservation_journal_invalidation (
+      tenant_id,
+      reservation_id,
+      revision,
+      action_id,
+      effect_id,
+      source_resource_type,
+      source_resource_id,
+      applied_at,
+      covered_by_effect_id,
+      created_at
+    )
+    select
+      outstanding.tenant_id,
+      outstanding.reservation_id,
+      outstanding.revision,
+      outstanding.action_id,
+      outstanding.effect_id,
+      case outstanding.root_entity_type
+        when 'recurringFee' then 'recurring-fee'::core.operation_resource_type
+        when 'reservation' then 'reservation'::core.operation_resource_type
+        when 'listing' then 'listing'::core.operation_resource_type
+        when 'ownerStatement' then 'statement'::core.operation_resource_type
+        else 'team'::core.operation_resource_type
+      end,
+      case
+        when outstanding.root_entity_type in (
+          'recurringFee',
+          'reservation',
+          'listing',
+          'ownerStatement'
+        ) then outstanding.root_entity_id
+        else outstanding.tenant_id
+      end,
+      case
+        when outstanding.status = 'completed'
+          and outstanding.latest_attempt_status is distinct from 'skipped_locked'
+          then outstanding.completed_at
+        else null
+      end,
+      case
+        when outstanding.status = 'completed'
+          and outstanding.latest_attempt_status is distinct from 'skipped_locked'
+          then outstanding.effect_id
+        else null
+      end,
+      outstanding.created_at
+    from outstanding
+    on conflict (effect_id) do nothing
+  `.execute(db);
+
+  await sql`
+    update accounting.reservation_journal_state as state
+    set
+      desired_revision = revisions.desired_revision,
+      applied_revision = revisions.applied_revision,
+      stale_since = revisions.stale_since,
+      calculated_at = coalesce(revisions.calculated_at, state.calculated_at),
+      updated_at = now()
+    from (
+      select
+        tenant_id,
+        reservation_id,
+        max(revision) as desired_revision,
+        coalesce(
+          min(revision) filter (where applied_at is null) - 1,
+          max(revision)
+        ) as applied_revision,
+        min(created_at) filter (where applied_at is null) as stale_since,
+        max(applied_at) as calculated_at
+      from accounting.reservation_journal_invalidation
+      group by tenant_id, reservation_id
+    ) as revisions
+    where state.tenant_id = revisions.tenant_id
+      and state.reservation_id = revisions.reservation_id
+  `.execute(db);
+
+  await sql`
+    with reservation_scope as (
+      select
+        invalidation.id as invalidation_id,
+        invalidation.tenant_id,
+        reservation.id as reservation_id,
+        listing_scope.listing_id,
+        coalesce(reservation.currency, tenant.default_currency) as currency,
+        least(
+          reservation.effective_check_in,
+          reservation.effective_check_out,
+          reservation.booked_at,
+          reservation.general_ledger_posting_at,
+          reservation.created_at,
+          line_bounds.minimum_at,
+          entry_bounds.minimum_at
+        ) as minimum_at,
+        greatest(
+          reservation.effective_check_in,
+          reservation.effective_check_out,
+          reservation.booked_at,
+          reservation.general_ledger_posting_at,
+          reservation.created_at,
+          line_bounds.maximum_at,
+          entry_bounds.maximum_at
+        ) as maximum_at
+      from accounting.reservation_journal_invalidation as invalidation
+      inner join public.reservation as reservation
+        on reservation.id = invalidation.reservation_id
+        and reservation.tenant_id = invalidation.tenant_id
+      inner join public.tenant as tenant
+        on tenant.id = invalidation.tenant_id
+      inner join lateral (
+        select coalesce(listing.parent_id, reservation.listing_id) as listing_id
+        from public.listing as listing
+        where listing.id = reservation.listing_id
+        union
+        select distinct coalesce(entry_listing.parent_id, entry.listing_id)
+        from accounting.journal_entry as entry
+        left join public.listing as entry_listing
+          on entry_listing.id = entry.listing_id
+        where entry.tenant_id = invalidation.tenant_id
+          and entry.reservation_id = invalidation.reservation_id
+          and entry.listing_id is not null
+      ) as listing_scope on true
+      left join lateral (
+        select
+          min(line.general_ledger_posting_at) as minimum_at,
+          max(line.general_ledger_posting_at) as maximum_at
+        from public.payment_line as line
+        where line.tenant_id = invalidation.tenant_id
+          and line.reservation_id = invalidation.reservation_id
+      ) as line_bounds on true
+      left join lateral (
+        select
+          min(entry.txn_at) as minimum_at,
+          max(entry.txn_at) as maximum_at
+        from accounting.journal_entry as entry
+        where entry.tenant_id = invalidation.tenant_id
+          and entry.reservation_id = invalidation.reservation_id
+      ) as entry_bounds on true
+      where invalidation.applied_at is null
+        and listing_scope.listing_id is not null
+    ), currencies as (
+      select
+        scope.invalidation_id,
+        scope.tenant_id,
+        scope.listing_id,
+        scope.minimum_at,
+        scope.maximum_at,
+        scope.currency
+      from reservation_scope as scope
+      where scope.currency is not null
+      union
+      select
+        scope.invalidation_id,
+        scope.tenant_id,
+        scope.listing_id,
+        scope.minimum_at,
+        scope.maximum_at,
+        entry.currency
+      from reservation_scope as scope
+      inner join accounting.journal_entry as entry
+        on entry.tenant_id = scope.tenant_id
+        and entry.reservation_id = scope.reservation_id
+    ), months as (
+      select
+        currencies.*,
+        month::date as month
+      from currencies
+      cross join lateral generate_series(
+        date_trunc('month', currencies.minimum_at),
+        date_trunc('month', currencies.maximum_at),
+        interval '1 month'
+      ) as month
+      where currencies.minimum_at is not null
+        and currencies.maximum_at is not null
+    )
+    insert into accounting.reservation_journal_statement_impact (
+      invalidation_id,
+      tenant_id,
+      listing_id,
+      listing_ownership_period_id,
+      month,
+      currency
+    )
+    select distinct
+      months.invalidation_id,
+      months.tenant_id,
+      months.listing_id,
+      ownership.id,
+      months.month,
+      months.currency
+    from months
+    inner join public.listing_ownership_period as ownership
+      on ownership.tenant_id = months.tenant_id
+      and ownership.listing_id = months.listing_id
+      and (
+        ownership.start_at is null
+        or ownership.start_at < months.month + interval '1 month'
+      )
+      and (
+        ownership.end_at is null
+        or ownership.end_at > months.month
+      )
+    on conflict do nothing
+  `.execute(db);
+}
+
+export async function down(_db: Kysely<unknown>): Promise<void> {}

package/build/migrations-v2/0000000000045-reservation-journal-freshness-revision-repair.ts

@@ -0,0 +1,83 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    with desired_revisions as (
+      select
+        state.tenant_id,
+        state.reservation_id,
+        max(invalidation.revision) as desired_revision
+      from accounting.reservation_journal_state as state
+      inner join accounting.reservation_journal_invalidation as invalidation
+        on invalidation.tenant_id = state.tenant_id
+        and invalidation.reservation_id = state.reservation_id
+        and invalidation.revision > state.desired_revision
+      group by state.tenant_id, state.reservation_id
+    )
+    update accounting.reservation_journal_state as state
+    set
+      desired_revision = greatest(
+        state.desired_revision,
+        desired_revisions.desired_revision
+      ),
+      updated_at = now()
+    from desired_revisions
+    where state.tenant_id = desired_revisions.tenant_id
+      and state.reservation_id = desired_revisions.reservation_id
+      and state.desired_revision < desired_revisions.desired_revision
+  `.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
+      left join accounting.reservation_journal_invalidation as invalidation
+        on invalidation.tenant_id = state.tenant_id
+        and invalidation.reservation_id = state.reservation_id
+      where state.desired_revision > state.applied_revision
+      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 = case
+        when greatest(
+          state.applied_revision,
+          advancement.applied_revision
+        ) >= state.desired_revision then null
+        else coalesce(state.stale_since, advancement.stale_since)
+      end,
+      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
+  `.execute(db);
+}
+
+export async function down(_db: Kysely<unknown>): Promise<void> {}