@voyant-travel/inventory 0.1.0

package/dist/interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../src/interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAM5D,eAAO,MAAM,wBAAwB,EAAE,kBAKtC,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,MAK7B,CAAA;AAED,eAAO,MAAM,qCAAqC,EAAE,kBAKnD,CAAA;AASD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,UAKjC,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAgB,CAAA;AACnD,eAAO,MAAM,4BAA4B;;aAlBE,CAAC;;;;cAKE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAagB,CAAA;AAC/D,eAAO,MAAM,yBAAyB,6CAA2B,CAAA;AAEjE,MAAM,MAAM,yBAAyB,GACjC,mBAAmB,GACnB,iBAAiB,GACjB,4BAA4B,GAC5B,6BAA6B,GAC7B,+BAA+B,CAAA;AAEnC,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,WAAW,CAAA;IACnB,oBAAoB,EAAE,UAAU,CAAA;IAChC,iBAAiB,EAAE,SAAS,yBAAyB,EAAE,CAAA;IACvD,uBAAuB,EAAE,SAAS;QAChC,YAAY;QACZ,QAAQ;QACR,SAAS;QACT,UAAU;QACV,mBAAmB;KACpB,CAAA;CACF;AAED,eAAO,MAAM,4BAA4B,EAAE,4BAW1C,CAAA"}

package/dist/interface.js

@@ -0,0 +1,54 @@
+import { productsBookingExtension } from "./booking-extension.js";
+import { productRoutes } from "./routes.js";
+import { publicProductRoutes } from "./routes-public.js";
+export const inventoryProductLinkable = {
+    module: "inventory",
+    entity: "product",
+    table: "products",
+    idPrefix: "prod",
+};
+export const inventoryModule = {
+    name: "inventory",
+    linkable: {
+        product: inventoryProductLinkable,
+    },
+};
+export const inventoryProductCompatibilityLinkable = {
+    module: "products",
+    entity: "product",
+    table: "products",
+    idPrefix: "prod",
+};
+const productsCompatibilityModule = {
+    name: "products",
+    linkable: {
+        product: inventoryProductCompatibilityLinkable,
+    },
+};
+/**
+ * Compatibility Hono module for the Inventory-owned Product runtime.
+ *
+ * Routes intentionally keep the existing `products` mount name so deployed
+ * `/v1/admin/products` and `/v1/public/products` clients do not break.
+ */
+export const inventoryHonoModule = {
+    module: productsCompatibilityModule,
+    adminRoutes: productRoutes,
+    publicRoutes: publicProductRoutes,
+    routes: productRoutes,
+};
+export const inventoryProductRoutes = productRoutes;
+export const publicInventoryProductRoutes = publicProductRoutes;
+export const inventoryBookingExtension = productsBookingExtension;
+export const inventoryInterfaceDescriptor = {
+    module: "inventory",
+    operatedEntityModule: "products",
+    authoringSurfaces: [
+        "product-structure",
+        "product-version",
+        "product-internal-component",
+        "owned-publication-lifecycle",
+        "operated-extras-configuration",
+    ],
+    catalogResponsibilities: ["projection", "search", "overlay", "snapshot", "source-governance"],
+};

package/dist/public-routes.d.ts

@@ -0,0 +1,2 @@
+export * from "./routes-public.js";
+//# sourceMappingURL=public-routes.d.ts.map

package/dist/public-routes.d.ts.map

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

package/dist/public-routes.js

@@ -0,0 +1 @@
+export * from "./routes-public.js";

package/dist/public-validation.d.ts

@@ -0,0 +1,2 @@
+export * from "./validation-public.js";
+//# sourceMappingURL=public-validation.d.ts.map

package/dist/public-validation.d.ts.map

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

package/dist/public-validation.js

@@ -0,0 +1 @@
+export * from "./validation-public.js";

package/dist/read-model.d.ts

@@ -0,0 +1,25 @@
+import type { KVStore } from "@voyant-travel/utils/cache";
+export declare function productDocKey(productId: string, variant: string): string;
+export declare function productSlugMapKey(slug: string): string;
+/** Stable variant id from the detail query (currently just the locale). */
+export declare function productDocVariant(query: {
+    languageTag?: string | null;
+}): string;
+/**
+ * Read-through document fetch. `null` compute results (missing/inactive
+ * product) are never cached — a 404 must not mask a product that
+ * activates a second later. Cache failures degrade to the live path.
+ */
+export declare function readThroughProductDoc<T>(kv: KVStore | undefined, key: string, compute: () => Promise<T | null>): Promise<{
+    data: T | null;
+    fromReadModel: boolean;
+}>;
+/** Resolve a slug to a product id through the KV mapping. */
+export declare function readThroughSlugMapping(kv: KVStore | undefined, slug: string, resolve: () => Promise<string | null>): Promise<string | null>;
+/**
+ * Drop every cached document variant for a product. Uses KV `list` by
+ * prefix (optional on the KVStore contract — silently a no-op without
+ * it, where the TTL becomes the only freshness bound).
+ */
+export declare function invalidateProductReadModel(kv: KVStore, productId: string): Promise<void>;
+//# sourceMappingURL=read-model.d.ts.map

package/dist/read-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-model.d.ts","sourceRoot":"","sources":["../src/read-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAA;AA2BzD,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAExE;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG,MAAM,CAEhF;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,CAAC,EAC3C,EAAE,EAAE,OAAO,GAAG,SAAS,EACvB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,GAC/B,OAAO,CAAC;IAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IAAC,aAAa,EAAE,OAAO,CAAA;CAAE,CAAC,CAkBrD;AAED,6DAA6D;AAC7D,wBAAsB,sBAAsB,CAC1C,EAAE,EAAE,OAAO,GAAG,SAAS,EACvB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GACpC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAkBxB;AAED;;;;GAIG;AACH,wBAAsB,0BAA0B,CAAC,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ9F"}

package/dist/read-model.js

@@ -0,0 +1,99 @@
+/**
+ * KV-backed read model for the public product detail surface (RFC
+ * voyant#1687 Phase 2.2 — the "document plane"; browse/search is the
+ * Typesense "query plane" and already serves cards without Postgres).
+ *
+ * Model: read-through with exact invalidation. The first read of a
+ * (product, variant) materializes the render-ready document into KV;
+ * repeat reads cost one KV get and ZERO Postgres queries. Admin
+ * mutations to a product delete its documents (see
+ * `productsReadModelInvalidation` in routes.ts), and a generous TTL
+ * bounds staleness for anything invalidation misses.
+ *
+ * Slug lookups resolve through a short-lived slug→id mapping so the
+ * id-keyed document is shared between `/:id` and `/slug/:slug`. The
+ * mapping is deliberately NOT invalidated on mutation: it's cheap to
+ * refill, and its short TTL bounds the only affected case (a renamed
+ * slug serving the old document) to a few minutes.
+ */
+const RM_PREFIX = "rm:v1:product";
+/** Product documents live long — exact invalidation keeps them fresh. */
+const PRODUCT_DOC_TTL_SECONDS = 24 * 60 * 60;
+/** Slug→id mappings are refill-cheap; the TTL bounds rename staleness. */
+const SLUG_MAP_TTL_SECONDS = 5 * 60;
+export function productDocKey(productId, variant) {
+    return `${RM_PREFIX}:${productId}:${variant}`;
+}
+export function productSlugMapKey(slug) {
+    return `rm:v1:product-slug:${slug}`;
+}
+/** Stable variant id from the detail query (currently just the locale). */
+export function productDocVariant(query) {
+    return query.languageTag ? `lang=${query.languageTag}` : "default";
+}
+/**
+ * Read-through document fetch. `null` compute results (missing/inactive
+ * product) are never cached — a 404 must not mask a product that
+ * activates a second later. Cache failures degrade to the live path.
+ */
+export async function readThroughProductDoc(kv, key, compute) {
+    if (kv) {
+        try {
+            const hit = await kv.get(key, { type: "json" });
+            if (hit !== null && hit !== undefined)
+                return { data: hit, fromReadModel: true };
+        }
+        catch {
+            // fall through to live compute
+        }
+    }
+    const data = await compute();
+    if (data !== null && kv) {
+        try {
+            await kv.put(key, JSON.stringify(data), { expirationTtl: PRODUCT_DOC_TTL_SECONDS });
+        }
+        catch {
+            // best-effort materialization
+        }
+    }
+    return { data, fromReadModel: false };
+}
+/** Resolve a slug to a product id through the KV mapping. */
+export async function readThroughSlugMapping(kv, slug, resolve) {
+    if (kv) {
+        try {
+            const hit = await kv.get(productSlugMapKey(slug), { type: "text" });
+            if (hit)
+                return hit;
+        }
+        catch {
+            // fall through
+        }
+    }
+    const id = await resolve();
+    if (id && kv) {
+        try {
+            await kv.put(productSlugMapKey(slug), id, { expirationTtl: SLUG_MAP_TTL_SECONDS });
+        }
+        catch {
+            // best-effort
+        }
+    }
+    return id;
+}
+/**
+ * Drop every cached document variant for a product. Uses KV `list` by
+ * prefix (optional on the KVStore contract — silently a no-op without
+ * it, where the TTL becomes the only freshness bound).
+ */
+export async function invalidateProductReadModel(kv, productId) {
+    if (!kv.list)
+        return;
+    try {
+        const { keys } = await kv.list({ prefix: `${RM_PREFIX}:${productId}:` });
+        await Promise.all(keys.map((key) => kv.delete(key.name)));
+    }
+    catch {
+        // best-effort — the document TTL bounds staleness if this fails
+    }
+}

package/dist/route-env.d.ts

@@ -0,0 +1,22 @@
+import type { EventBus } from "@voyant-travel/core";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+export type Env = {
+    Variables: {
+        db: PostgresJsDatabase;
+        userId?: string;
+        agentId?: string;
+        workflowPrincipalId?: string;
+        principalSubtype?: string;
+        sessionId?: string;
+        apiTokenId?: string;
+        apiKeyId?: string;
+        callerType?: string;
+        actor?: string;
+        isInternalRequest?: boolean;
+        organizationId?: string;
+        workflowRunId?: string;
+        workflowStepId?: string;
+        eventBus?: EventBus;
+    };
+};
+//# sourceMappingURL=route-env.d.ts.map

package/dist/route-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-env.d.ts","sourceRoot":"","sources":["../src/route-env.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,MAAM,MAAM,GAAG,GAAG;IAChB,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,mBAAmB,CAAC,EAAE,MAAM,CAAA;QAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAA;QACzB,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,UAAU,CAAC,EAAE,MAAM,CAAA;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,UAAU,CAAC,EAAE,MAAM,CAAA;QACnB,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,iBAAiB,CAAC,EAAE,OAAO,CAAA;QAC3B,cAAc,CAAC,EAAE,MAAM,CAAA;QACvB,aAAa,CAAC,EAAE,MAAM,CAAA;QACtB,cAAc,CAAC,EAAE,MAAM,CAAA;QACvB,QAAQ,CAAC,EAAE,QAAQ,CAAA;KACpB,CAAA;CACF,CAAA"}

package/dist/route-env.js

@@ -0,0 +1 @@
+export {};

package/dist/routes-associations.d.ts

@@ -0,0 +1,164 @@
+import type { Env } from "./route-env.js";
+export declare const productAssociationRoutes: import("hono/hono-base").HonoBase<Env, {
+    "/:id/categories": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    parentId: string | null;
+                    name: string;
+                    slug: string;
+                    description: string | null;
+                    sortOrder: number;
+                    active: boolean;
+                    customerPaymentPolicy: import("hono/utils/types").JSONValue;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
+                }[];
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/:id/categories": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 409;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                success: true;
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/:id/categories/:categoryId": {
+        $delete: {
+            input: {
+                param: {
+                    id: string;
+                } & {
+                    categoryId: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                } & {
+                    categoryId: string;
+                };
+            };
+            output: {
+                success: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/:id/tags": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    name: string;
+                    createdAt: string;
+                    updatedAt: string;
+                }[];
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/:id/tags": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 409;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                success: true;
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/:id/tags/:tagId": {
+        $delete: {
+            input: {
+                param: {
+                    id: string;
+                } & {
+                    tagId: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                } & {
+                    tagId: string;
+                };
+            };
+            output: {
+                success: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/:id/tags/:tagId">;
+//# sourceMappingURL=routes-associations.d.ts.map

package/dist/routes-associations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-associations.d.ts","sourceRoot":"","sources":["../src/routes-associations.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AAGzC,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAmHjC,CAAA"}

package/dist/routes-associations.js

@@ -0,0 +1,100 @@
+import { parseJsonBody } from "@voyant-travel/hono";
+import { Hono } from "hono";
+import { z } from "zod";
+import { appendProductMutationLedgerEntry, changedMutationFields } from "./action-ledger.js";
+import { emitProductContentChanged } from "./events.js";
+import { productsService } from "./service.js";
+export const productAssociationRoutes = new Hono()
+    // ==========================================================================
+    // Product <-> Category associations
+    // ==========================================================================
+    .get("/:id/categories", async (c) => {
+    return c.json({
+        data: await productsService.listProductCategories_(c.get("db"), c.req.param("id")),
+    });
+})
+    .post("/:id/categories", async (c) => {
+    const productId = c.req.param("id");
+    const body = await parseJsonBody(c, z.object({
+        categoryId: z.string(),
+        sortOrder: z.number().optional(),
+    }));
+    const { categoryId, sortOrder } = body;
+    const row = await productsService.addProductToCategory(c.get("db"), productId, categoryId, sortOrder);
+    if (!row) {
+        return c.json({ error: "Already assigned or not found" }, 409);
+    }
+    await appendProductMutationLedgerEntry(c, {
+        action: "create",
+        productId,
+        changedFields: changedMutationFields(body, null, row),
+        subject: "product category link",
+        actionName: "product.category_link.create",
+        routeOrToolName: "products.category_link.create",
+    });
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "category" });
+    return c.json({ success: true }, 201);
+})
+    .delete("/:id/categories/:categoryId", async (c) => {
+    const productId = c.req.param("id");
+    const row = await productsService.removeProductFromCategory(c.get("db"), productId, c.req.param("categoryId"));
+    if (!row) {
+        return c.json({ error: "Association not found" }, 404);
+    }
+    await appendProductMutationLedgerEntry(c, {
+        action: "delete",
+        productId,
+        changedFields: [],
+        subject: "product category link",
+        actionName: "product.category_link.delete",
+        routeOrToolName: "products.category_link.delete",
+    });
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "category" });
+    return c.json({ success: true }, 200);
+})
+    // ==========================================================================
+    // Product <-> Tag associations
+    // ==========================================================================
+    .get("/:id/tags", async (c) => {
+    return c.json({
+        data: await productsService.listProductTags_(c.get("db"), c.req.param("id")),
+    });
+})
+    .post("/:id/tags", async (c) => {
+    const productId = c.req.param("id");
+    const body = await parseJsonBody(c, z.object({
+        tagId: z.string(),
+    }));
+    const { tagId } = body;
+    const row = await productsService.addProductTag(c.get("db"), productId, tagId);
+    if (!row) {
+        return c.json({ error: "Already assigned or not found" }, 409);
+    }
+    await appendProductMutationLedgerEntry(c, {
+        action: "create",
+        productId,
+        changedFields: changedMutationFields(body, null, row),
+        subject: "product tag link",
+        actionName: "product.tag_link.create",
+        routeOrToolName: "products.tag_link.create",
+    });
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "tag" });
+    return c.json({ success: true }, 201);
+})
+    .delete("/:id/tags/:tagId", async (c) => {
+    const productId = c.req.param("id");
+    const row = await productsService.removeProductTag(c.get("db"), productId, c.req.param("tagId"));
+    if (!row) {
+        return c.json({ error: "Association not found" }, 404);
+    }
+    await appendProductMutationLedgerEntry(c, {
+        action: "delete",
+        productId,
+        changedFields: [],
+        subject: "product tag link",
+        actionName: "product.tag_link.delete",
+        routeOrToolName: "products.tag_link.delete",
+    });
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "tag" });
+    return c.json({ success: true }, 200);
+});