@voyantjs/pricing 0.3.0 → 0.4.0

package/dist/index.d.ts

@@ -2,6 +2,9 @@ import type { Module } from "@voyantjs/core";
 import type { HonoModule } from "@voyantjs/hono/module";
 import { pricingService } from "./service.js";
 export type { PricingRoutes } from "./routes.js";
+export type { PublicPricingRoutes } from "./routes-public.js";
+export { publicPricingRoutes } from "./routes-public.js";
+export { publicPricingService } from "./service-public.js";
 export declare const pricingModule: Module;
 export declare const pricingHonoModule: HonoModule;
 export type { CancellationPolicy, CancellationPolicyRule, DropoffPriceRule, ExtraPriceRule, NewCancellationPolicy, NewCancellationPolicyRule, NewDropoffPriceRule, NewExtraPriceRule, NewOptionPriceRule, NewOptionStartTimeRule, NewOptionUnitPriceRule, NewOptionUnitTier, NewPickupPriceRule, NewPriceCatalog, NewPriceSchedule, NewPricingCategory, NewPricingCategoryDependency, OptionPriceRule, OptionStartTimeRule, OptionUnitPriceRule, OptionUnitTier, PickupPriceRule, PriceCatalog, PriceSchedule, PricingCategory, PricingCategoryDependency, } from "./schema.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAGvD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAE7C,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,aAAa,EAAE,MAE3B,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,UAG/B,CAAA;AAED,YAAY,EACV,kBAAkB,EAClB,sBAAsB,EACtB,gBAAgB,EAChB,cAAc,EACd,qBAAqB,EACrB,yBAAyB,EACzB,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,EACtB,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,4BAA4B,EAC5B,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,eAAe,EACf,YAAY,EACZ,aAAa,EACb,eAAe,EACf,yBAAyB,GAC1B,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,oBAAoB,EACpB,uBAAuB,EACvB,0BAA0B,EAC1B,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACrB,2BAA2B,EAC3B,oBAAoB,EACpB,oBAAoB,EACpB,yBAAyB,EACzB,eAAe,EACf,gBAAgB,EAChB,uBAAuB,EACvB,aAAa,EACb,oBAAoB,EACpB,cAAc,EACd,iBAAiB,EACjB,2BAA2B,EAC3B,uBAAuB,EACvB,yBAAyB,GAC1B,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,sBAAsB,EACtB,4BAA4B,EAC5B,iCAAiC,EACjC,qCAAqC,EACrC,4BAA4B,EAC5B,+BAA+B,EAC/B,6BAA6B,EAC7B,kCAAkC,EAClC,8BAA8B,EAC9B,4BAA4B,EAC5B,0BAA0B,EAC1B,2BAA2B,EAC3B,+BAA+B,EAC/B,+BAA+B,EAC/B,0BAA0B,EAC1B,2BAA2B,EAC3B,wBAAwB,EACxB,yBAAyB,EACzB,qCAAqC,EACrC,2BAA2B,EAC3B,8BAA8B,EAC9B,uBAAuB,EACvB,kCAAkC,EAClC,6BAA6B,EAC7B,kCAAkC,EAClC,2BAA2B,EAC3B,6BAA6B,EAC7B,8BAA8B,EAC9B,yBAAyB,EACzB,2BAA2B,EAC3B,sBAAsB,EACtB,4BAA4B,EAC5B,wCAAwC,EACxC,8BAA8B,EAC9B,yBAAyB,EACzB,2BAA2B,EAC3B,kCAAkC,EAClC,8BAA8B,EAC9B,4BAA4B,EAC5B,0BAA0B,EAC1B,2BAA2B,EAC3B,+BAA+B,EAC/B,+BAA+B,EAC/B,0BAA0B,EAC1B,2BAA2B,EAC3B,wBAAwB,EACxB,yBAAyB,EACzB,qCAAqC,EACrC,2BAA2B,GAC5B,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,cAAc,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAGvD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAE7C,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAE1D,eAAO,MAAM,aAAa,EAAE,MAE3B,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,UAK/B,CAAA;AAED,YAAY,EACV,kBAAkB,EAClB,sBAAsB,EACtB,gBAAgB,EAChB,cAAc,EACd,qBAAqB,EACrB,yBAAyB,EACzB,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,EACtB,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,4BAA4B,EAC5B,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,eAAe,EACf,YAAY,EACZ,aAAa,EACb,eAAe,EACf,yBAAyB,GAC1B,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,oBAAoB,EACpB,uBAAuB,EACvB,0BAA0B,EAC1B,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACrB,2BAA2B,EAC3B,oBAAoB,EACpB,oBAAoB,EACpB,yBAAyB,EACzB,eAAe,EACf,gBAAgB,EAChB,uBAAuB,EACvB,aAAa,EACb,oBAAoB,EACpB,cAAc,EACd,iBAAiB,EACjB,2BAA2B,EAC3B,uBAAuB,EACvB,yBAAyB,GAC1B,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,sBAAsB,EACtB,4BAA4B,EAC5B,iCAAiC,EACjC,qCAAqC,EACrC,4BAA4B,EAC5B,+BAA+B,EAC/B,6BAA6B,EAC7B,kCAAkC,EAClC,8BAA8B,EAC9B,4BAA4B,EAC5B,0BAA0B,EAC1B,2BAA2B,EAC3B,+BAA+B,EAC/B,+BAA+B,EAC/B,0BAA0B,EAC1B,2BAA2B,EAC3B,wBAAwB,EACxB,yBAAyB,EACzB,qCAAqC,EACrC,2BAA2B,EAC3B,8BAA8B,EAC9B,uBAAuB,EACvB,kCAAkC,EAClC,6BAA6B,EAC7B,kCAAkC,EAClC,2BAA2B,EAC3B,6BAA6B,EAC7B,8BAA8B,EAC9B,yBAAyB,EACzB,2BAA2B,EAC3B,sBAAsB,EACtB,4BAA4B,EAC5B,wCAAwC,EACxC,8BAA8B,EAC9B,yBAAyB,EACzB,2BAA2B,EAC3B,kCAAkC,EAClC,8BAA8B,EAC9B,4BAA4B,EAC5B,0BAA0B,EAC1B,2BAA2B,EAC3B,+BAA+B,EAC/B,+BAA+B,EAC/B,0BAA0B,EAC1B,2BAA2B,EAC3B,wBAAwB,EACxB,yBAAyB,EACzB,qCAAqC,EACrC,2BAA2B,GAC5B,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/index.js

@@ -1,10 +1,15 @@
 import { pricingRoutes } from "./routes.js";
+import { publicPricingRoutes } from "./routes-public.js";
 import { pricingService } from "./service.js";
+export { publicPricingRoutes } from "./routes-public.js";
+export { publicPricingService } from "./service-public.js";
 export const pricingModule = {
     name: "pricing",
 };
 export const pricingHonoModule = {
     module: pricingModule,
+    adminRoutes: pricingRoutes,
+    publicRoutes: publicPricingRoutes,
     routes: pricingRoutes,
 };
 export { addonPricingModeEnum, cancellationChargeTypeEnum, cancellationPolicies, cancellationPolicyRules, cancellationPolicyTypeEnum, dropoffPriceRules, extraPriceRules, optionPriceRules, optionPricingModeEnum, optionStartTimeRuleModeEnum, optionStartTimeRules, optionUnitPriceRules, optionUnitPricingModeEnum, optionUnitTiers, pickupPriceRules, priceAdjustmentTypeEnum, priceCatalogs, priceCatalogTypeEnum, priceSchedules, pricingCategories, pricingCategoryDependencies, pricingCategoryTypeEnum, pricingDependencyTypeEnum, } from "./schema.js";

package/dist/routes-public.d.ts

@@ -0,0 +1,136 @@
+import { type Env } from "./routes-shared.js";
+export declare const publicPricingRoutes: import("hono/hono-base").HonoBase<Env, {
+    "/products/:productId/pricing": {
+        $get: {
+            input: {
+                param: {
+                    productId: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    productId: string;
+                };
+            };
+            output: {
+                data: {
+                    productId: string;
+                    catalog: {
+                        currencyCode: string | null;
+                        id: string;
+                        code: string;
+                        name: string;
+                    };
+                    options: {
+                        id: string;
+                        name: string;
+                        description: string | null;
+                        status: "active" | "draft" | "archived";
+                        isDefault: boolean;
+                        bookingMode: "other" | "date" | "open" | "date_time" | "stay" | "transfer" | "itinerary";
+                        capacityMode: "on_request" | "free_sale" | "limited";
+                        pricingRules: {
+                            id: string;
+                            name: string;
+                            description: string | null;
+                            pricingMode: "per_person" | "per_booking" | "starting_from" | "free" | "on_request";
+                            baseSellAmountCents: number | null;
+                            minPerBooking: number | null;
+                            maxPerBooking: number | null;
+                            isDefault: boolean;
+                            cancellationPolicyId: string | null;
+                            unitPrices: {
+                                id: string;
+                                unitId: string;
+                                unitName: string;
+                                unitType: "group" | "room" | "vehicle" | "service" | "other" | "person";
+                                pricingMode: "per_person" | "per_booking" | "free" | "on_request" | "per_unit" | "included";
+                                sellAmountCents: number | null;
+                                minQuantity: number | null;
+                                maxQuantity: number | null;
+                                pricingCategoryId: string | null;
+                                sortOrder: number;
+                                tiers: {
+                                    id: string;
+                                    minQuantity: number;
+                                    maxQuantity: number | null;
+                                    sellAmountCents: number | null;
+                                    sortOrder: number;
+                                }[];
+                            }[];
+                            startTimeAdjustments: {
+                                id: string;
+                                startTimeId: string;
+                                label: string | null;
+                                startTimeLocal: string;
+                                ruleMode: "included" | "excluded" | "override" | "adjustment";
+                                adjustmentType: "fixed" | "percentage" | null;
+                                sellAdjustmentCents: number | null;
+                                adjustmentBasisPoints: number | null;
+                            }[];
+                        }[];
+                    }[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/products/:productId/availability": {
+        $get: {
+            input: {
+                param: {
+                    productId: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    productId: string;
+                };
+            };
+            output: {
+                productId: string;
+                slots: {
+                    id: string;
+                    optionId: string | null;
+                    dateLocal: string | null;
+                    startsAt: string | null;
+                    endsAt: string | null;
+                    timezone: string;
+                    status: "open" | "closed" | "sold_out" | "cancelled";
+                    unlimited: boolean;
+                    remainingPax: number | null;
+                    remainingResources: number | null;
+                    pastCutoff: boolean;
+                    tooEarly: boolean;
+                    startTime: {
+                        id: string;
+                        label: string | null;
+                        startTimeLocal: string;
+                        durationMinutes: number | null;
+                    } | null;
+                }[];
+                total: number;
+                limit: number;
+                offset: number;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/products/:productId/availability">;
+export type PublicPricingRoutes = typeof publicPricingRoutes;
+//# sourceMappingURL=routes-public.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"routes-public.d.ts","sourceRoot":"","sources":["../src/routes-public.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,GAAG,EAAY,MAAM,oBAAoB,CAAA;AAOvD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAoB5B,CAAA;AAEJ,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAA"}

package/dist/routes-public.js

@@ -0,0 +1,13 @@
+import { Hono } from "hono";
+import { notFound } from "./routes-shared.js";
+import { publicPricingService } from "./service-public.js";
+import { publicAvailabilitySnapshotQuerySchema, publicProductPricingQuerySchema, } from "./validation-public.js";
+export const publicPricingRoutes = new Hono()
+    .get("/products/:productId/pricing", async (c) => {
+    const snapshot = await publicPricingService.getProductPricingSnapshot(c.get("db"), c.req.param("productId"), publicProductPricingQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams)));
+    return snapshot ? c.json({ data: snapshot }) : notFound(c, "Public pricing snapshot not found");
+})
+    .get("/products/:productId/availability", async (c) => {
+    const snapshot = await publicPricingService.getAvailabilitySnapshot(c.get("db"), c.req.param("productId"), publicAvailabilitySnapshotQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams)));
+    return snapshot ? c.json(snapshot) : notFound(c, "Public availability snapshot not found");
+});

package/dist/routes.d.ts

@@ -1,5 +1,7 @@
 import { Hono } from "hono";
+import type { publicPricingRoutes } from "./routes-public.js";
 import type { Env } from "./routes-shared.js";
 export declare const pricingRoutes: Hono<Env, import("hono/types").BlankSchema, "/">;
 export type PricingRoutes = typeof pricingRoutes;
+export type PublicPricingRoutes = typeof publicPricingRoutes;
 //# sourceMappingURL=routes.d.ts.map

package/dist/routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAI3B,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAA;AAE7C,eAAO,MAAM,aAAa,kDAAkB,CAAA;AAI5C,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAA"}
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAG3B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAE7D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAA;AAE7C,eAAO,MAAM,aAAa,kDAAkB,CAAA;AAI5C,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAA;AAChD,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAA"}

package/dist/service-public.d.ts

@@ -0,0 +1,89 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { PublicAvailabilitySnapshotQuery, PublicProductPricingQuery } from "./validation-public.js";
+export declare const publicPricingService: {
+    getProductPricingSnapshot(db: PostgresJsDatabase, productId: string, query: PublicProductPricingQuery): Promise<{
+        productId: string;
+        catalog: {
+            currencyCode: string | null;
+            id: string;
+            code: string;
+            name: string;
+        };
+        options: {
+            id: string;
+            name: string;
+            description: string | null;
+            status: "active" | "draft" | "archived";
+            isDefault: boolean;
+            bookingMode: "other" | "date" | "open" | "date_time" | "stay" | "transfer" | "itinerary";
+            capacityMode: "on_request" | "free_sale" | "limited";
+            pricingRules: {
+                id: string;
+                name: string;
+                description: string | null;
+                pricingMode: "per_person" | "per_booking" | "starting_from" | "free" | "on_request";
+                baseSellAmountCents: number | null;
+                minPerBooking: number | null;
+                maxPerBooking: number | null;
+                isDefault: boolean;
+                cancellationPolicyId: string | null;
+                unitPrices: {
+                    id: string;
+                    unitId: string;
+                    unitName: string;
+                    unitType: "group" | "room" | "vehicle" | "service" | "other" | "person";
+                    pricingMode: "per_person" | "per_booking" | "free" | "on_request" | "per_unit" | "included";
+                    sellAmountCents: number | null;
+                    minQuantity: number | null;
+                    maxQuantity: number | null;
+                    pricingCategoryId: string | null;
+                    sortOrder: number;
+                    tiers: {
+                        id: string;
+                        minQuantity: number;
+                        maxQuantity: number | null;
+                        sellAmountCents: number | null;
+                        sortOrder: number;
+                    }[];
+                }[];
+                startTimeAdjustments: {
+                    id: string;
+                    startTimeId: string;
+                    label: string | null;
+                    startTimeLocal: string;
+                    ruleMode: "included" | "excluded" | "override" | "adjustment";
+                    adjustmentType: "fixed" | "percentage" | null;
+                    sellAdjustmentCents: number | null;
+                    adjustmentBasisPoints: number | null;
+                }[];
+            }[];
+        }[];
+    } | null>;
+    getAvailabilitySnapshot(db: PostgresJsDatabase, productId: string, query: PublicAvailabilitySnapshotQuery): Promise<{
+        productId: string;
+        slots: {
+            id: string;
+            optionId: string | null;
+            dateLocal: string | null;
+            startsAt: string | null;
+            endsAt: string | null;
+            timezone: string;
+            status: "open" | "closed" | "sold_out" | "cancelled";
+            unlimited: boolean;
+            remainingPax: number | null;
+            remainingResources: number | null;
+            pastCutoff: boolean;
+            tooEarly: boolean;
+            startTime: {
+                id: string;
+                label: string | null;
+                startTimeLocal: string;
+                durationMinutes: number | null;
+            } | null;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    } | null>;
+};
+//# sourceMappingURL=service-public.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-public.d.ts","sourceRoot":"","sources":["../src/service-public.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AASjE,OAAO,KAAK,EACV,+BAA+B,EAC/B,yBAAyB,EAC1B,MAAM,wBAAwB,CAAA;AAuE/B,eAAO,MAAM,oBAAoB;kCAEzB,kBAAkB,aACX,MAAM,SACV,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA0R5B,kBAAkB,aACX,MAAM,SACV,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;CAgGzC,CAAA"}

package/dist/service-public.js

@@ -0,0 +1,355 @@
+import { availabilitySlots, availabilityStartTimes } from "@voyantjs/availability/schema";
+import { optionUnits, productOptions, products } from "@voyantjs/products/schema";
+import { and, asc, desc, eq, gte, inArray, lte, ne, or, sql } from "drizzle-orm";
+import { optionPriceRules, optionStartTimeRules, optionUnitPriceRules, optionUnitTiers, priceCatalogs, } from "./schema.js";
+function normalizeDate(value) {
+    if (!value) {
+        return null;
+    }
+    return value instanceof Date ? value.toISOString() : value;
+}
+async function ensurePublicProduct(db, productId) {
+    const [product] = await db
+        .select({
+        id: products.id,
+        bookingMode: products.bookingMode,
+        capacityMode: products.capacityMode,
+    })
+        .from(products)
+        .where(and(eq(products.id, productId), eq(products.status, "active"), eq(products.activated, true), eq(products.visibility, "public")))
+        .limit(1);
+    return product ?? null;
+}
+async function resolvePublicCatalog(db, input) {
+    if (input.catalogId) {
+        const [catalog] = await db
+            .select({
+            id: priceCatalogs.id,
+            code: priceCatalogs.code,
+            name: priceCatalogs.name,
+            currencyCode: priceCatalogs.currencyCode,
+        })
+            .from(priceCatalogs)
+            .where(and(eq(priceCatalogs.id, input.catalogId), eq(priceCatalogs.catalogType, "public"), eq(priceCatalogs.active, true)))
+            .limit(1);
+        return catalog ?? null;
+    }
+    const [catalog] = await db
+        .select({
+        id: priceCatalogs.id,
+        code: priceCatalogs.code,
+        name: priceCatalogs.name,
+        currencyCode: priceCatalogs.currencyCode,
+    })
+        .from(priceCatalogs)
+        .where(and(eq(priceCatalogs.catalogType, "public"), eq(priceCatalogs.active, true)))
+        .orderBy(desc(priceCatalogs.isDefault), asc(priceCatalogs.name))
+        .limit(1);
+    return catalog ?? null;
+}
+export const publicPricingService = {
+    async getProductPricingSnapshot(db, productId, query) {
+        const product = await ensurePublicProduct(db, productId);
+        if (!product) {
+            return null;
+        }
+        const catalog = await resolvePublicCatalog(db, query);
+        if (!catalog) {
+            return null;
+        }
+        const optionConditions = [
+            eq(productOptions.productId, productId),
+            eq(productOptions.status, "active"),
+        ];
+        if (query.optionId) {
+            optionConditions.push(eq(productOptions.id, query.optionId));
+        }
+        const options = await db
+            .select({
+            id: productOptions.id,
+            name: productOptions.name,
+            description: productOptions.description,
+            status: productOptions.status,
+            isDefault: productOptions.isDefault,
+        })
+            .from(productOptions)
+            .where(and(...optionConditions))
+            .orderBy(desc(productOptions.isDefault), asc(productOptions.sortOrder), asc(productOptions.name));
+        if (options.length === 0) {
+            return {
+                productId,
+                catalog: {
+                    ...catalog,
+                    currencyCode: catalog.currencyCode ?? null,
+                },
+                options: [],
+            };
+        }
+        const optionIds = options.map((option) => option.id);
+        const [units, rules] = await Promise.all([
+            db
+                .select({
+                id: optionUnits.id,
+                optionId: optionUnits.optionId,
+                name: optionUnits.name,
+                unitType: optionUnits.unitType,
+                isHidden: optionUnits.isHidden,
+                sortOrder: optionUnits.sortOrder,
+            })
+                .from(optionUnits)
+                .where(and(inArray(optionUnits.optionId, optionIds), eq(optionUnits.isHidden, false)))
+                .orderBy(asc(optionUnits.sortOrder), asc(optionUnits.name)),
+            db
+                .select({
+                id: optionPriceRules.id,
+                optionId: optionPriceRules.optionId,
+                name: optionPriceRules.name,
+                description: optionPriceRules.description,
+                pricingMode: optionPriceRules.pricingMode,
+                baseSellAmountCents: optionPriceRules.baseSellAmountCents,
+                minPerBooking: optionPriceRules.minPerBooking,
+                maxPerBooking: optionPriceRules.maxPerBooking,
+                isDefault: optionPriceRules.isDefault,
+                cancellationPolicyId: optionPriceRules.cancellationPolicyId,
+            })
+                .from(optionPriceRules)
+                .where(and(eq(optionPriceRules.productId, productId), inArray(optionPriceRules.optionId, optionIds), eq(optionPriceRules.priceCatalogId, catalog.id), eq(optionPriceRules.active, true)))
+                .orderBy(desc(optionPriceRules.isDefault), asc(optionPriceRules.name)),
+        ]);
+        const ruleIds = rules.map((rule) => rule.id);
+        const [unitPrices, startTimeAdjustments] = await Promise.all([
+            ruleIds.length > 0
+                ? db
+                    .select({
+                    id: optionUnitPriceRules.id,
+                    optionPriceRuleId: optionUnitPriceRules.optionPriceRuleId,
+                    unitId: optionUnitPriceRules.unitId,
+                    pricingMode: optionUnitPriceRules.pricingMode,
+                    sellAmountCents: optionUnitPriceRules.sellAmountCents,
+                    minQuantity: optionUnitPriceRules.minQuantity,
+                    maxQuantity: optionUnitPriceRules.maxQuantity,
+                    pricingCategoryId: optionUnitPriceRules.pricingCategoryId,
+                    sortOrder: optionUnitPriceRules.sortOrder,
+                })
+                    .from(optionUnitPriceRules)
+                    .where(and(inArray(optionUnitPriceRules.optionPriceRuleId, ruleIds), eq(optionUnitPriceRules.active, true)))
+                    .orderBy(asc(optionUnitPriceRules.sortOrder), asc(optionUnitPriceRules.createdAt))
+                : Promise.resolve([]),
+            ruleIds.length > 0
+                ? db
+                    .select({
+                    id: optionStartTimeRules.id,
+                    optionPriceRuleId: optionStartTimeRules.optionPriceRuleId,
+                    startTimeId: optionStartTimeRules.startTimeId,
+                    label: availabilityStartTimes.label,
+                    startTimeLocal: availabilityStartTimes.startTimeLocal,
+                    durationMinutes: availabilityStartTimes.durationMinutes,
+                    ruleMode: optionStartTimeRules.ruleMode,
+                    adjustmentType: optionStartTimeRules.adjustmentType,
+                    sellAdjustmentCents: optionStartTimeRules.sellAdjustmentCents,
+                    adjustmentBasisPoints: optionStartTimeRules.adjustmentBasisPoints,
+                })
+                    .from(optionStartTimeRules)
+                    .innerJoin(availabilityStartTimes, eq(availabilityStartTimes.id, optionStartTimeRules.startTimeId))
+                    .where(and(inArray(optionStartTimeRules.optionPriceRuleId, ruleIds), eq(optionStartTimeRules.active, true), eq(availabilityStartTimes.active, true)))
+                    .orderBy(asc(availabilityStartTimes.sortOrder), asc(availabilityStartTimes.startTimeLocal))
+                : Promise.resolve([]),
+        ]);
+        const unitPriceIds = unitPrices.map((unitPrice) => unitPrice.id);
+        const tiers = unitPriceIds.length > 0
+            ? await db
+                .select({
+                id: optionUnitTiers.id,
+                optionUnitPriceRuleId: optionUnitTiers.optionUnitPriceRuleId,
+                minQuantity: optionUnitTiers.minQuantity,
+                maxQuantity: optionUnitTiers.maxQuantity,
+                sellAmountCents: optionUnitTiers.sellAmountCents,
+                sortOrder: optionUnitTiers.sortOrder,
+            })
+                .from(optionUnitTiers)
+                .where(and(inArray(optionUnitTiers.optionUnitPriceRuleId, unitPriceIds), eq(optionUnitTiers.active, true)))
+                .orderBy(asc(optionUnitTiers.sortOrder), asc(optionUnitTiers.minQuantity))
+            : [];
+        const unitById = new Map(units.map((unit) => [
+            unit.id,
+            {
+                id: unit.id,
+                unitId: unit.id,
+                unitName: unit.name,
+                unitType: unit.unitType,
+                sortOrder: unit.sortOrder,
+            },
+        ]));
+        const tiersByUnitPriceRule = new Map();
+        for (const tier of tiers) {
+            const existing = tiersByUnitPriceRule.get(tier.optionUnitPriceRuleId) ?? [];
+            existing.push(tier);
+            tiersByUnitPriceRule.set(tier.optionUnitPriceRuleId, existing);
+        }
+        const unitPricesByRule = new Map();
+        for (const unitPrice of unitPrices) {
+            const existing = unitPricesByRule.get(unitPrice.optionPriceRuleId) ?? [];
+            existing.push(unitPrice);
+            unitPricesByRule.set(unitPrice.optionPriceRuleId, existing);
+        }
+        const startTimeAdjustmentsByRule = new Map();
+        for (const adjustment of startTimeAdjustments) {
+            const existing = startTimeAdjustmentsByRule.get(adjustment.optionPriceRuleId) ?? [];
+            existing.push(adjustment);
+            startTimeAdjustmentsByRule.set(adjustment.optionPriceRuleId, existing);
+        }
+        const rulesByOption = new Map();
+        for (const rule of rules) {
+            const existing = rulesByOption.get(rule.optionId) ?? [];
+            existing.push(rule);
+            rulesByOption.set(rule.optionId, existing);
+        }
+        return {
+            productId,
+            catalog: {
+                ...catalog,
+                currencyCode: catalog.currencyCode ?? null,
+            },
+            options: options.map((option) => ({
+                id: option.id,
+                name: option.name,
+                description: option.description ?? null,
+                status: option.status,
+                isDefault: option.isDefault,
+                bookingMode: product.bookingMode,
+                capacityMode: product.capacityMode,
+                pricingRules: (rulesByOption.get(option.id) ?? []).map((rule) => ({
+                    id: rule.id,
+                    name: rule.name,
+                    description: rule.description ?? null,
+                    pricingMode: rule.pricingMode,
+                    baseSellAmountCents: rule.baseSellAmountCents ?? null,
+                    minPerBooking: rule.minPerBooking ?? null,
+                    maxPerBooking: rule.maxPerBooking ?? null,
+                    isDefault: rule.isDefault,
+                    cancellationPolicyId: rule.cancellationPolicyId ?? null,
+                    unitPrices: (unitPricesByRule.get(rule.id) ?? [])
+                        .map((unitPrice) => {
+                        const unit = unitById.get(unitPrice.unitId);
+                        if (!unit) {
+                            return null;
+                        }
+                        return {
+                            id: unitPrice.id,
+                            unitId: unit.unitId,
+                            unitName: unit.unitName,
+                            unitType: unit.unitType,
+                            pricingMode: unitPrice.pricingMode,
+                            sellAmountCents: unitPrice.sellAmountCents ?? null,
+                            minQuantity: unitPrice.minQuantity ?? null,
+                            maxQuantity: unitPrice.maxQuantity ?? null,
+                            pricingCategoryId: unitPrice.pricingCategoryId ?? null,
+                            sortOrder: unitPrice.sortOrder,
+                            tiers: (tiersByUnitPriceRule.get(unitPrice.id) ?? []).map((tier) => ({
+                                id: tier.id,
+                                minQuantity: tier.minQuantity,
+                                maxQuantity: tier.maxQuantity ?? null,
+                                sellAmountCents: tier.sellAmountCents ?? null,
+                                sortOrder: tier.sortOrder,
+                            })),
+                        };
+                    })
+                        .filter((value) => value !== null),
+                    startTimeAdjustments: (startTimeAdjustmentsByRule.get(rule.id) ?? []).map((adjustment) => ({
+                        id: adjustment.id,
+                        startTimeId: adjustment.startTimeId,
+                        label: adjustment.label ?? null,
+                        startTimeLocal: adjustment.startTimeLocal,
+                        ruleMode: adjustment.ruleMode,
+                        adjustmentType: adjustment.adjustmentType ?? null,
+                        sellAdjustmentCents: adjustment.sellAdjustmentCents ?? null,
+                        adjustmentBasisPoints: adjustment.adjustmentBasisPoints ?? null,
+                    })),
+                })),
+            })),
+        };
+    },
+    async getAvailabilitySnapshot(db, productId, query) {
+        const product = await ensurePublicProduct(db, productId);
+        if (!product) {
+            return null;
+        }
+        const conditions = [
+            eq(availabilitySlots.productId, productId),
+            ne(availabilitySlots.status, "cancelled"),
+        ];
+        if (query.optionId) {
+            conditions.push(eq(availabilitySlots.optionId, query.optionId));
+        }
+        if (query.dateFrom) {
+            conditions.push(gte(availabilitySlots.dateLocal, query.dateFrom));
+        }
+        if (query.dateTo) {
+            conditions.push(lte(availabilitySlots.dateLocal, query.dateTo));
+        }
+        if (query.status) {
+            conditions.push(eq(availabilitySlots.status, query.status));
+        }
+        else {
+            conditions.push(or(eq(availabilitySlots.status, "open"), eq(availabilitySlots.status, "sold_out")) ??
+                sql `1 = 1`);
+        }
+        const where = and(...conditions);
+        const [rows, countResult] = await Promise.all([
+            db
+                .select({
+                id: availabilitySlots.id,
+                optionId: availabilitySlots.optionId,
+                dateLocal: availabilitySlots.dateLocal,
+                startsAt: availabilitySlots.startsAt,
+                endsAt: availabilitySlots.endsAt,
+                timezone: availabilitySlots.timezone,
+                status: availabilitySlots.status,
+                unlimited: availabilitySlots.unlimited,
+                remainingPax: availabilitySlots.remainingPax,
+                remainingResources: availabilitySlots.remainingResources,
+                pastCutoff: availabilitySlots.pastCutoff,
+                tooEarly: availabilitySlots.tooEarly,
+                startTimeId: availabilityStartTimes.id,
+                startTimeLabel: availabilityStartTimes.label,
+                startTimeLocal: availabilityStartTimes.startTimeLocal,
+                durationMinutes: availabilityStartTimes.durationMinutes,
+            })
+                .from(availabilitySlots)
+                .leftJoin(availabilityStartTimes, eq(availabilityStartTimes.id, availabilitySlots.startTimeId))
+                .where(where)
+                .orderBy(asc(availabilitySlots.startsAt))
+                .limit(query.limit)
+                .offset(query.offset),
+            db.select({ count: sql `count(*)::int` }).from(availabilitySlots).where(where),
+        ]);
+        return {
+            productId,
+            slots: rows.map((row) => ({
+                id: row.id,
+                optionId: row.optionId ?? null,
+                dateLocal: normalizeDate(row.dateLocal),
+                startsAt: normalizeDate(row.startsAt),
+                endsAt: normalizeDate(row.endsAt),
+                timezone: row.timezone,
+                status: row.status,
+                unlimited: row.unlimited,
+                remainingPax: row.remainingPax ?? null,
+                remainingResources: row.remainingResources ?? null,
+                pastCutoff: row.pastCutoff,
+                tooEarly: row.tooEarly,
+                startTime: row.startTimeId
+                    ? {
+                        id: row.startTimeId,
+                        label: row.startTimeLabel ?? null,
+                        startTimeLocal: row.startTimeLocal ?? "",
+                        durationMinutes: row.durationMinutes ?? null,
+                    }
+                    : null,
+            })),
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+};