@voyant-travel/catalog 0.117.2

package/dist/booking-engine/registry.js

@@ -0,0 +1,118 @@
+/**
+ * `SourceAdapterRegistry` — process-local map keyed by `connection_id` that
+ * the booking engine and channel-push pipeline consult when dispatching a
+ * quote / book / cancel / push call.
+ *
+ * Templates wire the registry at process start, registering one adapter
+ * instance per upstream connection. Two connections of the same kind
+ * (e.g. TUI dev + TUI prod, or two different Voyant Connect peers) get
+ * two registry entries with two distinct `connection_id`s — different
+ * credentials, different rate buckets, different `channel_id` mappings.
+ *
+ * `kind` remains a useful secondary index — "list all adapters of this
+ * kind" supports rotate-to-next-available policies and admin debug
+ * surfaces. But routing dispatches by `connection_id` because that's
+ * what the data carries (provenance.source_connection_id on sourced
+ * rows, channels.id on outbound mappings).
+ *
+ * Per channel-push-architecture §3.1 and catalog-booking-engine §4.
+ */
+import { NoAdapterRegisteredError } from "./errors.js";
+/**
+ * Construct a fresh registry. Templates create one at process start and
+ * pass it to the booking-engine route handlers + channel-push wiring.
+ */
+export function createSourceAdapterRegistry() {
+    const byConnection = new Map();
+    const kindIndex = new Map();
+    function indexAdd(kind, connectionId) {
+        let set = kindIndex.get(kind);
+        if (!set) {
+            set = new Set();
+            kindIndex.set(kind, set);
+        }
+        set.add(connectionId);
+    }
+    function indexRemove(kind, connectionId) {
+        const set = kindIndex.get(kind);
+        if (!set)
+            return;
+        set.delete(connectionId);
+        if (set.size === 0)
+            kindIndex.delete(kind);
+    }
+    function register(arg1, arg2) {
+        let connectionId;
+        let adapter;
+        if (typeof arg1 === "string") {
+            if (!arg2) {
+                throw new TypeError("register(connectionId, adapter): adapter argument is required");
+            }
+            connectionId = arg1;
+            adapter = arg2;
+        }
+        else {
+            adapter = arg1;
+            connectionId = `default:${adapter.kind}`;
+        }
+        const previous = byConnection.get(connectionId);
+        if (previous) {
+            indexRemove(previous.kind, connectionId);
+        }
+        byConnection.set(connectionId, adapter);
+        indexAdd(adapter.kind, connectionId);
+    }
+    function resolveByConnection(connectionId) {
+        return byConnection.get(connectionId);
+    }
+    function resolveByConnectionOrThrow(connectionId) {
+        const adapter = byConnection.get(connectionId);
+        if (!adapter)
+            throw new NoAdapterRegisteredError(connectionId);
+        return adapter;
+    }
+    function byKind(sourceKind) {
+        const set = kindIndex.get(sourceKind);
+        if (!set || set.size === 0)
+            return [];
+        const out = [];
+        for (const connectionId of set) {
+            const adapter = byConnection.get(connectionId);
+            if (adapter)
+                out.push({ connectionId, adapter });
+        }
+        return out;
+    }
+    function resolveOrThrow(sourceKind) {
+        const set = kindIndex.get(sourceKind);
+        if (!set || set.size === 0)
+            throw new NoAdapterRegisteredError(sourceKind);
+        const first = set.values().next().value;
+        if (!first)
+            throw new NoAdapterRegisteredError(sourceKind);
+        const adapter = byConnection.get(first);
+        if (!adapter)
+            throw new NoAdapterRegisteredError(sourceKind);
+        return adapter;
+    }
+    return {
+        register: register,
+        resolveByConnection,
+        resolveByConnectionOrThrow,
+        resolveOrThrow,
+        byKind,
+        connections() {
+            return [...byConnection.keys()];
+        },
+        kinds() {
+            return [...kindIndex.keys()];
+        },
+        has(connectionId) {
+            return byConnection.has(connectionId);
+        },
+        hasKind(sourceKind) {
+            const set = kindIndex.get(sourceKind);
+            return !!set && set.size > 0;
+        },
+    };
+}

package/dist/booking-engine/registry.test.d.ts

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

package/dist/booking-engine/registry.test.d.ts.map

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

package/dist/booking-engine/registry.test.js

@@ -0,0 +1,132 @@
+import { describe, expect, it } from "vitest";
+import { NoAdapterRegisteredError } from "./errors.js";
+import { createSourceAdapterRegistry } from "./registry.js";
+function stubAdapter(kind) {
+    // Minimal SourceAdapter conforming to the contract surface — none of
+    // these methods get called by registry tests, but they need to exist
+    // for the type to satisfy.
+    return {
+        kind,
+        capabilities: {
+            verticals: ["products"],
+            supportsLiveResolution: false,
+            supportsDriftDetection: false,
+            supportsBookingForwarding: false,
+            postBookOperations: [],
+        },
+        connect: async () => undefined,
+        pause: async () => undefined,
+        disconnect: async () => undefined,
+        getState: async () => "active",
+        discover: async () => ({ projections: [], next_cursor: undefined }),
+    };
+}
+describe("createSourceAdapterRegistry — backward-compat (register without connection id)", () => {
+    it("registers an adapter under its declared kind", () => {
+        const registry = createSourceAdapterRegistry();
+        registry.register(stubAdapter("demo"));
+        expect(registry.hasKind("demo")).toBe(true);
+        expect(registry.resolveOrThrow("demo").kind).toBe("demo");
+    });
+    it("returns undefined for unknown kinds", () => {
+        const registry = createSourceAdapterRegistry();
+        expect(registry.hasKind("voyant-connect")).toBe(false);
+        expect(registry.byKind("voyant-connect")).toEqual([]);
+    });
+    it("resolveOrThrow throws NoAdapterRegisteredError on miss", () => {
+        const registry = createSourceAdapterRegistry();
+        expect(() => registry.resolveOrThrow("voyant-connect")).toThrowError(NoAdapterRegisteredError);
+    });
+    it("resolveOrThrow returns the adapter on hit", () => {
+        const registry = createSourceAdapterRegistry();
+        registry.register(stubAdapter("demo"));
+        const adapter = registry.resolveOrThrow("demo");
+        expect(adapter.kind).toBe("demo");
+    });
+    it("re-registering without connection id replaces under the synthetic key", () => {
+        const registry = createSourceAdapterRegistry();
+        const first = stubAdapter("demo");
+        const second = stubAdapter("demo");
+        registry.register(first);
+        registry.register(second);
+        expect(registry.resolveOrThrow("demo")).toBe(second);
+        expect(registry.resolveByConnection("default:demo")).toBe(second);
+    });
+    it("kinds() lists every registered kind", () => {
+        const registry = createSourceAdapterRegistry();
+        registry.register(stubAdapter("demo"));
+        registry.register(stubAdapter("voyant-connect"));
+        expect([...registry.kinds()].sort()).toEqual(["demo", "voyant-connect"]);
+    });
+});
+describe("createSourceAdapterRegistry — per-connection registration", () => {
+    it("registers and resolves by connection id", () => {
+        const registry = createSourceAdapterRegistry();
+        const adapter = stubAdapter("tui");
+        registry.register("conn_tui_dev", adapter);
+        expect(registry.has("conn_tui_dev")).toBe(true);
+        expect(registry.resolveByConnection("conn_tui_dev")).toBe(adapter);
+        expect(registry.resolveByConnectionOrThrow("conn_tui_dev")).toBe(adapter);
+    });
+    it("supports multiple connections of the same kind", () => {
+        const registry = createSourceAdapterRegistry();
+        const dev = stubAdapter("tui");
+        const prod = stubAdapter("tui");
+        registry.register("conn_tui_dev", dev);
+        registry.register("conn_tui_prod", prod);
+        expect(registry.resolveByConnection("conn_tui_dev")).toBe(dev);
+        expect(registry.resolveByConnection("conn_tui_prod")).toBe(prod);
+        const both = registry.byKind("tui");
+        expect(both.map((e) => e.connectionId).sort()).toEqual(["conn_tui_dev", "conn_tui_prod"]);
+    });
+    it("byKind returns empty array for unknown kind", () => {
+        const registry = createSourceAdapterRegistry();
+        expect(registry.byKind("nope")).toEqual([]);
+    });
+    it("resolveByConnectionOrThrow throws on miss", () => {
+        const registry = createSourceAdapterRegistry();
+        expect(() => registry.resolveByConnectionOrThrow("conn_x")).toThrowError(NoAdapterRegisteredError);
+    });
+    it("re-registering same connection id replaces and updates kind index", () => {
+        const registry = createSourceAdapterRegistry();
+        registry.register("conn_x", stubAdapter("tui"));
+        registry.register("conn_x", stubAdapter("voyant-connect"));
+        expect(registry.byKind("tui")).toEqual([]);
+        expect(registry.byKind("voyant-connect").map((e) => e.connectionId)).toEqual(["conn_x"]);
+    });
+    it("connections() returns every registered id", () => {
+        const registry = createSourceAdapterRegistry();
+        registry.register("conn_a", stubAdapter("tui"));
+        registry.register("conn_b", stubAdapter("voyant-connect"));
+        expect([...registry.connections()].sort()).toEqual(["conn_a", "conn_b"]);
+    });
+    it("rejects register(connectionId) without an adapter argument", () => {
+        const registry = createSourceAdapterRegistry();
+        // @ts-expect-error — missing adapter argument
+        expect(() => registry.register("conn_x")).toThrowError(TypeError);
+    });
+});
+describe("createSourceAdapterRegistry — outbound-only adapters", () => {
+    it("accepts adapters with no inbound methods", () => {
+        const outboundOnly = {
+            kind: "syndicate-target",
+            capabilities: {
+                verticals: ["products"],
+                supportsLiveResolution: false,
+                supportsDriftDetection: false,
+                supportsBookingForwarding: false,
+                postBookOperations: [],
+                supportsBookingPush: true,
+                supportsAvailabilityPush: true,
+                supportsContentPush: true,
+            },
+            pushBooking: async () => ({ upstreamRef: "ext_1" }),
+            pushAvailability: async () => ({}),
+            pushContent: async () => ({}),
+        };
+        const registry = createSourceAdapterRegistry();
+        registry.register("conn_syn_a", outboundOnly);
+        expect(registry.resolveByConnection("conn_syn_a")).toBe(outboundOnly);
+        expect(registry.byKind("syndicate-target").length).toBe(1);
+    });
+});

package/dist/booking-engine/routes-contracts.d.ts

@@ -0,0 +1,169 @@
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import type { Context } from "hono";
+import { z } from "zod";
+import type { SourceAdapterContext } from "../adapter/contract.js";
+import type { BookEntityResult } from "./book.js";
+import type { OwnedBookingHandlerRegistry } from "./owned-handler.js";
+import type { QuoteEntityDeps, QuoteEntityResult } from "./quote.js";
+import type { SourceAdapterRegistry } from "./registry.js";
+import type { SnapshotContentCapturer } from "./snapshot-content.js";
+export declare const quoteBodySchema: z.ZodObject<{
+    entityModule: z.ZodString;
+    entityId: z.ZodString;
+    sourceKind: z.ZodOptional<z.ZodString>;
+    sourceProvider: z.ZodOptional<z.ZodString>;
+    sourceConnectionId: z.ZodOptional<z.ZodString>;
+    sourceRef: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodObject<{
+        locale: z.ZodOptional<z.ZodString>;
+        audience: z.ZodOptional<z.ZodEnum<{
+            staff: "staff";
+            customer: "customer";
+            partner: "partner";
+            supplier: "supplier";
+        }>>;
+        market: z.ZodOptional<z.ZodString>;
+        currency: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    draft: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    ttlMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const bookBodySchema: z.ZodObject<{
+    quoteId: z.ZodOptional<z.ZodString>;
+    bookingId: z.ZodOptional<z.ZodString>;
+    party: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    paymentIntent: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"hold">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"card">;
+        tokenizedCard: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"ticket_on_credit">;
+        agencyAccount: z.ZodString;
+    }, z.core.$strip>]>>;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    draftId: z.ZodOptional<z.ZodString>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const draftBodySchema: z.ZodObject<{
+    entityModule: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+    sourceKind: z.ZodOptional<z.ZodString>;
+    sourceConnectionId: z.ZodOptional<z.ZodString>;
+    sourceRef: z.ZodOptional<z.ZodString>;
+    draftPayload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    currentStep: z.ZodOptional<z.ZodString>;
+    currentQuoteId: z.ZodOptional<z.ZodString>;
+    ttlMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const holdPlaceBodySchema: z.ZodObject<{
+    entityModule: z.ZodString;
+    entityId: z.ZodString;
+    draftId: z.ZodString;
+    ttlMs: z.ZodOptional<z.ZodNumber>;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const holdReleaseBodySchema: z.ZodObject<{
+    entityModule: z.ZodString;
+    holdToken: z.ZodString;
+}, z.core.$strip>;
+export type CatalogBookingQuoteBody = z.infer<typeof quoteBodySchema>;
+export type CatalogBookingBookBody = z.infer<typeof bookBodySchema>;
+export type CatalogBookingDraftBody = z.infer<typeof draftBodySchema>;
+export type CatalogBookingHoldPlaceBody = z.infer<typeof holdPlaceBodySchema>;
+export type CatalogBookingHoldReleaseBody = z.infer<typeof holdReleaseBodySchema>;
+export interface CatalogBookingProvenance {
+    sourceKind: string;
+    sourceProvider?: string;
+    sourceConnectionId?: string;
+    sourceRef?: string;
+}
+export interface CatalogBookingProvenanceInput {
+    c: Context;
+    db: AnyDrizzleDb;
+    entityModule: string;
+    entityId: string;
+}
+export interface CatalogBookingAdapterContextInput {
+    c: Context;
+    db: AnyDrizzleDb;
+    operation: "quote" | "book" | "hold";
+    entityModule?: string;
+    entityId?: string;
+    sourceKind: string;
+    sourceConnectionId?: string;
+    correlationId: string;
+}
+export interface CatalogBookingHoldTtlInput {
+    c: Context;
+    db: AnyDrizzleDb;
+    entityModule: string;
+    entityId: string;
+}
+export interface CatalogBookingContentScopeInput {
+    c: Context;
+    db: AnyDrizzleDb;
+    body: CatalogBookingBookBody;
+    draftPayload?: Record<string, unknown>;
+}
+export interface CatalogBookingQuoteTransformInput {
+    c: Context;
+    db: AnyDrizzleDb;
+    request: CatalogBookingQuoteBody;
+    provenance: CatalogBookingProvenance;
+    result: QuoteEntityResult;
+}
+export interface CatalogBookingBookTransformInput {
+    c: Context;
+    db: AnyDrizzleDb;
+    request: CatalogBookingBookBody;
+    result: BookEntityResult;
+}
+export interface CatalogBookingDraftConsumedError {
+    c: Context;
+    db: AnyDrizzleDb;
+    draftId: string;
+    bookingId: string;
+    error: unknown;
+}
+export interface CatalogBookingCommittedEvent {
+    c: Context;
+    db: AnyDrizzleDb;
+    request: CatalogBookingBookBody;
+    result: BookEntityResult;
+}
+export interface CatalogBookingRoutesOptions {
+    resolveDb(c: Context): AnyDrizzleDb;
+    resolveSourceRegistry(c: Context): SourceAdapterRegistry;
+    resolveOwnedHandlers?(c: Context): OwnedBookingHandlerRegistry | undefined;
+    resolveActorId?(c: Context): string | null;
+    resolveCorrelationId?(c: Context): string;
+    resolveAdapterContext?(input: CatalogBookingAdapterContextInput): SourceAdapterContext;
+    resolveEntityProvenance?(input: CatalogBookingProvenanceInput): Promise<CatalogBookingProvenance>;
+    resolveHoldTtlMs?(input: CatalogBookingHoldTtlInput): Promise<number>;
+    resolveContentScope?(input: CatalogBookingContentScopeInput): {
+        locale: string;
+        market?: string;
+        currency?: string;
+    } | undefined;
+    contentEnricher?: QuoteEntityDeps["contentEnricher"];
+    onContentEnricherError?: QuoteEntityDeps["onEnricherError"];
+    /**
+     * Resolve a per-request `evaluatePromotions` hook. Returning `undefined`
+     * skips promotion evaluation. Templates typically wire
+     * `createCatalogPromotionEvaluator(db)` from `@voyant-travel/commerce`.
+     *
+     * Per docs/architecture/promotions-architecture.md §3.6 + §7.1.
+     */
+    resolveEvaluatePromotions?(input: {
+        c: Context;
+        db: AnyDrizzleDb;
+    }): QuoteEntityDeps["evaluatePromotions"];
+    captureSnapshotContent?: SnapshotContentCapturer;
+    transformQuoteResult?(input: CatalogBookingQuoteTransformInput): Promise<QuoteEntityResult>;
+    transformBookResult?(input: CatalogBookingBookTransformInput): Promise<BookEntityResult>;
+    onDraftConsumedError?(event: CatalogBookingDraftConsumedError): void;
+    onCommitted?(event: CatalogBookingCommittedEvent): Promise<void> | void;
+}
+//# sourceMappingURL=routes-contracts.d.ts.map

package/dist/booking-engine/routes-contracts.d.ts.map

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

package/dist/booking-engine/routes-contracts.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+const recordSchema = z.record(z.string(), z.unknown());
+const quoteScopeSchema = z
+    .object({
+    locale: z.string().min(1).optional(),
+    audience: z.enum(["staff", "customer", "partner", "supplier"]).optional(),
+    market: z.string().min(1).optional(),
+    currency: z.string().min(1).optional(),
+})
+    .optional();
+export const quoteBodySchema = z.object({
+    entityModule: z.string().min(1),
+    entityId: z.string().min(1),
+    sourceKind: z.string().min(1).optional(),
+    sourceProvider: z.string().min(1).optional(),
+    sourceConnectionId: z.string().min(1).optional(),
+    sourceRef: z.string().min(1).optional(),
+    scope: quoteScopeSchema,
+    parameters: recordSchema.optional(),
+    draft: recordSchema.optional(),
+    ttlMs: z.number().int().positive().optional(),
+});
+export const bookBodySchema = z
+    .object({
+    quoteId: z.string().min(1).optional(),
+    bookingId: z.string().min(1).optional(),
+    party: recordSchema.optional(),
+    paymentIntent: z
+        .union([
+        z.object({ type: z.literal("hold") }),
+        z.object({ type: z.literal("card"), tokenizedCard: z.string().min(1) }),
+        z.object({ type: z.literal("ticket_on_credit"), agencyAccount: z.string().min(1) }),
+    ])
+        .optional(),
+    parameters: recordSchema.optional(),
+    draftId: z.string().min(1).optional(),
+    idempotencyKey: z.string().min(8).max(128).optional(),
+})
+    .refine((body) => body.quoteId || body.draftId, {
+    message: "either quoteId or draftId is required",
+});
+export const draftBodySchema = z.object({
+    entityModule: z.string().min(1).optional(),
+    entityId: z.string().min(1).optional(),
+    sourceKind: z.string().min(1).optional(),
+    sourceConnectionId: z.string().min(1).optional(),
+    sourceRef: z.string().min(1).optional(),
+    draftPayload: recordSchema,
+    currentStep: z.string().min(1).optional(),
+    currentQuoteId: z.string().min(1).optional(),
+    ttlMs: z.number().int().positive().optional(),
+});
+export const holdPlaceBodySchema = z.object({
+    entityModule: z.string().min(1),
+    entityId: z.string().min(1),
+    draftId: z.string().min(1),
+    ttlMs: z.number().int().positive().optional(),
+    parameters: recordSchema.optional(),
+});
+export const holdReleaseBodySchema = z.object({
+    entityModule: z.string().min(1),
+    holdToken: z.string().min(1),
+});

package/dist/booking-engine/routes.d.ts

@@ -0,0 +1,7 @@
+import type { HonoModule } from "@voyant-travel/hono/module";
+import { Hono } from "hono";
+import { type CatalogBookingRoutesOptions } from "./routes-contracts.js";
+export type { CatalogBookingAdapterContextInput, CatalogBookingBookBody, CatalogBookingBookTransformInput, CatalogBookingCommittedEvent, CatalogBookingContentScopeInput, CatalogBookingDraftBody, CatalogBookingDraftConsumedError, CatalogBookingHoldPlaceBody, CatalogBookingHoldReleaseBody, CatalogBookingHoldTtlInput, CatalogBookingProvenance, CatalogBookingProvenanceInput, CatalogBookingQuoteBody, CatalogBookingQuoteTransformInput, CatalogBookingRoutesOptions, } from "./routes-contracts.js";
+export declare function createCatalogBookingRoutes(options: CatalogBookingRoutesOptions): Hono;
+export declare function createCatalogBookingHonoModule(options: CatalogBookingRoutesOptions): HonoModule;
+//# sourceMappingURL=routes.d.ts.map

package/dist/booking-engine/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/booking-engine/routes.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAE5D,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAmC3B,OAAO,EAIL,KAAK,2BAA2B,EAKjC,MAAM,uBAAuB,CAAA;AAI9B,YAAY,EACV,iCAAiC,EACjC,sBAAsB,EACtB,gCAAgC,EAChC,4BAA4B,EAC5B,+BAA+B,EAC/B,uBAAuB,EACvB,gCAAgC,EAChC,2BAA2B,EAC3B,6BAA6B,EAC7B,0BAA0B,EAC1B,wBAAwB,EACxB,6BAA6B,EAC7B,uBAAuB,EACvB,iCAAiC,EACjC,2BAA2B,GAC5B,MAAM,uBAAuB,CAAA;AAE9B,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,2BAA2B,GAAG,IAAI,CASrF;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,2BAA2B,GAAG,UAAU,CAM/F"}