@voyant-travel/cruises 0.118.2

package/dist/booking-extension.d.ts.map

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

package/dist/booking-extension.js

@@ -0,0 +1,342 @@
+import { typeIdRef } from "@voyant-travel/db/lib/typeid-column";
+import { parseJsonBody } from "@voyant-travel/hono";
+import { eq } from "drizzle-orm";
+import { char, index, jsonb, numeric, pgEnum, pgTable, smallint, text, timestamp, } from "drizzle-orm/pg-core";
+import { Hono } from "hono";
+import { z } from "zod";
+import { cruiseSourceEnum, priceFareVariantEnum } from "./schema-shared.js";
+// ---------- enums ----------
+export const cruiseBookingModeEnum = pgEnum("cruise_booking_mode", ["inquiry", "reserve"]);
+/**
+ * Air-arrangement choice on a cruise booking. Per
+ * booking-journey-architecture §7. The cruise booking carries the
+ * intent; the flight booking line itself lives in the flights
+ * vertical (or with the customer when "independent").
+ */
+export const cruiseAirArrangementEnum = pgEnum("cruise_air_arrangement", [
+    "cruise_line",
+    "independent",
+    "none",
+]);
+// ---------- schemas ----------
+export const bookingCruiseDetails = pgTable("booking_cruise_details", {
+    bookingId: text("booking_id").primaryKey(),
+    // Provenance — 'local' bookings reference local sailing/cabin rows;
+    // 'external' bookings carry a sourceRef back to the upstream adapter
+    // and have nullable local FK columns.
+    source: cruiseSourceEnum("source").notNull().default("local"),
+    sourceProvider: text("source_provider"),
+    sourceRef: jsonb("source_ref").$type(),
+    sailingId: typeIdRef("sailing_id"),
+    cabinCategoryId: typeIdRef("cabin_category_id"),
+    cabinId: typeIdRef("cabin_id"),
+    // Display / search hints — populated for both local and external so the UI
+    // can render booking history without resolving the sailing every time.
+    sailingDisplayName: text("sailing_display_name"),
+    cabinDisplayName: text("cabin_display_name"),
+    occupancy: smallint("occupancy").notNull(),
+    fareCode: text("fare_code"),
+    fareVariant: priceFareVariantEnum("fare_variant").notNull().default("cruise_only"),
+    mode: cruiseBookingModeEnum("mode").notNull().default("inquiry"),
+    quotedPricePerPerson: numeric("quoted_price_per_person", { precision: 12, scale: 2 }).notNull(),
+    quotedTotalForCabin: numeric("quoted_total_for_cabin", { precision: 12, scale: 2 }).notNull(),
+    quotedCurrency: char("quoted_currency", { length: 3 }).notNull(),
+    quotedComponentsJson: jsonb("quoted_components_json").$type().default([]),
+    bookingTermsSnapshotJson: jsonb("booking_terms_snapshot_json").$type(),
+    passengerCompositionSnapshotJson: jsonb("passenger_composition_snapshot_json").$type(),
+    connectorBookingRef: text("connector_booking_ref"),
+    connectorStatus: text("connector_status"),
+    /**
+     * Air-arrangement choice carried alongside the cruise. Per
+     * booking-journey-architecture §7 — cruises take the booking
+     * line for the cabin; the actual flight booking lives in the
+     * flights vertical and is the multi-line composer's concern.
+     * This column captures the customer's intent so ops can route
+     * follow-up:
+     *   - "cruise_line"  — operator must arrange flights with the
+     *                      cruise line's air desk.
+     *   - "independent"  — customer is booking flights themselves
+     *                      (or via a separate flight-booking line
+     *                      orchestrated by the composer).
+     *   - "none"         — no flights needed (regional / drive-to).
+     *   - null           — choice not collected (legacy bookings).
+     */
+    airArrangement: cruiseAirArrangementEnum("air_arrangement"),
+    /** Free-form pointer to the linked flight booking when the
+     *  composer ties cabin + flight lines together. Plain text per
+     *  schema-discipline (cross-domain refs go through links). */
+    linkedFlightBookingId: text("linked_flight_booking_id"),
+    notes: text("notes"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (t) => [
+    index("idx_bcd_source").on(t.source),
+    index("idx_bcd_sailing").on(t.sailingId),
+    index("idx_bcd_cabin_category").on(t.cabinCategoryId),
+    index("idx_bcd_connector_ref").on(t.connectorBookingRef),
+    index("idx_bcd_provider").on(t.sourceProvider),
+    index("idx_bcd_air_arrangement").on(t.airArrangement),
+]);
+export const bookingGroupCruiseDetails = pgTable("booking_group_cruise_details", {
+    bookingGroupId: text("booking_group_id").primaryKey(),
+    source: cruiseSourceEnum("source").notNull().default("local"),
+    sourceProvider: text("source_provider"),
+    sourceRef: jsonb("source_ref").$type(),
+    sailingId: typeIdRef("sailing_id"),
+    sailingDisplayName: text("sailing_display_name"),
+    cabinCount: smallint("cabin_count").notNull(),
+    totalQuotedAmount: numeric("total_quoted_amount", { precision: 12, scale: 2 }).notNull(),
+    quotedCurrency: char("quoted_currency", { length: 3 }).notNull(),
+    connectorBookingRef: text("connector_booking_ref"),
+    bookingTermsSnapshotJson: jsonb("booking_terms_snapshot_json").$type(),
+    notes: text("notes"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (t) => [
+    index("idx_bgcd_source").on(t.source),
+    index("idx_bgcd_sailing").on(t.sailingId),
+    index("idx_bgcd_connector_ref").on(t.connectorBookingRef),
+    index("idx_bgcd_provider").on(t.sourceProvider),
+]);
+// ---------- validation ----------
+const sourceRefValueSchema = z
+    .object({
+    connectionId: z.string().optional(),
+    externalId: z.string(),
+})
+    .catchall(z.unknown());
+const passengerCompositionValueSchema = z
+    .object({
+    adults: z.number().int().min(0),
+    children: z.number().int().min(0).optional(),
+    infants: z.number().int().min(0).optional(),
+    seniors: z.number().int().min(0).optional(),
+    childAges: z.array(z.number().int().min(0).max(17)).optional(),
+})
+    .catchall(z.unknown());
+const cruiseDetailUpsertSchema = z
+    .object({
+    source: z.enum(["local", "external"]).default("local"),
+    sourceProvider: z.string().optional().nullable(),
+    sourceRef: sourceRefValueSchema.optional().nullable(),
+    sailingId: z.string().optional().nullable(),
+    cabinCategoryId: z.string().optional().nullable(),
+    cabinId: z.string().optional().nullable(),
+    sailingDisplayName: z.string().optional().nullable(),
+    cabinDisplayName: z.string().optional().nullable(),
+    occupancy: z.number().int().min(1).max(8),
+    fareCode: z.string().optional().nullable(),
+    fareVariant: z.enum(["cruise_only", "air_inclusive"]).default("cruise_only"),
+    mode: z.enum(["inquiry", "reserve"]).default("inquiry"),
+    quotedPricePerPerson: z.string().regex(/^-?\d+(\.\d{1,2})?$/),
+    quotedTotalForCabin: z.string().regex(/^-?\d+(\.\d{1,2})?$/),
+    quotedCurrency: z.string().length(3),
+    quotedComponentsJson: z.array(z.unknown()).optional().nullable(),
+    bookingTermsSnapshotJson: z.record(z.string(), z.unknown()).optional().nullable(),
+    passengerCompositionSnapshotJson: passengerCompositionValueSchema.optional().nullable(),
+    connectorBookingRef: z.string().optional().nullable(),
+    connectorStatus: z.string().optional().nullable(),
+    airArrangement: z.enum(["cruise_line", "independent", "none"]).optional().nullable(),
+    linkedFlightBookingId: z.string().optional().nullable(),
+    notes: z.string().optional().nullable(),
+})
+    .superRefine((value, ctx) => {
+    if (value.source === "local") {
+        if (!value.sailingId)
+            ctx.addIssue({
+                code: "custom",
+                path: ["sailingId"],
+                message: "sailingId is required when source='local'",
+            });
+        if (!value.cabinCategoryId)
+            ctx.addIssue({
+                code: "custom",
+                path: ["cabinCategoryId"],
+                message: "cabinCategoryId is required when source='local'",
+            });
+    }
+    else {
+        if (!value.sourceProvider)
+            ctx.addIssue({
+                code: "custom",
+                path: ["sourceProvider"],
+                message: "sourceProvider is required when source='external'",
+            });
+        if (!value.sourceRef)
+            ctx.addIssue({
+                code: "custom",
+                path: ["sourceRef"],
+                message: "sourceRef is required when source='external'",
+            });
+    }
+});
+const groupCruiseDetailUpsertSchema = z
+    .object({
+    source: z.enum(["local", "external"]).default("local"),
+    sourceProvider: z.string().optional().nullable(),
+    sourceRef: sourceRefValueSchema.optional().nullable(),
+    sailingId: z.string().optional().nullable(),
+    sailingDisplayName: z.string().optional().nullable(),
+    cabinCount: z.number().int().min(1).max(20),
+    totalQuotedAmount: z.string().regex(/^-?\d+(\.\d{1,2})?$/),
+    quotedCurrency: z.string().length(3),
+    connectorBookingRef: z.string().optional().nullable(),
+    bookingTermsSnapshotJson: z.record(z.string(), z.unknown()).optional().nullable(),
+    notes: z.string().optional().nullable(),
+})
+    .superRefine((value, ctx) => {
+    if (value.source === "local" && !value.sailingId) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["sailingId"],
+            message: "sailingId is required when source='local'",
+        });
+    }
+    if (value.source === "external") {
+        if (!value.sourceProvider)
+            ctx.addIssue({
+                code: "custom",
+                path: ["sourceProvider"],
+                message: "sourceProvider is required when source='external'",
+            });
+        if (!value.sourceRef)
+            ctx.addIssue({
+                code: "custom",
+                path: ["sourceRef"],
+                message: "sourceRef is required when source='external'",
+            });
+    }
+});
+// ---------- services ----------
+export const bookingCruiseDetailsService = {
+    async get(db, bookingId) {
+        const [row] = await db
+            .select()
+            .from(bookingCruiseDetails)
+            .where(eq(bookingCruiseDetails.bookingId, bookingId))
+            .limit(1);
+        return row ?? null;
+    },
+    async upsert(db, bookingId, data) {
+        const [existing] = await db
+            .select()
+            .from(bookingCruiseDetails)
+            .where(eq(bookingCruiseDetails.bookingId, bookingId))
+            .limit(1);
+        const payload = {
+            ...data,
+            bookingId,
+            quotedComponentsJson: (data.quotedComponentsJson ?? []),
+        };
+        if (existing) {
+            const [row] = await db
+                .update(bookingCruiseDetails)
+                .set({ ...payload, updatedAt: new Date() })
+                .where(eq(bookingCruiseDetails.bookingId, bookingId))
+                .returning();
+            if (!row)
+                throw new Error("Failed to update booking cruise details");
+            return row;
+        }
+        const [row] = await db.insert(bookingCruiseDetails).values(payload).returning();
+        if (!row)
+            throw new Error("Failed to insert booking cruise details");
+        return row;
+    },
+    async remove(db, bookingId) {
+        const result = await db
+            .delete(bookingCruiseDetails)
+            .where(eq(bookingCruiseDetails.bookingId, bookingId))
+            .returning({ id: bookingCruiseDetails.bookingId });
+        return result.length > 0;
+    },
+};
+export const bookingGroupCruiseDetailsService = {
+    async get(db, bookingGroupId) {
+        const [row] = await db
+            .select()
+            .from(bookingGroupCruiseDetails)
+            .where(eq(bookingGroupCruiseDetails.bookingGroupId, bookingGroupId))
+            .limit(1);
+        return row ?? null;
+    },
+    async upsert(db, bookingGroupId, data) {
+        const [existing] = await db
+            .select()
+            .from(bookingGroupCruiseDetails)
+            .where(eq(bookingGroupCruiseDetails.bookingGroupId, bookingGroupId))
+            .limit(1);
+        const payload = { ...data, bookingGroupId };
+        if (existing) {
+            const [row] = await db
+                .update(bookingGroupCruiseDetails)
+                .set({ ...payload, updatedAt: new Date() })
+                .where(eq(bookingGroupCruiseDetails.bookingGroupId, bookingGroupId))
+                .returning();
+            if (!row)
+                throw new Error("Failed to update booking group cruise details");
+            return row;
+        }
+        const [row] = await db.insert(bookingGroupCruiseDetails).values(payload).returning();
+        if (!row)
+            throw new Error("Failed to insert booking group cruise details");
+        return row;
+    },
+    async remove(db, bookingGroupId) {
+        const result = await db
+            .delete(bookingGroupCruiseDetails)
+            .where(eq(bookingGroupCruiseDetails.bookingGroupId, bookingGroupId))
+            .returning({ id: bookingGroupCruiseDetails.bookingGroupId });
+        return result.length > 0;
+    },
+};
+export const cruisesBookingExtensionRoutes = new Hono()
+    .get("/:bookingId/cruise-details", async (c) => {
+    const bookingId = c.req.param("bookingId");
+    const row = await bookingCruiseDetailsService.get(c.get("db"), bookingId);
+    if (!row)
+        return c.json({ error: "not_found" }, 404);
+    return c.json({ data: row });
+})
+    .put("/:bookingId/cruise-details", async (c) => {
+    const bookingId = c.req.param("bookingId");
+    const data = await parseJsonBody(c, cruiseDetailUpsertSchema);
+    const row = await bookingCruiseDetailsService.upsert(c.get("db"), bookingId, data);
+    return c.json({ data: row });
+})
+    .delete("/:bookingId/cruise-details", async (c) => {
+    const bookingId = c.req.param("bookingId");
+    const ok = await bookingCruiseDetailsService.remove(c.get("db"), bookingId);
+    if (!ok)
+        return c.json({ error: "not_found" }, 404);
+    return c.body(null, 204);
+})
+    .get("/groups/:groupId/cruise-details", async (c) => {
+    const groupId = c.req.param("groupId");
+    const row = await bookingGroupCruiseDetailsService.get(c.get("db"), groupId);
+    if (!row)
+        return c.json({ error: "not_found" }, 404);
+    return c.json({ data: row });
+})
+    .put("/groups/:groupId/cruise-details", async (c) => {
+    const groupId = c.req.param("groupId");
+    const data = await parseJsonBody(c, groupCruiseDetailUpsertSchema);
+    const row = await bookingGroupCruiseDetailsService.upsert(c.get("db"), groupId, data);
+    return c.json({ data: row });
+})
+    .delete("/groups/:groupId/cruise-details", async (c) => {
+    const groupId = c.req.param("groupId");
+    const ok = await bookingGroupCruiseDetailsService.remove(c.get("db"), groupId);
+    if (!ok)
+        return c.json({ error: "not_found" }, 404);
+    return c.body(null, 204);
+});
+// ---------- HonoExtension export ----------
+const cruisesBookingExtensionDef = {
+    name: "cruises-booking",
+    module: "bookings",
+};
+export const cruisesBookingExtension = {
+    extension: cruisesBookingExtensionDef,
+    adminRoutes: cruisesBookingExtensionRoutes,
+};

package/dist/cabin-features.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Cabin facet vocabularies now live in `@voyant-travel/cruises-contracts` so
+ * external adapter authors can validate cabin facets without the cruises
+ * runtime. Re-exported here to keep the existing `@voyant-travel/cruises`
+ * import path stable for the runtime catalog/schema/validation modules.
+ */
+export * from "@voyant-travel/cruises-contracts/cabin-features";
+//# sourceMappingURL=cabin-features.d.ts.map

package/dist/cabin-features.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cabin-features.d.ts","sourceRoot":"","sources":["../src/cabin-features.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,iDAAiD,CAAA"}

package/dist/cabin-features.js

@@ -0,0 +1,7 @@
+/**
+ * Cabin facet vocabularies now live in `@voyant-travel/cruises-contracts` so
+ * external adapter authors can validate cabin facets without the cruises
+ * runtime. Re-exported here to keep the existing `@voyant-travel/cruises`
+ * import path stable for the runtime catalog/schema/validation modules.
+ */
+export * from "@voyant-travel/cruises-contracts/cabin-features";

package/dist/catalog-policy-cabins.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Catalog plane field policies for cruise cabin/deck facets.
+ *
+ * Cabin categories and decks are promoted child entities under catalog
+ * architecture §6.2: they have an independent query surface and the booking
+ * captures the selected cabin category. The root cruise search document also
+ * receives denormalized facet arrays so storefront browse can answer
+ * "show cruises with balcony cabins", "king bed", or "accessible shower"
+ * without traversing the ship graph at read time.
+ */
+import { type FieldPolicyInput } from "@voyant-travel/catalog/contract";
+export declare const CRUISE_CABIN_FACETS_FIELD_POLICY: FieldPolicyInput[];
+export declare const CRUISE_CABIN_CATEGORY_FIELD_POLICY: FieldPolicyInput[];
+export declare const CRUISE_DECK_FIELD_POLICY: FieldPolicyInput[];
+export declare const cruiseCabinFacetsCatalogPolicy: import("@voyant-travel/catalog").FieldPolicy[];
+export declare const cruiseCabinCategoryCatalogPolicy: import("@voyant-travel/catalog").FieldPolicy[];
+export declare const cruiseDeckCatalogPolicy: import("@voyant-travel/catalog").FieldPolicy[];
+//# sourceMappingURL=catalog-policy-cabins.d.ts.map

package/dist/catalog-policy-cabins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-policy-cabins.d.ts","sourceRoot":"","sources":["../src/catalog-policy-cabins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AAgD1F,eAAO,MAAM,gCAAgC,EAAE,gBAAgB,EAY9D,CAAA;AAED,eAAO,MAAM,kCAAkC,EAAE,gBAAgB,EAmBhE,CAAA;AAED,eAAO,MAAM,wBAAwB,EAAE,gBAAgB,EAOtD,CAAA;AAED,eAAO,MAAM,8BAA8B,gDAAsD,CAAA;AACjG,eAAO,MAAM,gCAAgC,gDAE5C,CAAA;AACD,eAAO,MAAM,uBAAuB,gDAA8C,CAAA"}

package/dist/catalog-policy-cabins.js

@@ -0,0 +1,96 @@
+/**
+ * Catalog plane field policies for cruise cabin/deck facets.
+ *
+ * Cabin categories and decks are promoted child entities under catalog
+ * architecture §6.2: they have an independent query surface and the booking
+ * captures the selected cabin category. The root cruise search document also
+ * receives denormalized facet arrays so storefront browse can answer
+ * "show cruises with balcony cabins", "king bed", or "accessible shower"
+ * without traversing the ship graph at read time.
+ */
+import { defineFieldPolicy } from "@voyant-travel/catalog/contract";
+const CUSTOMER_FACING = ["staff", "customer", "partner"];
+const managedFacet = (path) => ({
+    path,
+    class: "structural",
+    merge: "source-only",
+    drift: "low",
+    reindex: "facet-affecting",
+    snapshot: "on-book",
+    query: "indexed-column",
+    localized: false,
+    visibility: [...CUSTOMER_FACING],
+    editRole: "none",
+    overrideFriction: "none",
+    sourceFreshness: "sync",
+});
+const managedIndexed = (path) => ({
+    ...managedFacet(path),
+    class: "managed",
+    reindex: "entry",
+});
+const staffTimestamp = (path) => ({
+    ...managedFacet(path),
+    class: "managed",
+    reindex: "none",
+    visibility: ["staff"],
+    sourceFreshness: "static",
+});
+const merchandisableText = (path) => ({
+    path,
+    class: "merchandisable",
+    merge: "replace",
+    drift: "low",
+    reindex: "entry-locale",
+    snapshot: "on-book",
+    query: "indexed-column",
+    localized: true,
+    visibility: [...CUSTOMER_FACING],
+    editRole: "marketing",
+    overrideFriction: "none",
+    sourceFreshness: "sync",
+});
+export const CRUISE_CABIN_FACETS_FIELD_POLICY = [
+    managedFacet("cabinCategoryIds[]"),
+    managedFacet("cabinCategoryCodes[]"),
+    managedFacet("cabinGradeCodes[]"),
+    managedFacet("cabinRoomTypes[]"),
+    managedFacet("cabinFeatureCodes[]"),
+    managedFacet("cabinBedConfigurations[]"),
+    managedFacet("cabinAccessibilityFeatures[]"),
+    managedFacet("cabinViewTypes[]"),
+    managedFacet("deckIds[]"),
+    managedFacet("deckNames[]"),
+    managedFacet("deckLevels[]"),
+];
+export const CRUISE_CABIN_CATEGORY_FIELD_POLICY = [
+    managedIndexed("id"),
+    managedFacet("shipId"),
+    managedFacet("code"),
+    merchandisableText("name"),
+    merchandisableText("description"),
+    managedFacet("roomType"),
+    managedFacet("minOccupancy"),
+    managedFacet("maxOccupancy"),
+    managedFacet("squareFeet"),
+    managedFacet("wheelchairAccessible"),
+    managedFacet("featureCodes[]"),
+    managedFacet("bedConfigurations[]"),
+    managedFacet("accessibilityFeatures[]"),
+    managedFacet("viewType"),
+    merchandisableText("amenities[]"),
+    managedFacet("gradeCodes[]"),
+    staffTimestamp("createdAt"),
+    staffTimestamp("updatedAt"),
+];
+export const CRUISE_DECK_FIELD_POLICY = [
+    managedIndexed("id"),
+    managedFacet("shipId"),
+    merchandisableText("name"),
+    managedFacet("level"),
+    staffTimestamp("createdAt"),
+    staffTimestamp("updatedAt"),
+];
+export const cruiseCabinFacetsCatalogPolicy = defineFieldPolicy(CRUISE_CABIN_FACETS_FIELD_POLICY);
+export const cruiseCabinCategoryCatalogPolicy = defineFieldPolicy(CRUISE_CABIN_CATEGORY_FIELD_POLICY);
+export const cruiseDeckCatalogPolicy = defineFieldPolicy(CRUISE_DECK_FIELD_POLICY);

package/dist/catalog-policy-core.d.ts

@@ -0,0 +1,3 @@
+import type { FieldPolicyInput } from "@voyant-travel/catalog/contract";
+export declare const CRUISE_CORE_FIELD_POLICY: FieldPolicyInput[];
+//# sourceMappingURL=catalog-policy-core.d.ts.map

package/dist/catalog-policy-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-policy-core.d.ts","sourceRoot":"","sources":["../src/catalog-policy-core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AAEvE,eAAO,MAAM,wBAAwB,EAAE,gBAAgB,EAwPtD,CAAA"}