@voyantjs/travel-composer 0.55.0

package/dist/service-helpers.js

@@ -0,0 +1,161 @@
+import { isCatalogBackedTripComponent } from "./catalog-component-adapter.js";
+import { TravelComposerInvariantError } from "./service-types.js";
+import { isAllowedTripComponentStatusTransition, isTerminalTripComponentStatus, } from "./validation.js";
+export function hasCommittedComponentReference(component) {
+    return Boolean(component.bookingId ||
+        component.bookingGroupId ||
+        component.orderId ||
+        component.paymentSessionId ||
+        component.providerRef ||
+        component.supplierRef);
+}
+export function assertTripComponentCanBeUpdated(component, patch) {
+    if (isTerminalTripComponentStatus(component.status)) {
+        throw new TravelComposerInvariantError(`Trip component ${component.id} is ${component.status} and cannot be updated`);
+    }
+    if (patch.status && !isAllowedTripComponentStatusTransition(component.status, patch.status)) {
+        throw new TravelComposerInvariantError(`Invalid trip component status transition: ${component.status} -> ${patch.status}`);
+    }
+    if (hasCommittedComponentReference(component) && patch.catalogRef !== undefined) {
+        throw new TravelComposerInvariantError(`Trip component ${component.id} has committed references and cannot change catalog identity`);
+    }
+}
+export function assertTripComponentCanReceiveRefs(component, refs) {
+    if (isTerminalTripComponentStatus(component.status)) {
+        throw new TravelComposerInvariantError(`Trip component ${component.id} is ${component.status} and cannot receive references`);
+    }
+    if (hasCommittedComponentReference(component) &&
+        refs.committedRef &&
+        Object.keys(refs.committedRef).length > 0) {
+        throw new TravelComposerInvariantError(`Trip component ${component.id} already has committed references`);
+    }
+}
+export function assertTripComponentCanBeReserved(component, now = new Date()) {
+    if (component.status !== "priced") {
+        throw new TravelComposerInvariantError(`Trip component ${component.id} is ${component.status} and must be priced before reserve`);
+    }
+    if (!isCatalogBackedTripComponent(component)) {
+        throw new TravelComposerInvariantError(`Trip component ${component.id} is not a catalog-backed booking component`);
+    }
+    if (!component.pricingSnapshot) {
+        throw new TravelComposerInvariantError(`Trip component ${component.id} has no pricing snapshot to reserve`);
+    }
+    if (component.priceExpiresAt && component.priceExpiresAt.getTime() <= now.getTime()) {
+        throw new TravelComposerInvariantError(`Trip component ${component.id} price has expired`);
+    }
+}
+export function reserveResultToComponentPatch(result) {
+    const patch = {
+        status: result.status,
+    };
+    if (result.bookingId !== undefined)
+        patch.bookingId = result.bookingId;
+    if (result.bookingGroupId !== undefined)
+        patch.bookingGroupId = result.bookingGroupId;
+    if (result.orderId !== undefined)
+        patch.orderId = result.orderId;
+    if (result.paymentSessionId !== undefined)
+        patch.paymentSessionId = result.paymentSessionId;
+    if (result.providerRef !== undefined)
+        patch.providerRef = result.providerRef;
+    if (result.supplierRef !== undefined)
+        patch.supplierRef = result.supplierRef;
+    if (result.holdToken !== undefined)
+        patch.holdToken = result.holdToken;
+    if (result.holdExpiresAt !== undefined)
+        patch.holdExpiresAt = new Date(result.holdExpiresAt);
+    return patch;
+}
+export function shouldReplayReserve(envelope, idempotencyKey) {
+    return Boolean(idempotencyKey &&
+        envelope.reserveIdempotencyKey === idempotencyKey &&
+        ["reserved", "checkout_started", "booked"].includes(envelope.status));
+}
+export function shouldReplayCheckout(envelope, idempotencyKey) {
+    return Boolean(idempotencyKey &&
+        envelope.checkoutIdempotencyKey === idempotencyKey &&
+        ["checkout_started", "booked"].includes(envelope.status));
+}
+export function assertTripComponentCanStartCheckout(component, now = new Date()) {
+    if (component.status !== "held" && component.status !== "booked") {
+        throw new TravelComposerInvariantError(`Trip component ${component.id} is ${component.status} and must be held or booked before checkout`);
+    }
+    if (!component.bookingId && !component.orderId) {
+        throw new TravelComposerInvariantError(`Trip component ${component.id} has no booking/order reference for checkout`);
+    }
+    if (component.holdExpiresAt && component.holdExpiresAt.getTime() <= now.getTime()) {
+        throw new TravelComposerInvariantError(`Trip component ${component.id} hold has expired`);
+    }
+}
+export function checkoutResultToComponentPatch(result) {
+    const patch = {
+        status: result.status ?? "checkout_started",
+    };
+    if (result.bookingId !== undefined)
+        patch.bookingId = result.bookingId;
+    if (result.bookingGroupId !== undefined)
+        patch.bookingGroupId = result.bookingGroupId;
+    if (result.orderId !== undefined)
+        patch.orderId = result.orderId;
+    if (result.paymentSessionId !== undefined)
+        patch.paymentSessionId = result.paymentSessionId;
+    if (result.providerRef !== undefined)
+        patch.providerRef = result.providerRef;
+    if (result.supplierRef !== undefined)
+        patch.supplierRef = result.supplierRef;
+    return patch;
+}
+export function pricingSnapshotFromBreakdown(pricing, priceExpiresAt, warnings) {
+    return {
+        currency: pricing.currency,
+        subtotalAmountCents: pricing.subtotal,
+        taxAmountCents: pricing.taxTotal,
+        totalAmountCents: pricing.total,
+        priceExpiresAt,
+        warnings,
+    };
+}
+export function taxLinesFromBreakdown(pricing) {
+    return pricing.taxes.map((tax) => ({
+        code: tax.code,
+        label: tax.label,
+        amountCents: tax.amount,
+        baseAmountCents: tax.base,
+        rate: tax.rate,
+        includedInPrice: tax.includedInPrice,
+        source: tax.scope,
+    }));
+}
+export function aggregateComponentPricing(components, preferredCurrency) {
+    const priced = components.filter((component) => component.pricingSnapshot);
+    const currency = preferredCurrency ?? priced[0]?.pricingSnapshot?.currency ?? "EUR";
+    const warnings = new Set();
+    let subtotalAmountCents = 0;
+    let taxAmountCents = 0;
+    let totalAmountCents = 0;
+    for (const component of priced) {
+        const snapshot = component.pricingSnapshot;
+        if (!snapshot)
+            continue;
+        if (snapshot.currency !== currency) {
+            warnings.add(`currency_mismatch:${snapshot.currency}`);
+            continue;
+        }
+        subtotalAmountCents += snapshot.subtotalAmountCents;
+        taxAmountCents += snapshot.taxAmountCents;
+        totalAmountCents += snapshot.totalAmountCents;
+        for (const warning of snapshot.warnings ?? [])
+            warnings.add(warning);
+        for (const warning of component.warningCodes ?? [])
+            warnings.add(warning);
+    }
+    return {
+        currency,
+        subtotalAmountCents,
+        taxAmountCents,
+        totalAmountCents,
+        componentCount: components.length,
+        pricedComponentCount: priced.length,
+        warnings: [...warnings],
+    };
+}

package/dist/service-internals.d.ts

@@ -0,0 +1,11 @@
+import type { AnyDrizzleDb } from "@voyantjs/db";
+import type { NewTripComponentEvent, TripComponent } from "./schema.js";
+import type { TripComponentStatus } from "./validation.js";
+export declare function createComponentEvent(db: AnyDrizzleDb, data: Omit<NewTripComponentEvent, "id" | "occurredAt">): Promise<void>;
+export declare function statusToEventType(to: TripComponentStatus): NewTripComponentEvent["eventType"];
+export declare function appendWarningCodes(existing: string[], incoming: string[]): string[];
+export declare function markComponentForStaffRemediation(db: AnyDrizzleDb, component: TripComponent, reason: string): Promise<TripComponent>;
+export declare function commonString(values: Array<string | undefined>): string | undefined;
+export declare function minComponentPriceExpiry(components: TripComponent[]): Date | null;
+export declare function minComponentHoldExpiry(components: TripComponent[]): Date | null;
+//# sourceMappingURL=service-internals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-internals.d.ts","sourceRoot":"","sources":["../src/service-internals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAGhD,OAAO,KAAK,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAE1D,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,YAAY,EAChB,IAAI,EAAE,IAAI,CAAC,qBAAqB,EAAE,IAAI,GAAG,YAAY,CAAC,iBAGvD;AAED,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,mBAAmB,GAAG,qBAAqB,CAAC,WAAW,CAAC,CAoB7F;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAEnF;AAED,wBAAsB,gCAAgC,CACpD,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,aAAa,EACxB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,aAAa,CAAC,CA2BxB;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,GAAG,SAAS,CAGlF;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,aAAa,EAAE,GAAG,IAAI,GAAG,IAAI,CAMhF;AAED,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,aAAa,EAAE,GAAG,IAAI,GAAG,IAAI,CAM/E"}

package/dist/service-internals.js

@@ -0,0 +1,72 @@
+import { eq } from "drizzle-orm";
+import { tripComponentEvents, tripComponents } from "./schema.js";
+export async function createComponentEvent(db, data) {
+    await db.insert(tripComponentEvents).values(data);
+}
+export function statusToEventType(to) {
+    switch (to) {
+        case "priced":
+        case "unavailable":
+            return "priced";
+        case "held":
+            return "hold_placed";
+        case "booked":
+            return "booked";
+        case "checkout_started":
+            return "checkout_started";
+        case "failed":
+            return "failed";
+        case "cancelled":
+            return "cancelled";
+        case "removed":
+            return "removed";
+        case "draft":
+            return "updated";
+    }
+}
+export function appendWarningCodes(existing, incoming) {
+    return [...new Set([...existing, ...incoming])];
+}
+export async function markComponentForStaffRemediation(db, component, reason) {
+    const [updated] = (await db
+        .update(tripComponents)
+        .set({
+        warningCodes: appendWarningCodes(component.warningCodes, [
+            "staff_remediation_required",
+            reason,
+        ]),
+        updatedAt: new Date(),
+    })
+        .where(eq(tripComponents.id, component.id))
+        .returning());
+    if (!updated) {
+        throw new Error(`markComponentForStaffRemediation: update returned no row for ${component.id}`);
+    }
+    await createComponentEvent(db, {
+        envelopeId: updated.envelopeId,
+        componentId: updated.id,
+        eventType: "staff_remediation_required",
+        fromStatus: component.status,
+        toStatus: updated.status,
+        payload: { reason },
+    });
+    return updated;
+}
+export function commonString(values) {
+    const unique = [...new Set(values.filter((value) => Boolean(value)))];
+    return unique.length === 1 ? unique[0] : undefined;
+}
+export function minComponentPriceExpiry(components) {
+    const expiries = components
+        .map((component) => component.priceExpiresAt)
+        .filter((value) => value instanceof Date)
+        .sort((a, b) => a.getTime() - b.getTime());
+    return expiries[0] ?? null;
+}
+export function minComponentHoldExpiry(components) {
+    const expiries = components
+        .map((component) => component.holdExpiresAt)
+        .filter((value) => value instanceof Date)
+        .sort((a, b) => a.getTime() - b.getTime());
+    return expiries[0] ?? null;
+}

package/dist/service-pricing.d.ts

@@ -0,0 +1,8 @@
+import type { QuoteResponseV1 } from "@voyantjs/catalog/booking-engine";
+import type { AnyDrizzleDb } from "@voyantjs/db";
+import type { TripComponent } from "./schema.js";
+import type { PriceTripDeps, PriceTripResult } from "./service-types.js";
+import type { PriceTripInput } from "./validation.js";
+export declare function priceTrip(db: AnyDrizzleDb, input: PriceTripInput, deps: PriceTripDeps): Promise<PriceTripResult>;
+export declare function applyQuoteToComponent(db: AnyDrizzleDb, component: TripComponent, quote: QuoteResponseV1): Promise<TripComponent>;
+//# sourceMappingURL=service-pricing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-pricing.d.ts","sourceRoot":"","sources":["../src/service-pricing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAA;AACvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAIhD,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,aAAa,CAAA;AAU9D,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAExE,OAAO,KAAK,EAAE,cAAc,EAAuB,MAAM,iBAAiB,CAAA;AAE1E,wBAAsB,SAAS,CAC7B,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,eAAe,CAAC,CA0E1B;AAED,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,eAAe,GACrB,OAAO,CAAC,aAAa,CAAC,CA8CxB"}

package/dist/service-pricing.js

@@ -0,0 +1,142 @@
+import { eq } from "drizzle-orm";
+import { isCatalogBackedTripComponent, toBookingDraftV1 } from "./catalog-component-adapter.js";
+import { tripComponents, tripEnvelopes } from "./schema.js";
+import { aggregateComponentPricing, assertTripComponentCanBeUpdated, pricingSnapshotFromBreakdown, taxLinesFromBreakdown, } from "./service-helpers.js";
+import { createComponentEvent, minComponentPriceExpiry } from "./service-internals.js";
+import { getTrip } from "./service-trips.js";
+import { TravelComposerInvariantError } from "./service-types.js";
+export async function priceTrip(db, input, deps) {
+    const trip = await getTrip(db, input.envelopeId);
+    if (!trip) {
+        throw new TravelComposerInvariantError(`Trip envelope ${input.envelopeId} was not found`);
+    }
+    const warnings = new Set();
+    const failures = [];
+    const pricedComponents = [];
+    for (const component of trip.components) {
+        if (component.status === "removed" || component.status === "cancelled") {
+            pricedComponents.push(component);
+            continue;
+        }
+        if (isCatalogBackedTripComponent(component)) {
+            const quote = await deps.quoteCatalogComponent({
+                component,
+                bookingDraft: toBookingDraftV1(component, deps.componentBookingDraftOverrides?.[component.id]),
+                scope: input.scope,
+                ttlMs: input.ttlMs,
+            });
+            const updated = await applyQuoteToComponent(db, component, quote);
+            pricedComponents.push(updated);
+            if (!quote.available || !quote.pricing) {
+                const reason = quote.invalidReason ?? "quote_unavailable";
+                warnings.add(reason);
+                failures.push({ componentId: component.id, reason });
+            }
+            continue;
+        }
+        const updated = await applyPlaceholderPricing(db, component);
+        pricedComponents.push(updated);
+        for (const warning of updated.warningCodes)
+            warnings.add(warning);
+        if (!updated.pricingSnapshot) {
+            failures.push({ componentId: component.id, reason: "manual_price_missing" });
+        }
+    }
+    const aggregate = aggregateComponentPricing(pricedComponents, input.scope.currency);
+    for (const warning of aggregate.warnings ?? [])
+        warnings.add(warning);
+    const pricing = { ...aggregate, warnings: [...warnings] };
+    const [envelope] = (await db
+        .update(tripEnvelopes)
+        .set({
+        status: "priced",
+        aggregateCurrency: pricing.currency,
+        aggregateSubtotalAmountCents: pricing.subtotalAmountCents,
+        aggregateTaxAmountCents: pricing.taxAmountCents,
+        aggregateTotalAmountCents: pricing.totalAmountCents,
+        aggregatePricingSnapshot: pricing,
+        currentPriceExpiresAt: minComponentPriceExpiry(pricedComponents),
+        updatedAt: new Date(),
+    })
+        .where(eq(tripEnvelopes.id, input.envelopeId))
+        .returning());
+    if (!envelope) {
+        throw new Error("priceTrip: envelope update returned no rows");
+    }
+    return {
+        envelope,
+        components: pricedComponents,
+        pricing,
+        warnings: [...warnings],
+        failures,
+    };
+}
+export async function applyQuoteToComponent(db, component, quote) {
+    const pricingSnapshot = quote.pricing
+        ? pricingSnapshotFromBreakdown(quote.pricing, quote.expiresAt)
+        : undefined;
+    const warningCodes = quote.invalidReason ? [quote.invalidReason] : [];
+    const nextStatus = quote.available && quote.pricing ? "priced" : "unavailable";
+    assertTripComponentCanBeUpdated(component, { status: nextStatus });
+    const [updated] = (await db
+        .update(tripComponents)
+        .set({
+        status: nextStatus,
+        catalogQuoteId: quote.quoteId,
+        componentCurrency: pricingSnapshot?.currency ?? null,
+        componentSubtotalAmountCents: pricingSnapshot?.subtotalAmountCents ?? null,
+        componentTaxAmountCents: pricingSnapshot?.taxAmountCents ?? null,
+        componentTotalAmountCents: pricingSnapshot?.totalAmountCents ?? null,
+        pricingSnapshot,
+        taxLines: quote.pricing ? taxLinesFromBreakdown(quote.pricing) : [],
+        priceExpiresAt: quote.expiresAt ? new Date(quote.expiresAt) : null,
+        warningCodes,
+        updatedAt: new Date(),
+    })
+        .where(eq(tripComponents.id, component.id))
+        .returning());
+    if (!updated) {
+        throw new Error(`applyQuoteToComponent: update returned no row for ${component.id}`);
+    }
+    await createComponentEvent(db, {
+        envelopeId: updated.envelopeId,
+        componentId: updated.id,
+        eventType: "priced",
+        fromStatus: component.status,
+        toStatus: updated.status,
+        payload: {
+            quoteId: quote.quoteId,
+            available: quote.available,
+            invalidReason: quote.invalidReason,
+        },
+    });
+    return updated;
+}
+async function applyPlaceholderPricing(db, component) {
+    const warningCodes = component.pricingSnapshot
+        ? ["manual_placeholder_price"]
+        : ["manual_price_missing"];
+    const nextStatus = component.pricingSnapshot ? "priced" : "unavailable";
+    assertTripComponentCanBeUpdated(component, { status: nextStatus });
+    const [updated] = (await db
+        .update(tripComponents)
+        .set({
+        status: nextStatus,
+        warningCodes,
+        updatedAt: new Date(),
+    })
+        .where(eq(tripComponents.id, component.id))
+        .returning());
+    if (!updated) {
+        throw new Error(`applyPlaceholderPricing: update returned no row for ${component.id}`);
+    }
+    await createComponentEvent(db, {
+        envelopeId: updated.envelopeId,
+        componentId: updated.id,
+        eventType: "priced",
+        fromStatus: component.status,
+        toStatus: updated.status,
+        payload: { placeholder: true },
+    });
+    return updated;
+}

package/dist/service-reservation.d.ts

@@ -0,0 +1,5 @@
+import type { AnyDrizzleDb } from "@voyantjs/db";
+import type { ReserveTripDeps, ReserveTripResult } from "./service-types.js";
+import { type ReserveTripInput } from "./validation.js";
+export declare function reserveTrip(db: AnyDrizzleDb, input: ReserveTripInput, deps: ReserveTripDeps): Promise<ReserveTripResult>;
+//# sourceMappingURL=service-reservation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-reservation.d.ts","sourceRoot":"","sources":["../src/service-reservation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAuBhD,OAAO,KAAK,EAGV,eAAe,EACf,iBAAiB,EAElB,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EAA0C,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAE/F,wBAAsB,WAAW,CAC/B,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,gBAAgB,EACvB,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,iBAAiB,CAAC,CAqK5B"}