@voyantjs/bookings 0.9.0 → 0.11.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 { 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
@@ -1481,58 +1550,6 @@ export const bookingsService = {
             .returning({ id: bookings.id });
         return row ?? null;
     },
-    async updateBookingStatus(db, id, data, userId, runtime = {}) {
-        const [current] = await db
-            .select({ id: bookings.id, status: bookings.status })
-            .from(bookings)
-            .where(eq(bookings.id, id))
-            .limit(1);
-        if (!current) {
-            return { status: "not_found" };
-        }
-        if (current.status === "on_hold" && data.status === "confirmed") {
-            return bookingsService.confirmBooking(db, id, { note: data.note }, userId, runtime);
-        }
-        if (current.status === "on_hold" && data.status === "expired") {
-            return bookingsService.expireBooking(db, id, { note: data.note }, userId, runtime);
-        }
-        if (data.status === "cancelled") {
-            return bookingsService.cancelBooking(db, id, { note: data.note }, userId, runtime);
-        }
-        if (data.status === "on_hold") {
-            return { status: "invalid_transition" };
-        }
-        if (!isValidBookingTransition(current.status, data.status)) {
-            return { status: "invalid_transition" };
-        }
-        const [row] = await db
-            .update(bookings)
-            .set({
-            status: data.status,
-            ...toBookingStatusTimestamps(data.status),
-            updatedAt: new Date(),
-        })
-            .where(eq(bookings.id, id))
-            .returning();
-        await db.insert(bookingActivityLog).values({
-            bookingId: id,
-            actorId: userId ?? "system",
-            activityType: "status_change",
-            description: `Status changed from ${current.status} to ${data.status}`,
-            metadata: { oldStatus: current.status, newStatus: data.status },
-        });
-        if (data.note) {
-            await db.insert(bookingNotes).values({
-                bookingId: id,
-                authorId: userId ?? "system",
-                content: data.note,
-            });
-        }
-        if (data.status === "confirmed") {
-            await autoIssueFulfillmentsForBooking(db, id, userId);
-        }
-        return { status: "ok", booking: row ?? null };
-    },
     async confirmBooking(db, id, data, userId, runtime = {}) {
         try {
             const result = await db.transaction(async (tx) => {
@@ -1544,12 +1561,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 +1586,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 +1689,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 +1718,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 +1788,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 +1818,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))
@@ -1837,6 +1860,198 @@ export const bookingsService = {
             throw error;
         }
     },
+    async startBooking(db, id, data, userId, runtime = {}) {
+        try {
+            const result = await db.transaction(async (tx) => {
+                const rows = await tx.execute(sql `SELECT id, booking_number, status
+              FROM ${bookings}
+              WHERE ${bookings.id} = ${id}
+              FOR UPDATE`);
+                const booking = rows[0];
+                if (!booking) {
+                    throw new BookingServiceError("not_found");
+                }
+                if (!canTransitionBooking(booking.status, "in_progress")) {
+                    throw new BookingServiceError("invalid_transition");
+                }
+                const patch = transitionBooking(booking.status, "in_progress");
+                const [row] = await tx
+                    .update(bookings)
+                    .set({
+                    ...patch,
+                    updatedAt: new Date(),
+                })
+                    .where(eq(bookings.id, id))
+                    .returning();
+                await tx.insert(bookingActivityLog).values({
+                    bookingId: id,
+                    actorId: userId ?? "system",
+                    activityType: "booking_started",
+                    description: `Booking ${booking.booking_number} started`,
+                });
+                if (data.note) {
+                    await tx.insert(bookingNotes).values({
+                        bookingId: id,
+                        authorId: userId ?? "system",
+                        content: data.note,
+                    });
+                }
+                return { status: "ok", booking: row ?? null };
+            });
+            if (result.status === "ok" && result.booking) {
+                await runtime.eventBus?.emit("booking.started", {
+                    bookingId: result.booking.id,
+                    bookingNumber: result.booking.bookingNumber,
+                    actorId: userId ?? null,
+                }, { category: "domain", source: "service" });
+            }
+            return result;
+        }
+        catch (error) {
+            if (error instanceof BookingServiceError) {
+                return { status: error.code };
+            }
+            throw error;
+        }
+    },
+    async completeBooking(db, id, data, userId, runtime = {}) {
+        try {
+            const result = await db.transaction(async (tx) => {
+                const rows = await tx.execute(sql `SELECT id, booking_number, status
+              FROM ${bookings}
+              WHERE ${bookings.id} = ${id}
+              FOR UPDATE`);
+                const booking = rows[0];
+                if (!booking) {
+                    throw new BookingServiceError("not_found");
+                }
+                if (!canTransitionBooking(booking.status, "completed")) {
+                    throw new BookingServiceError("invalid_transition");
+                }
+                const patch = transitionBooking(booking.status, "completed");
+                await tx
+                    .update(bookingAllocations)
+                    .set({ status: "fulfilled", updatedAt: new Date() })
+                    .where(and(eq(bookingAllocations.bookingId, id), eq(bookingAllocations.status, "confirmed")));
+                await tx
+                    .update(bookingItems)
+                    .set({ status: "fulfilled", updatedAt: new Date() })
+                    .where(and(eq(bookingItems.bookingId, id), eq(bookingItems.status, "confirmed")));
+                const [row] = await tx
+                    .update(bookings)
+                    .set({
+                    ...patch,
+                    updatedAt: new Date(),
+                })
+                    .where(eq(bookings.id, id))
+                    .returning();
+                await tx.insert(bookingActivityLog).values({
+                    bookingId: id,
+                    actorId: userId ?? "system",
+                    activityType: "booking_completed",
+                    description: `Booking ${booking.booking_number} completed`,
+                });
+                if (data.note) {
+                    await tx.insert(bookingNotes).values({
+                        bookingId: id,
+                        authorId: userId ?? "system",
+                        content: data.note,
+                    });
+                }
+                return { status: "ok", booking: row ?? null };
+            });
+            if (result.status === "ok" && result.booking) {
+                await runtime.eventBus?.emit("booking.completed", {
+                    bookingId: result.booking.id,
+                    bookingNumber: result.booking.bookingNumber,
+                    actorId: userId ?? null,
+                }, { category: "domain", source: "service" });
+            }
+            return result;
+        }
+        catch (error) {
+            if (error instanceof BookingServiceError) {
+                return { status: error.code };
+            }
+            throw error;
+        }
+    },
+    /**
+     * Admin-only force: bypasses the transition graph. Updates the booking row
+     * only — does NOT cascade to items, allocations, or fulfillments. If the
+     * operator needs cascaded behavior (e.g. release allocations), they should
+     * call the verb-specific method instead. The override is for data
+     * correction; misuse leaves child state inconsistent with the parent.
+     */
+    async overrideBookingStatus(db, id, data, userId, runtime = {}) {
+        try {
+            const result = await db.transaction(async (tx) => {
+                const rows = await tx.execute(sql `SELECT id, booking_number, status
+              FROM ${bookings}
+              WHERE ${bookings.id} = ${id}
+              FOR UPDATE`);
+                const booking = rows[0];
+                if (!booking) {
+                    throw new BookingServiceError("not_found");
+                }
+                const now = new Date();
+                const updates = {
+                    status: data.status,
+                    updatedAt: now,
+                };
+                if (data.status === "confirmed")
+                    updates.confirmedAt = now;
+                if (data.status === "expired")
+                    updates.expiredAt = now;
+                if (data.status === "cancelled")
+                    updates.cancelledAt = now;
+                if (data.status === "completed")
+                    updates.completedAt = now;
+                const [row] = await tx.update(bookings).set(updates).where(eq(bookings.id, id)).returning();
+                await tx.insert(bookingActivityLog).values({
+                    bookingId: id,
+                    actorId: userId ?? "system",
+                    activityType: "status_overridden",
+                    description: `Booking status overridden from ${booking.status} to ${data.status}`,
+                    metadata: {
+                        oldStatus: booking.status,
+                        newStatus: data.status,
+                        reason: data.reason,
+                    },
+                });
+                if (data.note) {
+                    await tx.insert(bookingNotes).values({
+                        bookingId: id,
+                        authorId: userId ?? "system",
+                        content: data.note,
+                    });
+                }
+                return {
+                    status: "ok",
+                    booking: row ?? null,
+                    fromStatus: booking.status,
+                    toStatus: data.status,
+                };
+            });
+            if (result.status === "ok" && result.booking) {
+                await runtime.eventBus?.emit("booking.status_overridden", {
+                    bookingId: result.booking.id,
+                    bookingNumber: result.booking.bookingNumber,
+                    fromStatus: result.fromStatus,
+                    toStatus: result.toStatus,
+                    reason: data.reason,
+                    actorId: userId ?? null,
+                }, { category: "domain", source: "service" });
+            }
+            return { status: result.status, booking: result.booking };
+        }
+        catch (error) {
+            if (error instanceof BookingServiceError) {
+                return { status: error.code };
+            }
+            throw error;
+        }
+    },
     listTravelerRecords(db, bookingId) {
         return db
             .select()
@@ -1873,7 +2088,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 +2142,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 +2155,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 +2172,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