@voyant-travel/charters 0.117.2

package/dist/service-pricing.js

@@ -0,0 +1,167 @@
+import { and, asc, eq, sql } from "drizzle-orm";
+import { charterProducts, charterVoyages } from "./schema-core.js";
+import { charterSuites } from "./schema-pricing.js";
+// ---------- money helpers ----------
+// All math is performed in integer cents to avoid float drift.
+// Same approach the cruises module uses.
+const CENTS_PER_UNIT = 100n;
+function decimalStringToCents(s) {
+    const trimmed = s.trim();
+    if (!/^-?\d+(\.\d{1,2})?$/.test(trimmed)) {
+        throw new Error(`Invalid money string: ${s}`);
+    }
+    const negative = trimmed.startsWith("-");
+    const abs = negative ? trimmed.slice(1) : trimmed;
+    const parts = abs.split(".");
+    const whole = parts[0] ?? "0";
+    const frac = parts[1] ?? "";
+    const fracPadded = `${frac}00`.slice(0, 2);
+    const cents = BigInt(whole) * CENTS_PER_UNIT + BigInt(fracPadded);
+    return negative ? -cents : cents;
+}
+function centsToDecimalString(c) {
+    const negative = c < 0n;
+    const abs = negative ? -c : c;
+    const whole = abs / CENTS_PER_UNIT;
+    const frac = abs % CENTS_PER_UNIT;
+    const fracStr = frac.toString().padStart(2, "0");
+    return `${negative ? "-" : ""}${whole.toString()}.${fracStr}`;
+}
+function percentOf(cents, percentString) {
+    const trimmed = percentString.trim();
+    if (!/^-?\d+(\.\d{1,2})?$/.test(trimmed)) {
+        throw new Error(`Invalid percent string: ${percentString}`);
+    }
+    const parts = trimmed.split(".");
+    const whole = parts[0] ?? "0";
+    const frac = parts[1] ?? "";
+    const fracPadded = `${frac}00`.slice(0, 2);
+    // percent * 100 → integer basis points; multiply cents, divide by 10000
+    const basisPoints = BigInt(whole) * 100n + BigInt(fracPadded);
+    return (cents * basisPoints) / 10000n;
+}
+// ---------- currency resolution (pure) ----------
+/**
+ * Per-currency price lookup against a `Record<currency, amount>` map.
+ * Returns `null` when the entity isn't priced in that currency. Callers
+ * decide whether that's an error (quote composition) or a soft miss
+ * (browse aggregates).
+ */
+function priceForCurrency(map, currency) {
+    return map[currency] ?? null;
+}
+function listPriceCurrencies(map) {
+    return Object.keys(map).filter((code) => map[code] != null && map[code] !== "");
+}
+export function composePerSuiteQuote(input) {
+    const suitePrice = priceForCurrency(input.suite.pricesByCurrency, input.currency);
+    if (!suitePrice) {
+        throw new Error(`Suite ${input.suite.id} has no published price in ${input.currency}; available currencies: ${listPriceCurrencies(input.suite.pricesByCurrency).join(", ") || "none"}`);
+    }
+    const portFee = priceForCurrency(input.suite.portFeesByCurrency, input.currency);
+    const suiteCents = decimalStringToCents(suitePrice);
+    const portFeeCents = portFee ? decimalStringToCents(portFee) : 0n;
+    const totalCents = suiteCents + portFeeCents;
+    return {
+        mode: "per_suite",
+        voyageId: input.voyageId,
+        suiteId: input.suite.id,
+        suiteName: input.suite.suiteName,
+        currency: input.currency,
+        suitePrice: centsToDecimalString(suiteCents),
+        portFee: portFee ? centsToDecimalString(portFeeCents) : null,
+        total: centsToDecimalString(totalCents),
+    };
+}
+export function composeWholeYachtQuote(input) {
+    const charterFee = priceForCurrency(input.voyage.wholeYachtPricesByCurrency, input.currency);
+    if (!charterFee) {
+        throw new Error(`Voyage ${input.voyage.id} has no published whole-yacht price in ${input.currency}; available currencies: ${listPriceCurrencies(input.voyage.wholeYachtPricesByCurrency).join(", ") || "none"}`);
+    }
+    const apaPercent = input.voyage.apaPercentOverride ?? input.productDefaultApaPercent;
+    if (!apaPercent) {
+        throw new Error(`Voyage ${input.voyage.id} has no APA percent set (neither voyage override nor product default). Whole-yacht charters require an APA.`);
+    }
+    const charterFeeCents = decimalStringToCents(charterFee);
+    const apaAmountCents = percentOf(charterFeeCents, apaPercent);
+    const totalCents = charterFeeCents + apaAmountCents;
+    return {
+        mode: "whole_yacht",
+        voyageId: input.voyage.id,
+        currency: input.currency,
+        charterFee: centsToDecimalString(charterFeeCents),
+        apaPercent,
+        apaAmount: centsToDecimalString(apaAmountCents),
+        total: centsToDecimalString(totalCents),
+    };
+}
+// ---------- standalone APA helper ----------
+/**
+ * Compute APA amount from a charter fee and a percent. Useful for finance-side
+ * recalculation without needing to re-quote the whole voyage.
+ */
+export function computeApaAmount(charterFee, apaPercent) {
+    const cents = percentOf(decimalStringToCents(charterFee), apaPercent);
+    return centsToDecimalString(cents);
+}
+// ---------- DB-bound service ----------
+export const pricingService = {
+    async quotePerSuite(db, args) {
+        const [suite] = await db
+            .select()
+            .from(charterSuites)
+            .where(eq(charterSuites.id, args.suiteId))
+            .limit(1);
+        if (!suite)
+            throw new Error(`Charter suite ${args.suiteId} not found`);
+        return composePerSuiteQuote({
+            voyageId: suite.voyageId,
+            suite,
+            currency: args.currency,
+        });
+    },
+    async quoteWholeYacht(db, args) {
+        const [voyage] = await db
+            .select()
+            .from(charterVoyages)
+            .where(eq(charterVoyages.id, args.voyageId))
+            .limit(1);
+        if (!voyage)
+            throw new Error(`Charter voyage ${args.voyageId} not found`);
+        const [product] = await db
+            .select({ defaultApaPercent: charterProducts.defaultApaPercent })
+            .from(charterProducts)
+            .where(eq(charterProducts.id, voyage.productId))
+            .limit(1);
+        return composeWholeYachtQuote({
+            voyage,
+            productDefaultApaPercent: product?.defaultApaPercent ?? null,
+            currency: args.currency,
+        });
+    },
+    /**
+     * Lowest published per-suite price for a voyage, in the requested currency.
+     * Returns `null` when no available suite has that currency. The previous
+     * `lowestSuitePriceUSD` shape was renamed and generalized as part of #355
+     * (browse-currency policy is a deployment choice, not a hardcoded USD).
+     */
+    async lowestSuitePriceForCurrency(db, voyageId, currency) {
+        const [row] = await db
+            .select({
+            suiteId: charterSuites.id,
+            price: sql `(${charterSuites.pricesByCurrency} ->> ${currency})`,
+        })
+            .from(charterSuites)
+            .where(and(eq(charterSuites.voyageId, voyageId), 
+        // agent-quality: raw-sql reviewed -- owner: charters; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        sql `${charterSuites.availability} <> 'sold_out'`, 
+        // agent-quality: raw-sql reviewed -- owner: charters; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        sql `(${charterSuites.pricesByCurrency} ? ${currency})`))
+            // agent-quality: raw-sql reviewed -- owner: charters; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            .orderBy(asc(sql `((${charterSuites.pricesByCurrency} ->> ${currency})::numeric)`))
+            .limit(1);
+        if (!row?.price)
+            return null;
+        return { suiteId: row.suiteId, price: row.price };
+    },
+};

package/dist/service.d.ts

@@ -0,0 +1,131 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type CharterProduct, type CharterVoyage } from "./schema-core.js";
+import { type CharterScheduleDay } from "./schema-itinerary.js";
+import { type CharterSuite } from "./schema-pricing.js";
+import { type CharterYacht } from "./schema-yachts.js";
+import type { InsertProduct, InsertVoyage, ProductListQuery, UpdateProduct, UpdateVoyage, VoyageListQuery } from "./validation-core.js";
+import type { ReplaceVoyageSchedule } from "./validation-itinerary.js";
+import type { ReplaceVoyageSuites } from "./validation-pricing.js";
+import type { InsertYacht, UpdateYacht, YachtListQuery } from "./validation-yachts.js";
+export declare const chartersService: {
+    listProducts(db: PostgresJsDatabase, query: ProductListQuery): Promise<{
+        data: {
+            id: string;
+            slug: string;
+            name: string;
+            lineSupplierId: string | null;
+            defaultYachtId: string | null;
+            description: string | null;
+            shortDescription: string | null;
+            heroImageUrl: string | null;
+            mapImageUrl: string | null;
+            regions: string[] | null;
+            themes: string[] | null;
+            status: "live" | "draft" | "awaiting_review" | "archived";
+            defaultBookingModes: ("per_suite" | "whole_yacht")[] | null;
+            defaultMybaTemplateId: string | null;
+            defaultApaPercent: string | null;
+            lowestPriceCachedAmount: string | null;
+            lowestPriceCachedCurrency: string | null;
+            earliestVoyageCached: string | null;
+            latestVoyageCached: string | null;
+            externalRefs: Record<string, string> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getProductById(db: PostgresJsDatabase, id: string, options?: {
+        withVoyages?: boolean;
+        withYacht?: boolean;
+    }): Promise<(CharterProduct & {
+        voyages?: CharterVoyage[];
+        yacht?: CharterYacht | null;
+    }) | null>;
+    createProduct(db: PostgresJsDatabase, data: InsertProduct): Promise<CharterProduct>;
+    updateProduct(db: PostgresJsDatabase, id: string, data: UpdateProduct): Promise<CharterProduct | null>;
+    archiveProduct(db: PostgresJsDatabase, id: string): Promise<CharterProduct | null>;
+    recomputeProductAggregates(db: PostgresJsDatabase, productId: string, options?: {
+        browseCurrency?: string;
+    }): Promise<CharterProduct | null>;
+    listVoyages(db: PostgresJsDatabase, query: VoyageListQuery): Promise<{
+        data: {
+            id: string;
+            productId: string;
+            yachtId: string;
+            voyageCode: string;
+            name: string | null;
+            embarkPortFacilityId: string | null;
+            embarkPortName: string | null;
+            disembarkPortFacilityId: string | null;
+            disembarkPortName: string | null;
+            departureDate: string;
+            returnDate: string;
+            nights: number;
+            bookingModes: ("per_suite" | "whole_yacht")[];
+            appointmentOnly: boolean;
+            wholeYachtPricesByCurrency: Record<string, string>;
+            apaPercentOverride: string | null;
+            mybaTemplateIdOverride: string | null;
+            charterAreaOverride: string | null;
+            salesStatus: "open" | "on_request" | "wait_list" | "sold_out" | "closed";
+            availabilityNote: string | null;
+            externalRefs: Record<string, string> | null;
+            lastSyncedAt: Date | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getVoyageById(db: PostgresJsDatabase, id: string, options?: {
+        withSuites?: boolean;
+        withSchedule?: boolean;
+    }): Promise<(CharterVoyage & {
+        suites?: CharterSuite[];
+        schedule?: CharterScheduleDay[];
+    }) | null>;
+    upsertVoyage(db: PostgresJsDatabase, data: InsertVoyage): Promise<CharterVoyage>;
+    updateVoyage(db: PostgresJsDatabase, id: string, data: UpdateVoyage): Promise<CharterVoyage | null>;
+    replaceVoyageSuites(db: PostgresJsDatabase, payload: ReplaceVoyageSuites): Promise<CharterSuite[]>;
+    replaceVoyageSchedule(db: PostgresJsDatabase, payload: ReplaceVoyageSchedule): Promise<CharterScheduleDay[]>;
+    listYachts(db: PostgresJsDatabase, query: YachtListQuery): Promise<{
+        data: {
+            id: string;
+            lineSupplierId: string | null;
+            name: string;
+            slug: string;
+            yachtClass: "luxury_motor" | "luxury_sailing" | "expedition" | "small_cruise";
+            capacityGuests: number | null;
+            capacityCrew: number | null;
+            lengthMeters: string | null;
+            yearBuilt: number | null;
+            yearRefurbished: number | null;
+            imo: string | null;
+            description: string | null;
+            gallery: string[] | null;
+            amenities: Record<string, unknown> | null;
+            crewBios: {
+                role: string;
+                name: string;
+                bio?: string;
+                photoUrl?: string;
+            }[] | null;
+            defaultCharterAreas: string[] | null;
+            externalRefs: Record<string, string> | null;
+            isActive: boolean;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getYachtById(db: PostgresJsDatabase, id: string): Promise<CharterYacht | null>;
+    createYacht(db: PostgresJsDatabase, data: InsertYacht): Promise<CharterYacht>;
+    updateYacht(db: PostgresJsDatabase, id: string, data: UpdateYacht): Promise<CharterYacht | 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":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,aAAa,EAKnB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,KAAK,kBAAkB,EAAuB,MAAM,uBAAuB,CAAA;AACpF,OAAO,EAAE,KAAK,YAAY,EAAiB,MAAM,qBAAqB,CAAA;AACtE,OAAO,EAAE,KAAK,YAAY,EAAiB,MAAM,oBAAoB,CAAA;AACrE,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,eAAe,EAChB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AACtE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAQtF,eAAO,MAAM,eAAe;qBAGH,kBAAkB,SAAS,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAgC5D,kBAAkB,MAClB,MAAM,YACD;QAAE,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GACtD,OAAO,CAAC,CAAC,cAAc,GAAG;QAAE,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;QAAC,KAAK,CAAC,EAAE,YAAY,GAAG,IAAI,CAAA;KAAE,CAAC,GAAG,IAAI,CAAC;sBAyBxE,kBAAkB,QAAQ,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;sBAUnF,kBAAkB,MAClB,MAAM,QACJ,aAAa,GAClB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;uBASR,kBAAkB,MAAM,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;mCAUlF,kBAAkB,aACX,MAAM,YACR;QAAE,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,GACnC,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;oBAiDX,kBAAkB,SAAS,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA8B1D,kBAAkB,MAClB,MAAM,YACD;QAAE,UAAU,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE,GACxD,OAAO,CACN,CAAC,aAAa,GAAG;QACf,MAAM,CAAC,EAAE,YAAY,EAAE,CAAA;QACvB,QAAQ,CAAC,EAAE,kBAAkB,EAAE,CAAA;KAChC,CAAC,GACF,IAAI,CACP;qBA0BsB,kBAAkB,QAAQ,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;qBAgChF,kBAAkB,MAClB,MAAM,QACJ,YAAY,GACjB,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;4BAU1B,kBAAkB,WACb,mBAAmB,GAC3B,OAAO,CAAC,YAAY,EAAE,CAAC;8BAapB,kBAAkB,WACb,qBAAqB,GAC7B,OAAO,CAAC,kBAAkB,EAAE,CAAC;mBAcX,kBAAkB,SAAS,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwBvC,kBAAkB,MAAM,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;oBAK9D,kBAAkB,QAAQ,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;oBAO7E,kBAAkB,MAClB,MAAM,QACJ,WAAW,GAChB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;CAQhC,CAAA"}

package/dist/service.js

@@ -0,0 +1,279 @@
+import { and, asc, count, desc, eq, gte, ilike, lte, or, sql } from "drizzle-orm";
+import { charterProducts, charterVoyages, } from "./schema-core.js";
+import { charterScheduleDays } from "./schema-itinerary.js";
+import { charterSuites } from "./schema-pricing.js";
+import { charterYachts } from "./schema-yachts.js";
+const setUpdated = { updatedAt: new Date() };
+function paginate(query) {
+    return { limit: query.limit, offset: query.offset };
+}
+export const chartersService = {
+    // ---------- products ----------
+    async listProducts(db, query) {
+        const conditions = [];
+        if (query.status)
+            conditions.push(eq(charterProducts.status, query.status));
+        if (query.lineSupplierId)
+            conditions.push(eq(charterProducts.lineSupplierId, query.lineSupplierId));
+        if (query.region) {
+            // agent-quality: raw-sql reviewed -- owner: charters; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            conditions.push(sql `${charterProducts.regions} @> ${JSON.stringify([query.region])}::jsonb`);
+        }
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(charterProducts.name, term), ilike(charterProducts.description, term)));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const { limit, offset } = paginate(query);
+        const [rows, totalRows] = await Promise.all([
+            db
+                .select()
+                .from(charterProducts)
+                .where(where)
+                .orderBy(desc(charterProducts.createdAt))
+                .limit(limit)
+                .offset(offset),
+            db.select({ value: count() }).from(charterProducts).where(where),
+        ]);
+        return { data: rows, total: totalRows[0]?.value ?? 0, limit, offset };
+    },
+    async getProductById(db, id, options = {}) {
+        const [row] = await db.select().from(charterProducts).where(eq(charterProducts.id, id)).limit(1);
+        if (!row)
+            return null;
+        const out = {
+            ...row,
+        };
+        if (options.withVoyages) {
+            out.voyages = await db
+                .select()
+                .from(charterVoyages)
+                .where(eq(charterVoyages.productId, id))
+                .orderBy(asc(charterVoyages.departureDate));
+        }
+        if (options.withYacht && row.defaultYachtId) {
+            const [yacht] = await db
+                .select()
+                .from(charterYachts)
+                .where(eq(charterYachts.id, row.defaultYachtId))
+                .limit(1);
+            out.yacht = yacht ?? null;
+        }
+        return out;
+    },
+    async createProduct(db, data) {
+        const [row] = await db
+            .insert(charterProducts)
+            .values(data)
+            .returning();
+        if (!row)
+            throw new Error("Failed to create charter product");
+        return row;
+    },
+    async updateProduct(db, id, data) {
+        const [row] = await db
+            .update(charterProducts)
+            .set({ ...data, ...setUpdated })
+            .where(eq(charterProducts.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async archiveProduct(db, id) {
+        const [row] = await db
+            .update(charterProducts)
+            .set({ status: "archived", ...setUpdated })
+            .where(eq(charterProducts.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async recomputeProductAggregates(db, productId, options = {}) {
+        // Lowest suite price across this product's voyages × suites, in the
+        // deployment's chosen browse currency. Defaults to "USD" so existing
+        // callers and storefronts that haven't picked a browse currency yet
+        // keep their previous behavior; pass `browseCurrency` explicitly to
+        // override (e.g. EUR-first European catalog).
+        const browseCurrency = options.browseCurrency ?? "USD";
+        const [priceAgg] = await db
+            .select({
+            lowest: sql `MIN(((${charterSuites.pricesByCurrency} ->> ${browseCurrency})::numeric))::text`,
+        })
+            .from(charterSuites)
+            .innerJoin(charterVoyages, eq(charterSuites.voyageId, charterVoyages.id))
+            .where(and(eq(charterVoyages.productId, productId), 
+        // agent-quality: raw-sql reviewed -- owner: charters; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        sql `${charterSuites.availability} <> 'sold_out'`, 
+        // agent-quality: raw-sql reviewed -- owner: charters; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        sql `(${charterSuites.pricesByCurrency} ? ${browseCurrency})`));
+        const [dateAgg] = await db
+            .select({
+            earliest: sql `MIN(${charterVoyages.departureDate})`,
+            latest: sql `MAX(${charterVoyages.departureDate})`,
+        })
+            .from(charterVoyages)
+            .where(eq(charterVoyages.productId, productId));
+        const [row] = await db
+            .update(charterProducts)
+            .set({
+            lowestPriceCachedAmount: priceAgg?.lowest ?? null,
+            lowestPriceCachedCurrency: priceAgg?.lowest ? browseCurrency : null,
+            earliestVoyageCached: dateAgg?.earliest ?? null,
+            latestVoyageCached: dateAgg?.latest ?? null,
+            ...setUpdated,
+        })
+            .where(eq(charterProducts.id, productId))
+            .returning();
+        return row ?? null;
+    },
+    // ---------- voyages ----------
+    async listVoyages(db, query) {
+        const conditions = [];
+        if (query.productId)
+            conditions.push(eq(charterVoyages.productId, query.productId));
+        if (query.yachtId)
+            conditions.push(eq(charterVoyages.yachtId, query.yachtId));
+        if (query.salesStatus)
+            conditions.push(eq(charterVoyages.salesStatus, query.salesStatus));
+        if (query.dateFrom)
+            conditions.push(gte(charterVoyages.departureDate, query.dateFrom));
+        if (query.dateTo)
+            conditions.push(lte(charterVoyages.departureDate, query.dateTo));
+        if (query.bookingMode) {
+            conditions.push(
+            // agent-quality: raw-sql reviewed -- owner: charters; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            sql `${charterVoyages.bookingModes} @> ${JSON.stringify([query.bookingMode])}::jsonb`);
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const { limit, offset } = paginate(query);
+        const [rows, totalRows] = await Promise.all([
+            db
+                .select()
+                .from(charterVoyages)
+                .where(where)
+                .orderBy(asc(charterVoyages.departureDate))
+                .limit(limit)
+                .offset(offset),
+            db.select({ value: count() }).from(charterVoyages).where(where),
+        ]);
+        return { data: rows, total: totalRows[0]?.value ?? 0, limit, offset };
+    },
+    async getVoyageById(db, id, options = {}) {
+        const [row] = await db.select().from(charterVoyages).where(eq(charterVoyages.id, id)).limit(1);
+        if (!row)
+            return null;
+        const out = { ...row };
+        if (options.withSuites) {
+            out.suites = await db
+                .select()
+                .from(charterSuites)
+                .where(eq(charterSuites.voyageId, id))
+                .orderBy(asc(charterSuites.suiteCode));
+        }
+        if (options.withSchedule) {
+            out.schedule = await db
+                .select()
+                .from(charterScheduleDays)
+                .where(eq(charterScheduleDays.voyageId, id))
+                .orderBy(asc(charterScheduleDays.dayNumber));
+        }
+        return out;
+    },
+    async upsertVoyage(db, data) {
+        const [existing] = await db
+            .select()
+            .from(charterVoyages)
+            .where(and(eq(charterVoyages.productId, data.productId), eq(charterVoyages.departureDate, data.departureDate), eq(charterVoyages.yachtId, data.yachtId)))
+            .limit(1);
+        if (existing) {
+            const [row] = await db
+                .update(charterVoyages)
+                .set({ ...data, ...setUpdated, lastSyncedAt: new Date() })
+                .where(eq(charterVoyages.id, existing.id))
+                .returning();
+            if (!row)
+                throw new Error("Failed to update voyage");
+            return row;
+        }
+        const [row] = await db
+            .insert(charterVoyages)
+            .values({ ...data, lastSyncedAt: new Date() })
+            .returning();
+        if (!row)
+            throw new Error("Failed to insert voyage");
+        return row;
+    },
+    async updateVoyage(db, id, data) {
+        const [row] = await db
+            .update(charterVoyages)
+            .set({ ...data, ...setUpdated })
+            .where(eq(charterVoyages.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async replaceVoyageSuites(db, payload) {
+        return db.transaction(async (tx) => {
+            await tx.delete(charterSuites).where(eq(charterSuites.voyageId, payload.voyageId));
+            if (payload.suites.length === 0)
+                return [];
+            const inserted = await tx
+                .insert(charterSuites)
+                .values(payload.suites.map((s) => ({ ...s, voyageId: payload.voyageId })))
+                .returning();
+            return inserted;
+        });
+    },
+    async replaceVoyageSchedule(db, payload) {
+        return db.transaction(async (tx) => {
+            await tx.delete(charterScheduleDays).where(eq(charterScheduleDays.voyageId, payload.voyageId));
+            if (payload.days.length === 0)
+                return [];
+            const inserted = await tx
+                .insert(charterScheduleDays)
+                .values(payload.days.map((d) => ({ ...d, voyageId: payload.voyageId })))
+                .returning();
+            return inserted;
+        });
+    },
+    // ---------- yachts ----------
+    async listYachts(db, query) {
+        const conditions = [];
+        if (query.lineSupplierId)
+            conditions.push(eq(charterYachts.lineSupplierId, query.lineSupplierId));
+        if (query.yachtClass)
+            conditions.push(eq(charterYachts.yachtClass, query.yachtClass));
+        if (typeof query.isActive === "boolean")
+            conditions.push(eq(charterYachts.isActive, query.isActive));
+        if (query.search)
+            conditions.push(ilike(charterYachts.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(charterYachts)
+                .where(where)
+                .orderBy(asc(charterYachts.name))
+                .limit(limit)
+                .offset(offset),
+            db.select({ value: count() }).from(charterYachts).where(where),
+        ]);
+        return { data: rows, total: totalRows[0]?.value ?? 0, limit, offset };
+    },
+    async getYachtById(db, id) {
+        const [row] = await db.select().from(charterYachts).where(eq(charterYachts.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createYacht(db, data) {
+        const [row] = await db.insert(charterYachts).values(data).returning();
+        if (!row)
+            throw new Error("Failed to create yacht");
+        return row;
+    },
+    async updateYacht(db, id, data) {
+        const [row] = await db
+            .update(charterYachts)
+            .set({ ...data, ...setUpdated })
+            .where(eq(charterYachts.id, id))
+            .returning();
+        return row ?? null;
+    },
+};