@voyant-travel/cruises 0.118.2

package/dist/routes-detail.js

@@ -0,0 +1,261 @@
+import { parseJsonBody } from "@voyant-travel/hono";
+import { parseUnifiedKey } from "./lib/key.js";
+import { adapterNotRegistered, entityIdFromExternal, invalidKey, makeExternalKey, readContentScope, registryNotConfigured, resolveExternal, } from "./routes-keying.js";
+import { cruisesService } from "./service.js";
+import { getCruiseContent } from "./service-content.js";
+import { detachExternalCruise } from "./service-detach.js";
+import { insertEnrichmentProgramSchema, replaceEnrichmentProgramsSchema, } from "./validation-content.js";
+import { updateCruiseSchema } from "./validation-core.js";
+import { replaceCruiseDaysSchema } from "./validation-itinerary.js";
+export function registerCruiseDetailRoutes(app) {
+    app
+        // --- per-cruise (parses unified key, dispatches local or external) ---
+        // Keep wildcard key routes after static admin subresources so reserved
+        // segments such as /sailings, /ships, and /prices reach their handlers.
+        // External branch dispatches through the catalog content service
+        // (cache-first, SWR refresh, synthesizer fallback) — flipped from
+        // ad-hoc adapter.fetchCruise() per the catalog-sourced-content
+        // migration. Returns the rich CruiseContent shape; templates that
+        // need backwards-compatible ExternalCruise can post-process the
+        // response.
+        .get("/:key", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        if (parsed.kind === "external") {
+            const registry = c.get("sourceAdapterRegistry");
+            if (!registry)
+                return c.json(registryNotConfigured(), 503);
+            const entityId = entityIdFromExternal(parsed);
+            const result = await getCruiseContent(c.get("db"), entityId, readContentScope(c), {
+                registry,
+            });
+            if (!result) {
+                return c.json({
+                    error: "not_found",
+                    detail: `No sourced-entry row for cruise ${parsed.provider}:${parsed.ref} (entity ${entityId}). Run discovery first or check that an adapter is registered for "${parsed.provider}".`,
+                }, 404);
+            }
+            return c.json({
+                data: {
+                    source: "external",
+                    sourceProvider: parsed.provider,
+                    sourceRef: parsed.ref,
+                    entityId,
+                    content: result.content,
+                    servedLocale: result.resolution.served_locale,
+                    matchKind: result.resolution.match_kind,
+                    contentSource: result.source,
+                    servedStale: result.served_stale,
+                    synthesized: result.synthesized,
+                    machineTranslated: result.machine_translated,
+                },
+            });
+        }
+        const includeRaw = c.req.query("include") ?? "";
+        const includes = new Set(includeRaw
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean));
+        const row = await cruisesService.getCruiseById(c.get("db"), parsed.id, {
+            withSailings: includes.has("sailings"),
+            withDays: includes.has("days"),
+        });
+        if (!row)
+            return c.json({ error: "not_found" }, 404);
+        return c.json({
+            data: {
+                source: "local",
+                sourceProvider: null,
+                sourceRef: null,
+                cruise: row,
+            },
+        });
+    })
+        .put("/:key", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "external") {
+            return c.json({
+                error: "external_cruise_read_only",
+                detail: `External cruise from '${parsed.provider}' cannot be edited locally. Edit at the upstream system, or POST /:key/detach to convert to a local cruise first.`,
+            }, 409);
+        }
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        const data = await parseJsonBody(c, updateCruiseSchema);
+        const row = await cruisesService.updateCruise(c.get("db"), parsed.id, data, {
+            eventBus: c.get("eventBus"),
+        });
+        if (!row)
+            return c.json({ error: "not_found" }, 404);
+        return c.json({ data: row });
+    })
+        .delete("/:key", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "external") {
+            return c.json({
+                error: "external_cruise_read_only",
+                detail: "External cruises can't be deleted locally.",
+            }, 409);
+        }
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        const row = await cruisesService.archiveCruise(c.get("db"), parsed.id, {
+            eventBus: c.get("eventBus"),
+        });
+        if (!row)
+            return c.json({ error: "not_found" }, 404);
+        return c.json({ data: row });
+    })
+        .post("/:key/aggregates/recompute", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "external") {
+            return c.json({ error: "external_cruise_read_only", detail: "Aggregates only apply to local cruises." }, 409);
+        }
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        const row = await cruisesService.recomputeCruiseAggregates(c.get("db"), parsed.id);
+        if (!row)
+            return c.json({ error: "not_found" }, 404);
+        return c.json({ data: row });
+    })
+        .get("/:key/sailings", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        if (parsed.kind === "external") {
+            const ext = resolveExternal(parsed);
+            if (!ext)
+                return c.json(adapterNotRegistered(parsed.provider), 501);
+            const sailings = await ext.adapter.listSailingsForCruise(ext.sourceRef);
+            return c.json({
+                data: sailings.map((s) => ({
+                    source: "external",
+                    sourceProvider: ext.adapter.name,
+                    key: makeExternalKey(ext.adapter, s.sourceRef),
+                    sailing: s,
+                })),
+                total: sailings.length,
+            });
+        }
+        const result = await cruisesService.listSailings(c.get("db"), {
+            cruiseId: parsed.id,
+            limit: 100,
+            offset: 0,
+        });
+        return c.json(result);
+    })
+        .put("/:key/days/bulk", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "external") {
+            return c.json({ error: "external_cruise_read_only" }, 409);
+        }
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        const payload = await parseJsonBody(c, replaceCruiseDaysSchema.omit({ cruiseId: true }));
+        const days = await cruisesService.replaceCruiseDays(c.get("db"), {
+            cruiseId: parsed.id,
+            days: payload.days,
+        });
+        return c.json({ data: days });
+    })
+        // --- external-only operations ---
+        // Refresh dispatches through the catalog content service. The
+        // invalidator marks the cache row stale; the subsequent
+        // getCruiseContent call sees the staleness and triggers a SWR
+        // refresh. Templates that need synchronous "force fresh from
+        // upstream" semantics should call adapter.getContent() directly
+        // — this route's contract is "best effort refresh, eventually
+        // consistent."
+        .post("/:key/refresh", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind !== "external")
+            return c.json({ error: "local_cruise_no_refresh" }, 400);
+        const registry = c.get("sourceAdapterRegistry");
+        if (!registry)
+            return c.json(registryNotConfigured(), 503);
+        const entityId = entityIdFromExternal(parsed);
+        const { invalidateCruiseContentOnDrift } = await import("./service-content.js");
+        await invalidateCruiseContentOnDrift(c.get("db"), {
+            id: `cnde_refresh_${Date.now()}`,
+            entity_module: "cruises",
+            entity_id: entityId,
+            kind: "content_invalidated",
+            detected_at: new Date(),
+        });
+        const result = await getCruiseContent(c.get("db"), entityId, readContentScope(c), {
+            registry,
+        });
+        if (!result) {
+            return c.json({
+                error: "not_found",
+                detail: `No sourced-entry row for cruise ${parsed.provider}:${parsed.ref} (entity ${entityId}).`,
+            }, 404);
+        }
+        return c.json({
+            data: {
+                source: "external",
+                sourceProvider: parsed.provider,
+                sourceRef: parsed.ref,
+                entityId,
+                content: result.content,
+                contentSource: result.source,
+                servedStale: result.served_stale,
+                refreshedAt: new Date().toISOString(),
+            },
+        });
+    })
+        .post("/:key/detach", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind !== "external")
+            return c.json({ error: "local_cruise_no_detach" }, 400);
+        const ext = resolveExternal(parsed);
+        if (!ext)
+            return c.json(adapterNotRegistered(parsed.provider), 501);
+        const cruise = await detachExternalCruise(c.get("db"), ext.adapter, ext.sourceRef);
+        return c.json({ data: cruise }, 201);
+    })
+        // --- enrichment programs (expedition-focused; local cruises only) ---
+        .get("/:key/enrichment", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "external") {
+            const ext = resolveExternal(parsed);
+            if (!ext)
+                return c.json(adapterNotRegistered(parsed.provider), 501);
+            // Adapters surface enrichment via the rich cruise detail; we return an
+            // empty list here for shape compatibility. Templates that need richer
+            // external enrichment should read from adapter.fetchCruise() directly.
+            return c.json({ data: [] });
+        }
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        const programs = await cruisesService.listEnrichmentPrograms(c.get("db"), parsed.id);
+        return c.json({ data: programs });
+    })
+        .post("/:key/enrichment", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "external")
+            return c.json({ error: "external_cruise_read_only" }, 409);
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        const data = await parseJsonBody(c, insertEnrichmentProgramSchema.omit({ cruiseId: true }));
+        const row = await cruisesService.createEnrichmentProgram(c.get("db"), {
+            ...data,
+            cruiseId: parsed.id,
+        });
+        return c.json({ data: row }, 201);
+    })
+        .put("/:key/enrichment/bulk", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "external")
+            return c.json({ error: "external_cruise_read_only" }, 409);
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        const payload = await parseJsonBody(c, replaceEnrichmentProgramsSchema.omit({ cruiseId: true }));
+        const rows = await cruisesService.replaceEnrichmentPrograms(c.get("db"), {
+            cruiseId: parsed.id,
+            programs: payload.programs,
+        });
+        return c.json({ data: rows });
+    });
+}

package/dist/routes-env.d.ts

@@ -0,0 +1,13 @@
+import type { SourceAdapterRegistry } from "@voyant-travel/catalog/booking-engine";
+import type { EventBus } from "@voyant-travel/core";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+export type CruiseRoutesEnv = {
+    Variables: {
+        db: PostgresJsDatabase;
+        userId?: string;
+        eventBus?: EventBus;
+        /** Catalog source-adapter registry used by external cruise content routes. */
+        sourceAdapterRegistry?: SourceAdapterRegistry;
+    };
+};
+//# sourceMappingURL=routes-env.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"routes-env.d.ts","sourceRoot":"","sources":["../src/routes-env.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAA;AAClF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,QAAQ,CAAC,EAAE,QAAQ,CAAA;QACnB,8EAA8E;QAC9E,qBAAqB,CAAC,EAAE,qBAAqB,CAAA;KAC9C,CAAA;CACF,CAAA"}

package/dist/routes-env.js

@@ -0,0 +1 @@
+export {};

package/dist/routes-keying.d.ts

@@ -0,0 +1,28 @@
+import type { Context } from "hono";
+import type { CruiseAdapter, SourceRef } from "./adapters/index.js";
+import { type ParsedKey } from "./lib/key.js";
+import type { CruiseContentScope } from "./service-content.js";
+export declare const adapterNotRegistered: (provider: string) => {
+    error: string;
+    detail: string;
+};
+export declare const invalidKey: (raw: string) => {
+    error: string;
+    detail: string;
+};
+export declare function resolveExternal(parsed: Extract<ParsedKey, {
+    kind: "external";
+}>): {
+    adapter: CruiseAdapter;
+    sourceRef: SourceRef;
+} | null;
+export declare function makeExternalKey(adapter: CruiseAdapter, ref: SourceRef): string;
+export declare const registryNotConfigured: () => {
+    error: string;
+    detail: string;
+};
+export declare function entityIdFromExternal(parsed: Extract<ParsedKey, {
+    kind: "external";
+}>): string;
+export declare function readContentScope(c: Context): CruiseContentScope;
+//# sourceMappingURL=routes-keying.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"routes-keying.d.ts","sourceRoot":"","sources":["../src/routes-keying.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAEnE,OAAO,EAGL,KAAK,SAAS,EAEf,MAAM,cAAc,CAAA;AACrB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAE9D,eAAO,MAAM,oBAAoB,GAAI,UAAU,MAAM;;;CAMnD,CAAA;AAEF,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM;;;CAGpC,CAAA;AAEF,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,GAAG;IACjF,OAAO,EAAE,aAAa,CAAA;IACtB,SAAS,EAAE,SAAS,CAAA;CACrB,GAAG,IAAI,CAIP;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,EAAE,SAAS,GAAG,MAAM,CAE9E;AAED,eAAO,MAAM,qBAAqB;;;CAIhC,CAAA;AAEF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,GAAG,MAAM,CAE7F;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,kBAAkB,CAiB/D"}

package/dist/routes-keying.js

@@ -0,0 +1,70 @@
+import { resolveCruiseAdapter } from "./adapters/registry.js";
+import { encodeSourceRef, makeExternalSourceKey, sourceRefFromExternalKeyRef, } from "./lib/key.js";
+export const adapterNotRegistered = (provider) => ({
+    error: "adapter_not_registered",
+    detail: "No CruiseAdapter registered for source provider '" +
+        provider +
+        "'. Register one at app startup via registerCruiseAdapter() - see docs/architecture/cruises-module.md section 10.",
+});
+export const invalidKey = (raw) => ({
+    error: "invalid_key",
+    detail: `Unrecognized cruise key: ${raw}`,
+});
+export function resolveExternal(parsed) {
+    const adapter = resolveCruiseAdapter(parsed.provider);
+    if (!adapter)
+        return null;
+    return { adapter, sourceRef: sourceRefFromExternalKeyRef(parsed.ref) };
+}
+export function makeExternalKey(adapter, ref) {
+    return makeExternalSourceKey(adapter.name, ref);
+}
+export const registryNotConfigured = () => ({
+    error: "registry_not_configured",
+    detail: "Cruise external detail/refresh dispatches through the catalog SourceAdapterRegistry. Inject one via Hono middleware: c.set('sourceAdapterRegistry', registry). See cruiseAdapterToSourceAdapter() in @voyant-travel/cruises/adapters.",
+});
+export function entityIdFromExternal(parsed) {
+    return `crus_${encodeSourceRef(sourceRefFromExternalKeyRef(parsed.ref))}`;
+}
+export function readContentScope(c) {
+    const localeParams = c.req.queries("locale") ?? c.req.queries("locales") ?? [];
+    const headerLocale = c.req.header("accept-language");
+    const acceptLanguageList = headerLocale ? parseAcceptLanguageHeader(headerLocale) : [];
+    const preferredLocales = localeParams.length > 0
+        ? localeParams
+        : acceptLanguageList.length > 0
+            ? acceptLanguageList
+            : ["en-GB"];
+    const acceptMt = c.req.query("accept_mt");
+    return {
+        preferredLocales,
+        market: c.req.query("market") ?? undefined,
+        currency: c.req.query("currency") ?? undefined,
+        acceptMachineTranslated: acceptMt != null ? acceptMt !== "false" && acceptMt !== "0" : true,
+    };
+}
+function parseAcceptLanguageHeader(header) {
+    const parts = header.split(",");
+    const ranked = [];
+    for (let i = 0; i < parts.length; i += 1) {
+        const part = parts[i].trim();
+        if (!part)
+            continue;
+        const [tagRaw, ...params] = part.split(";");
+        const tag = tagRaw.trim();
+        if (!tag || tag === "*")
+            continue;
+        let q = 1;
+        for (const p of params) {
+            const [k, v] = p.split("=").map((s) => s.trim());
+            if (k === "q" && v) {
+                const parsed = Number.parseFloat(v);
+                if (Number.isFinite(parsed))
+                    q = parsed;
+            }
+        }
+        ranked.push({ tag, q, idx: i });
+    }
+    ranked.sort((a, b) => b.q - a.q || a.idx - b.idx);
+    return ranked.map((r) => r.tag);
+}