@voyantjs/travel-composer 0.55.0

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"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"}

package/dist/schema.js

@@ -0,0 +1,163 @@
+import { typeId, typeIdRef } from "@voyantjs/db/lib/typeid-column";
+import { relations } from "drizzle-orm";
+import { index, integer, jsonb, pgEnum, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+export const tripEnvelopeStatusEnum = pgEnum("trip_envelope_status", [
+    "draft",
+    "priced",
+    "reserve_in_progress",
+    "reserved",
+    "checkout_started",
+    "booked",
+    "failed",
+    "cancelled",
+]);
+export const tripComponentKindEnum = pgEnum("trip_component_kind", [
+    "catalog_booking",
+    "manual_placeholder",
+    "flight_placeholder",
+    "flight_order",
+    "external_order",
+]);
+export const tripComponentStatusEnum = pgEnum("trip_component_status", [
+    "draft",
+    "priced",
+    "unavailable",
+    "held",
+    "booked",
+    "checkout_started",
+    "failed",
+    "cancelled",
+    "removed",
+]);
+export const tripComponentEventTypeEnum = pgEnum("trip_component_event_type", [
+    "created",
+    "updated",
+    "priced",
+    "hold_placed",
+    "booked",
+    "checkout_started",
+    "failed",
+    "cancelled",
+    "removed",
+    "staff_remediation_required",
+]);
+export const tripEnvelopes = pgTable("trip_envelopes", {
+    id: typeId("trip_envelopes"),
+    status: tripEnvelopeStatusEnum("status").notNull().default("draft"),
+    title: text("title"),
+    description: text("description"),
+    travelerParty: jsonb("traveler_party").$type().notNull().default({}),
+    constraints: jsonb("constraints").$type().notNull().default({}),
+    aggregateCurrency: text("aggregate_currency"),
+    aggregateSubtotalAmountCents: integer("aggregate_subtotal_amount_cents"),
+    aggregateTaxAmountCents: integer("aggregate_tax_amount_cents"),
+    aggregateTotalAmountCents: integer("aggregate_total_amount_cents"),
+    aggregatePricingSnapshot: jsonb("aggregate_pricing_snapshot").$type(),
+    currentPriceExpiresAt: timestamp("current_price_expires_at", { withTimezone: true }),
+    bookingGroupId: text("booking_group_id"),
+    orderId: text("order_id"),
+    paymentSessionId: text("payment_session_id"),
+    reserveIdempotencyKey: text("reserve_idempotency_key"),
+    reserveStartedAt: timestamp("reserve_started_at", { withTimezone: true }),
+    reservedAt: timestamp("reserved_at", { withTimezone: true }),
+    checkoutIdempotencyKey: text("checkout_idempotency_key"),
+    checkoutStartedAt: timestamp("checkout_started_at", { withTimezone: true }),
+    createdBy: text("created_by"),
+    updatedBy: text("updated_by"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_trip_envelopes_status_updated").on(table.status, table.updatedAt),
+    index("idx_trip_envelopes_created_by_updated").on(table.createdBy, table.updatedAt),
+    index("idx_trip_envelopes_booking_group").on(table.bookingGroupId),
+    index("idx_trip_envelopes_payment_session").on(table.paymentSessionId),
+    index("idx_trip_envelopes_reserve_idempotency").on(table.reserveIdempotencyKey),
+    index("idx_trip_envelopes_checkout_idempotency").on(table.checkoutIdempotencyKey),
+]);
+export const tripComponents = pgTable("trip_components", {
+    id: typeId("trip_components"),
+    envelopeId: typeIdRef("envelope_id")
+        .notNull()
+        .references(() => tripEnvelopes.id, { onDelete: "cascade" }),
+    sequence: integer("sequence").notNull().default(0),
+    kind: tripComponentKindEnum("kind").notNull(),
+    status: tripComponentStatusEnum("status").notNull().default("draft"),
+    title: text("title"),
+    description: text("description"),
+    entityModule: text("entity_module"),
+    entityId: text("entity_id"),
+    sourceKind: text("source_kind"),
+    sourceConnectionId: text("source_connection_id"),
+    sourceRef: text("source_ref"),
+    bookingDraftId: text("booking_draft_id"),
+    catalogQuoteId: text("catalog_quote_id"),
+    bookingId: text("booking_id"),
+    bookingGroupId: text("booking_group_id"),
+    orderId: text("order_id"),
+    paymentSessionId: text("payment_session_id"),
+    providerRef: text("provider_ref"),
+    supplierRef: text("supplier_ref"),
+    componentCurrency: text("component_currency"),
+    componentSubtotalAmountCents: integer("component_subtotal_amount_cents"),
+    componentTaxAmountCents: integer("component_tax_amount_cents"),
+    componentTotalAmountCents: integer("component_total_amount_cents"),
+    pricingSnapshot: jsonb("pricing_snapshot").$type(),
+    taxLines: jsonb("tax_lines").$type().default([]),
+    cancellationSnapshot: jsonb("cancellation_snapshot").$type(),
+    holdToken: text("hold_token"),
+    holdExpiresAt: timestamp("hold_expires_at", { withTimezone: true }),
+    priceExpiresAt: timestamp("price_expires_at", { withTimezone: true }),
+    warningCodes: jsonb("warning_codes").$type().notNull().default([]),
+    metadata: jsonb("metadata").$type().notNull().default({}),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_trip_components_envelope_sequence").on(table.envelopeId, table.sequence),
+    index("idx_trip_components_envelope_status").on(table.envelopeId, table.status),
+    index("idx_trip_components_catalog_entity").on(table.entityModule, table.entityId),
+    index("idx_trip_components_booking_draft").on(table.bookingDraftId),
+    index("idx_trip_components_catalog_quote").on(table.catalogQuoteId),
+    index("idx_trip_components_booking").on(table.bookingId),
+    index("idx_trip_components_order").on(table.orderId),
+    index("idx_trip_components_payment_session").on(table.paymentSessionId),
+]);
+export const tripComponentEvents = pgTable("trip_component_events", {
+    id: typeId("trip_component_events"),
+    envelopeId: typeIdRef("envelope_id")
+        .notNull()
+        .references(() => tripEnvelopes.id, { onDelete: "cascade" }),
+    componentId: typeIdRef("component_id").references(() => tripComponents.id, {
+        onDelete: "set null",
+    }),
+    eventType: tripComponentEventTypeEnum("event_type").notNull(),
+    fromStatus: tripComponentStatusEnum("from_status"),
+    toStatus: tripComponentStatusEnum("to_status"),
+    payload: jsonb("payload").$type().notNull().default({}),
+    actorId: text("actor_id"),
+    occurredAt: timestamp("occurred_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_trip_component_events_envelope_time").on(table.envelopeId, table.occurredAt),
+    index("idx_trip_component_events_component_time").on(table.componentId, table.occurredAt),
+    index("idx_trip_component_events_type_time").on(table.eventType, table.occurredAt),
+]);
+export const tripEnvelopeRelations = relations(tripEnvelopes, ({ many }) => ({
+    components: many(tripComponents),
+    events: many(tripComponentEvents),
+}));
+export const tripComponentRelations = relations(tripComponents, ({ one, many }) => ({
+    envelope: one(tripEnvelopes, {
+        fields: [tripComponents.envelopeId],
+        references: [tripEnvelopes.id],
+    }),
+    events: many(tripComponentEvents),
+}));
+export const tripComponentEventRelations = relations(tripComponentEvents, ({ one }) => ({
+    envelope: one(tripEnvelopes, {
+        fields: [tripComponentEvents.envelopeId],
+        references: [tripEnvelopes.id],
+    }),
+    component: one(tripComponents, {
+        fields: [tripComponentEvents.componentId],
+        references: [tripComponents.id],
+    }),
+}));

package/dist/service-cancellation.d.ts

@@ -0,0 +1,6 @@
+import type { AnyDrizzleDb } from "@voyantjs/db";
+import type { CancelTripComponentsDeps, CancelTripComponentsResult, PreviewTripCancellationDeps, TripCancellationPreviewResult } from "./service-types.js";
+import { type CancelTripComponentsInput, type PreviewTripCancellationInput } from "./validation.js";
+export declare function previewCancellation(db: AnyDrizzleDb, input: PreviewTripCancellationInput, deps?: PreviewTripCancellationDeps): Promise<TripCancellationPreviewResult>;
+export declare function cancelComponents(db: AnyDrizzleDb, input: CancelTripComponentsInput, deps?: CancelTripComponentsDeps): Promise<CancelTripComponentsResult>;
+//# sourceMappingURL=service-cancellation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-cancellation.d.ts","sourceRoot":"","sources":["../src/service-cancellation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAWhD,OAAO,KAAK,EAEV,wBAAwB,EACxB,0BAA0B,EAE1B,2BAA2B,EAE3B,6BAA6B,EAC9B,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EACL,KAAK,yBAAyB,EAE9B,KAAK,4BAA4B,EAClC,MAAM,iBAAiB,CAAA;AAExB,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,4BAA4B,EACnC,IAAI,GAAE,2BAAgC,GACrC,OAAO,CAAC,6BAA6B,CAAC,CAqBxC;AAED,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,yBAAyB,EAChC,IAAI,GAAE,wBAA6B,GAClC,OAAO,CAAC,0BAA0B,CAAC,CAsFrC"}

package/dist/service-cancellation.js

@@ -0,0 +1,251 @@
+import { eq } from "drizzle-orm";
+import { tripComponents, tripEnvelopes } from "./schema.js";
+import { assertTripComponentCanBeUpdated, hasCommittedComponentReference, } from "./service-helpers.js";
+import { createComponentEvent, markComponentForStaffRemediation } from "./service-internals.js";
+import { getTrip } from "./service-trips.js";
+import { TravelComposerInvariantError } from "./service-types.js";
+import { isTerminalTripComponentStatus, } from "./validation.js";
+export async function previewCancellation(db, input, deps = {}) {
+    const trip = await getTrip(db, input.envelopeId);
+    if (!trip) {
+        throw new TravelComposerInvariantError(`Trip envelope ${input.envelopeId} was not found`);
+    }
+    const requestedAt = input.requestedAt ? new Date(input.requestedAt) : new Date();
+    const selected = selectComponentsForCancellation(trip, input.componentIds);
+    const componentPreviews = [];
+    for (const component of selected) {
+        componentPreviews.push(await previewComponentCancellation(trip.envelope, component, input, requestedAt, deps));
+    }
+    return {
+        envelope: trip.envelope,
+        components: trip.components,
+        preview: buildCancellationPreviewAggregate(trip.envelope, selected, componentPreviews),
+    };
+}
+export async function cancelComponents(db, input, deps = {}) {
+    const preview = await previewCancellation(db, input, deps);
+    const requestedAt = input.requestedAt ? new Date(input.requestedAt) : new Date();
+    const componentsById = new Map(preview.components.map((component) => [component.id, component]));
+    const cancelled = [];
+    const remediation = [];
+    const skipped = [];
+    for (const item of preview.preview.components) {
+        const component = componentsById.get(item.componentId);
+        if (!component)
+            continue;
+        if (item.action === "no_op") {
+            skipped.push({ componentId: item.componentId, reason: item.reason ?? "no_action" });
+            continue;
+        }
+        if (item.action === "staff_remediation") {
+            const reason = item.reason ?? "staff_remediation_required";
+            const updated = await markComponentForStaffRemediation(db, component, reason);
+            componentsById.set(updated.id, updated);
+            remediation.push({ componentId: item.componentId, reason });
+            continue;
+        }
+        if (!deps.cancelComponent && !canCancelComponentLocally(component)) {
+            const reason = "cancel_adapter_not_configured";
+            const updated = await markComponentForStaffRemediation(db, component, reason);
+            componentsById.set(updated.id, updated);
+            remediation.push({ componentId: item.componentId, reason });
+            continue;
+        }
+        try {
+            const result = canCancelComponentLocally(component)
+                ? localCancellationResult(item)
+                : await deps.cancelComponent?.({
+                    envelope: preview.envelope,
+                    component,
+                    preview: item,
+                    reason: input.reason,
+                    requestedAt,
+                    request: input.request,
+                });
+            if (!result || result.status !== "cancelled") {
+                const reason = result?.reason ?? `cancel_${result?.status ?? "not_configured"}`;
+                const updated = await markComponentForStaffRemediation(db, component, reason);
+                componentsById.set(updated.id, updated);
+                remediation.push({ componentId: item.componentId, reason });
+                continue;
+            }
+            const updated = await markComponentCancelled(db, component, {
+                ...item,
+                refundAmountCents: result.refundAmountCents ?? item.refundAmountCents,
+                refundCurrency: result.refundCurrency ?? item.refundCurrency,
+                snapshot: result.snapshot ?? item.snapshot,
+            });
+            componentsById.set(updated.id, updated);
+            cancelled.push({ componentId: item.componentId, status: "cancelled" });
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : "cancel_failed";
+            const updated = await markComponentForStaffRemediation(db, component, reason);
+            componentsById.set(updated.id, updated);
+            remediation.push({ componentId: item.componentId, reason });
+        }
+    }
+    const refreshed = await getTrip(db, input.envelopeId);
+    const components = refreshed?.components ?? [...componentsById.values()];
+    const envelope = await maybeCancelEnvelope(db, preview.envelope, components);
+    const finalTrip = envelope.status === preview.envelope.status ? refreshed : await getTrip(db, input.envelopeId);
+    return {
+        envelope,
+        components: finalTrip?.components ?? components,
+        preview: {
+            ...preview.preview,
+            staffActionRequired: preview.preview.staffActionRequired || remediation.length > 0,
+        },
+        cancelled,
+        remediation,
+        skipped,
+    };
+}
+function selectComponentsForCancellation(trip, componentIds) {
+    if (!componentIds || componentIds.length === 0) {
+        return trip.components.filter((component) => !isTerminalTripComponentStatus(component.status));
+    }
+    const componentsById = new Map(trip.components.map((component) => [component.id, component]));
+    const selected = [];
+    for (const componentId of componentIds) {
+        const component = componentsById.get(componentId);
+        if (!component) {
+            throw new TravelComposerInvariantError(`Trip component ${componentId} was not found on envelope ${trip.envelope.id}`);
+        }
+        selected.push(component);
+    }
+    return selected;
+}
+async function previewComponentCancellation(envelope, component, input, requestedAt, deps) {
+    if (isTerminalTripComponentStatus(component.status)) {
+        return componentCancellationPreview(component, {
+            action: "no_op",
+            staffActionRequired: false,
+            reason: `already_${component.status}`,
+        });
+    }
+    if (canCancelComponentLocally(component)) {
+        return componentCancellationPreview(component, {
+            action: "cancel",
+            staffActionRequired: false,
+            reason: "local_component_cancel",
+        });
+    }
+    if (deps.previewComponentCancellation) {
+        return deps.previewComponentCancellation({
+            envelope,
+            component,
+            reason: input.reason,
+            requestedAt,
+            request: input.request,
+        });
+    }
+    return componentCancellationPreview(component, {
+        action: "staff_remediation",
+        staffActionRequired: true,
+        reason: "cancel_preview_not_configured",
+    });
+}
+function canCancelComponentLocally(component) {
+    if (component.kind === "manual_placeholder" || component.kind === "flight_placeholder") {
+        return true;
+    }
+    return (component.kind === "catalog_booking" &&
+        !hasCommittedComponentReference(component) &&
+        (component.status === "draft" ||
+            component.status === "priced" ||
+            component.status === "unavailable" ||
+            component.status === "failed"));
+}
+function componentCancellationPreview(component, overrides) {
+    return {
+        componentId: component.id,
+        currentStatus: component.status,
+        refundAmountCents: 0,
+        refundCurrency: component.componentCurrency ?? undefined,
+        penaltyAmountCents: 0,
+        ...overrides,
+    };
+}
+function buildCancellationPreviewAggregate(envelope, selected, componentPreviews) {
+    const warnings = new Set();
+    let currency = envelope.aggregateCurrency ?? null;
+    let estimatedRefundAmountCents = 0;
+    let estimatedPenaltyAmountCents = 0;
+    for (const item of componentPreviews) {
+        if (item.refundCurrency) {
+            currency ??= item.refundCurrency;
+            if (currency !== item.refundCurrency) {
+                warnings.add(`refund_currency_mismatch:${item.refundCurrency}`);
+            }
+        }
+        if (!item.refundCurrency || !currency || item.refundCurrency === currency) {
+            estimatedRefundAmountCents += item.refundAmountCents ?? 0;
+        }
+        estimatedPenaltyAmountCents += item.penaltyAmountCents ?? 0;
+        if (item.reason && item.action !== "cancel")
+            warnings.add(item.reason);
+    }
+    return {
+        envelopeId: envelope.id,
+        selectedComponentIds: selected.map((component) => component.id),
+        currency,
+        estimatedRefundAmountCents,
+        estimatedPenaltyAmountCents,
+        staffActionRequired: componentPreviews.some((item) => item.staffActionRequired),
+        components: componentPreviews,
+        warnings: [...warnings],
+    };
+}
+function localCancellationResult(preview) {
+    return {
+        status: "cancelled",
+        refundAmountCents: preview.refundAmountCents,
+        refundCurrency: preview.refundCurrency,
+        snapshot: preview.snapshot,
+    };
+}
+async function markComponentCancelled(db, component, preview) {
+    assertTripComponentCanBeUpdated(component, { status: "cancelled" });
+    const cancellationSnapshot = {
+        action: preview.action,
+        refundAmountCents: preview.refundAmountCents ?? 0,
+        refundCurrency: preview.refundCurrency ?? component.componentCurrency ?? null,
+        penaltyAmountCents: preview.penaltyAmountCents ?? 0,
+        supplierCancellationDeadline: preview.supplierCancellationDeadline ?? null,
+        policySummary: preview.policySummary ?? null,
+        snapshot: preview.snapshot ?? null,
+    };
+    const [updated] = (await db
+        .update(tripComponents)
+        .set({
+        status: "cancelled",
+        cancellationSnapshot,
+        updatedAt: new Date(),
+    })
+        .where(eq(tripComponents.id, component.id))
+        .returning());
+    if (!updated) {
+        throw new Error(`markComponentCancelled: update returned no row for ${component.id}`);
+    }
+    await createComponentEvent(db, {
+        envelopeId: updated.envelopeId,
+        componentId: updated.id,
+        eventType: "cancelled",
+        fromStatus: component.status,
+        toStatus: updated.status,
+        payload: cancellationSnapshot,
+    });
+    return updated;
+}
+async function maybeCancelEnvelope(db, envelope, components) {
+    const hasActiveComponent = components.some((component) => component.status !== "cancelled" && component.status !== "removed");
+    if (hasActiveComponent || envelope.status === "cancelled")
+        return envelope;
+    const [updated] = (await db
+        .update(tripEnvelopes)
+        .set({ status: "cancelled", updatedAt: new Date() })
+        .where(eq(tripEnvelopes.id, envelope.id))
+        .returning());
+    return updated ?? envelope;
+}

package/dist/service-checkout.d.ts

@@ -0,0 +1,6 @@
+import type { AnyDrizzleDb } from "@voyantjs/db";
+import type { CompleteTripCheckoutInput, CompleteTripCheckoutResult, StartCheckoutDeps, StartCheckoutResult } from "./service-types.js";
+import type { StartTripCheckoutInput } from "./validation.js";
+export declare function startCheckout(db: AnyDrizzleDb, input: StartTripCheckoutInput, deps: StartCheckoutDeps): Promise<StartCheckoutResult>;
+export declare function completeTripCheckout(db: AnyDrizzleDb, input: CompleteTripCheckoutInput): Promise<CompleteTripCheckoutResult | null>;
+//# sourceMappingURL=service-checkout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-checkout.d.ts","sourceRoot":"","sources":["../src/service-checkout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAqBhD,OAAO,KAAK,EACV,yBAAyB,EACzB,0BAA0B,EAE1B,iBAAiB,EACjB,mBAAmB,EAKpB,MAAM,oBAAoB,CAAA;AAG3B,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAA;AAK7D,wBAAsB,aAAa,CACjC,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,sBAAsB,EAC7B,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,mBAAmB,CAAC,CAyI9B;AAED,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,yBAAyB,GAC/B,OAAO,CAAC,0BAA0B,GAAG,IAAI,CAAC,CAoG5C"}