@voyant-travel/inventory 0.1.0

package/dist/schema-taxonomy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-taxonomy.d.ts","sourceRoot":"","sources":["../src/schema-taxonomy.ts"],"names":[],"mappings":"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"}

package/dist/schema-taxonomy.js

@@ -0,0 +1,203 @@
+import { typeId, typeIdRef } from "@voyant-travel/db/lib/typeid-column";
+import { boolean, doublePrecision, index, integer, jsonb, pgTable, primaryKey, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+import { products } from "./schema-core.js";
+export const productTypes = pgTable("product_types", {
+    id: typeId("product_types"),
+    name: text("name").notNull(),
+    code: text("code").notNull(),
+    description: text("description"),
+    sortOrder: integer("sort_order").notNull().default(0),
+    active: boolean("active").notNull().default(true),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    uniqueIndex("uidx_product_types_code").on(table.code),
+    index("idx_product_types_active").on(table.active),
+    index("idx_product_types_sort_name").on(table.sortOrder, table.name),
+    index("idx_product_types_active_sort_name").on(table.active, table.sortOrder, table.name),
+]);
+export const productCategories = pgTable("product_categories", {
+    id: typeId("product_categories"),
+    parentId: text("parent_id"),
+    name: text("name").notNull(),
+    slug: text("slug").notNull(),
+    description: text("description"),
+    sortOrder: integer("sort_order").notNull().default(0),
+    active: boolean("active").notNull().default(true),
+    /**
+     * Customer-facing payment policy override. When set, bookings
+     * for products in this category inherit these terms (unless
+     * the listing or booking sets its own override). Shape mirrors
+     * `PaymentPolicy` from `@voyant-travel/finance`.
+     *
+     * `null` means "inherit from supplier / operator default".
+     *
+     * Multi-category products: the cascade picks the FIRST category
+     * (ordered by `productCategoryProducts.sortOrder` ascending) that
+     * has a non-null policy.
+     */
+    customerPaymentPolicy: jsonb("customer_payment_policy"),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    uniqueIndex("uidx_product_categories_slug").on(table.slug),
+    index("idx_product_categories_parent").on(table.parentId),
+    index("idx_product_categories_active").on(table.active),
+    index("idx_product_categories_sort_name").on(table.sortOrder, table.name),
+    index("idx_product_categories_active_sort_name").on(table.active, table.sortOrder, table.name),
+    index("idx_product_categories_parent_sort_name").on(table.parentId, table.sortOrder, table.name),
+    // Trigram GIN indexes back the `ILIKE '%term%'` category search
+    // (name OR slug — both branches need an index for a BitmapOr plan).
+    // Requires the pg_trgm extension.
+    index("idx_product_categories_name_trgm").using("gin", table.name.op("gin_trgm_ops")),
+    index("idx_product_categories_slug_trgm").using("gin", table.slug.op("gin_trgm_ops")),
+]);
+/**
+ * Locale-aware category labels. Mirrors `destinationTranslations`.
+ *
+ * The catalog plane's taxonomy projection (`catalog-policy-taxonomy.ts` +
+ * `service-catalog-plane-taxonomy.ts`) reads this table per-slice locale
+ * and falls back to `productCategories.name` when no row exists for a
+ * given `(categoryId, languageTag)`. Slug stays single-locale on
+ * `productCategories.slug` per #502 non-goals — operators want stable
+ * URLs that don't shift when translations are edited.
+ */
+export const productCategoryTranslations = pgTable("product_category_translations", {
+    id: typeId("product_category_translations"),
+    categoryId: typeIdRef("category_id")
+        .notNull()
+        .references(() => productCategories.id, { onDelete: "cascade" }),
+    languageTag: text("language_tag").notNull(),
+    name: text("name").notNull(),
+    description: text("description"),
+    seoTitle: text("seo_title"),
+    seoDescription: text("seo_description"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    uniqueIndex("uidx_product_category_translations_locale").on(table.categoryId, table.languageTag),
+    index("idx_product_category_translations_language").on(table.languageTag),
+    index("idx_product_category_translations_category_language_created").on(table.categoryId, table.languageTag, table.createdAt),
+    index("idx_product_category_translations_language_created").on(table.languageTag, table.createdAt),
+]);
+export const productTags = pgTable("product_tags", {
+    id: typeId("product_tags"),
+    name: text("name").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    uniqueIndex("uidx_product_tags_name").on(table.name),
+    // Backs the `ILIKE '%term%'` tag search. Requires the pg_trgm extension.
+    index("idx_product_tags_name_trgm").using("gin", table.name.op("gin_trgm_ops")),
+]);
+/**
+ * Locale-aware tag labels. Slimmer than category translations — tags are
+ * short labels with no description / SEO blurbs (per #502 non-goals).
+ */
+export const productTagTranslations = pgTable("product_tag_translations", {
+    id: typeId("product_tag_translations"),
+    tagId: typeIdRef("tag_id")
+        .notNull()
+        .references(() => productTags.id, { onDelete: "cascade" }),
+    languageTag: text("language_tag").notNull(),
+    name: text("name").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    uniqueIndex("uidx_product_tag_translations_locale").on(table.tagId, table.languageTag),
+    index("idx_product_tag_translations_language").on(table.languageTag),
+    index("idx_product_tag_translations_tag_language_created").on(table.tagId, table.languageTag, table.createdAt),
+    index("idx_product_tag_translations_language_created").on(table.languageTag, table.createdAt),
+]);
+export const destinations = pgTable("destinations", {
+    id: typeId("destinations"),
+    parentId: typeIdRef("parent_id"),
+    slug: text("slug").notNull(),
+    code: text("code"),
+    canonicalPlaceId: text("canonical_place_id"),
+    destinationType: text("destination_type").notNull().default("destination"),
+    latitude: doublePrecision("latitude"),
+    longitude: doublePrecision("longitude"),
+    sortOrder: integer("sort_order").notNull().default(0),
+    active: boolean("active").notNull().default(true),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    uniqueIndex("uidx_destinations_slug").on(table.slug),
+    uniqueIndex("uidx_destinations_code").on(table.code),
+    index("idx_destinations_parent").on(table.parentId),
+    index("idx_destinations_active").on(table.active),
+    index("idx_destinations_canonical_place").on(table.canonicalPlaceId),
+    index("idx_destinations_sort_slug").on(table.sortOrder, table.slug),
+    index("idx_destinations_active_sort_slug").on(table.active, table.sortOrder, table.slug),
+    index("idx_destinations_type_sort_slug").on(table.destinationType, table.sortOrder, table.slug),
+    index("idx_destinations_parent_sort_slug").on(table.parentId, table.sortOrder, table.slug),
+]);
+export const destinationTranslations = pgTable("destination_translations", {
+    id: typeId("destination_translations"),
+    destinationId: typeIdRef("destination_id")
+        .notNull()
+        .references(() => destinations.id, { onDelete: "cascade" }),
+    languageTag: text("language_tag").notNull(),
+    name: text("name").notNull(),
+    description: text("description"),
+    seoTitle: text("seo_title"),
+    seoDescription: text("seo_description"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    uniqueIndex("uidx_destination_translations_locale").on(table.destinationId, table.languageTag),
+    index("idx_destination_translations_language").on(table.languageTag),
+    index("idx_destination_translations_destination_language_created").on(table.destinationId, table.languageTag, table.createdAt),
+    index("idx_destination_translations_language_created").on(table.languageTag, table.createdAt),
+    // Trigram GIN indexes back the `ILIKE '%term%'` destination search
+    // (name OR description — both branches need an index for a BitmapOr
+    // plan). Requires the pg_trgm extension.
+    index("idx_destination_translations_name_trgm").using("gin", table.name.op("gin_trgm_ops")),
+    index("idx_destination_translations_description_trgm").using("gin", table.description.op("gin_trgm_ops")),
+]);
+export const productCategoryProducts = pgTable("product_category_products", {
+    productId: typeIdRef("product_id")
+        .notNull()
+        .references(() => products.id, { onDelete: "cascade" }),
+    categoryId: typeIdRef("category_id")
+        .notNull()
+        .references(() => productCategories.id, { onDelete: "cascade" }),
+    sortOrder: integer("sort_order").notNull().default(0),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    primaryKey({ columns: [table.productId, table.categoryId] }),
+    index("idx_pcp_product_sort").on(table.productId, table.sortOrder),
+    index("idx_pcp_category").on(table.categoryId),
+]);
+export const productTagProducts = pgTable("product_tag_products", {
+    productId: typeIdRef("product_id")
+        .notNull()
+        .references(() => products.id, { onDelete: "cascade" }),
+    tagId: typeIdRef("tag_id")
+        .notNull()
+        .references(() => productTags.id, { onDelete: "cascade" }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    primaryKey({ columns: [table.productId, table.tagId] }),
+    index("idx_ptp_tag").on(table.tagId),
+]);
+export const productDestinations = pgTable("product_destinations", {
+    productId: typeIdRef("product_id")
+        .notNull()
+        .references(() => products.id, { onDelete: "cascade" }),
+    destinationId: typeIdRef("destination_id")
+        .notNull()
+        .references(() => destinations.id, { onDelete: "cascade" }),
+    sortOrder: integer("sort_order").notNull().default(0),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    primaryKey({ columns: [table.productId, table.destinationId] }),
+    index("idx_product_destinations_product_sort").on(table.productId, table.sortOrder),
+    index("idx_product_destinations_destination_sort").on(table.destinationId, table.sortOrder),
+]);

package/dist/schema.d.ts

@@ -0,0 +1,10 @@
+export { bookingItemProductDetails, bookingProductDetails } from "./booking-extension.js";
+export * from "./extras/schema.js";
+export * from "./schema-core.js";
+export * from "./schema-itinerary.js";
+export * from "./schema-relations.js";
+export * from "./schema-settings.js";
+export * from "./schema-shared.js";
+export { type InsertProductsSourcedContent, PRODUCTS_CONTENT_MARKET_ANY, type ProductsSourcedContentFetchStatus, productsSourcedContentTable, type SelectProductsSourcedContent, } from "./schema-sourced-content.js";
+export * from "./schema-taxonomy.js";
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAA;AACzF,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,uBAAuB,CAAA;AACrC,cAAc,uBAAuB,CAAA;AACrC,cAAc,sBAAsB,CAAA;AACpC,cAAc,oBAAoB,CAAA;AAClC,OAAO,EACL,KAAK,4BAA4B,EACjC,2BAA2B,EAC3B,KAAK,iCAAiC,EACtC,2BAA2B,EAC3B,KAAK,4BAA4B,GAClC,MAAM,6BAA6B,CAAA;AACpC,cAAc,sBAAsB,CAAA"}

package/dist/schema.js

@@ -0,0 +1,9 @@
+export { bookingItemProductDetails, bookingProductDetails } from "./booking-extension.js";
+export * from "./extras/schema.js";
+export * from "./schema-core.js";
+export * from "./schema-itinerary.js";
+export * from "./schema-relations.js";
+export * from "./schema-settings.js";
+export * from "./schema-shared.js";
+export { PRODUCTS_CONTENT_MARKET_ANY, productsSourcedContentTable, } from "./schema-sourced-content.js";
+export * from "./schema-taxonomy.js";

package/dist/service-aggregates.d.ts

@@ -0,0 +1,29 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { products } from "./schema-core.js";
+type ProductStatus = (typeof products.$inferSelect)["status"];
+export interface ProductAggregates {
+    total: number;
+    countsByStatus: Array<{
+        status: ProductStatus;
+        count: number;
+    }>;
+    /** Shorthand for the `active` bucket — dashboard KPI card. */
+    active: number;
+    /**
+     * Products publicly listed on the storefront: `status = active` AND
+     * `activated = true` AND `visibility = 'public'`. Distinct from `active`,
+     * which includes internal-only active products.
+     */
+    publicActive: number;
+    /** Product creation count bucketed by UTC yearMonth, oldest first. */
+    monthlyCreatedCounts: Array<{
+        yearMonth: string;
+        count: number;
+    }>;
+}
+export declare function getProductAggregates(db: PostgresJsDatabase, options?: {
+    from?: string;
+    to?: string;
+}): Promise<ProductAggregates>;
+export {};
+//# sourceMappingURL=service-aggregates.d.ts.map

package/dist/service-aggregates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-aggregates.d.ts","sourceRoot":"","sources":["../src/service-aggregates.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAE3C,KAAK,aAAa,GAAG,CAAC,OAAO,QAAQ,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,CAAA;AAI7D,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,cAAc,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,aAAa,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAC/D,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAA;IACpB,sEAAsE;IACtE,oBAAoB,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAClE;AAED,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,kBAAkB,EACtB,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAA;CAAO,GAC3C,OAAO,CAAC,iBAAiB,CAAC,CA4D5B"}

package/dist/service-aggregates.js

@@ -0,0 +1,56 @@
+import { and, eq, sql } from "drizzle-orm";
+import { products } from "./schema-core.js";
+const ALL_PRODUCT_STATUSES = ["draft", "active", "archived"];
+export async function getProductAggregates(db, options = {}) {
+    const fromDate = options.from ? new Date(options.from) : undefined;
+    const toDate = options.to ? new Date(options.to) : undefined;
+    const rangeConditions = [];
+    // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+    if (fromDate)
+        rangeConditions.push(sql `${products.createdAt} >= ${fromDate.toISOString()}`);
+    // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+    if (toDate)
+        rangeConditions.push(sql `${products.createdAt} < ${toDate.toISOString()}`);
+    const rangeWhere = rangeConditions.length ? and(...rangeConditions) : undefined;
+    // Publicly-listed count ignores the date range — it's a point-in-time KPI
+    // ("what's live on the storefront right now"). The range-bound `active`
+    // bucket serves the "how many active products did we create this quarter"
+    // question instead.
+    const [[totalRow], statusRows, [publicActiveRow], monthlyCreatedCountsRows] = await Promise.all([
+        db.select({ count: sql `count(*)::int` }).from(products).where(rangeWhere),
+        db
+            .select({ status: products.status, count: sql `count(*)::int` })
+            .from(products)
+            .where(rangeWhere)
+            .groupBy(products.status),
+        db
+            .select({ count: sql `count(*)::int` })
+            .from(products)
+            .where(and(eq(products.status, "active"), eq(products.activated, true), eq(products.visibility, "public"))),
+        db
+            .select({
+            yearMonth: sql `to_char(${products.createdAt} at time zone 'UTC', 'YYYY-MM')`,
+            count: sql `count(*)::int`,
+        })
+            .from(products)
+            .where(rangeWhere)
+            // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            .groupBy(sql `to_char(${products.createdAt} at time zone 'UTC', 'YYYY-MM')`)
+            // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            .orderBy(sql `to_char(${products.createdAt} at time zone 'UTC', 'YYYY-MM')`),
+    ]);
+    const statusMap = new Map(statusRows.map((r) => [r.status, r.count]));
+    return {
+        total: totalRow?.count ?? 0,
+        countsByStatus: ALL_PRODUCT_STATUSES.map((status) => ({
+            status,
+            count: statusMap.get(status) ?? 0,
+        })),
+        active: statusMap.get("active") ?? 0,
+        publicActive: publicActiveRow?.count ?? 0,
+        monthlyCreatedCounts: monthlyCreatedCountsRows.map((row) => ({
+            yearMonth: row.yearMonth,
+            count: row.count,
+        })),
+    };
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Projection extension that joins product → destinations and contributes
+ * locale-aware destination fields (regions, countries, cities, slugs, ids)
+ * onto the product search document.
+ *
+ * Wire via `createProductDocumentBuilder({ extensions: [destinationsExtension] })`.
+ * Requires the registry to include `productDestinationsCatalogPolicy` —
+ * otherwise the contributed fields are silently dropped by the indexer's
+ * field-policy filter.
+ *
+ * Locale handling: `destination_translations` is keyed by `(destination_id,
+ * language_tag)`. The projection looks up the slice's locale; missing
+ * translations fall back to the destination's canonical `slug`. Operators
+ * who want the locale lookup to fall back to a different language (e.g.
+ * `fr-CA` → `fr` → `en`) should pre-populate the translation row;
+ * multi-tier fallback isn't built into the joins.
+ *
+ * Today's destinations table has no coordinate columns — geopoints come
+ * from `product_locations` and will ship as a separate projection
+ * extension once that policy lands.
+ */
+import type { ProductProjectionExtension } from "./service-catalog-plane.js";
+/**
+ * Construct the destinations projection extension.
+ *
+ * Returns a `ProductProjectionExtension` ready to pass to
+ * `createProductDocumentBuilder`.
+ */
+export declare function createProductDestinationsProjectionExtension(): ProductProjectionExtension;
+//# sourceMappingURL=service-catalog-plane-destinations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-catalog-plane-destinations.d.ts","sourceRoot":"","sources":["../src/service-catalog-plane-destinations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAMH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAA;AAsH5E;;;;;GAKG;AACH,wBAAgB,4CAA4C,IAAI,0BAA0B,CAgCzF"}

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

@@ -0,0 +1,143 @@
+/**
+ * Projection extension that joins product → destinations and contributes
+ * locale-aware destination fields (regions, countries, cities, slugs, ids)
+ * onto the product search document.
+ *
+ * Wire via `createProductDocumentBuilder({ extensions: [destinationsExtension] })`.
+ * Requires the registry to include `productDestinationsCatalogPolicy` —
+ * otherwise the contributed fields are silently dropped by the indexer's
+ * field-policy filter.
+ *
+ * Locale handling: `destination_translations` is keyed by `(destination_id,
+ * language_tag)`. The projection looks up the slice's locale; missing
+ * translations fall back to the destination's canonical `slug`. Operators
+ * who want the locale lookup to fall back to a different language (e.g.
+ * `fr-CA` → `fr` → `en`) should pre-populate the translation row;
+ * multi-tier fallback isn't built into the joins.
+ *
+ * Today's destinations table has no coordinate columns — geopoints come
+ * from `product_locations` and will ship as a separate projection
+ * extension once that policy lands.
+ */
+import { and, eq, inArray } from "drizzle-orm";
+import { destinations, destinationTranslations, productDestinations } from "./schema-taxonomy.js";
+async function joinProductDestinations(db, productId, languageTag) {
+    // Sub-query the linked destination ids first so the locale lookup is
+    // single-shot. Drizzle's join builder doesn't compose left joins on
+    // composite predicates cleanly across all dialects, so two queries +
+    // an in-memory merge keeps the contract obvious.
+    const links = await db
+        .select({
+        destinationId: productDestinations.destinationId,
+        destinationType: destinations.destinationType,
+        slug: destinations.slug,
+        canonicalPlaceId: destinations.canonicalPlaceId,
+        active: destinations.active,
+    })
+        .from(productDestinations)
+        .innerJoin(destinations, eq(productDestinations.destinationId, destinations.id))
+        .where(eq(productDestinations.productId, productId));
+    const activeLinks = links.filter((row) => row.active);
+    if (activeLinks.length === 0)
+        return [];
+    const destinationIds = activeLinks.map((row) => row.destinationId);
+    const translations = await db
+        .select({
+        destinationId: destinationTranslations.destinationId,
+        name: destinationTranslations.name,
+    })
+        .from(destinationTranslations)
+        .where(and(inArray(destinationTranslations.destinationId, destinationIds), eq(destinationTranslations.languageTag, languageTag)));
+    const nameByDestinationId = new Map();
+    for (const row of translations) {
+        nameByDestinationId.set(row.destinationId, row.name);
+    }
+    return activeLinks.map((row) => ({
+        destinationId: row.destinationId,
+        destinationType: row.destinationType,
+        slug: row.slug,
+        canonicalPlaceId: row.canonicalPlaceId ?? null,
+        translatedName: nameByDestinationId.get(row.destinationId) ?? null,
+    }));
+}
+/** Bucket destinations by `destinationType` and return locale-aware names. */
+function bucketByType(rows) {
+    const regions = [];
+    const countries = [];
+    const cities = [];
+    const ports = [];
+    const waterways = [];
+    const slugs = [];
+    const ids = [];
+    const canonicalPlaceIds = [];
+    for (const row of rows) {
+        const label = row.translatedName ?? row.slug;
+        switch (row.destinationType) {
+            case "region":
+                regions.push(label);
+                break;
+            case "country":
+                countries.push(label);
+                break;
+            case "city":
+                cities.push(label);
+                break;
+            case "port":
+                ports.push(label);
+                break;
+            case "river":
+            case "sea":
+            case "ocean":
+            case "canal":
+            case "lake":
+                waterways.push(label);
+                break;
+            // "destination" (the catch-all default) doesn't bucket into any of
+            // the typed lists. Its slug + id still land in the doc so storefronts
+            // can filter generically.
+        }
+        slugs.push(row.slug);
+        ids.push(row.destinationId);
+        if (row.canonicalPlaceId) {
+            canonicalPlaceIds.push(row.canonicalPlaceId);
+        }
+    }
+    return { regions, countries, cities, ports, waterways, slugs, ids, canonicalPlaceIds };
+}
+/**
+ * Construct the destinations projection extension.
+ *
+ * Returns a `ProductProjectionExtension` ready to pass to
+ * `createProductDocumentBuilder`.
+ */
+export function createProductDestinationsProjectionExtension() {
+    return {
+        name: "products:destinations",
+        async project(db, productId, slice) {
+            const rows = await joinProductDestinations(db, productId, slice.locale);
+            if (rows.length === 0) {
+                return new Map([
+                    ["regions[]", []],
+                    ["countries[]", []],
+                    ["cities[]", []],
+                    ["ports[]", []],
+                    ["waterways[]", []],
+                    ["destinationSlugs[]", []],
+                    ["destinationIds[]", []],
+                    ["destinationCanonicalPlaceIds[]", []],
+                ]);
+            }
+            const { regions, countries, cities, ports, waterways, slugs, ids, canonicalPlaceIds } = bucketByType(rows);
+            return new Map([
+                ["regions[]", regions],
+                ["countries[]", countries],
+                ["cities[]", cities],
+                ["ports[]", ports],
+                ["waterways[]", waterways],
+                ["destinationSlugs[]", slugs],
+                ["destinationIds[]", ids],
+                ["destinationCanonicalPlaceIds[]", canonicalPlaceIds],
+            ]);
+        },
+    };
+}

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

@@ -0,0 +1,73 @@
+/**
+ * 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 type { ProductProjectionExtension } from "./service-catalog-plane.js";
+interface CategoryRow {
+    id: string;
+    parentId: string | null;
+    name: string;
+    slug: string;
+    active: boolean;
+}
+interface DirectCategoryLink {
+    categoryId: string;
+    sortOrder: number;
+}
+interface TagRow {
+    id: string;
+    name: string;
+}
+interface TaxonomyProjection {
+    categoryIds: string[];
+    categoryNames: string[];
+    categorySlugs: string[];
+    primaryCategoryId: string | null;
+    primaryCategoryName: string | null;
+    primaryCategorySlug: string | null;
+    tagIds: string[];
+    tagLabels: string[];
+}
+/**
+ * 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.
+ */
+declare function buildTaxonomyProjection(directLinks: ReadonlyArray<DirectCategoryLink>, resolvedCategories: ReadonlyMap<string, CategoryRow>, tags: ReadonlyArray<TagRow>, categoryNameByLocale?: ReadonlyMap<string, string>, tagNameByLocale?: ReadonlyMap<string, string>): TaxonomyProjection;
+/**
+ * Construct the taxonomy projection extension.
+ *
+ * Returns a `ProductProjectionExtension` ready to pass to
+ * `createProductDocumentBuilder`.
+ */
+export declare function createProductTaxonomyProjectionExtension(): ProductProjectionExtension;
+export declare const __test__: {
+    buildTaxonomyProjection: typeof buildTaxonomyProjection;
+};
+export {};
+//# sourceMappingURL=service-catalog-plane-taxonomy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-catalog-plane-taxonomy.d.ts","sourceRoot":"","sources":["../src/service-catalog-plane-taxonomy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAaH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAA;AAE5E,UAAU,WAAW;IACnB,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,OAAO,CAAA;CAChB;AAED,UAAU,kBAAkB;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;CAClB;AAkED,UAAU,MAAM;IACd,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;CACb;AA8DD,UAAU,kBAAkB;IAC1B,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB;AAED;;;;;GAKG;AACH,iBAAS,uBAAuB,CAC9B,WAAW,EAAE,aAAa,CAAC,kBAAkB,CAAC,EAC9C,kBAAkB,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,EACpD,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,EAC3B,oBAAoB,GAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAa,EAC7D,eAAe,GAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAa,GACvD,kBAAkB,CAmEpB;AAED;;;;;GAKG;AACH,wBAAgB,wCAAwC,IAAI,0BAA0B,CA6CrF;AAGD,eAAO,MAAM,QAAQ;;CAEpB,CAAA"}