@voyant-travel/cruises 0.118.2

package/dist/adapters/mock.js

@@ -0,0 +1,192 @@
+/**
+ * In-memory CruiseAdapter for tests and templates that need a working
+ * external source without a real upstream.
+ *
+ * Seed it via the `add*` methods; queries against the registered data work
+ * exactly like a real adapter would. Booking commits return synthesized
+ * confirmation refs and increment a per-instance counter.
+ */
+function refKey(ref) {
+    return JSON.stringify(sortValue(ref));
+}
+function sortValue(value) {
+    if (Array.isArray(value))
+        return value.map(sortValue);
+    if (!value || typeof value !== "object")
+        return value;
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+        out[key] = sortValue(value[key]);
+    }
+    return out;
+}
+export class MockCruiseAdapter {
+    name;
+    version;
+    cruisesByRef = new Map();
+    shipsByRef = new Map();
+    bookingResults = new Map();
+    // Telemetry — useful for assertions in tests.
+    callCount = 0;
+    bookingCount = 0;
+    failEveryNthCall;
+    constructor(options = {}) {
+        this.name = options.name ?? "mock";
+        this.version = options.version ?? "1.0.0";
+        this.failEveryNthCall = options.failEveryNthCall ?? 0;
+    }
+    // ---------- seeders ----------
+    addCruise(cruise, sailings = []) {
+        const key = refKey(cruise.sourceRef);
+        this.cruisesByRef.set(key, {
+            cruise,
+            sailings: [...sailings],
+            itinerariesBySailing: new Map(),
+            pricingBySailing: new Map(),
+        });
+    }
+    addSailing(cruiseRef, sailing) {
+        const seeded = this.cruisesByRef.get(refKey(cruiseRef));
+        if (!seeded)
+            throw new Error(`MockCruiseAdapter: cruise ${cruiseRef.externalId} not seeded`);
+        seeded.sailings.push(sailing);
+    }
+    addShip(ship) {
+        this.shipsByRef.set(refKey(ship.sourceRef), ship);
+    }
+    setSailingPricing(sailingRef, prices) {
+        for (const seeded of this.cruisesByRef.values()) {
+            const match = seeded.sailings.find((s) => refKey(s.sourceRef) === refKey(sailingRef));
+            if (match) {
+                seeded.pricingBySailing.set(refKey(sailingRef), prices);
+                return;
+            }
+        }
+        throw new Error(`MockCruiseAdapter: sailing ${sailingRef.externalId} not seeded`);
+    }
+    setSailingItinerary(sailingRef, days) {
+        for (const seeded of this.cruisesByRef.values()) {
+            const match = seeded.sailings.find((s) => refKey(s.sourceRef) === refKey(sailingRef));
+            if (match) {
+                seeded.itinerariesBySailing.set(refKey(sailingRef), days);
+                return;
+            }
+        }
+        throw new Error(`MockCruiseAdapter: sailing ${sailingRef.externalId} not seeded`);
+    }
+    /** Pre-program a specific booking response for the next createBooking that matches. */
+    setBookingResult(sailingRef, cabinCategoryRef, result) {
+        this.bookingResults.set(`${refKey(sailingRef)}::${refKey(cabinCategoryRef)}`, result);
+    }
+    // ---------- contract implementation ----------
+    tickAndCheck() {
+        this.callCount++;
+        if (this.failEveryNthCall > 0 && this.callCount % this.failEveryNthCall === 0) {
+            throw new Error(`MockCruiseAdapter forced failure on call #${this.callCount}`);
+        }
+    }
+    async listEntries(options = {}) {
+        this.tickAndCheck();
+        const limit = options.limit ?? 50;
+        const all = [];
+        for (const seeded of this.cruisesByRef.values()) {
+            const c = seeded.cruise;
+            const earliest = seeded.sailings
+                .map((s) => s.departureDate)
+                .sort()
+                .at(0) ?? null;
+            all.push({
+                sourceRef: c.sourceRef,
+                name: c.name,
+                slug: c.slug,
+                cruiseType: c.cruiseType,
+                lineName: c.lineName,
+                nights: c.nights,
+                earliestDeparture: earliest,
+                heroImageUrl: c.heroImageUrl ?? null,
+            });
+        }
+        return { entries: all.slice(0, limit) };
+    }
+    async *searchProjection(options = {}) {
+        this.tickAndCheck();
+        void options;
+        for (const seeded of this.cruisesByRef.values()) {
+            const c = seeded.cruise;
+            const earliest = seeded.sailings
+                .map((s) => s.departureDate)
+                .sort()
+                .at(0) ?? null;
+            const latest = seeded.sailings
+                .map((s) => s.departureDate)
+                .sort()
+                .at(-1) ?? null;
+            yield {
+                sourceRef: c.sourceRef,
+                slug: c.slug,
+                name: c.name,
+                cruiseType: c.cruiseType,
+                lineName: c.lineName,
+                shipName: this.shipsByRef.get(refKey(c.defaultShipRef ?? c.sourceRef))?.name ?? c.lineName,
+                nights: c.nights,
+                embarkPortName: c.embarkPortName ?? null,
+                disembarkPortName: c.disembarkPortName ?? null,
+                regions: c.regions,
+                themes: c.themes,
+                earliestDeparture: earliest,
+                latestDeparture: latest,
+                heroImageUrl: c.heroImageUrl ?? null,
+            };
+        }
+    }
+    async fetchCruise(ref) {
+        this.tickAndCheck();
+        return this.cruisesByRef.get(refKey(ref))?.cruise ?? null;
+    }
+    async fetchSailing(ref) {
+        this.tickAndCheck();
+        for (const seeded of this.cruisesByRef.values()) {
+            const match = seeded.sailings.find((s) => refKey(s.sourceRef) === refKey(ref));
+            if (match)
+                return match;
+        }
+        return null;
+    }
+    async fetchSailingPricing(ref) {
+        this.tickAndCheck();
+        for (const seeded of this.cruisesByRef.values()) {
+            const prices = seeded.pricingBySailing.get(refKey(ref));
+            if (prices)
+                return prices;
+        }
+        return [];
+    }
+    async fetchSailingItinerary(ref) {
+        this.tickAndCheck();
+        for (const seeded of this.cruisesByRef.values()) {
+            const days = seeded.itinerariesBySailing.get(refKey(ref));
+            if (days)
+                return days;
+        }
+        return [];
+    }
+    async fetchShip(ref) {
+        this.tickAndCheck();
+        return this.shipsByRef.get(refKey(ref)) ?? null;
+    }
+    async listSailingsForCruise(cruiseRef) {
+        this.tickAndCheck();
+        return this.cruisesByRef.get(refKey(cruiseRef))?.sailings ?? [];
+    }
+    async createBooking(input) {
+        this.tickAndCheck();
+        this.bookingCount++;
+        const programmed = this.bookingResults.get(`${refKey(input.sailingRef)}::${refKey(input.cabinCategoryRef)}`);
+        if (programmed)
+            return programmed;
+        return {
+            connectorBookingRef: `MOCK-${this.bookingCount.toString().padStart(6, "0")}`,
+            connectorStatus: "confirmed",
+        };
+    }
+}

package/dist/adapters/registry.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Process-local registry of cruise adapters.
+ *
+ * Templates register adapters at app startup:
+ *
+ *   import { registerCruiseAdapter } from "@voyant-travel/cruises/adapters"
+ *   import { createCruiseAdapter } from "external-cruise-adapter"
+ *
+ *   registerCruiseAdapter(createCruiseAdapter({ token: env.CRUISE_ADAPTER_TOKEN }))
+ *
+ * The route layer resolves an adapter by `sourceProvider` (the prefix in the
+ * unified key `<provider>:<ref>`) before dispatching detail reads, refresh,
+ * detach, or the external booking commit.
+ *
+ * The registry is intentionally a plain Map. There's no per-tenant scoping —
+ * each Voyant deployment is single-tenant. Tests can reset state via
+ * `clearCruiseAdapters()`.
+ */
+import type { CruiseAdapter } from "./index.js";
+export declare function registerCruiseAdapter(adapter: CruiseAdapter): void;
+export declare function unregisterCruiseAdapter(name: string): boolean;
+export declare function clearCruiseAdapters(): void;
+export declare function resolveCruiseAdapter(name: string): CruiseAdapter | undefined;
+export declare function listCruiseAdapters(): CruiseAdapter[];
+export declare function hasCruiseAdapter(name: string): boolean;
+//# sourceMappingURL=registry.d.ts.map

package/dist/adapters/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/adapters/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAI/C,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAQlE;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAE5E;AAED,wBAAgB,kBAAkB,IAAI,aAAa,EAAE,CAEpD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtD"}

package/dist/adapters/registry.js

@@ -0,0 +1,42 @@
+/**
+ * Process-local registry of cruise adapters.
+ *
+ * Templates register adapters at app startup:
+ *
+ *   import { registerCruiseAdapter } from "@voyant-travel/cruises/adapters"
+ *   import { createCruiseAdapter } from "external-cruise-adapter"
+ *
+ *   registerCruiseAdapter(createCruiseAdapter({ token: env.CRUISE_ADAPTER_TOKEN }))
+ *
+ * The route layer resolves an adapter by `sourceProvider` (the prefix in the
+ * unified key `<provider>:<ref>`) before dispatching detail reads, refresh,
+ * detach, or the external booking commit.
+ *
+ * The registry is intentionally a plain Map. There's no per-tenant scoping —
+ * each Voyant deployment is single-tenant. Tests can reset state via
+ * `clearCruiseAdapters()`.
+ */
+const adapters = new Map();
+export function registerCruiseAdapter(adapter) {
+    if (!adapter.name)
+        throw new Error("Adapter must have a non-empty name");
+    if (adapters.has(adapter.name)) {
+        throw new Error(`Cruise adapter '${adapter.name}' is already registered; call unregisterCruiseAdapter first if you intend to replace it`);
+    }
+    adapters.set(adapter.name, adapter);
+}
+export function unregisterCruiseAdapter(name) {
+    return adapters.delete(name);
+}
+export function clearCruiseAdapters() {
+    adapters.clear();
+}
+export function resolveCruiseAdapter(name) {
+    return adapters.get(name);
+}
+export function listCruiseAdapters() {
+    return Array.from(adapters.values());
+}
+export function hasCruiseAdapter(name) {
+    return adapters.has(name);
+}

package/dist/adapters/source-adapter-shim.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Adapt a vertical-shaped `CruiseAdapter` (with its multi-method
+ * `fetchCruise / fetchSailing / fetchShip / fetchSailingItinerary`
+ * surface) into a catalog-plane `SourceAdapter` so the cruises module
+ * can participate in:
+ *
+ *   - The catalog plane's discovery / projection-capture pipeline
+ *     (`sync.ts` writes a `catalog_sourced_entries` row per emitted
+ *     projection), enabling the durable thin-content synthesizer
+ *     fallback for cruises (sourced-content §2.5, §3.6).
+ *   - The `getCruiseContent` SWR machinery (sourced-content §3.4) —
+ *     the shim's `getContent` composes the cruise adapter's per-aspect
+ *     fetches into one `CruiseContent` payload.
+ *   - The catalog plane's snapshot content capture (sourced-content
+ *     §5.1) — `bookEntity` calls this `getContent` at commit time.
+ *
+ * Per the doc's Phase E note: the cruise adapter retains its internal
+ * multi-call composition; only the public catalog surface narrows.
+ *
+ * Templates wire the shim by registering it into the catalog
+ * `SourceAdapterRegistry` AT PROCESS START, alongside the cruise
+ * adapter's own per-vertical registration. Both registrations are
+ * cheap — they share the same underlying `CruiseAdapter` instance.
+ */
+import type { SourceAdapter } from "@voyant-travel/catalog";
+import { type CruiseContent } from "../content-shape.js";
+import type { CruiseAdapter, ExternalItineraryDay, SourceRef } from "./index.js";
+export interface CruiseSourceAdapterShimOptions {
+    /**
+     * The `source_kind` reported on every projection emitted by the
+     * shim. Defaults to `"cruise:" + adapter.name` so multiple cruise
+     * adapters (different agencies) coexist in the catalog registry
+     * without colliding on `source_kind`.
+     */
+    sourceKind?: string;
+    /**
+     * Optional translator from `SourceRef` → catalog-side `entity_id`.
+     * Catalog `entity_id` is the Voyant-side TypeID; this shim produces
+     * one synthetically by hashing the upstream ref so discovery is
+     * idempotent. Templates can override when they have an external-id
+     * → typeid mapping in their own DB.
+     *
+     * The default produces stable ids that round-trip across re-syncs:
+     * `crus_${slug-of-externalId}`. The catalog plane uses the entity_id
+     * as its primary key into `catalog_sourced_entries`, so stability is
+     * load-bearing — drift on the id maps to a new entity.
+     */
+    buildEntityId?: (sourceRef: SourceRef) => string;
+    /**
+     * Pagination batch size for `discover`. Defaults to 200 — large
+     * enough to amortize HTTP overhead, small enough to cap memory.
+     */
+    pageSize?: number;
+    /**
+     * BCP 47 locales the cruise adapter can serve content in. Reported
+     * via `capabilities.supportedContentLocales`. Defaults to undefined
+     * (unknown — caller probes per-call).
+     */
+    supportedContentLocales?: ReadonlyArray<string>;
+    /**
+     * When false, declares `supportsContentFetch: false` so the catalog
+     * plane skips `getContent` and falls through to the per-vertical
+     * thin-content synthesizer (sourced-content §3.6). Defaults to
+     * true — the shim composes a real `CruiseContent` payload from the
+     * cruise adapter's per-aspect fetches.
+     */
+    supportsContentFetch?: boolean;
+}
+export interface CruiseSourceAdapterShim extends SourceAdapter {
+    /** The wrapped vertical adapter — exposed for diagnostics / tests. */
+    readonly cruiseAdapter: CruiseAdapter;
+}
+/**
+ * Wrap a `CruiseAdapter` as a catalog `SourceAdapter`. The wrapped
+ * adapter is shared by reference — its internal state (HTTP clients,
+ * caches, credentials) is not duplicated.
+ */
+export declare function cruiseAdapterToSourceAdapter(cruiseAdapter: CruiseAdapter, options?: CruiseSourceAdapterShimOptions): CruiseSourceAdapterShim;
+export declare function cruiseItineraryStopFrom(day: ExternalItineraryDay, date?: string | null): CruiseContent["itinerary_stops"][number];
+//# sourceMappingURL=source-adapter-shim.d.ts.map

package/dist/adapters/source-adapter-shim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-adapter-shim.d.ts","sourceRoot":"","sources":["../../src/adapters/source-adapter-shim.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAcV,aAAa,EAEd,MAAM,wBAAwB,CAAA;AAG/B,OAAO,EAAkC,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAGxF,OAAO,KAAK,EACV,aAAa,EAIb,oBAAoB,EAGpB,SAAS,EACV,MAAM,YAAY,CAAA;AAEnB,MAAM,WAAW,8BAA8B;IAC7C;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;;;;;;;;OAWG;IACH,aAAa,CAAC,EAAE,CAAC,SAAS,EAAE,SAAS,KAAK,MAAM,CAAA;IAChD;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;OAIG;IACH,uBAAuB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC/C;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B;AAED,MAAM,WAAW,uBAAwB,SAAQ,aAAa;IAC5D,sEAAsE;IACtE,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAA;CACtC;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,aAAa,EAAE,aAAa,EAC5B,OAAO,GAAE,8BAAmC,GAC3C,uBAAuB,CAgKzB;AA0HD,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,oBAAoB,EACzB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,GACnB,aAAa,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAU1C"}