@voyant-travel/commerce 0.1.0

package/dist/accepted-quote-version-reservation-golden-flow.test.js

@@ -0,0 +1,398 @@
+import { describe, expect, it } from "vitest";
+import { createCommercialDecisionEvaluator, recordCommercialSnapshot, } from "./index.js";
+const acceptedQuoteVersionId = "qver_1793_accepted";
+const quoteId = "quote_1793";
+const frozenTripSnapshotId = "trsn_1793_frozen";
+const reservationPlanId = "trplan_1793";
+const bookingId = "book_1793";
+const eur = (amountMinor) => ({ amountMinor, currency: "EUR" });
+const expectedModuleInterfaces = [
+    "Quotes.acceptQuoteVersion",
+    "Trips.prepareReservationPlanForAcceptedQuoteVersion",
+    "Commerce.evaluateCommercialDecision",
+    "Commerce.recordCommercialSnapshot",
+    "Bookings.submitReservationPlan",
+    "Finance.startCollection",
+    "Legal.attachPolicyAndTermsTargets",
+];
+const expectedDurableOwnerRecords = [
+    "Quotes:quote_versions.status",
+    "Quotes:quotes.acceptedVersionId",
+    "Trips:trip_reservation_plans",
+    "Commerce:commercial_snapshots",
+    "Bookings:booking_origins",
+    "Bookings:bookings",
+    "Bookings:booking_items",
+    "Bookings:booking_travelers",
+    "Bookings:booking_allocations",
+    "Bookings:booking_fulfillments",
+    "Finance:payment_sessions",
+    "Legal:policy_acceptances",
+    "Legal:contracts",
+];
+const pricedLineInput = {
+    item: {
+        kind: "catalog-item",
+        id: "catalog_item_cruise_1793",
+        source: "sourced",
+        vertical: "cruise",
+        adapterHint: "golden-flow-source",
+        sourceRef: {
+            providerId: "cruise-provider",
+            sourceId: "source_cruise",
+            externalRef: "sailing_1793",
+        },
+    },
+    date: "2026-09-18",
+    party: {
+        pax: 2,
+        adults: 2,
+    },
+    currency: "EUR",
+    buyer: {
+        actorType: "customer",
+        relationshipId: "relationship_b2b_buyer",
+    },
+    channel: {
+        id: "channel_direct",
+        kind: "direct",
+    },
+    market: {
+        id: "market_eu",
+        code: "EU",
+        currency: "EUR",
+    },
+    requestedAt: "2026-06-13T09:00:00.000Z",
+    idempotencyKey: `${acceptedQuoteVersionId}:catalog_item_cruise_1793`,
+    evaluationMode: "checkout",
+};
+const sourceAdapter = {
+    id: "golden-flow-source",
+    kind: "source",
+    supports(input) {
+        return input.item.adapterHint === "golden-flow-source";
+    },
+    evaluate(input) {
+        return {
+            status: "available",
+            validUntil: "2026-06-13T09:15:00.000Z",
+            pricing: {
+                currency: input.currency,
+                total: eur(192000),
+                components: [
+                    {
+                        kind: "base",
+                        label: "Cabin fare",
+                        amount: eur(192000),
+                        ruleId: "fare_rule_1793",
+                    },
+                ],
+                priceRuleIds: ["fare_rule_1793"],
+            },
+            availability: {
+                status: "available",
+                capacityRemaining: 4,
+            },
+            sellability: {
+                status: "allowed",
+                policyIds: ["sellability_policy_b2b"],
+            },
+            handles: [
+                {
+                    providerId: "cruise-provider",
+                    sourceId: "source_cruise",
+                    externalRef: "source_quote_1793",
+                    handle: "source_quote_handle_1793",
+                },
+            ],
+        };
+    },
+};
+describe("accepted Quote Version reservation golden flow", () => {
+    it("names ownership from accepted Quote Version through reservation, collection, and legal targets", async () => {
+        const flow = await runAcceptedQuoteVersionReservationGoldenFlow();
+        expect(flow.calls.map((call) => call.interfaceName)).toEqual(expectedModuleInterfaces);
+        expect(flow.durableRecords.map(formatDurableRecord)).toEqual(expectedDurableOwnerRecords);
+        expect(flow.quote.acceptedVersionId).toBe(acceptedQuoteVersionId);
+        expect(flow.quote.status).toBe("won");
+        expect(flow.quote.versions.filter((version) => version.status === "accepted")).toHaveLength(1);
+        expect(flow.quote.versions.find((version) => version.id !== acceptedQuoteVersionId)?.status).toBe("declined");
+        expect(flow.handoff).toEqual({
+            kind: "accepted_quote_version",
+            quoteId,
+            quoteVersionId: acceptedQuoteVersionId,
+            tripSnapshotRef: {
+                owner: "Trips",
+                id: frozenTripSnapshotId,
+            },
+        });
+        expect(flow.tripsReservedInventoryDirectly).toBe(false);
+        expect(flow.reservationPlan).toMatchObject({
+            id: reservationPlanId,
+            origin: "accepted_quote_version",
+            quoteVersionId: acceptedQuoteVersionId,
+            tripSnapshotId: frozenTripSnapshotId,
+        });
+        expect(flow.reservationPlan.inputs).toEqual([
+            expect.objectContaining({
+                componentId: "trcp_priced_catalog",
+                commercialDecisionId: expect.stringMatching(/^commercial_decision_/),
+                commercialSnapshotId: "commercial_snapshot_1",
+            }),
+            expect.objectContaining({
+                componentId: "trcp_manual_supplier",
+                confirmationWorkflow: "staff_supplier_confirmation",
+            }),
+        ]);
+        expect(flow.bookings.supportedReservationOrigins).toEqual([
+            "direct_b2c",
+            "accepted_quote_version",
+        ]);
+        expect(flow.bookings.origin).toMatchObject({
+            bookingId,
+            source: "accepted_quote_version",
+            quoteVersionId: acceptedQuoteVersionId,
+            tripSnapshotId: frozenTripSnapshotId,
+            reservationPlanId,
+            commercialSnapshotIds: ["commercial_snapshot_1"],
+        });
+        expect(flow.financeCollectionTarget).toEqual({
+            targetType: "booking",
+            targetId: bookingId,
+            amountMinor: 192000,
+            currency: "EUR",
+        });
+        expect(flow.legalTargets).toEqual([
+            { targetType: "booking", targetId: bookingId, targetPurpose: "terms_acceptance" },
+            {
+                targetType: "quote_version",
+                targetId: acceptedQuoteVersionId,
+                targetPurpose: "proposal_contract",
+            },
+        ]);
+        assertNoLegacyTransactionLadder(flow);
+    });
+});
+async function runAcceptedQuoteVersionReservationGoldenFlow() {
+    const calls = [];
+    const durableRecords = [];
+    const quote = {
+        id: quoteId,
+        status: "open",
+        acceptedVersionId: null,
+        versions: [
+            {
+                id: acceptedQuoteVersionId,
+                status: "sent",
+                tripSnapshotId: frozenTripSnapshotId,
+            },
+            {
+                id: "qver_1793_alternative",
+                status: "sent",
+                tripSnapshotId: "trsn_1793_alternative",
+            },
+        ],
+    };
+    const quotes = {
+        acceptQuoteVersion(versionId) {
+            calls.push({ interfaceName: "Quotes.acceptQuoteVersion" });
+            const accepted = quote.versions.find((version) => version.id === versionId);
+            if (!accepted || accepted.status !== "sent") {
+                throw new Error("Quote Version must be sent before acceptance");
+            }
+            quote.status = "won";
+            quote.acceptedVersionId = accepted.id;
+            quote.versions = quote.versions.map((version) => ({
+                ...version,
+                status: version.id === accepted.id
+                    ? "accepted"
+                    : version.status === "draft"
+                        ? "superseded"
+                        : "declined",
+            }));
+            durableRecords.push({
+                owner: "Quotes",
+                record: "quote_versions.status",
+            }, {
+                owner: "Quotes",
+                record: "quotes.acceptedVersionId",
+            });
+            return {
+                kind: "accepted_quote_version",
+                quoteId: quote.id,
+                quoteVersionId: accepted.id,
+                tripSnapshotRef: {
+                    owner: "Trips",
+                    id: accepted.tripSnapshotId,
+                },
+            };
+        },
+    };
+    const evaluator = createCommercialDecisionEvaluator({ adapters: [sourceAdapter] });
+    const repository = createSnapshotRepository(durableRecords);
+    const trips = {
+        reservedInventoryDirectly: false,
+        async prepareReservationPlanForAcceptedQuoteVersion(handoff) {
+            calls.push({ interfaceName: "Trips.prepareReservationPlanForAcceptedQuoteVersion" });
+            durableRecords.push({
+                owner: "Trips",
+                record: "trip_reservation_plans",
+            });
+            calls.push({ interfaceName: "Commerce.evaluateCommercialDecision" });
+            const decision = await evaluator.evaluateCommercialDecision(pricedLineInput);
+            calls.push({ interfaceName: "Commerce.recordCommercialSnapshot" });
+            const snapshot = await recordCommercialSnapshot(decision, {
+                kind: "trip-component",
+                id: "trcp_priced_catalog",
+                facts: {
+                    quoteVersionId: handoff.quoteVersionId,
+                    tripSnapshotId: handoff.tripSnapshotRef.id,
+                    reservationPlanId,
+                },
+            }, repository);
+            return {
+                id: reservationPlanId,
+                origin: "accepted_quote_version",
+                quoteId: handoff.quoteId,
+                quoteVersionId: handoff.quoteVersionId,
+                tripSnapshotId: handoff.tripSnapshotRef.id,
+                inputs: [
+                    {
+                        componentId: "trcp_priced_catalog",
+                        kind: "catalog_backed",
+                        commercialDecisionId: decision.decisionId,
+                        commercialSnapshotId: snapshot.snapshotId,
+                        providerHandles: decision.handles,
+                    },
+                    {
+                        componentId: "trcp_manual_supplier",
+                        kind: "manual_placeholder",
+                        quotedAmountMinor: 65000,
+                        currency: "EUR",
+                        confirmationWorkflow: "staff_supplier_confirmation",
+                    },
+                ],
+            };
+        },
+    };
+    const bookings = {
+        supportedReservationOrigins: ["direct_b2c", "accepted_quote_version"],
+        submitReservationPlan(plan) {
+            calls.push({ interfaceName: "Bookings.submitReservationPlan" });
+            const origin = {
+                bookingId,
+                source: "accepted_quote_version",
+                quoteId: plan.quoteId,
+                quoteVersionId: plan.quoteVersionId,
+                tripSnapshotId: plan.tripSnapshotId,
+                reservationPlanId: plan.id,
+                commercialSnapshotIds: plan.inputs.flatMap((input) => "commercialSnapshotId" in input ? [input.commercialSnapshotId] : []),
+                providerSourceRefs: plan.inputs.flatMap((input) => "providerHandles" in input && Array.isArray(input.providerHandles)
+                    ? input.providerHandles.map((handle) => handle.externalRef ?? handle.handle ?? null)
+                    : []),
+                legacyTransactionRef: null,
+            };
+            durableRecords.push({ owner: "Bookings", record: "booking_origins" }, { owner: "Bookings", record: "bookings" }, { owner: "Bookings", record: "booking_items" }, { owner: "Bookings", record: "booking_travelers" }, { owner: "Bookings", record: "booking_allocations" }, { owner: "Bookings", record: "booking_fulfillments" });
+            return {
+                bookingId,
+                status: "awaiting_payment",
+                origin,
+            };
+        },
+    };
+    const finance = {
+        startCollection(input) {
+            calls.push({ interfaceName: "Finance.startCollection" });
+            durableRecords.push({
+                owner: "Finance",
+                record: "payment_sessions",
+            });
+            return {
+                targetType: "booking",
+                targetId: input.bookingId,
+                amountMinor: input.amountMinor,
+                currency: input.currency,
+            };
+        },
+    };
+    const legal = {
+        attachPolicyAndTermsTargets(input) {
+            calls.push({ interfaceName: "Legal.attachPolicyAndTermsTargets" });
+            durableRecords.push({
+                owner: "Legal",
+                record: "policy_acceptances",
+            }, {
+                owner: "Legal",
+                record: "contracts",
+            });
+            return [
+                {
+                    targetType: "booking",
+                    targetId: input.bookingId,
+                    targetPurpose: "terms_acceptance",
+                },
+                {
+                    targetType: "quote_version",
+                    targetId: input.quoteVersionId,
+                    targetPurpose: "proposal_contract",
+                },
+            ];
+        },
+    };
+    const handoff = quotes.acceptQuoteVersion(acceptedQuoteVersionId);
+    const reservationPlan = await trips.prepareReservationPlanForAcceptedQuoteVersion(handoff);
+    const booking = bookings.submitReservationPlan(reservationPlan);
+    const financeCollectionTarget = finance.startCollection({
+        bookingId: booking.bookingId,
+        amountMinor: 192000,
+        currency: "EUR",
+    });
+    const legalTargets = legal.attachPolicyAndTermsTargets({
+        bookingId: booking.bookingId,
+        quoteVersionId: acceptedQuoteVersionId,
+    });
+    return {
+        calls,
+        durableRecords,
+        quote,
+        handoff,
+        reservationPlan,
+        tripsReservedInventoryDirectly: trips.reservedInventoryDirectly,
+        bookings: {
+            supportedReservationOrigins: bookings.supportedReservationOrigins,
+            origin: booking.origin,
+        },
+        financeCollectionTarget,
+        legalTargets,
+    };
+}
+function createSnapshotRepository(durableRecords) {
+    let writeCount = 0;
+    return {
+        async recordCommercialSnapshot(write) {
+            writeCount += 1;
+            durableRecords.push({
+                owner: "Commerce",
+                record: "commercial_snapshots",
+            });
+            return {
+                snapshotId: `commercial_snapshot_${writeCount}`,
+                decisionId: write.decision.decisionId,
+                target: write.target,
+                idempotencyKey: write.idempotencyKey,
+                recordedAt: "2026-06-13T09:01:00.000Z",
+            };
+        },
+    };
+}
+function formatDurableRecord(record) {
+    return `${record.owner}:${record.record}`;
+}
+function assertNoLegacyTransactionLadder(value) {
+    const serialized = JSON.stringify(value);
+    expect(serialized).not.toContain("booking_transaction_details");
+    expect(serialized).not.toContain("transactions.");
+    expect(serialized).not.toContain('"offerId"');
+    expect(serialized).not.toContain('"orderId"');
+    expect(serialized).not.toContain('"transactionOrderId"');
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import type { Module } from "@voyant-travel/core";
+export declare const commerceModule: Module;
+export { CommercialDecisionError, createCommerceAdapterRegistry, createCommercialDecisionEvaluator, evaluateCommercialDecision, recordCommercialSnapshot, } from "./interface.js";
+export * from "./markets/index.js";
+export * from "./pricing/index.js";
+export { createProductPricingProjectionExtension, loadProductPriceFrom, } from "./pricing/service-catalog-plane-pricing.js";
+export * from "./promotions/index.js";
+export { recordPromotionRedemptionsForBooking } from "./promotions/service-booking-confirmed.js";
+export { type BoundarySchedulerResult, runPromotionBoundaryScheduler, } from "./promotions/service-boundary-scheduler.js";
+export { createCatalogPromotionEvaluator } from "./promotions/service-catalog-evaluator.js";
+export { createProductPromotionsProjectionExtension } from "./promotions/service-catalog-plane-promotions.js";
+export { type CommerceHonoModulesOptions, type CommerceRuntimeModuleName, commerceRuntimeModuleNames, createCommerceHonoModules, createCommerceStorefrontOfferResolvers, } from "./runtime.js";
+export * from "./sellability/index.js";
+export type { CommercialAdapterHandle, CommercialAdapterRegistrationKind, CommercialAvailabilityFact, CommercialBuyerRef, CommercialChannelRef, CommercialCurrencyCode, CommercialDecision, CommercialDecisionErrorCode, CommercialDecisionEvaluationContext, CommercialDecisionEvaluator, CommercialDecisionInput, CommercialDecisionReason, CommercialDecisionStatus, CommercialDecisionTrace, CommercialDecisionTraceOutcome, CommercialDecisionTraceSource, CommercialFxFact, CommercialItemRef, CommercialJson, CommercialMarketRef, CommercialMoney, CommercialParty, CommercialPriceAvailabilityAdapter, CommercialPriceAvailabilityResult, CommercialPricingComponent, CommercialPricingFacts, CommercialPromotionFact, CommercialPromotionFacts, CommercialProviderHandle, CommercialSellabilityFact, CommercialSnapshotRecord, CommercialSnapshotRepository, CommercialSnapshotTarget, CommercialSnapshotWriteInput, EvaluateCommercialDecision, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAEjD,eAAO,MAAM,cAAc,EAAE,MAE5B,CAAA;AAED,OAAO,EACL,uBAAuB,EACvB,6BAA6B,EAC7B,iCAAiC,EACjC,0BAA0B,EAC1B,wBAAwB,GACzB,MAAM,gBAAgB,CAAA;AACvB,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,OAAO,EACL,uCAAuC,EACvC,oBAAoB,GACrB,MAAM,4CAA4C,CAAA;AACnD,cAAc,uBAAuB,CAAA;AACrC,OAAO,EAAE,oCAAoC,EAAE,MAAM,2CAA2C,CAAA;AAChG,OAAO,EACL,KAAK,uBAAuB,EAC5B,6BAA6B,GAC9B,MAAM,4CAA4C,CAAA;AACnD,OAAO,EAAE,+BAA+B,EAAE,MAAM,2CAA2C,CAAA;AAC3F,OAAO,EAAE,0CAA0C,EAAE,MAAM,kDAAkD,CAAA;AAC7G,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,EAC9B,0BAA0B,EAC1B,yBAAyB,EACzB,sCAAsC,GACvC,MAAM,cAAc,CAAA;AACrB,cAAc,wBAAwB,CAAA;AACtC,YAAY,EACV,uBAAuB,EACvB,iCAAiC,EACjC,0BAA0B,EAC1B,kBAAkB,EAClB,oBAAoB,EACpB,sBAAsB,EACtB,kBAAkB,EAClB,2BAA2B,EAC3B,mCAAmC,EACnC,2BAA2B,EAC3B,uBAAuB,EACvB,wBAAwB,EACxB,wBAAwB,EACxB,uBAAuB,EACvB,8BAA8B,EAC9B,6BAA6B,EAC7B,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,eAAe,EACf,kCAAkC,EAClC,iCAAiC,EACjC,0BAA0B,EAC1B,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EACxB,wBAAwB,EACxB,yBAAyB,EACzB,wBAAwB,EACxB,4BAA4B,EAC5B,wBAAwB,EACxB,4BAA4B,EAC5B,0BAA0B,GAC3B,MAAM,YAAY,CAAA"}

package/dist/index.js

@@ -0,0 +1,14 @@
+export const commerceModule = {
+    name: "commerce",
+};
+export { CommercialDecisionError, createCommerceAdapterRegistry, createCommercialDecisionEvaluator, evaluateCommercialDecision, recordCommercialSnapshot, } from "./interface.js";
+export * from "./markets/index.js";
+export * from "./pricing/index.js";
+export { createProductPricingProjectionExtension, loadProductPriceFrom, } from "./pricing/service-catalog-plane-pricing.js";
+export * from "./promotions/index.js";
+export { recordPromotionRedemptionsForBooking } from "./promotions/service-booking-confirmed.js";
+export { runPromotionBoundaryScheduler, } from "./promotions/service-boundary-scheduler.js";
+export { createCatalogPromotionEvaluator } from "./promotions/service-catalog-evaluator.js";
+export { createProductPromotionsProjectionExtension } from "./promotions/service-catalog-plane-promotions.js";
+export { commerceRuntimeModuleNames, createCommerceHonoModules, createCommerceStorefrontOfferResolvers, } from "./runtime.js";
+export * from "./sellability/index.js";

package/dist/interface.d.ts

@@ -0,0 +1,18 @@
+import type { CommercialDecision, CommercialDecisionErrorCode, CommercialDecisionEvaluationContext, CommercialDecisionEvaluator, CommercialDecisionInput, CommercialPriceAvailabilityAdapter, CommercialSnapshotRecord, CommercialSnapshotRepository, CommercialSnapshotTarget } from "./types.js";
+export declare class CommercialDecisionError extends Error {
+    readonly code: CommercialDecisionErrorCode;
+    constructor(message: string, code: CommercialDecisionErrorCode);
+}
+export declare function createCommerceAdapterRegistry(adapters?: CommercialPriceAvailabilityAdapter[]): {
+    listAdapters: () => CommercialPriceAvailabilityAdapter[];
+    registerPriceAvailabilityAdapter: (adapter: CommercialPriceAvailabilityAdapter) => void;
+    resolveAdapter: (input: CommercialDecisionInput) => Promise<CommercialPriceAvailabilityAdapter | null>;
+};
+export declare function evaluateCommercialDecision(input: CommercialDecisionInput, context?: CommercialDecisionEvaluationContext & {
+    registry?: ReturnType<typeof createCommerceAdapterRegistry>;
+}): Promise<CommercialDecision>;
+export declare function createCommercialDecisionEvaluator(options?: {
+    adapters?: CommercialPriceAvailabilityAdapter[];
+}): CommercialDecisionEvaluator;
+export declare function recordCommercialSnapshot(decision: CommercialDecision, target: CommercialSnapshotTarget, repository: CommercialSnapshotRepository): Promise<CommercialSnapshotRecord>;
+//# sourceMappingURL=interface.d.ts.map

package/dist/interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../src/interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,kBAAkB,EAClB,2BAA2B,EAC3B,mCAAmC,EACnC,2BAA2B,EAC3B,uBAAuB,EAQvB,kCAAkC,EAMlC,wBAAwB,EACxB,4BAA4B,EAC5B,wBAAwB,EACzB,MAAM,YAAY,CAAA;AAEnB,qBAAa,uBAAwB,SAAQ,KAAK;IAG9C,QAAQ,CAAC,IAAI,EAAE,2BAA2B;gBAD1C,OAAO,EAAE,MAAM,EACN,IAAI,EAAE,2BAA2B;CAK7C;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,GAAE,kCAAkC,EAAO;;gDAG5C,kCAAkC;4BAUhD,uBAAuB;EAmC7D;AAED,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,uBAAuB,EAC9B,OAAO,GAAE,mCAAmC,GAAG;IAC7C,QAAQ,CAAC,EAAE,UAAU,CAAC,OAAO,6BAA6B,CAAC,CAAA;CACvD,GACL,OAAO,CAAC,kBAAkB,CAAC,CAqH7B;AAED,wBAAgB,iCAAiC,CAC/C,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,kCAAkC,EAAE,CAAA;CAAO,GAChE,2BAA2B,CAQ7B;AAED,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,kBAAkB,EAC5B,MAAM,EAAE,wBAAwB,EAChC,UAAU,EAAE,4BAA4B,GACvC,OAAO,CAAC,wBAAwB,CAAC,CAMnC"}