@voyantjs/products 0.28.3 → 0.29.0

package/dist/service-catalog-plane-taxonomy.js

@@ -0,0 +1,242 @@
+/**
+ * Projection extension that joins product → categories (with ancestor walk)
+ * and product → tags, contributing taxonomy fields onto the product search
+ * document.
+ *
+ * Wire via `createProductDocumentBuilder({ extensions: [taxonomyExtension] })`.
+ * Requires the registry to include `productTaxonomyCatalogPolicy` —
+ * otherwise the contributed fields are silently dropped by the indexer's
+ * field-policy filter.
+ *
+ * Hierarchy denormalization: Typesense can't recurse, so a product linked
+ * to "Hiking" (parent: "Adventure") needs both labels in `categories[]` for
+ * the "Adventure" filter to match. The projection walks the parent chain
+ * iteratively, filtering inactive ancestors (so an operator-paused parent
+ * stops surfacing its still-active children under the parent filter).
+ *
+ * Localization (#502): when a `product_category_translations` /
+ * `product_tag_translations` row exists for the slice's locale, its `name`
+ * wins. Otherwise the projection falls back to the canonical
+ * `productCategories.name` / `productTags.name` (the legacy single-locale
+ * column). This makes the upgrade non-breaking — operators that haven't
+ * created translations keep seeing the English label on every locale slice
+ * exactly as before.
+ *
+ * Slugs stay single-locale on `productCategories.slug` (per #502 non-goals
+ * — operators want stable URLs that don't shift when translations are
+ * edited).
+ */
+import { and, eq, inArray } from "drizzle-orm";
+import { productCategories, productCategoryProducts, productCategoryTranslations, productTagProducts, productTags, productTagTranslations, } from "./schema-taxonomy.js";
+/**
+ * Resolve linked category ids for a product, ordered by the operator-set
+ * `sortOrder` on `product_category_products` (lowest first). Direct links
+ * only — ancestors are walked separately.
+ */
+async function fetchDirectCategoryLinks(db, productId) {
+    return db
+        .select({
+        categoryId: productCategoryProducts.categoryId,
+        sortOrder: productCategoryProducts.sortOrder,
+    })
+        .from(productCategoryProducts)
+        .where(eq(productCategoryProducts.productId, productId));
+}
+/**
+ * Walk up the parent chain from a set of seed category ids, filtering
+ * inactive rows. Returns every active row reachable from the seeds.
+ *
+ * Iterative breadth-first to bound depth and avoid Drizzle recursive-CTE
+ * complexity. Real-world category trees are O(depth ≤ 5), so this issues
+ * at most a handful of `inArray` lookups regardless of breadth.
+ *
+ * Cycle-protected via a visited set — a misconfigured parent loop won't
+ * spin the indexer.
+ */
+async function walkActiveCategoryChain(db, seedIds) {
+    const resolved = new Map();
+    const visited = new Set();
+    let frontier = Array.from(new Set(seedIds));
+    while (frontier.length > 0) {
+        for (const id of frontier)
+            visited.add(id);
+        const rows = await db
+            .select({
+            id: productCategories.id,
+            parentId: productCategories.parentId,
+            name: productCategories.name,
+            slug: productCategories.slug,
+            active: productCategories.active,
+        })
+            .from(productCategories)
+            .where(and(inArray(productCategories.id, frontier), eq(productCategories.active, true)));
+        const nextFrontier = [];
+        for (const row of rows) {
+            resolved.set(row.id, row);
+            if (row.parentId && !visited.has(row.parentId) && !resolved.has(row.parentId)) {
+                nextFrontier.push(row.parentId);
+            }
+        }
+        frontier = Array.from(new Set(nextFrontier));
+    }
+    return resolved;
+}
+async function fetchProductTags(db, productId) {
+    return db
+        .select({ id: productTags.id, name: productTags.name })
+        .from(productTagProducts)
+        .innerJoin(productTags, eq(productTagProducts.tagId, productTags.id))
+        .where(eq(productTagProducts.productId, productId));
+}
+/**
+ * Look up locale-specific category names for the given category ids. Returns
+ * a Map keyed by category id; entries only exist when a translation row was
+ * found for the slice locale. Callers fall back to the canonical
+ * `productCategories.name` for any missing entry.
+ */
+async function fetchCategoryTranslations(db, categoryIds, languageTag) {
+    if (categoryIds.length === 0)
+        return new Map();
+    const rows = await db
+        .select({
+        categoryId: productCategoryTranslations.categoryId,
+        name: productCategoryTranslations.name,
+    })
+        .from(productCategoryTranslations)
+        .where(and(inArray(productCategoryTranslations.categoryId, categoryIds), eq(productCategoryTranslations.languageTag, languageTag)));
+    const out = new Map();
+    for (const row of rows)
+        out.set(row.categoryId, row.name);
+    return out;
+}
+async function fetchTagTranslations(db, tagIds, languageTag) {
+    if (tagIds.length === 0)
+        return new Map();
+    const rows = await db
+        .select({
+        tagId: productTagTranslations.tagId,
+        name: productTagTranslations.name,
+    })
+        .from(productTagTranslations)
+        .where(and(inArray(productTagTranslations.tagId, tagIds), eq(productTagTranslations.languageTag, languageTag)));
+    const out = new Map();
+    for (const row of rows)
+        out.set(row.tagId, row.name);
+    return out;
+}
+/**
+ * Pure aggregation kernel. `categoryNameByLocale` and `tagNameByLocale`
+ * carry slice-locale translations; entries override the canonical name on
+ * the row. Missing entries fall back to the canonical name. Slug stays
+ * canonical regardless — there's no per-locale slug.
+ */
+function buildTaxonomyProjection(directLinks, resolvedCategories, tags, categoryNameByLocale = new Map(), tagNameByLocale = new Map()) {
+    // Primary = first direct link (by sortOrder asc, then category name asc)
+    // that resolved as active. Tie-break uses the canonical row name so the
+    // ordering is stable across slice locales — a translation that sorts
+    // differently shouldn't shuffle which category is "primary".
+    const sortedDirect = [...directLinks].sort((a, b) => {
+        if (a.sortOrder !== b.sortOrder)
+            return a.sortOrder - b.sortOrder;
+        const nameA = resolvedCategories.get(a.categoryId)?.name ?? "";
+        const nameB = resolvedCategories.get(b.categoryId)?.name ?? "";
+        return nameA.localeCompare(nameB);
+    });
+    let primary = null;
+    for (const link of sortedDirect) {
+        const row = resolvedCategories.get(link.categoryId);
+        if (row) {
+            primary = row;
+            break;
+        }
+    }
+    // Categories[] = direct links + ancestors, deduped, ordered by direct-link
+    // sortOrder first then ancestor walk order. Stable enough that storefronts
+    // can rely on `categories[0]` being a representative label.
+    const seenIds = new Set();
+    const categoryIds = [];
+    const categoryNames = [];
+    const categorySlugs = [];
+    function emit(row) {
+        if (seenIds.has(row.id))
+            return;
+        seenIds.add(row.id);
+        categoryIds.push(row.id);
+        // Locale override wins; otherwise use the canonical row.name.
+        categoryNames.push(categoryNameByLocale.get(row.id) ?? row.name);
+        categorySlugs.push(row.slug);
+    }
+    // Pass 1: direct links first, in operator-controlled order.
+    for (const link of sortedDirect) {
+        const row = resolvedCategories.get(link.categoryId);
+        if (row)
+            emit(row);
+    }
+    // Pass 2: ancestors of direct links, walking up via parentId.
+    for (const link of sortedDirect) {
+        let cursor = resolvedCategories.get(link.categoryId)?.parentId ?? null;
+        const guard = new Set(); // local guard against malformed loops
+        while (cursor && !guard.has(cursor)) {
+            guard.add(cursor);
+            const parentRow = resolvedCategories.get(cursor);
+            if (!parentRow)
+                break;
+            emit(parentRow);
+            cursor = parentRow.parentId;
+        }
+    }
+    return {
+        categoryIds,
+        categoryNames,
+        categorySlugs,
+        primaryCategoryId: primary?.id ?? null,
+        primaryCategoryName: primary ? (categoryNameByLocale.get(primary.id) ?? primary.name) : null,
+        primaryCategorySlug: primary?.slug ?? null,
+        tagIds: tags.map((t) => t.id),
+        tagLabels: tags.map((t) => tagNameByLocale.get(t.id) ?? t.name),
+    };
+}
+/**
+ * Construct the taxonomy projection extension.
+ *
+ * Returns a `ProductProjectionExtension` ready to pass to
+ * `createProductDocumentBuilder`.
+ */
+export function createProductTaxonomyProjectionExtension() {
+    return {
+        name: "products:taxonomy",
+        async project(db, productId, slice) {
+            const [directLinks, tags] = await Promise.all([
+                fetchDirectCategoryLinks(db, productId),
+                fetchProductTags(db, productId),
+            ]);
+            const seedIds = directLinks.map((l) => l.categoryId);
+            const resolvedCategories = seedIds.length > 0
+                ? await walkActiveCategoryChain(db, seedIds)
+                : new Map();
+            // Translations cover the FULL chain (direct + ancestors), so look up
+            // by every resolved-category id, not just the seed set.
+            const allCategoryIds = Array.from(resolvedCategories.keys());
+            const tagIds = tags.map((t) => t.id);
+            const [categoryNameByLocale, tagNameByLocale] = await Promise.all([
+                fetchCategoryTranslations(db, allCategoryIds, slice.locale),
+                fetchTagTranslations(db, tagIds, slice.locale),
+            ]);
+            const projection = buildTaxonomyProjection(directLinks, resolvedCategories, tags, categoryNameByLocale, tagNameByLocale);
+            return new Map([
+                ["categories[]", projection.categoryNames],
+                ["categoryIds[]", projection.categoryIds],
+                ["categorySlugs[]", projection.categorySlugs],
+                ["primaryCategoryId", projection.primaryCategoryId],
+                ["primaryCategoryName", projection.primaryCategoryName],
+                ["primaryCategorySlug", projection.primaryCategorySlug],
+                ["tagLabels[]", projection.tagLabels],
+                ["tagIds[]", projection.tagIds],
+            ]);
+        },
+    };
+}
+// Internal exports for unit tests — kept separate from the public surface.
+export const __test__ = {
+    buildTaxonomyProjection,
+};

package/dist/service-catalog-plane.d.ts

@@ -18,7 +18,7 @@
  * pattern this file establishes (replicated for cruises, hospitality, etc.
  * in their own service-catalog-plane.ts files).
  */
-import { type CaptureSnapshotInput, type DocumentBuilder, type DocumentEmitter, type IndexerDocument, type IndexerSlice, type PricingBasis, type Provenance, type ResolvedView, type ResolverScope, type Visibility } from "@voyantjs/catalog";
+import { type CaptureSnapshotInput, type DocumentBuilder, type DocumentEmitter, type FieldPolicy, type FieldPolicyRegistry, type IndexerDocument, type IndexerSlice, type PricingBasis, type Provenance, type ResolvedView, type ResolverScope, type Visibility } from "@voyantjs/catalog";
 import type { AnyDrizzleDb } from "@voyantjs/db";
 import { products } from "./schema-core.js";
 /**
@@ -99,6 +99,37 @@ export declare function listResolvedProducts(db: AnyDrizzleDb, rows: ReadonlyArr
 export declare function buildProductSnapshotInput(db: AnyDrizzleDb, productId: string, context: ProductCatalogContext & {
     pricingBasis?: PricingBasis;
 }): Promise<Omit<CaptureSnapshotInput, "bookingId"> | null>;
+/**
+ * A projection extension contributes additional field-keyed entries to the
+ * product search document. The builder runs all extensions in parallel after
+ * fetching the product row, then merges their entries into the base
+ * projection before emitting.
+ *
+ * Used by child-entity registries (destinations, taxonomy, departures, etc.)
+ * to denormalize fields onto the product doc. See architecture §5.4 — the
+ * search index is the canonical place for cross-entity denormalization.
+ *
+ * `buildIndexerDocument` silently drops entries whose paths aren't registered
+ * in the field-policy registry — so an extension's contributed registry must
+ * be composed into the registry passed to `createProductDocumentBuilder` for
+ * its fields to actually land in the document.
+ */
+export interface ProductProjectionExtension {
+    /** Identifier — used for diagnostics and logging only. */
+    readonly name: string;
+    /**
+     * Contribute additional projection entries for one product. The slice
+     * carries locale and audience for translation lookups and audience
+     * filtering.
+     */
+    project(db: AnyDrizzleDb, productId: string, slice: IndexerSlice): Promise<ReadonlyMap<string, unknown>>;
+}
+/**
+ * Compose the registry from the base product policy plus any contributing
+ * extensions' policies. Templates wire this when they enable child-entity
+ * registries.
+ */
+export declare function createProductsRegistry(...extensionPolicies: ReadonlyArray<ReadonlyArray<FieldPolicy>>): FieldPolicyRegistry;
 /**
  * Construct a sync `DocumentEmitter` for products. The emitter takes a
  * pre-fetched product row + a slice and returns the indexer document
@@ -107,9 +138,13 @@ export declare function buildProductSnapshotInput(db: AnyDrizzleDb, productId: s
  * Bulk-reindex pipelines that already have rows in hand call this directly.
  * Live reindex paths use `createProductDocumentBuilder` below, which fetches
  * the row before emitting.
+ *
+ * Pass a custom `registry` when the deployment composes additional
+ * child-entity policies; otherwise the default products registry is used.
  */
 export declare function createProductDocumentEmitter(context: {
     sellerOperatorId: string;
+    registry?: FieldPolicyRegistry;
 }): DocumentEmitter<typeof products.$inferSelect>;
 /**
  * Async `DocumentBuilder` for products — fetches the row by id, then emits.
@@ -118,9 +153,19 @@ export declare function createProductDocumentEmitter(context: {
  * Returns `null` if the product no longer exists (e.g. it was deleted
  * between the reindex enqueue and the worker picking it up). Callers can
  * treat `null` as a delete signal.
+ *
+ * `extensions` denormalize child-entity fields onto the product doc. They
+ * run in parallel after the base row is fetched. An extension that throws
+ * fails the whole build — failures here would otherwise produce silently
+ * incomplete documents.
+ *
+ * Pass a custom `registry` (composed via `createProductsRegistry`) when
+ * extensions contribute fields beyond the base products policy.
  */
 export declare function createProductDocumentBuilder(db: AnyDrizzleDb, context: {
     sellerOperatorId: string;
+    extensions?: ReadonlyArray<ProductProjectionExtension>;
+    registry?: FieldPolicyRegistry;
 }): DocumentBuilder;
 /**
  * Re-exports for routes that only import from this file.

package/dist/service-catalog-plane.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service-catalog-plane.d.ts","sourceRoot":"","sources":["../src/service-catalog-plane.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAGL,KAAK,oBAAoB,EAEzB,KAAK,eAAe,EACpB,KAAK,eAAe,EAEpB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,aAAa,EAElB,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAIhD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAc3C;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,OAAO,QAAQ,CAAC,YAAY,EACjC,OAAO,EAAE;IAAE,gBAAgB,EAAE,MAAM,CAAA;CAAE,GACpC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAwC9B;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,OAAO,QAAQ,CAAC,YAAY,EAClC,QAAQ,EAAE;IAAE,gBAAgB,EAAE,MAAM,CAAA;CAAE,GACrC,UAAU,CAKZ;AAED,8EAA8E;AAC9E,MAAM,WAAW,qBAAqB;IACpC,iFAAiF;IACjF,gBAAgB,EAAE,MAAM,CAAA;IACxB,qCAAqC;IACrC,KAAK,EAAE,aAAa,CAAA;CACrB;AAED;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAC1C,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAS9B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,YAAY,EAChB,IAAI,EAAE,aAAa,CAAC,OAAO,QAAQ,CAAC,YAAY,CAAC,EACjD,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,YAAY,EAAE,CAAC,CAkBzB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,qBAAqB,GAAG;IAAE,YAAY,CAAC,EAAE,YAAY,CAAA;CAAE,GAC/D,OAAO,CAAC,IAAI,CAAC,oBAAoB,EAAE,WAAW,CAAC,GAAG,IAAI,CAAC,CASzD;AAMD;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE;IACpD,gBAAgB,EAAE,MAAM,CAAA;CACzB,GAAG,eAAe,CAAC,OAAO,QAAQ,CAAC,YAAY,CAAC,CAWhD;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,EAAE,EAAE,YAAY,EAChB,OAAO,EAAE;IAAE,gBAAgB,EAAE,MAAM,CAAA;CAAE,GACpC,eAAe,CAQjB;AAED;;GAEG;AACH,YAAY,EACV,oBAAoB,EACpB,eAAe,EACf,eAAe,EACf,eAAe,EACf,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,aAAa,EACb,UAAU,GACX,CAAA"}
+{"version":3,"file":"service-catalog-plane.d.ts","sourceRoot":"","sources":["../src/service-catalog-plane.ts"],"names":[],"mappings":"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"}

package/dist/service-catalog-plane.js

@@ -168,9 +168,20 @@ export async function buildProductSnapshotInput(db, productId, context) {
         pricingBasis: context.pricingBasis,
     });
 }
-// ─────────────────────────────────────────────────────────────────────────────
-// Indexer document emission
-// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Compose the registry from the base product policy plus any contributing
+ * extensions' policies. Templates wire this when they enable child-entity
+ * registries.
+ */
+export function createProductsRegistry(...extensionPolicies) {
+    if (extensionPolicies.length === 0)
+        return getProductsRegistry();
+    const composed = [...productCatalogPolicy];
+    for (const policies of extensionPolicies) {
+        composed.push(...policies);
+    }
+    return createFieldPolicyRegistry(composed);
+}
 /**
  * Construct a sync `DocumentEmitter` for products. The emitter takes a
  * pre-fetched product row + a slice and returns the indexer document
@@ -179,9 +190,12 @@ export async function buildProductSnapshotInput(db, productId, context) {
  * Bulk-reindex pipelines that already have rows in hand call this directly.
  * Live reindex paths use `createProductDocumentBuilder` below, which fetches
  * the row before emitting.
+ *
+ * Pass a custom `registry` when the deployment composes additional
+ * child-entity policies; otherwise the default products registry is used.
  */
 export function createProductDocumentEmitter(context) {
-    const registry = getProductsRegistry();
+    const registry = context.registry ?? getProductsRegistry();
     return {
         vertical: "products",
         emit(source, slice) {
@@ -199,14 +213,36 @@ export function createProductDocumentEmitter(context) {
  * Returns `null` if the product no longer exists (e.g. it was deleted
  * between the reindex enqueue and the worker picking it up). Callers can
  * treat `null` as a delete signal.
+ *
+ * `extensions` denormalize child-entity fields onto the product doc. They
+ * run in parallel after the base row is fetched. An extension that throws
+ * fails the whole build — failures here would otherwise produce silently
+ * incomplete documents.
+ *
+ * Pass a custom `registry` (composed via `createProductsRegistry`) when
+ * extensions contribute fields beyond the base products policy.
  */
 export function createProductDocumentBuilder(db, context) {
-    const emitter = createProductDocumentEmitter(context);
+    const registry = context.registry ?? getProductsRegistry();
+    const extensions = context.extensions ?? [];
     return async (entityId, slice) => {
         const rows = await db.select().from(products).where(eq(products.id, entityId)).limit(1);
         const row = rows[0];
         if (!row)
             return null;
-        return emitter.emit(row, slice);
+        const baseProjection = productRowToProjection(row, {
+            sellerOperatorId: context.sellerOperatorId,
+        });
+        if (extensions.length === 0) {
+            return buildIndexerDocument(registry, baseProjection, slice, entityId);
+        }
+        const extensionProjections = await Promise.all(extensions.map((ext) => ext.project(db, entityId, slice)));
+        const merged = new Map(baseProjection);
+        for (const projection of extensionProjections) {
+            for (const [path, value] of projection) {
+                merged.set(path, value);
+            }
+        }
+        return buildIndexerDocument(registry, merged, slice, entityId);
     };
 }