@voyant-travel/catalog 0.117.2

package/dist/services/content-service.test.js

@@ -0,0 +1,322 @@
+import { describe, expect, it, vi } from "vitest";
+import { applyJsonPointerOverlay, buildDriftInvalidationPredicate, createInvalidateOnDrift, isStale, JsonPointerError, mergeOverlaysIntoContent, parseJsonPointer, pickBestCachedLocale, } from "./content-service.js";
+// ─────────────────────────────────────────────────────────────────────────────
+// isStale
+// ─────────────────────────────────────────────────────────────────────────────
+describe("isStale", () => {
+    it("returns false when fresh_until is null/undefined", () => {
+        expect(isStale({ fresh_until: null })).toBe(false);
+        expect(isStale({ fresh_until: undefined })).toBe(false);
+    });
+    it("returns true when fresh_until is in the past", () => {
+        const past = new Date(Date.now() - 60_000);
+        expect(isStale({ fresh_until: past })).toBe(true);
+    });
+    it("returns false when fresh_until is in the future", () => {
+        const future = new Date(Date.now() + 60_000);
+        expect(isStale({ fresh_until: future })).toBe(false);
+    });
+    it("treats fresh_until == now as stale (boundary)", () => {
+        const now = new Date();
+        expect(isStale({ fresh_until: now }, now)).toBe(true);
+    });
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// pickBestCachedLocale
+// ─────────────────────────────────────────────────────────────────────────────
+describe("pickBestCachedLocale", () => {
+    it("returns null when there are no candidates", () => {
+        expect(pickBestCachedLocale([], ["en-GB"])).toBeNull();
+    });
+    it("returns an exact match when present", () => {
+        const result = pickBestCachedLocale([
+            { locale: "en-GB", payload: 1 },
+            { locale: "ro-RO", payload: 2 },
+        ], ["ro-RO", "en-GB"]);
+        expect(result?.served_locale).toBe("ro-RO");
+        expect(result?.match_kind).toBe("exact");
+        expect(result?.candidate.payload).toBe(2);
+    });
+    it("falls back to language match when region differs", () => {
+        const result = pickBestCachedLocale([{ locale: "fr-FR", payload: 1 }], ["fr-CA"]);
+        expect(result?.served_locale).toBe("fr-FR");
+        expect(result?.match_kind).toBe("language_match");
+    });
+    it("prefers exact match later in chain over earlier language match", () => {
+        // Asked for fr-CA first (lang match available as fr-FR), then en-GB
+        // (exact match available). The earlier preference still wins because
+        // its language-match rank (0) beats the later exact rank (1).
+        const result = pickBestCachedLocale([
+            { locale: "fr-FR", payload: 1 },
+            { locale: "en-GB", payload: 2 },
+        ], ["fr-CA", "en-GB"]);
+        expect(result?.served_locale).toBe("fr-FR");
+        expect(result?.match_kind).toBe("language_match");
+    });
+    it("when nothing matches the chain, falls back to fallback_chain mark", () => {
+        const result = pickBestCachedLocale([{ locale: "de-DE", payload: 1 }], ["ro-RO", "en-GB"]);
+        expect(result?.match_kind).toBe("fallback_chain");
+        expect(result?.served_locale).toBe("de-DE");
+    });
+    it("returns 'any' when the preference chain is empty", () => {
+        const result = pickBestCachedLocale([{ locale: "ro-RO", payload: 1 }], []);
+        expect(result?.match_kind).toBe("any");
+        expect(result?.served_locale).toBe("ro-RO");
+    });
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// JSON pointer
+// ─────────────────────────────────────────────────────────────────────────────
+describe("parseJsonPointer", () => {
+    it("parses '' as the root pointer", () => {
+        expect(parseJsonPointer("")).toEqual([]);
+    });
+    it("parses '/foo' as a single segment", () => {
+        expect(parseJsonPointer("/foo")).toEqual(["foo"]);
+    });
+    it("parses nested pointers", () => {
+        expect(parseJsonPointer("/days/3/description")).toEqual(["days", "3", "description"]);
+    });
+    it("unescapes ~1 to / and ~0 to ~ (in that order)", () => {
+        expect(parseJsonPointer("/foo~1bar")).toEqual(["foo/bar"]);
+        expect(parseJsonPointer("/foo~0bar")).toEqual(["foo~bar"]);
+        // Edge: per RFC 6901, ~01 should unescape to ~1 (not /).
+        expect(parseJsonPointer("/foo~01")).toEqual(["foo~1"]);
+    });
+    it("throws on a non-empty pointer that doesn't start with '/'", () => {
+        expect(() => parseJsonPointer("foo")).toThrow(JsonPointerError);
+    });
+});
+describe("applyJsonPointerOverlay", () => {
+    it("sets a top-level field on an object", () => {
+        const target = { name: "Original" };
+        const result = applyJsonPointerOverlay(target, "/name", "Updated");
+        expect(result.name).toBe("Updated");
+    });
+    it("descends into nested objects", () => {
+        const target = { hero: { caption: "old" } };
+        applyJsonPointerOverlay(target, "/hero/caption", "new");
+        expect(target.hero.caption).toBe("new");
+    });
+    it("descends into arrays via numeric segments", () => {
+        const target = { days: [{ description: "Day 1" }, { description: "Day 2" }] };
+        applyJsonPointerOverlay(target, "/days/1/description", "Day 2 (overridden)");
+        expect(target.days[1]?.description).toBe("Day 2 (overridden)");
+    });
+    it("replaces array elements at the leaf", () => {
+        const target = { tags: ["a", "b", "c"] };
+        applyJsonPointerOverlay(target, "/tags/0", "z");
+        expect(target.tags[0]).toBe("z");
+    });
+    it("throws on missing intermediate keys", () => {
+        const target = { hero: {} };
+        expect(() => applyJsonPointerOverlay(target, "/hero/caption/foo", "x")).toThrow(JsonPointerError);
+    });
+    it("throws on out-of-range array indices", () => {
+        const target = { tags: ["a"] };
+        expect(() => applyJsonPointerOverlay(target, "/tags/5", "z")).toThrow(JsonPointerError);
+    });
+    it("rejects RFC 6901 '-' append-segment (we don't support extending)", () => {
+        const target = { tags: ["a"] };
+        expect(() => applyJsonPointerOverlay(target, "/tags/-", "b")).toThrow(JsonPointerError);
+    });
+    it("returns the value when pointer is empty (whole-document replace)", () => {
+        const result = applyJsonPointerOverlay({ foo: 1 }, "", { bar: 2 });
+        expect(result).toEqual({ bar: 2 });
+    });
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// Overlay merge
+// ─────────────────────────────────────────────────────────────────────────────
+describe("mergeOverlaysIntoContent", () => {
+    it("returns a deep-cloned payload — does not mutate the input", () => {
+        const payload = { name: "Original", days: [{ description: "Day 1" }] };
+        const overlays = [{ field_path: "/name", value: "Override" }];
+        const merged = mergeOverlaysIntoContent(payload, overlays);
+        expect(merged.name).toBe("Override");
+        expect(payload.name).toBe("Original"); // original untouched
+    });
+    it("applies multiple overlays in order", () => {
+        const payload = { a: 1, b: 2 };
+        const overlays = [
+            { field_path: "/a", value: 100 },
+            { field_path: "/b", value: 200 },
+        ];
+        const merged = mergeOverlaysIntoContent(payload, overlays);
+        expect(merged.a).toBe(100);
+        expect(merged.b).toBe(200);
+    });
+    it("skips overlays that fail to apply, calling onOverlayError once each", () => {
+        const payload = { name: "Original" };
+        const overlays = [
+            { field_path: "/name", value: "Override" },
+            { field_path: "/missing/deep", value: "X" }, // fails: no /missing
+            { field_path: "/name", value: "Final" },
+        ];
+        const errors = [];
+        const merged = mergeOverlaysIntoContent(payload, overlays, {
+            onOverlayError: (e) => errors.push(e),
+        });
+        expect(merged.name).toBe("Final");
+        expect(errors).toHaveLength(1);
+        expect(errors[0]?.overlay.field_path).toBe("/missing/deep");
+    });
+    it("rolls back overlays whose result fails the validator", () => {
+        const payload = { count: 1 };
+        const overlays = [{ field_path: "/count", value: "not-a-number" }];
+        const errors = [];
+        const merged = mergeOverlaysIntoContent(payload, overlays, {
+            validate(p) {
+                const ok = typeof p.count === "number";
+                return { valid: ok, reason: ok ? undefined : "count must be number" };
+            },
+            onOverlayError: (e) => errors.push(e),
+        });
+        expect(merged.count).toBe(1); // rolled back
+        expect(errors).toHaveLength(1);
+        expect(errors[0]?.reason).toContain("count must be number");
+    });
+    it("validator that always passes lets every overlay through", () => {
+        const payload = { a: 1 };
+        const overlays = [{ field_path: "/a", value: 2 }];
+        const merged = mergeOverlaysIntoContent(payload, overlays, {
+            validate: () => ({ valid: true }),
+        });
+        expect(merged.a).toBe(2);
+    });
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// Drift invalidation predicate
+// ─────────────────────────────────────────────────────────────────────────────
+describe("buildDriftInvalidationPredicate", () => {
+    it("matches one entity across all locales / markets when neither is set", () => {
+        const event = {
+            id: "cnde_1",
+            entity_module: "products",
+            entity_id: "prod_abc",
+            kind: "content_changed",
+            detected_at: new Date(),
+        };
+        const pred = buildDriftInvalidationPredicate(event);
+        expect(pred.entity_module).toBe("products");
+        expect(pred.entity_id).toBe("prod_abc");
+        expect(pred.locale).toBeNull();
+        expect(pred.market).toBeNull();
+    });
+    it("narrows to one locale + market when set", () => {
+        const event = {
+            id: "cnde_2",
+            entity_module: "products",
+            entity_id: "prod_abc",
+            locale: "ro-RO",
+            market: "RO",
+            kind: "content_changed",
+            detected_at: new Date(),
+        };
+        const pred = buildDriftInvalidationPredicate(event);
+        expect(pred.locale).toBe("ro-RO");
+        expect(pred.market).toBe("RO");
+    });
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// Locale chain — language tag matching is case-insensitive
+// ─────────────────────────────────────────────────────────────────────────────
+describe("pickBestCachedLocale — case insensitivity", () => {
+    it("compares language tags case-insensitively", () => {
+        const result = pickBestCachedLocale([{ locale: "FR-fr", payload: 1 }], ["fr-CA"]);
+        expect(result?.match_kind).toBe("language_match");
+    });
+});
+// vi unused but imported for parity with other test files; reference it
+// to avoid lint complaints under noUnusedLocals.
+void vi;
+// ─────────────────────────────────────────────────────────────────────────────
+// createInvalidateOnDrift — runner factory
+// ─────────────────────────────────────────────────────────────────────────────
+describe("createInvalidateOnDrift", () => {
+    function makeStubDb() {
+        const calls = [];
+        const fakeColumn = { name: "stub" };
+        const fakeTable = {
+            entity_id: fakeColumn,
+            locale: fakeColumn,
+            market: fakeColumn,
+            fresh_until: fakeColumn,
+        };
+        let rowsToReturn = 1;
+        const db = {
+            update(t) {
+                calls.push({ phase: "update", arg: t });
+                return {
+                    set(values) {
+                        calls.push({ phase: "set", arg: values });
+                        return {
+                            where(cond) {
+                                calls.push({ phase: "where", arg: cond });
+                                return {
+                                    async returning(_cols) {
+                                        calls.push({ phase: "returning", arg: _cols });
+                                        return Array.from({ length: rowsToReturn }, (_, i) => ({
+                                            entity_id: `row_${i}`,
+                                        }));
+                                    },
+                                };
+                            },
+                        };
+                    },
+                };
+            },
+            __setRows(n) {
+                rowsToReturn = n;
+            },
+        };
+        return { db: db, calls, table: fakeTable, setRows: (n) => db.__setRows(n) };
+    }
+    function makeEvent(overrides = {}) {
+        return {
+            id: "cnde_x",
+            entity_module: "products",
+            entity_id: "prod_abc",
+            kind: "content_changed",
+            detected_at: new Date(),
+            ...overrides,
+        };
+    }
+    it("returns invalidated: 0 and skips the UPDATE for events targeting other modules", async () => {
+        const { db, calls, table } = makeStubDb();
+        const invalidate = createInvalidateOnDrift(table, { entityModule: "products" });
+        const result = await invalidate(db, makeEvent({ entity_module: "cruises" }));
+        expect(result.invalidated).toBe(0);
+        expect(calls).toHaveLength(0);
+    });
+    it("dispatches the UPDATE when the event matches the registered entity_module", async () => {
+        const { db, calls, table, setRows } = makeStubDb();
+        setRows(3);
+        const invalidate = createInvalidateOnDrift(table, { entityModule: "products" });
+        const result = await invalidate(db, makeEvent());
+        expect(result.invalidated).toBe(3);
+        // Drizzle chain: update → set → where → returning
+        expect(calls.map((c) => c.phase)).toEqual(["update", "set", "where", "returning"]);
+    });
+    it("returns invalidated: 0 when no rows match (returning() returns empty)", async () => {
+        const { db, table, setRows } = makeStubDb();
+        setRows(0);
+        const invalidate = createInvalidateOnDrift(table, { entityModule: "products" });
+        const result = await invalidate(db, makeEvent());
+        expect(result.invalidated).toBe(0);
+    });
+    it("scopes to one locale + market when the event sets them", async () => {
+        const { db, table } = makeStubDb();
+        const invalidate = createInvalidateOnDrift(table, { entityModule: "products" });
+        // Just ensures no throw — the actual SQL is opaque but the
+        // function consumed all event fields. Coverage is at the
+        // integration test level.
+        await invalidate(db, makeEvent({ locale: "ro-RO", market: "RO" }));
+    });
+    it("matches all locales / markets when event fields are unset (full-entity invalidation)", async () => {
+        const { db, table } = makeStubDb();
+        const invalidate = createInvalidateOnDrift(table, { entityModule: "products" });
+        // No throw — the WHERE clause omits the locale/market predicates.
+        await invalidate(db, makeEvent({ locale: undefined, market: undefined }));
+    });
+});

package/dist/services/indexer-service.d.ts

@@ -0,0 +1,109 @@
+/**
+ * IndexerService — higher-level wrapper around an `IndexerAdapter` that
+ * handles the cross-slice orchestration verticals actually need:
+ *
+ *   - Targeted reindex of one entity across all configured slices.
+ *   - Targeted reindex narrowed to a single `(locale, audience, market)`
+ *     when an editorial overlay change has narrow scope.
+ *   - Deletion across all slices for the same entity.
+ *   - `ensureCollections` at deployment startup.
+ *   - Search delegation to the underlying adapter.
+ *
+ * Templates configure the service with their actual slice set (which
+ * `(locale, audience, market)` combinations the deployment serves) and the
+ * IndexerAdapter implementation (Typesense by default).
+ *
+ * See `docs/architecture/catalog-architecture.md` §5.4 for the design.
+ */
+import type { FieldPolicyRegistry } from "../contract.js";
+import type { IndexerAdapter, IndexerDocument, IndexerSlice, SearchRequest, SearchResults } from "../indexer/contract.js";
+/**
+ * Options for constructing an IndexerService.
+ */
+export interface IndexerServiceOptions {
+    /** The underlying IndexerAdapter implementation. */
+    adapter: IndexerAdapter;
+    /**
+     * The `(vertical, locale, audience, market)` slices this deployment
+     * materializes. Default deployments have ~2 slices per vertical per
+     * locale; scale-stage deployments have more.
+     */
+    slices: IndexerSlice[];
+    /**
+     * Per-vertical field-policy registries, keyed by `entity_module`.
+     * `ensureCollections` and document-emission paths consult the relevant
+     * registry to know what to index and how.
+     */
+    registries: ReadonlyMap<string, FieldPolicyRegistry>;
+}
+/**
+ * Builder function the service calls per slice when reindexing — produces
+ * the `IndexerDocument` for a particular entity in a particular slice.
+ *
+ * Verticals supply this via their `DocumentEmitter` (see
+ * `../indexer/contract.ts`); the service is engine-agnostic.
+ */
+export type DocumentBuilder = (entityId: string, slice: IndexerSlice) => Promise<IndexerDocument | null>;
+/**
+ * The IndexerService surface.
+ */
+export interface IndexerService {
+    /**
+     * Ensure every configured slice has its engine-side schema set up.
+     * Called at deployment startup or after a field-policy registry change.
+     */
+    ensureCollections(): Promise<void>;
+    /**
+     * Reindex one entity across **all** slices configured for its vertical.
+     * Used when a source projection update affects all variant combinations
+     * (e.g. a managed-class field changes).
+     */
+    reindexEntity(entityModule: string, entityId: string, builder: DocumentBuilder): Promise<void>;
+    /**
+     * Reindex one entity for **one specific slice only**. Used when an
+     * editorial overlay change has narrow scope (one locale × audience ×
+     * market) and rebuilding all slices would be wasteful.
+     */
+    reindexEntityForSlice(slice: IndexerSlice, entityId: string, builder: DocumentBuilder): Promise<void>;
+    /**
+     * Delete one entity from every slice configured for its vertical. Used by
+     * the source-disconnect cleanup pipeline (§5.10.3) and for hard entity
+     * deletions.
+     */
+    deleteEntity(entityModule: string, entityId: string): Promise<void>;
+    /**
+     * Search delegation — pass-through to the underlying adapter.
+     */
+    search(slice: IndexerSlice, request: SearchRequest): Promise<SearchResults>;
+    /**
+     * Returns the slices configured for a given vertical. Useful for callers
+     * orchestrating bulk operations themselves.
+     */
+    slicesForVertical(entityModule: string): IndexerSlice[];
+}
+/**
+ * Create the service from its options. Pure construction — no IO until
+ * methods are called.
+ */
+export declare function createIndexerService(options: IndexerServiceOptions): IndexerService;
+/**
+ * Build an `IndexerDocument` from a field-keyed projection, filtered by:
+ *   - Visibility — for storefront slices (`customer` / `partner` / `supplier`),
+ *     only fields whose policy `visibility[]` includes the slice audience.
+ *     For admin slices (the `staff-admin` sentinel), all fields visible to
+ *     any audience are included so the admin search document carries the
+ *     cross-audience denormalized text described in architecture §5.4.4.
+ *   - Queryability — `blob-only` fields are skipped (stored on the entity row
+ *     but not indexed). `indexed-column` and `first-class-table` fields land
+ *     in the document.
+ *
+ * Field paths ending in `[]` (lists) are renamed to drop the suffix so the
+ * indexer schema field names match (`gallery[]` → `gallery`).
+ *
+ * Pure logic — no IO. Sync emitters use this directly; async builders wrap
+ * it with row-fetching.
+ *
+ * Used by every vertical's `DocumentEmitter` implementation.
+ */
+export declare function buildIndexerDocument(registry: FieldPolicyRegistry, projection: ReadonlyMap<string, unknown>, slice: IndexerSlice, entityId: string): IndexerDocument;
+//# sourceMappingURL=indexer-service.d.ts.map

package/dist/services/indexer-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexer-service.d.ts","sourceRoot":"","sources":["../../src/services/indexer-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAe,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AACtE,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,wBAAwB,CAAA;AAE/B;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,oDAAoD;IACpD,OAAO,EAAE,cAAc,CAAA;IACvB;;;;OAIG;IACH,MAAM,EAAE,YAAY,EAAE,CAAA;IACtB;;;;OAIG;IACH,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAA;CACrD;AAED;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,CAC5B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,YAAY,KAChB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAA;AAEpC;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IAElC;;;;OAIG;IACH,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE9F;;;;OAIG;IACH,qBAAqB,CACnB,KAAK,EAAE,YAAY,EACnB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,IAAI,CAAC,CAAA;IAEhB;;;;OAIG;IACH,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEnE;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;IAE3E;;;OAGG;IACH,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,YAAY,EAAE,CAAA;CACxD;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,cAAc,CA0DnF;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,mBAAmB,EAC7B,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,KAAK,EAAE,YAAY,EACnB,QAAQ,EAAE,MAAM,GACf,eAAe,CAgBjB"}

package/dist/services/indexer-service.js

@@ -0,0 +1,123 @@
+/**
+ * IndexerService — higher-level wrapper around an `IndexerAdapter` that
+ * handles the cross-slice orchestration verticals actually need:
+ *
+ *   - Targeted reindex of one entity across all configured slices.
+ *   - Targeted reindex narrowed to a single `(locale, audience, market)`
+ *     when an editorial overlay change has narrow scope.
+ *   - Deletion across all slices for the same entity.
+ *   - `ensureCollections` at deployment startup.
+ *   - Search delegation to the underlying adapter.
+ *
+ * Templates configure the service with their actual slice set (which
+ * `(locale, audience, market)` combinations the deployment serves) and the
+ * IndexerAdapter implementation (Typesense by default).
+ *
+ * See `docs/architecture/catalog-architecture.md` §5.4 for the design.
+ */
+/**
+ * Create the service from its options. Pure construction — no IO until
+ * methods are called.
+ */
+export function createIndexerService(options) {
+    const { adapter, slices, registries } = options;
+    const slicesForVertical = (entityModule) => slices.filter((slice) => slice.vertical === entityModule);
+    const requireRegistry = (entityModule) => {
+        const registry = registries.get(entityModule);
+        if (!registry) {
+            throw new Error(`IndexerService: no field-policy registry registered for vertical "${entityModule}"`);
+        }
+        return registry;
+    };
+    return {
+        async ensureCollections() {
+            for (const slice of slices) {
+                const registry = requireRegistry(slice.vertical);
+                await adapter.ensureCollection(slice, registry);
+            }
+        },
+        async reindexEntity(entityModule, entityId, builder) {
+            const verticalSlices = slicesForVertical(entityModule);
+            for (const slice of verticalSlices) {
+                const document = await builder(entityId, slice);
+                if (!document) {
+                    await adapter.delete(slice, [entityId]);
+                    continue;
+                }
+                await adapter.upsert(slice, [document]);
+            }
+        },
+        async reindexEntityForSlice(slice, entityId, builder) {
+            const document = await builder(entityId, slice);
+            if (!document) {
+                await adapter.delete(slice, [entityId]);
+                return;
+            }
+            await adapter.upsert(slice, [document]);
+        },
+        async deleteEntity(entityModule, entityId) {
+            const verticalSlices = slicesForVertical(entityModule);
+            for (const slice of verticalSlices) {
+                await adapter.delete(slice, [entityId]);
+            }
+        },
+        async search(slice, request) {
+            return adapter.search(slice, request);
+        },
+        slicesForVertical,
+    };
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Document construction
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Build an `IndexerDocument` from a field-keyed projection, filtered by:
+ *   - Visibility — for storefront slices (`customer` / `partner` / `supplier`),
+ *     only fields whose policy `visibility[]` includes the slice audience.
+ *     For admin slices (the `staff-admin` sentinel), all fields visible to
+ *     any audience are included so the admin search document carries the
+ *     cross-audience denormalized text described in architecture §5.4.4.
+ *   - Queryability — `blob-only` fields are skipped (stored on the entity row
+ *     but not indexed). `indexed-column` and `first-class-table` fields land
+ *     in the document.
+ *
+ * Field paths ending in `[]` (lists) are renamed to drop the suffix so the
+ * indexer schema field names match (`gallery[]` → `gallery`).
+ *
+ * Pure logic — no IO. Sync emitters use this directly; async builders wrap
+ * it with row-fetching.
+ *
+ * Used by every vertical's `DocumentEmitter` implementation.
+ */
+export function buildIndexerDocument(registry, projection, slice, entityId) {
+    const fields = {};
+    for (const [path, value] of projection) {
+        let policy = registry.resolve(path);
+        let policyPath = path;
+        if (!policy && Array.isArray(value)) {
+            const listPath = `${path}[]`;
+            policy = registry.resolve(listPath);
+            policyPath = listPath;
+        }
+        if (!policy)
+            continue;
+        if (!shouldIndexInDocument(policy, slice.audience))
+            continue;
+        const fieldName = policyPath.endsWith("[]") ? policyPath.slice(0, -2) : policyPath;
+        fields[fieldName] = value;
+    }
+    return { id: entityId, fields };
+}
+function shouldIndexInDocument(policy, audience) {
+    // Skip blob-only fields — they're stored on the entity row, not indexed.
+    if (policy.query === "blob-only")
+        return false;
+    // Admin slices carry cross-audience text (§5.4.4) — include any field
+    // visible to any audience. The admin search document is queryable only
+    // by staff actors so cross-audience denormalization is safe here.
+    if (audience === "staff-admin") {
+        return policy.visibility.length > 0;
+    }
+    // Storefront slices: only fields visible to that specific audience.
+    return policy.visibility.includes(audience);
+}

package/dist/services/indexer-service.test.d.ts

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

package/dist/services/indexer-service.test.d.ts.map

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