@voyant-travel/storefront-sdk 0.120.1

package/dist/client.js

@@ -0,0 +1,98 @@
+import { parseStorefrontApiErrorEnvelope } from "./errors.js";
+export const defaultStorefrontFetcher = (url, init) => fetch(url, { credentials: "include", ...init });
+export class VoyantStorefrontApiError extends Error {
+    status;
+    body;
+    normalizedError;
+    constructor(message, status, body, normalizedError = parseStorefrontApiErrorEnvelope(body)) {
+        super(message);
+        this.name = "VoyantStorefrontApiError";
+        this.status = status;
+        this.body = body;
+        this.normalizedError = normalizedError;
+    }
+}
+export function withStorefrontQueryParams(path, query) {
+    if (!query) {
+        return path;
+    }
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                params.append(key, String(item));
+            }
+            continue;
+        }
+        params.set(key, String(value));
+    }
+    const serialized = params.toString();
+    return serialized ? `${path}?${serialized}` : path;
+}
+export async function storefrontFetchWithValidation(path, schema, options, init) {
+    const url = joinUrl(options.baseUrl, path);
+    const headers = new Headers(options.headers);
+    for (const [key, value] of new Headers(init?.headers)) {
+        headers.set(key, value);
+    }
+    if (init?.body !== undefined && !headers.has("Content-Type")) {
+        headers.set("Content-Type", "application/json");
+    }
+    const response = await options.fetcher(url, { ...init, headers });
+    if (!response.ok) {
+        const body = await safeJson(response);
+        throw new VoyantStorefrontApiError(extractErrorMessage(response.status, response.statusText, body), response.status, body);
+    }
+    if (response.status === 204) {
+        return schema.parse(undefined);
+    }
+    const body = await safeJson(response);
+    const parsed = schema.safeParse(body);
+    if (!parsed.success) {
+        throw new VoyantStorefrontApiError(`Voyant storefront response failed validation: ${parsed.error.message}`, response.status, body);
+    }
+    return parsed.data;
+}
+export function requestHeaders(options) {
+    if (!options?.headers && !options?.idempotencyKey) {
+        return undefined;
+    }
+    const headers = new Headers(options.headers);
+    if (options.idempotencyKey) {
+        headers.set("Idempotency-Key", options.idempotencyKey);
+    }
+    return headers;
+}
+function extractErrorMessage(status, statusText, body) {
+    const normalizedError = parseStorefrontApiErrorEnvelope(body);
+    if (normalizedError)
+        return normalizedError.message;
+    if (typeof body === "object" && body !== null && "error" in body) {
+        const err = body.error;
+        if (typeof err === "string")
+            return err;
+        if (typeof err === "object" && err !== null && "message" in err) {
+            return String(err.message);
+        }
+    }
+    return `Voyant storefront API error: ${status} ${statusText}`;
+}
+async function safeJson(response) {
+    const text = await response.text();
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function joinUrl(baseUrl, path) {
+    const trimmedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    const trimmedPath = path.startsWith("/") ? path : `/${path}`;
+    return `${trimmedBase}${trimmedPath}`;
+}

package/dist/engine-state.d.ts

@@ -0,0 +1,21 @@
+import type { PublicBookingSessionRecord } from "./schemas.js";
+export declare const bookingEngineStates: readonly ["draft", "reserved", "billing_completed", "travelers_completed", "terms_accepted", "ready_for_payment", "payment_started", "payment_pending", "confirmed", "completed", "expired", "cancelled"];
+export type BookingEngineState = (typeof bookingEngineStates)[number];
+export declare const bookingEngineActions: readonly ["create_session", "reserve", "update_billing", "update_travelers", "reprice", "accept_terms", "start_payment", "poll_payment", "confirm", "expire", "clear_session"];
+export type BookingEngineAction = (typeof bookingEngineActions)[number];
+export interface BookingEngineSnapshot {
+    sessionId: string;
+    bookingNumber: string;
+    state: BookingEngineState;
+    bookingStatus: PublicBookingSessionRecord["status"];
+    currentStep: string | null;
+    completedSteps: string[];
+    holdExpiresAt: string | null;
+    readyForConfirmation: boolean;
+    allowedActions: BookingEngineAction[];
+}
+export declare function deriveBookingEngineState(session: PublicBookingSessionRecord): BookingEngineState;
+export declare function getAllowedBookingEngineActions(state: BookingEngineState): BookingEngineAction[];
+export declare function canRunBookingEngineAction(state: BookingEngineState, action: BookingEngineAction): boolean;
+export declare function createBookingEngineSnapshot(session: PublicBookingSessionRecord): BookingEngineSnapshot;
+//# sourceMappingURL=engine-state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engine-state.d.ts","sourceRoot":"","sources":["../src/engine-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAA;AAE9D,eAAO,MAAM,mBAAmB,2MAatB,CAAA;AAEV,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAA;AAErE,eAAO,MAAM,oBAAoB,gLAYvB,CAAA;AAEV,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEvE,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,kBAAkB,CAAA;IACzB,aAAa,EAAE,0BAA0B,CAAC,QAAQ,CAAC,CAAA;IACnD,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,oBAAoB,EAAE,OAAO,CAAA;IAC7B,cAAc,EAAE,mBAAmB,EAAE,CAAA;CACtC;AAWD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,0BAA0B,GAAG,kBAAkB,CAmChG;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,kBAAkB,GAAG,mBAAmB,EAAE,CAoC/F;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,kBAAkB,EACzB,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAET;AAED,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,0BAA0B,GAClC,qBAAqB,CAavB"}

package/dist/engine-state.js

@@ -0,0 +1,124 @@
+export const bookingEngineStates = [
+    "draft",
+    "reserved",
+    "billing_completed",
+    "travelers_completed",
+    "terms_accepted",
+    "ready_for_payment",
+    "payment_started",
+    "payment_pending",
+    "confirmed",
+    "completed",
+    "expired",
+    "cancelled",
+];
+export const bookingEngineActions = [
+    "create_session",
+    "reserve",
+    "update_billing",
+    "update_travelers",
+    "reprice",
+    "accept_terms",
+    "start_payment",
+    "poll_payment",
+    "confirm",
+    "expire",
+    "clear_session",
+];
+const completedStateByStep = [
+    ["payment", "payment_started"],
+    ["terms", "terms_accepted"],
+    ["contract", "terms_accepted"],
+    ["travelers", "travelers_completed"],
+    ["passengers", "travelers_completed"],
+    ["billing", "billing_completed"],
+];
+export function deriveBookingEngineState(session) {
+    switch (session.status) {
+        case "cancelled":
+            return "cancelled";
+        case "completed":
+            return "completed";
+        case "expired":
+            return "expired";
+        case "confirmed":
+        case "in_progress":
+            return "confirmed";
+        case "awaiting_payment":
+            return "payment_pending";
+        case "on_hold":
+            break;
+        case "draft":
+            return "draft";
+    }
+    const completedSteps = new Set(session.state?.completedSteps ?? []);
+    if (session.checklist.readyForConfirmation && completedSteps.has("payment")) {
+        return "payment_started";
+    }
+    if (session.checklist.readyForConfirmation && hasTermsAccepted(completedSteps)) {
+        return "ready_for_payment";
+    }
+    for (const [step, state] of completedStateByStep) {
+        if (completedSteps.has(step)) {
+            return state;
+        }
+    }
+    return "reserved";
+}
+export function getAllowedBookingEngineActions(state) {
+    switch (state) {
+        case "draft":
+            return ["create_session", "reserve", "clear_session"];
+        case "reserved":
+        case "billing_completed":
+        case "travelers_completed":
+            return [
+                "update_billing",
+                "update_travelers",
+                "reprice",
+                "accept_terms",
+                "expire",
+                "clear_session",
+            ];
+        case "terms_accepted":
+        case "ready_for_payment":
+            return [
+                "update_billing",
+                "update_travelers",
+                "reprice",
+                "start_payment",
+                "confirm",
+                "expire",
+                "clear_session",
+            ];
+        case "payment_started":
+        case "payment_pending":
+            return ["poll_payment", "confirm", "clear_session"];
+        case "confirmed":
+        case "completed":
+            return ["clear_session"];
+        case "expired":
+        case "cancelled":
+            return ["clear_session"];
+    }
+}
+export function canRunBookingEngineAction(state, action) {
+    return getAllowedBookingEngineActions(state).includes(action);
+}
+export function createBookingEngineSnapshot(session) {
+    const state = deriveBookingEngineState(session);
+    return {
+        sessionId: session.sessionId,
+        bookingNumber: session.bookingNumber,
+        state,
+        bookingStatus: session.status,
+        currentStep: session.state?.currentStep ?? null,
+        completedSteps: session.state?.completedSteps ?? [],
+        holdExpiresAt: session.holdExpiresAt,
+        readyForConfirmation: session.checklist.readyForConfirmation,
+        allowedActions: getAllowedBookingEngineActions(state),
+    };
+}
+function hasTermsAccepted(completedSteps) {
+    return completedSteps.has("terms") || completedSteps.has("contract");
+}

package/dist/errors.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+export declare const bookingEngineErrorCodes: readonly ["contract_template_missing", "reservation_expired", "departure_unavailable", "invalid_traveler_payload", "payment_provider_unavailable", "payment_url_missing", "payment_webhook_pending", "checkout_finalization_failed"];
+export type BookingEngineErrorCode = (typeof bookingEngineErrorCodes)[number];
+export declare const bookingEngineNextActions: readonly ["configure_contract_template", "restart_reservation", "choose_another_departure", "correct_traveler_payload", "choose_another_payment_method", "retry_payment_start", "poll_payment_status", "contact_operator"];
+export type BookingEngineNextAction = (typeof bookingEngineNextActions)[number];
+export declare const storefrontApiErrorEnvelopeSchema: z.ZodObject<{
+    code: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+    recoverable: z.ZodOptional<z.ZodBoolean>;
+    nextAction: z.ZodOptional<z.ZodString>;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const bookingEngineErrorEnvelopeSchema: z.ZodObject<{
+    message: z.ZodString;
+    recoverable: z.ZodOptional<z.ZodBoolean>;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    code: z.ZodEnum<{
+        contract_template_missing: "contract_template_missing";
+        reservation_expired: "reservation_expired";
+        departure_unavailable: "departure_unavailable";
+        invalid_traveler_payload: "invalid_traveler_payload";
+        payment_provider_unavailable: "payment_provider_unavailable";
+        payment_url_missing: "payment_url_missing";
+        payment_webhook_pending: "payment_webhook_pending";
+        checkout_finalization_failed: "checkout_finalization_failed";
+    }>;
+    nextAction: z.ZodOptional<z.ZodEnum<{
+        configure_contract_template: "configure_contract_template";
+        restart_reservation: "restart_reservation";
+        choose_another_departure: "choose_another_departure";
+        correct_traveler_payload: "correct_traveler_payload";
+        choose_another_payment_method: "choose_another_payment_method";
+        retry_payment_start: "retry_payment_start";
+        poll_payment_status: "poll_payment_status";
+        contact_operator: "contact_operator";
+    }>>;
+}, z.core.$strip>;
+export type StorefrontApiErrorEnvelope = z.infer<typeof storefrontApiErrorEnvelopeSchema>;
+export type BookingEngineErrorEnvelope = z.infer<typeof bookingEngineErrorEnvelopeSchema>;
+export declare function parseStorefrontApiErrorEnvelope(body: unknown): StorefrontApiErrorEnvelope | null;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,uBAAuB,sOAS1B,CAAA;AAEV,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAA;AAE7E,eAAO,MAAM,wBAAwB,4NAS3B,CAAA;AAEV,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAA;AAE/E,eAAO,MAAM,gCAAgC;;;;;;iBAM3C,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;iBAG3C,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AACzF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAEzF,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,OAAO,GAAG,0BAA0B,GAAG,IAAI,CAqBhG"}

package/dist/errors.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+export const bookingEngineErrorCodes = [
+    "contract_template_missing",
+    "reservation_expired",
+    "departure_unavailable",
+    "invalid_traveler_payload",
+    "payment_provider_unavailable",
+    "payment_url_missing",
+    "payment_webhook_pending",
+    "checkout_finalization_failed",
+];
+export const bookingEngineNextActions = [
+    "configure_contract_template",
+    "restart_reservation",
+    "choose_another_departure",
+    "correct_traveler_payload",
+    "choose_another_payment_method",
+    "retry_payment_start",
+    "poll_payment_status",
+    "contact_operator",
+];
+export const storefrontApiErrorEnvelopeSchema = z.object({
+    code: z.string().optional(),
+    message: z.string(),
+    recoverable: z.boolean().optional(),
+    nextAction: z.string().optional(),
+    details: z.record(z.string(), z.unknown()).optional(),
+});
+export const bookingEngineErrorEnvelopeSchema = storefrontApiErrorEnvelopeSchema.extend({
+    code: z.enum(bookingEngineErrorCodes),
+    nextAction: z.enum(bookingEngineNextActions).optional(),
+});
+export function parseStorefrontApiErrorEnvelope(body) {
+    const direct = storefrontApiErrorEnvelopeSchema.safeParse(body);
+    if (direct.success) {
+        return direct.data;
+    }
+    if (typeof body !== "object" || body === null || !("error" in body)) {
+        return null;
+    }
+    const error = body.error;
+    if (typeof error === "string") {
+        const code = typeof body.code === "string"
+            ? body.code
+            : undefined;
+        return { code, message: error };
+    }
+    const nested = storefrontApiErrorEnvelopeSchema.safeParse(error);
+    return nested.success ? nested.data : null;
+}