@voyantjs/products 0.20.0 → 0.21.1

package/dist/routes.js

@@ -1,6 +1,7 @@
 import { parseJsonBody, parseQuery, RequestValidationError, requireUserId } from "@voyantjs/hono";
 import { Hono } from "hono";
 import { z } from "zod";
+import { emitProductContentChanged } from "./events.js";
 import { productsService } from "./service.js";
 import { destinationListQuerySchema, destinationTranslationListQuerySchema, duplicateItinerarySchema, insertDaySchema, insertDayServiceSchema, insertDestinationSchema, insertDestinationTranslationSchema, insertItinerarySchema, insertOptionUnitSchema, insertOptionUnitTranslationSchema, insertProductActivationSettingSchema, insertProductCapabilitySchema, insertProductCategorySchema, insertProductDeliveryFormatSchema, insertProductDestinationSchema, insertProductFaqSchema, insertProductFeatureSchema, insertProductLocationSchema, insertProductMediaSchema, insertProductNoteSchema, insertProductOptionSchema, insertProductOptionTranslationSchema, insertProductSchema, insertProductTagSchema, insertProductTicketSettingSchema, insertProductTranslationSchema, insertProductTypeSchema, insertProductVisibilitySettingSchema, insertVersionSchema, optionUnitListQuerySchema, optionUnitTranslationListQuerySchema, productActivationSettingListQuerySchema, productAggregatesQuerySchema, productCapabilityListQuerySchema, productCategoryListQuerySchema, productDeliveryFormatListQuerySchema, productDestinationListQuerySchema, productFaqListQuerySchema, productFeatureListQuerySchema, productListQuerySchema, productLocationListQuerySchema, productMediaListQuerySchema, productOptionListQuerySchema, productOptionTranslationListQuerySchema, productTagListQuerySchema, productTicketSettingListQuerySchema, productTranslationListQuerySchema, productTypeListQuerySchema, productVisibilitySettingListQuerySchema, reorderProductMediaSchema, updateDaySchema, updateDayServiceSchema, updateDestinationSchema, updateDestinationTranslationSchema, updateItinerarySchema, updateOptionUnitSchema, updateOptionUnitTranslationSchema, updateProductActivationSettingSchema, updateProductCapabilitySchema, updateProductCategorySchema, updateProductDeliveryFormatSchema, updateProductFaqSchema, updateProductFeatureSchema, updateProductLocationSchema, updateProductMediaSchema, updateProductOptionSchema, updateProductOptionTranslationSchema, updateProductSchema, updateProductTagSchema, updateProductTicketSettingSchema, updateProductTranslationSchema, updateProductTypeSchema, updateProductVisibilitySettingSchema, upsertProductBrochureSchema, } from "./validation.js";
 // ==========================================================================
@@ -198,10 +199,12 @@ export const productRoutes = new Hono()
     return c.json({ data: row });
 })
     .post("/:id/features", async (c) => {
-    const row = await productsService.createFeature(c.get("db"), c.req.param("id"), await parseJsonBody(c, insertProductFeatureSchema));
+    const productId = c.req.param("id");
+    const row = await productsService.createFeature(c.get("db"), productId, await parseJsonBody(c, insertProductFeatureSchema));
     if (!row) {
         return c.json({ error: "Product not found" }, 404);
     }
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "feature" });
     return c.json({ data: row }, 201);
 })
     .patch("/features/:id", async (c) => {
@@ -209,6 +212,9 @@ export const productRoutes = new Hono()
     if (!row) {
         return c.json({ error: "Product feature not found" }, 404);
     }
+    if (row.productId) {
+        await emitProductContentChanged(c.get("eventBus"), { id: row.productId, axis: "feature" });
+    }
     return c.json({ data: row });
 })
     .delete("/features/:id", async (c) => {
@@ -216,6 +222,9 @@ export const productRoutes = new Hono()
     if (!row) {
         return c.json({ error: "Product feature not found" }, 404);
     }
+    if ("productId" in row && typeof row.productId === "string") {
+        await emitProductContentChanged(c.get("eventBus"), { id: row.productId, axis: "feature" });
+    }
     return c.json({ success: true }, 200);
 })
     .get("/faqs", async (c) => {
@@ -230,10 +239,12 @@ export const productRoutes = new Hono()
     return c.json({ data: row });
 })
     .post("/:id/faqs", async (c) => {
-    const row = await productsService.createFaq(c.get("db"), c.req.param("id"), await parseJsonBody(c, insertProductFaqSchema));
+    const productId = c.req.param("id");
+    const row = await productsService.createFaq(c.get("db"), productId, await parseJsonBody(c, insertProductFaqSchema));
     if (!row) {
         return c.json({ error: "Product not found" }, 404);
     }
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "faq" });
     return c.json({ data: row }, 201);
 })
     .patch("/faqs/:id", async (c) => {
@@ -241,6 +252,9 @@ export const productRoutes = new Hono()
     if (!row) {
         return c.json({ error: "Product FAQ not found" }, 404);
     }
+    if (row.productId) {
+        await emitProductContentChanged(c.get("eventBus"), { id: row.productId, axis: "faq" });
+    }
     return c.json({ data: row });
 })
     .delete("/faqs/:id", async (c) => {
@@ -248,6 +262,9 @@ export const productRoutes = new Hono()
     if (!row) {
         return c.json({ error: "Product FAQ not found" }, 404);
     }
+    if ("productId" in row && typeof row.productId === "string") {
+        await emitProductContentChanged(c.get("eventBus"), { id: row.productId, axis: "faq" });
+    }
     return c.json({ success: true }, 200);
 })
     .get("/locations", async (c) => {
@@ -262,10 +279,12 @@ export const productRoutes = new Hono()
     return c.json({ data: row });
 })
     .post("/:id/locations", async (c) => {
-    const row = await productsService.createLocation(c.get("db"), c.req.param("id"), await parseJsonBody(c, insertProductLocationSchema));
+    const productId = c.req.param("id");
+    const row = await productsService.createLocation(c.get("db"), productId, await parseJsonBody(c, insertProductLocationSchema));
     if (!row) {
         return c.json({ error: "Product not found" }, 404);
     }
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "location" });
     return c.json({ data: row }, 201);
 })
     .patch("/locations/:id", async (c) => {
@@ -273,6 +292,9 @@ export const productRoutes = new Hono()
     if (!row) {
         return c.json({ error: "Product location not found" }, 404);
     }
+    if (row.productId) {
+        await emitProductContentChanged(c.get("eventBus"), { id: row.productId, axis: "location" });
+    }
     return c.json({ data: row });
 })
     .delete("/locations/:id", async (c) => {
@@ -280,6 +302,9 @@ export const productRoutes = new Hono()
     if (!row) {
         return c.json({ error: "Product location not found" }, 404);
     }
+    if ("productId" in row && typeof row.productId === "string") {
+        await emitProductContentChanged(c.get("eventBus"), { id: row.productId, axis: "location" });
+    }
     return c.json({ success: true }, 200);
 })
     .get("/destinations", async (c) => {
@@ -341,17 +366,21 @@ export const productRoutes = new Hono()
     return c.json(await productsService.listProductDestinations(c.get("db"), query));
 })
     .post("/:id/destinations", async (c) => {
-    const row = await productsService.assignProductDestination(c.get("db"), c.req.param("id"), await parseJsonBody(c, insertProductDestinationSchema));
+    const productId = c.req.param("id");
+    const row = await productsService.assignProductDestination(c.get("db"), productId, await parseJsonBody(c, insertProductDestinationSchema));
     if (!row) {
         return c.json({ error: "Product or destination not found" }, 404);
     }
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "destination" });
     return c.json({ data: row }, 201);
 })
     .delete("/:id/destinations/:destinationId", async (c) => {
-    const row = await productsService.removeProductDestination(c.get("db"), c.req.param("id"), c.req.param("destinationId"));
+    const productId = c.req.param("id");
+    const row = await productsService.removeProductDestination(c.get("db"), productId, c.req.param("destinationId"));
     if (!row) {
         return c.json({ error: "Product destination link not found" }, 404);
     }
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "destination" });
     return c.json({ success: true }, 200);
 })
     // ==========================================================================
@@ -372,10 +401,12 @@ export const productRoutes = new Hono()
 })
     // POST /:id/options — Create option for product
     .post("/:id/options", async (c) => {
-    const row = await productsService.createOption(c.get("db"), c.req.param("id"), await parseJsonBody(c, insertProductOptionSchema));
+    const productId = c.req.param("id");
+    const row = await productsService.createOption(c.get("db"), productId, await parseJsonBody(c, insertProductOptionSchema));
     if (!row) {
         return c.json({ error: "Product not found" }, 404);
     }
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "option" });
     return c.json({ data: row }, 201);
 })
     // PATCH /options/:optionId — Update option
@@ -384,6 +415,9 @@ export const productRoutes = new Hono()
     if (!row) {
         return c.json({ error: "Product option not found" }, 404);
     }
+    if (row.productId) {
+        await emitProductContentChanged(c.get("eventBus"), { id: row.productId, axis: "option" });
+    }
     return c.json({ data: row });
 })
     // DELETE /options/:optionId — Delete option
@@ -392,6 +426,9 @@ export const productRoutes = new Hono()
     if (!row) {
         return c.json({ error: "Product option not found" }, 404);
     }
+    if ("productId" in row && typeof row.productId === "string") {
+        await emitProductContentChanged(c.get("eventBus"), { id: row.productId, axis: "option" });
+    }
     return c.json({ success: true }, 200);
 })
     // ==========================================================================
@@ -449,10 +486,12 @@ export const productRoutes = new Hono()
     return c.json({ data: row });
 })
     .post("/:id/translations", async (c) => {
-    const row = await productsService.createProductTranslation(c.get("db"), c.req.param("id"), await parseJsonBody(c, insertProductTranslationSchema));
+    const productId = c.req.param("id");
+    const row = await productsService.createProductTranslation(c.get("db"), productId, await parseJsonBody(c, insertProductTranslationSchema));
     if (!row) {
         return c.json({ error: "Product not found" }, 404);
     }
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "translation" });
     return c.json({ data: row }, 201);
 })
     .patch("/translations/:translationId", async (c) => {
@@ -460,6 +499,12 @@ export const productRoutes = new Hono()
     if (!row) {
         return c.json({ error: "Product translation not found" }, 404);
     }
+    if (row.productId) {
+        await emitProductContentChanged(c.get("eventBus"), {
+            id: row.productId,
+            axis: "translation",
+        });
+    }
     return c.json({ data: row });
 })
     .delete("/translations/:translationId", async (c) => {
@@ -467,6 +512,12 @@ export const productRoutes = new Hono()
     if (!row) {
         return c.json({ error: "Product translation not found" }, 404);
     }
+    if ("productId" in row && typeof row.productId === "string") {
+        await emitProductContentChanged(c.get("eventBus"), {
+            id: row.productId,
+            axis: "translation",
+        });
+    }
     return c.json({ success: true }, 200);
 })
     .get("/option-translations", async (c) => {
@@ -730,6 +781,7 @@ export const productRoutes = new Hono()
         return c.json({ error: "Product not found" }, 404);
     }
     await c.get("eventBus")?.emit("product.updated", { id: row.id });
+    await emitProductContentChanged(c.get("eventBus"), { id: row.id, axis: "product" });
     return c.json({ data: row });
 })
     // DELETE /:id — Delete product
@@ -797,26 +849,32 @@ export const productRoutes = new Hono()
 })
     // POST /:id/days — Add day to product
     .post("/:id/days", async (c) => {
-    const row = await productsService.createDay(c.get("db"), c.req.param("id"), await parseJsonBody(c, insertDaySchema));
+    const productId = c.req.param("id");
+    const row = await productsService.createDay(c.get("db"), productId, await parseJsonBody(c, insertDaySchema));
     if (!row) {
         return c.json({ error: "Product not found" }, 404);
     }
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "day" });
     return c.json({ data: row }, 201);
 })
     // PATCH /:id/days/:dayId — Update day
     .patch("/:id/days/:dayId", async (c) => {
+    const productId = c.req.param("id");
     const row = await productsService.updateDay(c.get("db"), c.req.param("dayId"), await parseJsonBody(c, updateDaySchema));
     if (!row) {
         return c.json({ error: "Day not found" }, 404);
     }
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "day" });
     return c.json({ data: row });
 })
     // DELETE /:id/days/:dayId — Delete day
     .delete("/:id/days/:dayId", async (c) => {
+    const productId = c.req.param("id");
     const row = await productsService.deleteDay(c.get("db"), c.req.param("dayId"));
     if (!row) {
         return c.json({ error: "Day not found" }, 404);
     }
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "day" });
     return c.json({ success: true }, 200);
 })
     // ==========================================================================
@@ -830,26 +888,32 @@ export const productRoutes = new Hono()
 })
     // POST /:id/days/:dayId/services — Add service to day
     .post("/:id/days/:dayId/services", async (c) => {
-    const row = await productsService.createDayService(c.get("db"), c.req.param("id"), c.req.param("dayId"), await parseJsonBody(c, insertDayServiceSchema));
+    const productId = c.req.param("id");
+    const row = await productsService.createDayService(c.get("db"), productId, c.req.param("dayId"), await parseJsonBody(c, insertDayServiceSchema));
     if (!row) {
         return c.json({ error: "Day not found" }, 404);
     }
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "day" });
     return c.json({ data: row }, 201);
 })
     // PATCH /:id/days/:dayId/services/:serviceId — Update service
     .patch("/:id/days/:dayId/services/:serviceId", async (c) => {
-    const row = await productsService.updateDayService(c.get("db"), c.req.param("id"), c.req.param("serviceId"), await parseJsonBody(c, updateDayServiceSchema));
+    const productId = c.req.param("id");
+    const row = await productsService.updateDayService(c.get("db"), productId, c.req.param("serviceId"), await parseJsonBody(c, updateDayServiceSchema));
     if (!row) {
         return c.json({ error: "Service not found" }, 404);
     }
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "day" });
     return c.json({ data: row });
 })
     // DELETE /:id/days/:dayId/services/:serviceId — Delete service
     .delete("/:id/days/:dayId/services/:serviceId", async (c) => {
-    const row = await productsService.deleteDayService(c.get("db"), c.req.param("id"), c.req.param("serviceId"));
+    const productId = c.req.param("id");
+    const row = await productsService.deleteDayService(c.get("db"), productId, c.req.param("serviceId"));
     if (!row) {
         return c.json({ error: "Service not found" }, 404);
     }
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "day" });
     return c.json({ success: true }, 200);
 })
     // ==========================================================================
@@ -952,16 +1016,20 @@ export const productRoutes = new Hono()
 })
     // POST /:id/media — Create media for product
     .post("/:id/media", async (c) => {
-    const row = await productsService.createMedia(c.get("db"), c.req.param("id"), await parseJsonBody(c, insertProductMediaSchema));
+    const productId = c.req.param("id");
+    const row = await productsService.createMedia(c.get("db"), productId, await parseJsonBody(c, insertProductMediaSchema));
     if (!row) {
         return c.json({ error: "Product not found or invalid dayId" }, 404);
     }
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "media" });
     return c.json({ data: row }, 201);
 })
     // POST /:id/media/reorder — Batch reorder media
     .post("/:id/media/reorder", async (c) => {
+    const productId = c.req.param("id");
     const data = await parseJsonBody(c, reorderProductMediaSchema);
     const results = await productsService.reorderMedia(c.get("db"), data);
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "media" });
     return c.json({ data: results });
 })
     // GET /:id/days/:dayId/media — List day media
@@ -974,14 +1042,16 @@ export const productRoutes = new Hono()
 })
     // POST /:id/days/:dayId/media — Create day media
     .post("/:id/days/:dayId/media", async (c) => {
+    const productId = c.req.param("id");
     const body = await parseJsonBody(c, insertProductMediaSchema);
-    const row = await productsService.createMedia(c.get("db"), c.req.param("id"), {
+    const row = await productsService.createMedia(c.get("db"), productId, {
         ...body,
         dayId: c.req.param("dayId"),
     });
     if (!row) {
         return c.json({ error: "Product or day not found" }, 404);
     }
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "media" });
     return c.json({ data: row }, 201);
 })
     // ==========================================================================

package/dist/schema-core.d.ts

@@ -257,6 +257,23 @@ export declare const products: import("drizzle-orm/pg-core").PgTableWithColumns<
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        supplierId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "supplier_id";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         startDate: import("drizzle-orm/pg-core").PgColumn<{
             name: "start_date";
             tableName: "products";
@@ -325,6 +342,40 @@ export declare const products: import("drizzle-orm/pg-core").PgTableWithColumns<
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        taxClassId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tax_class_id";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        customerPaymentPolicy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "customer_payment_policy";
+            tableName: "products";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         tags: import("drizzle-orm/pg-core").PgColumn<{
             name: "tags";
             tableName: "products";
@@ -690,7 +741,7 @@ export declare const optionUnits: import("drizzle-orm/pg-core").PgTableWithColum
             tableName: "option_units";
             dataType: "string";
             columnType: "PgEnumColumn";
-            data: "service" | "other" | "person" | "group" | "room" | "vehicle";
+            data: "service" | "other" | "group" | "person" | "room" | "vehicle";
             driverParam: string;
             notNull: true;
             hasDefault: true;
@@ -894,4 +945,192 @@ export declare const optionUnits: import("drizzle-orm/pg-core").PgTableWithColum
 }>;
 export type OptionUnit = typeof optionUnits.$inferSelect;
 export type NewOptionUnit = typeof optionUnits.$inferInsert;
+/**
+ * Per-product per-occupancy rate tiers for non-cruise verticals.
+ * Cruises keep the specialized `cruise_prices` table; everyone else
+ * uses this. Per booking-journey-architecture §9.
+ *
+ * `tier_pax` is the occupancy count the rate applies to (1-supp, 2-default,
+ * 3-share, 4). Falls back to `option_unit_tiers` (quantity-based, not
+ * occupancy-based) when no occupancy tier exists.
+ */
+export declare const productPaxPricingTiers: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "product_pax_pricing_tiers";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "product_pax_pricing_tiers";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        productId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "product_pax_pricing_tiers";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        optionUnitId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "product_pax_pricing_tiers";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tierPax: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tier_pax";
+            tableName: "product_pax_pricing_tiers";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        pricePerPaxCents: import("drizzle-orm/pg-core").PgColumn<{
+            name: "price_per_pax_cents";
+            tableName: "product_pax_pricing_tiers";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        promoPricePerPaxCents: import("drizzle-orm/pg-core").PgColumn<{
+            name: "promo_price_per_pax_cents";
+            tableName: "product_pax_pricing_tiers";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        effectiveFrom: import("drizzle-orm/pg-core").PgColumn<{
+            name: "effective_from";
+            tableName: "product_pax_pricing_tiers";
+            dataType: "string";
+            columnType: "PgDateString";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        effectiveTo: import("drizzle-orm/pg-core").PgColumn<{
+            name: "effective_to";
+            tableName: "product_pax_pricing_tiers";
+            dataType: "string";
+            columnType: "PgDateString";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "product_pax_pricing_tiers";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "product_pax_pricing_tiers";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type ProductPaxPricingTier = typeof productPaxPricingTiers.$inferSelect;
+export type NewProductPaxPricingTier = typeof productPaxPricingTiers.$inferInsert;
 //# sourceMappingURL=schema-core.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"schema-core.d.ts","sourceRoot":"","sources":["../src/schema-core.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4CpB,CAAA;AAED,MAAM,MAAM,OAAO,GAAG,OAAO,QAAQ,CAAC,YAAY,CAAA;AAClD,MAAM,MAAM,UAAU,GAAG,OAAO,QAAQ,CAAC,YAAY,CAAA;AAErD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyB1B,CAAA;AAED,MAAM,MAAM,aAAa,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA;AAC9D,MAAM,MAAM,gBAAgB,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA;AAEjE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BvB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,OAAO,WAAW,CAAC,YAAY,CAAA;AACxD,MAAM,MAAM,aAAa,GAAG,OAAO,WAAW,CAAC,YAAY,CAAA"}
+{"version":3,"file":"schema-core.d.ts","sourceRoot":"","sources":["../src/schema-core.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgEpB,CAAA;AAED,MAAM,MAAM,OAAO,GAAG,OAAO,QAAQ,CAAC,YAAY,CAAA;AAClD,MAAM,MAAM,UAAU,GAAG,OAAO,QAAQ,CAAC,YAAY,CAAA;AAErD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyB1B,CAAA;AAED,MAAM,MAAM,aAAa,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA;AAC9D,MAAM,MAAM,gBAAgB,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA;AAEjE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BvB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,OAAO,WAAW,CAAC,YAAY,CAAA;AACxD,MAAM,MAAM,aAAa,GAAG,OAAO,WAAW,CAAC,YAAY,CAAA;AAE3D;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBlC,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,OAAO,sBAAsB,CAAC,YAAY,CAAA;AAC9E,MAAM,MAAM,wBAAwB,GAAG,OAAO,sBAAsB,CAAC,YAAY,CAAA"}

package/dist/schema-core.js

@@ -17,16 +17,35 @@ export const products = pgTable("products", {
     costAmountCents: integer("cost_amount_cents"),
     marginPercent: integer("margin_percent"),
     facilityId: text("facility_id"),
+    supplierId: text("supplier_id"),
     startDate: date("start_date"),
     endDate: date("end_date"),
     pax: integer("pax"),
     productTypeId: text("product_type_id"),
+    /**
+     * Per-product tax class — drives the engine's tax computation at
+     * quote time. Plain text (no FK) since `tax_classes` lives in
+     * @voyantjs/finance and cross-domain refs go through the link
+     * service per schema-discipline. Default null → falls through to a
+     * market-level default. Per booking-journey-architecture §9.
+     */
+    taxClassId: text("tax_class_id"),
+    /**
+     * Per-listing customer payment policy override. Wins over the
+     * product's category and supplier policies in the cascade. Shape
+     * mirrors `PaymentPolicy` from `@voyantjs/finance`.
+     *
+     * `null` means "inherit from category / supplier / operator
+     * default" — most products leave this empty.
+     */
+    customerPaymentPolicy: jsonb("customer_payment_policy"),
     tags: jsonb("tags").$type().default([]),
     createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
     updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
 }, (table) => [
     index("idx_products_status").on(table.status),
     index("idx_products_facility").on(table.facilityId),
+    index("idx_products_supplier").on(table.supplierId),
     index("idx_products_product_type").on(table.productTypeId),
     index("idx_products_status_created").on(table.status, table.createdAt),
     index("idx_products_booking_mode_created").on(table.bookingMode, table.createdAt),
@@ -34,6 +53,7 @@ export const products = pgTable("products", {
     index("idx_products_visibility_created").on(table.visibility, table.createdAt),
     index("idx_products_activated_created").on(table.activated, table.createdAt),
     index("idx_products_facility_created").on(table.facilityId, table.createdAt),
+    index("idx_products_supplier_created").on(table.supplierId, table.createdAt),
     index("idx_products_product_type_created").on(table.productTypeId, table.createdAt),
     index("idx_products_public_created").on(table.status, table.activated, table.visibility, table.createdAt),
 ]);
@@ -85,3 +105,32 @@ export const optionUnits = pgTable("option_units", {
     index("idx_option_units_type").on(table.unitType),
     uniqueIndex("uidx_option_units_option_code").on(table.optionId, table.code),
 ]);
+/**
+ * Per-product per-occupancy rate tiers for non-cruise verticals.
+ * Cruises keep the specialized `cruise_prices` table; everyone else
+ * uses this. Per booking-journey-architecture §9.
+ *
+ * `tier_pax` is the occupancy count the rate applies to (1-supp, 2-default,
+ * 3-share, 4). Falls back to `option_unit_tiers` (quantity-based, not
+ * occupancy-based) when no occupancy tier exists.
+ */
+export const productPaxPricingTiers = pgTable("product_pax_pricing_tiers", {
+    id: typeId("product_pax_pricing_tiers"),
+    productId: typeIdRef("product_id")
+        .notNull()
+        .references(() => products.id, { onDelete: "cascade" }),
+    optionUnitId: typeIdRef("option_unit_id").references(() => optionUnits.id, {
+        onDelete: "cascade",
+    }),
+    tierPax: integer("tier_pax").notNull(),
+    pricePerPaxCents: integer("price_per_pax_cents").notNull(),
+    promoPricePerPaxCents: integer("promo_price_per_pax_cents"),
+    effectiveFrom: date("effective_from"),
+    effectiveTo: date("effective_to"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_pax_tiers_product").on(table.productId),
+    index("idx_pax_tiers_unit").on(table.optionUnitId),
+    uniqueIndex("uidx_pax_tiers_unit_pax").on(table.optionUnitId, table.tierPax),
+]);