@voyant-travel/distribution 0.109.8

package/dist/channel-push/admin-routes.js

@@ -0,0 +1,165 @@
+/**
+ * Admin API for the channel-push operator dashboard.
+ *
+ * Ships the data layer for "channel sync" views per §9 + §10 (Phase D)
+ * + §14.5 — operators want to see (a) which booking links are stuck,
+ * (b) the delivery log per booking, (c) per-channel throttling, and
+ * (d) a one-click retry button. The React surface lives in templates;
+ * this file is the backing API.
+ *
+ * Routes are mounted under `/v1/admin/distribution/*`.
+ *
+ *   GET  /links              — counts + filterable list of channel_booking_links
+ *   POST /retry/:bookingId   — drain pending links for one booking
+ *   GET  /deliveries         — webhook_deliveries scoped by booking/channel
+ *   GET  /throttling         — per-channel rate-limited count in last hour
+ *   POST /reconcile/:flow    — manually trigger a reconciler scanner
+ *
+ * Per docs/architecture/channel-push-architecture.md §9 + §14.5.
+ */
+import { infraWebhookDeliveriesTable, } from "@voyant-travel/db/schema/infra";
+import { and, desc, eq, gte, sql } from "drizzle-orm";
+import { Hono } from "hono";
+import { channelBookingLinks, channels } from "../schema.js";
+import { reconcileAvailability, reconcileBookingLinks, reconcileContent } from "./reconciler.js";
+import { triggerBookingPushForBooking } from "./subscriber.js";
+export function createChannelPushAdminRoutes() {
+    const app = new Hono();
+    // ── GET /links ───────────────────────────────────────────────────
+    // Status counts + filterable list of channel_booking_links. The
+    // dashboard's "channel sync" view consumes this for both the summary
+    // tiles ("X pending, Y failed, Z compensated") and the row table.
+    app.get("/links", async (c) => {
+        const db = c.get("db");
+        const status = c.req.query("status");
+        const channelId = c.req.query("channelId");
+        const bookingId = c.req.query("bookingId");
+        const limit = clampLimit(c.req.query("limit"));
+        const filters = [
+            status ? eq(channelBookingLinks.pushStatus, status) : sql `true`,
+            channelId ? eq(channelBookingLinks.channelId, channelId) : sql `true`,
+            bookingId ? eq(channelBookingLinks.bookingId, bookingId) : sql `true`,
+        ];
+        const rows = await db
+            .select({
+            link: channelBookingLinks,
+            channelName: channels.name,
+            channelKind: channels.kind,
+        })
+            .from(channelBookingLinks)
+            .innerJoin(channels, eq(channelBookingLinks.channelId, channels.id))
+            .where(and(...filters))
+            .orderBy(desc(channelBookingLinks.lastPushAt), desc(channelBookingLinks.createdAt))
+            .limit(limit);
+        const counts = await db
+            .select({
+            status: channelBookingLinks.pushStatus,
+            count: sql `count(*)::int`,
+        })
+            .from(channelBookingLinks)
+            .where(and(...filters))
+            .groupBy(channelBookingLinks.pushStatus);
+        return c.json({
+            data: rows,
+            counts: Object.fromEntries(counts.map((c) => [c.status, c.count])),
+        });
+    });
+    // ── POST /retry/:bookingId ───────────────────────────────────────
+    // Operator-driven retry. Re-resolves push targets, upserts pending
+    // intent rows, and runs processBookingPush inline. Idempotent on
+    // the booking_links unique constraint, so accidental double-clicks
+    // are safe.
+    app.post("/retry/:bookingId", async (c) => {
+        const bookingId = c.req.param("bookingId");
+        try {
+            await triggerBookingPushForBooking(bookingId);
+            return c.json({ data: { ok: true, bookingId } });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return c.json({ error: message }, 500);
+        }
+    });
+    // ── GET /deliveries ──────────────────────────────────────────────
+    // Drilldown view: every webhook_deliveries row scoped to a booking,
+    // channel, or both. Used by the "show me what we sent" link in the
+    // dashboard's failure rows.
+    app.get("/deliveries", async (c) => {
+        const db = c.get("db");
+        const bookingId = c.req.query("bookingId");
+        const channelId = c.req.query("channelId");
+        const limit = clampLimit(c.req.query("limit"));
+        const filters = [
+            eq(infraWebhookDeliveriesTable.sourceModule, "distribution"),
+            bookingId
+                ? and(eq(infraWebhookDeliveriesTable.sourceEntityModule, "bookings"), eq(infraWebhookDeliveriesTable.sourceEntityId, bookingId))
+                : sql `true`,
+            channelId ? eq(infraWebhookDeliveriesTable.targetRef, channelId) : sql `true`,
+        ];
+        const rows = (await db
+            .select()
+            .from(infraWebhookDeliveriesTable)
+            .where(and(...filters))
+            .orderBy(desc(infraWebhookDeliveriesTable.createdAt))
+            .limit(limit));
+        return c.json({ data: rows });
+    });
+    // ── GET /throttling ──────────────────────────────────────────────
+    // Per-channel rate-limited count in the last hour. The dashboard
+    // shows a yellow "throttled" badge when any channel has > 0
+    // rate_limited rows in the window. Per §14.5.
+    app.get("/throttling", async (c) => {
+        const db = c.get("db");
+        const sinceMs = Number.parseInt(c.req.query("sinceMs") ?? String(60 * 60 * 1000), 10);
+        const since = new Date(Date.now() - (Number.isFinite(sinceMs) ? sinceMs : 60 * 60 * 1000));
+        const rows = await db
+            .select({
+            channelId: infraWebhookDeliveriesTable.targetRef,
+            count: sql `count(*)::int`,
+        })
+            .from(infraWebhookDeliveriesTable)
+            .where(and(eq(infraWebhookDeliveriesTable.sourceModule, "distribution"), eq(infraWebhookDeliveriesTable.errorClass, "rate_limited"), gte(infraWebhookDeliveriesTable.createdAt, since)))
+            .groupBy(infraWebhookDeliveriesTable.targetRef);
+        return c.json({
+            data: rows.filter((r) => r.channelId != null),
+            sinceMs,
+        });
+    });
+    // ── POST /reconcile/:flow ────────────────────────────────────────
+    // Manual reconciler trigger for ops — useful when a channel comes
+    // back up after a long outage and you don't want to wait for the
+    // next scheduled run. `flow` is one of "bookings", "availability",
+    // "content".
+    app.post("/reconcile/:flow", async (c) => {
+        const flow = c.req.param("flow");
+        try {
+            switch (flow) {
+                case "bookings": {
+                    const result = await reconcileBookingLinks({});
+                    return c.json({ data: result });
+                }
+                case "availability": {
+                    const result = await reconcileAvailability({});
+                    return c.json({ data: result });
+                }
+                case "content": {
+                    const result = await reconcileContent({});
+                    return c.json({ data: result });
+                }
+                default:
+                    return c.json({ error: `unknown flow "${flow}"` }, 400);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return c.json({ error: message }, 500);
+        }
+    });
+    return app;
+}
+function clampLimit(raw) {
+    const parsed = raw ? Number.parseInt(raw, 10) : 50;
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return 50;
+    return Math.min(parsed, 500);
+}

package/dist/channel-push/availability-push.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Availability-push pipeline.
+ *
+ * Triggered by `availability.slot.changed`. The subscriber upserts a
+ * `channel_availability_push_intents` row per (channel, slot) — concurrent
+ * supersession events collapse to one row via the unique constraint.
+ * The processor (`processAvailabilityPushIntents`) drains intents per
+ * channel, reads the *current* slot state, and dispatches via
+ * `adapter.pushAvailability()`. Stale-event protection comes from
+ * reading current state at processing time, not the event payload.
+ *
+ * Per docs/architecture/channel-push-architecture.md §5 + §12.2.
+ */
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import { channelProductMappings, channels } from "../schema.js";
+import { type ChannelPushDeps } from "./types.js";
+/** Stable string identifier for the availability-push workflow. */
+export declare const CHANNEL_AVAILABILITY_PUSH_WORKFLOW_ID: "channel.availability.push";
+export interface ResolveAllotmentTargetsForSlotInput {
+    slotId: string;
+    productId: string;
+    optionId: string | null;
+}
+/**
+ * Resolve the channels that hold an allotment for this slot/product/option.
+ * Per §7.4 — availability push uses `channel_inventory_allotments` (NOT
+ * `channel_product_mappings`), so channels mapped to the product but
+ * with no per-slot allotment don't receive pushes.
+ *
+ * v1 returns one row per channel that has an active allotment whose
+ * scope matches the slot (by product, optionally by option). Per-slot
+ * targeting via `channel_inventory_allotment_targets` is consulted in a
+ * future iteration; v1 dispatches at allotment-level so any allotment
+ * row covering the product/option triggers a push.
+ */
+export declare function resolveAllotmentTargetsForSlot(db: AnyDrizzleDb, input: ResolveAllotmentTargetsForSlotInput): Promise<Array<{
+    channelId: string;
+    sourceConnectionId: string;
+    mapping: typeof channelProductMappings.$inferSelect;
+    channel: typeof channels.$inferSelect;
+}>>;
+/**
+ * Insert/update an intent row per (channel, slot). The unique
+ * constraint on `(channel_id, slot_id)` collapses concurrent
+ * supersession events to one row; the worker reads the *current* slot
+ * state when it processes, so stale event payloads never propagate.
+ */
+export declare function upsertAvailabilityIntent(db: AnyDrizzleDb, input: {
+    channelId: string;
+    sourceConnectionId: string;
+    slotId: string;
+    productId: string;
+    optionId: string | null;
+    startsAt: Date;
+}): Promise<void>;
+export interface ProcessAvailabilityPushInput {
+    /** When set, drain intents only for this channel. Otherwise drain all. */
+    channelId?: string;
+    /** Max intents to process per call (across all channels). Default 100. */
+    limit?: number;
+}
+export interface ProcessAvailabilityPushResult {
+    attempted: number;
+    succeeded: number;
+    failed: number;
+    skipped: number;
+}
+/**
+ * Drain pending availability intents. Reads CURRENT slot state for each
+ * intent (so superseded values never propagate). On success, deletes the
+ * intent row. On failure, increments `attempts` and stamps `last_error`.
+ *
+ * Per §5.3 + §12.2.
+ */
+export declare function processAvailabilityPushIntents(input?: ProcessAvailabilityPushInput, deps?: ChannelPushDeps): Promise<ProcessAvailabilityPushResult>;
+//# sourceMappingURL=availability-push.d.ts.map

package/dist/channel-push/availability-push.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"availability-push.d.ts","sourceRoot":"","sources":["../../src/channel-push/availability-push.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAOH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAIrD,OAAO,EAGL,sBAAsB,EACtB,QAAQ,EACT,MAAM,cAAc,CAAA;AAIrB,OAAO,EAAE,KAAK,eAAe,EAA4C,MAAM,YAAY,CAAA;AAE3F,mEAAmE;AACnE,eAAO,MAAM,qCAAqC,EAAG,2BAAoC,CAAA;AAEzF,MAAM,WAAW,mCAAmC;IAClD,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,8BAA8B,CAClD,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,mCAAmC,GACzC,OAAO,CACR,KAAK,CAAC;IACJ,SAAS,EAAE,MAAM,CAAA;IACjB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,OAAO,EAAE,OAAO,sBAAsB,CAAC,YAAY,CAAA;IACnD,OAAO,EAAE,OAAO,QAAQ,CAAC,YAAY,CAAA;CACtC,CAAC,CACH,CAoDA;AAED;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE;IACL,SAAS,EAAE,MAAM,CAAA;IACjB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,QAAQ,EAAE,IAAI,CAAA;CACf,GACA,OAAO,CAAC,IAAI,CAAC,CAsBf;AAED,MAAM,WAAW,4BAA4B;IAC3C,0EAA0E;IAC1E,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,6BAA6B;IAC5C,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;GAMG;AACH,wBAAsB,8BAA8B,CAClD,KAAK,GAAE,4BAAiC,EACxC,IAAI,CAAC,EAAE,eAAe,GACrB,OAAO,CAAC,6BAA6B,CAAC,CA2JxC"}

package/dist/channel-push/availability-push.js

@@ -0,0 +1,236 @@
+/**
+ * Availability-push pipeline.
+ *
+ * Triggered by `availability.slot.changed`. The subscriber upserts a
+ * `channel_availability_push_intents` row per (channel, slot) — concurrent
+ * supersession events collapse to one row via the unique constraint.
+ * The processor (`processAvailabilityPushIntents`) drains intents per
+ * channel, reads the *current* slot state, and dispatches via
+ * `adapter.pushAvailability()`. Stale-event protection comes from
+ * reading current state at processing time, not the event payload.
+ *
+ * Per docs/architecture/channel-push-architecture.md §5 + §12.2.
+ */
+import { AdapterRateLimitedError, } from "@voyant-travel/catalog";
+import { newId } from "@voyant-travel/db/lib/typeid";
+import { and, asc, eq, inArray, sql } from "drizzle-orm";
+import { acquireToken, channelScopeKey, drainBucket } from "../rate-limit.js";
+import { channelAvailabilityPushIntents, channelInventoryAllotments, channelProductMappings, channels, } from "../schema.js";
+import { prepareOutboundEnvelope } from "../webhook-deliveries.js";
+import { loadAvailabilityPushSlot } from "./boundary-sql.js";
+import { defaultLogger, getChannelPushDepsOrThrow } from "./types.js";
+/** Stable string identifier for the availability-push workflow. */
+export const CHANNEL_AVAILABILITY_PUSH_WORKFLOW_ID = "channel.availability.push";
+/**
+ * Resolve the channels that hold an allotment for this slot/product/option.
+ * Per §7.4 — availability push uses `channel_inventory_allotments` (NOT
+ * `channel_product_mappings`), so channels mapped to the product but
+ * with no per-slot allotment don't receive pushes.
+ *
+ * v1 returns one row per channel that has an active allotment whose
+ * scope matches the slot (by product, optionally by option). Per-slot
+ * targeting via `channel_inventory_allotment_targets` is consulted in a
+ * future iteration; v1 dispatches at allotment-level so any allotment
+ * row covering the product/option triggers a push.
+ */
+export async function resolveAllotmentTargetsForSlot(db, input) {
+    // Resolve allotments for this product (optionally option-scoped).
+    const allotmentRows = (await db
+        .select({
+        channelId: channelInventoryAllotments.channelId,
+    })
+        .from(channelInventoryAllotments)
+        .innerJoin(channels, eq(channelInventoryAllotments.channelId, channels.id))
+        .where(and(eq(channelInventoryAllotments.productId, input.productId), eq(channelInventoryAllotments.active, true), eq(channels.status, "active"), input.optionId
+        ? // agent-quality: raw-sql reviewed -- owner: distribution; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            sql `(${channelInventoryAllotments.optionId} IS NULL OR ${channelInventoryAllotments.optionId} = ${input.optionId})`
+        : // agent-quality: raw-sql reviewed -- owner: distribution; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            sql `${channelInventoryAllotments.optionId} IS NULL`)));
+    if (allotmentRows.length === 0)
+        return [];
+    const channelIds = Array.from(new Set(allotmentRows.map((r) => r.channelId)));
+    const mappings = (await db
+        .select({
+        mapping: channelProductMappings,
+        channel: channels,
+    })
+        .from(channelProductMappings)
+        .innerJoin(channels, eq(channelProductMappings.channelId, channels.id))
+        .where(and(eq(channelProductMappings.productId, input.productId), eq(channelProductMappings.active, true), eq(channelProductMappings.pushAvailability, true), inArray(channelProductMappings.channelId, channelIds))));
+    return mappings
+        .filter((row) => row.mapping.sourceConnectionId)
+        .map((row) => ({
+        channelId: row.channel.id,
+        sourceConnectionId: row.mapping.sourceConnectionId,
+        mapping: row.mapping,
+        channel: row.channel,
+    }));
+}
+/**
+ * Insert/update an intent row per (channel, slot). The unique
+ * constraint on `(channel_id, slot_id)` collapses concurrent
+ * supersession events to one row; the worker reads the *current* slot
+ * state when it processes, so stale event payloads never propagate.
+ */
+export async function upsertAvailabilityIntent(db, input) {
+    await db
+        .insert(channelAvailabilityPushIntents)
+        .values({
+        id: newId("channel_availability_push_intents"),
+        channelId: input.channelId,
+        sourceConnectionId: input.sourceConnectionId,
+        slotId: input.slotId,
+        productId: input.productId,
+        optionId: input.optionId,
+        startsAt: input.startsAt,
+    })
+        .onConflictDoUpdate({
+        target: [channelAvailabilityPushIntents.channelId, channelAvailabilityPushIntents.slotId],
+        set: {
+            requestedAt: new Date(),
+            updatedAt: new Date(),
+            // Reset attempts when a new event lands — fresh chance.
+            attempts: 0,
+            lastError: null,
+        },
+    });
+}
+/**
+ * Drain pending availability intents. Reads CURRENT slot state for each
+ * intent (so superseded values never propagate). On success, deletes the
+ * intent row. On failure, increments `attempts` and stamps `last_error`.
+ *
+ * Per §5.3 + §12.2.
+ */
+export async function processAvailabilityPushIntents(input = {}, deps) {
+    const { db, registry, logger = defaultLogger } = deps ?? getChannelPushDepsOrThrow();
+    const limit = input.limit ?? 100;
+    const intents = (await db
+        .select({
+        intent: channelAvailabilityPushIntents,
+        channel: channels,
+    })
+        .from(channelAvailabilityPushIntents)
+        .innerJoin(channels, eq(channelAvailabilityPushIntents.channelId, channels.id))
+        .where(and(input.channelId ? eq(channelAvailabilityPushIntents.channelId, input.channelId) : sql `true`, eq(channels.status, "active")))
+        .orderBy(asc(channelAvailabilityPushIntents.requestedAt))
+        .limit(limit));
+    let succeeded = 0;
+    let failed = 0;
+    let skipped = 0;
+    for (const { intent, channel } of intents) {
+        // Read current slot state — stale events naturally don't propagate.
+        const slot = await loadAvailabilityPushSlot(db, intent.slotId);
+        if (!slot) {
+            // Slot deleted; drop the intent. Reconciler covers any drift.
+            await db
+                .delete(channelAvailabilityPushIntents)
+                .where(eq(channelAvailabilityPushIntents.id, intent.id));
+            skipped += 1;
+            continue;
+        }
+        const adapter = registry.resolveByConnection(intent.sourceConnectionId);
+        if (!adapter?.capabilities.supportsAvailabilityPush || !adapter.pushAvailability) {
+            await stampIntentError(db, intent.id, intent.attempts + 1, adapter ? "adapter_unsupported" : "no_adapter_registered");
+            failed += 1;
+            continue;
+        }
+        // Look up external ids via channel_product_mappings.
+        const [mapping] = (await db
+            .select()
+            .from(channelProductMappings)
+            .where(and(eq(channelProductMappings.channelId, channel.id), eq(channelProductMappings.productId, intent.productId)))
+            .limit(1));
+        if (!mapping) {
+            await stampIntentError(db, intent.id, intent.attempts + 1, "no_mapping");
+            failed += 1;
+            continue;
+        }
+        // Rate limit before dispatching. Availability uses the gated
+        // priority (default 0.3) so bookings always pre-empt.
+        const rlConfig = rateLimitConfigForChannel(channel);
+        if (rlConfig) {
+            const acq = await acquireToken(db, channelScopeKey(channel.id, intent.sourceConnectionId), rlConfig, "availability");
+            if (!acq.acquired) {
+                // Per §14.3: availability denials don't sleep. The next event
+                // for the same key supersedes; intent stays for next pass.
+                await stampIntentError(db, intent.id, intent.attempts + 1, "rate_limited");
+                failed += 1;
+                continue;
+            }
+        }
+        const request = {
+            channelId: channel.id,
+            externalProductId: mapping.externalProductId ?? "",
+            externalRateId: mapping.externalRateId ?? undefined,
+            externalCategoryId: mapping.externalCategoryId ?? undefined,
+            slotId: slot.id,
+            productId: slot.productId,
+            optionId: slot.optionId ?? undefined,
+            startsAt: slot.startsAt,
+            remainingPax: slot.unlimited ? Number.MAX_SAFE_INTEGER : (slot.remainingPax ?? 0),
+            source: "refresh",
+        };
+        const adapterCtx = {
+            connection_id: intent.sourceConnectionId,
+        };
+        const envelope = await prepareOutboundEnvelope(db, {
+            sourceModule: "distribution",
+            sourceEvent: "channel.availability.push",
+            sourceEntityModule: "availability",
+            sourceEntityId: slot.id,
+            targetUrl: `adapter:${adapter.kind}`,
+            targetKind: `channel:${adapter.kind}`,
+            targetRef: channel.id,
+            requestMethod: "POST",
+            requestBody: request,
+            attemptNumber: intent.attempts + 1,
+        });
+        try {
+            const result = await adapter.pushAvailability(adapterCtx, request);
+            await envelope.complete({ responseStatus: 200, responseBody: result });
+            // Drain on success.
+            await db
+                .delete(channelAvailabilityPushIntents)
+                .where(eq(channelAvailabilityPushIntents.id, intent.id));
+            succeeded += 1;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const isRateLimited = err instanceof AdapterRateLimitedError;
+            if (isRateLimited) {
+                await drainBucket(db, channelScopeKey(channel.id, intent.sourceConnectionId), err.retryAfterMs);
+            }
+            await envelope.complete({
+                errorClass: isRateLimited ? "rate_limited" : "adapter_error",
+                errorMessage: message,
+            });
+            await stampIntentError(db, intent.id, intent.attempts + 1, message);
+            failed += 1;
+            logger.error?.(`pushAvailability failed for slot ${slot.id} channel ${channel.id}`, {
+                error: message,
+            });
+        }
+    }
+    return {
+        attempted: intents.length,
+        succeeded,
+        failed,
+        skipped,
+    };
+}
+async function stampIntentError(db, id, attempts, message) {
+    await db
+        .update(channelAvailabilityPushIntents)
+        .set({ attempts, lastError: message, updatedAt: new Date() })
+        .where(eq(channelAvailabilityPushIntents.id, id));
+}
+function rateLimitConfigForChannel(channel) {
+    if (!channel.rateLimitRps || !channel.rateLimitBurst)
+        return null;
+    return {
+        rps: channel.rateLimitRps,
+        burst: channel.rateLimitBurst,
+        priorityGates: channel.rateLimitPriorityGates ?? undefined,
+    };
+}

package/dist/channel-push/booking-push-helpers.d.ts

@@ -0,0 +1,36 @@
+import { type bookings } from "@voyant-travel/bookings/schema";
+import type { SourceAdapter, SourceAdapterContext } from "@voyant-travel/catalog";
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import { channelBookingLinks, channelProductMappings, type channels } from "@voyant-travel/distribution/schema";
+import type { RateLimitConfig } from "../rate-limit.js";
+import type { CompensationPolicy } from "./booking-push.js";
+/**
+ * Read the compensation policy for a channel by walking
+ * `channel_contracts` (most-recent active contract wins). Returns
+ * `eventually-consistent` when no contract exists or no compensation
+ * key is set — that's the doc-default safe behavior for travel
+ * inventory.
+ */
+export declare function resolveCompensationPolicy(db: AnyDrizzleDb, channelId: string | null): Promise<CompensationPolicy>;
+/**
+ * Roll back a succeeded link by calling `adapter.cancel` for the
+ * upstream reference. Marks the link `compensated` regardless of the
+ * cancel call's outcome — leaving it `ok` would lie to the operator
+ * dashboard. Per §4.2.
+ */
+export declare function compensateSucceededLink(db: AnyDrizzleDb, entry: {
+    link: typeof channelBookingLinks.$inferSelect;
+    channel: typeof channels.$inferSelect;
+    adapter: SourceAdapter;
+    adapterCtx: SourceAdapterContext;
+    upstreamRef: string;
+}, bookingId: string, logger: {
+    error?: (message: string, meta?: Record<string, unknown>) => void;
+    warn?: (message: string, meta?: Record<string, unknown>) => void;
+}): Promise<boolean>;
+export declare function markLinkOk(db: AnyDrizzleDb, linkId: string, attempts: number, upstreamRef: string, externalReference: string | null, externalStatus: string | null): Promise<void>;
+export declare function markLinkFailed(db: AnyDrizzleDb, linkId: string, attempts: number, message: string): Promise<void>;
+export declare function readMappingForLink(db: AnyDrizzleDb, link: typeof channelBookingLinks.$inferSelect, booking: typeof bookings.$inferSelect): Promise<typeof channelProductMappings.$inferSelect | null>;
+export declare function rateLimitConfigForChannel(channel: typeof channels.$inferSelect): RateLimitConfig | null;
+export declare function serializeBookingForPush(booking: typeof bookings.$inferSelect, bookingItemId: string | null): Record<string, unknown>;
+//# sourceMappingURL=booking-push-helpers.d.ts.map

package/dist/channel-push/booking-push-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"booking-push-helpers.d.ts","sourceRoot":"","sources":["../../src/channel-push/booking-push-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,gCAAgC,CAAA;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AACjF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,EACL,mBAAmB,EAEnB,sBAAsB,EACtB,KAAK,QAAQ,EACd,MAAM,oCAAoC,CAAA;AAG3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAGvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAE3D;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,GAAG,IAAI,GACvB,OAAO,CAAC,kBAAkB,CAAC,CAmB7B;AAED;;;;;GAKG;AACH,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE;IACL,IAAI,EAAE,OAAO,mBAAmB,CAAC,YAAY,CAAA;IAC7C,OAAO,EAAE,OAAO,QAAQ,CAAC,YAAY,CAAA;IACrC,OAAO,EAAE,aAAa,CAAA;IACtB,UAAU,EAAE,oBAAoB,CAAA;IAChC,WAAW,EAAE,MAAM,CAAA;CACpB,EACD,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE;IACN,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;IACjE,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;CACjE,GACA,OAAO,CAAC,OAAO,CAAC,CA+ClB;AAMD,wBAAsB,UAAU,CAC9B,EAAE,EAAE,YAAY,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,iBAAiB,EAAE,MAAM,GAAG,IAAI,EAChC,cAAc,EAAE,MAAM,GAAG,IAAI,GAC5B,OAAO,CAAC,IAAI,CAAC,CAgBf;AAED,wBAAsB,cAAc,CAClC,EAAE,EAAE,YAAY,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAYf;AAED,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,YAAY,EAChB,IAAI,EAAE,OAAO,mBAAmB,CAAC,YAAY,EAC7C,OAAO,EAAE,OAAO,QAAQ,CAAC,YAAY,GACpC,OAAO,CAAC,OAAO,sBAAsB,CAAC,YAAY,GAAG,IAAI,CAAC,CAmC5D;AAED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,OAAO,QAAQ,CAAC,YAAY,GACpC,eAAe,GAAG,IAAI,CAOxB;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,QAAQ,CAAC,YAAY,EACrC,aAAa,EAAE,MAAM,GAAG,IAAI,GAC3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAezB"}