@voyant-travel/commerce 0.1.0

package/dist/interface.js

@@ -0,0 +1,246 @@
+export class CommercialDecisionError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "CommercialDecisionError";
+    }
+}
+export function createCommerceAdapterRegistry(adapters = []) {
+    const registrations = new Map();
+    function registerPriceAvailabilityAdapter(adapter) {
+        if (registrations.has(adapter.id)) {
+            throw new CommercialDecisionError(`Commercial adapter "${adapter.id}" is already registered.`, "duplicate_adapter");
+        }
+        registrations.set(adapter.id, adapter);
+    }
+    async function resolveAdapter(input) {
+        if (input.item.adapterHint) {
+            const hinted = registrations.get(input.item.adapterHint);
+            if (!hinted) {
+                return null;
+            }
+            return (await hinted.supports(input)) ? hinted : null;
+        }
+        const matches = [];
+        for (const adapter of registrations.values()) {
+            if (await adapter.supports(input)) {
+                matches.push(adapter);
+            }
+        }
+        if (matches.length > 1) {
+            throw new CommercialDecisionError(`More than one commercial adapter supports item "${input.item.id}".`, "adapter_ambiguous");
+        }
+        return matches[0] ?? null;
+    }
+    for (const adapter of adapters) {
+        registerPriceAvailabilityAdapter(adapter);
+    }
+    return {
+        listAdapters: () => Array.from(registrations.values()),
+        registerPriceAvailabilityAdapter,
+        resolveAdapter,
+    };
+}
+export async function evaluateCommercialDecision(input, context = {}) {
+    const registry = context.registry ?? createCommerceAdapterRegistry();
+    const evaluatedAt = input.requestedAt ?? context.now?.toISOString() ?? new Date().toISOString();
+    let adapter;
+    try {
+        adapter = await registry.resolveAdapter(input);
+    }
+    catch (error) {
+        if (error instanceof CommercialDecisionError && error.code === "adapter_ambiguous") {
+            return buildDecision(input, evaluatedAt, {
+                status: "error",
+                reason: {
+                    code: "adapter_ambiguous",
+                    message: error.message,
+                },
+                traces: [
+                    commerceTrace("adapter_ambiguous", "error", {
+                        message: error.message,
+                    }),
+                ],
+            });
+        }
+        throw error;
+    }
+    if (!adapter) {
+        return buildDecision(input, evaluatedAt, {
+            status: "unbuyable",
+            reason: {
+                code: "unsupported_item",
+                message: "No price-availability adapter supports this item.",
+            },
+            traces: [
+                commerceTrace("adapter_not_found", "blocked", {
+                    message: "No price-availability adapter supports this item.",
+                    refs: { itemId: input.item.id },
+                }),
+            ],
+        });
+    }
+    const adapterHandle = {
+        adapterId: adapter.id,
+        adapterKind: adapter.kind,
+    };
+    let result;
+    try {
+        result = await adapter.evaluate(input, context);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Adapter execution failed.";
+        return buildDecision(input, evaluatedAt, {
+            status: "error",
+            reason: {
+                code: "adapter_failed",
+                message,
+            },
+            handles: [adapterHandle],
+            traces: [
+                commerceTrace("adapter_selected", "applied", {
+                    refs: { adapterId: adapter.id },
+                }),
+                commerceTrace("adapter_failed", "error", {
+                    message,
+                    refs: { adapterId: adapter.id },
+                }),
+            ],
+        });
+    }
+    if (result.status === "available" && !result.pricing) {
+        return buildDecision(input, evaluatedAt, {
+            status: "error",
+            reason: {
+                code: "adapter_invalid_result",
+                message: "A buyable commercial decision requires pricing facts.",
+            },
+            handles: [adapterHandle, ...toAdapterHandles(adapter, result.handles)],
+            traces: [
+                commerceTrace("adapter_selected", "applied", {
+                    refs: { adapterId: adapter.id },
+                }),
+                ...(result.traces ?? []),
+                commerceTrace("adapter_invalid_result", "error", {
+                    message: "A buyable commercial decision requires pricing facts.",
+                    refs: { adapterId: adapter.id },
+                }),
+            ],
+        });
+    }
+    const status = result.status === "available" ? "buyable" : "unbuyable";
+    return buildDecision(input, evaluatedAt, {
+        status,
+        validFrom: result.validFrom,
+        validUntil: result.validUntil,
+        reason: result.reason ??
+            (status === "buyable"
+                ? { code: "buyable", message: "Adapter returned an available price." }
+                : { code: "unavailable", message: "Adapter returned unavailable." }),
+        pricing: result.pricing,
+        fx: result.fx ?? result.pricing?.fx,
+        promotions: result.promotions,
+        availability: result.availability,
+        sellability: result.sellability,
+        market: result.market ?? input.market,
+        channel: result.channel ?? input.channel,
+        handles: [adapterHandle, ...toAdapterHandles(adapter, result.handles)],
+        traces: [
+            commerceTrace("adapter_selected", "applied", {
+                refs: { adapterId: adapter.id },
+            }),
+            ...(result.traces ?? []),
+        ],
+    });
+}
+export function createCommercialDecisionEvaluator(options = {}) {
+    const registry = createCommerceAdapterRegistry(options.adapters);
+    return {
+        registerPriceAvailabilityAdapter: registry.registerPriceAvailabilityAdapter,
+        evaluateCommercialDecision(input, context = {}) {
+            return evaluateCommercialDecision(input, { ...context, registry });
+        },
+    };
+}
+export async function recordCommercialSnapshot(decision, target, repository) {
+    return repository.recordCommercialSnapshot({
+        decision,
+        target,
+        idempotencyKey: target.idempotencyKey ?? decision.idempotencyKey,
+    });
+}
+function buildDecision(input, evaluatedAt, fields) {
+    return {
+        decisionId: `commercial_decision_${fingerprint(input.idempotencyKey
+            ? { idempotencyKey: input.idempotencyKey }
+            : {
+                evaluatedAt,
+                input,
+                reason: fields.reason,
+                status: fields.status,
+            })}`,
+        status: fields.status,
+        buyable: fields.status === "buyable",
+        input,
+        evaluatedAt,
+        idempotencyKey: input.idempotencyKey,
+        validFrom: fields.validFrom,
+        validUntil: fields.validUntil,
+        reason: fields.reason,
+        pricing: fields.pricing,
+        fx: fields.fx,
+        promotions: fields.promotions ?? {
+            requestedCodes: input.promotionCodes,
+            applied: [],
+            rejected: [],
+        },
+        availability: fields.availability,
+        sellability: fields.sellability,
+        market: fields.market ?? input.market,
+        channel: fields.channel ?? input.channel,
+        traces: fields.traces ?? [],
+        handles: fields.handles ?? [],
+    };
+}
+function commerceTrace(code, outcome, options = {}) {
+    return {
+        id: `trace_${fingerprint({ code, outcome, ...options })}`,
+        source: "commerce",
+        outcome,
+        code,
+        message: options.message,
+        refs: options.refs,
+        facts: options.facts,
+    };
+}
+function toAdapterHandles(adapter, handles) {
+    return (handles ?? []).map((handle) => ({
+        ...handle,
+        adapterId: adapter.id,
+        adapterKind: adapter.kind,
+    }));
+}
+function fingerprint(value) {
+    const text = stableStringify(value);
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < text.length; i += 1) {
+        hash ^= text.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(36);
+}
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record)
+            .filter((key) => record[key] !== undefined)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+}

package/dist/interface.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=interface.test.d.ts.map

package/dist/interface.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.test.d.ts","sourceRoot":"","sources":["../src/interface.test.ts"],"names":[],"mappings":""}

package/dist/interface.test.js

@@ -0,0 +1,357 @@
+import { describe, expect, it } from "vitest";
+import { createCommercialDecisionEvaluator, recordCommercialSnapshot, } from "./index.js";
+const operatedInput = {
+    item: {
+        kind: "catalog-item",
+        id: "catalog_item_operated_tour",
+        source: "operated",
+        vertical: "tour",
+    },
+    date: "2026-09-18",
+    party: {
+        pax: 2,
+        adults: 2,
+    },
+    currency: "EUR",
+    buyer: {
+        actorType: "customer",
+        segmentIds: ["retail"],
+    },
+    channel: {
+        id: "channel_direct",
+        kind: "direct",
+    },
+    market: {
+        id: "market_ro",
+        code: "RO",
+        currency: "EUR",
+    },
+    promotionCodes: ["EARLY10"],
+    requestedAt: "2026-06-13T09:00:00.000Z",
+    idempotencyKey: "quote-version:quote_v1:item:catalog_item_operated_tour",
+};
+const operatedInventoryAdapter = {
+    id: "operated-inventory",
+    kind: "operated-inventory",
+    supports(input) {
+        return input.item.kind === "catalog-item" && input.item.source === "operated";
+    },
+    evaluate(input) {
+        return {
+            status: "available",
+            validUntil: "2026-06-13T09:15:00.000Z",
+            pricing: {
+                currency: input.currency,
+                subtotal: {
+                    amountMinor: 24000,
+                    currency: input.currency,
+                },
+                discountTotal: {
+                    amountMinor: 2400,
+                    currency: input.currency,
+                },
+                total: {
+                    amountMinor: 21600,
+                    currency: input.currency,
+                },
+                components: [
+                    {
+                        kind: "base",
+                        label: "Adult",
+                        quantity: 2,
+                        amount: {
+                            amountMinor: 24000,
+                            currency: input.currency,
+                        },
+                        ruleId: "price_rule_adult",
+                    },
+                    {
+                        kind: "discount",
+                        label: "Early booking",
+                        amount: {
+                            amountMinor: -2400,
+                            currency: input.currency,
+                        },
+                        ruleId: "promotion_early10",
+                    },
+                ],
+                priceRuleIds: ["price_rule_adult"],
+            },
+            promotions: {
+                requestedCodes: input.promotionCodes,
+                applied: [
+                    {
+                        id: "promotion_early10",
+                        code: "EARLY10",
+                        status: "applied",
+                        discount: {
+                            amountMinor: 2400,
+                            currency: input.currency,
+                        },
+                        ruleId: "promotion_early10",
+                    },
+                ],
+                rejected: [],
+                totalDiscount: {
+                    amountMinor: 2400,
+                    currency: input.currency,
+                },
+            },
+            availability: {
+                status: "limited",
+                capacityRemaining: 6,
+                allocationRef: "slot_2026_09_18",
+            },
+            sellability: {
+                status: "allowed",
+                policyIds: ["sellability_policy_public"],
+            },
+            traces: [
+                {
+                    id: "trace_market_rule_ro",
+                    source: "markets",
+                    outcome: "applied",
+                    code: "market_rule_applied",
+                    ruleId: "market_rule_ro",
+                },
+                {
+                    id: "trace_price_rule_adult",
+                    source: "pricing",
+                    outcome: "applied",
+                    code: "price_rule_applied",
+                    ruleId: "price_rule_adult",
+                },
+                {
+                    id: "trace_promotion_early10",
+                    source: "promotions",
+                    outcome: "applied",
+                    code: "promotion_applied",
+                    ruleId: "promotion_early10",
+                },
+            ],
+            handles: [
+                {
+                    providerId: "inventory",
+                    handle: "slot_2026_09_18",
+                },
+            ],
+        };
+    },
+};
+const sourcedAdapter = {
+    id: "cruise-source",
+    kind: "source",
+    supports(input) {
+        return input.item.kind === "vertical-item" && input.item.vertical === "cruise";
+    },
+    evaluate(input) {
+        return {
+            status: "available",
+            validUntil: "2026-06-13T09:05:00.000Z",
+            pricing: {
+                currency: input.currency,
+                subtotal: {
+                    amountMinor: 180000,
+                    currency: input.currency,
+                },
+                taxTotal: {
+                    amountMinor: 12000,
+                    currency: input.currency,
+                },
+                total: {
+                    amountMinor: 192000,
+                    currency: input.currency,
+                },
+                components: [
+                    {
+                        kind: "base",
+                        label: "Cabin fare",
+                        amount: {
+                            amountMinor: 180000,
+                            currency: input.currency,
+                        },
+                        ruleId: "fare_offer_abc",
+                    },
+                    {
+                        kind: "tax",
+                        label: "Port taxes",
+                        amount: {
+                            amountMinor: 12000,
+                            currency: input.currency,
+                        },
+                    },
+                ],
+                fx: {
+                    sourceCurrency: "USD",
+                    requestedCurrency: "EUR",
+                    rate: "0.920000",
+                    rateSetId: "fx_2026_06_13",
+                    provider: {
+                        providerId: "treasury",
+                    },
+                    quotedAt: "2026-06-13T09:00:00.000Z",
+                },
+            },
+            fx: {
+                sourceCurrency: "USD",
+                requestedCurrency: "EUR",
+                rate: "0.920000",
+                rateSetId: "fx_2026_06_13",
+                provider: {
+                    providerId: "treasury",
+                },
+                quotedAt: "2026-06-13T09:00:00.000Z",
+            },
+            promotions: {
+                requestedCodes: input.promotionCodes,
+                applied: [],
+                rejected: [
+                    {
+                        code: "EARLY10",
+                        status: "rejected",
+                        reason: "not_source_eligible",
+                        ruleId: "promotion_early10",
+                    },
+                ],
+            },
+            availability: {
+                status: "available",
+                capacityRemaining: 3,
+            },
+            sellability: {
+                status: "allowed",
+                policyIds: ["source_policy_public"],
+            },
+            traces: [
+                {
+                    id: "trace_live_offer",
+                    source: "adapter",
+                    outcome: "applied",
+                    code: "live_offer_resolved",
+                    refs: {
+                        offerRef: "offer_abc",
+                    },
+                },
+                {
+                    id: "trace_fx",
+                    source: "fx",
+                    outcome: "applied",
+                    code: "fx_rate_applied",
+                    ruleId: "fx_2026_06_13",
+                },
+            ],
+            handles: [
+                {
+                    providerId: "cruise-provider",
+                    sourceId: "source_cruise",
+                    externalRef: "offer_abc",
+                    handle: "live_quote_123",
+                },
+            ],
+        };
+    },
+};
+describe("commercial decision Interface", () => {
+    it("evaluates an operated item through the operated inventory adapter", async () => {
+        const evaluator = createCommercialDecisionEvaluator({
+            adapters: [operatedInventoryAdapter],
+        });
+        const decision = await evaluator.evaluateCommercialDecision(operatedInput);
+        expect(decision.status).toBe("buyable");
+        expect(decision.buyable).toBe(true);
+        expect(decision.pricing?.total).toEqual({
+            amountMinor: 21600,
+            currency: "EUR",
+        });
+        expect(decision.promotions.applied).toHaveLength(1);
+        expect(decision.availability?.capacityRemaining).toBe(6);
+        expect(decision.sellability?.policyIds).toEqual(["sellability_policy_public"]);
+        expect(decision.traces.map((trace) => trace.code)).toEqual([
+            "adapter_selected",
+            "market_rule_applied",
+            "price_rule_applied",
+            "promotion_applied",
+        ]);
+        expect(decision.handles).toEqual([
+            {
+                adapterId: "operated-inventory",
+                adapterKind: "operated-inventory",
+            },
+            {
+                adapterId: "operated-inventory",
+                adapterKind: "operated-inventory",
+                providerId: "inventory",
+                handle: "slot_2026_09_18",
+            },
+        ]);
+    });
+    it("evaluates a sourced vertical item through a source adapter and records snapshots separately", async () => {
+        const evaluator = createCommercialDecisionEvaluator({
+            adapters: [operatedInventoryAdapter],
+        });
+        evaluator.registerPriceAvailabilityAdapter(sourcedAdapter);
+        const input = {
+            ...operatedInput,
+            item: {
+                kind: "vertical-item",
+                id: "cruise_sailing_2026_11_02",
+                vertical: "cruise",
+                source: "sourced",
+                sourceRef: {
+                    sourceId: "source_cruise",
+                    externalRef: "sailing_2026_11_02",
+                },
+            },
+            idempotencyKey: "quote-version:quote_v1:item:cruise_sailing_2026_11_02",
+        };
+        const writes = [];
+        const repository = {
+            async recordCommercialSnapshot(write) {
+                writes.push(write);
+                return {
+                    snapshotId: `commercial_snapshot_${writes.length}`,
+                    decisionId: write.decision.decisionId,
+                    target: write.target,
+                    idempotencyKey: write.idempotencyKey,
+                    recordedAt: "2026-06-13T09:01:00.000Z",
+                };
+            },
+        };
+        const decision = await evaluator.evaluateCommercialDecision(input);
+        expect(writes).toHaveLength(0);
+        expect(decision.status).toBe("buyable");
+        expect(decision.pricing?.total.amountMinor).toBe(192000);
+        expect(decision.fx).toMatchObject({
+            sourceCurrency: "USD",
+            requestedCurrency: "EUR",
+            rateSetId: "fx_2026_06_13",
+        });
+        expect(decision.promotions.rejected).toEqual([
+            {
+                code: "EARLY10",
+                status: "rejected",
+                reason: "not_source_eligible",
+                ruleId: "promotion_early10",
+            },
+        ]);
+        expect(decision.traces.map((trace) => trace.code)).toContain("live_offer_resolved");
+        expect(decision.handles).toContainEqual({
+            adapterId: "cruise-source",
+            adapterKind: "source",
+            providerId: "cruise-provider",
+            sourceId: "source_cruise",
+            externalRef: "offer_abc",
+            handle: "live_quote_123",
+        });
+        const snapshot = await recordCommercialSnapshot(decision, {
+            kind: "quote-version",
+            id: "quote_version_1",
+        }, repository);
+        expect(writes).toHaveLength(1);
+        expect(snapshot).toMatchObject({
+            snapshotId: "commercial_snapshot_1",
+            decisionId: decision.decisionId,
+            idempotencyKey: "quote-version:quote_v1:item:cruise_sailing_2026_11_02",
+        });
+    });
+});

package/dist/markets/index.d.ts

@@ -0,0 +1,11 @@
+import type { Module } from "@voyant-travel/core";
+import type { HonoModule } from "@voyant-travel/hono/module";
+import { marketsService } from "./service.js";
+export type { MarketsRoutes } from "./routes.js";
+export declare const marketsModule: Module;
+export declare const marketsHonoModule: HonoModule;
+export type { ExchangeRate, FxRateSet, Market, MarketChannelRule, MarketCurrency, MarketLocale, MarketPriceCatalog, MarketProductRule, NewExchangeRate, NewFxRateSet, NewMarket, NewMarketChannelRule, NewMarketCurrency, NewMarketLocale, NewMarketPriceCatalog, NewMarketProductRule, } from "./schema.js";
+export { exchangeRates, fxRateSets, marketChannelRules, marketCurrencies, marketLocales, marketPriceCatalogs, marketProductRules, markets, } from "./schema.js";
+export { exchangeRateListQuerySchema, fxRateSetListQuerySchema, insertExchangeRateSchema, insertFxRateSetSchema, insertMarketChannelRuleSchema, insertMarketCurrencySchema, insertMarketLocaleSchema, insertMarketPriceCatalogSchema, insertMarketProductRuleSchema, insertMarketSchema, marketChannelRuleListQuerySchema, marketCurrencyListQuerySchema, marketListQuerySchema, marketLocaleListQuerySchema, marketPriceCatalogListQuerySchema, marketProductRuleListQuerySchema, updateExchangeRateSchema, updateFxRateSetSchema, updateMarketChannelRuleSchema, updateMarketCurrencySchema, updateMarketLocaleSchema, updateMarketPriceCatalogSchema, updateMarketProductRuleSchema, updateMarketSchema, } from "./validation.js";
+export { marketsService };
+//# sourceMappingURL=index.d.ts.map

package/dist/markets/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/markets/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAG5D,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAE7C,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,aAAa,EAAE,MAE3B,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,UAG/B,CAAA;AAED,YAAY,EACV,YAAY,EACZ,SAAS,EACT,MAAM,EACN,iBAAiB,EACjB,cAAc,EACd,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EACf,YAAY,EACZ,SAAS,EACT,oBAAoB,EACpB,iBAAiB,EACjB,eAAe,EACf,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,aAAa,EACb,UAAU,EACV,kBAAkB,EAClB,gBAAgB,EAChB,aAAa,EACb,mBAAmB,EACnB,kBAAkB,EAClB,OAAO,GACR,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,2BAA2B,EAC3B,wBAAwB,EACxB,wBAAwB,EACxB,qBAAqB,EACrB,6BAA6B,EAC7B,0BAA0B,EAC1B,wBAAwB,EACxB,8BAA8B,EAC9B,6BAA6B,EAC7B,kBAAkB,EAClB,gCAAgC,EAChC,6BAA6B,EAC7B,qBAAqB,EACrB,2BAA2B,EAC3B,iCAAiC,EACjC,gCAAgC,EAChC,wBAAwB,EACxB,qBAAqB,EACrB,6BAA6B,EAC7B,0BAA0B,EAC1B,wBAAwB,EACxB,8BAA8B,EAC9B,6BAA6B,EAC7B,kBAAkB,GACnB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/markets/index.js

@@ -0,0 +1,12 @@
+import { marketsRoutes } from "./routes.js";
+import { marketsService } from "./service.js";
+export const marketsModule = {
+    name: "markets",
+};
+export const marketsHonoModule = {
+    module: marketsModule,
+    routes: marketsRoutes,
+};
+export { exchangeRates, fxRateSets, marketChannelRules, marketCurrencies, marketLocales, marketPriceCatalogs, marketProductRules, markets, } from "./schema.js";
+export { exchangeRateListQuerySchema, fxRateSetListQuerySchema, insertExchangeRateSchema, insertFxRateSetSchema, insertMarketChannelRuleSchema, insertMarketCurrencySchema, insertMarketLocaleSchema, insertMarketPriceCatalogSchema, insertMarketProductRuleSchema, insertMarketSchema, marketChannelRuleListQuerySchema, marketCurrencyListQuerySchema, marketListQuerySchema, marketLocaleListQuerySchema, marketPriceCatalogListQuerySchema, marketProductRuleListQuerySchema, updateExchangeRateSchema, updateFxRateSetSchema, updateMarketChannelRuleSchema, updateMarketCurrencySchema, updateMarketLocaleSchema, updateMarketPriceCatalogSchema, updateMarketProductRuleSchema, updateMarketSchema, } from "./validation.js";
+export { marketsService };