@voyantjs/bookings 0.3.0 → 0.4.0

package/dist/service-public.js

@@ -0,0 +1,900 @@
+import { and, asc, desc, eq, inArray, or } from "drizzle-orm";
+import { optionPriceRulesRef, optionUnitPriceRulesRef, optionUnitTiersRef, priceCatalogsRef, } from "./pricing-ref.js";
+import { optionUnitsRef, productOptionsRef, productsRef } from "./products-ref.js";
+import { bookingAllocations, bookingDocuments, bookingFulfillments, bookingItemParticipants, bookingItems, bookingParticipants, bookingSessionStates, bookings, } from "./schema.js";
+import { bookingsService } from "./service.js";
+const travelerParticipantTypes = new Set(["traveler", "occupant"]);
+const WIZARD_STATE_KEY = "wizard";
+function normalizeDate(value) {
+    if (!value) {
+        return null;
+    }
+    if (value instanceof Date) {
+        return value.toISOString().slice(0, 10);
+    }
+    return value;
+}
+function normalizeDateTime(value) {
+    if (!value) {
+        return null;
+    }
+    return value instanceof Date ? value.toISOString() : value;
+}
+function countTravelerParticipants(participants) {
+    return participants.filter((participant) => travelerParticipantTypes.has(participant.participantType)).length;
+}
+function normalizeSessionState(bookingId, state) {
+    if (!state) {
+        return null;
+    }
+    return {
+        sessionId: bookingId,
+        stateKey: WIZARD_STATE_KEY,
+        currentStep: state.currentStep ?? null,
+        completedSteps: state.completedSteps ?? [],
+        payload: state.payload ?? {},
+        version: state.version,
+        createdAt: normalizeDateTime(state.createdAt),
+        updatedAt: normalizeDateTime(state.updatedAt),
+    };
+}
+async function getWizardSessionState(db, bookingId) {
+    const [state] = await db
+        .select()
+        .from(bookingSessionStates)
+        .where(and(eq(bookingSessionStates.bookingId, bookingId), eq(bookingSessionStates.stateKey, WIZARD_STATE_KEY)))
+        .limit(1);
+    return normalizeSessionState(bookingId, state);
+}
+async function upsertWizardSessionState(db, bookingId, input) {
+    const [existing] = await db
+        .select()
+        .from(bookingSessionStates)
+        .where(and(eq(bookingSessionStates.bookingId, bookingId), eq(bookingSessionStates.stateKey, WIZARD_STATE_KEY)))
+        .limit(1);
+    const payload = input.replacePayload
+        ? input.payload
+        : {
+            ...(existing?.payload ?? {}),
+            ...input.payload,
+        };
+    const completedSteps = input.completedSteps ?? existing?.completedSteps ?? [];
+    const currentStep = input.currentStep === undefined ? (existing?.currentStep ?? null) : (input.currentStep ?? null);
+    if (existing) {
+        const [updated] = await db
+            .update(bookingSessionStates)
+            .set({
+            currentStep,
+            completedSteps,
+            payload,
+            version: existing.version + 1,
+            updatedAt: new Date(),
+        })
+            .where(eq(bookingSessionStates.id, existing.id))
+            .returning();
+        return normalizeSessionState(bookingId, updated ?? existing);
+    }
+    const [created] = await db
+        .insert(bookingSessionStates)
+        .values({
+        bookingId,
+        stateKey: WIZARD_STATE_KEY,
+        currentStep,
+        completedSteps,
+        payload,
+        version: 1,
+    })
+        .returning();
+    return normalizeSessionState(bookingId, created);
+}
+function resolveTierAmount(tiers, quantity, fallbackAmount) {
+    const tier = tiers.find((candidate) => quantity >= candidate.minQuantity &&
+        (candidate.maxQuantity === null || quantity <= candidate.maxQuantity));
+    return tier?.sellAmountCents ?? fallbackAmount;
+}
+function computeLineTotal(pricingMode, unitSellAmountCents, quantity, fallbackAmount) {
+    switch (pricingMode) {
+        case "free":
+        case "included":
+            return 0;
+        case "on_request":
+            return null;
+        case "per_unit":
+        case "per_person":
+            return unitSellAmountCents === null ? null : unitSellAmountCents * quantity;
+        default:
+            return unitSellAmountCents ?? fallbackAmount;
+    }
+}
+async function generateBookingNumber(db) {
+    const now = new Date();
+    const y = now.getFullYear().toString().slice(-2);
+    const m = String(now.getMonth() + 1).padStart(2, "0");
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+        const suffix = String(Math.floor(Math.random() * 900000) + 100000);
+        const bookingNumber = `BK-${y}${m}-${suffix}`;
+        const [existing] = await db
+            .select({ id: bookings.id })
+            .from(bookings)
+            .where(eq(bookings.bookingNumber, bookingNumber))
+            .limit(1);
+        if (!existing) {
+            return bookingNumber;
+        }
+    }
+    throw new Error("Unable to generate a unique booking number");
+}
+async function buildOverviewSnapshot(db, query) {
+    const bookingLookupNumber = query.bookingNumber ?? query.bookingCode ?? null;
+    const [booking] = await db
+        .select()
+        .from(bookings)
+        .where(query.bookingId
+        ? eq(bookings.id, query.bookingId)
+        : bookingLookupNumber
+            ? eq(bookings.bookingNumber, bookingLookupNumber)
+            : eq(bookings.id, "__missing__"))
+        .limit(1);
+    if (!booking) {
+        return null;
+    }
+    const [participants, items, itemParticipantLinks, documents, fulfillments] = await Promise.all([
+        db
+            .select()
+            .from(bookingParticipants)
+            .where(eq(bookingParticipants.bookingId, booking.id))
+            .orderBy(asc(bookingParticipants.createdAt)),
+        db
+            .select()
+            .from(bookingItems)
+            .where(eq(bookingItems.bookingId, booking.id))
+            .orderBy(asc(bookingItems.createdAt)),
+        db
+            .select({
+            id: bookingItemParticipants.id,
+            bookingItemId: bookingItemParticipants.bookingItemId,
+            participantId: bookingItemParticipants.participantId,
+            role: bookingItemParticipants.role,
+            isPrimary: bookingItemParticipants.isPrimary,
+        })
+            .from(bookingItemParticipants)
+            .innerJoin(bookingItems, eq(bookingItems.id, bookingItemParticipants.bookingItemId))
+            .where(eq(bookingItems.bookingId, booking.id))
+            .orderBy(asc(bookingItemParticipants.createdAt)),
+        db
+            .select()
+            .from(bookingDocuments)
+            .where(eq(bookingDocuments.bookingId, booking.id))
+            .orderBy(asc(bookingDocuments.createdAt)),
+        db
+            .select()
+            .from(bookingFulfillments)
+            .where(eq(bookingFulfillments.bookingId, booking.id))
+            .orderBy(asc(bookingFulfillments.createdAt)),
+    ]);
+    const email = query.email?.trim().toLowerCase() ?? null;
+    if (email) {
+        const authorized = participants.some((participant) => participant.email?.toLowerCase() === email);
+        if (!authorized) {
+            return null;
+        }
+    }
+    const itemLinksByItemId = new Map();
+    for (const link of itemParticipantLinks) {
+        const existing = itemLinksByItemId.get(link.bookingItemId) ?? [];
+        existing.push({
+            id: link.id,
+            participantId: link.participantId,
+            role: link.role,
+            isPrimary: link.isPrimary,
+        });
+        itemLinksByItemId.set(link.bookingItemId, existing);
+    }
+    return {
+        bookingId: booking.id,
+        bookingNumber: booking.bookingNumber,
+        status: booking.status,
+        sellCurrency: booking.sellCurrency,
+        sellAmountCents: booking.sellAmountCents ?? null,
+        startDate: normalizeDate(booking.startDate),
+        endDate: normalizeDate(booking.endDate),
+        pax: booking.pax ?? null,
+        confirmedAt: normalizeDateTime(booking.confirmedAt),
+        cancelledAt: normalizeDateTime(booking.cancelledAt),
+        completedAt: normalizeDateTime(booking.completedAt),
+        participants: participants.map((participant) => ({
+            id: participant.id,
+            participantType: participant.participantType,
+            firstName: participant.firstName,
+            lastName: participant.lastName,
+            isPrimary: participant.isPrimary,
+        })),
+        items: items.map((item) => ({
+            id: item.id,
+            title: item.title,
+            description: item.description ?? null,
+            itemType: item.itemType,
+            status: item.status,
+            serviceDate: normalizeDate(item.serviceDate),
+            startsAt: normalizeDateTime(item.startsAt),
+            endsAt: normalizeDateTime(item.endsAt),
+            quantity: item.quantity,
+            sellCurrency: item.sellCurrency,
+            unitSellAmountCents: item.unitSellAmountCents ?? null,
+            totalSellAmountCents: item.totalSellAmountCents ?? null,
+            costCurrency: item.costCurrency ?? null,
+            unitCostAmountCents: item.unitCostAmountCents ?? null,
+            totalCostAmountCents: item.totalCostAmountCents ?? null,
+            notes: item.notes ?? null,
+            productId: item.productId ?? null,
+            optionId: item.optionId ?? null,
+            optionUnitId: item.optionUnitId ?? null,
+            pricingCategoryId: item.pricingCategoryId ?? null,
+            participantLinks: itemLinksByItemId.get(item.id) ?? [],
+        })),
+        documents: documents.map((document) => ({
+            id: document.id,
+            participantId: document.participantId ?? null,
+            type: document.type,
+            fileName: document.fileName,
+            fileUrl: document.fileUrl,
+        })),
+        fulfillments: fulfillments.map((fulfillment) => ({
+            id: fulfillment.id,
+            bookingItemId: fulfillment.bookingItemId ?? null,
+            participantId: fulfillment.participantId ?? null,
+            fulfillmentType: fulfillment.fulfillmentType,
+            deliveryChannel: fulfillment.deliveryChannel,
+            status: fulfillment.status,
+            artifactUrl: fulfillment.artifactUrl ?? null,
+        })),
+    };
+}
+function buildUnitWarnings(unit, quantity, sessionPax) {
+    const warnings = [];
+    if (!unit) {
+        return warnings;
+    }
+    if (unit.minQuantity !== null && quantity < unit.minQuantity) {
+        warnings.push(`Selected quantity is below the minimum for ${unit.name}.`);
+    }
+    if (unit.maxQuantity !== null && quantity > unit.maxQuantity) {
+        warnings.push(`Selected quantity is above the maximum for ${unit.name}.`);
+    }
+    if (sessionPax && unit.occupancyMin !== null && quantity * unit.occupancyMin > sessionPax) {
+        warnings.push(`Selected ${unit.name} quantity exceeds the current traveler count.`);
+    }
+    if (sessionPax && unit.occupancyMax !== null && quantity * unit.occupancyMax < sessionPax) {
+        warnings.push(`Selected ${unit.name} quantity does not cover the current traveler count.`);
+    }
+    return warnings;
+}
+async function resolveSessionPricingSnapshot(db, productId, input) {
+    const [product] = await db
+        .select({
+        id: productsRef.id,
+    })
+        .from(productsRef)
+        .where(and(eq(productsRef.id, productId), eq(productsRef.status, "active"), eq(productsRef.activated, true), eq(productsRef.visibility, "public")))
+        .limit(1);
+    if (!product) {
+        return null;
+    }
+    const catalog = input.catalogId
+        ? await db
+            .select({
+            id: priceCatalogsRef.id,
+            currencyCode: priceCatalogsRef.currencyCode,
+        })
+            .from(priceCatalogsRef)
+            .where(and(eq(priceCatalogsRef.id, input.catalogId), eq(priceCatalogsRef.catalogType, "public"), eq(priceCatalogsRef.active, true)))
+            .limit(1)
+            .then((rows) => rows[0] ?? null)
+        : await db
+            .select({
+            id: priceCatalogsRef.id,
+            currencyCode: priceCatalogsRef.currencyCode,
+        })
+            .from(priceCatalogsRef)
+            .where(and(eq(priceCatalogsRef.catalogType, "public"), eq(priceCatalogsRef.active, true)))
+            .orderBy(desc(priceCatalogsRef.isDefault), asc(priceCatalogsRef.name))
+            .limit(1)
+            .then((rows) => rows[0] ?? null);
+    if (!catalog) {
+        return null;
+    }
+    const optionConditions = [
+        eq(productOptionsRef.productId, productId),
+        eq(productOptionsRef.status, "active"),
+    ];
+    if (input.optionId) {
+        optionConditions.push(eq(productOptionsRef.id, input.optionId));
+    }
+    const options = await db
+        .select({
+        id: productOptionsRef.id,
+        name: productOptionsRef.name,
+        isDefault: productOptionsRef.isDefault,
+    })
+        .from(productOptionsRef)
+        .where(and(...optionConditions))
+        .orderBy(desc(productOptionsRef.isDefault), asc(productOptionsRef.sortOrder));
+    if (options.length === 0) {
+        return null;
+    }
+    const optionIds = options.map((option) => option.id);
+    const [rules, unitPrices] = await Promise.all([
+        db
+            .select({
+            id: optionPriceRulesRef.id,
+            optionId: optionPriceRulesRef.optionId,
+            pricingMode: optionPriceRulesRef.pricingMode,
+            baseSellAmountCents: optionPriceRulesRef.baseSellAmountCents,
+            isDefault: optionPriceRulesRef.isDefault,
+        })
+            .from(optionPriceRulesRef)
+            .where(and(eq(optionPriceRulesRef.productId, productId), inArray(optionPriceRulesRef.optionId, optionIds), eq(optionPriceRulesRef.priceCatalogId, catalog.id), eq(optionPriceRulesRef.active, true)))
+            .orderBy(desc(optionPriceRulesRef.isDefault), asc(optionPriceRulesRef.name)),
+        db
+            .select({
+            id: optionUnitPriceRulesRef.id,
+            optionPriceRuleId: optionUnitPriceRulesRef.optionPriceRuleId,
+            unitId: optionUnitPriceRulesRef.unitId,
+            unitName: optionUnitsRef.name,
+            unitType: optionUnitsRef.unitType,
+            pricingCategoryId: optionUnitPriceRulesRef.pricingCategoryId,
+            pricingMode: optionUnitPriceRulesRef.pricingMode,
+            sellAmountCents: optionUnitPriceRulesRef.sellAmountCents,
+            minQuantity: optionUnitPriceRulesRef.minQuantity,
+            maxQuantity: optionUnitPriceRulesRef.maxQuantity,
+        })
+            .from(optionUnitPriceRulesRef)
+            .innerJoin(optionUnitsRef, eq(optionUnitsRef.id, optionUnitPriceRulesRef.unitId))
+            .where(and(inArray(optionUnitPriceRulesRef.optionId, optionIds), eq(optionUnitPriceRulesRef.active, true)))
+            .orderBy(asc(optionUnitPriceRulesRef.sortOrder), asc(optionUnitPriceRulesRef.createdAt)),
+    ]);
+    const tiers = unitPrices.length > 0
+        ? await db
+            .select({
+            id: optionUnitTiersRef.id,
+            optionUnitPriceRuleId: optionUnitTiersRef.optionUnitPriceRuleId,
+            minQuantity: optionUnitTiersRef.minQuantity,
+            maxQuantity: optionUnitTiersRef.maxQuantity,
+            sellAmountCents: optionUnitTiersRef.sellAmountCents,
+            sortOrder: optionUnitTiersRef.sortOrder,
+        })
+            .from(optionUnitTiersRef)
+            .where(and(inArray(optionUnitTiersRef.optionUnitPriceRuleId, unitPrices.map((row) => row.id)), eq(optionUnitTiersRef.active, true)))
+            .orderBy(asc(optionUnitTiersRef.sortOrder), asc(optionUnitTiersRef.minQuantity))
+        : [];
+    const tiersByUnitPriceId = new Map();
+    for (const tier of tiers) {
+        const existing = tiersByUnitPriceId.get(tier.optionUnitPriceRuleId) ?? [];
+        existing.push(tier);
+        tiersByUnitPriceId.set(tier.optionUnitPriceRuleId, existing);
+    }
+    return {
+        catalog: catalog,
+        options: options,
+        rules: rules,
+        unitPrices: unitPrices.map((row) => ({
+            ...row,
+            tiers: tiersByUnitPriceId.get(row.id) ?? [],
+        })),
+    };
+}
+async function buildSessionSnapshot(db, bookingId) {
+    const [booking, participants, items, allocations, itemParticipantLinks, state] = await Promise.all([
+        bookingsService.getBookingById(db, bookingId),
+        db
+            .select()
+            .from(bookingParticipants)
+            .where(eq(bookingParticipants.bookingId, bookingId))
+            .orderBy(asc(bookingParticipants.createdAt)),
+        db
+            .select()
+            .from(bookingItems)
+            .where(eq(bookingItems.bookingId, bookingId))
+            .orderBy(asc(bookingItems.createdAt)),
+        db
+            .select()
+            .from(bookingAllocations)
+            .where(eq(bookingAllocations.bookingId, bookingId))
+            .orderBy(asc(bookingAllocations.createdAt)),
+        db
+            .select({
+            id: bookingItemParticipants.id,
+            bookingItemId: bookingItemParticipants.bookingItemId,
+            participantId: bookingItemParticipants.participantId,
+            role: bookingItemParticipants.role,
+            isPrimary: bookingItemParticipants.isPrimary,
+        })
+            .from(bookingItemParticipants)
+            .innerJoin(bookingItems, eq(bookingItems.id, bookingItemParticipants.bookingItemId))
+            .where(eq(bookingItems.bookingId, bookingId))
+            .orderBy(asc(bookingItemParticipants.createdAt)),
+        getWizardSessionState(db, bookingId),
+    ]);
+    if (!booking) {
+        return null;
+    }
+    const itemLinksByItemId = new Map();
+    for (const link of itemParticipantLinks) {
+        const existing = itemLinksByItemId.get(link.bookingItemId) ?? [];
+        existing.push({
+            id: link.id,
+            participantId: link.participantId,
+            role: link.role,
+            isPrimary: link.isPrimary,
+        });
+        itemLinksByItemId.set(link.bookingItemId, existing);
+    }
+    const hasParticipants = participants.length > 0;
+    const hasTraveler = countTravelerParticipants(participants) > 0;
+    const hasPrimaryParticipant = participants.some((participant) => participant.isPrimary);
+    const hasItems = items.length > 0;
+    const hasAllocations = allocations.length > 0;
+    return {
+        sessionId: booking.id,
+        bookingNumber: booking.bookingNumber,
+        status: booking.status,
+        externalBookingRef: booking.externalBookingRef ?? null,
+        communicationLanguage: booking.communicationLanguage ?? null,
+        sellCurrency: booking.sellCurrency,
+        sellAmountCents: booking.sellAmountCents ?? null,
+        startDate: normalizeDate(booking.startDate),
+        endDate: normalizeDate(booking.endDate),
+        pax: booking.pax ?? null,
+        holdExpiresAt: normalizeDateTime(booking.holdExpiresAt),
+        confirmedAt: normalizeDateTime(booking.confirmedAt),
+        expiredAt: normalizeDateTime(booking.expiredAt),
+        cancelledAt: normalizeDateTime(booking.cancelledAt),
+        completedAt: normalizeDateTime(booking.completedAt),
+        participants: participants.map((participant) => ({
+            id: participant.id,
+            participantType: participant.participantType,
+            travelerCategory: participant.travelerCategory ?? null,
+            firstName: participant.firstName,
+            lastName: participant.lastName,
+            email: participant.email ?? null,
+            phone: participant.phone ?? null,
+            preferredLanguage: participant.preferredLanguage ?? null,
+            accessibilityNeeds: participant.accessibilityNeeds ?? null,
+            specialRequests: participant.specialRequests ?? null,
+            isPrimary: participant.isPrimary,
+            notes: participant.notes ?? null,
+        })),
+        items: items.map((item) => ({
+            id: item.id,
+            title: item.title,
+            description: item.description ?? null,
+            itemType: item.itemType,
+            status: item.status,
+            serviceDate: normalizeDate(item.serviceDate),
+            startsAt: normalizeDateTime(item.startsAt),
+            endsAt: normalizeDateTime(item.endsAt),
+            quantity: item.quantity,
+            sellCurrency: item.sellCurrency,
+            unitSellAmountCents: item.unitSellAmountCents ?? null,
+            totalSellAmountCents: item.totalSellAmountCents ?? null,
+            costCurrency: item.costCurrency ?? null,
+            unitCostAmountCents: item.unitCostAmountCents ?? null,
+            totalCostAmountCents: item.totalCostAmountCents ?? null,
+            notes: item.notes ?? null,
+            productId: item.productId ?? null,
+            optionId: item.optionId ?? null,
+            optionUnitId: item.optionUnitId ?? null,
+            pricingCategoryId: item.pricingCategoryId ?? null,
+            participantLinks: itemLinksByItemId.get(item.id) ?? [],
+        })),
+        allocations: allocations.map((allocation) => ({
+            id: allocation.id,
+            bookingItemId: allocation.bookingItemId ?? null,
+            productId: allocation.productId ?? null,
+            optionId: allocation.optionId ?? null,
+            optionUnitId: allocation.optionUnitId ?? null,
+            pricingCategoryId: allocation.pricingCategoryId ?? null,
+            availabilitySlotId: allocation.availabilitySlotId ?? null,
+            quantity: allocation.quantity,
+            allocationType: allocation.allocationType,
+            status: allocation.status,
+            holdExpiresAt: normalizeDateTime(allocation.holdExpiresAt),
+            confirmedAt: normalizeDateTime(allocation.confirmedAt),
+            releasedAt: normalizeDateTime(allocation.releasedAt),
+        })),
+        checklist: {
+            hasParticipants,
+            hasTraveler,
+            hasPrimaryParticipant,
+            hasItems,
+            hasAllocations,
+            readyForConfirmation: booking.status === "on_hold" &&
+                hasParticipants &&
+                hasTraveler &&
+                hasPrimaryParticipant &&
+                hasItems &&
+                hasAllocations,
+        },
+        state,
+    };
+}
+export const publicBookingsService = {
+    async createSession(db, input, userId) {
+        const travelerCount = countTravelerParticipants(input.participants);
+        const bookingNumber = await generateBookingNumber(db);
+        const result = await bookingsService.reserveBooking(db, {
+            bookingNumber,
+            sourceType: "direct",
+            externalBookingRef: input.externalBookingRef ?? null,
+            communicationLanguage: input.communicationLanguage ?? null,
+            sellCurrency: input.sellCurrency,
+            baseCurrency: input.baseCurrency ?? null,
+            sellAmountCents: input.sellAmountCents ?? null,
+            baseSellAmountCents: input.baseSellAmountCents ?? null,
+            costAmountCents: input.costAmountCents ?? null,
+            baseCostAmountCents: input.baseCostAmountCents ?? null,
+            marginPercent: input.marginPercent ?? null,
+            startDate: input.startDate ?? null,
+            endDate: input.endDate ?? null,
+            pax: input.pax ?? (travelerCount > 0 ? travelerCount : null),
+            holdMinutes: input.holdMinutes,
+            holdExpiresAt: input.holdExpiresAt ?? null,
+            items: input.items.map((item) => ({
+                ...item,
+                sellCurrency: item.sellCurrency ?? input.sellCurrency,
+                costCurrency: item.costCurrency ?? null,
+                description: item.description ?? null,
+                notes: item.notes ?? null,
+                productId: item.productId ?? null,
+                optionId: item.optionId ?? null,
+                optionUnitId: item.optionUnitId ?? null,
+                pricingCategoryId: item.pricingCategoryId ?? null,
+                sourceSnapshotId: item.sourceSnapshotId ?? null,
+                sourceOfferId: null,
+                metadata: item.metadata ?? null,
+            })),
+            internalNotes: null,
+        }, userId);
+        if (!("booking" in result) || !result.booking) {
+            return result;
+        }
+        for (const participant of input.participants) {
+            await bookingsService.createParticipant(db, result.booking.id, {
+                participantType: participant.participantType,
+                travelerCategory: participant.travelerCategory ?? null,
+                firstName: participant.firstName,
+                lastName: participant.lastName,
+                email: participant.email ?? null,
+                phone: participant.phone ?? null,
+                preferredLanguage: participant.preferredLanguage ?? null,
+                accessibilityNeeds: participant.accessibilityNeeds ?? null,
+                specialRequests: participant.specialRequests ?? null,
+                isPrimary: participant.isPrimary,
+                notes: participant.notes ?? null,
+                personId: null,
+            }, userId);
+        }
+        const session = await buildSessionSnapshot(db, result.booking.id);
+        return session ? { status: "ok", session } : { status: "not_found" };
+    },
+    getSessionById(db, bookingId) {
+        return buildSessionSnapshot(db, bookingId);
+    },
+    async getSessionState(db, bookingId) {
+        const booking = await bookingsService.getBookingById(db, bookingId);
+        if (!booking) {
+            return null;
+        }
+        return getWizardSessionState(db, bookingId);
+    },
+    async updateSessionState(db, bookingId, input) {
+        const booking = await bookingsService.getBookingById(db, bookingId);
+        if (!booking) {
+            return { status: "not_found" };
+        }
+        const state = await upsertWizardSessionState(db, bookingId, input);
+        return { status: "ok", state };
+    },
+    async updateSession(db, bookingId, input, userId) {
+        const booking = await bookingsService.getBookingById(db, bookingId);
+        if (!booking) {
+            return { status: "not_found" };
+        }
+        if (input.externalBookingRef !== undefined ||
+            input.communicationLanguage !== undefined ||
+            input.pax !== undefined) {
+            await bookingsService.updateBooking(db, bookingId, {
+                externalBookingRef: input.externalBookingRef,
+                communicationLanguage: input.communicationLanguage,
+                pax: input.pax,
+            });
+        }
+        for (const participantId of input.removedParticipantIds) {
+            const participant = await bookingsService.getParticipantById(db, bookingId, participantId);
+            if (participant) {
+                await bookingsService.deleteParticipant(db, participant.id);
+            }
+        }
+        if (input.participants) {
+            for (const participant of input.participants) {
+                if (participant.id) {
+                    const existing = await bookingsService.getParticipantById(db, bookingId, participant.id);
+                    if (!existing) {
+                        return { status: "participant_not_found" };
+                    }
+                    await bookingsService.updateParticipant(db, participant.id, {
+                        participantType: participant.participantType,
+                        travelerCategory: participant.travelerCategory ?? null,
+                        firstName: participant.firstName,
+                        lastName: participant.lastName,
+                        email: participant.email ?? null,
+                        phone: participant.phone ?? null,
+                        preferredLanguage: participant.preferredLanguage ?? null,
+                        accessibilityNeeds: participant.accessibilityNeeds ?? null,
+                        specialRequests: participant.specialRequests ?? null,
+                        isPrimary: participant.isPrimary,
+                        notes: participant.notes ?? null,
+                    });
+                    continue;
+                }
+                await bookingsService.createParticipant(db, bookingId, {
+                    participantType: participant.participantType,
+                    travelerCategory: participant.travelerCategory ?? null,
+                    firstName: participant.firstName,
+                    lastName: participant.lastName,
+                    email: participant.email ?? null,
+                    phone: participant.phone ?? null,
+                    preferredLanguage: participant.preferredLanguage ?? null,
+                    accessibilityNeeds: participant.accessibilityNeeds ?? null,
+                    specialRequests: participant.specialRequests ?? null,
+                    isPrimary: participant.isPrimary,
+                    notes: participant.notes ?? null,
+                    personId: null,
+                }, userId);
+            }
+        }
+        if (input.holdMinutes !== undefined || input.holdExpiresAt !== undefined) {
+            const holdResult = await bookingsService.extendBookingHold(db, bookingId, {
+                holdMinutes: input.holdMinutes,
+                holdExpiresAt: input.holdExpiresAt,
+            }, userId);
+            if (holdResult.status !== "ok") {
+                return holdResult;
+            }
+        }
+        if (input.pax === undefined && (input.participants || input.removedParticipantIds.length > 0)) {
+            const participants = await db
+                .select({ participantType: bookingParticipants.participantType })
+                .from(bookingParticipants)
+                .where(eq(bookingParticipants.bookingId, bookingId));
+            const travelerCount = countTravelerParticipants(participants);
+            await bookingsService.updateBooking(db, bookingId, {
+                pax: travelerCount > 0 ? travelerCount : null,
+            });
+        }
+        const session = await buildSessionSnapshot(db, bookingId);
+        return session ? { status: "ok", session } : { status: "not_found" };
+    },
+    async repriceSession(db, bookingId, input) {
+        const [booking, items] = await Promise.all([
+            bookingsService.getBookingById(db, bookingId),
+            db
+                .select()
+                .from(bookingItems)
+                .where(eq(bookingItems.bookingId, bookingId))
+                .orderBy(asc(bookingItems.createdAt)),
+        ]);
+        if (!booking) {
+            return { status: "not_found" };
+        }
+        const selectedItemIds = input.selections.map((selection) => selection.itemId);
+        const itemById = new Map(items.map((item) => [item.id, item]));
+        for (const selection of input.selections) {
+            if (!itemById.has(selection.itemId)) {
+                return { status: "invalid_selection" };
+            }
+        }
+        const requestedUnitIds = Array.from(new Set(input.selections
+            .map((selection) => selection.optionUnitId)
+            .filter((value) => Boolean(value))));
+        const requestedUnits = requestedUnitIds.length > 0
+            ? await db.select().from(optionUnitsRef).where(inArray(optionUnitsRef.id, requestedUnitIds))
+            : [];
+        const requestedUnitById = new Map(requestedUnits.map((unit) => [unit.id, unit]));
+        const pricingWarnings = [];
+        const pricedItems = [];
+        let resolvedCatalogId = input.catalogId ?? null;
+        let resolvedCurrency = booking.sellCurrency;
+        for (const selection of input.selections) {
+            const item = itemById.get(selection.itemId);
+            if (!item?.productId) {
+                return { status: "invalid_selection" };
+            }
+            const optionId = selection.optionId === undefined
+                ? (item.optionId ?? undefined)
+                : (selection.optionId ?? undefined);
+            const quantity = selection.quantity ?? item.quantity;
+            const pricingCategoryId = selection.pricingCategoryId === undefined
+                ? (item.pricingCategoryId ?? null)
+                : (selection.pricingCategoryId ?? null);
+            const selectedUnitId = selection.optionUnitId === undefined
+                ? (item.optionUnitId ?? null)
+                : (selection.optionUnitId ?? null);
+            const snapshot = await resolveSessionPricingSnapshot(db, item.productId, {
+                catalogId: input.catalogId,
+                optionId,
+            });
+            if (!snapshot) {
+                return { status: "pricing_unavailable" };
+            }
+            resolvedCatalogId = snapshot.catalog.id;
+            resolvedCurrency = snapshot.catalog.currencyCode ?? booking.sellCurrency;
+            const option = snapshot.options.find((candidate) => candidate.id === optionId) ??
+                snapshot.options[0] ??
+                null;
+            if (!option) {
+                return { status: "pricing_unavailable" };
+            }
+            const rule = snapshot.rules.find((candidate) => candidate.optionId === option.id && candidate.isDefault) ??
+                snapshot.rules.find((candidate) => candidate.optionId === option.id) ??
+                null;
+            if (!rule) {
+                return { status: "pricing_unavailable" };
+            }
+            const ruleUnitPrices = snapshot.unitPrices.filter((candidate) => candidate.optionPriceRuleId === rule.id);
+            const unitPriceCandidates = ruleUnitPrices.filter((candidate) => {
+                if (selectedUnitId && candidate.unitId !== selectedUnitId) {
+                    return false;
+                }
+                if (pricingCategoryId && candidate.pricingCategoryId !== pricingCategoryId) {
+                    return false;
+                }
+                if (candidate.minQuantity !== null && quantity < candidate.minQuantity) {
+                    return false;
+                }
+                if (candidate.maxQuantity !== null && quantity > candidate.maxQuantity) {
+                    return false;
+                }
+                return true;
+            });
+            const fallbackUnitPrice = !pricingCategoryId && !selectedUnitId
+                ? (ruleUnitPrices.find((candidate) => candidate.pricingCategoryId === null &&
+                    (candidate.minQuantity === null || quantity >= candidate.minQuantity) &&
+                    (candidate.maxQuantity === null || quantity <= candidate.maxQuantity)) ?? null)
+                : null;
+            const unitPrice = unitPriceCandidates[0] ?? fallbackUnitPrice;
+            if ((selectedUnitId || ruleUnitPrices.length > 0) &&
+                !unitPrice &&
+                rule.pricingMode !== "per_booking") {
+                return { status: "pricing_unavailable" };
+            }
+            const unit = selectedUnitId ? (requestedUnitById.get(selectedUnitId) ?? null) : null;
+            const unitSellAmountCents = unitPrice
+                ? resolveTierAmount(unitPrice.tiers, quantity, unitPrice.sellAmountCents)
+                : rule.baseSellAmountCents;
+            const pricingMode = unitPrice?.pricingMode ?? rule.pricingMode;
+            const totalSellAmountCents = computeLineTotal(pricingMode, unitSellAmountCents, quantity, rule.baseSellAmountCents);
+            const warnings = buildUnitWarnings(unit, quantity, booking.pax ?? null);
+            if (selectedUnitId && !unit) {
+                warnings.push("Selected room/unit metadata is not available in the current catalog.");
+            }
+            if (pricingMode === "on_request") {
+                warnings.push("Selected option requires manual pricing confirmation.");
+            }
+            pricingWarnings.push(...warnings);
+            pricedItems.push({
+                itemId: item.id,
+                title: item.title,
+                productId: item.productId ?? null,
+                optionId: option.id,
+                optionUnitId: selectedUnitId,
+                optionUnitName: unit?.name ?? unitPrice?.unitName ?? null,
+                optionUnitType: unit?.unitType ?? unitPrice?.unitType ?? null,
+                pricingCategoryId,
+                quantity,
+                pricingMode,
+                unitSellAmountCents,
+                totalSellAmountCents,
+                warnings,
+            });
+        }
+        const totalSellAmountCents = items.reduce((total, item) => {
+            const repriced = pricedItems.find((candidate) => candidate.itemId === item.id);
+            return total + (repriced?.totalSellAmountCents ?? item.totalSellAmountCents ?? 0);
+        }, 0);
+        let session = null;
+        if (input.applyToSession) {
+            const activeAllocations = selectedItemIds.length > 0
+                ? await db
+                    .select()
+                    .from(bookingAllocations)
+                    .where(and(eq(bookingAllocations.bookingId, bookingId), inArray(bookingAllocations.bookingItemId, selectedItemIds), or(eq(bookingAllocations.status, "held"), eq(bookingAllocations.status, "confirmed"))))
+                : [];
+            const activeAllocationsByItemId = new Map();
+            for (const allocation of activeAllocations) {
+                const existing = activeAllocationsByItemId.get(allocation.bookingItemId) ?? [];
+                existing.push(allocation);
+                activeAllocationsByItemId.set(allocation.bookingItemId, existing);
+            }
+            const quantityChangedWithActiveAllocation = pricedItems.some((pricedItem) => {
+                const item = itemById.get(pricedItem.itemId);
+                return Boolean(item &&
+                    item.quantity !== pricedItem.quantity &&
+                    (activeAllocationsByItemId.get(pricedItem.itemId)?.length ?? 0) > 0);
+            });
+            if (quantityChangedWithActiveAllocation) {
+                return { status: "quantity_change_requires_reallocation" };
+            }
+            await db.transaction(async (tx) => {
+                for (const pricedItem of pricedItems) {
+                    await tx
+                        .update(bookingItems)
+                        .set({
+                        optionId: pricedItem.optionId,
+                        optionUnitId: pricedItem.optionUnitId,
+                        pricingCategoryId: pricedItem.pricingCategoryId,
+                        quantity: pricedItem.quantity,
+                        sellCurrency: resolvedCurrency,
+                        unitSellAmountCents: pricedItem.unitSellAmountCents,
+                        totalSellAmountCents: pricedItem.totalSellAmountCents,
+                        updatedAt: new Date(),
+                    })
+                        .where(eq(bookingItems.id, pricedItem.itemId));
+                    await tx
+                        .update(bookingAllocations)
+                        .set({
+                        optionId: pricedItem.optionId,
+                        optionUnitId: pricedItem.optionUnitId,
+                        pricingCategoryId: pricedItem.pricingCategoryId,
+                        updatedAt: new Date(),
+                    })
+                        .where(and(eq(bookingAllocations.bookingId, bookingId), eq(bookingAllocations.bookingItemId, pricedItem.itemId), or(eq(bookingAllocations.status, "held"), eq(bookingAllocations.status, "confirmed"))));
+                }
+                await tx
+                    .update(bookings)
+                    .set({
+                    sellCurrency: resolvedCurrency,
+                    sellAmountCents: totalSellAmountCents,
+                    updatedAt: new Date(),
+                })
+                    .where(eq(bookings.id, bookingId));
+            });
+            session = await buildSessionSnapshot(db, bookingId);
+        }
+        return {
+            status: "ok",
+            pricing: {
+                sessionId: bookingId,
+                catalogId: resolvedCatalogId,
+                currencyCode: resolvedCurrency,
+                totalSellAmountCents,
+                items: pricedItems,
+                warnings: Array.from(new Set(pricingWarnings)),
+                appliedToSession: input.applyToSession,
+            },
+            session,
+        };
+    },
+    async confirmSession(db, bookingId, input, userId) {
+        const result = await bookingsService.confirmBooking(db, bookingId, input, userId);
+        if (result.status !== "ok") {
+            return result;
+        }
+        const session = await buildSessionSnapshot(db, bookingId);
+        return session ? { status: "ok", session } : { status: "not_found" };
+    },
+    async expireSession(db, bookingId, input, userId) {
+        const result = await bookingsService.expireBooking(db, bookingId, input, userId);
+        if (result.status !== "ok") {
+            return result;
+        }
+        const session = await buildSessionSnapshot(db, bookingId);
+        return session ? { status: "ok", session } : { status: "not_found" };
+    },
+    async getOverview(db, query) {
+        return buildOverviewSnapshot(db, query);
+    },
+    async getOverviewByLookup(db, query) {
+        return buildOverviewSnapshot(db, query);
+    },
+};