@voyant-travel/catalog 0.117.2

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

@@ -0,0 +1,377 @@
+import { describe, expect, it } from "vitest";
+import { createSourceAdapterRegistry } from "./registry.js";
+import { syncSources } from "./sync.js";
+function drizzleStub(methods) {
+    return methods;
+}
+/**
+ * Stub IndexerService that records every reindex call and synthesizes
+ * its own slices so the sync's pagination + dispatch are observable
+ * without spinning up Typesense.
+ */
+function makeStubIndexer(slicesByVertical) {
+    const upserted = [];
+    const deleted = [];
+    const service = {
+        async ensureCollections() { },
+        async reindexEntity(entityModule, entityId, builder) {
+            const slices = slicesByVertical[entityModule] ?? [];
+            for (const slice of slices) {
+                const doc = await builder(entityId, slice);
+                if (doc)
+                    upserted.push({ slice, doc });
+            }
+        },
+        async reindexEntityForSlice(slice, entityId, builder) {
+            const doc = await builder(entityId, slice);
+            if (doc)
+                upserted.push({ slice, doc });
+        },
+        async deleteEntity(entityModule, entityId) {
+            deleted.push({ entityModule, entityId });
+        },
+        async search(_slice, _request) {
+            return { total: 0, hits: [] };
+        },
+        slicesForVertical(entityModule) {
+            return slicesByVertical[entityModule] ?? [];
+        },
+    };
+    return { service, upserted, deleted };
+}
+/**
+ * Stub field-policy registry that pretends every projection field is
+ * indexed and visible to staff. The sync's job is to call
+ * `buildIndexerDocument` with the right registry, slice, and entity id —
+ * the registry's actual policy logic is covered by other tests.
+ */
+function makePassthroughRegistry() {
+    const policy = (path) => ({
+        path,
+        class: "managed",
+        merge: "source-only",
+        drift: "low",
+        reindex: "entry",
+        snapshot: "never",
+        query: "indexed-column",
+        localized: false,
+        visibility: ["staff", "customer", "partner", "supplier"],
+        editRole: "none",
+        overrideFriction: "none",
+        sourceFreshness: "static",
+    });
+    return {
+        policies: [],
+        byPath: new Map(),
+        resolve(path) {
+            return policy(path);
+        },
+    };
+}
+function makeAdapter(kind, pages) {
+    let pageIdx = 0;
+    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 () => {
+            const page = pages[pageIdx] ?? { projections: [], next: undefined };
+            pageIdx += 1;
+            return {
+                projections: page.projections.map((id) => ({
+                    entity_module: "products",
+                    entity_id: id,
+                    provenance: { source_kind: kind, source_freshness: "sync" },
+                    fields: { id, name: `Inventory ${id}`, status: "active" },
+                })),
+                next_cursor: page.next,
+            };
+        },
+    };
+}
+describe("syncSources", () => {
+    it("paginates discovery and pushes each projection into every slice for the vertical", async () => {
+        const registry = createSourceAdapterRegistry();
+        registry.register(makeAdapter("demo", [
+            { projections: ["a", "b"], next: "page-2" },
+            { projections: ["c"], next: undefined },
+        ]));
+        const slices = [
+            { vertical: "products", locale: "en-GB", audience: "staff", market: "default" },
+            { vertical: "products", locale: "en-GB", audience: "customer", market: "default" },
+        ];
+        const { service, upserted } = makeStubIndexer({ products: slices });
+        const fieldPolicyRegistries = new Map([["products", makePassthroughRegistry()]]);
+        const summary = await syncSources({
+            registry,
+            indexerService: service,
+            fieldPolicyRegistries,
+        });
+        expect(summary.totalProjections).toBe(3);
+        expect(summary.adapters[0]?.pages).toBe(2);
+        expect(summary.adapters[0]?.projectionsSynced).toBe(3);
+        expect(summary.adapters[0]?.verticalsTouched).toEqual(["products"]);
+        // 3 projections × 2 slices = 6 upserts
+        expect(upserted).toHaveLength(6);
+        expect(upserted.map((u) => u.doc.id).sort()).toEqual(["a", "a", "b", "b", "c", "c"]);
+    });
+    it("skips projections whose vertical has no field-policy registry", async () => {
+        const registry = createSourceAdapterRegistry();
+        registry.register(makeAdapter("demo", [{ projections: ["x"], next: undefined }]));
+        const slices = [
+            { vertical: "products", locale: "en-GB", audience: "staff", market: "default" },
+        ];
+        const { service, upserted } = makeStubIndexer({ products: slices });
+        // Empty registry map → projection should be skipped, not crash.
+        const summary = await syncSources({
+            registry,
+            indexerService: service,
+            fieldPolicyRegistries: new Map(),
+        });
+        expect(summary.totalProjections).toBe(0);
+        expect(summary.adapters[0]?.projectionsSynced).toBe(0);
+        expect(summary.adapters[0]?.skippedNoRegistry).toBe(1);
+        expect(upserted).toHaveLength(0);
+    });
+    it("emits onProgress per page", async () => {
+        const registry = createSourceAdapterRegistry();
+        registry.register(makeAdapter("demo", [
+            { projections: ["a", "b"], next: "p2" },
+            { projections: ["c"], next: undefined },
+        ]));
+        const { service } = makeStubIndexer({
+            products: [{ vertical: "products", locale: "en-GB", audience: "staff", market: "default" }],
+        });
+        const fieldPolicyRegistries = new Map([["products", makePassthroughRegistry()]]);
+        const events = [];
+        await syncSources({
+            registry,
+            indexerService: service,
+            fieldPolicyRegistries,
+            onProgress(event) {
+                events.push(event.pageSize);
+            },
+        });
+        expect(events).toEqual([2, 1]);
+    });
+    it("counts owned vs sourced projections without a DB handle", async () => {
+        // Adapter that emits one sourced + one owned projection. Without a
+        // DB handle in scope, sync skips the sourced-entry upsert entirely;
+        // it still counts owned vs sourced for diagnostics.
+        const registry = createSourceAdapterRegistry();
+        registry.register({
+            kind: "mixed",
+            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: [
+                    {
+                        entity_module: "products",
+                        entity_id: "owned_a",
+                        provenance: { source_kind: "owned", source_freshness: "static" },
+                        fields: { id: "owned_a", name: "Owned A", status: "active" },
+                    },
+                    {
+                        entity_module: "products",
+                        entity_id: "src_b",
+                        provenance: { source_kind: "direct:tui", source_freshness: "sync" },
+                        fields: { id: "src_b", name: "Sourced B", status: "active" },
+                    },
+                ],
+                next_cursor: undefined,
+            }),
+        });
+        const { service } = makeStubIndexer({
+            products: [{ vertical: "products", locale: "en-GB", audience: "staff", market: "default" }],
+        });
+        const fieldPolicyRegistries = new Map([["products", makePassthroughRegistry()]]);
+        const summary = await syncSources({
+            registry,
+            indexerService: service,
+            fieldPolicyRegistries,
+            // No db handle → sourced-entry upsert path is gated off.
+        });
+        expect(summary.adapters[0]?.projectionsSynced).toBe(2);
+        expect(summary.adapters[0]?.ownedProjections).toBe(1);
+        expect(summary.adapters[0]?.sourcedEntriesUpserted).toBe(0);
+    });
+    it("upserts sourced-entry rows when a DB handle is in scope (stub)", async () => {
+        // Stub the upsert path by passing a fake `db` and asserting the
+        // counter advances. The integration test covers the actual SQL.
+        const registry = createSourceAdapterRegistry();
+        registry.register(makeAdapter("demo", [{ projections: ["a", "b"], next: undefined }]));
+        const { service } = makeStubIndexer({
+            products: [{ vertical: "products", locale: "en-GB", audience: "staff", market: "default" }],
+        });
+        const fieldPolicyRegistries = new Map([["products", makePassthroughRegistry()]]);
+        // Stub db whose .insert(...).values(...).onConflictDoUpdate(...).returning()
+        // returns one row. Mirrors enough of the drizzle chain to exercise sync.
+        const upsertCalls = [];
+        const stubDb = drizzleStub({
+            insert() {
+                return {
+                    values(v) {
+                        upsertCalls.push(v);
+                        return {
+                            onConflictDoUpdate() {
+                                return {
+                                    async returning() {
+                                        return [{ id: "cse_x", entity_module: "products", entity_id: "a" }];
+                                    },
+                                };
+                            },
+                        };
+                    },
+                };
+            },
+        });
+        const summary = await syncSources({
+            registry,
+            indexerService: service,
+            fieldPolicyRegistries,
+            db: stubDb,
+        });
+        expect(summary.adapters[0]?.sourcedEntriesUpserted).toBe(2);
+        expect(upsertCalls).toHaveLength(2);
+    });
+    it("applies wrapBuilder to every per-projection builder", async () => {
+        const registry = createSourceAdapterRegistry();
+        registry.register(makeAdapter("demo", [{ projections: ["a"], next: undefined }]));
+        const { service, upserted } = makeStubIndexer({
+            products: [{ vertical: "products", locale: "en-GB", audience: "staff", market: "default" }],
+        });
+        const fieldPolicyRegistries = new Map([["products", makePassthroughRegistry()]]);
+        let wrapped = 0;
+        await syncSources({
+            registry,
+            indexerService: service,
+            fieldPolicyRegistries,
+            wrapBuilder(inner) {
+                wrapped += 1;
+                return async (entityId, slice) => {
+                    const doc = await inner(entityId, slice);
+                    if (!doc)
+                        return null;
+                    return {
+                        ...doc,
+                        fields: { ...doc.fields, wrapped: true },
+                    };
+                };
+            },
+        });
+        expect(wrapped).toBe(1);
+        expect(upserted[0]?.doc.fields.wrapped).toBe(true);
+    });
+    it("marks missing sourced rows withdrawn and deletes them from index slices after a successful pruned sync", async () => {
+        const registry = createSourceAdapterRegistry();
+        registry.register("conn-a", {
+            kind: "demo",
+            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: [
+                    {
+                        entity_module: "products",
+                        entity_id: "active_a",
+                        provenance: {
+                            source_kind: "demo",
+                            source_connection_id: "conn-a",
+                            source_ref: "src-a",
+                            source_freshness: "sync",
+                        },
+                        fields: { id: "active_a", name: "Active A", status: "active" },
+                    },
+                ],
+                next_cursor: undefined,
+            }),
+        });
+        const { service, deleted } = makeStubIndexer({
+            products: [{ vertical: "products", locale: "en-GB", audience: "staff", market: "default" }],
+        });
+        const fieldPolicyRegistries = new Map([["products", makePassthroughRegistry()]]);
+        const updatedIds = [];
+        const stubDb = drizzleStub({
+            insert() {
+                return {
+                    values() {
+                        return {
+                            onConflictDoUpdate() {
+                                return {
+                                    async returning() {
+                                        return [{ id: "cse_active", entity_module: "products", entity_id: "active_a" }];
+                                    },
+                                };
+                            },
+                        };
+                    },
+                };
+            },
+            select() {
+                return {
+                    from() {
+                        return {
+                            async where() {
+                                return [
+                                    {
+                                        id: "cse_stale",
+                                        entity_module: "products",
+                                        entity_id: "stale_b",
+                                    },
+                                ];
+                            },
+                        };
+                    },
+                };
+            },
+            update() {
+                return {
+                    set() {
+                        return {
+                            async where(condition) {
+                                updatedIds.push([String(condition)]);
+                            },
+                        };
+                    },
+                };
+            },
+        });
+        const summary = await syncSources({
+            registry,
+            indexerService: service,
+            fieldPolicyRegistries,
+            db: stubDb,
+            pruneMissing: true,
+            verticals: ["products"],
+        });
+        expect(summary.adapters[0]?.withdrawnProjections).toBe(1);
+        expect(deleted).toEqual([{ entityModule: "products", entityId: "stale_b" }]);
+        expect(updatedIds).toHaveLength(1);
+    });
+});

package/dist/contract.d.ts

@@ -0,0 +1,2 @@
+export * from "@voyant-travel/catalog-contracts/contract";
+//# sourceMappingURL=contract.d.ts.map

package/dist/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,2CAA2C,CAAA"}

package/dist/contract.js

@@ -0,0 +1 @@
+export * from "@voyant-travel/catalog-contracts/contract";

package/dist/contract.test.d.ts

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

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

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

package/dist/contract.test.js

@@ -0,0 +1,107 @@
+import { describe, expect, it } from "vitest";
+import { ancestorPaths, createFieldPolicyRegistry, defineFieldPolicy, FieldPolicyError, } from "./contract.js";
+const baseLeaf = {
+    class: "merchandisable",
+    merge: "replace",
+    editRole: "marketing",
+    overrideFriction: "none",
+    snapshot: "on-book",
+};
+describe("ancestorPaths", () => {
+    it("returns empty for a single-segment path", () => {
+        expect(ancestorPaths("title")).toEqual([]);
+    });
+    it("returns nearest-first for nested paths", () => {
+        expect(ancestorPaths("geography.countries[].name")).toEqual([
+            "geography.countries[]",
+            "geography",
+        ]);
+    });
+    it("treats list[] as one segment", () => {
+        expect(ancestorPaths("gallery[].caption")).toEqual(["gallery[]"]);
+    });
+});
+describe("defineFieldPolicy — required axes", () => {
+    it("throws if a non-inheriting axis is missing", () => {
+        expect(() => defineFieldPolicy([
+            // biome-ignore lint/suspicious/noExplicitAny: deliberately invalid for the test -- owner: catalog; existing suppression is intentional pending typed cleanup.
+            { path: "title", class: "merchandisable" },
+        ])).toThrow(FieldPolicyError);
+    });
+    it("throws on duplicate paths", () => {
+        expect(() => defineFieldPolicy([
+            { path: "title", ...baseLeaf },
+            { path: "title", ...baseLeaf },
+        ])).toThrow(/duplicate/);
+    });
+    it("throws on malformed path syntax", () => {
+        expect(() => defineFieldPolicy([{ path: "with spaces", ...baseLeaf }])).toThrow(/invalid path segment/);
+    });
+});
+describe("defineFieldPolicy — inheritance", () => {
+    it("inherits drift / reindex / query / localized / visibility / sourceFreshness from ancestor", () => {
+        const policies = defineFieldPolicy([
+            {
+                path: "geography.countries[]",
+                ...baseLeaf,
+                class: "structural",
+                merge: "source-only",
+                editRole: "ops",
+                drift: "high",
+                reindex: "facet-affecting",
+                query: "indexed-column",
+                localized: false,
+                visibility: ["staff", "customer", "partner"],
+                sourceFreshness: "sync",
+            },
+            {
+                // Leaf declares only the non-inheriting axes; everything else inherits.
+                path: "geography.countries[].name",
+                ...baseLeaf,
+                class: "merchandisable",
+                merge: "replace",
+                editRole: "marketing",
+            },
+        ]);
+        const leaf = policies[1];
+        expect(leaf?.drift).toBe("high");
+        expect(leaf?.reindex).toBe("facet-affecting");
+        expect(leaf?.query).toBe("indexed-column");
+        expect(leaf?.visibility).toEqual(["staff", "customer", "partner"]);
+        expect(leaf?.sourceFreshness).toBe("sync");
+    });
+    it("applies registry defaults when no ancestor declares the inheriting axis", () => {
+        const policies = defineFieldPolicy([{ path: "title", ...baseLeaf }]);
+        const title = policies[0];
+        expect(title?.drift).toBe("none");
+        expect(title?.reindex).toBe("none");
+        expect(title?.query).toBe("blob-only");
+        expect(title?.localized).toBe(false);
+        expect(title?.visibility).toEqual(["staff"]);
+        expect(title?.sourceFreshness).toBeNull();
+    });
+});
+describe("createFieldPolicyRegistry", () => {
+    it("resolves exact matches first", () => {
+        const policies = defineFieldPolicy([
+            { path: "title", ...baseLeaf },
+            { path: "gallery[]", ...baseLeaf },
+            { path: "gallery[].caption", ...baseLeaf, editRole: "marketing" },
+        ]);
+        const registry = createFieldPolicyRegistry(policies);
+        expect(registry.resolve("gallery[].caption")?.path).toBe("gallery[].caption");
+        expect(registry.resolve("gallery[]")?.path).toBe("gallery[]");
+        expect(registry.resolve("title")?.path).toBe("title");
+    });
+    it("falls back to nearest ancestor when exact match is missing", () => {
+        const policies = defineFieldPolicy([{ path: "geography", ...baseLeaf, class: "structural" }]);
+        const registry = createFieldPolicyRegistry(policies);
+        // No exact policy for `geography.country` — falls back to `geography`.
+        expect(registry.resolve("geography.country")?.path).toBe("geography");
+    });
+    it("returns undefined when no ancestor matches", () => {
+        const policies = defineFieldPolicy([{ path: "title", ...baseLeaf }]);
+        const registry = createFieldPolicyRegistry(policies);
+        expect(registry.resolve("description")).toBeUndefined();
+    });
+});

package/dist/drift/events.d.ts

@@ -0,0 +1,2 @@
+export * from "@voyant-travel/catalog-contracts/drift/events";
+//# sourceMappingURL=events.d.ts.map

package/dist/drift/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/drift/events.ts"],"names":[],"mappings":"AAAA,cAAc,+CAA+C,CAAA"}

package/dist/drift/events.js

@@ -0,0 +1 @@
+export * from "@voyant-travel/catalog-contracts/drift/events";

package/dist/drift/events.test.d.ts

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

package/dist/drift/events.test.d.ts.map

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

package/dist/drift/events.test.js

@@ -0,0 +1,100 @@
+import { describe, expect, it } from "vitest";
+import { blocksBookings, maxDriftSeverity, } from "./events.js";
+describe("maxDriftSeverity", () => {
+    it("returns 'none' for an empty drift list", () => {
+        expect(maxDriftSeverity([])).toBe("none");
+    });
+    it("returns the highest severity present", () => {
+        const drifts = [
+            { field_path: "a", severity: "low", had_overlay: false },
+            { field_path: "b", severity: "high", had_overlay: false },
+            { field_path: "c", severity: "medium", had_overlay: false },
+        ];
+        expect(maxDriftSeverity(drifts)).toBe("high");
+    });
+    it("treats critical as the top of the order", () => {
+        const drifts = [
+            { field_path: "a", severity: "critical", had_overlay: true },
+            { field_path: "b", severity: "high", had_overlay: false },
+        ];
+        expect(maxDriftSeverity(drifts)).toBe("critical");
+    });
+});
+describe("blocksBookings", () => {
+    it("returns true only for critical severity", () => {
+        expect(blocksBookings("critical")).toBe(true);
+        expect(blocksBookings("high")).toBe(false);
+        expect(blocksBookings("medium")).toBe(false);
+        expect(blocksBookings("low")).toBe(false);
+        expect(blocksBookings("none")).toBe(false);
+    });
+});
+describe("CatalogDriftEvent", () => {
+    it("carries field-level drifts plus computed severity + booking-block flag", () => {
+        const event = {
+            drift_event_id: "cdrf_01HXX",
+            entity_module: "products",
+            entity_id: "prod_abc",
+            source_connection_id: "conn_tui",
+            source_kind: "direct:tui",
+            drifts: [{ field_path: "title", severity: "low", had_overlay: false }],
+            detected_at: new Date(),
+            max_severity: "low",
+            blocks_bookings: false,
+        };
+        expect(event.drifts).toHaveLength(1);
+        expect(event.blocks_bookings).toBe(false);
+    });
+});
+describe("ContentDriftEvent — sibling to CatalogDriftEvent", () => {
+    it("matches a single (entity_module, entity_id) when locale + market are unset", () => {
+        const event = {
+            id: "cnde_01HXX",
+            entity_module: "products",
+            entity_id: "prod_abc",
+            kind: "content_changed",
+            detected_at: new Date(),
+        };
+        expect(event.locale).toBeUndefined();
+        expect(event.market).toBeUndefined();
+        expect(event.kind).toBe("content_changed");
+    });
+    it("scopes invalidation to one locale + market when set", () => {
+        const event = {
+            id: "cnde_01HXY",
+            entity_module: "cruises",
+            entity_id: "crus_xyz",
+            locale: "de-DE",
+            market: "DE",
+            kind: "content_changed",
+            previous_etag: 'W/"abc"',
+            current_etag: 'W/"def"',
+            detected_at: new Date(),
+        };
+        expect(event.locale).toBe("de-DE");
+        expect(event.market).toBe("DE");
+        expect(event.previous_etag).toBe('W/"abc"');
+        expect(event.current_etag).toBe('W/"def"');
+    });
+    it("models the locale-added kind for newly-served languages", () => {
+        const event = {
+            id: "cnde_01HXZ",
+            entity_module: "products",
+            entity_id: "prod_abc",
+            locale: "ro-RO",
+            kind: "content_locale_added",
+            detected_at: new Date(),
+        };
+        expect(event.kind).toBe("content_locale_added");
+    });
+    it("models explicit invalidation for ops escalations", () => {
+        const event = {
+            id: "cnde_01HY0",
+            entity_module: "products",
+            entity_id: "prod_abc",
+            kind: "content_invalidated",
+            detected_at: new Date(),
+        };
+        expect(event.kind).toBe("content_invalidated");
+    });
+});