@voyant-travel/storefront 0.121.1 → 0.122.0

package/dist/index.d.ts

@@ -3,6 +3,8 @@ import type { HonoModule } from "@voyant-travel/hono/module";
 import { createStorefrontPublicRoutes } from "./routes-public.js";
 export type { GuestBookingGuardOptions, GuestBookingGuardRequest, GuestBookingLookupInput, } from "./guest-booking-guard.js";
 export { createGuestBookingGuard } from "./guest-booking-guard.js";
+export type { PaymentLinkBankTransferDetails, PaymentLinkRoutesOptions, PaymentLinkSessionInput, PaymentLinkTripComponent, PaymentLinkTripData, } from "./payment-link/routes.js";
+export { createPaymentLinkRoutes } from "./payment-link/routes.js";
 export type { StorefrontAdminRoutes } from "./routes-admin.js";
 export { createStorefrontAdminRoutes } from "./routes-admin.js";
 export type { StorefrontPublicRoutes } from "./routes-public.js";

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -2,6 +2,7 @@ import { BOOKING_BOOTSTRAP_INTENT_EVENT, createBookingBootstrapIntentHandler, }
 import { createStorefrontAdminRoutes } from "./routes-admin.js";
 import { createStorefrontPublicRoutes } from "./routes-public.js";
 export { createGuestBookingGuard } from "./guest-booking-guard.js";
+export { createPaymentLinkRoutes } from "./payment-link/routes.js";
 export { createStorefrontAdminRoutes } from "./routes-admin.js";
 export { createStorefrontPublicRoutes } from "./routes-public.js";
 export { createStorefrontService, mergeStorefrontSettingsPatch, resolveStorefrontSettings, } from "./service.js";

package/dist/payment-link/routes.d.ts

@@ -0,0 +1,97 @@
+import type { Context } from "hono";
+import { Hono } from "hono";
+/** Resolved bank-transfer beneficiary details from operator settings + env. */
+export interface PaymentLinkBankTransferDetails {
+    beneficiary: string;
+    iban: string;
+    bankName?: string | null;
+}
+/** A resolved trip component, with optional product enrichment. */
+export interface PaymentLinkTripComponent {
+    id: string;
+    kind: string;
+    entityModule: string | null;
+    entityId: string | null;
+    description: string | null;
+    status: string | null;
+    sequence: number | null;
+    componentTotalAmountCents: number | null;
+    componentCurrency: string | null;
+    metadata: Record<string, unknown> | null;
+}
+/** A resolved trip envelope + its visible components and product enrichment. */
+export interface PaymentLinkTripData {
+    envelope: {
+        id: string;
+        status: string | null;
+    };
+    /**
+     * Visible (non-removed, non-cancelled) components, already ordered by
+     * sequence then createdAt.
+     */
+    components: PaymentLinkTripComponent[];
+    /** product id → display name (from the inventory product record). */
+    productNameById: Map<string, string>;
+    /** product id → cover image (from inventory product media). */
+    mediaByProductId: Map<string, {
+        url: string;
+        altText: string | null;
+    }>;
+}
+/** The payment-session record fields the handlers read across routes. */
+export interface PaymentLinkSessionInput {
+    invoiceId: string | null;
+    amountCents: number;
+    currency: string;
+}
+/**
+ * Deployment-supplied access the payment-link handlers need. Everything here
+ * encapsulates a module storefront does not statically depend on, so the
+ * package stays free of inventory / trips / netopia / operator-settings
+ * imports.
+ */
+export interface PaymentLinkRoutesOptions {
+    /**
+     * Resolve the bank-transfer beneficiary details (operator settings merged
+     * with deploy-wide env defaults), or `null` when not configured.
+     */
+    resolveBankTransferDetails(c: Context): Promise<PaymentLinkBankTransferDetails | null>;
+    /** Resolve the public checkout base URL from the deployment bindings. */
+    resolvePublicCheckoutBaseUrl(c: Context): string | null;
+    /**
+     * Best-effort: ensure a fresh payment session can be started on the card
+     * provider, returning the redirect URL (or null). Returns `{ configured:
+     * false }` when no card processor is wired so the handler can 503. May throw
+     * — the handler maps the error to a 502.
+     */
+    startCardPayment(c: Context, session: {
+        id: string;
+        payerName: string | null;
+        payerEmail: string | null;
+        notes: string | null;
+        redirectUrl: string | null;
+    }): Promise<{
+        configured: true;
+        redirectUrl: string | null;
+    } | {
+        configured: false;
+    }>;
+    /**
+     * Resolve a trip envelope (+ reconcile a paid checkout) and its visible
+     * components with product-media enrichment, or `null` when the envelope is
+     * gone. Encapsulates the trips + inventory schema reads.
+     */
+    resolveTripData(c: Context, tripEnvelopeId: string, session: {
+        id: string;
+        status: string | null;
+        amountCents: number;
+        currency: string;
+        provider: string | null;
+    }): Promise<PaymentLinkTripData | null>;
+}
+/**
+ * Build the public payment-link routes. Paths are ABSOLUTE so the deployment
+ * can lazy-mount the returned app directly via `lazyRoutes.paths`.
+ */
+export declare function createPaymentLinkRoutes(options: PaymentLinkRoutesOptions): Hono;
+//# sourceMappingURL=routes.d.ts.map

package/dist/payment-link/routes.d.ts.map

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

package/dist/payment-link/routes.js

@@ -0,0 +1,473 @@
+/**
+ * Public payment-link + checkout-status routes — owned by
+ * `@voyant-travel/storefront`.
+ *
+ * agent-quality: file-size exception -- the public payment-link surface
+ * (config, retry, resolve, start-card, trip/booking summary, checkout-status)
+ * is one cohesive route family backed by the finance payment-session record;
+ * splitting it would scatter a single checkout contract.
+ *
+ *   GET  /v1/public/payment-link-config
+ *   POST /v1/public/payment-link/:sessionId/retry
+ *   GET  /v1/public/payment-link/resolve
+ *   POST /v1/public/payment-link/:sessionId/start-card
+ *   GET  /v1/public/payment-link/:sessionId/trip-summary
+ *   GET  /v1/public/payment-link/:sessionId/booking-summary
+ *   GET  /v1/public/bookings/:bookingId/checkout-status
+ *
+ * The routes are mounted at their ABSOLUTE public paths so the deployment can
+ * lazy-mount them via `lazyRoutes.paths`. All cross-module access that
+ * storefront does not already depend on (inventory product media, trip
+ * envelopes/components reconciliation, the card-payment provider, and the
+ * operator settings + checkout base URL) is INJECTED via `options` — the
+ * package never statically imports inventory / trips / the netopia plugin /
+ * the operator settings module.
+ *
+ * Storefront already depends acyclically on `@voyant-travel/bookings` and
+ * `@voyant-travel/finance`, so the booking / invoice / payment-session reads
+ * use those schemas directly.
+ */
+import { bookingItems, bookings } from "@voyant-travel/bookings/schema";
+import { financeService } from "@voyant-travel/finance";
+import { invoices, paymentSessions } from "@voyant-travel/finance/schema";
+import { and, asc, desc, eq, or } from "drizzle-orm";
+import { Hono } from "hono";
+const PUBLIC_PAYMENT_LINK_CONFIG_CACHE_CONTROL = "public, s-maxage=300, stale-while-revalidate=600";
+// ─────────────────────────────────────────────────────────────────
+// Local helpers
+// ─────────────────────────────────────────────────────────────────
+function cachePublicPaymentLinkConfig(c) {
+    c.header("Cache-Control", PUBLIC_PAYMENT_LINK_CONFIG_CACHE_CONTROL);
+}
+function requireRouteParam(c, name) {
+    const value = c.req.param(name);
+    return value ? value : c.json({ error: `${name} route param is required` }, 400);
+}
+function getDb(c) {
+    return c.get("db");
+}
+async function buildPublicBankTransferInstructions(c, options, bookingNumber, session) {
+    const db = getDb(c);
+    const details = await options.resolveBankTransferDetails(c);
+    if (!details)
+        return null;
+    const [invoice] = session.invoiceId
+        ? await db
+            .select({
+            invoiceNumber: invoices.invoiceNumber,
+            dueDate: invoices.dueDate,
+            balanceDueCents: invoices.balanceDueCents,
+            currency: invoices.currency,
+        })
+            .from(invoices)
+            .where(eq(invoices.id, session.invoiceId))
+            .limit(1)
+        : [];
+    return {
+        beneficiary: details.beneficiary,
+        iban: details.iban,
+        bankName: details.bankName ?? "-",
+        reference: `BOOK-${bookingNumber}`,
+        amountCents: invoice?.balanceDueCents ?? session.amountCents,
+        currency: invoice?.currency ?? session.currency,
+        dueAt: invoice?.dueDate ?? null,
+        proformaNumber: invoice?.invoiceNumber ?? null,
+    };
+}
+// ─────────────────────────────────────────────────────────────────
+// Routes
+// ─────────────────────────────────────────────────────────────────
+/**
+ * Build the public payment-link routes. Paths are ABSOLUTE so the deployment
+ * can lazy-mount the returned app directly via `lazyRoutes.paths`.
+ */
+export function createPaymentLinkRoutes(options) {
+    const hono = new Hono();
+    hono.get("/v1/public/payment-link-config", async (c) => {
+        const bankTransfer = await options.resolveBankTransferDetails(c);
+        cachePublicPaymentLinkConfig(c);
+        return c.json({
+            data: {
+                publicCheckoutBaseUrl: options.resolvePublicCheckoutBaseUrl(c),
+                bankTransfer,
+            },
+        });
+    });
+    hono.post("/v1/public/payment-link/:sessionId/retry", async (c) => {
+        const sessionId = requireRouteParam(c, "sessionId");
+        if (sessionId instanceof Response)
+            return sessionId;
+        const db = getDb(c);
+        const [original] = await db
+            .select()
+            .from(paymentSessions)
+            .where(eq(paymentSessions.id, sessionId))
+            .limit(1);
+        if (!original)
+            return c.json({ error: "Session not found" }, 404);
+        if (original.status === "paid" || original.status === "authorized") {
+            return c.json({ data: { sessionId: original.id, alreadyPaid: true } });
+        }
+        const dbCast = db;
+        const fresh = await financeService.createPaymentSession(dbCast, {
+            targetType: original.targetType,
+            targetId: original.targetId ?? undefined,
+            bookingId: original.bookingId ?? undefined,
+            invoiceId: original.invoiceId ?? undefined,
+            bookingPaymentScheduleId: original.bookingPaymentScheduleId ?? undefined,
+            bookingGuaranteeId: original.bookingGuaranteeId ?? undefined,
+            currency: original.currency,
+            amountCents: original.amountCents,
+            status: "pending",
+            provider: original.provider ?? undefined,
+            paymentMethod: original.paymentMethod ?? undefined,
+            payerEmail: original.payerEmail ?? undefined,
+            payerName: original.payerName ?? undefined,
+            notes: original.notes ?? undefined,
+        });
+        if (!fresh)
+            return c.json({ error: "Failed to create payment session" }, 500);
+        return c.json({ data: { sessionId: fresh.id } });
+    });
+    hono.get("/v1/public/payment-link/resolve", async (c) => {
+        const ref = c.req.query("ref");
+        if (!ref)
+            return c.json({ error: "ref query param is required" }, 400);
+        const db = getDb(c);
+        const [session] = await db
+            .select({ id: paymentSessions.id })
+            .from(paymentSessions)
+            .where(or(eq(paymentSessions.id, ref), eq(paymentSessions.clientReference, ref), eq(paymentSessions.externalReference, ref)))
+            .limit(1);
+        if (!session)
+            return c.json({ error: "Payment session not found" }, 404);
+        return c.json({ data: { sessionId: session.id } });
+    });
+    hono.post("/v1/public/payment-link/:sessionId/start-card", async (c) => {
+        const sessionId = requireRouteParam(c, "sessionId");
+        if (sessionId instanceof Response)
+            return sessionId;
+        const db = getDb(c);
+        const [session] = await db
+            .select()
+            .from(paymentSessions)
+            .where(eq(paymentSessions.id, sessionId))
+            .limit(1);
+        if (!session)
+            return c.json({ error: "Session not found" }, 404);
+        if (session.redirectUrl) {
+            return c.json({ data: { redirectUrl: session.redirectUrl } });
+        }
+        try {
+            const started = await options.startCardPayment(c, {
+                id: session.id,
+                payerName: session.payerName,
+                payerEmail: session.payerEmail,
+                notes: session.notes,
+                redirectUrl: session.redirectUrl,
+            });
+            if (!started.configured) {
+                return c.json({ error: "Card processor not configured" }, 503);
+            }
+            return c.json({ data: { redirectUrl: started.redirectUrl } });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "Failed to start card payment";
+            return c.json({ error: message }, 502);
+        }
+    });
+    hono.get("/v1/public/payment-link/:sessionId/trip-summary", async (c) => {
+        const sessionId = requireRouteParam(c, "sessionId");
+        if (sessionId instanceof Response)
+            return sessionId;
+        const db = getDb(c);
+        const [session] = await db
+            .select()
+            .from(paymentSessions)
+            .where(eq(paymentSessions.id, sessionId))
+            .limit(1);
+        if (!session)
+            return c.json({ error: "Session not found" }, 404);
+        const metadata = (session.metadata ?? {});
+        const tripEnvelopeId = typeof metadata.tripEnvelopeId === "string" ? metadata.tripEnvelopeId : null;
+        if (!tripEnvelopeId)
+            return c.json({ data: null });
+        const tripData = await options.resolveTripData(c, tripEnvelopeId, {
+            id: session.id,
+            status: session.status,
+            amountCents: session.amountCents,
+            currency: session.currency,
+            provider: session.provider,
+        });
+        if (!tripData)
+            return c.json({ data: null });
+        const { envelope, components: visibleComponents, productNameById, mediaByProductId } = tripData;
+        const allocationsRaw = Array.isArray(metadata.componentAllocations)
+            ? metadata.componentAllocations
+            : [];
+        const allocationByComponentId = new Map();
+        for (const allocation of allocationsRaw) {
+            if (allocation.componentId)
+                allocationByComponentId.set(allocation.componentId, allocation);
+        }
+        const trip = {
+            envelopeId: envelope.id,
+            currency: session.currency,
+            totalAmountCents: session.amountCents,
+            components: visibleComponents.map((component) => {
+                const metadataRecord = (component.metadata ?? {});
+                const catalogItem = (metadataRecord.catalogItem ?? null);
+                const flightDraft = (metadataRecord.flightDraft ?? null);
+                const schedule = resolvePublicTripComponentSchedule(metadataRecord);
+                const fallbackName = catalogItem?.name ??
+                    (component.entityId ? productNameById.get(component.entityId) : null) ??
+                    (flightDraft?.origin && flightDraft?.destination
+                        ? `${flightDraft.origin} -> ${flightDraft.destination}`
+                        : null) ??
+                    component.description ??
+                    component.kind.replaceAll("_", " ");
+                const thumbnail = component.entityId
+                    ? (mediaByProductId.get(component.entityId) ?? null)
+                    : null;
+                const catalogThumbnailUrl = publicStringValue(readPublicRecord(metadataRecord.catalogItem)?.thumbnailUrl);
+                const allocation = allocationByComponentId.get(component.id);
+                return {
+                    id: component.id,
+                    kind: component.kind,
+                    entityModule: component.entityModule,
+                    title: fallbackName,
+                    thumbnailUrl: thumbnail?.url ?? catalogThumbnailUrl ?? null,
+                    thumbnailAlt: thumbnail?.altText ?? null,
+                    scheduledStartsAt: schedule.start,
+                    scheduledEndsAt: schedule.end,
+                    sourceAmountCents: allocation?.sourceAmountCents ?? component.componentTotalAmountCents ?? null,
+                    sourceCurrency: allocation?.sourceCurrency ?? component.componentCurrency ?? session.currency,
+                    targetAmountCents: allocation?.targetAmountCents ?? component.componentTotalAmountCents ?? null,
+                    targetCurrency: allocation?.targetCurrency ?? session.currency,
+                    fx: allocation?.fx ?? null,
+                };
+            }),
+        };
+        return c.json({ data: trip });
+    });
+    hono.get("/v1/public/payment-link/:sessionId/booking-summary", async (c) => {
+        const sessionId = requireRouteParam(c, "sessionId");
+        if (sessionId instanceof Response)
+            return sessionId;
+        const db = getDb(c);
+        const [session] = await db
+            .select({
+            id: paymentSessions.id,
+            bookingId: paymentSessions.bookingId,
+            amountCents: paymentSessions.amountCents,
+            currency: paymentSessions.currency,
+            metadata: paymentSessions.metadata,
+        })
+            .from(paymentSessions)
+            .where(eq(paymentSessions.id, sessionId))
+            .limit(1);
+        if (!session)
+            return c.json({ error: "Session not found" }, 404);
+        const metadata = (session.metadata ?? {});
+        if (typeof metadata.tripEnvelopeId === "string" && metadata.tripEnvelopeId.length > 0) {
+            return c.json({ data: null });
+        }
+        if (!session.bookingId)
+            return c.json({ data: null });
+        const [booking] = await db
+            .select({
+            id: bookings.id,
+            bookingNumber: bookings.bookingNumber,
+            status: bookings.status,
+            sellCurrency: bookings.sellCurrency,
+            sellAmountCents: bookings.sellAmountCents,
+            pax: bookings.pax,
+            startDate: bookings.startDate,
+            endDate: bookings.endDate,
+        })
+            .from(bookings)
+            .where(eq(bookings.id, session.bookingId))
+            .limit(1);
+        if (!booking)
+            return c.json({ data: null });
+        const items = await db
+            .select({
+            id: bookingItems.id,
+            title: bookingItems.title,
+            itemType: bookingItems.itemType,
+            quantity: bookingItems.quantity,
+            totalSellAmountCents: bookingItems.totalSellAmountCents,
+            sellCurrency: bookingItems.sellCurrency,
+            startsAt: bookingItems.startsAt,
+            endsAt: bookingItems.endsAt,
+            serviceDate: bookingItems.serviceDate,
+            productNameSnapshot: bookingItems.productNameSnapshot,
+            optionNameSnapshot: bookingItems.optionNameSnapshot,
+            unitNameSnapshot: bookingItems.unitNameSnapshot,
+            departureLabelSnapshot: bookingItems.departureLabelSnapshot,
+        })
+            .from(bookingItems)
+            .where(eq(bookingItems.bookingId, booking.id))
+            .orderBy(asc(bookingItems.createdAt));
+        return c.json({
+            data: {
+                bookingId: booking.id,
+                bookingNumber: booking.bookingNumber,
+                status: booking.status,
+                pax: booking.pax,
+                startDate: booking.startDate,
+                endDate: booking.endDate,
+                chargeAmountCents: session.amountCents,
+                currency: session.currency ?? booking.sellCurrency,
+                bookingTotalAmountCents: booking.sellAmountCents,
+                bookingCurrency: booking.sellCurrency,
+                items: items.map((item) => ({
+                    id: item.id,
+                    productName: item.productNameSnapshot ?? item.title,
+                    optionName: item.optionNameSnapshot,
+                    unitName: item.unitNameSnapshot,
+                    departureLabel: item.departureLabelSnapshot,
+                    startsAt: item.startsAt instanceof Date ? item.startsAt.toISOString() : item.startsAt,
+                    endsAt: item.endsAt instanceof Date ? item.endsAt.toISOString() : item.endsAt,
+                    serviceDate: item.serviceDate,
+                    quantity: item.quantity,
+                    itemType: item.itemType,
+                    amountCents: item.totalSellAmountCents,
+                    currency: item.sellCurrency,
+                })),
+            },
+        });
+    });
+    hono.get("/v1/public/bookings/:bookingId/checkout-status", async (c) => {
+        const bookingId = requireRouteParam(c, "bookingId");
+        if (bookingId instanceof Response)
+            return bookingId;
+        const ref = c.req.query("session") ?? c.req.query("orderId") ?? c.req.query("ref") ?? null;
+        const db = getDb(c);
+        const [booking] = await db
+            .select({
+            id: bookings.id,
+            bookingNumber: bookings.bookingNumber,
+            status: bookings.status,
+            updatedAt: bookings.updatedAt,
+        })
+            .from(bookings)
+            .where(eq(bookings.id, bookingId))
+            .limit(1);
+        if (!booking)
+            return c.json({ error: "Booking not found" }, 404);
+        const sessionRefFilter = ref
+            ? or(eq(paymentSessions.id, ref), eq(paymentSessions.clientReference, ref), eq(paymentSessions.externalReference, ref), eq(paymentSessions.providerSessionId, ref), eq(paymentSessions.providerPaymentId, ref))
+            : undefined;
+        const sessionWhere = sessionRefFilter
+            ? and(eq(paymentSessions.bookingId, bookingId), sessionRefFilter)
+            : eq(paymentSessions.bookingId, bookingId);
+        let sessions = await db
+            .select({
+            id: paymentSessions.id,
+            status: paymentSessions.status,
+            amountCents: paymentSessions.amountCents,
+            currency: paymentSessions.currency,
+            invoiceId: paymentSessions.invoiceId,
+            paymentMethod: paymentSessions.paymentMethod,
+            completedAt: paymentSessions.completedAt,
+            failedAt: paymentSessions.failedAt,
+            updatedAt: paymentSessions.updatedAt,
+        })
+            .from(paymentSessions)
+            .where(sessionWhere)
+            .orderBy(desc(paymentSessions.createdAt))
+            .limit(5);
+        if (sessions.length === 0 && ref) {
+            sessions = await db
+                .select({
+                id: paymentSessions.id,
+                status: paymentSessions.status,
+                amountCents: paymentSessions.amountCents,
+                currency: paymentSessions.currency,
+                invoiceId: paymentSessions.invoiceId,
+                paymentMethod: paymentSessions.paymentMethod,
+                completedAt: paymentSessions.completedAt,
+                failedAt: paymentSessions.failedAt,
+                updatedAt: paymentSessions.updatedAt,
+            })
+                .from(paymentSessions)
+                .where(eq(paymentSessions.bookingId, bookingId))
+                .orderBy(desc(paymentSessions.createdAt))
+                .limit(5);
+        }
+        const paidSession = sessions.find((session) => session.status === "paid" || session.status === "authorized");
+        const latestSession = paidSession ?? sessions[0] ?? null;
+        const isBankTransferSession = latestSession?.paymentMethod === "bank_transfer" ||
+            (booking.status === "awaiting_payment" && Boolean(latestSession?.invoiceId));
+        const bankTransferInstructions = isBankTransferSession && latestSession
+            ? await buildPublicBankTransferInstructions(c, options, booking.bookingNumber, latestSession)
+            : null;
+        const failedStatuses = new Set(["failed", "cancelled", "expired"]);
+        const paymentStatus = booking.status === "confirmed" || paidSession
+            ? "paid"
+            : sessions.length > 0 && sessions.every((session) => failedStatuses.has(session.status))
+                ? "failed"
+                : "pending";
+        return c.json({
+            data: {
+                bookingId: booking.id,
+                bookingNumber: booking.bookingNumber,
+                bookingStatus: booking.status,
+                paymentStatus,
+                session: latestSession,
+                bankTransferInstructions,
+                updatedAt: (latestSession?.updatedAt ?? booking.updatedAt)?.toISOString?.() ?? null,
+            },
+        });
+    });
+    return hono;
+}
+// ─────────────────────────────────────────────────────────────────
+// Pure schedule resolution helpers
+// ─────────────────────────────────────────────────────────────────
+function resolvePublicTripComponentSchedule(metadata) {
+    const scheduledStart = publicStringValue(metadata.scheduledStartsAt);
+    const scheduledEnd = publicStringValue(metadata.scheduledEndsAt);
+    if (scheduledStart)
+        return { start: scheduledStart, end: scheduledEnd };
+    const flightDraft = readPublicRecord(metadata.flightDraft);
+    if (flightDraft) {
+        const selectedOffer = readPublicRecord(flightDraft.selectedOffer);
+        const itineraries = Array.isArray(selectedOffer?.itineraries) ? selectedOffer.itineraries : [];
+        const firstItinerary = readPublicRecord(itineraries[0]);
+        const lastItinerary = readPublicRecord(itineraries[itineraries.length - 1]);
+        const firstSegments = Array.isArray(firstItinerary?.segments) ? firstItinerary.segments : [];
+        const lastSegments = Array.isArray(lastItinerary?.segments) ? lastItinerary.segments : [];
+        const firstSegment = readPublicRecord(firstSegments[0]);
+        const lastSegment = readPublicRecord(lastSegments[lastSegments.length - 1]);
+        const departure = readPublicRecord(firstSegment?.departure);
+        const arrival = readPublicRecord(lastSegment?.arrival);
+        return {
+            start: publicStringValue(departure?.at) ?? publicStringValue(flightDraft.departDate),
+            end: publicStringValue(arrival?.at) ?? publicStringValue(flightDraft.returnDate),
+        };
+    }
+    const bookingDraft = readPublicRecord(metadata.bookingDraftV1);
+    const configure = readPublicRecord(bookingDraft?.configure);
+    const dateRange = readPublicRecord(configure?.dateRange);
+    const departureDate = publicStringValue(configure?.departureDate);
+    const checkIn = publicStringValue(dateRange?.checkIn);
+    const checkOut = publicStringValue(dateRange?.checkOut);
+    if (departureDate || checkIn) {
+        return { start: departureDate ?? checkIn, end: checkOut };
+    }
+    const cruiseDraft = readPublicRecord(metadata.cruiseDraft);
+    const embarkationDate = publicStringValue(cruiseDraft?.embarkationDate);
+    if (embarkationDate)
+        return { start: embarkationDate, end: null };
+    return { start: null, end: null };
+}
+function readPublicRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function publicStringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}

package/dist/routes-public.d.ts

@@ -126,7 +126,7 @@ export declare function createStorefrontPublicRoutes(options?: StorefrontService
                 error: string;
             };
             outputFormat: "json";
-            status: 429 | 400 | 403;
+            status: 400 | 403 | 429;
         } | {
             input: {};
             output: {
@@ -134,7 +134,7 @@ export declare function createStorefrontPublicRoutes(options?: StorefrontService
                     id: string;
                     personId: string;
                     kind: "notify" | "wishlist" | "inquiry" | "request_offer" | "referral";
-                    source: "admin" | "phone" | "booking" | "form" | "website" | "abandoned_cart";
+                    source: "admin" | "form" | "phone" | "booking" | "website" | "abandoned_cart";
                     status: "expired" | "new" | "contacted" | "qualified" | "converted" | "lost";
                     duplicate: boolean;
                 };
@@ -151,7 +151,7 @@ export declare function createStorefrontPublicRoutes(options?: StorefrontService
                 error: string;
             };
             outputFormat: "json";
-            status: 429 | 400 | 403;
+            status: 400 | 403 | 429;
         } | {
             input: {};
             output: {
@@ -159,7 +159,7 @@ export declare function createStorefrontPublicRoutes(options?: StorefrontService
                     id: string;
                     personId: string;
                     kind: "notify" | "wishlist" | "inquiry" | "request_offer" | "referral";
-                    source: "admin" | "phone" | "booking" | "form" | "website" | "abandoned_cart";
+                    source: "admin" | "form" | "phone" | "booking" | "website" | "abandoned_cart";
                     status: "expired" | "new" | "contacted" | "qualified" | "converted" | "lost";
                     duplicate: boolean;
                     doubleOptIn: "requested" | "not_configured";
@@ -1278,6 +1278,17 @@ export declare function createStorefrontPublicRoutes(options?: StorefrontService
 } & {
     "/offers/:slug": {
         $get: {
+            input: {
+                param: {
+                    slug: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
             input: {
                 param: {
                     slug: string;
@@ -1306,17 +1317,6 @@ export declare function createStorefrontPublicRoutes(options?: StorefrontService
             };
             outputFormat: "json";
             status: import("hono/utils/http-status").ContentfulStatusCode;
-        } | {
-            input: {
-                param: {
-                    slug: string;
-                };
-            };
-            output: {
-                error: string;
-            };
-            outputFormat: "json";
-            status: 404;
         };
     };
 } & {

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

@@ -1 +1 @@
-{"version":3,"file":"routes-public.d.ts","sourceRoot":"","sources":["../src/routes-public.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"routes-public.d.ts","sourceRoot":"","sources":["../src/routes-public.ts"],"names":[],"mappings":"AAOA,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,eAAe,EACrB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAQnC,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,cAAc,CAAA;AAuCrB,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAO1F;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CAAC,CAAC,EAC3C,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EACf,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACxB,OAAO,CAAC,CAAC,CAAC,CAmBZ;AAED,KAAK,GAAG,GAAG;IACT,QAAQ,EAAE,cAAc,CAAA;IACxB,SAAS,EAAE;QACT,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,GAAG,eAAe,CAAA;CACpB,CAAA;AA+CD,wBAAgB,4BAA4B,CAAC,OAAO,CAAC,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA2W9E;AAED,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAAC,OAAO,4BAA4B,CAAC,CAAA"}

package/dist/routes-public.js

@@ -15,6 +15,9 @@ import { storefrontTransportEligibilityInputSchema } from "./validation-transpor
  * to success responses only.
  */
 const PUBLIC_CACHE_CONTROL = "public, s-maxage=60, stale-while-revalidate=300";
+function setPublicCacheHeaders(c) {
+    c.header("Cache-Control", PUBLIC_CACHE_CONTROL);
+}
 /**
  * KV read-model TTL for the departure list (RFC voyant#1687 Phase 2.2).
  * Departure availability shifts with every booking, so unlike the
@@ -144,14 +147,14 @@ export function createStorefrontPublicRoutes(options) {
         const departure = await storefrontService.getDeparture(c.get("db"), c.req.param("departureId"));
         if (!departure)
             return c.json({ error: "Storefront departure not found" }, 404);
-        c.header("Cache-Control", PUBLIC_CACHE_CONTROL);
+        setPublicCacheHeaders(c);
         return c.json({ data: departure });
     })
         .get("/products/:productId/departures", async (c) => {
         const productId = c.req.param("productId");
         const query = await parseQuery(c, storefrontDepartureListQuerySchema);
         const result = await readThroughDepartures(c, departuresDocKey(productId, query), () => storefrontService.listProductDepartures(c.get("db"), productId, query));
-        c.header("Cache-Control", PUBLIC_CACHE_CONTROL);
+        setPublicCacheHeaders(c);
         return c.json(result);
     })
         .post("/departures/:departureId/price", async (c) => {
@@ -301,14 +304,14 @@ export function createStorefrontPublicRoutes(options) {
     })
         .get("/products/:productId/extensions", async (c) => {
         const query = await parseQuery(c, storefrontProductExtensionsQuerySchema);
-        return c.json({
-            data: await storefrontService.getProductExtensions(c.get("db"), c.req.param("productId"), query.optionId),
-        });
+        const extensions = await storefrontService.getProductExtensions(c.get("db"), c.req.param("productId"), query.optionId);
+        setPublicCacheHeaders(c);
+        return c.json({ data: extensions });
     })
         .get("/products/:productId/availability", async (c) => {
-        return c.json({
-            data: await storefrontService.getProductAvailabilitySummary(c.get("db"), c.req.param("productId"), await parseQuery(c, storefrontProductAvailabilitySummaryQuerySchema)),
-        });
+        const availability = await storefrontService.getProductAvailabilitySummary(c.get("db"), c.req.param("productId"), await parseQuery(c, storefrontProductAvailabilitySummaryQuerySchema));
+        setPublicCacheHeaders(c);
+        return c.json({ data: availability });
     })
         .get("/products/:productId/departures/:departureId/itinerary", async (c) => {
         const itinerary = await storefrontService.getDepartureItinerary(c.get("db"), {
@@ -317,19 +320,19 @@ export function createStorefrontPublicRoutes(options) {
         });
         if (!itinerary)
             return c.json({ error: "Storefront itinerary not found" }, 404);
-        c.header("Cache-Control", PUBLIC_CACHE_CONTROL);
+        setPublicCacheHeaders(c);
         return c.json({ data: itinerary });
     })
         .get("/products/:productId/offers", async (c) => {
         const query = await parseQuery(c, storefrontPromotionalOfferListQuerySchema);
-        return c.json({
-            data: await storefrontService.listApplicableOffers({
-                productId: c.req.param("productId"),
-                departureId: query.departureId,
-                locale: query.locale,
-                context: getRequestContext(c),
-            }),
+        const offers = await storefrontService.listApplicableOffers({
+            productId: c.req.param("productId"),
+            departureId: query.departureId,
+            locale: query.locale,
+            context: getRequestContext(c),
         });
+        setPublicCacheHeaders(c);
+        return c.json({ data: offers });
     })
         .get("/offers/:slug", async (c) => {
         const query = await parseQuery(c, storefrontPromotionalOfferListQuerySchema);
@@ -338,7 +341,10 @@ export function createStorefrontPublicRoutes(options) {
             locale: query.locale,
             context: getRequestContext(c),
         });
-        return offer ? c.json({ data: offer }) : c.json({ error: "Storefront offer not found" }, 404);
+        if (!offer)
+            return c.json({ error: "Storefront offer not found" }, 404);
+        setPublicCacheHeaders(c);
+        return c.json({ data: offer });
     })
         .post("/offers/:slug/apply", async (c) => {
         const result = await storefrontService.applyOffer({

package/dist/service.d.ts

@@ -1041,7 +1041,7 @@ export declare function createStorefrontService(options?: StorefrontServiceOptio
         id: string;
         personId: string;
         kind: "notify" | "wishlist" | "inquiry" | "request_offer" | "referral";
-        source: "admin" | "phone" | "booking" | "form" | "website" | "abandoned_cart";
+        source: "admin" | "form" | "phone" | "booking" | "website" | "abandoned_cart";
         status: "expired" | "new" | "contacted" | "qualified" | "converted" | "lost";
         duplicate: boolean;
     }>;
@@ -1052,7 +1052,7 @@ export declare function createStorefrontService(options?: StorefrontServiceOptio
         id: string;
         personId: string;
         kind: "notify" | "wishlist" | "inquiry" | "request_offer" | "referral";
-        source: "admin" | "phone" | "booking" | "form" | "website" | "abandoned_cart";
+        source: "admin" | "form" | "phone" | "booking" | "website" | "abandoned_cart";
         status: "expired" | "new" | "contacted" | "qualified" | "converted" | "lost";
         duplicate: boolean;
         doubleOptIn: "requested" | "not_configured";

package/dist/validation/intake.d.ts

@@ -23,9 +23,9 @@ export declare const storefrontLeadIntakeInputSchema: z.ZodObject<{
     }>>;
     source: z.ZodDefault<z.ZodEnum<{
         admin: "admin";
+        form: "form";
         phone: "phone";
         booking: "booking";
-        form: "form";
         website: "website";
         abandoned_cart: "abandoned_cart";
     }>>;
@@ -59,9 +59,9 @@ export declare const storefrontNewsletterSubscribeInputSchema: z.ZodObject<{
     lastName: z.ZodOptional<z.ZodString>;
     source: z.ZodDefault<z.ZodEnum<{
         admin: "admin";
+        form: "form";
         phone: "phone";
         booking: "booking";
-        form: "form";
         website: "website";
         abandoned_cart: "abandoned_cart";
     }>>;
@@ -90,9 +90,9 @@ export declare const storefrontIntakeResponseSchema: z.ZodObject<{
     }>;
     source: z.ZodEnum<{
         admin: "admin";
+        form: "form";
         phone: "phone";
         booking: "booking";
-        form: "form";
         website: "website";
         abandoned_cart: "abandoned_cart";
     }>;
@@ -118,9 +118,9 @@ export declare const storefrontNewsletterSubscribeResponseSchema: z.ZodObject<{
     }>;
     source: z.ZodEnum<{
         admin: "admin";
+        form: "form";
         phone: "phone";
         booking: "booking";
-        form: "form";
         website: "website";
         abandoned_cart: "abandoned_cart";
     }>;

package/dist/verification/routes-public.d.ts

@@ -46,7 +46,7 @@ export declare function createStorefrontVerificationPublicRoutes(options?: Store
                 error: string;
             };
             outputFormat: "json";
-            status: 404 | 400 | 409 | 410 | 501;
+            status: 400 | 404 | 409 | 410 | 501;
         } | {
             input: {};
             output: {
@@ -95,7 +95,7 @@ export declare function createStorefrontVerificationPublicRoutes(options?: Store
                 error: string;
             };
             outputFormat: "json";
-            status: 404 | 400 | 409 | 410 | 501;
+            status: 400 | 404 | 409 | 410 | 501;
         } | {
             input: {};
             output: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voyant-travel/storefront",
-  "version": "0.121.1",
+  "version": "0.122.0",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
@@ -34,6 +34,11 @@
       "import": "./dist/customer-portal/routes.js",
       "default": "./dist/customer-portal/routes.js"
     },
+    "./payment-link": {
+      "types": "./dist/payment-link/routes.d.ts",
+      "import": "./dist/payment-link/routes.js",
+      "default": "./dist/payment-link/routes.js"
+    },
     "./public-routes": {
       "types": "./dist/routes-public.d.ts",
       "import": "./dist/routes-public.js",
@@ -90,19 +95,19 @@
     "drizzle-orm": "^0.45.2",
     "hono": "^4.12.10",
     "zod": "^4.3.6",
-    "@voyant-travel/bookings": "^0.120.1",
-    "@voyant-travel/commerce": "^0.2.2",
-    "@voyant-travel/db": "^0.108.1",
-    "@voyant-travel/finance": "^0.120.1",
     "@voyant-travel/core": "^0.109.0",
-    "@voyant-travel/hono": "^0.110.2",
+    "@voyant-travel/bookings": "^0.121.0",
+    "@voyant-travel/db": "^0.108.1",
+    "@voyant-travel/commerce": "^0.3.0",
+    "@voyant-travel/finance": "^0.121.0",
+    "@voyant-travel/hono": "^0.111.0",
     "@voyant-travel/utils": "^0.105.2",
     "@voyant-travel/relationships-contracts": "^0.107.0"
   },
   "peerDependencies": {
-    "@voyant-travel/identity": "^0.120.1",
-    "@voyant-travel/legal": "^0.120.1",
-    "@voyant-travel/relationships": "^0.119.3"
+    "@voyant-travel/legal": "^0.121.0",
+    "@voyant-travel/relationships": "^0.119.4",
+    "@voyant-travel/identity": "^0.121.0"
   },
   "peerDependenciesMeta": {
     "@voyant-travel/identity": {
@@ -118,12 +123,12 @@
   "devDependencies": {
     "typescript": "^6.0.2",
     "vitest": "^4.1.2",
-    "@voyant-travel/identity": "^0.120.1",
-    "@voyant-travel/inventory": "^0.2.0",
-    "@voyant-travel/legal": "^0.120.1",
-    "@voyant-travel/operations": "^0.1.0",
-    "@voyant-travel/relationships": "^0.119.3",
-    "@voyant-travel/voyant-typescript-config": "^0.1.0"
+    "@voyant-travel/identity": "^0.121.0",
+    "@voyant-travel/operations": "^0.1.1",
+    "@voyant-travel/legal": "^0.121.0",
+    "@voyant-travel/voyant-typescript-config": "^0.1.0",
+    "@voyant-travel/relationships": "^0.119.4",
+    "@voyant-travel/inventory": "^0.3.0"
   },
   "files": [
     "dist"