@ticketboothapp/booking 1.2.48 → 1.2.50

package/src/lib/dependent-add-on-api.ts

@@ -0,0 +1,434 @@
+/**
+ * TicketBooth dependent add-on (DAP) APIs — booking-reference-first flow.
+ *
+ * Availability response may include primary booking itinerary (no last name typed by user):
+ *   `data.itineraryDisplay` or `data.primaryItineraryDisplay`
+ * and `data.primaryCustomerLastName` when stored on the booking.
+ * Same step shape as public booking `itineraryDisplay` (stepType, time, place, label).
+ *
+ * Itinerary-aware slots (client + recommended server behavior):
+ *   For each `arrive` → next `depart` pair, treat [arriveTime, departTime] as an on-site
+ *   window. Only offer slots fully contained in at least one window for the trip day.
+ *   This module filters the GET response when an itinerary is present (see
+ *   `filterSlotsByPrimaryItineraryWindows`). TicketBooth should apply the same rules when
+ *   building offerings so capacity and pricing stay authoritative.
+ */
+
+import { ENV } from './env';
+import {
+  filterDapSlotsToPrimaryItineraryWindows,
+  normalizeDapItinerarySteps,
+  type DapItineraryStep,
+} from './dap-itinerary-preview';
+
+export type { DapItineraryStep };
+
+const API_BASE = ENV.API_URL;
+
+function getAuthHeaders(): Record<string, string> {
+  const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+  if (ENV.BASIC_AUTH) {
+    headers['Authorization'] = `Basic ${ENV.BASIC_AUTH}`;
+  }
+  return headers;
+}
+
+async function parseJsonSafely(res: Response): Promise<unknown> {
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+interface ApiErrorPayload {
+  errorCode?: string;
+  errorMessage?: string;
+  error?: string;
+}
+
+function isApiErrorPayload(value: unknown): value is ApiErrorPayload {
+  return typeof value === 'object' && value !== null;
+}
+
+function messageFromPayload(payload: unknown, fallback: string): string {
+  if (isApiErrorPayload(payload)) {
+    return payload.errorMessage || payload.error || fallback;
+  }
+  return fallback;
+}
+
+function pickStr(obj: Record<string, unknown>, ...keys: string[]): string | undefined {
+  for (const k of keys) {
+    const v = obj[k];
+    if (typeof v === 'string' && v.trim()) return v.trim();
+  }
+  return undefined;
+}
+
+function pickNum(obj: Record<string, unknown>, ...keys: string[]): number | undefined {
+  for (const k of keys) {
+    const v = obj[k];
+    if (typeof v === 'number' && !Number.isNaN(v)) return v;
+    if (typeof v === 'string' && v.trim()) {
+      const n = Number(v);
+      if (!Number.isNaN(n)) return n;
+    }
+  }
+  return undefined;
+}
+
+/** Positive whole days, capped for sanity (DAP cancellation window from TicketBooth). */
+function pickPositiveDayCount(obj: Record<string, unknown>, ...keys: string[]): number | undefined {
+  const n = pickNum(obj, ...keys);
+  if (n === undefined || !Number.isFinite(n)) return undefined;
+  const floor = Math.floor(n);
+  if (floor < 1) return undefined;
+  return Math.min(floor, 365);
+}
+
+function extractDapCancellationDaysBeforeSession(
+  inner: Record<string, unknown> | null | undefined
+): number | undefined {
+  if (!inner) return undefined;
+  const top = pickPositiveDayCount(
+    inner,
+    'cancellationDaysBeforeSession',
+    'cancellation_days_before_session'
+  );
+  if (top !== undefined) return top;
+  const prod =
+    inner.dependentAddOnProduct ?? inner.dependent_add_on_product ?? inner.product;
+  if (prod && typeof prod === 'object') {
+    return pickPositiveDayCount(
+      prod as Record<string, unknown>,
+      'cancellationDaysBeforeSession',
+      'cancellation_days_before_session'
+    );
+  }
+  return undefined;
+}
+
+/** Normalize TicketBooth create-payment-intent JSON (nested `data`, snake_case). */
+function coercePaymentIntentResult(payload: unknown): CreateDependentAddOnPaymentIntentResult {
+  const root = payload && typeof payload === 'object' ? (payload as Record<string, unknown>) : {};
+  const inner =
+    root.data && typeof root.data === 'object'
+      ? (root.data as Record<string, unknown>)
+      : root;
+  return {
+    clientSecret: pickStr(inner, 'clientSecret', 'client_secret'),
+    totalAmount: pickNum(inner, 'totalAmount', 'total_amount'),
+    currency: pickStr(inner, 'currency'),
+    subtotalAmount: pickNum(inner, 'subtotalAmount', 'subtotal_amount'),
+    taxAmount: pickNum(inner, 'taxAmount', 'tax_amount'),
+    customerLastName: pickStr(inner, 'customerLastName', 'customer_last_name'),
+  };
+}
+
+export type DependentAddOnCheckoutQuestionType = 'TEXT' | 'CHECKBOX';
+
+export interface DependentAddOnCheckoutQuestion {
+  id: string;
+  type: DependentAddOnCheckoutQuestionType;
+  label: string;
+  required?: boolean;
+  maxLength?: number | null;
+  placeholder?: string | null;
+  helpText?: string | null;
+}
+
+export interface DependentAddOnSlot {
+  offeringId: string;
+  resourceId: string;
+  resourceName?: string;
+  slotStart: string;
+  slotEnd: string;
+  capacityTotal?: number;
+  capacityRemaining?: number;
+  price?: number;
+  currency?: string;
+  dependentAddOnProductOptionId?: string;
+}
+
+export interface GetDependentAddOnAvailabilityParams {
+  companyId: string;
+  primaryBookingReference: string;
+  lastName: string;
+  dependentAddOnProductId: string;
+  dependentAddOnProductOptionId?: string;
+  /** YYYY-MM-DD — limits slots to one local day when supported */
+  date?: string;
+  /**
+   * When true (default), drop slots not fully inside an arrive→depart on-site window
+   * derived from `primaryItineraryDisplay` in the same response (or after normalize).
+   */
+  filterSlotsByPrimaryItineraryWindows?: boolean;
+  /** Pass from AbortController to cancel in-flight work (e.g. route change, Strict Mode remount). */
+  signal?: AbortSignal;
+}
+
+export type DependentAddOnBookingUpsellProductRow = {
+  dependentAddOnProductId: string;
+  dependentAddOnProductOptionId?: string;
+};
+
+export interface GetDependentAddOnBookingUpsellEligibilityParams {
+  companyId: string;
+  primaryBookingReference: string;
+  lastName: string;
+  signal?: AbortSignal;
+}
+
+/**
+ * Single TicketBooth read for manage-booking photo upsell: ACTIVE DAP products that have at least one
+ * bookable slot for this primary booking (same last-name gate as availability). Replaces N parallel
+ * `getDependentAddOnAvailability` probes.
+ */
+export async function getDependentAddOnBookingUpsellEligibility(
+  params: GetDependentAddOnBookingUpsellEligibilityParams
+): Promise<{ productsWithSlots: DependentAddOnBookingUpsellProductRow[] }> {
+  const endpoint = '/1/dependent-add-ons/booking-upsell-eligibility';
+  const q = new URLSearchParams({
+    companyId: params.companyId,
+    primaryBookingReference: params.primaryBookingReference.trim(),
+    lastName: params.lastName.trim(),
+  });
+  const url = `${API_BASE}${endpoint}?${q}`;
+  if (params.signal?.aborted) {
+    const aborted = new Error('Aborted');
+    aborted.name = 'AbortError';
+    throw aborted;
+  }
+  let res: Response;
+  try {
+    res = await fetch(url, {
+      method: 'GET',
+      headers: getAuthHeaders(),
+      signal: params.signal,
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === 'AbortError') throw err;
+    if (
+      typeof DOMException !== 'undefined' &&
+      err instanceof DOMException &&
+      err.name === 'AbortError'
+    ) {
+      throw err;
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Unable to load add-on upsell eligibility. ${msg}`);
+  }
+  const payload = await parseJsonSafely(res);
+  if (!res.ok) {
+    throw new Error(
+      messageFromPayload(payload, `Could not load upsell eligibility (HTTP ${res.status})`)
+    );
+  }
+  const data = payload as { data?: Record<string, unknown> } | null;
+  const inner = data?.data;
+  const rawList = inner?.productsWithSlots ?? inner?.products_with_slots;
+  const rows: DependentAddOnBookingUpsellProductRow[] = [];
+  if (Array.isArray(rawList)) {
+    for (const item of rawList) {
+      if (!item || typeof item !== 'object') continue;
+      const o = item as Record<string, unknown>;
+      const id =
+        pickStr(o, 'dependentAddOnProductId', 'dependent_add_on_product_id') ?? '';
+      if (!id) continue;
+      const opt = pickStr(
+        o,
+        'dependentAddOnProductOptionId',
+        'dependent_add_on_product_option_id'
+      );
+      rows.push({
+        dependentAddOnProductId: id,
+        ...(opt ? { dependentAddOnProductOptionId: opt } : {}),
+      });
+    }
+  }
+  return { productsWithSlots: rows };
+}
+
+export type DependentAddOnAvailabilityResult = {
+  slots: DependentAddOnSlot[];
+  /** Present when API includes itinerary for this reference (preview without last name). */
+  primaryItineraryDisplay: DapItineraryStep[];
+  /** Primary booking last name from TicketBooth (for manage-booking after DAP payment). */
+  primaryCustomerLastName?: string;
+  /** When TicketBooth sends it on this DAP product / availability payload. */
+  cancellationDaysBeforeSession?: number;
+  /** Server-defined checkout questionnaire for this DAP (empty if none). */
+  checkoutQuestions: DependentAddOnCheckoutQuestion[];
+};
+
+export async function getDependentAddOnAvailability(
+  params: GetDependentAddOnAvailabilityParams
+): Promise<DependentAddOnAvailabilityResult> {
+  const endpoint = '/1/dependent-add-ons/availability';
+  const q = new URLSearchParams({
+    companyId: params.companyId,
+    primaryBookingReference: params.primaryBookingReference.trim(),
+    lastName: params.lastName.trim(),
+    dependentAddOnProductId: params.dependentAddOnProductId,
+  });
+  if (params.dependentAddOnProductOptionId?.trim()) {
+    q.set('dependentAddOnProductOptionId', params.dependentAddOnProductOptionId.trim());
+  }
+  if (params.date?.trim()) {
+    q.set('date', params.date.trim());
+  }
+  const url = `${API_BASE}${endpoint}?${q}`;
+  if (params.signal?.aborted) {
+    const aborted = new Error('Aborted');
+    aborted.name = 'AbortError';
+    throw aborted;
+  }
+  let res: Response;
+  try {
+    res = await fetch(url, {
+      method: 'GET',
+      headers: getAuthHeaders(),
+      signal: params.signal,
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === 'AbortError') throw err;
+    if (
+      typeof DOMException !== 'undefined' &&
+      err instanceof DOMException &&
+      err.name === 'AbortError'
+    ) {
+      throw err;
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Unable to load add-on times. ${msg}`);
+  }
+  const payload = await parseJsonSafely(res);
+  if (!res.ok) {
+    throw new Error(messageFromPayload(payload, `Could not load times (HTTP ${res.status})`));
+  }
+  const data = payload as { data?: Record<string, unknown> } | null;
+  const inner = data?.data;
+  const cancellationDaysBeforeSession = extractDapCancellationDaysBeforeSession(inner);
+  const slots = inner?.slots;
+  const itineraryRaw =
+    inner?.itineraryDisplay ?? inner?.primaryItineraryDisplay ?? null;
+  const primaryCustomerLastName = inner
+    ? pickStr(
+        inner,
+        'primaryCustomerLastName',
+        'primary_customer_last_name'
+      )
+    : undefined;
+  const primaryItineraryDisplay = normalizeDapItinerarySteps(itineraryRaw);
+  const rawSlots = Array.isArray(slots) ? slots : [];
+  const shouldFilterWindows = params.filterSlotsByPrimaryItineraryWindows !== false;
+  const filteredSlots =
+    shouldFilterWindows && primaryItineraryDisplay.length > 0
+      ? filterDapSlotsToPrimaryItineraryWindows(rawSlots, primaryItineraryDisplay)
+      : rawSlots;
+
+  const checkoutQuestions = normalizeCheckoutQuestions(
+    inner?.checkoutQuestions ?? inner?.checkout_questions
+  );
+
+  return {
+    slots: filteredSlots,
+    primaryItineraryDisplay,
+    primaryCustomerLastName,
+    checkoutQuestions,
+    ...(cancellationDaysBeforeSession !== undefined
+      ? { cancellationDaysBeforeSession }
+      : {}),
+  };
+}
+
+function normalizeCheckoutQuestions(raw: unknown): DependentAddOnCheckoutQuestion[] {
+  if (!Array.isArray(raw)) return [];
+  const out: DependentAddOnCheckoutQuestion[] = [];
+  for (const item of raw) {
+    if (!item || typeof item !== 'object') continue;
+    const o = item as Record<string, unknown>;
+    const id = pickStr(o, 'id') ?? '';
+    if (!id) continue;
+    const typeRaw = (pickStr(o, 'type') ?? 'TEXT').toUpperCase();
+    const type: DependentAddOnCheckoutQuestionType =
+      typeRaw === 'CHECKBOX' ? 'CHECKBOX' : 'TEXT';
+    const label = pickStr(o, 'label') ?? id;
+    const required = Boolean(o.required ?? o.Required);
+    const maxLength =
+      typeof o.maxLength === 'number'
+        ? o.maxLength
+        : typeof o.max_length === 'number'
+          ? o.max_length
+          : undefined;
+    const placeholder = pickStr(o, 'placeholder', 'placeholder_text') ?? null;
+    const helpText = pickStr(o, 'helpText', 'help_text') ?? null;
+    out.push({
+      id,
+      type,
+      label,
+      required,
+      maxLength: maxLength ?? null,
+      placeholder,
+      helpText,
+    });
+  }
+  return out;
+}
+
+export interface CreateDependentAddOnPaymentIntentBody {
+  companyId: string;
+  primaryBookingReference: string;
+  lastName: string;
+  dependentAddOnProductId: string;
+  dependentAddOnProductOptionId?: string;
+  offeringId: string;
+  slotStart: string;
+  slotEnd: string;
+  quantity: number;
+  idempotencyKey: string;
+  customerEmail?: string;
+  customerFirstName?: string;
+  customerLastName?: string;
+  /** Keyed by question id; checkboxes use "true" / "false". */
+  checkoutAnswers?: Record<string, string>;
+}
+
+export interface CreateDependentAddOnPaymentIntentResult {
+  clientSecret?: string;
+  totalAmount?: number;
+  currency?: string;
+  /** Pre-tax subtotal (same as TicketBooth pricing config + GST logic) */
+  subtotalAmount?: number;
+  /** GST / tax included in totalAmount for CAD, etc. */
+  taxAmount?: number;
+  /** Primary booking customer last name (for manage-booking redirect). */
+  customerLastName?: string;
+}
+
+/**
+ * Server-priced Stripe PaymentIntent for a dependent add-on. After payment succeeds,
+ * TicketBooth webhook creates the dependent add-on booking (same idempotency key).
+ */
+export async function createDependentAddOnPaymentIntent(
+  body: CreateDependentAddOnPaymentIntentBody
+): Promise<CreateDependentAddOnPaymentIntentResult> {
+  const endpoint = '/checkout/dependent-add-on-payment-intent';
+  let res: Response;
+  try {
+    res = await fetch(`${API_BASE}${endpoint}`, {
+      method: 'POST',
+      headers: getAuthHeaders(),
+      body: JSON.stringify(body),
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Unable to start payment. ${msg}`);
+  }
+  const payload = await parseJsonSafely(res);
+  if (!res.ok) {
+    throw new Error(messageFromPayload(payload, `Could not start payment (HTTP ${res.status})`));
+  }
+  return coercePaymentIntentResult(payload);
+}

package/src/lib/env.ts

@@ -0,0 +1,102 @@
+/**
+ * Type-safe environment variable access
+ * Direct access to process.env for Next.js build-time replacement
+ * This ensures NEXT_PUBLIC_* variables are properly embedded at build time
+ */
+const getApiUrl = (): string => {
+  const apiUrl = process.env.NEXT_PUBLIC_API_URL;
+  
+  if (!apiUrl) {
+    if (process.env.NODE_ENV === 'production') {
+      throw new Error(
+        'NEXT_PUBLIC_API_URL environment variable is required for production builds. ' +
+        'Set it in your .env.local file or build environment.'
+      );
+    }
+    // Development fallback - warn but allow
+    console.warn(
+      '⚠️  NEXT_PUBLIC_API_URL not set. Using localhost fallback. ' +
+      'Set NEXT_PUBLIC_API_URL in .env.local for production API.'
+    );
+    return 'http://localhost:3001';
+  }
+  
+  return apiUrl;
+};
+
+const getGoogleMapsApiKey = (): string => {
+  return process.env.NEXT_PUBLIC_GOOGLE_MAPS_API_KEY ?? '';
+};
+
+const getStripePublishableKey = (): string => {
+  const key = process.env.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY ?? '';
+  return key;
+};
+
+/**
+ * Base64-encoded `user:password` for TicketBooth Basic auth (not including the "Basic " prefix).
+ * Some endpoints (e.g. get-availabilities, reserve) require this; others may work without it.
+ */
+const getBasicAuth = (): string => {
+  return process.env.NEXT_PUBLIC_BASIC_AUTH ?? '';
+};
+
+/** Via Via company ID in TicketBooth (for API calls). */
+const getCompanyId = (): string => {
+  return process.env.NEXT_PUBLIC_COMPANY_ID ?? 'c_LFU0Vx9hS5v3';
+};
+
+/** GA4 Measurement ID (e.g. G-XXXXXXXXXX). Use same as backend for deduplication. */
+const getGa4MeasurementId = (): string => {
+  return process.env.NEXT_PUBLIC_GA4_MEASUREMENT_ID ?? 'G-BVCCYBSHP8';
+};
+
+/** Meta Pixel ID (e.g. 123456789012345). Use same as backend for deduplication. */
+const getMetaPixelId = (): string => {
+  return process.env.NEXT_PUBLIC_META_PIXEL_ID ?? '';
+};
+
+/** Where `/videos/…` and other public assets live when booking is embedded off viavia.com (Ticketbooth, etc.). Empty = same-origin relative paths. */
+const getViaviaStaticOrigin = (): string => {
+  return process.env.NEXT_PUBLIC_VIAVIA_STATIC_ORIGIN?.trim() ?? '';
+};
+
+/** App environment: development, staging, or production. Used for analytics, feature flags, etc. */
+export type AppEnv = 'development' | 'staging' | 'production';
+
+const getAppEnv = (): AppEnv => {
+  const raw = process.env.NEXT_PUBLIC_APP_ENV?.toLowerCase();
+  if (raw === 'production' || raw === 'staging') return raw;
+  return 'development';
+};
+
+export const APP_ENV = getAppEnv();
+
+/** True when running in production. Use for GA4, Meta Pixel, etc. */
+export const isProduction = (): boolean => APP_ENV === 'production';
+
+/** True when running in staging. */
+export const isStaging = (): boolean => APP_ENV === 'staging';
+
+/** True when running in development (local or when NEXT_PUBLIC_APP_ENV is unset). */
+export const isDevelopment = (): boolean => APP_ENV === 'development';
+
+/** True when purchase events should only log to console (dev/staging). Phase 2: production sends to GA4/Meta. */
+export const shouldLogPurchaseToConsole = (): boolean =>
+  APP_ENV === 'development' || APP_ENV === 'staging';
+
+/** True when running on localhost (runtime check). Use to avoid sending to GA4/Meta when testing prod build locally. */
+export const isLocalhost = (): boolean =>
+  typeof window !== 'undefined' &&
+  (window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1');
+
+export const ENV = {
+  API_URL: getApiUrl(),
+  GOOGLE_MAPS_API_KEY: getGoogleMapsApiKey(),
+  STRIPE_PUBLISHABLE_KEY: getStripePublishableKey(),
+  BASIC_AUTH: getBasicAuth(),
+  COMPANY_ID: getCompanyId(),
+  GA4_MEASUREMENT_ID: getGa4MeasurementId(),
+  META_PIXEL_ID: getMetaPixelId(),
+  VIAVIA_STATIC_ORIGIN: getViaviaStaticOrigin(),
+} as const;

package/src/lib/manage-booking-post-checkout.ts

@@ -0,0 +1,68 @@
+/**
+ * Manage-booking post-checkout helpers.
+ *
+ * Next.js `router.replace` remounts the page; React state for a success banner is lost.
+ * We stash a one-time marker in sessionStorage immediately before cleaning the URL
+ * (only paid *change booking* Stripe returns). New bookings use `reservationRef` → `ref`
+ * and never set this flag.
+ *
+ * We intentionally do not poll the booking API here: one landing fetch + optional remount
+ * fetch after `replace` is enough; avoid timers/retry loops that feel like “random” refreshes.
+ */
+const STORAGE_KEY = 'viavia:manage-booking:flash:v1';
+
+export const MANAGE_BOOKING_QUERY_FROM = 'from';
+/** Only paid *change booking* Stripe returns add this; new bookings must not use it. */
+export const MANAGE_BOOKING_FROM_CHANGE_PAYMENT = 'change_payment';
+
+/** Success copy for any self-serve booking change (no-pay, paid-after-Stripe, etc.). */
+export function manageBookingChangeSuccessMessage(
+  preview: {
+    dateChanged?: boolean;
+    ticketsChanged?: boolean;
+  } | null,
+): string {
+  const updates: string[] = [];
+  if (preview?.dateChanged) updates.push('date/time');
+  if (preview?.ticketsChanged) updates.push('ticket selection');
+  const suffix =
+    updates.length > 0 ? ` Updated ${updates.join(' and ')}.` : '';
+  return `Your booking was updated successfully.${suffix}`;
+}
+
+export type ManageBookingFlashPayload = {
+  v: 1;
+  kind: 'change_payment_success';
+  t: number;
+};
+
+export function setManageBookingFlashChangePaymentSuccess(): void {
+  if (typeof window === 'undefined') return;
+  try {
+    const payload: ManageBookingFlashPayload = {
+      v: 1,
+      kind: 'change_payment_success',
+      t: Date.now(),
+    };
+    sessionStorage.setItem(STORAGE_KEY, JSON.stringify(payload));
+  } catch {
+    /* private mode / quota */
+  }
+}
+
+/** Read and clear. Returns user-facing message or null. */
+export function consumeManageBookingFlash(): string | null {
+  if (typeof window === 'undefined') return null;
+  try {
+    const raw = sessionStorage.getItem(STORAGE_KEY);
+    if (!raw) return null;
+    sessionStorage.removeItem(STORAGE_KEY);
+    const j = JSON.parse(raw) as ManageBookingFlashPayload;
+    if (j?.v === 1 && j.kind === 'change_payment_success') {
+      return manageBookingChangeSuccessMessage(null);
+    }
+  } catch {
+    /* ignore */
+  }
+  return null;
+}