@voyantjs/pricing 0.28.1 → 0.29.0

package/dist/events.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Pricing domain events.
+ *
+ * Emitted (after commit) by paths that mutate pricing rules feeding the
+ * catalog-plane `priceFromAmountCents` projection (PR4 of #493). The
+ * catalog bridge subscribes to these and reindexes the affected
+ * product so the denormalized "from $X" stays in sync without a full
+ * reindex run.
+ *
+ * Subscriber contract: treat the payload as a *trigger*, not the source
+ * of truth. Re-read the row(s) before acting on them — concurrent edits
+ * may have superseded the snapshot in this payload.
+ *
+ * Per docs/architecture/channel-push-architecture.md §5.1 (same shape as
+ * `availability.slot.changed`).
+ *
+ * Today's surface covers `option_price_rules` + `option_unit_price_rules`
+ * — the two tables that feed PR4's MIN aggregation. Other pricing
+ * tables (`option_start_time_rules`, `option_unit_tiers`,
+ * `departure_price_overrides`, `pickup_price_rules`, `cancellation_*`)
+ * intentionally do NOT emit yet: extending the catalog projection to
+ * read them is its own design conversation and emitting an event no
+ * subscriber consumes is dead surface area. When a future projection
+ * grows to read one of those tables, extend `kind` and add emission to
+ * the corresponding service function.
+ */
+/** Stable string identifier for the event. */
+export declare const PRICING_RULE_CHANGED_EVENT: "pricing.rule.changed";
+/** Origin of the change. Diagnostic only — subscribers don't behave
+ *  differently on this field, but it's preserved end-to-end so logs
+ *  and dashboards can attribute drift to a cause. */
+export type PricingRuleChangeSource = "created" | "updated" | "deleted";
+/**
+ * Which pricing-rule table the mutation touched. Lets a subscriber
+ * filter without re-reading the row (e.g. a future projection that
+ * only cares about `option-rule` mutations can skip per-unit deltas).
+ */
+export type PricingRuleKind = "option-rule" | "option-unit-rule";
+export interface PricingRuleChangedEvent {
+    /**
+     * The product whose pricing surface changed. Subscribers reindex
+     * this product. Always set — every relevant rule belongs to a
+     * product (option-unit rules join through their parent option-rule
+     * to find the product).
+     */
+    productId: string;
+    /** The mutated row's id, for diagnostics. */
+    ruleId: string;
+    /** Which table was touched. */
+    kind: PricingRuleKind;
+    source: PricingRuleChangeSource;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,8CAA8C;AAC9C,eAAO,MAAM,0BAA0B,EAAG,sBAA+B,CAAA;AAEzE;;qDAEqD;AACrD,MAAM,MAAM,uBAAuB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAA;AAEvE;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG,kBAAkB,CAAA;AAEhE,MAAM,WAAW,uBAAuB;IACtC;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAA;IACd,+BAA+B;IAC/B,IAAI,EAAE,eAAe,CAAA;IACrB,MAAM,EAAE,uBAAuB,CAAA;CAChC"}

package/dist/events.js

@@ -0,0 +1,28 @@
+/**
+ * Pricing domain events.
+ *
+ * Emitted (after commit) by paths that mutate pricing rules feeding the
+ * catalog-plane `priceFromAmountCents` projection (PR4 of #493). The
+ * catalog bridge subscribes to these and reindexes the affected
+ * product so the denormalized "from $X" stays in sync without a full
+ * reindex run.
+ *
+ * Subscriber contract: treat the payload as a *trigger*, not the source
+ * of truth. Re-read the row(s) before acting on them — concurrent edits
+ * may have superseded the snapshot in this payload.
+ *
+ * Per docs/architecture/channel-push-architecture.md §5.1 (same shape as
+ * `availability.slot.changed`).
+ *
+ * Today's surface covers `option_price_rules` + `option_unit_price_rules`
+ * — the two tables that feed PR4's MIN aggregation. Other pricing
+ * tables (`option_start_time_rules`, `option_unit_tiers`,
+ * `departure_price_overrides`, `pickup_price_rules`, `cancellation_*`)
+ * intentionally do NOT emit yet: extending the catalog projection to
+ * read them is its own design conversation and emitting an event no
+ * subscriber consumes is dead surface area. When a future projection
+ * grows to read one of those tables, extend `kind` and add emission to
+ * the corresponding service function.
+ */
+/** Stable string identifier for the event. */
+export const PRICING_RULE_CHANGED_EVENT = "pricing.rule.changed";

package/dist/routes-core.d.ts

@@ -11,7 +11,7 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
                     unitId: string | null;
                     code: string | null;
                     name: string;
-                    categoryType: "service" | "other" | "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle";
+                    categoryType: "service" | "child" | "other" | "adult" | "infant" | "senior" | "group" | "room" | "vehicle";
                     seatOccupancy: number;
                     groupSize: number | null;
                     isAgeQualified: boolean;
@@ -43,8 +43,8 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
                     metadata: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | null;
-                    id: string;
                     name: string;
+                    id: string;
                     createdAt: string;
                     updatedAt: string;
                     code: string | null;
@@ -52,7 +52,7 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
                     productId: string | null;
                     optionId: string | null;
                     unitId: string | null;
-                    categoryType: "service" | "other" | "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle";
+                    categoryType: "service" | "child" | "other" | "adult" | "infant" | "senior" | "group" | "room" | "vehicle";
                     seatOccupancy: number;
                     groupSize: number | null;
                     isAgeQualified: boolean;
@@ -93,7 +93,7 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
                     unitId: string | null;
                     code: string | null;
                     name: string;
-                    categoryType: "service" | "other" | "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle";
+                    categoryType: "service" | "child" | "other" | "adult" | "infant" | "senior" | "group" | "room" | "vehicle";
                     seatOccupancy: number;
                     groupSize: number | null;
                     isAgeQualified: boolean;
@@ -140,7 +140,7 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
                     unitId: string | null;
                     code: string | null;
                     name: string;
-                    categoryType: "service" | "other" | "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle";
+                    categoryType: "service" | "child" | "other" | "adult" | "infant" | "senior" | "group" | "room" | "vehicle";
                     seatOccupancy: number;
                     groupSize: number | null;
                     isAgeQualified: boolean;
@@ -370,8 +370,8 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
                     metadata: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | null;
-                    id: string;
                     name: string;
+                    id: string;
                     createdAt: string;
                     updatedAt: string;
                     notes: string | null;
@@ -680,8 +680,8 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
                     metadata: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | null;
-                    id: string;
                     name: string;
+                    id: string;
                     createdAt: string;
                     updatedAt: string;
                     notes: string | null;
@@ -843,8 +843,8 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
                     metadata: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | null;
-                    id: string;
                     name: string;
+                    id: string;
                     createdAt: string;
                     updatedAt: string;
                     notes: string | null;

package/dist/routes-public.d.ts

@@ -110,7 +110,7 @@ export declare const publicPricingRoutes: import("hono/hono-base").HonoBase<Env,
                     startsAt: string | null;
                     endsAt: string | null;
                     timezone: string;
-                    status: "open" | "closed" | "sold_out" | "cancelled";
+                    status: "cancelled" | "open" | "closed" | "sold_out";
                     unlimited: boolean;
                     remainingPax: number | null;
                     remainingResources: number | null;

package/dist/routes-rules.d.ts

@@ -46,8 +46,8 @@ export declare const pricingRuleRoutes: import("hono/hono-base").HonoBase<Env, {
                     metadata: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | null;
-                    id: string;
                     name: string;
+                    id: string;
                     createdAt: string;
                     updatedAt: string;
                     notes: string | null;

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

@@ -1 +1 @@
-{"version":3,"file":"routes-rules.d.ts","sourceRoot":"","sources":["../src/routes-rules.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,GAAG,EAAY,MAAM,oBAAoB,CAAA;AA6BvD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAwR1B,CAAA"}
+{"version":3,"file":"routes-rules.d.ts","sourceRoot":"","sources":["../src/routes-rules.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,GAAG,EAAY,MAAM,oBAAoB,CAAA;AA6BvD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAgS1B,CAAA"}

package/dist/routes-rules.js

@@ -6,34 +6,38 @@ import { departurePriceOverrideListQuerySchema, dropoffPriceRuleListQuerySchema,
 export const pricingRuleRoutes = new Hono()
     .get("/option-price-rules", async (c) => c.json(await pricingService.listOptionPriceRules(c.get("db"), await parseQuery(c, optionPriceRuleListQuerySchema))))
     .post("/option-price-rules", async (c) => c.json({
-    data: await pricingService.createOptionPriceRule(c.get("db"), await parseJsonBody(c, insertOptionPriceRuleSchema)),
+    data: await pricingService.createOptionPriceRule(c.get("db"), await parseJsonBody(c, insertOptionPriceRuleSchema), { eventBus: c.get("eventBus") }),
 }, 201))
     .get("/option-price-rules/:id", async (c) => {
     const row = await pricingService.getOptionPriceRuleById(c.get("db"), c.req.param("id"));
     return row ? c.json({ data: row }) : notFound(c, "Option price rule not found");
 })
     .patch("/option-price-rules/:id", async (c) => {
-    const row = await pricingService.updateOptionPriceRule(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateOptionPriceRuleSchema));
+    const row = await pricingService.updateOptionPriceRule(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateOptionPriceRuleSchema), { eventBus: c.get("eventBus") });
     return row ? c.json({ data: row }) : notFound(c, "Option price rule not found");
 })
     .delete("/option-price-rules/:id", async (c) => {
-    const row = await pricingService.deleteOptionPriceRule(c.get("db"), c.req.param("id"));
+    const row = await pricingService.deleteOptionPriceRule(c.get("db"), c.req.param("id"), {
+        eventBus: c.get("eventBus"),
+    });
     return row ? c.json({ success: true }) : notFound(c, "Option price rule not found");
 })
     .get("/option-unit-price-rules", async (c) => c.json(await pricingService.listOptionUnitPriceRules(c.get("db"), await parseQuery(c, optionUnitPriceRuleListQuerySchema))))
     .post("/option-unit-price-rules", async (c) => c.json({
-    data: await pricingService.createOptionUnitPriceRule(c.get("db"), await parseJsonBody(c, insertOptionUnitPriceRuleSchema)),
+    data: await pricingService.createOptionUnitPriceRule(c.get("db"), await parseJsonBody(c, insertOptionUnitPriceRuleSchema), { eventBus: c.get("eventBus") }),
 }, 201))
     .get("/option-unit-price-rules/:id", async (c) => {
     const row = await pricingService.getOptionUnitPriceRuleById(c.get("db"), c.req.param("id"));
     return row ? c.json({ data: row }) : notFound(c, "Option unit price rule not found");
 })
     .patch("/option-unit-price-rules/:id", async (c) => {
-    const row = await pricingService.updateOptionUnitPriceRule(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateOptionUnitPriceRuleSchema));
+    const row = await pricingService.updateOptionUnitPriceRule(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateOptionUnitPriceRuleSchema), { eventBus: c.get("eventBus") });
     return row ? c.json({ data: row }) : notFound(c, "Option unit price rule not found");
 })
     .delete("/option-unit-price-rules/:id", async (c) => {
-    const row = await pricingService.deleteOptionUnitPriceRule(c.get("db"), c.req.param("id"));
+    const row = await pricingService.deleteOptionUnitPriceRule(c.get("db"), c.req.param("id"), {
+        eventBus: c.get("eventBus"),
+    });
     return row ? c.json({ success: true }) : notFound(c, "Option unit price rule not found");
 })
     .get("/option-start-time-rules", async (c) => c.json(await pricingService.listOptionStartTimeRules(c.get("db"), await parseQuery(c, optionStartTimeRuleListQuerySchema))))

package/dist/routes-shared.d.ts

@@ -1,9 +1,11 @@
+import type { EventBus } from "@voyantjs/core";
 import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
 import type { Context } from "hono";
 export type Env = {
     Variables: {
         db: PostgresJsDatabase;
         userId?: string;
+        eventBus?: EventBus;
     };
 };
 export declare function notFound(c: Context<Env>, message: string): Response & import("hono").TypedResponse<{

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

@@ -1 +1 @@
-{"version":3,"file":"routes-shared.d.ts","sourceRoot":"","sources":["../src/routes-shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,MAAM,MAAM,GAAG,GAAG;IAChB,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM;;gBAExD"}
+{"version":3,"file":"routes-shared.d.ts","sourceRoot":"","sources":["../src/routes-shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,MAAM,MAAM,GAAG,GAAG;IAChB,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,QAAQ,CAAC,EAAE,QAAQ,CAAA;KACpB,CAAA;CACF,CAAA;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM;;gBAExD"}

package/dist/schema-categories.d.ts

@@ -109,7 +109,7 @@ export declare const pricingCategories: import("drizzle-orm/pg-core").PgTableWit
             tableName: "pricing_categories";
             dataType: "string";
             columnType: "PgEnumColumn";
-            data: "service" | "other" | "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle";
+            data: "service" | "child" | "other" | "adult" | "infant" | "senior" | "group" | "room" | "vehicle";
             driverParam: string;
             notNull: true;
             hasDefault: true;

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

@@ -0,0 +1,80 @@
+/**
+ * Projection extension that aggregates a "price from" amount across the
+ * product's configured default-rule prices and contributes
+ * `priceFromAmountCents`, `priceFromCurrency`, and `hasPricing` to the
+ * product search document.
+ *
+ * Lives in `@voyantjs/pricing` because:
+ *   - The data lives here (`option_price_rules`, `option_unit_price_rules`,
+ *     `price_catalogs`).
+ *   - `pricing` already depends on `products`; importing the
+ *     `ProductProjectionExtension` contract type from products is the
+ *     same direction. The reverse would create a circular dep.
+ *
+ * Wire via `createProductDocumentBuilder({ extensions: [pricingExtension] })`
+ * after composing `productPricingCatalogPolicy` into the registry.
+ *
+ * Scope intentionally narrow:
+ *   - **No schedule-aware rule resolution.** Only `is_default = true`
+ *     rules contribute. Seasonal / promo rules with schedules don't
+ *     surface here — they'd require per-slice resolution against a
+ *     moving "now" date and are deferred to a follow-up.
+ *   - **No per-departure overrides.** Same reason.
+ *   - **Currency consistency.** Only rules whose catalog currency matches
+ *     the product's `sellCurrency` (or whose catalog currency is null
+ *     and therefore inherits the product's) are MIN'd together. This
+ *     prevents emitting a misleading "from $50" when one of the rules
+ *     is actually €50.
+ *
+ * Document churn: this projection is `now()`-independent — it reads
+ * static configured prices, not date-dependent rule windows. Same
+ * product reindexed an hour later produces the same fields.
+ */
+import type { AnyDrizzleDb } from "@voyantjs/db";
+import type { ProductProjectionExtension } from "@voyantjs/products/service-catalog-plane";
+interface PricingProjectionOptions {
+    /**
+     * Resolve the product's `sellAmountCents` + `sellCurrency` so the
+     * projection can MIN the product-row default into the candidate set
+     * and filter rules by matching currency. Templates inject this — the
+     * default reads the products table via raw SQL, but tests can stub
+     * with a known shape without standing up the products schema.
+     *
+     * Returns `null` for both fields when the product doesn't exist.
+     */
+    loadProductPricing?: (db: AnyDrizzleDb, productId: string) => Promise<{
+        sellAmountCents: number | null;
+        sellCurrency: string | null;
+    }>;
+}
+interface PricingAggregate {
+    priceFromAmountCents: number | null;
+    priceFromCurrency: string | null;
+    hasPricing: boolean;
+}
+/**
+ * Pure aggregation kernel — given the product-row pricing and the rule
+ * candidate set, produce the projection fields. Exposed via `__test__`
+ * for unit coverage that doesn't need a real DB.
+ *
+ * `productPrice` is the row's `sellAmountCents` (`null` when unset).
+ * `currency` is the row's `sellCurrency` (used as the projected
+ * currency; rule prices fed in here are pre-filtered to match).
+ * `ruleCandidates` is every active default rule's `baseSellAmountCents`
+ * AND every active default rule's per-unit `sellAmountCents`, with
+ * nulls already filtered out.
+ */
+declare function aggregatePricing(productPrice: number | null, currency: string | null, ruleCandidates: ReadonlyArray<number>): PricingAggregate;
+/**
+ * Construct the pricing projection extension.
+ *
+ * Pass `loadProductPricing` in tests to stub the products-row fetch;
+ * production uses the default raw-SQL implementation.
+ */
+export declare function createProductPricingProjectionExtension(options?: PricingProjectionOptions): ProductProjectionExtension;
+export declare const __test__: {
+    aggregatePricing: typeof aggregatePricing;
+    EMPTY_AGGREGATE: PricingAggregate;
+};
+export {};
+//# sourceMappingURL=service-catalog-plane-pricing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-catalog-plane-pricing.d.ts","sourceRoot":"","sources":["../src/service-catalog-plane-pricing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,KAAK,EAEV,0BAA0B,EAC3B,MAAM,0CAA0C,CAAA;AAMjD,UAAU,wBAAwB;IAChC;;;;;;;;OAQG;IACH,kBAAkB,CAAC,EAAE,CACnB,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,KACd,OAAO,CAAC;QAAE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,CAAA;CAC9E;AAED,UAAU,gBAAgB;IACxB,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAA;IACnC,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,UAAU,EAAE,OAAO,CAAA;CACpB;AAQD;;;;;;;;;;;GAWG;AACH,iBAAS,gBAAgB,CACvB,YAAY,EAAE,MAAM,GAAG,IAAI,EAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,cAAc,EAAE,aAAa,CAAC,MAAM,CAAC,GACpC,gBAAgB,CAqBlB;AAED;;;;;GAKG;AACH,wBAAgB,uCAAuC,CACrD,OAAO,GAAE,wBAA6B,GACrC,0BAA0B,CA4B5B;AA6GD,eAAO,MAAM,QAAQ;;;CAGpB,CAAA"}

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

@@ -0,0 +1,181 @@
+/**
+ * Projection extension that aggregates a "price from" amount across the
+ * product's configured default-rule prices and contributes
+ * `priceFromAmountCents`, `priceFromCurrency`, and `hasPricing` to the
+ * product search document.
+ *
+ * Lives in `@voyantjs/pricing` because:
+ *   - The data lives here (`option_price_rules`, `option_unit_price_rules`,
+ *     `price_catalogs`).
+ *   - `pricing` already depends on `products`; importing the
+ *     `ProductProjectionExtension` contract type from products is the
+ *     same direction. The reverse would create a circular dep.
+ *
+ * Wire via `createProductDocumentBuilder({ extensions: [pricingExtension] })`
+ * after composing `productPricingCatalogPolicy` into the registry.
+ *
+ * Scope intentionally narrow:
+ *   - **No schedule-aware rule resolution.** Only `is_default = true`
+ *     rules contribute. Seasonal / promo rules with schedules don't
+ *     surface here — they'd require per-slice resolution against a
+ *     moving "now" date and are deferred to a follow-up.
+ *   - **No per-departure overrides.** Same reason.
+ *   - **Currency consistency.** Only rules whose catalog currency matches
+ *     the product's `sellCurrency` (or whose catalog currency is null
+ *     and therefore inherits the product's) are MIN'd together. This
+ *     prevents emitting a misleading "from $50" when one of the rules
+ *     is actually €50.
+ *
+ * Document churn: this projection is `now()`-independent — it reads
+ * static configured prices, not date-dependent rule windows. Same
+ * product reindexed an hour later produces the same fields.
+ */
+import { and, eq, isNull, or, sql } from "drizzle-orm";
+import { priceCatalogs } from "./schema-catalogs.js";
+import { optionPriceRules, optionUnitPriceRules } from "./schema-option-rules.js";
+const EMPTY_AGGREGATE = {
+    priceFromAmountCents: null,
+    priceFromCurrency: null,
+    hasPricing: false,
+};
+/**
+ * Pure aggregation kernel — given the product-row pricing and the rule
+ * candidate set, produce the projection fields. Exposed via `__test__`
+ * for unit coverage that doesn't need a real DB.
+ *
+ * `productPrice` is the row's `sellAmountCents` (`null` when unset).
+ * `currency` is the row's `sellCurrency` (used as the projected
+ * currency; rule prices fed in here are pre-filtered to match).
+ * `ruleCandidates` is every active default rule's `baseSellAmountCents`
+ * AND every active default rule's per-unit `sellAmountCents`, with
+ * nulls already filtered out.
+ */
+function aggregatePricing(productPrice, currency, ruleCandidates) {
+    const candidates = [];
+    if (productPrice !== null)
+        candidates.push(productPrice);
+    for (const c of ruleCandidates)
+        candidates.push(c);
+    if (candidates.length === 0) {
+        return { ...EMPTY_AGGREGATE, priceFromCurrency: currency };
+    }
+    // MIN with a sentinel; faster than spread+Math.min for large arrays
+    // and avoids the Math.min stack-arg limit edge case.
+    let min = candidates[0];
+    for (const c of candidates) {
+        if (c < min)
+            min = c;
+    }
+    return {
+        priceFromAmountCents: min,
+        priceFromCurrency: currency,
+        hasPricing: true,
+    };
+}
+/**
+ * Construct the pricing projection extension.
+ *
+ * Pass `loadProductPricing` in tests to stub the products-row fetch;
+ * production uses the default raw-SQL implementation.
+ */
+export function createProductPricingProjectionExtension(options = {}) {
+    const loadProductPricing = options.loadProductPricing ?? defaultLoadProductPricing;
+    return {
+        name: "products:pricing",
+        async project(db, productId, _slice) {
+            const product = await loadProductPricing(db, productId);
+            const currency = product.sellCurrency;
+            // Without a product row currency we can't safely filter rules by
+            // matching currency — emit only the (null) row pricing. This case
+            // is rare in practice (every product has sellCurrency set in the
+            // operator UI) but keeps the projection failure-isolated.
+            if (!currency) {
+                const out = aggregatePricing(product.sellAmountCents, null, []);
+                return toProjectionMap(out);
+            }
+            const [flatPrices, unitPrices] = await Promise.all([
+                fetchFlatRulePrices(db, productId, currency),
+                fetchUnitRulePrices(db, productId, currency),
+            ]);
+            const candidates = [...flatPrices, ...unitPrices];
+            const out = aggregatePricing(product.sellAmountCents, currency, candidates);
+            return toProjectionMap(out);
+        },
+    };
+}
+/**
+ * Read `optionPriceRules.baseSellAmountCents` for the product's active
+ * default rules whose catalog currency matches the product currency
+ * (or whose catalog has a NULL currency, meaning "inherit product").
+ *
+ * Filtering on the `(productId, active=true, isDefault=true)` subset
+ * keeps the candidate set small even for products with hundreds of
+ * seasonal rules.
+ */
+async function fetchFlatRulePrices(db, productId, productCurrency) {
+    const rows = await db
+        .select({ price: optionPriceRules.baseSellAmountCents })
+        .from(optionPriceRules)
+        .innerJoin(priceCatalogs, eq(priceCatalogs.id, optionPriceRules.priceCatalogId))
+        .where(and(eq(optionPriceRules.productId, productId), eq(optionPriceRules.active, true), eq(optionPriceRules.isDefault, true), eq(priceCatalogs.active, true), or(eq(priceCatalogs.currencyCode, productCurrency), isNull(priceCatalogs.currencyCode))));
+    const out = [];
+    for (const row of rows) {
+        if (row.price !== null)
+            out.push(row.price);
+    }
+    return out;
+}
+/**
+ * Read `optionUnitPriceRules.sellAmountCents` for active per-unit tiers
+ * whose parent rule is one of the product's active default rules in a
+ * matching-currency catalog. Used for products priced per occupancy
+ * (e.g. cabins at "single $X / double $Y / triple $Z") where the parent
+ * rule's `baseSellAmountCents` is null and the actual prices live on
+ * the unit tiers.
+ */
+async function fetchUnitRulePrices(db, productId, productCurrency) {
+    const rows = await db
+        .select({ price: optionUnitPriceRules.sellAmountCents })
+        .from(optionUnitPriceRules)
+        .innerJoin(optionPriceRules, eq(optionPriceRules.id, optionUnitPriceRules.optionPriceRuleId))
+        .innerJoin(priceCatalogs, eq(priceCatalogs.id, optionPriceRules.priceCatalogId))
+        .where(and(eq(optionPriceRules.productId, productId), eq(optionPriceRules.active, true), eq(optionPriceRules.isDefault, true), eq(optionUnitPriceRules.active, true), eq(priceCatalogs.active, true), or(eq(priceCatalogs.currencyCode, productCurrency), isNull(priceCatalogs.currencyCode))));
+    const out = [];
+    for (const row of rows) {
+        if (row.price !== null)
+            out.push(row.price);
+    }
+    return out;
+}
+/**
+ * Default loader reads the products row via raw SQL so we don't pull
+ * the products schema into this file (would create a circular import
+ * via the typed schema). The columns we read are stable enough that a
+ * rename would break far more than this.
+ */
+async function defaultLoadProductPricing(db, productId) {
+    // biome-ignore lint/suspicious/noExplicitAny: drizzle's typed sql is overkill for two-column read
+    const dbAny = db;
+    const result = await dbAny.execute(sql `SELECT sell_amount_cents, sell_currency FROM products WHERE id = ${productId} LIMIT 1`);
+    // postgres-js returns rows as an array-like; node-postgres returns `{ rows: [...] }`.
+    const rows = Array.isArray(result) ? result : (result?.rows ?? []);
+    const first = rows[0];
+    if (!first)
+        return { sellAmountCents: null, sellCurrency: null };
+    return {
+        sellAmountCents: first.sell_amount_cents,
+        sellCurrency: first.sell_currency,
+    };
+}
+function toProjectionMap(a) {
+    return new Map([
+        ["priceFromAmountCents", a.priceFromAmountCents],
+        ["priceFromCurrency", a.priceFromCurrency],
+        ["hasPricing", a.hasPricing],
+    ]);
+}
+// Internal exports for unit tests — kept off the public surface.
+export const __test__ = {
+    aggregatePricing,
+    EMPTY_AGGREGATE,
+};

package/dist/service-catalogs.d.ts

@@ -33,8 +33,8 @@ export declare function getPriceCatalogById(db: PostgresJsDatabase, id: string):
 } | null>;
 export declare function createPriceCatalog(db: PostgresJsDatabase, data: CreatePriceCatalogInput): Promise<{
     metadata: Record<string, unknown> | null;
-    id: string;
     name: string;
+    id: string;
     createdAt: Date;
     updatedAt: Date;
     notes: string | null;
@@ -101,8 +101,8 @@ export declare function getPriceScheduleById(db: PostgresJsDatabase, id: string)
 } | null>;
 export declare function createPriceSchedule(db: PostgresJsDatabase, data: CreatePriceScheduleInput): Promise<{
     metadata: Record<string, unknown> | null;
-    id: string;
     name: string;
+    id: string;
     createdAt: Date;
     updatedAt: Date;
     notes: string | null;

package/dist/service-categories.d.ts

@@ -8,7 +8,7 @@ export declare function listPricingCategories(db: PostgresJsDatabase, query: Pri
         unitId: string | null;
         code: string | null;
         name: string;
-        categoryType: "service" | "other" | "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle";
+        categoryType: "service" | "child" | "other" | "adult" | "infant" | "senior" | "group" | "room" | "vehicle";
         seatOccupancy: number;
         groupSize: number | null;
         isAgeQualified: boolean;
@@ -32,7 +32,7 @@ export declare function getPricingCategoryById(db: PostgresJsDatabase, id: strin
     unitId: string | null;
     code: string | null;
     name: string;
-    categoryType: "service" | "other" | "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle";
+    categoryType: "service" | "child" | "other" | "adult" | "infant" | "senior" | "group" | "room" | "vehicle";
     seatOccupancy: number;
     groupSize: number | null;
     isAgeQualified: boolean;
@@ -47,8 +47,8 @@ export declare function getPricingCategoryById(db: PostgresJsDatabase, id: strin
 } | null>;
 export declare function createPricingCategory(db: PostgresJsDatabase, data: CreatePricingCategoryInput): Promise<{
     metadata: Record<string, unknown> | null;
-    id: string;
     name: string;
+    id: string;
     createdAt: Date;
     updatedAt: Date;
     code: string | null;
@@ -56,7 +56,7 @@ export declare function createPricingCategory(db: PostgresJsDatabase, data: Crea
     productId: string | null;
     optionId: string | null;
     unitId: string | null;
-    categoryType: "service" | "other" | "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle";
+    categoryType: "service" | "child" | "other" | "adult" | "infant" | "senior" | "group" | "room" | "vehicle";
     seatOccupancy: number;
     groupSize: number | null;
     isAgeQualified: boolean;
@@ -72,7 +72,7 @@ export declare function updatePricingCategory(db: PostgresJsDatabase, id: string
     unitId: string | null;
     code: string | null;
     name: string;
-    categoryType: "service" | "other" | "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle";
+    categoryType: "service" | "child" | "other" | "adult" | "infant" | "senior" | "group" | "room" | "vehicle";
     seatOccupancy: number;
     groupSize: number | null;
     isAgeQualified: boolean;

package/dist/service-option-rules.d.ts

@@ -1,4 +1,18 @@
+import type { EventBus } from "@voyantjs/core";
 import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type PricingRuleChangeSource } from "./events.js";
+/**
+ * Optional runtime context for pricing-rule mutations. When `eventBus`
+ * is wired the service emits `pricing.rule.changed` after a successful
+ * mutation so the catalog bridge can reindex the affected product.
+ *
+ * Keeping it optional preserves back-compat with existing callers that
+ * don't care about the catalog plane (e.g. data-import scripts).
+ */
+export interface RuleMutationRuntime {
+    eventBus?: EventBus;
+    source?: PricingRuleChangeSource;
+}
 import type { CreateOptionPriceRuleInput, CreateOptionStartTimeRuleInput, CreateOptionUnitPriceRuleInput, CreateOptionUnitTierInput, OptionPriceRuleListQuery, OptionStartTimeRuleListQuery, OptionUnitPriceRuleListQuery, OptionUnitTierListQuery, UpdateOptionPriceRuleInput, UpdateOptionStartTimeRuleInput, UpdateOptionUnitPriceRuleInput, UpdateOptionUnitTierInput } from "./service-shared.js";
 export declare function listOptionPriceRules(db: PostgresJsDatabase, query: OptionPriceRuleListQuery): Promise<{
     data: {
@@ -51,10 +65,10 @@ export declare function getOptionPriceRuleById(db: PostgresJsDatabase, id: strin
     createdAt: Date;
     updatedAt: Date;
 } | null>;
-export declare function createOptionPriceRule(db: PostgresJsDatabase, data: CreateOptionPriceRuleInput): Promise<{
+export declare function createOptionPriceRule(db: PostgresJsDatabase, data: CreateOptionPriceRuleInput, runtime?: RuleMutationRuntime): Promise<{
     metadata: Record<string, unknown> | null;
-    id: string;
     name: string;
+    id: string;
     createdAt: Date;
     updatedAt: Date;
     notes: string | null;
@@ -74,7 +88,7 @@ export declare function createOptionPriceRule(db: PostgresJsDatabase, data: Crea
     maxPerBooking: number | null;
     allPricingCategories: boolean;
 } | null>;
-export declare function updateOptionPriceRule(db: PostgresJsDatabase, id: string, data: UpdateOptionPriceRuleInput): Promise<{
+export declare function updateOptionPriceRule(db: PostgresJsDatabase, id: string, data: UpdateOptionPriceRuleInput, runtime?: RuleMutationRuntime): Promise<{
     id: string;
     productId: string;
     optionId: string;
@@ -97,7 +111,7 @@ export declare function updateOptionPriceRule(db: PostgresJsDatabase, id: string
     createdAt: Date;
     updatedAt: Date;
 } | null>;
-export declare function deleteOptionPriceRule(db: PostgresJsDatabase, id: string): Promise<{
+export declare function deleteOptionPriceRule(db: PostgresJsDatabase, id: string, runtime?: RuleMutationRuntime): Promise<{
     id: string;
 } | null>;
 export declare function listOptionUnitPriceRules(db: PostgresJsDatabase, query: OptionUnitPriceRuleListQuery): Promise<{
@@ -141,7 +155,7 @@ export declare function getOptionUnitPriceRuleById(db: PostgresJsDatabase, id: s
     createdAt: Date;
     updatedAt: Date;
 } | null>;
-export declare function createOptionUnitPriceRule(db: PostgresJsDatabase, data: CreateOptionUnitPriceRuleInput): Promise<{
+export declare function createOptionUnitPriceRule(db: PostgresJsDatabase, data: CreateOptionUnitPriceRuleInput, runtime?: RuleMutationRuntime): Promise<{
     metadata: Record<string, unknown> | null;
     id: string;
     createdAt: Date;
@@ -159,7 +173,7 @@ export declare function createOptionUnitPriceRule(db: PostgresJsDatabase, data:
     minQuantity: number | null;
     maxQuantity: number | null;
 } | null>;
-export declare function updateOptionUnitPriceRule(db: PostgresJsDatabase, id: string, data: UpdateOptionUnitPriceRuleInput): Promise<{
+export declare function updateOptionUnitPriceRule(db: PostgresJsDatabase, id: string, data: UpdateOptionUnitPriceRuleInput, runtime?: RuleMutationRuntime): Promise<{
     id: string;
     optionPriceRuleId: string;
     optionId: string;
@@ -177,7 +191,7 @@ export declare function updateOptionUnitPriceRule(db: PostgresJsDatabase, id: st
     createdAt: Date;
     updatedAt: Date;
 } | null>;
-export declare function deleteOptionUnitPriceRule(db: PostgresJsDatabase, id: string): Promise<{
+export declare function deleteOptionUnitPriceRule(db: PostgresJsDatabase, id: string, runtime?: RuleMutationRuntime): Promise<{
     id: string;
 } | null>;
 export declare function listOptionStartTimeRules(db: PostgresJsDatabase, query: OptionStartTimeRuleListQuery): Promise<{

package/dist/service-option-rules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service-option-rules.d.ts","sourceRoot":"","sources":["../src/service-option-rules.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAQjE,OAAO,KAAK,EACV,0BAA0B,EAC1B,8BAA8B,EAC9B,8BAA8B,EAC9B,yBAAyB,EACzB,wBAAwB,EACxB,4BAA4B,EAC5B,4BAA4B,EAC5B,uBAAuB,EACvB,0BAA0B,EAC1B,8BAA8B,EAC9B,8BAA8B,EAC9B,yBAAyB,EAC1B,MAAM,qBAAqB,CAAA;AAG5B,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BhC;AAED,wBAAsB,sBAAsB,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;UAG9E;AAED,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,kBAAkB,EACtB,IAAI,EAAE,0BAA0B;;;;;;;;;;;;;;;;;;;;;;UAIjC;AAED,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,0BAA0B;;;;;;;;;;;;;;;;;;;;;;UAQjC;AAED,wBAAsB,qBAAqB,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM;;UAM7E;AAED,wBAAsB,wBAAwB,CAC5C,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,4BAA4B;;;;;;;;;;;;;;;;;;;;;;GA0BpC;AAED,wBAAsB,0BAA0B,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM;;;;;;;;;;;;;;;;;UAOlF;AAED,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,kBAAkB,EACtB,IAAI,EAAE,8BAA8B;;;;;;;;;;;;;;;;;UAIrC;AAED,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,8BAA8B;;;;;;;;;;;;;;;;;UAQrC;AAED,wBAAsB,yBAAyB,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM;;UAMjF;AAED,wBAAsB,wBAAwB,CAC5C,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,4BAA4B;;;;;;;;;;;;;;;;;;;GAuBpC;AAED,wBAAsB,0BAA0B,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM;;;;;;;;;;;;;;UAOlF;AAED,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,kBAAkB,EACtB,IAAI,EAAE,8BAA8B;;;;;;;;;;;;;;UAIrC;AAED,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,8BAA8B;;;;;;;;;;;;;;UAQrC;AAED,wBAAsB,yBAAyB,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM;;UAMjF;AAED,wBAAsB,mBAAmB,CAAC,EAAE,EAAE,kBAAkB,EAAE,KAAK,EAAE,uBAAuB;;;;;;;;;;;;;;;;GAoB/F;AAED,wBAAsB,qBAAqB,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM;;;;;;;;;;;UAG7E;AAED,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,kBAAkB,EACtB,IAAI,EAAE,yBAAyB;;;;;;;;;;;UAIhC;AAED,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,yBAAyB;;;;;;;;;;;UAQhC;AAED,wBAAsB,oBAAoB,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM;;UAM5E"}
+{"version":3,"file":"service-option-rules.d.ts","sourceRoot":"","sources":["../src/service-option-rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAG9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EAGL,KAAK,uBAAuB,EAC7B,MAAM,aAAa,CAAA;AAQpB;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,MAAM,CAAC,EAAE,uBAAuB,CAAA;CACjC;AAqBD,OAAO,KAAK,EACV,0BAA0B,EAC1B,8BAA8B,EAC9B,8BAA8B,EAC9B,yBAAyB,EACzB,wBAAwB,EACxB,4BAA4B,EAC5B,4BAA4B,EAC5B,uBAAuB,EACvB,0BAA0B,EAC1B,8BAA8B,EAC9B,8BAA8B,EAC9B,yBAAyB,EAC1B,MAAM,qBAAqB,CAAA;AAG5B,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BhC;AAED,wBAAsB,sBAAsB,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;UAG9E;AAED,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,kBAAkB,EACtB,IAAI,EAAE,0BAA0B,EAChC,OAAO,GAAE,mBAAwB;;;;;;;;;;;;;;;;;;;;;;UAWlC;AAED,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,0BAA0B,EAChC,OAAO,GAAE,mBAAwB;;;;;;;;;;;;;;;;;;;;;;UAgDlC;AAED,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,mBAAwB;;UAyBlC;AAED,wBAAsB,wBAAwB,CAC5C,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,4BAA4B;;;;;;;;;;;;;;;;;;;;;;GA0BpC;AAED,wBAAsB,0BAA0B,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM;;;;;;;;;;;;;;;;;UAOlF;AAsBD,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,kBAAkB,EACtB,IAAI,EAAE,8BAA8B,EACpC,OAAO,GAAE,mBAAwB;;;;;;;;;;;;;;;;;UAwBlC;AAED,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,8BAA8B,EACpC,OAAO,GAAE,mBAAwB;;;;;;;;;;;;;;;;;UAkClC;AAED,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,mBAAwB;;UAoBlC;AAED,wBAAsB,wBAAwB,CAC5C,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,4BAA4B;;;;;;;;;;;;;;;;;;;GAuBpC;AAED,wBAAsB,0BAA0B,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM;;;;;;;;;;;;;;UAOlF;AAED,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,kBAAkB,EACtB,IAAI,EAAE,8BAA8B;;;;;;;;;;;;;;UAIrC;AAED,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,8BAA8B;;;;;;;;;;;;;;UAQrC;AAED,wBAAsB,yBAAyB,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM;;UAMjF;AAED,wBAAsB,mBAAmB,CAAC,EAAE,EAAE,kBAAkB,EAAE,KAAK,EAAE,uBAAuB;;;;;;;;;;;;;;;;GAoB/F;AAED,wBAAsB,qBAAqB,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM;;;;;;;;;;;UAG7E;AAED,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,kBAAkB,EACtB,IAAI,EAAE,yBAAyB;;;;;;;;;;;UAIhC;AAED,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,yBAAyB;;;;;;;;;;;UAQhC;AAED,wBAAsB,oBAAoB,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM;;UAM5E"}

package/dist/service-option-rules.js

@@ -1,5 +1,21 @@
+import { RequestValidationError } from "@voyantjs/hono";
 import { and, asc, desc, eq, sql } from "drizzle-orm";
+import { PRICING_RULE_CHANGED_EVENT, } from "./events.js";
 import { optionPriceRules, optionStartTimeRules, optionUnitPriceRules, optionUnitTiers, } from "./schema.js";
+async function emitRuleChanged(eventBus, payload) {
+    if (!eventBus)
+        return;
+    await eventBus.emit(PRICING_RULE_CHANGED_EVENT, payload, {
+        category: "domain",
+        source: "service",
+    });
+}
+// A `per_booking` rule produces a single flat amount for the whole booking;
+// per-unit prices implicitly assume a per-unit (or per-person) multiplier.
+// The two are contradictory — see #482.
+const PER_BOOKING_REJECTS_UNIT_PRICES_MESSAGE = "Rules with pricingMode = 'per_booking' cannot carry per-unit prices. " +
+    "Use pricingMode = 'per_person' or 'starting_from' for unit-priced rules, " +
+    "or remove the unit prices to keep this rule a flat per-booking amount.";
 import { paginate } from "./service-shared.js";
 export async function listOptionPriceRules(db, query) {
     const conditions = [];
@@ -31,24 +47,87 @@ export async function getOptionPriceRuleById(db, id) {
     const [row] = await db.select().from(optionPriceRules).where(eq(optionPriceRules.id, id)).limit(1);
     return row ?? null;
 }
-export async function createOptionPriceRule(db, data) {
+export async function createOptionPriceRule(db, data, runtime = {}) {
     const [row] = await db.insert(optionPriceRules).values(data).returning();
-    return row ?? null;
+    if (!row)
+        return null;
+    await emitRuleChanged(runtime.eventBus, {
+        productId: row.productId,
+        ruleId: row.id,
+        kind: "option-rule",
+        source: runtime.source ?? "created",
+    });
+    return row;
 }
-export async function updateOptionPriceRule(db, id, data) {
+export async function updateOptionPriceRule(db, id, data, runtime = {}) {
+    if (data.pricingMode === "per_booking") {
+        const [countRow] = await db
+            .select({ count: sql `count(*)::int` })
+            .from(optionUnitPriceRules)
+            .where(eq(optionUnitPriceRules.optionPriceRuleId, id));
+        const unitPriceCount = countRow?.count ?? 0;
+        if (unitPriceCount > 0) {
+            throw new RequestValidationError(PER_BOOKING_REJECTS_UNIT_PRICES_MESSAGE, {
+                ruleId: id,
+                unitPriceCount,
+            });
+        }
+    }
+    // Snapshot the pre-update productId so reassignment (rule moves
+    // between products) reindexes the *previous* product too. Without
+    // this, the projection on the old product keeps a stale MIN that
+    // includes a rule it no longer owns.
+    const [pre] = await db
+        .select({ productId: optionPriceRules.productId })
+        .from(optionPriceRules)
+        .where(eq(optionPriceRules.id, id))
+        .limit(1);
     const [row] = await db
         .update(optionPriceRules)
         .set({ ...data, updatedAt: new Date() })
         .where(eq(optionPriceRules.id, id))
         .returning();
-    return row ?? null;
+    if (!row)
+        return null;
+    await emitRuleChanged(runtime.eventBus, {
+        productId: row.productId,
+        ruleId: row.id,
+        kind: "option-rule",
+        source: runtime.source ?? "updated",
+    });
+    if (pre && pre.productId !== row.productId) {
+        await emitRuleChanged(runtime.eventBus, {
+            productId: pre.productId,
+            ruleId: row.id,
+            kind: "option-rule",
+            source: runtime.source ?? "updated",
+        });
+    }
+    return row;
 }
-export async function deleteOptionPriceRule(db, id) {
+export async function deleteOptionPriceRule(db, id, runtime = {}) {
+    // Snapshot before deletion so the event payload carries productId —
+    // can't read it back from the deleted row.
+    const [snapshot] = await db
+        .select({ productId: optionPriceRules.productId })
+        .from(optionPriceRules)
+        .where(eq(optionPriceRules.id, id))
+        .limit(1);
     const [row] = await db
         .delete(optionPriceRules)
         .where(eq(optionPriceRules.id, id))
         .returning({ id: optionPriceRules.id });
-    return row ?? null;
+    if (!row)
+        return null;
+    if (snapshot) {
+        await emitRuleChanged(runtime.eventBus, {
+            productId: snapshot.productId,
+            ruleId: row.id,
+            kind: "option-rule",
+            source: runtime.source ?? "deleted",
+        });
+    }
+    return row;
 }
 export async function listOptionUnitPriceRules(db, query) {
     const conditions = [];
@@ -81,24 +160,97 @@ export async function getOptionUnitPriceRuleById(db, id) {
         .limit(1);
     return row ?? null;
 }
-export async function createOptionUnitPriceRule(db, data) {
+/**
+ * Look up the productId on an option-unit-rule's parent rule. Used by
+ * the mutation paths to populate the `pricing.rule.changed` payload —
+ * unit rules don't carry productId directly, so we walk through their
+ * parent every time. One small extra query per mutation; pricing
+ * mutations aren't on a hot path so the cost is negligible.
+ */
+async function getProductIdForUnitRule(db, unitRuleId) {
+    const [row] = await db
+        .select({ productId: optionPriceRules.productId })
+        .from(optionUnitPriceRules)
+        .innerJoin(optionPriceRules, eq(optionPriceRules.id, optionUnitPriceRules.optionPriceRuleId))
+        .where(eq(optionUnitPriceRules.id, unitRuleId))
+        .limit(1);
+    return row?.productId ?? null;
+}
+export async function createOptionUnitPriceRule(db, data, runtime = {}) {
+    const [parent] = await db
+        .select({ pricingMode: optionPriceRules.pricingMode, productId: optionPriceRules.productId })
+        .from(optionPriceRules)
+        .where(eq(optionPriceRules.id, data.optionPriceRuleId))
+        .limit(1);
+    if (parent?.pricingMode === "per_booking") {
+        throw new RequestValidationError(PER_BOOKING_REJECTS_UNIT_PRICES_MESSAGE, {
+            ruleId: data.optionPriceRuleId,
+        });
+    }
     const [row] = await db.insert(optionUnitPriceRules).values(data).returning();
-    return row ?? null;
+    if (!row)
+        return null;
+    if (parent) {
+        await emitRuleChanged(runtime.eventBus, {
+            productId: parent.productId,
+            ruleId: row.id,
+            kind: "option-unit-rule",
+            source: runtime.source ?? "created",
+        });
+    }
+    return row;
 }
-export async function updateOptionUnitPriceRule(db, id, data) {
+export async function updateOptionUnitPriceRule(db, id, data, runtime = {}) {
+    // Snapshot the pre-update parent's productId. If the update reassigns
+    // `optionPriceRuleId` to a parent rule under a different product, the
+    // *previous* product also loses this unit-rule from its MIN
+    // candidate set and needs reindexing. Without this snapshot the old
+    // product's `priceFromAmountCents` stays stale.
+    const prevProductId = await getProductIdForUnitRule(db, id);
     const [row] = await db
         .update(optionUnitPriceRules)
         .set({ ...data, updatedAt: new Date() })
         .where(eq(optionUnitPriceRules.id, id))
         .returning();
-    return row ?? null;
+    if (!row)
+        return null;
+    const nextProductId = await getProductIdForUnitRule(db, row.id);
+    if (nextProductId) {
+        await emitRuleChanged(runtime.eventBus, {
+            productId: nextProductId,
+            ruleId: row.id,
+            kind: "option-unit-rule",
+            source: runtime.source ?? "updated",
+        });
+    }
+    if (prevProductId && prevProductId !== nextProductId) {
+        await emitRuleChanged(runtime.eventBus, {
+            productId: prevProductId,
+            ruleId: row.id,
+            kind: "option-unit-rule",
+            source: runtime.source ?? "updated",
+        });
+    }
+    return row;
 }
-export async function deleteOptionUnitPriceRule(db, id) {
+export async function deleteOptionUnitPriceRule(db, id, runtime = {}) {
+    // Snapshot productId before deletion — the row is gone after.
+    const productId = await getProductIdForUnitRule(db, id);
     const [row] = await db
         .delete(optionUnitPriceRules)
         .where(eq(optionUnitPriceRules.id, id))
         .returning({ id: optionUnitPriceRules.id });
-    return row ?? null;
+    if (!row)
+        return null;
+    if (productId) {
+        await emitRuleChanged(runtime.eventBus, {
+            productId,
+            ruleId: row.id,
+            kind: "option-unit-rule",
+            source: runtime.source ?? "deleted",
+        });
+    }
+    return row;
 }
 export async function listOptionStartTimeRules(db, query) {
     const conditions = [];

package/dist/service-policies.d.ts

@@ -33,8 +33,8 @@ export declare function getCancellationPolicyById(db: PostgresJsDatabase, id: st
 } | null>;
 export declare function createCancellationPolicy(db: PostgresJsDatabase, data: CreateCancellationPolicyInput): Promise<{
     metadata: Record<string, unknown> | null;
-    id: string;
     name: string;
+    id: string;
     createdAt: Date;
     updatedAt: Date;
     notes: string | null;

package/dist/service-public.d.ts

@@ -68,7 +68,7 @@ export declare const publicPricingService: {
             startsAt: string | null;
             endsAt: string | null;
             timezone: string;
-            status: "open" | "closed" | "sold_out" | "cancelled";
+            status: "cancelled" | "open" | "closed" | "sold_out";
             unlimited: boolean;
             remainingPax: number | null;
             remainingResources: number | null;

package/dist/validation-public.d.ts

@@ -10,10 +10,10 @@ export declare const publicAvailabilitySnapshotQuerySchema: z.ZodObject<{
     dateFrom: z.ZodOptional<z.ZodString>;
     dateTo: z.ZodOptional<z.ZodString>;
     status: z.ZodOptional<z.ZodEnum<{
+        cancelled: "cancelled";
         open: "open";
         closed: "closed";
         sold_out: "sold_out";
-        cancelled: "cancelled";
     }>>;
     limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
@@ -359,10 +359,10 @@ export declare const publicAvailabilitySlotSchema: z.ZodObject<{
     endsAt: z.ZodNullable<z.ZodString>;
     timezone: z.ZodString;
     status: z.ZodEnum<{
+        cancelled: "cancelled";
         open: "open";
         closed: "closed";
         sold_out: "sold_out";
-        cancelled: "cancelled";
     }>;
     unlimited: z.ZodBoolean;
     remainingPax: z.ZodNullable<z.ZodNumber>;
@@ -386,10 +386,10 @@ export declare const publicAvailabilitySnapshotSchema: z.ZodObject<{
         endsAt: z.ZodNullable<z.ZodString>;
         timezone: z.ZodString;
         status: z.ZodEnum<{
+            cancelled: "cancelled";
             open: "open";
             closed: "closed";
             sold_out: "sold_out";
-            cancelled: "cancelled";
         }>;
         unlimited: z.ZodBoolean;
         remainingPax: z.ZodNullable<z.ZodNumber>;

package/dist/validation-shared.d.ts

@@ -1,9 +1,9 @@
 import { z } from "zod";
 export declare const pricingCategoryTypeSchema: z.ZodEnum<{
     service: "service";
+    child: "child";
     other: "other";
     adult: "adult";
-    child: "child";
     infant: "infant";
     senior: "senior";
     group: "group";

package/dist/validation.d.ts

@@ -7,9 +7,9 @@ export declare const pricingCategoryCoreSchema: z.ZodObject<{
     name: z.ZodString;
     categoryType: z.ZodDefault<z.ZodEnum<{
         service: "service";
+        child: "child";
         other: "other";
         adult: "adult";
-        child: "child";
         infant: "infant";
         senior: "senior";
         group: "group";
@@ -34,9 +34,9 @@ export declare const insertPricingCategorySchema: z.ZodObject<{
     name: z.ZodString;
     categoryType: z.ZodDefault<z.ZodEnum<{
         service: "service";
+        child: "child";
         other: "other";
         adult: "adult";
-        child: "child";
         infant: "infant";
         senior: "senior";
         group: "group";
@@ -61,9 +61,9 @@ export declare const updatePricingCategorySchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     categoryType: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
         service: "service";
+        child: "child";
         other: "other";
         adult: "adult";
-        child: "child";
         infant: "infant";
         senior: "senior";
         group: "group";
@@ -88,9 +88,9 @@ export declare const pricingCategoryListQuerySchema: z.ZodObject<{
     unitId: z.ZodOptional<z.ZodString>;
     categoryType: z.ZodOptional<z.ZodEnum<{
         service: "service";
+        child: "child";
         other: "other";
         adult: "adult";
-        child: "child";
         infant: "infant";
         senior: "senior";
         group: "group";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voyantjs/pricing",
-  "version": "0.28.1",
+  "version": "0.29.0",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
@@ -33,6 +33,11 @@
       "types": "./dist/validation-public.d.ts",
       "import": "./dist/validation-public.js",
       "default": "./dist/validation-public.js"
+    },
+    "./service-catalog-plane-pricing": {
+      "types": "./dist/service-catalog-plane-pricing.d.ts",
+      "import": "./dist/service-catalog-plane-pricing.js",
+      "default": "./dist/service-catalog-plane-pricing.js"
     }
   },
   "dependencies": {
@@ -40,16 +45,16 @@
     "hono": "^4.12.10",
     "rrule": "^2.8.1",
     "zod": "^4.3.6",
-    "@voyantjs/availability": "0.28.1",
-    "@voyantjs/core": "0.28.1",
-    "@voyantjs/db": "0.28.1",
-    "@voyantjs/hono": "0.28.1",
-    "@voyantjs/products": "0.28.1"
+    "@voyantjs/availability": "0.29.0",
+    "@voyantjs/core": "0.29.0",
+    "@voyantjs/db": "0.29.0",
+    "@voyantjs/hono": "0.29.0",
+    "@voyantjs/products": "0.29.0"
   },
   "devDependencies": {
     "typescript": "^6.0.2",
-    "@voyantjs/extras": "0.28.1",
-    "@voyantjs/facilities": "0.28.1",
+    "@voyantjs/extras": "0.29.0",
+    "@voyantjs/facilities": "0.29.0",
     "@voyantjs/voyant-typescript-config": "0.1.0"
   },
   "files": [