@voyant-travel/cruises 0.118.2

package/dist/service-ships.js

@@ -0,0 +1,156 @@
+import { and, asc, count, eq, ilike } from "drizzle-orm";
+import { cruiseCabinCategories, cruiseCabins, cruiseDecks, cruiseShips } from "./schema-cabins.js";
+import { paginate, setUpdated } from "./service-shared.js";
+export const cruiseShipService = {
+    async listShips(db, query) {
+        const conditions = [];
+        if (query.lineSupplierId)
+            conditions.push(eq(cruiseShips.lineSupplierId, query.lineSupplierId));
+        if (query.shipType)
+            conditions.push(eq(cruiseShips.shipType, query.shipType));
+        if (typeof query.isActive === "boolean")
+            conditions.push(eq(cruiseShips.isActive, query.isActive));
+        if (query.search)
+            conditions.push(ilike(cruiseShips.name, `%${query.search}%`));
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const { limit, offset } = paginate(query);
+        const [rows, totalRows] = await Promise.all([
+            db
+                .select()
+                .from(cruiseShips)
+                .where(where)
+                .orderBy(asc(cruiseShips.name))
+                .limit(limit)
+                .offset(offset),
+            db.select({ value: count() }).from(cruiseShips).where(where),
+        ]);
+        return { data: rows, total: totalRows[0]?.value ?? 0, limit, offset };
+    },
+    async getShipById(db, id) {
+        const [row] = await db.select().from(cruiseShips).where(eq(cruiseShips.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createShip(db, data) {
+        const [row] = await db.insert(cruiseShips).values(data).returning();
+        if (!row)
+            throw new Error("Failed to create ship");
+        return row;
+    },
+    async updateShip(db, id, data) {
+        const [row] = await db
+            .update(cruiseShips)
+            .set({ ...data, ...setUpdated })
+            .where(eq(cruiseShips.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async listShipDecks(db, shipId) {
+        return db
+            .select()
+            .from(cruiseDecks)
+            .where(eq(cruiseDecks.shipId, shipId))
+            .orderBy(asc(cruiseDecks.level));
+    },
+    async upsertDeck(db, data) {
+        const [existing] = await db
+            .select()
+            .from(cruiseDecks)
+            .where(and(eq(cruiseDecks.shipId, data.shipId), eq(cruiseDecks.name, data.name)))
+            .limit(1);
+        if (existing) {
+            const [row] = await db
+                .update(cruiseDecks)
+                .set({ ...data, ...setUpdated })
+                .where(eq(cruiseDecks.id, existing.id))
+                .returning();
+            if (!row)
+                throw new Error("Failed to update deck");
+            return row;
+        }
+        const [row] = await db.insert(cruiseDecks).values(data).returning();
+        if (!row)
+            throw new Error("Failed to insert deck");
+        return row;
+    },
+    async updateDeck(db, id, data) {
+        const [row] = await db
+            .update(cruiseDecks)
+            .set({ ...data, ...setUpdated })
+            .where(eq(cruiseDecks.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async listShipCabinCategories(db, shipId) {
+        return db
+            .select()
+            .from(cruiseCabinCategories)
+            .where(eq(cruiseCabinCategories.shipId, shipId))
+            .orderBy(asc(cruiseCabinCategories.code));
+    },
+    async upsertCabinCategory(db, data) {
+        const [existing] = await db
+            .select()
+            .from(cruiseCabinCategories)
+            .where(and(eq(cruiseCabinCategories.shipId, data.shipId), eq(cruiseCabinCategories.code, data.code)))
+            .limit(1);
+        if (existing) {
+            const [row] = await db
+                .update(cruiseCabinCategories)
+                .set({ ...data, ...setUpdated })
+                .where(eq(cruiseCabinCategories.id, existing.id))
+                .returning();
+            if (!row)
+                throw new Error("Failed to update cabin category");
+            return row;
+        }
+        const [row] = await db.insert(cruiseCabinCategories).values(data).returning();
+        if (!row)
+            throw new Error("Failed to insert cabin category");
+        return row;
+    },
+    async updateCabinCategory(db, id, data) {
+        const [row] = await db
+            .update(cruiseCabinCategories)
+            .set({ ...data, ...setUpdated })
+            .where(eq(cruiseCabinCategories.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async listCabinsByCategory(db, categoryId) {
+        return db
+            .select()
+            .from(cruiseCabins)
+            .where(eq(cruiseCabins.categoryId, categoryId))
+            .orderBy(asc(cruiseCabins.cabinNumber));
+    },
+    async upsertCabin(db, data) {
+        const [existing] = await db
+            .select()
+            .from(cruiseCabins)
+            .where(and(eq(cruiseCabins.categoryId, data.categoryId), eq(cruiseCabins.cabinNumber, data.cabinNumber)))
+            .limit(1);
+        if (existing) {
+            const [row] = await db
+                .update(cruiseCabins)
+                .set({ ...data, ...setUpdated })
+                .where(eq(cruiseCabins.id, existing.id))
+                .returning();
+            if (!row)
+                throw new Error("Failed to update cabin");
+            return row;
+        }
+        const [row] = await db.insert(cruiseCabins).values(data).returning();
+        if (!row)
+            throw new Error("Failed to insert cabin");
+        return row;
+    },
+    async updateCabin(db, id, data) {
+        const [row] = await db
+            .update(cruiseCabins)
+            .set({ ...data, ...setUpdated })
+            .where(eq(cruiseCabins.id, id))
+            .returning();
+        return row ?? null;
+    },
+    // ---------- prices ----------
+};

package/dist/service.d.ts

@@ -0,0 +1,255 @@
+export type { EffectiveItineraryDay } from "./service-itinerary.js";
+export type { CruiseMutationRuntime } from "./service-shared.js";
+export declare const cruisesService: {
+    listEnrichmentPrograms(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, cruiseId: string): Promise<import("./schema-content.js").CruiseEnrichmentProgram[]>;
+    createEnrichmentProgram(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, data: import("./validation-content.js").InsertEnrichmentProgram): Promise<import("./schema-content.js").CruiseEnrichmentProgram>;
+    updateEnrichmentProgram(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string, data: import("./validation-content.js").UpdateEnrichmentProgram): Promise<import("./schema-content.js").CruiseEnrichmentProgram | null>;
+    deleteEnrichmentProgram(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string): Promise<boolean>;
+    replaceEnrichmentPrograms(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, payload: import("./validation-content.js").ReplaceEnrichmentPrograms): Promise<import("./schema-content.js").CruiseEnrichmentProgram[]>;
+    listPrices(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, query: import("./validation-pricing.js").PriceListQuery): Promise<{
+        data: {
+            id: string;
+            sailingId: string;
+            cabinCategoryId: string;
+            occupancy: number;
+            fareCode: string | null;
+            fareCodeName: string | null;
+            fareVariant: "cruise_only" | "air_inclusive";
+            currency: string;
+            pricePerPerson: string;
+            originalPricePerPerson: string | null;
+            secondGuestPricePerPerson: string | null;
+            singlePricePerPerson: string | null;
+            singleSupplementPercent: string | null;
+            availability: "on_request" | "wait_list" | "sold_out" | "available" | "limited";
+            availabilityCount: number | null;
+            priceCatalogId: string | null;
+            priceScheduleId: string | null;
+            bookingDeadline: string | null;
+            earlyBookingDeadline: string | null;
+            earlyBookingBonusDescription: string | null;
+            requiresRequest: boolean;
+            notes: string | null;
+            externalRefs: Record<string, string> | null;
+            lastSyncedAt: Date | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    createPrice(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, data: import("./validation-pricing.js").InsertPrice): Promise<import("./schema-pricing.js").CruisePrice>;
+    updatePrice(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string, data: import("./validation-pricing.js").UpdatePrice): Promise<import("./schema-pricing.js").CruisePrice | null>;
+    replaceSailingPricing(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, sailingId: string, payload: {
+        prices: Array<import("./validation-pricing.js").InsertPrice & {
+            components?: Array<Omit<import("./validation-pricing.js").InsertPriceComponent, "priceId">>;
+        }>;
+    }): Promise<import("./schema-pricing.js").CruisePrice[]>;
+    listShips(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, query: import("./validation-cabins.js").ShipListQuery): Promise<{
+        data: {
+            id: string;
+            lineSupplierId: string | null;
+            name: string;
+            slug: string;
+            shipType: "ocean" | "river" | "expedition" | "coastal" | "yacht" | "sailing";
+            capacityGuests: number | null;
+            capacityCrew: number | null;
+            cabinCount: number | null;
+            deckCount: number | null;
+            lengthMeters: string | null;
+            cruisingSpeedKnots: string | null;
+            yearBuilt: number | null;
+            yearRefurbished: number | null;
+            imo: string | null;
+            description: string | null;
+            deckPlanUrl: string | null;
+            gallery: string[] | null;
+            amenities: Record<string, unknown> | null;
+            externalRefs: Record<string, string> | null;
+            isActive: boolean;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getShipById(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string): Promise<import("./schema-cabins.js").CruiseShip | null>;
+    createShip(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, data: import("./validation-cabins.js").InsertShip): Promise<import("./schema-cabins.js").CruiseShip>;
+    updateShip(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string, data: import("./validation-cabins.js").UpdateShip): Promise<import("./schema-cabins.js").CruiseShip | null>;
+    listShipDecks(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, shipId: string): Promise<import("./schema-cabins.js").CruiseDeck[]>;
+    upsertDeck(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, data: import("./validation-cabins.js").InsertDeck): Promise<import("./schema-cabins.js").CruiseDeck>;
+    updateDeck(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string, data: import("./validation-cabins.js").UpdateDeck): Promise<import("./schema-cabins.js").CruiseDeck | null>;
+    listShipCabinCategories(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, shipId: string): Promise<import("./schema-cabins.js").CruiseCabinCategory[]>;
+    upsertCabinCategory(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, data: import("./validation-cabins.js").InsertCabinCategory): Promise<import("./schema-cabins.js").CruiseCabinCategory>;
+    updateCabinCategory(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string, data: import("./validation-cabins.js").UpdateCabinCategory): Promise<import("./schema-cabins.js").CruiseCabinCategory | null>;
+    listCabinsByCategory(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, categoryId: string): Promise<import("./schema-cabins.js").CruiseCabin[]>;
+    upsertCabin(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, data: import("./validation-cabins.js").InsertCabin): Promise<import("./schema-cabins.js").CruiseCabin>;
+    updateCabin(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string, data: import("./validation-cabins.js").UpdateCabin): Promise<import("./schema-cabins.js").CruiseCabin | null>;
+    listSailings(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, query: import("./validation-core.js").SailingListQuery): Promise<{
+        data: {
+            id: string;
+            cruiseId: string;
+            shipId: string;
+            departureDate: string;
+            returnDate: string;
+            embarkPortFacilityId: string | null;
+            embarkPortCanonicalPlaceId: string | null;
+            disembarkPortFacilityId: string | null;
+            disembarkPortCanonicalPlaceId: string | null;
+            direction: "upstream" | "downstream" | "round_trip" | "one_way" | null;
+            availabilityNote: string | null;
+            isCharter: boolean;
+            salesStatus: "open" | "on_request" | "wait_list" | "sold_out" | "closed";
+            externalRefs: Record<string, string> | null;
+            customerPaymentPolicy: unknown;
+            lastSyncedAt: Date | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getSailingById(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string, options?: {
+        withPricing?: boolean;
+        withItinerary?: boolean;
+    }): Promise<(import("./schema-core.js").CruiseSailing & {
+        prices?: import("./schema-pricing.js").CruisePrice[];
+        priceComponents?: import("./schema-pricing.js").CruisePriceComponent[];
+        effectiveDays?: import("./service-itinerary.js").EffectiveItineraryDay[];
+    }) | null>;
+    upsertSailing(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, data: import("./validation-core.js").InsertSailing): Promise<import("./schema-core.js").CruiseSailing>;
+    updateSailing(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string, data: import("./validation-core.js").UpdateSailing): Promise<import("./schema-core.js").CruiseSailing | null>;
+    getEffectiveItinerary(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, sailingId: string): Promise<import("./service-itinerary.js").EffectiveItineraryDay[]>;
+    replaceCruiseDays(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, payload: import("./validation-itinerary.js").ReplaceCruiseDays): Promise<import("./schema-itinerary.js").CruiseDay[]>;
+    replaceSailingDays(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, payload: import("./validation-itinerary.js").ReplaceSailingDays): Promise<import("./schema-itinerary.js").CruiseSailingDay[]>;
+    listVoyageGroups(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, query: import("./validation-core.js").VoyageGroupListQuery): Promise<{
+        data: {
+            id: string;
+            slug: string;
+            name: string;
+            groupKind: "combination" | "grand_voyage" | "world_cruise" | "cruise_tour";
+            lineSupplierId: string | null;
+            nights: number;
+            embarkPortFacilityId: string | null;
+            embarkPortCanonicalPlaceId: string | null;
+            disembarkPortFacilityId: string | null;
+            disembarkPortCanonicalPlaceId: string | null;
+            description: string | null;
+            shortDescription: string | null;
+            highlights: string[] | null;
+            regions: string[] | null;
+            themes: string[] | null;
+            heroImageUrl: string | null;
+            mapImageUrl: string | null;
+            status: "draft" | "awaiting_review" | "live" | "archived";
+            lowestPriceCached: string | null;
+            lowestPriceCurrencyCached: string | null;
+            earliestDepartureCached: string | null;
+            latestDepartureCached: string | null;
+            externalRefs: Record<string, string> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getVoyageGroupById(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string, options?: {
+        withSegments?: boolean;
+    }): Promise<(import("./schema-core.js").CruiseVoyageGroup & {
+        segments?: import("./schema-core.js").CruiseVoyageGroupSegment[];
+    }) | null>;
+    createVoyageGroup(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, data: import("./validation-core.js").InsertVoyageGroup): Promise<import("./schema-core.js").CruiseVoyageGroup>;
+    updateVoyageGroup(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string, data: import("./validation-core.js").UpdateVoyageGroup): Promise<import("./schema-core.js").CruiseVoyageGroup | null>;
+    archiveVoyageGroup(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string): Promise<import("./schema-core.js").CruiseVoyageGroup | null>;
+    listVoyageGroupSegments(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, query: import("./validation-core.js").VoyageGroupSegmentListQuery): Promise<{
+        data: {
+            id: string;
+            voyageGroupId: string;
+            sortOrder: number;
+            segmentKind: "rail" | "other" | "transfer" | "cruise" | "land" | "hotel" | "air";
+            segmentRole: "core" | "pre_extension" | "post_extension";
+            title: string;
+            description: string | null;
+            cruiseId: string | null;
+            sailingId: string | null;
+            startDay: number | null;
+            endDay: number | null;
+            startDate: string | null;
+            endDate: string | null;
+            embarkPortFacilityId: string | null;
+            embarkPortCanonicalPlaceId: string | null;
+            disembarkPortFacilityId: string | null;
+            disembarkPortCanonicalPlaceId: string | null;
+            nights: number | null;
+            externalRefs: Record<string, string> | null;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    createVoyageGroupSegment(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, data: import("./validation-core.js").InsertVoyageGroupSegment): Promise<import("./schema-core.js").CruiseVoyageGroupSegment>;
+    updateVoyageGroupSegment(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string, data: import("./validation-core.js").UpdateVoyageGroupSegment): Promise<import("./schema-core.js").CruiseVoyageGroupSegment | null>;
+    deleteVoyageGroupSegment(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string): Promise<boolean>;
+    listCruises(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, query: import("./validation-core.js").CruiseListQuery): Promise<{
+        data: {
+            id: string;
+            slug: string;
+            name: string;
+            cruiseType: "ocean" | "river" | "expedition" | "coastal";
+            lineSupplierId: string | null;
+            defaultShipId: string | null;
+            nights: number;
+            embarkPortFacilityId: string | null;
+            embarkPortCanonicalPlaceId: string | null;
+            disembarkPortFacilityId: string | null;
+            disembarkPortCanonicalPlaceId: string | null;
+            description: string | null;
+            shortDescription: string | null;
+            highlights: string[] | null;
+            inclusionsHtml: string | null;
+            exclusionsHtml: string | null;
+            regionIds: string[] | null;
+            waterwayIds: string[] | null;
+            portIds: string[] | null;
+            countryIso: string[] | null;
+            regions: string[] | null;
+            waterways: string[] | null;
+            ports: string[] | null;
+            countries: string[] | null;
+            themes: string[] | null;
+            heroImageUrl: string | null;
+            mapImageUrl: string | null;
+            status: "draft" | "awaiting_review" | "live" | "archived";
+            lowestPriceCached: string | null;
+            lowestPriceCurrencyCached: string | null;
+            earliestDepartureCached: string | null;
+            latestDepartureCached: string | null;
+            externalRefs: Record<string, string> | null;
+            customerPaymentPolicy: unknown;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getCruiseById(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string, options?: {
+        withSailings?: boolean;
+        withDays?: boolean;
+    }): Promise<(import("./schema-core.js").Cruise & {
+        sailings?: import("./schema-core.js").CruiseSailing[];
+        days?: import("./schema-itinerary.js").CruiseDay[];
+    }) | null>;
+    createCruise(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, data: import("./validation-core.js").InsertCruise, runtime?: import("./service-shared.js").CruiseMutationRuntime): Promise<import("./schema-core.js").Cruise>;
+    updateCruise(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string, data: import("./validation-core.js").UpdateCruise, runtime?: import("./service-shared.js").CruiseMutationRuntime): Promise<import("./schema-core.js").Cruise | null>;
+    archiveCruise(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, id: string, runtime?: import("./service-shared.js").CruiseMutationRuntime): Promise<import("./schema-core.js").Cruise | null>;
+    recomputeCruiseAggregates(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, cruiseId: string): Promise<import("./schema-core.js").Cruise | null>;
+};
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAMA,YAAY,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAA;AACnE,YAAY,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAEhE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAO67D,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAriB,CAAC;qBAAwB,CAAC;;cAAuE,CAAC;uBAAuC,CAAC;qBAA8C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAgY,CAAC;;gBAA6E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAulK,CAAC;gBAAmB,CAAC;;gBAAkE,CAAC;YAA8B,CAAC;;;;;;CADzwO,CAAA"}

package/dist/service.js

@@ -0,0 +1,12 @@
+import { cruiseCoreService } from "./service-core.js";
+import { cruiseEnrichmentService } from "./service-enrichment.js";
+import { cruisePriceRowsService } from "./service-prices.js";
+import { cruiseSailingsService } from "./service-sailings.js";
+import { cruiseShipService } from "./service-ships.js";
+export const cruisesService = {
+    ...cruiseCoreService,
+    ...cruiseSailingsService,
+    ...cruiseShipService,
+    ...cruisePriceRowsService,
+    ...cruiseEnrichmentService,
+};