@voyantjs/bookings 0.9.0 → 0.10.0

package/dist/service.js

@@ -1,8 +1,10 @@
 import { and, asc, desc, eq, exists, ilike, inArray, lte, ne, or, sql } from "drizzle-orm";
 import { availabilitySlotsRef } from "./availability-ref.js";
+import { exchangeRatesRef } from "./markets-ref.js";
 import { bookingItemProductDetailsRef, bookingProductDetailsRef, optionUnitsRef, productDayServicesRef, productDaysRef, productItinerariesRef, productOptionsRef, productsRef, productTicketSettingsRef, } from "./products-ref.js";
 import { bookingActivityLog, bookingAllocations, bookingDocuments, bookingFulfillments, bookingItems, bookingItemTravelers, bookingNotes, bookingRedemptionEvents, bookingStaffAssignments, bookingSupplierStatuses, bookings, bookingTravelers, } from "./schema.js";
 import { cleanupGroupOnBookingCancelled } from "./service-groups.js";
+import { BookingTransitionError, canTransitionBooking, transitionBooking, } from "./state-machine.js";
 import { bookingTransactionDetailsRef, offerItemParticipantsRef, offerItemsRef, offerParticipantsRef, offerStaffAssignmentsRef, offersRef, orderItemParticipantsRef, orderItemsRef, orderParticipantsRef, orderStaffAssignmentsRef, ordersRef, } from "./transactions-ref.js";
 const travelerParticipantTypes = ["traveler", "occupant"];
 class BookingServiceError extends Error {
@@ -35,7 +37,6 @@ function toTravelerResponse(participant) {
         email: participant.email,
         phone: participant.phone,
         preferredLanguage: participant.preferredLanguage,
-        accessibilityNeeds: participant.accessibilityNeeds,
         specialRequests: participant.specialRequests,
         isPrimary: participant.isPrimary,
         notes: participant.notes,
@@ -250,18 +251,6 @@ async function getConvertProductData(db, data) {
         })),
     };
 }
-const VALID_BOOKING_TRANSITIONS = {
-    draft: ["on_hold", "confirmed", "cancelled"],
-    on_hold: ["confirmed", "expired", "cancelled"],
-    confirmed: ["in_progress", "cancelled"],
-    in_progress: ["completed", "cancelled"],
-    completed: [],
-    expired: [],
-    cancelled: [],
-};
-function isValidBookingTransition(from, to) {
-    return VALID_BOOKING_TRANSITIONS[from].includes(to);
-}
 function computeHoldExpiresAt(input) {
     if (input.holdExpiresAt) {
         return new Date(input.holdExpiresAt);
@@ -270,14 +259,94 @@ function computeHoldExpiresAt(input) {
     const minutes = input.holdMinutes ?? 30;
     return new Date(now + minutes * 60 * 1000);
 }
-function toBookingStatusTimestamps(status) {
-    const now = new Date();
-    return {
-        confirmedAt: status === "confirmed" ? now : undefined,
-        expiredAt: status === "expired" ? now : undefined,
-        cancelledAt: status === "cancelled" ? now : undefined,
-        completedAt: status === "completed" ? now : undefined,
-    };
+/**
+ * Walk a booking's items, convert each line into the booking's
+ * `baseCurrency` via the booking's `fxRateSetId`, sum.
+ *
+ * Returns:
+ * - `{ status: "ok", baseSellAmountCents, baseCostAmountCents }` when
+ *   every item's currency was either already in `baseCurrency` or had
+ *   a rate row in the rate set
+ * - `{ status: "missing_rate", currency }` when an item's
+ *   `sellCurrency` had no rate in the rate set; caller treats as
+ *   "leave base totals untouched, surface to ops"
+ * - `{ status: "skipped" }` when the booking has no `fxRateSetId`
+ *   (multi-currency conversion isn't possible without one)
+ *
+ * Pure conversion math. Caller controls persistence.
+ */
+async function rollupBaseTotals(db, bookingId, baseCurrency) {
+    const [booking] = await db
+        .select({ fxRateSetId: bookings.fxRateSetId })
+        .from(bookings)
+        .where(eq(bookings.id, bookingId))
+        .limit(1);
+    if (!booking?.fxRateSetId) {
+        return { status: "skipped" };
+    }
+    // Cache for the closure — TypeScript can't narrow `booking` after
+    // the closure boundary, so capture the id in a local.
+    const fxRateSetId = booking.fxRateSetId;
+    const items = await db
+        .select({
+        sellCurrency: bookingItems.sellCurrency,
+        totalSellAmountCents: bookingItems.totalSellAmountCents,
+        costCurrency: bookingItems.costCurrency,
+        totalCostAmountCents: bookingItems.totalCostAmountCents,
+    })
+        .from(bookingItems)
+        .where(eq(bookingItems.bookingId, bookingId));
+    // Cache rates we look up to avoid N+1 within one booking.
+    const rateCache = new Map(); // key: `${from}->${to}`, value: decimal rate or null
+    async function rate(from, to) {
+        if (from === to)
+            return 1;
+        const key = `${from}->${to}`;
+        if (rateCache.has(key))
+            return rateCache.get(key) ?? null;
+        const [direct] = await db
+            .select({ rate: exchangeRatesRef.rateDecimal })
+            .from(exchangeRatesRef)
+            .where(and(eq(exchangeRatesRef.fxRateSetId, fxRateSetId), eq(exchangeRatesRef.baseCurrency, from), eq(exchangeRatesRef.quoteCurrency, to)))
+            .limit(1);
+        if (direct) {
+            const value = Number.parseFloat(direct.rate);
+            rateCache.set(key, value);
+            return value;
+        }
+        // Try the inverse
+        const [inverse] = await db
+            .select({ rate: exchangeRatesRef.inverseRateDecimal })
+            .from(exchangeRatesRef)
+            .where(and(eq(exchangeRatesRef.fxRateSetId, fxRateSetId), eq(exchangeRatesRef.baseCurrency, to), eq(exchangeRatesRef.quoteCurrency, from)))
+            .limit(1);
+        if (inverse?.rate) {
+            const value = Number.parseFloat(inverse.rate);
+            rateCache.set(key, value);
+            return value;
+        }
+        rateCache.set(key, null);
+        return null;
+    }
+    let baseSellAmountCents = 0;
+    let baseCostAmountCents = 0;
+    for (const item of items) {
+        if (item.totalSellAmountCents !== null) {
+            const r = await rate(item.sellCurrency, baseCurrency);
+            if (r === null) {
+                return { status: "missing_rate", currency: item.sellCurrency };
+            }
+            baseSellAmountCents += Math.round(item.totalSellAmountCents * r);
+        }
+        if (item.totalCostAmountCents !== null && item.costCurrency) {
+            const r = await rate(item.costCurrency, baseCurrency);
+            if (r === null) {
+                return { status: "missing_rate", currency: item.costCurrency };
+            }
+            baseCostAmountCents += Math.round(item.totalCostAmountCents * r);
+        }
+    }
+    return { status: "ok", baseSellAmountCents, baseCostAmountCents };
 }
 async function lockAvailabilitySlot(db, slotId) {
     const rows = await db.execute(sql `SELECT id, product_id, option_id, date_local, starts_at, ends_at, timezone, status, unlimited, remaining_pax
@@ -1499,17 +1568,24 @@ export const bookingsService = {
         if (data.status === "cancelled") {
             return bookingsService.cancelBooking(db, id, { note: data.note }, userId, runtime);
         }
+        // `on_hold` is only reachable through `reserveBooking`, never via direct status PATCH.
         if (data.status === "on_hold") {
             return { status: "invalid_transition" };
         }
-        if (!isValidBookingTransition(current.status, data.status)) {
-            return { status: "invalid_transition" };
+        let patch;
+        try {
+            patch = transitionBooking(current.status, data.status);
+        }
+        catch (error) {
+            if (error instanceof BookingTransitionError) {
+                return { status: "invalid_transition" };
+            }
+            throw error;
         }
         const [row] = await db
             .update(bookings)
             .set({
-            status: data.status,
-            ...toBookingStatusTimestamps(data.status),
+            ...patch,
             updatedAt: new Date(),
         })
             .where(eq(bookings.id, id))
@@ -1544,12 +1620,16 @@ export const bookingsService = {
                 if (!booking) {
                     throw new BookingServiceError("not_found");
                 }
+                if (!canTransitionBooking(booking.status, "confirmed")) {
+                    throw new BookingServiceError("invalid_transition");
+                }
                 if (booking.status !== "on_hold") {
                     throw new BookingServiceError("invalid_transition");
                 }
                 if (booking.hold_expires_at && booking.hold_expires_at < new Date()) {
                     throw new BookingServiceError("hold_expired");
                 }
+                const patch = transitionBooking(booking.status, "confirmed");
                 await tx
                     .update(bookingAllocations)
                     .set({
@@ -1565,9 +1645,8 @@ export const bookingsService = {
                 const [row] = await tx
                     .update(bookings)
                     .set({
-                    status: "confirmed",
+                    ...patch,
                     holdExpiresAt: null,
-                    confirmedAt: new Date(),
                     updatedAt: new Date(),
                 })
                     .where(eq(bookings.id, id))
@@ -1669,9 +1748,13 @@ export const bookingsService = {
                 if (!booking) {
                     throw new BookingServiceError("not_found");
                 }
+                if (!canTransitionBooking(booking.status, "expired")) {
+                    throw new BookingServiceError("invalid_transition");
+                }
                 if (booking.status !== "on_hold") {
                     throw new BookingServiceError("invalid_transition");
                 }
+                const patch = transitionBooking(booking.status, "expired");
                 const allocations = await tx
                     .select()
                     .from(bookingAllocations)
@@ -1694,9 +1777,8 @@ export const bookingsService = {
                 const [row] = await tx
                     .update(bookings)
                     .set({
-                    status: "expired",
+                    ...patch,
                     holdExpiresAt: null,
-                    expiredAt: new Date(),
                     updatedAt: new Date(),
                 })
                     .where(eq(bookings.id, id))
@@ -1765,9 +1847,10 @@ export const bookingsService = {
                 if (!booking) {
                     throw new BookingServiceError("not_found");
                 }
-                if (!["draft", "on_hold", "confirmed", "in_progress"].includes(booking.status)) {
+                if (!canTransitionBooking(booking.status, "cancelled")) {
                     throw new BookingServiceError("invalid_transition");
                 }
+                const patch = transitionBooking(booking.status, "cancelled");
                 const previousStatus = booking.status;
                 const allocations = await tx
                     .select()
@@ -1794,9 +1877,8 @@ export const bookingsService = {
                 const [row] = await tx
                     .update(bookings)
                     .set({
-                    status: "cancelled",
+                    ...patch,
                     holdExpiresAt: null,
-                    cancelledAt: new Date(),
                     updatedAt: new Date(),
                 })
                     .where(eq(bookings.id, id))
@@ -1873,7 +1955,6 @@ export const bookingsService = {
             email: data.email ?? null,
             phone: data.phone ?? null,
             preferredLanguage: data.preferredLanguage ?? null,
-            accessibilityNeeds: data.accessibilityNeeds ?? null,
             specialRequests: data.specialRequests ?? null,
             isPrimary: data.isPrimary ?? false,
             notes: data.notes ?? null,
@@ -1928,7 +2009,6 @@ export const bookingsService = {
             email: data.email ?? null,
             phone: data.phone ?? null,
             preferredLanguage: data.preferredLanguage ?? null,
-            accessibilityNeeds: data.accessibilityNeeds ?? null,
             specialRequests: data.specialRequests ?? null,
             isPrimary: data.isPrimary ?? false,
             notes: data.notes ?? null,
@@ -1942,7 +2022,6 @@ export const bookingsService = {
             email: data.email ?? null,
             phone: data.phone ?? null,
             preferredLanguage: data.preferredLanguage ?? null,
-            accessibilityNeeds: data.accessibilityNeeds ?? null,
             specialRequests: data.specialRequests ?? null,
             travelerCategory: data.travelerCategory ?? null,
             isPrimary: data.isPrimary ?? undefined,
@@ -1960,74 +2039,194 @@ export const bookingsService = {
             .where(eq(bookingItems.bookingId, bookingId))
             .orderBy(asc(bookingItems.createdAt));
     },
-    async createItem(db, bookingId, data, userId) {
+    /**
+     * Re-derive `bookings.sellAmountCents` / `costAmountCents` from
+     * `Σ(booking_items.total*AmountCents)`, plus — when the booking
+     * declares a `baseCurrency` and `fxRateSetId` — re-derive
+     * `baseSellAmountCents` / `baseCostAmountCents` by converting each
+     * item's total via the FX rate set.
+     *
+     * Called automatically inside the item-mutation methods so callers
+     * that go through `createItem` / `updateItem` / `deleteItem` never
+     * have to remember to roll the parent. Public so external flows
+     * (saga compensations, ad-hoc fix-ups) can also invoke it.
+     *
+     * Pass a tx-bound `db` to compose with an existing transaction; this
+     * method does NOT wrap its own transaction.
+     *
+     * **FX rollup behaviour**:
+     *
+     * - Single-currency booking (every item's `sellCurrency === baseCurrency`,
+     *   or `baseCurrency === sellCurrency` on the parent): `base*Cents`
+     *   equal `sell*Cents` / `cost*Cents` directly. No FX lookup needed.
+     * - Multi-currency booking with `fxRateSetId`: every item is
+     *   converted to `baseCurrency` via `exchange_rates`. If any item's
+     *   currency is missing from the rate set, the FX rollup short-circuits
+     *   with `fxStatus: "missing_rate"` and `base*Cents` are LEFT
+     *   UNCHANGED on the parent (caller chooses whether to abort).
+     * - No `baseCurrency` configured: FX rollup is skipped entirely
+     *   (`fxStatus: "skipped"`), and `base*Cents` stay null.
+     *
+     * Returns `{ sellAmountCents, costAmountCents, baseSellAmountCents,
+     * baseCostAmountCents, fxStatus, missingCurrency? }` or `null` for a
+     * missing booking.
+     */
+    async recomputeBookingTotal(db, bookingId) {
         const [booking] = await db
-            .select({ id: bookings.id, sellCurrency: bookings.sellCurrency })
+            .select({
+            id: bookings.id,
+            sellCurrency: bookings.sellCurrency,
+            baseCurrency: bookings.baseCurrency,
+        })
             .from(bookings)
             .where(eq(bookings.id, bookingId))
             .limit(1);
         if (!booking) {
             return null;
         }
-        const [row] = await db
-            .insert(bookingItems)
-            .values({
-            bookingId,
-            title: data.title,
-            description: data.description ?? null,
-            itemType: data.itemType,
-            status: data.status,
-            serviceDate: data.serviceDate ?? null,
-            startsAt: toTimestamp(data.startsAt),
-            endsAt: toTimestamp(data.endsAt),
-            quantity: data.quantity,
-            sellCurrency: data.sellCurrency ?? booking.sellCurrency,
-            unitSellAmountCents: data.unitSellAmountCents ?? null,
-            totalSellAmountCents: data.totalSellAmountCents ?? null,
-            costCurrency: data.costCurrency ?? null,
-            unitCostAmountCents: data.unitCostAmountCents ?? null,
-            totalCostAmountCents: data.totalCostAmountCents ?? null,
-            notes: data.notes ?? null,
-            productId: data.productId ?? null,
-            optionId: data.optionId ?? null,
-            optionUnitId: data.optionUnitId ?? null,
-            pricingCategoryId: data.pricingCategoryId ?? null,
-            sourceSnapshotId: data.sourceSnapshotId ?? null,
-            sourceOfferId: data.sourceOfferId ?? null,
-            metadata: data.metadata ?? null,
+        const [totals] = await db
+            .select({
+            sellAmountCents: sql `coalesce(sum(${bookingItems.totalSellAmountCents}), 0)::int`,
+            costAmountCents: sql `coalesce(sum(${bookingItems.totalCostAmountCents}), 0)::int`,
         })
-            .returning();
-        if (!row) {
-            return null;
+            .from(bookingItems)
+            .where(eq(bookingItems.bookingId, bookingId));
+        const sellAmountCents = totals?.sellAmountCents ?? 0;
+        const costAmountCents = totals?.costAmountCents ?? 0;
+        // We need fxRateSetId from the bookings row plus per-item currency
+        // for the FX rollup. Refetch with those columns.
+        const [bookingForFx] = await db
+            .select({
+            baseCurrency: bookings.baseCurrency,
+            sellCurrency: bookings.sellCurrency,
+        })
+            .from(bookings)
+            .where(eq(bookings.id, bookingId))
+            .limit(1);
+        let fxStatus = "skipped";
+        let baseSellAmountCents = null;
+        let baseCostAmountCents = null;
+        let missingCurrency = null;
+        const baseCurrency = bookingForFx?.baseCurrency ?? null;
+        if (baseCurrency) {
+            const fxResult = await rollupBaseTotals(db, bookingId, baseCurrency);
+            if (fxResult.status === "ok") {
+                fxStatus = "ok";
+                baseSellAmountCents = fxResult.baseSellAmountCents;
+                baseCostAmountCents = fxResult.baseCostAmountCents;
+            }
+            else if (fxResult.status === "missing_rate") {
+                fxStatus = "missing_rate";
+                missingCurrency = fxResult.currency;
+            }
         }
-        await db.insert(bookingActivityLog).values({
-            bookingId,
-            actorId: userId ?? "system",
-            activityType: "item_update",
-            description: `Booking item "${data.title}" added`,
-            metadata: { bookingItemId: row.id, itemType: data.itemType },
+        const patch = {
+            sellAmountCents,
+            costAmountCents,
+            updatedAt: new Date(),
+        };
+        if (fxStatus === "ok") {
+            patch.baseSellAmountCents = baseSellAmountCents;
+            patch.baseCostAmountCents = baseCostAmountCents;
+        }
+        await db.update(bookings).set(patch).where(eq(bookings.id, bookingId));
+        return {
+            sellAmountCents,
+            costAmountCents,
+            baseSellAmountCents,
+            baseCostAmountCents,
+            fxStatus,
+            ...(missingCurrency ? { missingCurrency } : {}),
+        };
+    },
+    async createItem(db, bookingId, data, userId) {
+        return db.transaction(async (tx) => {
+            const [booking] = await tx
+                .select({ id: bookings.id, sellCurrency: bookings.sellCurrency })
+                .from(bookings)
+                .where(eq(bookings.id, bookingId))
+                .limit(1);
+            if (!booking) {
+                return null;
+            }
+            const [row] = await tx
+                .insert(bookingItems)
+                .values({
+                bookingId,
+                title: data.title,
+                description: data.description ?? null,
+                itemType: data.itemType,
+                status: data.status,
+                serviceDate: data.serviceDate ?? null,
+                startsAt: toTimestamp(data.startsAt),
+                endsAt: toTimestamp(data.endsAt),
+                quantity: data.quantity,
+                sellCurrency: data.sellCurrency ?? booking.sellCurrency,
+                unitSellAmountCents: data.unitSellAmountCents ?? null,
+                totalSellAmountCents: data.totalSellAmountCents ?? null,
+                costCurrency: data.costCurrency ?? null,
+                unitCostAmountCents: data.unitCostAmountCents ?? null,
+                totalCostAmountCents: data.totalCostAmountCents ?? null,
+                notes: data.notes ?? null,
+                productId: data.productId ?? null,
+                optionId: data.optionId ?? null,
+                optionUnitId: data.optionUnitId ?? null,
+                pricingCategoryId: data.pricingCategoryId ?? null,
+                sourceSnapshotId: data.sourceSnapshotId ?? null,
+                sourceOfferId: data.sourceOfferId ?? null,
+                metadata: data.metadata ?? null,
+            })
+                .returning();
+            if (!row) {
+                return null;
+            }
+            await tx.insert(bookingActivityLog).values({
+                bookingId,
+                actorId: userId ?? "system",
+                activityType: "item_update",
+                description: `Booking item "${data.title}" added`,
+                metadata: { bookingItemId: row.id, itemType: data.itemType },
+            });
+            await bookingsService.recomputeBookingTotal(tx, bookingId);
+            return row;
         });
-        return row;
     },
     async updateItem(db, itemId, data) {
-        const [row] = await db
-            .update(bookingItems)
-            .set({
-            ...data,
-            startsAt: data.startsAt === undefined ? undefined : toTimestamp(data.startsAt),
-            endsAt: data.endsAt === undefined ? undefined : toTimestamp(data.endsAt),
-            updatedAt: new Date(),
-        })
-            .where(eq(bookingItems.id, itemId))
-            .returning();
-        return row ?? null;
+        return db.transaction(async (tx) => {
+            const [row] = await tx
+                .update(bookingItems)
+                .set({
+                ...data,
+                startsAt: data.startsAt === undefined ? undefined : toTimestamp(data.startsAt),
+                endsAt: data.endsAt === undefined ? undefined : toTimestamp(data.endsAt),
+                updatedAt: new Date(),
+            })
+                .where(eq(bookingItems.id, itemId))
+                .returning();
+            if (!row)
+                return null;
+            await bookingsService.recomputeBookingTotal(tx, row.bookingId);
+            return row;
+        });
     },
     async deleteItem(db, itemId) {
-        const [row] = await db
-            .delete(bookingItems)
-            .where(eq(bookingItems.id, itemId))
-            .returning({ id: bookingItems.id });
-        return row ?? null;
+        return db.transaction(async (tx) => {
+            // Look up the parent booking BEFORE the delete so we can roll up
+            // afterwards.
+            const [item] = await tx
+                .select({ bookingId: bookingItems.bookingId })
+                .from(bookingItems)
+                .where(eq(bookingItems.id, itemId))
+                .limit(1);
+            const [row] = await tx
+                .delete(bookingItems)
+                .where(eq(bookingItems.id, itemId))
+                .returning({ id: bookingItems.id });
+            if (item) {
+                await bookingsService.recomputeBookingTotal(tx, item.bookingId);
+            }
+            return row ?? null;
+        });
     },
     listItemParticipants(db, itemId) {
         return db

package/dist/state-machine.d.ts

@@ -0,0 +1,29 @@
+import type { bookings } from "./schema-core.js";
+export type BookingStatus = (typeof bookings.$inferSelect)["status"];
+export declare const BOOKING_TRANSITIONS: {
+    readonly draft: readonly ["on_hold", "confirmed", "cancelled"];
+    readonly on_hold: readonly ["confirmed", "expired", "cancelled"];
+    readonly confirmed: readonly ["in_progress", "cancelled"];
+    readonly in_progress: readonly ["completed", "cancelled"];
+    readonly completed: readonly [];
+    readonly expired: readonly [];
+    readonly cancelled: readonly [];
+};
+export declare class BookingTransitionError extends Error {
+    readonly from: BookingStatus;
+    readonly to: BookingStatus;
+    readonly code = "INVALID_BOOKING_TRANSITION";
+    constructor(from: BookingStatus, to: BookingStatus);
+}
+export declare function canTransitionBooking(from: BookingStatus, to: BookingStatus): boolean;
+export interface BookingStatusPatch {
+    status: BookingStatus;
+    confirmedAt?: Date;
+    expiredAt?: Date;
+    cancelledAt?: Date;
+    completedAt?: Date;
+}
+export declare function transitionBooking(from: BookingStatus, to: BookingStatus, opts?: {
+    now?: Date;
+}): BookingStatusPatch;
+//# sourceMappingURL=state-machine.d.ts.map

package/dist/state-machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-machine.d.ts","sourceRoot":"","sources":["../src/state-machine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEhD,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,QAAQ,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,CAAA;AAEpE,eAAO,MAAM,mBAAmB;;;;;;;;CAQoC,CAAA;AAEpE,qBAAa,sBAAuB,SAAQ,KAAK;IAI7C,QAAQ,CAAC,IAAI,EAAE,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,aAAa;IAJ5B,QAAQ,CAAC,IAAI,gCAA+B;gBAGjC,IAAI,EAAE,aAAa,EACnB,EAAE,EAAE,aAAa;CAK7B;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,EAAE,EAAE,EAAE,aAAa,GAAG,OAAO,CAEpF;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,aAAa,CAAA;IACrB,WAAW,CAAC,EAAE,IAAI,CAAA;IAClB,SAAS,CAAC,EAAE,IAAI,CAAA;IAChB,WAAW,CAAC,EAAE,IAAI,CAAA;IAClB,WAAW,CAAC,EAAE,IAAI,CAAA;CACnB;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,aAAa,EACnB,EAAE,EAAE,aAAa,EACjB,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,IAAI,CAAA;CAAO,GACxB,kBAAkB,CAcpB"}

package/dist/state-machine.js

@@ -0,0 +1,39 @@
+export const BOOKING_TRANSITIONS = {
+    draft: ["on_hold", "confirmed", "cancelled"],
+    on_hold: ["confirmed", "expired", "cancelled"],
+    confirmed: ["in_progress", "cancelled"],
+    in_progress: ["completed", "cancelled"],
+    completed: [],
+    expired: [],
+    cancelled: [],
+};
+export class BookingTransitionError extends Error {
+    from;
+    to;
+    code = "INVALID_BOOKING_TRANSITION";
+    constructor(from, to) {
+        super(`Illegal booking status transition: ${from} → ${to}`);
+        this.from = from;
+        this.to = to;
+        this.name = "BookingTransitionError";
+    }
+}
+export function canTransitionBooking(from, to) {
+    return BOOKING_TRANSITIONS[from].includes(to);
+}
+export function transitionBooking(from, to, opts = {}) {
+    if (!canTransitionBooking(from, to)) {
+        throw new BookingTransitionError(from, to);
+    }
+    const now = opts.now ?? new Date();
+    const patch = { status: to };
+    if (to === "confirmed")
+        patch.confirmedAt = now;
+    if (to === "expired")
+        patch.expiredAt = now;
+    if (to === "cancelled")
+        patch.cancelledAt = now;
+    if (to === "completed")
+        patch.completedAt = now;
+    return patch;
+}

package/dist/validation-public.d.ts

@@ -17,7 +17,6 @@ export declare const publicBookingSessionTravelerInputSchema: z.ZodObject<{
     email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     preferredLanguage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    accessibilityNeeds: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     specialRequests: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     isPrimary: z.ZodDefault<z.ZodBoolean>;
     notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -127,7 +126,6 @@ export declare const publicCreateBookingSessionSchema: z.ZodObject<{
         email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         preferredLanguage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        accessibilityNeeds: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         specialRequests: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         isPrimary: z.ZodDefault<z.ZodBoolean>;
         notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -157,7 +155,6 @@ export declare const publicUpdateBookingSessionSchema: z.ZodObject<{
         email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         preferredLanguage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        accessibilityNeeds: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         specialRequests: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         isPrimary: z.ZodDefault<z.ZodBoolean>;
         notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -230,7 +227,6 @@ export declare const publicBookingSessionTravelerSchema: z.ZodObject<{
     email: z.ZodNullable<z.ZodString>;
     phone: z.ZodNullable<z.ZodString>;
     preferredLanguage: z.ZodNullable<z.ZodString>;
-    accessibilityNeeds: z.ZodNullable<z.ZodString>;
     specialRequests: z.ZodNullable<z.ZodString>;
     isPrimary: z.ZodBoolean;
     notes: z.ZodNullable<z.ZodString>;
@@ -373,7 +369,6 @@ export declare const publicBookingSessionSchema: z.ZodObject<{
         email: z.ZodNullable<z.ZodString>;
         phone: z.ZodNullable<z.ZodString>;
         preferredLanguage: z.ZodNullable<z.ZodString>;
-        accessibilityNeeds: z.ZodNullable<z.ZodString>;
         specialRequests: z.ZodNullable<z.ZodString>;
         isPrimary: z.ZodBoolean;
         notes: z.ZodNullable<z.ZodString>;
@@ -578,7 +573,6 @@ export declare const publicBookingSessionRepriceResultSchema: z.ZodObject<{
             email: z.ZodNullable<z.ZodString>;
             phone: z.ZodNullable<z.ZodString>;
             preferredLanguage: z.ZodNullable<z.ZodString>;
-            accessibilityNeeds: z.ZodNullable<z.ZodString>;
             specialRequests: z.ZodNullable<z.ZodString>;
             isPrimary: z.ZodBoolean;
             notes: z.ZodNullable<z.ZodString>;

package/dist/validation-public.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation-public.d.ts","sourceRoot":"","sources":["../src/validation-public.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"validation-public.d.ts","sourceRoot":"","sources":["../src/validation-public.ts"],"names":[],"mappings":"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"}

package/dist/validation-public.js

@@ -13,7 +13,6 @@ export const publicBookingSessionTravelerInputSchema = z.object({
     email: z.string().email().nullable().optional(),
     phone: z.string().max(50).nullable().optional(),
     preferredLanguage: z.string().max(35).nullable().optional(),
-    accessibilityNeeds: z.string().nullable().optional(),
     specialRequests: z.string().nullable().optional(),
     isPrimary: z.boolean().default(false),
     notes: z.string().nullable().optional(),
@@ -130,7 +129,6 @@ export const publicBookingSessionTravelerSchema = z.object({
     email: z.string().nullable(),
     phone: z.string().nullable(),
     preferredLanguage: z.string().nullable(),
-    accessibilityNeeds: z.string().nullable(),
     specialRequests: z.string().nullable(),
     isPrimary: z.boolean(),
     notes: z.string().nullable(),