State machines

pending  ──────►  invited  ──────►  completed  ──────►  arrived  ──────►  checked_out
   │                │                                      │
   │                └─ (retour possible si annulation) ─────┘
   │
   │ initial state quand guest créé

export const checkInTransitions = {
  pending:     ["invited"],
  invited:     ["completed", "pending"],   // cancel invite possible
  completed:   ["arrived"],
  arrived:     ["checked_out"],
  checked_out: [],                          // terminal
} as const;

         ┌──────────────►  occupied  ─┐
         │                            │
   reserved                           ▼
         ▲                       cleaning
         │                            │
      available  ◄───────────────────┘
         ▲
         │
     maintenance

export const roomStatusTransitions = {
  available:   ["reserved", "occupied", "maintenance"],
  reserved:    ["occupied", "available", "maintenance"],
  occupied:    ["cleaning", "maintenance"],
  cleaning:    ["available", "maintenance"],
  maintenance: ["available", "cleaning"],
} as const;

pending  ──►  preparing  ──►  delivering  ──►  delivered
   │             │
   └──► cancelled ◄──┘
   │
(cancelled accessible depuis pending et preparing uniquement)

export const roomServiceTransitions = {
  pending:    ["preparing", "cancelled"],
  preparing:  ["delivering", "cancelled"],
  delivering: ["delivered"],
  delivered:  [],
  cancelled:  [],
} as const;

pending  ──►  collected  ──►  washing  ──►  ready  ──►  delivered
   │             │              │             │
   └──► cancelled ◄──────────────┘             │
                                               │
                                          (ready → cancelled
                                           pas autorisé,
                                           tout est lavé)

requested  ──►  confirmed  ──►  seated  ──►  done
    │               │             │
    └──►  cancelled  ◄────────────┘
                                  │
                                  └──► no_show (heure dépassée + pas séjour)

requested  ──►  confirmed  ──►  in_progress  ──►  done
    │               │              │
    └──►  cancelled ◄──────────────┘

inquiry  ──►  confirmed  ──►  checked_in  ──►  checked_out
    │             │
    └─► canceled ◄┘

open  ──►  in_progress  ──►  waiting  ──►  resolved  ──►  closed
   │            │               │             │
   └──► cancelled ◄──────────────┴─────────────┘

import { checkInStatusEnum } from "@bell/db/schema/enums";

export type CheckInStatus = (typeof checkInStatusEnum.enumValues)[number];

export const checkInTransitions = {
  pending:     ["invited"],
  invited:     ["completed", "pending"],
  completed:   ["arrived"],
  arrived:     ["checked_out"],
  checked_out: [],
} as const satisfies Record<CheckInStatus, readonly CheckInStatus[]>;

export function canTransitionCheckIn(from: CheckInStatus, to: CheckInStatus): boolean {
  return checkInTransitions[from].includes(to as never);
}

export class InvalidCheckInTransitionError extends Error {
  readonly code = "INVALID_CHECK_IN_TRANSITION";
  constructor(public from: CheckInStatus, public to: CheckInStatus) {
    super(`Invalid check-in transition: ${from} → ${to}`);
    this.name = "InvalidCheckInTransitionError";
  }
}

export function assertTransitionCheckIn(from: CheckInStatus, to: CheckInStatus): void {
  if (!canTransitionCheckIn(from, to)) {
    throw new InvalidCheckInTransitionError(from, to);
  }
}

import { describe, test, expect } from "bun:test";
import { checkInStatusEnum } from "@bell/db/schema/enums";
import {
  canTransitionCheckIn,
  assertTransitionCheckIn,
  InvalidCheckInTransitionError,
  checkInTransitions,
} from "./check-in.machine";

describe("check-in state machine", () => {
  // Matrice exhaustive
  for (const from of checkInStatusEnum.enumValues) {
    for (const to of checkInStatusEnum.enumValues) {
      const allowed = checkInTransitions[from].includes(to as never);
      test(`${allowed ? "allows" : "forbids"} ${from} → ${to}`, () => {
        expect(canTransitionCheckIn(from, to)).toBe(allowed);
      });
    }
  }

  test("assert throws InvalidCheckInTransitionError on forbidden transition", () => {
    expect(() => assertTransitionCheckIn("arrived", "pending"))
      .toThrow(InvalidCheckInTransitionError);
  });

  test("every checkInStatus value is a valid machine key", () => {
    for (const status of checkInStatusEnum.enumValues) {
      expect(checkInTransitions[status]).toBeDefined();
    }
  });
});

import { assertTransitionCheckIn } from "../../domain/check-in.machine";

export async function confirmGuestArrival(opts: {
  organizationId: string;
  guestId: string;
}) {
  return await db.transaction(async (tx) => {
    const current = await repo.getGuestById(tx, opts);
    if (!current) throw new NotFoundError("guest");

    // Invalide la transition si elle n'est pas autorisée
    assertTransitionCheckIn(current.checkInStatus, "arrived");

    await repo.setCheckInStatus(tx, opts.guestId, "arrived");
    // ... suite
  });
}