@voyant-travel/cruises 0.118.2

package/dist/service-core.js

@@ -0,0 +1,257 @@
+import { and, asc, count, desc, eq, ilike, or, sql } from "drizzle-orm";
+import { CRUISE_CREATED_EVENT, CRUISE_DELETED_EVENT, CRUISE_UPDATED_EVENT, emitCruiseLifecycleEvent, } from "./events.js";
+import { cruiseSailings, cruises, cruiseVoyageGroupSegments, cruiseVoyageGroups, } from "./schema-core.js";
+import { cruiseDays } from "./schema-itinerary.js";
+import { cruisePrices } from "./schema-pricing.js";
+import { paginate, reprojectIfPossible, setUpdated, } from "./service-shared.js";
+export const cruiseCoreService = {
+    async listVoyageGroups(db, query) {
+        const conditions = [];
+        if (query.groupKind)
+            conditions.push(eq(cruiseVoyageGroups.groupKind, query.groupKind));
+        if (query.status)
+            conditions.push(eq(cruiseVoyageGroups.status, query.status));
+        if (query.lineSupplierId) {
+            conditions.push(eq(cruiseVoyageGroups.lineSupplierId, query.lineSupplierId));
+        }
+        if (query.region) {
+            conditions.push(
+            // agent-quality: raw-sql reviewed -- owner: cruises; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            sql `${cruiseVoyageGroups.regions} @> ${JSON.stringify([query.region])}::jsonb`);
+        }
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(cruiseVoyageGroups.name, term), ilike(cruiseVoyageGroups.description, term)));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const { limit, offset } = paginate(query);
+        const [rows, totalRows] = await Promise.all([
+            db
+                .select()
+                .from(cruiseVoyageGroups)
+                .where(where)
+                .orderBy(desc(cruiseVoyageGroups.createdAt))
+                .limit(limit)
+                .offset(offset),
+            db.select({ value: count() }).from(cruiseVoyageGroups).where(where),
+        ]);
+        return { data: rows, total: totalRows[0]?.value ?? 0, limit, offset };
+    },
+    async getVoyageGroupById(db, id, options = {}) {
+        const [row] = await db
+            .select()
+            .from(cruiseVoyageGroups)
+            .where(eq(cruiseVoyageGroups.id, id))
+            .limit(1);
+        if (!row)
+            return null;
+        const out = { ...row };
+        if (options.withSegments) {
+            out.segments = await db
+                .select()
+                .from(cruiseVoyageGroupSegments)
+                .where(eq(cruiseVoyageGroupSegments.voyageGroupId, id))
+                .orderBy(asc(cruiseVoyageGroupSegments.sortOrder));
+        }
+        return out;
+    },
+    async createVoyageGroup(db, data) {
+        const [row] = await db
+            .insert(cruiseVoyageGroups)
+            .values(data)
+            .returning();
+        if (!row)
+            throw new Error("Failed to create voyage group");
+        return row;
+    },
+    async updateVoyageGroup(db, id, data) {
+        const [row] = await db
+            .update(cruiseVoyageGroups)
+            .set({ ...data, ...setUpdated })
+            .where(eq(cruiseVoyageGroups.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async archiveVoyageGroup(db, id) {
+        const [row] = await db
+            .update(cruiseVoyageGroups)
+            .set({ status: "archived", ...setUpdated })
+            .where(eq(cruiseVoyageGroups.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async listVoyageGroupSegments(db, query) {
+        const conditions = [];
+        if (query.voyageGroupId) {
+            conditions.push(eq(cruiseVoyageGroupSegments.voyageGroupId, query.voyageGroupId));
+        }
+        if (query.cruiseId)
+            conditions.push(eq(cruiseVoyageGroupSegments.cruiseId, query.cruiseId));
+        if (query.sailingId)
+            conditions.push(eq(cruiseVoyageGroupSegments.sailingId, query.sailingId));
+        if (query.segmentKind) {
+            conditions.push(eq(cruiseVoyageGroupSegments.segmentKind, query.segmentKind));
+        }
+        if (query.segmentRole) {
+            conditions.push(eq(cruiseVoyageGroupSegments.segmentRole, query.segmentRole));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const { limit, offset } = paginate(query);
+        const [rows, totalRows] = await Promise.all([
+            db
+                .select()
+                .from(cruiseVoyageGroupSegments)
+                .where(where)
+                .orderBy(asc(cruiseVoyageGroupSegments.voyageGroupId), asc(cruiseVoyageGroupSegments.sortOrder))
+                .limit(limit)
+                .offset(offset),
+            db.select({ value: count() }).from(cruiseVoyageGroupSegments).where(where),
+        ]);
+        return { data: rows, total: totalRows[0]?.value ?? 0, limit, offset };
+    },
+    async createVoyageGroupSegment(db, data) {
+        const [row] = await db
+            .insert(cruiseVoyageGroupSegments)
+            .values(data)
+            .returning();
+        if (!row)
+            throw new Error("Failed to create voyage group segment");
+        return row;
+    },
+    async updateVoyageGroupSegment(db, id, data) {
+        const [row] = await db
+            .update(cruiseVoyageGroupSegments)
+            .set({ ...data, ...setUpdated })
+            .where(eq(cruiseVoyageGroupSegments.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteVoyageGroupSegment(db, id) {
+        const rows = await db
+            .delete(cruiseVoyageGroupSegments)
+            .where(eq(cruiseVoyageGroupSegments.id, id))
+            .returning({ id: cruiseVoyageGroupSegments.id });
+        return rows.length > 0;
+    },
+    async listCruises(db, query) {
+        const conditions = [];
+        if (query.cruiseType)
+            conditions.push(eq(cruises.cruiseType, query.cruiseType));
+        if (query.status)
+            conditions.push(eq(cruises.status, query.status));
+        if (query.lineSupplierId)
+            conditions.push(eq(cruises.lineSupplierId, query.lineSupplierId));
+        if (query.region) {
+            // agent-quality: raw-sql reviewed -- owner: cruises; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            conditions.push(sql `${cruises.regions} @> ${JSON.stringify([query.region])}::jsonb`);
+        }
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(cruises.name, term), ilike(cruises.description, term)));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const { limit, offset } = paginate(query);
+        const [rows, totalRows] = await Promise.all([
+            db
+                .select()
+                .from(cruises)
+                .where(where)
+                .orderBy(desc(cruises.createdAt))
+                .limit(limit)
+                .offset(offset),
+            db.select({ value: count() }).from(cruises).where(where),
+        ]);
+        return { data: rows, total: totalRows[0]?.value ?? 0, limit, offset };
+    },
+    async getCruiseById(db, id, options = {}) {
+        const [row] = await db.select().from(cruises).where(eq(cruises.id, id)).limit(1);
+        if (!row)
+            return null;
+        const out = { ...row };
+        if (options.withSailings) {
+            out.sailings = await db
+                .select()
+                .from(cruiseSailings)
+                .where(eq(cruiseSailings.cruiseId, id))
+                .orderBy(asc(cruiseSailings.departureDate));
+        }
+        if (options.withDays) {
+            out.days = await db
+                .select()
+                .from(cruiseDays)
+                .where(eq(cruiseDays.cruiseId, id))
+                .orderBy(asc(cruiseDays.dayNumber));
+        }
+        return out;
+    },
+    async createCruise(db, data, runtime = {}) {
+        const [row] = await db
+            .insert(cruises)
+            .values(data)
+            .returning();
+        if (!row)
+            throw new Error("Failed to create cruise");
+        await reprojectIfPossible(db, row.id);
+        await emitCruiseLifecycleEvent(runtime.eventBus, CRUISE_CREATED_EVENT, { id: row.id });
+        return row;
+    },
+    async updateCruise(db, id, data, runtime = {}) {
+        const [row] = await db
+            .update(cruises)
+            .set({ ...data, ...setUpdated })
+            .where(eq(cruises.id, id))
+            .returning();
+        if (row) {
+            await reprojectIfPossible(db, row.id);
+            await emitCruiseLifecycleEvent(runtime.eventBus, CRUISE_UPDATED_EVENT, { id: row.id });
+        }
+        return row ?? null;
+    },
+    async archiveCruise(db, id, runtime = {}) {
+        const [row] = await db
+            .update(cruises)
+            .set({ status: "archived", ...setUpdated })
+            .where(eq(cruises.id, id))
+            .returning();
+        if (row) {
+            await reprojectIfPossible(db, row.id);
+            await emitCruiseLifecycleEvent(runtime.eventBus, CRUISE_DELETED_EVENT, { id: row.id });
+        }
+        return row ?? null;
+    },
+    async recomputeCruiseAggregates(db, cruiseId) {
+        // Lowest available price across all of this cruise's sailings × cabin categories × occupancies.
+        const [priceAgg] = await db
+            .select({
+            lowest: sql `MIN(${cruisePrices.pricePerPerson}::numeric)::text`,
+            currency: sql `(ARRAY_AGG(${cruisePrices.currency} ORDER BY ${cruisePrices.pricePerPerson}::numeric ASC))[1]`,
+        })
+            .from(cruisePrices)
+            .innerJoin(cruiseSailings, eq(cruisePrices.sailingId, cruiseSailings.id))
+            .where(
+        // agent-quality: raw-sql reviewed -- owner: cruises; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        and(eq(cruiseSailings.cruiseId, cruiseId), sql `${cruisePrices.availability} <> 'sold_out'`));
+        const [dateAgg] = await db
+            .select({
+            earliest: sql `MIN(${cruiseSailings.departureDate})`,
+            latest: sql `MAX(${cruiseSailings.departureDate})`,
+        })
+            .from(cruiseSailings)
+            .where(eq(cruiseSailings.cruiseId, cruiseId));
+        const [row] = await db
+            .update(cruises)
+            .set({
+            lowestPriceCached: priceAgg?.lowest ?? null,
+            lowestPriceCurrencyCached: priceAgg?.currency ?? null,
+            earliestDepartureCached: dateAgg?.earliest ?? null,
+            latestDepartureCached: dateAgg?.latest ?? null,
+            ...setUpdated,
+        })
+            .where(eq(cruises.id, cruiseId))
+            .returning();
+        if (row)
+            await reprojectIfPossible(db, row.id);
+        return row ?? null;
+    },
+    // ---------- sailings ----------
+};

package/dist/service-detach.d.ts

@@ -0,0 +1,18 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { CruiseAdapter, SourceRef } from "./adapters/index.js";
+import { type Cruise } from "./schema-core.js";
+/**
+ * One-way conversion of an external cruise into a local cruise.
+ *
+ * Fetches the cruise + ship + cabin categories + sailings (with itineraries)
+ * from the adapter and inserts them as local rows in one transaction. After
+ * detach the operator owns the data and can edit it freely; the upstream
+ * link is severed (future calls to the original external key still work
+ * upstream-side, but the local DB has its own snapshot).
+ *
+ * Returns the newly-created local cruise row.
+ */
+export declare function detachExternalCruise(db: PostgresJsDatabase, adapter: CruiseAdapter, sourceRef: SourceRef, options?: {
+    slugSuffix?: string;
+}): Promise<Cruise>;
+//# sourceMappingURL=service-detach.d.ts.map

package/dist/service-detach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-detach.d.ts","sourceRoot":"","sources":["../src/service-detach.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAEnE,OAAO,EAAE,KAAK,MAAM,EAA2B,MAAM,kBAAkB,CAAA;AAIvE;;;;;;;;;;GAUG;AACH,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,kBAAkB,EACtB,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,SAAS,EACpB,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GACpC,OAAO,CAAC,MAAM,CAAC,CAsKjB"}

package/dist/service-detach.js

@@ -0,0 +1,199 @@
+import { eq } from "drizzle-orm";
+import { cruiseCabinCategories, cruiseDecks, cruiseShips } from "./schema-cabins.js";
+import { cruiseSailings, cruises } from "./schema-core.js";
+import { cruiseSailingDays } from "./schema-itinerary.js";
+import { cruisesService } from "./service.js";
+/**
+ * One-way conversion of an external cruise into a local cruise.
+ *
+ * Fetches the cruise + ship + cabin categories + sailings (with itineraries)
+ * from the adapter and inserts them as local rows in one transaction. After
+ * detach the operator owns the data and can edit it freely; the upstream
+ * link is severed (future calls to the original external key still work
+ * upstream-side, but the local DB has its own snapshot).
+ *
+ * Returns the newly-created local cruise row.
+ */
+export async function detachExternalCruise(db, adapter, sourceRef, options = {}) {
+    const externalCruise = await adapter.fetchCruise(sourceRef);
+    if (!externalCruise) {
+        throw new Error(`Adapter '${adapter.name}' returned no cruise for ref ${sourceRef.externalId}`);
+    }
+    return db.transaction(async (tx) => {
+        let localShipId = null;
+        // 1. Snapshot ship + decks + cabin categories if the cruise references a ship.
+        if (externalCruise.defaultShipRef) {
+            const externalShip = await adapter.fetchShip(externalCruise.defaultShipRef);
+            if (externalShip) {
+                const slug = await ensureUniqueShipSlug(tx, externalShip.slug, options.slugSuffix);
+                const [shipRow] = await tx
+                    .insert(cruiseShips)
+                    .values({
+                    slug,
+                    name: externalShip.name,
+                    shipType: externalShip.shipType,
+                    capacityGuests: externalShip.capacityGuests ?? null,
+                    capacityCrew: externalShip.capacityCrew ?? null,
+                    cabinCount: externalShip.cabinCount ?? null,
+                    deckCount: externalShip.deckCount ?? null,
+                    lengthMeters: externalShip.lengthMeters ?? null,
+                    cruisingSpeedKnots: externalShip.cruisingSpeedKnots ?? null,
+                    yearBuilt: externalShip.yearBuilt ?? null,
+                    yearRefurbished: externalShip.yearRefurbished ?? null,
+                    imo: externalShip.imo ?? null,
+                    description: externalShip.description ?? null,
+                    deckPlanUrl: externalShip.deckPlanUrl ?? null,
+                    gallery: externalShip.gallery ?? [],
+                    amenities: (externalShip.amenities ?? {}),
+                    externalRefs: { [adapter.name]: externalShip.sourceRef.externalId },
+                    isActive: true,
+                })
+                    .returning();
+                if (!shipRow)
+                    throw new Error("Failed to insert detached ship");
+                localShipId = shipRow.id;
+                if (externalShip.decks) {
+                    for (const deck of externalShip.decks) {
+                        await tx.insert(cruiseDecks).values({
+                            shipId: shipRow.id,
+                            name: deck.name,
+                            level: deck.level ?? null,
+                            planImageUrl: deck.planImageUrl ?? null,
+                        });
+                    }
+                }
+                if (externalShip.categories) {
+                    for (const cat of externalShip.categories) {
+                        await tx.insert(cruiseCabinCategories).values({
+                            shipId: shipRow.id,
+                            code: cat.code,
+                            name: cat.name,
+                            roomType: cat.roomType,
+                            description: cat.description ?? null,
+                            minOccupancy: cat.minOccupancy,
+                            maxOccupancy: cat.maxOccupancy,
+                            squareFeet: cat.squareFeet ?? null,
+                            wheelchairAccessible: cat.wheelchairAccessible ?? false,
+                            amenities: cat.amenities ?? [],
+                            featureCodes: cat.featureCodes ?? [],
+                            bedConfigurations: cat.bedConfigurations ?? [],
+                            accessibilityFeatures: cat.accessibilityFeatures ?? [],
+                            viewType: cat.viewType ?? null,
+                            images: cat.images ?? [],
+                            floorplanImages: cat.floorplanImages ?? [],
+                            gradeCodes: cat.gradeCodes ?? [],
+                            externalRefs: { [adapter.name]: cat.sourceRef.externalId },
+                        });
+                    }
+                }
+            }
+        }
+        // 2. Insert the cruise row.
+        const slug = await ensureUniqueCruiseSlug(tx, externalCruise.slug, options.slugSuffix);
+        const [cruiseRow] = await tx
+            .insert(cruises)
+            .values({
+            slug,
+            name: externalCruise.name,
+            cruiseType: externalCruise.cruiseType,
+            defaultShipId: localShipId,
+            nights: externalCruise.nights,
+            embarkPortCanonicalPlaceId: externalCruise.embarkPortCanonicalPlaceId ?? null,
+            disembarkPortCanonicalPlaceId: externalCruise.disembarkPortCanonicalPlaceId ?? null,
+            description: externalCruise.description ?? null,
+            shortDescription: externalCruise.shortDescription ?? null,
+            highlights: externalCruise.highlights ?? [],
+            inclusionsHtml: externalCruise.inclusionsHtml ?? null,
+            exclusionsHtml: externalCruise.exclusionsHtml ?? null,
+            regionIds: externalCruise.regionIds ?? [],
+            waterwayIds: externalCruise.waterwayIds ?? [],
+            portIds: externalCruise.portIds ?? [],
+            countryIso: externalCruise.countryIso ?? [],
+            regions: externalCruise.regions ?? [],
+            waterways: externalCruise.waterways ?? [],
+            ports: externalCruise.ports ?? [],
+            countries: externalCruise.countries ?? [],
+            themes: externalCruise.themes ?? [],
+            heroImageUrl: externalCruise.heroImageUrl ?? null,
+            mapImageUrl: externalCruise.mapImageUrl ?? null,
+            status: externalCruise.status ?? "draft",
+            externalRefs: { [`${adapter.name}-detach-source`]: externalCruise.sourceRef.externalId },
+        })
+            .returning();
+        if (!cruiseRow)
+            throw new Error("Failed to insert detached cruise");
+        // 3. Snapshot sailings with their itinerary day overrides. v1 falls back to
+        //    the default ship for every sailing when an external sailing references
+        //    a different ship — multi-ship sailing detach can be added later.
+        if (localShipId) {
+            const sailings = await adapter.listSailingsForCruise(externalCruise.sourceRef);
+            for (const sailing of sailings) {
+                const [sailingRow] = await tx
+                    .insert(cruiseSailings)
+                    .values({
+                    cruiseId: cruiseRow.id,
+                    shipId: localShipId,
+                    departureDate: sailing.departureDate,
+                    returnDate: sailing.returnDate,
+                    embarkPortFacilityId: null,
+                    embarkPortCanonicalPlaceId: sailing.embarkPortCanonicalPlaceId ?? null,
+                    disembarkPortFacilityId: null,
+                    disembarkPortCanonicalPlaceId: sailing.disembarkPortCanonicalPlaceId ?? null,
+                    direction: sailing.direction ?? null,
+                    availabilityNote: sailing.availabilityNote ?? null,
+                    isCharter: sailing.isCharter ?? false,
+                    salesStatus: sailing.salesStatus ?? "open",
+                    externalRefs: { [`${adapter.name}-detach-source`]: sailing.sourceRef.externalId },
+                    lastSyncedAt: new Date(),
+                })
+                    .returning();
+                if (!sailingRow)
+                    throw new Error("Failed to insert detached sailing");
+                const days = await adapter.fetchSailingItinerary(sailing.sourceRef);
+                for (const day of days) {
+                    await tx.insert(cruiseSailingDays).values({
+                        sailingId: sailingRow.id,
+                        dayNumber: day.dayNumber,
+                        title: day.title ?? null,
+                        description: day.description ?? null,
+                        portFacilityId: null,
+                        portCanonicalPlaceId: day.portCanonicalPlaceId ?? null,
+                        arrivalTime: day.arrivalTime ?? null,
+                        departureTime: day.departureTime ?? null,
+                        isOvernight: day.isOvernight ?? null,
+                        isSeaDay: day.isSeaDay ?? null,
+                        isExpeditionLanding: day.isExpeditionLanding ?? null,
+                        isSkipped: false,
+                        meals: day.meals ?? null,
+                    });
+                }
+            }
+        }
+        // 4. Recompute aggregates so the new cruise reports correct cached fields.
+        await cruisesService.recomputeCruiseAggregates(tx, cruiseRow.id);
+        const [refreshed] = await tx.select().from(cruises).where(eq(cruises.id, cruiseRow.id)).limit(1);
+        return refreshed ?? cruiseRow;
+    });
+}
+async function ensureUniqueCruiseSlug(tx, baseSlug, suffix) {
+    const candidate = suffix ? `${baseSlug}-${suffix}` : baseSlug;
+    const [exists] = await tx
+        .select({ id: cruises.id })
+        .from(cruises)
+        .where(eq(cruises.slug, candidate))
+        .limit(1);
+    if (!exists)
+        return candidate;
+    return `${candidate}-${Math.random().toString(36).slice(2, 6)}`;
+}
+async function ensureUniqueShipSlug(tx, baseSlug, suffix) {
+    const candidate = suffix ? `${baseSlug}-${suffix}` : baseSlug;
+    const [exists] = await tx
+        .select({ id: cruiseShips.id })
+        .from(cruiseShips)
+        .where(eq(cruiseShips.slug, candidate))
+        .limit(1);
+    if (!exists)
+        return candidate;
+    return `${candidate}-${Math.random().toString(36).slice(2, 6)}`;
+}

package/dist/service-enrichment.d.ts

@@ -0,0 +1,11 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { CruiseEnrichmentProgram } from "./schema-content.js";
+import type { InsertEnrichmentProgram, ReplaceEnrichmentPrograms, UpdateEnrichmentProgram } from "./validation-content.js";
+export declare const cruiseEnrichmentService: {
+    listEnrichmentPrograms(db: PostgresJsDatabase, cruiseId: string): Promise<CruiseEnrichmentProgram[]>;
+    createEnrichmentProgram(db: PostgresJsDatabase, data: InsertEnrichmentProgram): Promise<CruiseEnrichmentProgram>;
+    updateEnrichmentProgram(db: PostgresJsDatabase, id: string, data: UpdateEnrichmentProgram): Promise<CruiseEnrichmentProgram | null>;
+    deleteEnrichmentProgram(db: PostgresJsDatabase, id: string): Promise<boolean>;
+    replaceEnrichmentPrograms(db: PostgresJsDatabase, payload: ReplaceEnrichmentPrograms): Promise<CruiseEnrichmentProgram[]>;
+};
+//# sourceMappingURL=service-enrichment.d.ts.map

package/dist/service-enrichment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-enrichment.d.ts","sourceRoot":"","sources":["../src/service-enrichment.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAA;AAGlE,OAAO,KAAK,EACV,uBAAuB,EACvB,yBAAyB,EACzB,uBAAuB,EACxB,MAAM,yBAAyB,CAAA;AAEhC,eAAO,MAAM,uBAAuB;+BAE5B,kBAAkB,YACZ,MAAM,GACf,OAAO,CAAC,uBAAuB,EAAE,CAAC;gCAS/B,kBAAkB,QAChB,uBAAuB,GAC5B,OAAO,CAAC,uBAAuB,CAAC;gCAO7B,kBAAkB,MAClB,MAAM,QACJ,uBAAuB,GAC5B,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC;gCASR,kBAAkB,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;kCAS7E,kBAAkB,WACb,yBAAyB,GACjC,OAAO,CAAC,uBAAuB,EAAE,CAAC;CAatC,CAAA"}

package/dist/service-enrichment.js

@@ -0,0 +1,47 @@
+import { asc, eq } from "drizzle-orm";
+import { cruiseEnrichmentPrograms } from "./schema-content.js";
+import { setUpdated } from "./service-shared.js";
+export const cruiseEnrichmentService = {
+    async listEnrichmentPrograms(db, cruiseId) {
+        return db
+            .select()
+            .from(cruiseEnrichmentPrograms)
+            .where(eq(cruiseEnrichmentPrograms.cruiseId, cruiseId))
+            .orderBy(asc(cruiseEnrichmentPrograms.sortOrder), asc(cruiseEnrichmentPrograms.name));
+    },
+    async createEnrichmentProgram(db, data) {
+        const [row] = await db.insert(cruiseEnrichmentPrograms).values(data).returning();
+        if (!row)
+            throw new Error("Failed to create enrichment program");
+        return row;
+    },
+    async updateEnrichmentProgram(db, id, data) {
+        const [row] = await db
+            .update(cruiseEnrichmentPrograms)
+            .set({ ...data, ...setUpdated })
+            .where(eq(cruiseEnrichmentPrograms.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteEnrichmentProgram(db, id) {
+        const result = await db
+            .delete(cruiseEnrichmentPrograms)
+            .where(eq(cruiseEnrichmentPrograms.id, id))
+            .returning({ id: cruiseEnrichmentPrograms.id });
+        return result.length > 0;
+    },
+    async replaceEnrichmentPrograms(db, payload) {
+        return db.transaction(async (tx) => {
+            await tx
+                .delete(cruiseEnrichmentPrograms)
+                .where(eq(cruiseEnrichmentPrograms.cruiseId, payload.cruiseId));
+            if (payload.programs.length === 0)
+                return [];
+            const inserted = await tx
+                .insert(cruiseEnrichmentPrograms)
+                .values(payload.programs.map((p) => ({ ...p, cruiseId: payload.cruiseId })))
+                .returning();
+            return inserted;
+        });
+    },
+};

package/dist/service-external-refresh.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Provider-agnostic external cruise catalog refresh.
+ *
+ * Reconciles both local browse/search projections (`cruise_search_index`) and,
+ * when catalog runtime dependencies are supplied, catalog sourced entries plus
+ * catalog search slices. The service never imports a concrete provider.
+ */
+import type { DocumentBuilder, FieldPolicyRegistry, IndexerService } from "@voyant-travel/catalog";
+import { type SourceAdapterRegistry, type SyncProgressEvent, type SyncSourcesSummary } from "@voyant-travel/catalog/booking-engine";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type ExternalAdapterRefreshResult } from "./service-search.js";
+export interface ExternalCruiseCatalogRefreshOptions {
+    db: PostgresJsDatabase;
+    /**
+     * Optional catalog source registry. Supplying it lets the refresh update
+     * `catalog_sourced_entries` and catalog search slices from cruise shims.
+     */
+    sourceAdapterRegistry?: SourceAdapterRegistry;
+    indexerService?: IndexerService;
+    fieldPolicyRegistries?: ReadonlyMap<string, FieldPolicyRegistry>;
+    wrapCatalogBuilder?: (builder: DocumentBuilder) => DocumentBuilder;
+    onCatalogProgress?: (event: SyncProgressEvent) => void;
+}
+export interface ExternalCruiseCatalogRefreshResult {
+    cruiseSearchIndex: {
+        adapters: Array<{
+            adapter: string;
+        } & ExternalAdapterRefreshResult>;
+        upserted: number;
+        removed: number;
+        errors: Array<{
+            adapter: string;
+            error: string;
+        }>;
+    };
+    catalog?: SyncSourcesSummary;
+}
+export declare function refreshExternalCruiseCatalog(options: ExternalCruiseCatalogRefreshOptions): Promise<ExternalCruiseCatalogRefreshResult>;
+//# sourceMappingURL=service-external-refresh.d.ts.map

package/dist/service-external-refresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-external-refresh.d.ts","sourceRoot":"","sources":["../src/service-external-refresh.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAClG,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EAExB,MAAM,uCAAuC,CAAA;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,EAAwB,KAAK,4BAA4B,EAAE,MAAM,qBAAqB,CAAA;AAE7F,MAAM,WAAW,mCAAmC;IAClD,EAAE,EAAE,kBAAkB,CAAA;IACtB;;;OAGG;IACH,qBAAqB,CAAC,EAAE,qBAAqB,CAAA;IAC7C,cAAc,CAAC,EAAE,cAAc,CAAA;IAC/B,qBAAqB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAA;IAChE,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,eAAe,CAAA;IAClE,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAA;CACvD;AAED,MAAM,WAAW,kCAAkC;IACjD,iBAAiB,EAAE;QACjB,QAAQ,EAAE,KAAK,CACb;YACE,OAAO,EAAE,MAAM,CAAA;SAChB,GAAG,4BAA4B,CACjC,CAAA;QACD,QAAQ,EAAE,MAAM,CAAA;QAChB,OAAO,EAAE,MAAM,CAAA;QACf,MAAM,EAAE,KAAK,CAAC;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAClD,CAAA;IACD,OAAO,CAAC,EAAE,kBAAkB,CAAA;CAC7B;AAED,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,mCAAmC,GAC3C,OAAO,CAAC,kCAAkC,CAAC,CAsC7C"}

package/dist/service-external-refresh.js

@@ -0,0 +1,47 @@
+/**
+ * Provider-agnostic external cruise catalog refresh.
+ *
+ * Reconciles both local browse/search projections (`cruise_search_index`) and,
+ * when catalog runtime dependencies are supplied, catalog sourced entries plus
+ * catalog search slices. The service never imports a concrete provider.
+ */
+import { syncSources, } from "@voyant-travel/catalog/booking-engine";
+import { listCruiseAdapters } from "./adapters/registry.js";
+import { cruisesSearchService } from "./service-search.js";
+export async function refreshExternalCruiseCatalog(options) {
+    const adapters = listCruiseAdapters();
+    const cruiseSearchIndex = {
+        adapters: [],
+        upserted: 0,
+        removed: 0,
+        errors: [],
+    };
+    for (const adapter of adapters) {
+        try {
+            const result = await cruisesSearchService.refreshExternalForAdapter(options.db, adapter);
+            cruiseSearchIndex.adapters.push({ adapter: adapter.name, ...result });
+            cruiseSearchIndex.upserted += result.upserted;
+            cruiseSearchIndex.removed += result.removed;
+        }
+        catch (err) {
+            cruiseSearchIndex.errors.push({
+                adapter: adapter.name,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    let catalog;
+    if (options.sourceAdapterRegistry && options.indexerService && options.fieldPolicyRegistries) {
+        catalog = await syncSources({
+            registry: options.sourceAdapterRegistry,
+            indexerService: options.indexerService,
+            fieldPolicyRegistries: options.fieldPolicyRegistries,
+            db: options.db,
+            verticals: ["cruises"],
+            pruneMissing: true,
+            ...(options.wrapCatalogBuilder ? { wrapBuilder: options.wrapCatalogBuilder } : {}),
+            ...(options.onCatalogProgress ? { onProgress: options.onCatalogProgress } : {}),
+        });
+    }
+    return { cruiseSearchIndex, ...(catalog ? { catalog } : {}) };
+}

package/dist/service-itinerary.d.ts

@@ -0,0 +1,22 @@
+import type { CruiseDay, CruiseSailingDay } from "./schema-itinerary.js";
+export type EffectiveItineraryDay = {
+    dayNumber: number;
+    title: string | null;
+    description: string | null;
+    portFacilityId: string | null;
+    portCanonicalPlaceId: string | null;
+    arrivalTime: string | null;
+    departureTime: string | null;
+    isOvernight: boolean;
+    isSeaDay: boolean;
+    isExpeditionLanding: boolean;
+    isSkipped: boolean;
+    meals: {
+        breakfast?: boolean;
+        lunch?: boolean;
+        dinner?: boolean;
+    };
+    hasOverride: boolean;
+};
+export declare function mergeDay(base: CruiseDay, override: CruiseSailingDay | undefined): EffectiveItineraryDay;
+//# sourceMappingURL=service-itinerary.d.ts.map

package/dist/service-itinerary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-itinerary.d.ts","sourceRoot":"","sources":["../src/service-itinerary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAExE,MAAM,MAAM,qBAAqB,GAAG;IAClC,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAA;IACnC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,WAAW,EAAE,OAAO,CAAA;IACpB,QAAQ,EAAE,OAAO,CAAA;IACjB,mBAAmB,EAAE,OAAO,CAAA;IAC5B,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;IACjE,WAAW,EAAE,OAAO,CAAA;CACrB,CAAA;AAED,wBAAgB,QAAQ,CACtB,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,gBAAgB,GAAG,SAAS,GACrC,qBAAqB,CAiCvB"}