@voyant-travel/catalog 0.117.2

package/dist/services/sourced-entry-service.js

@@ -0,0 +1,203 @@
+/**
+ * SourcedEntryService — drizzle-bound entry point for the
+ * `catalog_sourced_entries` store.
+ *
+ * One row per sourced entity, written at `discover()` time. The row carries
+ * provenance, lifecycle markers, and the canonical local copy of the
+ * indexed projection (so the read service and the thin-content synthesizer
+ * can dispatch without round-tripping the search index).
+ *
+ * Three primitives:
+ *
+ *   - `upsertSourcedEntry` — called from `sync.ts` for every projection;
+ *     idempotent on (entity_module, entity_id) and on
+ *     (source_kind, source_connection_id, source_ref).
+ *   - `readSourcedEntry`   — point-read by Voyant-side identity. Returns
+ *     null for owned entities (which have no row here).
+ *   - `createReadProvenance` — factory that composes `readSourcedEntry`
+ *     with vertical-specific owned-checkers to produce a unified
+ *     `readProvenance(db, entity_module, entity_id)` that returns one of:
+ *     `{ kind: "owned" }`, `{ kind: "sourced", ... }`, or `null`.
+ *
+ * The factory pattern keeps this package neutral — it doesn't know how to
+ * read the products / cruises / hotels owned tables. Each vertical
+ * registers its owned-checker once when wiring its content service (Phase
+ * D and beyond).
+ *
+ * See `docs/architecture/catalog-sourced-content.md` §2.5.
+ */
+import { and, eq, inArray, isNull, notInArray, sql } from "drizzle-orm";
+import { catalogSourcedEntriesTable, } from "../schema-sourced-entries.js";
+// ─────────────────────────────────────────────────────────────────────────────
+// Reads
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Read one sourced-entry row by Voyant-side identity. Returns `null` for
+ * entities that aren't in the sourced-entry store — owned entities, or
+ * sourced entities the deployment hasn't yet discovered.
+ */
+export async function readSourcedEntry(db, entityModule, entityId) {
+    const rows = await db
+        .select()
+        .from(catalogSourcedEntriesTable)
+        .where(and(eq(catalogSourcedEntriesTable.entity_module, entityModule), eq(catalogSourcedEntriesTable.entity_id, entityId)))
+        .limit(1);
+    return rows[0] ?? null;
+}
+/**
+ * Build a unified `readProvenance(db, entity_module, entity_id)` against a
+ * registry of vertical-specific owned-checkers. The returned function:
+ *
+ *   1. Calls the vertical's owned-checker. If it returns `true`, the entity
+ *      is owned — return `{ kind: "owned", provenance: ... }` without
+ *      touching the sourced-entry table.
+ *   2. Otherwise, look up the sourced-entry row. If found, return
+ *      `{ kind: "sourced", ... }`.
+ *   3. If neither, return `null`.
+ *
+ * Verticals not in `ownedCheckers` skip the owned check (treated as
+ * sourced-only). This is intentional: not every vertical has an owned
+ * counterpart for every sourced entity.
+ */
+export function createReadProvenance(options) {
+    const ownedCheckers = options.ownedCheckers ?? new Map();
+    return async function readProvenance(db, entityModule, entityId) {
+        const ownedChecker = ownedCheckers.get(entityModule);
+        if (ownedChecker) {
+            const isOwned = await ownedChecker(db, entityId);
+            if (isOwned) {
+                return {
+                    kind: "owned",
+                    provenance: { source_kind: "owned", source_freshness: "static" },
+                };
+            }
+        }
+        const row = await readSourcedEntry(db, entityModule, entityId);
+        if (!row)
+            return null;
+        return {
+            kind: "sourced",
+            provenance: {
+                source_kind: row.source_kind,
+                source_provider: row.source_provider ?? undefined,
+                source_connection_id: row.source_connection_id ?? undefined,
+                source_ref: row.source_ref ?? undefined,
+                source_freshness: row.source_freshness,
+                last_sourced_at: row.last_sourced_at ?? undefined,
+            },
+            entry_id: row.id,
+            status: row.status,
+            projection: row.projection,
+            projection_etag: row.projection_etag,
+            projection_seen_at: row.projection_seen_at,
+            first_seen_at: row.first_seen_at,
+            last_seen_at: row.last_seen_at,
+        };
+    };
+}
+/**
+ * Upsert a sourced-entry row. Idempotent on `(entity_module, entity_id)`
+ * — repeated calls update `projection`, `projection_etag`,
+ * `projection_seen_at`, `last_seen_at`, `last_sourced_at`,
+ * `source_freshness`, and `updated_at`. The first-seen timestamp is
+ * preserved.
+ *
+ * Owned projections are rejected — `provenance.source_kind === "owned"`
+ * has no place in the sourced-entry store. Callers in `sync.ts` should
+ * already filter these out, but this guard makes the invariant explicit.
+ */
+export async function upsertSourcedEntry(db, input) {
+    const { projection, projectionEtag, lastSourcedAt, status } = input;
+    const provenance = projection.provenance;
+    if (provenance.source_kind === "owned") {
+        throw new Error(`upsertSourcedEntry called with owned provenance for ${projection.entity_module}/${projection.entity_id}; owned entities live in the vertical's owned schema, not catalog_sourced_entries`);
+    }
+    const now = new Date();
+    const stampedAt = lastSourcedAt ?? provenance.last_sourced_at ?? now;
+    const rows = await db
+        .insert(catalogSourcedEntriesTable)
+        .values({
+        entity_module: projection.entity_module,
+        entity_id: projection.entity_id,
+        source_kind: provenance.source_kind,
+        source_provider: provenance.source_provider ?? null,
+        source_connection_id: provenance.source_connection_id ?? null,
+        source_ref: provenance.source_ref ?? null,
+        source_freshness: (provenance.source_freshness ?? "static"),
+        last_sourced_at: stampedAt,
+        status: status ?? "active",
+        first_seen_at: now,
+        last_seen_at: now,
+        projection: projection.fields,
+        projection_etag: projectionEtag ?? null,
+        projection_seen_at: now,
+        created_at: now,
+        updated_at: now,
+    })
+        .onConflictDoUpdate({
+        target: [catalogSourcedEntriesTable.entity_module, catalogSourcedEntriesTable.entity_id],
+        set: {
+            source_kind: sql `excluded.source_kind`,
+            source_provider: sql `excluded.source_provider`,
+            source_connection_id: sql `excluded.source_connection_id`,
+            source_ref: sql `excluded.source_ref`,
+            source_freshness: sql `excluded.source_freshness`,
+            last_sourced_at: sql `excluded.last_sourced_at`,
+            status: sql `excluded.status`,
+            last_seen_at: sql `excluded.last_seen_at`,
+            projection: sql `excluded.projection`,
+            projection_etag: sql `excluded.projection_etag`,
+            projection_seen_at: sql `excluded.projection_seen_at`,
+            updated_at: sql `excluded.updated_at`,
+        },
+    })
+        .returning();
+    const row = rows[0];
+    if (!row) {
+        throw new Error(`upsertSourcedEntry returned no row for ${projection.entity_module}/${projection.entity_id}`);
+    }
+    return row;
+}
+/**
+ * Mark a sourced-entry row as withdrawn (the upstream stopped emitting
+ * it). Used by the periodic withdrawal sweeper or by drift events of kind
+ * `entity_archived`. Does not delete the row — withdrawals are auditable.
+ */
+export async function markSourcedEntryWithdrawn(db, entityModule, entityId) {
+    const now = new Date();
+    await db
+        .update(catalogSourcedEntriesTable)
+        .set({ status: "withdrawn", updated_at: now })
+        .where(and(eq(catalogSourcedEntriesTable.entity_module, entityModule), eq(catalogSourcedEntriesTable.entity_id, entityId)));
+}
+/**
+ * Mark active sourced rows missing from a successful full-source discovery pass
+ * as withdrawn. Callers should invoke this only after an adapter completed its
+ * projection stream; failed refreshes must leave existing rows untouched.
+ */
+export async function markMissingSourcedEntriesWithdrawn(db, input) {
+    const conditions = [
+        eq(catalogSourcedEntriesTable.entity_module, input.entityModule),
+        eq(catalogSourcedEntriesTable.source_kind, input.sourceKind),
+        eq(catalogSourcedEntriesTable.status, "active"),
+        input.sourceConnectionId == null
+            ? isNull(catalogSourcedEntriesTable.source_connection_id)
+            : eq(catalogSourcedEntriesTable.source_connection_id, input.sourceConnectionId),
+    ];
+    const seen = [...input.seenEntityIds];
+    if (seen.length > 0) {
+        conditions.push(notInArray(catalogSourcedEntriesTable.entity_id, seen));
+    }
+    const rows = await db
+        .select()
+        .from(catalogSourcedEntriesTable)
+        .where(and(...conditions));
+    if (rows.length === 0)
+        return [];
+    const now = new Date();
+    await db
+        .update(catalogSourcedEntriesTable)
+        .set({ status: "withdrawn", updated_at: now })
+        .where(inArray(catalogSourcedEntriesTable.id, rows.map((row) => row.id)));
+    return rows;
+}

package/dist/services/sourced-entry-service.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Pure-function tests for the sourced-entry service.
+ *
+ * Integration tests (real Postgres) live in
+ * `tests/integration/sourced-entry-service.test.ts`. These cover the
+ * `createReadProvenance` factory's branching against stub owned-checkers
+ * and a stub DB — no Postgres needed.
+ */
+export {};
+//# sourceMappingURL=sourced-entry-service.test.d.ts.map

package/dist/services/sourced-entry-service.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sourced-entry-service.test.d.ts","sourceRoot":"","sources":["../../src/services/sourced-entry-service.test.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/services/sourced-entry-service.test.js

@@ -0,0 +1,66 @@
+/**
+ * Pure-function tests for the sourced-entry service.
+ *
+ * Integration tests (real Postgres) live in
+ * `tests/integration/sourced-entry-service.test.ts`. These cover the
+ * `createReadProvenance` factory's branching against stub owned-checkers
+ * and a stub DB — no Postgres needed.
+ */
+import { describe, expect, it, vi } from "vitest";
+import { createReadProvenance } from "./sourced-entry-service.js";
+// Minimal stub mirroring the columns `readSourcedEntry` selects. We don't
+// exercise any drizzle methods here — we replace the `readSourcedEntry`
+// shape entirely via vi.mock for the dispatch tests.
+function fakeDb() {
+    return {};
+}
+describe("createReadProvenance — owned check fast path", () => {
+    it("returns kind: 'owned' when the owned-checker returns true", async () => {
+        const ownedChecker = vi.fn(async () => true);
+        const readProvenance = createReadProvenance({
+            ownedCheckers: new Map([["products", ownedChecker]]),
+        });
+        const result = await readProvenance(fakeDb(), "products", "prod_abc");
+        expect(result?.kind).toBe("owned");
+        if (result?.kind === "owned") {
+            expect(result.provenance.source_kind).toBe("owned");
+            expect(result.provenance.source_freshness).toBe("static");
+        }
+        expect(ownedChecker).toHaveBeenCalledWith(expect.anything(), "prod_abc");
+    });
+    it("skips the owned-checker for verticals not in the registry", async () => {
+        const productsOwnedChecker = vi.fn(async () => true);
+        const readProvenance = createReadProvenance({
+            ownedCheckers: new Map([["products", productsOwnedChecker]]),
+        });
+        // No checker registered for "cruises" — falls through to sourced-entry
+        // lookup directly. We can't hit a real DB here, so we expect this to
+        // attempt a query and fail cleanly. The point is the products checker
+        // is NOT called for a different vertical.
+        await expect(readProvenance(fakeDb(), "cruises", "crus_xyz")).rejects.toBeTruthy();
+        expect(productsOwnedChecker).not.toHaveBeenCalled();
+    });
+});
+describe("createReadProvenance — empty checker map", () => {
+    it("treats every vertical as sourced-only when no checkers are registered", async () => {
+        const readProvenance = createReadProvenance({});
+        // With no checkers, the function falls straight through to the
+        // sourced-entry table read — which fails against the stub DB. We
+        // verify only that it didn't throw before reaching the DB read.
+        await expect(readProvenance(fakeDb(), "products", "prod_abc")).rejects.toBeTruthy();
+    });
+});
+describe("CatalogProjection input shape", () => {
+    it("requires non-owned provenance for the upsert path", () => {
+        // Pure-shape assertion — the upsert function throws if you pass an
+        // owned projection. This is a structural property of the input
+        // contract; the DB is irrelevant.
+        const projection = {
+            entity_module: "products",
+            entity_id: "prod_abc",
+            provenance: { source_kind: "direct:tui", source_freshness: "sync" },
+            fields: { title: "Sample" },
+        };
+        expect(projection.provenance.source_kind).toBe("direct:tui");
+    });
+});

package/dist/snapshot/schema.d.ts

@@ -0,0 +1,362 @@
+/**
+ * Booking snapshot graph — immutable frozen views of CatalogEntries captured
+ * at booking commit time.
+ *
+ * One booking can produce multiple snapshot rows (one per participating
+ * CatalogEntry — a TUI package booking captures the package, the referenced
+ * hotel, each selected excursion, the chosen departure, the selected flight).
+ * Snapshots are never mutated and are preserved through source disconnection.
+ *
+ * See `docs/architecture/catalog-architecture.md` §5.3 for the full design.
+ */
+import type { PricingBasis } from "@voyant-travel/catalog-contracts/snapshot";
+import type { AppliedOffer } from "../booking-engine/promotions-contract.js";
+export type { PricingBasis };
+/**
+ * `booking_catalog_snapshot` — frozen view of a CatalogEntry captured at
+ * booking commit. One booking may produce many snapshot rows (one per
+ * participating CatalogEntry).
+ */
+export declare const bookingCatalogSnapshotTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "booking_catalog_snapshot";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "booking_catalog_snapshot";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        booking_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "booking_id";
+            tableName: "booking_catalog_snapshot";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entity_module: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_module";
+            tableName: "booking_catalog_snapshot";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entity_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_id";
+            tableName: "booking_catalog_snapshot";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        source_kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_kind";
+            tableName: "booking_catalog_snapshot";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        source_provider: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_provider";
+            tableName: "booking_catalog_snapshot";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        source_connection_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_connection_id";
+            tableName: "booking_catalog_snapshot";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        source_ref: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_ref";
+            tableName: "booking_catalog_snapshot";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        frozen_payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "frozen_payload";
+            tableName: "booking_catalog_snapshot";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        overlay_state_at_capture: import("drizzle-orm/pg-core").PgColumn<{
+            name: "overlay_state_at_capture";
+            tableName: "booking_catalog_snapshot";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        pricing_base_amount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pricing_base_amount";
+            tableName: "booking_catalog_snapshot";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        pricing_taxes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pricing_taxes";
+            tableName: "booking_catalog_snapshot";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        pricing_fees: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pricing_fees";
+            tableName: "booking_catalog_snapshot";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        pricing_surcharges: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pricing_surcharges";
+            tableName: "booking_catalog_snapshot";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        pricing_currency: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pricing_currency";
+            tableName: "booking_catalog_snapshot";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        pricing_breakdown: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pricing_breakdown";
+            tableName: "booking_catalog_snapshot";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        pricing_applied_offers: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pricing_applied_offers";
+            tableName: "booking_catalog_snapshot";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: AppliedOffer[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: AppliedOffer[];
+        }>;
+        idempotency_key: import("drizzle-orm/pg-core").PgColumn<{
+            name: "idempotency_key";
+            tableName: "booking_catalog_snapshot";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        captured_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "captured_at";
+            tableName: "booking_catalog_snapshot";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type InsertBookingCatalogSnapshot = typeof bookingCatalogSnapshotTable.$inferInsert;
+export type SelectBookingCatalogSnapshot = typeof bookingCatalogSnapshotTable.$inferSelect;
+/**
+ * Helper to compose a `PricingBasis` from the structured columns of a
+ * snapshot row. Returns `null` if the snapshot has no pricing columns set
+ * (volatile-live fields without `on-quote` / `on-book` snapshot mode).
+ */
+export declare function readPricingBasis(row: SelectBookingCatalogSnapshot): PricingBasis | null;
+//# sourceMappingURL=schema.d.ts.map

package/dist/snapshot/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/snapshot/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2CAA2C,CAAA;AAK7E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAA;AAI5E,YAAY,EAAE,YAAY,EAAE,CAAA;AAE5B;;;;GAIG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+EvC,CAAA;AAED,MAAM,MAAM,4BAA4B,GAAG,OAAO,2BAA2B,CAAC,YAAY,CAAA;AAC1F,MAAM,MAAM,4BAA4B,GAAG,OAAO,2BAA2B,CAAC,YAAY,CAAA;AAE1F;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,4BAA4B,GAAG,YAAY,GAAG,IAAI,CAavF"}