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

package/build/migrations-v2/0000000000046-materialized-reservation-journal-operations.ts

@@ -0,0 +1,709 @@
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+
+async function replaceOperationRefreshFunctions(db: Kysely<unknown>) {
+  await sql`
+    create or replace function core.refresh_operation_state(
+      target_operation_id uuid
+    ) returns void
+    language plpgsql
+    as $$
+    declare
+      next_status core.operation_status;
+      next_started_at timestamptz;
+      next_finished_at timestamptz;
+      next_failure_code text;
+      next_failure_message text;
+      target_operation_type core.operation_type;
+      target_public_id_format core.operation_public_id_format;
+      target_action_id uuid;
+    begin
+      select
+        operation.type,
+        operation.public_id_format,
+        source.source_id
+      into
+        target_operation_type,
+        target_public_id_format,
+        target_action_id
+      from core.operation as operation
+      left join core.operation_source as source
+        on source.operation_id = operation.id
+        and source.source_type = 'audit-action'
+      where operation.id = target_operation_id;
+
+      select
+        case
+          when count(*) filter (where required) = 0 then 'queued'
+          when bool_and(status = 'completed') filter (where required)
+            then 'completed'
+          when bool_and(status in ('completed', 'failed')) filter (where required)
+            then 'failed'
+          when bool_or(status = 'running') filter (where required)
+            or bool_or(status in ('completed', 'failed')) filter (where required)
+            then 'running'
+          else 'queued'
+        end::core.operation_status,
+        min(started_at) filter (where required),
+        max(finished_at) filter (where required)
+      into next_status, next_started_at, next_finished_at
+      from core.operation_source
+      where operation_id = target_operation_id;
+
+      if next_status = 'failed' then
+        if target_operation_type = 'reservation-journal-refresh'
+          and target_public_id_format = 'action'
+          and target_action_id is not null then
+          select
+            case
+              when bool_or(
+                invalidation.applied_at is null
+                and attempt.result_code = 'journal_unbalanced'
+              ) then 'journalUnbalanced'
+              when bool_or(
+                invalidation.applied_at is null
+                and attempt.result_code = 'journal_configuration_invalid'
+              ) then 'journalConfigurationInvalid'
+              when bool_or(
+                invalidation.applied_at is null
+                and attempt.result_code in (
+                  'statement_period_locked',
+                  'skipped_locked'
+                )
+              ) then 'journalLocked'
+              else 'journalRefreshFailed'
+            end,
+            case
+              when bool_or(
+                invalidation.applied_at is null
+                and attempt.result_code = 'journal_unbalanced'
+              ) then 'Journal refresh produced unbalanced entries'
+              when bool_or(
+                invalidation.applied_at is null
+                and attempt.result_code = 'journal_configuration_invalid'
+              ) then 'Journal configuration is invalid'
+              when bool_or(
+                invalidation.applied_at is null
+                and attempt.result_code in (
+                  'statement_period_locked',
+                  'skipped_locked'
+                )
+              ) then 'Journal refresh is blocked by accounting locks'
+              else 'Journal refresh failed'
+            end
+          into next_failure_code, next_failure_message
+          from audit.effect as effect
+          left join accounting.reservation_journal_invalidation as invalidation
+            on invalidation.tenant_id = effect.tenant_id
+            and invalidation.effect_id = effect.id
+          left join lateral (
+            select effect_attempt.result_code
+            from audit.effect_attempt as effect_attempt
+            where effect_attempt.tenant_id = effect.tenant_id
+              and effect_attempt.effect_id = effect.id
+            order by effect_attempt.attempt_num desc
+            limit 1
+          ) as attempt on true
+          where effect.action_id = target_action_id
+            and effect.effect_type = 'REFRESH_RESERVATION_JOURNAL'
+            and effect.entity_type = 'reservation';
+        else
+          next_failure_code := 'operation_failed';
+          next_failure_message := 'Operation failed';
+        end if;
+      else
+        next_failure_code := null;
+        next_failure_message := null;
+      end if;
+
+      update core.operation
+      set
+        status = next_status,
+        started_at = coalesce(core.operation.started_at, next_started_at),
+        finished_at = case
+          when next_status in ('completed', 'failed')
+            then coalesce(next_finished_at, now())
+          else null
+        end,
+        failure_code = next_failure_code,
+        failure_message = next_failure_message,
+        updated_at = now(),
+        source_version = source_version + 1
+      where id = target_operation_id
+        and (
+          status is distinct from next_status
+          or started_at is distinct from coalesce(started_at, next_started_at)
+          or finished_at is distinct from case
+            when next_status in ('completed', 'failed')
+              then coalesce(next_finished_at, finished_at, now())
+            else null
+          end
+          or failure_code is distinct from next_failure_code
+          or failure_message is distinct from next_failure_message
+        );
+    end;
+    $$
+  `.execute(db);
+
+  await sql`
+    create or replace function core.refresh_audit_action_source(
+      target_action_id uuid
+    ) returns void
+    language plpgsql
+    as $$
+    declare
+      operation_row record;
+      next_status core.operation_status;
+      next_started_at timestamptz;
+      next_finished_at timestamptz;
+    begin
+      for operation_row in
+        select
+          operation.id,
+          operation.type,
+          operation.public_id_format
+        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 = target_action_id
+      loop
+        if operation_row.type = 'reservation-journal-refresh' then
+          select
+            case
+              when count(*) = 0 then 'failed'
+              when bool_or(
+                (
+                  invalidation.id is null
+                  or invalidation.applied_at is null
+                )
+                and effect.status in ('claimed', 'running')
+              ) then 'running'
+              when bool_or(
+                (
+                  invalidation.id is null
+                  or invalidation.applied_at is null
+                )
+                and (
+                  effect.status = 'pending'
+                  or (
+                    effect.status = 'failed'
+                    and effect.retry_count < effect.max_retries
+                  )
+                )
+              ) then 'queued'
+              when bool_and(
+                (
+                  invalidation.id is not null
+                  and invalidation.applied_at is not null
+                )
+                or (
+                  invalidation.id is null
+                  and effect.status = 'completed'
+                )
+              ) then 'completed'
+              else 'failed'
+            end::core.operation_status,
+            case
+              when count(*) = 0 then now()
+              else min(coalesce(effect.claimed_at, effect.last_attempt_at))
+            end,
+            case
+              when count(*) = 0 then now()
+              when bool_or(
+                (
+                  invalidation.id is null
+                  or invalidation.applied_at is null
+                )
+                and (
+                  effect.status in ('pending', 'claimed', 'running')
+                  or (
+                    effect.status = 'failed'
+                    and effect.retry_count < effect.max_retries
+                  )
+                )
+              ) then null
+              else coalesce(
+                max(coalesce(
+                  invalidation.applied_at,
+                  effect.completed_at,
+                  effect.last_attempt_at,
+                  effect.claimed_at,
+                  invalidation.created_at
+                )),
+                now()
+              )
+            end
+          into next_status, next_started_at, next_finished_at
+          from audit.effect as effect
+          left join accounting.reservation_journal_invalidation as invalidation
+            on invalidation.tenant_id = effect.tenant_id
+            and invalidation.effect_id = effect.id
+          where effect.action_id = target_action_id
+            and (
+              operation_row.public_id_format = 'legacy'
+              or (
+                effect.effect_type = 'REFRESH_RESERVATION_JOURNAL'
+                and effect.entity_type = 'reservation'
+              )
+            );
+        else
+          select
+            case
+              when count(*) = 0 then 'completed'
+              when bool_and(effect.status = 'completed') then 'completed'
+              when bool_and(
+                effect.status in ('completed', 'dead_letter')
+                or (
+                  effect.status = 'failed'
+                  and effect.retry_count >= effect.max_retries
+                )
+              ) then 'failed'
+              when bool_or(effect.status in ('claimed', 'running'))
+                or bool_or(
+                  effect.status in ('completed', 'dead_letter')
+                  or (
+                    effect.status = 'failed'
+                    and effect.retry_count >= effect.max_retries
+                  )
+                ) then 'running'
+              else 'queued'
+            end::core.operation_status,
+            case
+              when count(*) = 0 then now()
+              else min(coalesce(effect.last_attempt_at, effect.claimed_at))
+            end,
+            case
+              when count(*) = 0 then now()
+              when bool_and(
+                effect.status in ('completed', 'dead_letter')
+                or (
+                  effect.status = 'failed'
+                  and effect.retry_count >= effect.max_retries
+                )
+              ) then coalesce(
+                max(coalesce(effect.completed_at, effect.last_attempt_at)),
+                now()
+              )
+            end
+          into next_status, next_started_at, next_finished_at
+          from audit.effect as effect
+          where effect.action_id = target_action_id;
+        end if;
+
+        update core.operation_source as source
+        set
+          status = next_status,
+          started_at = next_started_at,
+          finished_at = next_finished_at,
+          source_version = source.source_version + 1
+        where source.operation_id = operation_row.id
+          and source.source_type = 'audit-action'
+          and source.source_id = target_action_id
+          and (
+            source.status is distinct from next_status
+            or source.started_at is distinct from next_started_at
+            or source.finished_at is distinct from next_finished_at
+          );
+
+        perform core.refresh_operation_state(operation_row.id);
+      end loop;
+    end;
+    $$
+  `.execute(db);
+}
+
+async function restoreOperationRefreshFunctions(db: Kysely<unknown>) {
+  await sql`
+    create or replace function core.refresh_operation_state(
+      target_operation_id uuid
+    ) returns void
+    language plpgsql
+    as $$
+    declare
+      next_status core.operation_status;
+      next_started_at timestamptz;
+      next_finished_at timestamptz;
+    begin
+      select
+        case
+          when count(*) filter (where required) = 0 then 'queued'
+          when bool_and(status = 'completed') filter (where required)
+            then 'completed'
+          when bool_and(status in ('completed', 'failed')) filter (where required)
+            then 'failed'
+          when bool_or(status = 'running') filter (where required)
+            or bool_or(status in ('completed', 'failed')) filter (where required)
+            then 'running'
+          else 'queued'
+        end::core.operation_status,
+        min(started_at) filter (where required),
+        max(finished_at) filter (where required)
+      into next_status, next_started_at, next_finished_at
+      from core.operation_source
+      where operation_id = target_operation_id;
+
+      update core.operation
+      set
+        status = next_status,
+        started_at = coalesce(core.operation.started_at, next_started_at),
+        finished_at = case
+          when next_status in ('completed', 'failed')
+            then coalesce(next_finished_at, now())
+          else null
+        end,
+        failure_code = case
+          when next_status = 'failed' then 'operation_failed'
+        end,
+        failure_message = case
+          when next_status = 'failed' then 'Operation failed'
+        end,
+        updated_at = now(),
+        source_version = source_version + 1
+      where id = target_operation_id
+        and (
+          status is distinct from next_status
+          or started_at is distinct from coalesce(started_at, next_started_at)
+          or finished_at is distinct from case
+            when next_status in ('completed', 'failed')
+              then coalesce(next_finished_at, finished_at, now())
+            else null
+          end
+        );
+    end;
+    $$
+  `.execute(db);
+
+  await sql`
+    create or replace function core.refresh_audit_action_source(
+      target_action_id uuid
+    ) returns void
+    language plpgsql
+    as $$
+    declare
+      target_operation_id uuid;
+    begin
+      update core.operation_source as source
+      set
+        status = state.status,
+        started_at = state.started_at,
+        finished_at = state.finished_at,
+        source_version = source.source_version + 1
+      from (
+        select
+          case
+            when count(*) = 0 then 'completed'
+            when bool_and(effect.status = 'completed') then 'completed'
+            when bool_and(
+              effect.status in ('completed', 'dead_letter')
+              or (
+                effect.status = 'failed'
+                and effect.retry_count >= effect.max_retries
+              )
+            ) then 'failed'
+            when bool_or(effect.status in ('claimed', 'running'))
+              or bool_or(
+                effect.status in ('completed', 'dead_letter')
+                or (
+                  effect.status = 'failed'
+                  and effect.retry_count >= effect.max_retries
+                )
+              ) then 'running'
+            else 'queued'
+          end::core.operation_status as status,
+          case
+            when count(*) = 0 then now()
+            else min(coalesce(effect.last_attempt_at, effect.claimed_at))
+          end as started_at,
+          case
+            when count(*) = 0 then now()
+            when bool_and(
+              effect.status in ('completed', 'dead_letter')
+              or (
+                effect.status = 'failed'
+                and effect.retry_count >= effect.max_retries
+              )
+            ) then coalesce(
+              max(coalesce(effect.completed_at, effect.last_attempt_at)),
+              now()
+            )
+          end as finished_at
+        from audit.effect
+        where action_id = target_action_id
+      ) as state
+      where source.source_type = 'audit-action'
+        and source.source_id = target_action_id
+        and (
+          source.status is distinct from state.status
+          or source.started_at is distinct from state.started_at
+          or source.finished_at is distinct from state.finished_at
+        );
+
+      for target_operation_id in
+        select operation_id
+        from core.operation_source
+        where source_type = 'audit-action'
+          and source_id = target_action_id
+      loop
+        perform core.refresh_operation_state(target_operation_id);
+      end loop;
+    end;
+    $$
+  `.execute(db);
+}
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    create type core.operation_public_id_format as enum ('action', 'legacy')
+  `.execute(db);
+  await sql`
+    alter table core.operation
+      add column public_id_format core.operation_public_id_format
+        not null default 'legacy'
+  `.execute(db);
+  await sql`
+    create index reservation_journal_invalidation_operation_idx
+      on accounting.reservation_journal_invalidation (
+        action_id,
+        tenant_id,
+        effect_id
+      )
+      where action_id is not null
+  `.execute(db);
+  await sql`
+    create table core.operation_backfill (
+      name text primary key,
+      completed_at timestamptz,
+      created_at timestamptz not null default now(),
+      updated_at timestamptz not null default now()
+    )
+  `.execute(db);
+  await sql`
+    insert into core.operation_backfill (name)
+    values ('reservation-journal-refresh-v1')
+  `.execute(db);
+
+  await replaceOperationRefreshFunctions(db);
+
+  await sql`
+    create function core.register_reservation_journal_operation(
+      target_action_id uuid
+    ) returns void
+    language plpgsql
+    as $$
+    begin
+      insert into core.operation (
+        id,
+        tenant_id,
+        initiated_by_user_id,
+        type,
+        public_id_format,
+        created_at,
+        updated_at
+      )
+      select
+        action.id,
+        action.tenant_id,
+        case when action.actor_type = 'user' then action.actor_id end,
+        'reservation-journal-refresh',
+        'action',
+        action.created_at,
+        action.created_at
+      from audit.action as action
+      where action.id = target_action_id
+        and exists (
+          select 1
+          from accounting.reservation_journal_invalidation as invalidation
+          where invalidation.action_id = action.id
+            and invalidation.tenant_id = action.tenant_id
+        )
+        and exists (
+          select 1
+          from audit.effect as effect
+          where effect.action_id = action.id
+            and effect.tenant_id = action.tenant_id
+            and effect.effect_type = 'REFRESH_RESERVATION_JOURNAL'
+            and effect.entity_type = 'reservation'
+        )
+        and not exists (
+          select 1
+          from core.operation_source as source
+          where source.source_type = 'audit-action'
+            and source.source_id = action.id
+        )
+      on conflict (id) do nothing;
+
+      insert into core.operation_source (
+        operation_id,
+        source_type,
+        source_id
+      )
+      select operation.id, 'audit-action', target_action_id
+      from core.operation as operation
+      where operation.id = target_action_id
+        and operation.type = 'reservation-journal-refresh'
+        and operation.public_id_format = 'action'
+        and exists (
+          select 1
+          from audit.effect as effect
+          where effect.action_id = target_action_id
+            and effect.tenant_id = operation.tenant_id
+            and effect.effect_type = 'REFRESH_RESERVATION_JOURNAL'
+            and effect.entity_type = 'reservation'
+        )
+      on conflict (source_type, source_id) do nothing;
+
+      insert into core.operation_resource (
+        operation_id,
+        resource_type,
+        resource_id,
+        role,
+        is_primary
+      )
+      select
+        operation.id,
+        case
+          when recurring_fee.id is not null
+            then 'recurring-fee'::core.operation_resource_type
+          else case action.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
+        end,
+        case
+          when recurring_fee.id is not null then recurring_fee.id
+          when action.root_entity_type in (
+            'recurringFee',
+            'reservation',
+            'listing',
+            'ownerStatement'
+          ) and action.root_entity_id is not null then action.root_entity_id
+          else action.tenant_id
+        end,
+        'source',
+        true
+      from core.operation as operation
+      inner join audit.action as action
+        on action.id = operation.id
+        and action.tenant_id = operation.tenant_id
+      left join lateral (
+        select mutation.subject_id as id
+        from audit.mutation as mutation
+        where mutation.action_id = action.id
+          and mutation.tenant_id = action.tenant_id
+          and action.action_type = 'recurring_fees.update'
+          and mutation.subject_type = 'recurringFee'
+        order by mutation.created_at, mutation.id
+        limit 1
+      ) as recurring_fee on true
+      where operation.id = target_action_id
+        and operation.type = 'reservation-journal-refresh'
+        and operation.public_id_format = 'action'
+      on conflict do nothing;
+
+      perform core.refresh_audit_action_source(target_action_id);
+    end;
+    $$
+  `.execute(db);
+
+  await sql`
+    create function core.refresh_reservation_journal_invalidation_operation()
+    returns trigger
+    language plpgsql
+    as $$
+    begin
+      if new.action_id is not null then
+        perform core.register_reservation_journal_operation(new.action_id);
+      end if;
+      if tg_op = 'UPDATE'
+        and old.action_id is distinct from new.action_id
+        and old.action_id is not null then
+        perform core.refresh_audit_action_source(old.action_id);
+      end if;
+      return new;
+    end;
+    $$
+  `.execute(db);
+  await sql`
+    create trigger refresh_reservation_journal_invalidation_operation
+    after insert or update of action_id, applied_at
+    on accounting.reservation_journal_invalidation
+    for each row
+    execute function core.refresh_reservation_journal_invalidation_operation()
+  `.execute(db);
+
+  await sql`
+    create function core.refresh_audit_action_operation_attempt()
+    returns trigger
+    language plpgsql
+    as $$
+    begin
+      perform core.refresh_audit_action_source(
+        coalesce(new.action_id, old.action_id)
+      );
+      return coalesce(new, old);
+    end;
+    $$
+  `.execute(db);
+  await sql`
+    create trigger refresh_audit_action_operation_attempt
+    after insert or update of status, result_code, finished_at or delete
+    on audit.effect_attempt
+    for each row execute function core.refresh_audit_action_operation_attempt()
+  `.execute(db);
+
+  await sql`
+    do $$
+    begin
+      if exists (select 1 from pg_roles where rolname = 'application') then
+        grant execute on function
+          core.register_reservation_journal_operation(uuid),
+          core.refresh_reservation_journal_invalidation_operation(),
+          core.refresh_audit_action_operation_attempt()
+        to application;
+        grant select, update on core.operation_backfill to application;
+      end if;
+    end;
+    $$
+  `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await sql`
+    drop trigger if exists refresh_audit_action_operation_attempt
+      on audit.effect_attempt
+  `.execute(db);
+  await sql`
+    drop function if exists core.refresh_audit_action_operation_attempt
+  `.execute(db);
+  await sql`
+    drop trigger if exists refresh_reservation_journal_invalidation_operation
+      on accounting.reservation_journal_invalidation
+  `.execute(db);
+  await sql`
+    drop function if exists
+      core.refresh_reservation_journal_invalidation_operation
+  `.execute(db);
+  await sql`
+    drop function if exists core.register_reservation_journal_operation
+  `.execute(db);
+
+  await sql`
+    delete from core.operation
+    where public_id_format = 'action'
+      and type = 'reservation-journal-refresh'
+  `.execute(db);
+  await restoreOperationRefreshFunctions(db);
+  await sql`drop table core.operation_backfill`.execute(db);
+  await sql`
+    drop index accounting.reservation_journal_invalidation_operation_idx
+  `.execute(db);
+  await sql`
+    alter table core.operation drop column public_id_format
+  `.execute(db);
+  await sql`drop type core.operation_public_id_format`.execute(db);
+}