@voyant-travel/trips 0.110.2

package/dist/service-snapshots.js

@@ -0,0 +1,115 @@
+import { desc, eq } from "drizzle-orm";
+import { tripSnapshots } from "./schema.js";
+import { aggregateComponentPricing } from "./service-helpers.js";
+import { getTrip } from "./service-trips.js";
+import { TripsInvariantError } from "./service-types.js";
+export async function freezeTripSnapshot(db, input) {
+    const trip = await getTrip(db, input.envelopeId);
+    if (!trip) {
+        throw new TripsInvariantError(`Trip envelope ${input.envelopeId} was not found`);
+    }
+    const components = trip.components.filter((component) => component.status !== "removed");
+    const missingPricing = components.filter((component) => !component.pricingSnapshot);
+    if (missingPricing.length > 0) {
+        throw new TripsInvariantError(`Cannot freeze trip ${input.envelopeId}; components missing pricing snapshots: ${missingPricing
+            .map((component) => component.id)
+            .join(", ")}`);
+    }
+    const frozenAt = new Date();
+    const proposal = buildTripSnapshotProposal(trip.envelope, components, frozenAt);
+    const values = {
+        envelopeId: trip.envelope.id,
+        sourceEnvelopeUpdatedAt: trip.envelope.updatedAt ?? frozenAt,
+        titleSnapshot: trip.envelope.title,
+        descriptionSnapshot: trip.envelope.description,
+        travelerPartySnapshot: snapshotJsonRecord(trip.envelope.travelerParty),
+        constraintsSnapshot: snapshotJsonRecord(trip.envelope.constraints),
+        currency: proposal.currency,
+        subtotalAmountCents: proposal.subtotalAmountCents,
+        taxAmountCents: proposal.taxAmountCents,
+        totalAmountCents: proposal.totalAmountCents,
+        componentCount: proposal.componentCount,
+        pricedComponentCount: proposal.pricedComponentCount,
+        frozenEnvelope: snapshotJsonRecord(trip.envelope),
+        frozenComponents: components.map(snapshotJsonRecord),
+        proposal,
+        createdBy: input.createdBy ?? null,
+    };
+    const [snapshot] = (await db.insert(tripSnapshots).values(values).returning());
+    if (!snapshot)
+        throw new Error("freezeTripSnapshot: insert returned no snapshot");
+    return snapshot;
+}
+export async function getTripSnapshotById(db, snapshotId) {
+    const [snapshot] = (await db
+        .select()
+        .from(tripSnapshots)
+        .where(eq(tripSnapshots.id, snapshotId))
+        .limit(1));
+    return snapshot ?? null;
+}
+export async function listTripSnapshots(db, envelopeId) {
+    return (await db
+        .select()
+        .from(tripSnapshots)
+        .where(eq(tripSnapshots.envelopeId, envelopeId))
+        .orderBy(desc(tripSnapshots.createdAt)));
+}
+export function buildTripSnapshotProposal(envelope, components, frozenAt) {
+    const aggregate = aggregateComponentPricing(components, envelope.aggregateCurrency ?? undefined);
+    return {
+        envelopeId: envelope.id,
+        title: envelope.title,
+        description: envelope.description,
+        currency: aggregate.currency,
+        subtotalAmountCents: aggregate.subtotalAmountCents,
+        taxAmountCents: aggregate.taxAmountCents,
+        totalAmountCents: aggregate.totalAmountCents,
+        componentCount: aggregate.componentCount,
+        pricedComponentCount: aggregate.pricedComponentCount,
+        warnings: aggregate.warnings ?? [],
+        frozenAt: frozenAt.toISOString(),
+        lines: components.map(componentToProposalLine),
+    };
+}
+function componentToProposalLine(component) {
+    const pricing = component.pricingSnapshot;
+    if (!pricing) {
+        throw new TripsInvariantError(`Cannot build proposal line for unpriced component ${component.id}`);
+    }
+    return {
+        componentId: component.id,
+        sequence: component.sequence,
+        kind: component.kind,
+        status: component.status,
+        title: component.title,
+        description: componentDisplayName(component),
+        entityModule: component.entityModule,
+        entityId: component.entityId,
+        sourceKind: component.sourceKind,
+        currency: pricing.currency,
+        subtotalAmountCents: pricing.subtotalAmountCents,
+        taxAmountCents: pricing.taxAmountCents,
+        totalAmountCents: pricing.totalAmountCents,
+        priceExpiresAt: pricing.priceExpiresAt ?? component.priceExpiresAt?.toISOString() ?? null,
+        warnings: [...new Set([...(pricing.warnings ?? []), ...(component.warningCodes ?? [])])],
+    };
+}
+function componentDisplayName(component) {
+    const metadata = component.metadata;
+    const manualServiceName = metadata.manualService?.name;
+    if (typeof component.title === "string" && component.title.trim())
+        return component.title;
+    if (typeof manualServiceName === "string" && manualServiceName.trim()) {
+        return manualServiceName.trim();
+    }
+    if (typeof component.description === "string" && component.description.trim()) {
+        return component.description;
+    }
+    if (component.entityModule && component.entityId)
+        return `${component.entityModule}:${component.entityId}`;
+    return component.kind.replaceAll("_", " ");
+}
+function snapshotJsonRecord(value) {
+    return JSON.parse(JSON.stringify(value));
+}

package/dist/service-trips.d.ts

@@ -0,0 +1,14 @@
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import type { TripComponent, TripEnvelope } from "./schema.js";
+import { type Trip, type TripListResult } from "./service-types.js";
+import type { CreateTripComponentInput, CreateTripEnvelopeInput, ListTripsQuery, ReorderTripComponentsInput, UpdateTripComponentInput, UpdateTripComponentRefsInput, UpdateTripEnvelopeInput } from "./validation.js";
+export declare function createTrip(db: AnyDrizzleDb, input: CreateTripEnvelopeInput): Promise<Trip>;
+export declare function getTrip(db: AnyDrizzleDb, envelopeId: string): Promise<Trip | null>;
+export declare function listTrips(db: AnyDrizzleDb, input?: ListTripsQuery): Promise<TripListResult>;
+export declare function updateTrip(db: AnyDrizzleDb, envelopeId: string, input: UpdateTripEnvelopeInput): Promise<TripEnvelope | null>;
+export declare function addComponent(db: AnyDrizzleDb, input: CreateTripComponentInput): Promise<TripComponent>;
+export declare function updateComponent(db: AnyDrizzleDb, componentId: string, input: UpdateTripComponentInput): Promise<TripComponent | null>;
+export declare function updateComponentRefs(db: AnyDrizzleDb, componentId: string, input: UpdateTripComponentRefsInput): Promise<TripComponent | null>;
+export declare function removeComponent(db: AnyDrizzleDb, componentId: string): Promise<TripComponent | null>;
+export declare function reorderComponents(db: AnyDrizzleDb, input: ReorderTripComponentsInput): Promise<TripComponent[]>;
+//# sourceMappingURL=service-trips.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-trips.d.ts","sourceRoot":"","sources":["../src/service-trips.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAGrD,OAAO,KAAK,EAAqC,aAAa,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAOjG,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,cAAc,EAAuB,MAAM,oBAAoB,CAAA;AAExF,OAAO,KAAK,EACV,wBAAwB,EACxB,uBAAuB,EACvB,cAAc,EACd,0BAA0B,EAC1B,wBAAwB,EACxB,4BAA4B,EAC5B,uBAAuB,EACxB,MAAM,iBAAiB,CAAA;AAExB,wBAAsB,UAAU,CAAC,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBhG;AAED,wBAAsB,OAAO,CAAC,EAAE,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAexF;AAED,wBAAsB,SAAS,CAC7B,EAAE,EAAE,YAAY,EAChB,KAAK,GAAE,cAKN,GACA,OAAO,CAAC,cAAc,CAAC,CAsIzB;AAqBD,wBAAsB,UAAU,CAC9B,EAAE,EAAE,YAAY,EAChB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,uBAAuB,GAC7B,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAsB9B;AAED,wBAAsB,YAAY,CAChC,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,wBAAwB,GAC9B,OAAO,CAAC,aAAa,CAAC,CAkCxB;AAED,wBAAsB,eAAe,CACnC,EAAE,EAAE,YAAY,EAChB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,wBAAwB,GAC9B,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CA+B/B;AAED,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,YAAY,EAChB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CA8B/B;AAED,wBAAsB,eAAe,CACnC,EAAE,EAAE,YAAY,EAChB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAE/B;AAED,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,aAAa,EAAE,CAAC,CAkC1B"}

package/dist/service-trips.js

@@ -0,0 +1,378 @@
+import { asc, eq, inArray } from "drizzle-orm";
+import { tripComponents, tripEnvelopes } from "./schema.js";
+import { assertTripComponentCanBeUpdated, assertTripComponentCanReceiveRefs, } from "./service-helpers.js";
+import { createComponentEvent, statusToEventType } from "./service-internals.js";
+import { TripsInvariantError } from "./service-types.js";
+import { assertTripTravelerPartyComplete } from "./traveler-party-validation.js";
+export async function createTrip(db, input) {
+    assertTripTravelerPartyComplete(input.travelerParty, "Trip creation");
+    const values = {
+        title: input.title,
+        description: input.description,
+        travelerParty: input.travelerParty,
+        constraints: input.constraints,
+        createdBy: input.createdBy,
+        updatedBy: input.createdBy,
+    };
+    const [envelope] = (await db.insert(tripEnvelopes).values(values).returning());
+    if (!envelope)
+        throw new Error("createTrip: insert returned no envelope");
+    return { envelope, components: [] };
+}
+export async function getTrip(db, envelopeId) {
+    const [envelope] = (await db
+        .select()
+        .from(tripEnvelopes)
+        .where(eq(tripEnvelopes.id, envelopeId))
+        .limit(1));
+    if (!envelope)
+        return null;
+    const components = (await db
+        .select()
+        .from(tripComponents)
+        .where(eq(tripComponents.envelopeId, envelopeId))
+        .orderBy(asc(tripComponents.sequence), asc(tripComponents.createdAt)));
+    return { envelope, components };
+}
+export async function listTrips(db, input = {
+    limit: 50,
+    offset: 0,
+    sortBy: "updatedAt",
+    sortDir: "desc",
+}) {
+    const allEnvelopes = (await db.select().from(tripEnvelopes));
+    const needsComponents = input.productId !== undefined ||
+        input.accommodationId !== undefined ||
+        input.cruiseId !== undefined ||
+        input.hasFlight === true;
+    // When a component-based filter is active we have to know each envelope's
+    // components *before* paging, so fetch them up front. Otherwise we keep the
+    // cheap path that only loads components for the visible page.
+    const allComponents = needsComponents
+        ? (await db
+            .select()
+            .from(tripComponents)
+            .orderBy(asc(tripComponents.sequence), asc(tripComponents.createdAt)))
+        : [];
+    const allComponentsByEnvelope = new Map();
+    if (needsComponents) {
+        for (const component of allComponents) {
+            if (component.status === "removed")
+                continue;
+            const bucket = allComponentsByEnvelope.get(component.envelopeId) ?? [];
+            bucket.push(component);
+            allComponentsByEnvelope.set(component.envelopeId, bucket);
+        }
+    }
+    const normalizedSearch = input.search?.toLowerCase();
+    const createdFromMs = parseDateMs(input.createdFrom);
+    const createdToMs = parseEndDateMs(input.createdTo);
+    const filtered = allEnvelopes.filter((envelope) => {
+        if (input.status && envelope.status !== input.status)
+            return false;
+        if (normalizedSearch) {
+            const matches = [envelope.id, envelope.title, envelope.description]
+                .filter((value) => typeof value === "string")
+                .some((value) => value.toLowerCase().includes(normalizedSearch));
+            if (!matches)
+                return false;
+        }
+        if (input.totalMinCents !== undefined) {
+            const total = envelope.aggregateTotalAmountCents ?? null;
+            if (total === null || total < input.totalMinCents)
+                return false;
+        }
+        if (input.totalMaxCents !== undefined) {
+            const total = envelope.aggregateTotalAmountCents ?? null;
+            if (total === null || total > input.totalMaxCents)
+                return false;
+        }
+        if (createdFromMs !== null) {
+            const ts = envelope.createdAt?.getTime() ?? null;
+            if (ts === null || ts < createdFromMs)
+                return false;
+        }
+        if (createdToMs !== null) {
+            const ts = envelope.createdAt?.getTime() ?? null;
+            if (ts === null || ts > createdToMs)
+                return false;
+        }
+        if (needsComponents) {
+            const envelopeComponents = allComponentsByEnvelope.get(envelope.id) ?? [];
+            if (input.productId &&
+                !envelopeComponents.some((component) => component.entityModule === "products" && component.entityId === input.productId)) {
+                return false;
+            }
+            if (input.accommodationId &&
+                !envelopeComponents.some((component) => component.entityModule === "accommodations" &&
+                    component.entityId === input.accommodationId)) {
+                return false;
+            }
+            if (input.cruiseId &&
+                !envelopeComponents.some((component) => component.entityModule === "cruises" && component.entityId === input.cruiseId)) {
+                return false;
+            }
+            if (input.hasFlight === true &&
+                !envelopeComponents.some((component) => component.kind === "flight_placeholder" || component.kind === "flight_order")) {
+                return false;
+            }
+        }
+        return true;
+    });
+    const sortDirection = input.sortDir === "asc" ? 1 : -1;
+    filtered.sort((a, b) => {
+        const compare = compareEnvelopes(a, b, input.sortBy);
+        if (compare !== 0)
+            return compare * sortDirection;
+        const updatedDelta = (b.updatedAt?.getTime() ?? 0) - (a.updatedAt?.getTime() ?? 0);
+        if (updatedDelta !== 0)
+            return updatedDelta;
+        return (b.createdAt?.getTime() ?? 0) - (a.createdAt?.getTime() ?? 0);
+    });
+    const page = filtered.slice(input.offset, input.offset + input.limit);
+    const envelopeIds = page.map((envelope) => envelope.id);
+    const components = needsComponents
+        ? envelopeIds.flatMap((id) => allComponentsByEnvelope.get(id) ?? [])
+        : envelopeIds.length > 0
+            ? (await db
+                .select()
+                .from(tripComponents)
+                .where(inArray(tripComponents.envelopeId, envelopeIds))
+                .orderBy(asc(tripComponents.sequence), asc(tripComponents.createdAt)))
+            : [];
+    const componentsByEnvelope = new Map();
+    for (const component of components) {
+        const bucket = componentsByEnvelope.get(component.envelopeId) ?? [];
+        bucket.push(component);
+        componentsByEnvelope.set(component.envelopeId, bucket);
+    }
+    return {
+        data: page.map((envelope) => ({
+            envelope,
+            components: componentsByEnvelope.get(envelope.id) ?? [],
+        })),
+        total: filtered.length,
+        limit: input.limit,
+        offset: input.offset,
+    };
+}
+function parseDateMs(value) {
+    if (!value)
+        return null;
+    const ts = new Date(value).getTime();
+    return Number.isFinite(ts) ? ts : null;
+}
+function parseEndDateMs(value) {
+    if (!value)
+        return null;
+    // Date-only `YYYY-MM-DD` strings should match the whole day. Use the end
+    // of that day in UTC so callers comparing `createdAt <= createdTo` get the
+    // intuitive inclusive behaviour.
+    if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+        const ts = new Date(`${value}T23:59:59.999Z`).getTime();
+        return Number.isFinite(ts) ? ts : null;
+    }
+    const ts = new Date(value).getTime();
+    return Number.isFinite(ts) ? ts : null;
+}
+export async function updateTrip(db, envelopeId, input) {
+    if (input.travelerParty !== undefined) {
+        assertTripTravelerPartyComplete(input.travelerParty, "Trip update");
+    }
+    const updates = {
+        updatedAt: new Date(),
+    };
+    if (input.title !== undefined)
+        updates.title = input.title;
+    if (input.description !== undefined)
+        updates.description = input.description;
+    if (input.travelerParty !== undefined)
+        updates.travelerParty = input.travelerParty;
+    if (input.constraints !== undefined)
+        updates.constraints = input.constraints;
+    if (input.status !== undefined)
+        updates.status = input.status;
+    if (input.updatedBy !== undefined)
+        updates.updatedBy = input.updatedBy;
+    const [row] = (await db
+        .update(tripEnvelopes)
+        .set(updates)
+        .where(eq(tripEnvelopes.id, envelopeId))
+        .returning());
+    return row ?? null;
+}
+export async function addComponent(db, input) {
+    const values = {
+        envelopeId: input.envelopeId,
+        sequence: input.sequence,
+        kind: input.kind,
+        description: input.description,
+        entityModule: input.catalogRef?.entityModule,
+        entityId: input.catalogRef?.entityId,
+        sourceKind: input.catalogRef?.sourceKind,
+        sourceConnectionId: input.catalogRef?.sourceConnectionId,
+        sourceRef: input.catalogRef?.sourceRef,
+        componentCurrency: input.estimatedPricing?.currency,
+        componentSubtotalAmountCents: input.estimatedPricing?.subtotalAmountCents,
+        componentTaxAmountCents: input.estimatedPricing?.taxAmountCents,
+        componentTotalAmountCents: input.estimatedPricing?.totalAmountCents,
+        pricingSnapshot: input.estimatedPricing,
+        metadata: input.metadata,
+    };
+    const [component] = (await db
+        .insert(tripComponents)
+        .values(values)
+        .returning());
+    if (!component)
+        throw new Error("addComponent: insert returned no component");
+    await createComponentEvent(db, {
+        envelopeId: component.envelopeId,
+        componentId: component.id,
+        eventType: "created",
+        toStatus: component.status,
+        payload: {},
+    });
+    return component;
+}
+export async function updateComponent(db, componentId, input) {
+    const existing = await getTripComponentOrThrow(db, componentId);
+    assertTripComponentCanBeUpdated(existing, input);
+    const updates = {
+        updatedAt: new Date(),
+        ...toCatalogRefPatch(input.catalogRef),
+    };
+    if (input.sequence !== undefined)
+        updates.sequence = input.sequence;
+    if (input.status !== undefined)
+        updates.status = input.status;
+    if (input.description !== undefined)
+        updates.description = input.description;
+    if (input.metadata !== undefined)
+        updates.metadata = input.metadata;
+    if (input.warningCodes !== undefined)
+        updates.warningCodes = input.warningCodes;
+    const [component] = (await db
+        .update(tripComponents)
+        .set(updates)
+        .where(eq(tripComponents.id, componentId))
+        .returning());
+    if (!component)
+        return null;
+    await createComponentEvent(db, {
+        envelopeId: component.envelopeId,
+        componentId: component.id,
+        eventType: input.status ? statusToEventType(input.status) : "updated",
+        fromStatus: existing.status,
+        toStatus: component.status,
+        payload: {},
+    });
+    return component;
+}
+export async function updateComponentRefs(db, componentId, input) {
+    const existing = await getTripComponentOrThrow(db, componentId);
+    assertTripComponentCanReceiveRefs(existing, input);
+    const updates = {
+        updatedAt: new Date(),
+    };
+    if (input.bookingDraftId !== undefined)
+        updates.bookingDraftId = input.bookingDraftId;
+    if (input.catalogQuoteId !== undefined)
+        updates.catalogQuoteId = input.catalogQuoteId;
+    if (input.committedRef?.bookingId !== undefined)
+        updates.bookingId = input.committedRef.bookingId;
+    if (input.committedRef?.bookingGroupId !== undefined) {
+        updates.bookingGroupId = input.committedRef.bookingGroupId;
+    }
+    if (input.committedRef?.orderId !== undefined)
+        updates.orderId = input.committedRef.orderId;
+    if (input.committedRef?.paymentSessionId !== undefined) {
+        updates.paymentSessionId = input.committedRef.paymentSessionId;
+    }
+    if (input.committedRef?.providerRef !== undefined) {
+        updates.providerRef = input.committedRef.providerRef;
+    }
+    if (input.committedRef?.supplierRef !== undefined) {
+        updates.supplierRef = input.committedRef.supplierRef;
+    }
+    const [component] = (await db
+        .update(tripComponents)
+        .set(updates)
+        .where(eq(tripComponents.id, componentId))
+        .returning());
+    return component ?? null;
+}
+export async function removeComponent(db, componentId) {
+    return updateComponent(db, componentId, { status: "removed" });
+}
+export async function reorderComponents(db, input) {
+    const rows = (await db
+        .select()
+        .from(tripComponents)
+        .where(inArray(tripComponents.id, input.componentIds)));
+    const found = new Set(rows.map((row) => row.id));
+    const missing = input.componentIds.filter((id) => !found.has(id));
+    if (missing.length > 0) {
+        throw new TripsInvariantError(`Cannot reorder missing trip components: ${missing.join(", ")}`);
+    }
+    for (const row of rows) {
+        if (row.envelopeId !== input.envelopeId) {
+            throw new TripsInvariantError(`Trip component ${row.id} does not belong to envelope ${input.envelopeId}`);
+        }
+        if (row.status === "removed") {
+            throw new TripsInvariantError(`Trip component ${row.id} is removed`);
+        }
+    }
+    const updated = [];
+    for (const [sequence, componentId] of input.componentIds.entries()) {
+        const [row] = (await db
+            .update(tripComponents)
+            .set({ sequence, updatedAt: new Date() })
+            .where(eq(tripComponents.id, componentId))
+            .returning());
+        if (row)
+            updated.push(row);
+    }
+    return updated.sort((a, b) => a.sequence - b.sequence);
+}
+function compareEnvelopes(a, b, field) {
+    switch (field) {
+        case "createdAt":
+            return (a.createdAt?.getTime() ?? 0) - (b.createdAt?.getTime() ?? 0);
+        case "status":
+            return a.status.localeCompare(b.status);
+        case "total":
+            return (a.aggregateTotalAmountCents ?? 0) - (b.aggregateTotalAmountCents ?? 0);
+        default:
+            return (a.updatedAt?.getTime() ?? 0) - (b.updatedAt?.getTime() ?? 0);
+    }
+}
+function toCatalogRefPatch(input) {
+    if (input === undefined)
+        return {};
+    if (input === null) {
+        return {
+            entityModule: null,
+            entityId: null,
+            sourceKind: null,
+            sourceConnectionId: null,
+            sourceRef: null,
+        };
+    }
+    return {
+        entityModule: input.entityModule,
+        entityId: input.entityId,
+        sourceKind: input.sourceKind,
+        sourceConnectionId: input.sourceConnectionId ?? null,
+        sourceRef: input.sourceRef ?? null,
+    };
+}
+async function getTripComponentOrThrow(db, id) {
+    const [component] = (await db
+        .select()
+        .from(tripComponents)
+        .where(eq(tripComponents.id, id))
+        .limit(1));
+    if (!component)
+        throw new TripsInvariantError(`Trip component ${id} was not found`);
+    return component;
+}