@voyantjs/pricing 0.5.0 → 0.6.0

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: "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle" | "service" | "other";
+                    categoryType: "service" | "other" | "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle";
                     seatOccupancy: number;
                     groupSize: number | null;
                     isAgeQualified: boolean;
@@ -40,19 +40,19 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
             input: {};
             output: {
                 data: {
-                    id: string;
-                    name: string;
-                    code: string | null;
-                    active: boolean;
                     metadata: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | null;
+                    id: string;
+                    name: string;
                     createdAt: string;
                     updatedAt: string;
+                    code: string | null;
+                    active: boolean;
                     productId: string | null;
                     optionId: string | null;
                     unitId: string | null;
-                    categoryType: "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle" | "service" | "other";
+                    categoryType: "service" | "other" | "adult" | "child" | "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: "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle" | "service" | "other";
+                    categoryType: "service" | "other" | "adult" | "child" | "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: "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle" | "service" | "other";
+                    categoryType: "service" | "other" | "adult" | "child" | "infant" | "senior" | "group" | "room" | "vehicle";
                     seatOccupancy: number;
                     groupSize: number | null;
                     isAgeQualified: boolean;
@@ -218,10 +218,10 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
             output: {
                 data: {
                     id: string;
-                    active: boolean;
-                    notes: string | null;
                     createdAt: string;
                     updatedAt: string;
+                    notes: string | null;
+                    active: boolean;
                     pricingCategoryId: string;
                     masterPricingCategoryId: string;
                     dependencyType: "requires" | "limits_per_master" | "limits_sum" | "excludes";
@@ -342,7 +342,7 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
                     id: string;
                     code: string | null;
                     name: string;
-                    policyType: "simple" | "advanced" | "non_refundable" | "custom";
+                    policyType: "custom" | "simple" | "advanced" | "non_refundable";
                     simpleCutoffHours: number | null;
                     isDefault: boolean;
                     active: boolean;
@@ -367,18 +367,18 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
             input: {};
             output: {
                 data: {
-                    id: string;
-                    name: string;
-                    code: string | null;
-                    isDefault: boolean;
-                    active: boolean;
-                    notes: string | null;
                     metadata: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | null;
+                    id: string;
+                    name: string;
                     createdAt: string;
                     updatedAt: string;
-                    policyType: "simple" | "advanced" | "non_refundable" | "custom";
+                    notes: string | null;
+                    code: string | null;
+                    isDefault: boolean;
+                    active: boolean;
+                    policyType: "custom" | "simple" | "advanced" | "non_refundable";
                     simpleCutoffHours: number | null;
                 } | null;
             };
@@ -410,7 +410,7 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
                     id: string;
                     code: string | null;
                     name: string;
-                    policyType: "simple" | "advanced" | "non_refundable" | "custom";
+                    policyType: "custom" | "simple" | "advanced" | "non_refundable";
                     simpleCutoffHours: number | null;
                     isDefault: boolean;
                     active: boolean;
@@ -450,7 +450,7 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
                     id: string;
                     code: string | null;
                     name: string;
-                    policyType: "simple" | "advanced" | "non_refundable" | "custom";
+                    policyType: "custom" | "simple" | "advanced" | "non_refundable";
                     simpleCutoffHours: number | null;
                     isDefault: boolean;
                     active: boolean;
@@ -525,10 +525,10 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
             output: {
                 data: {
                     id: string;
-                    active: boolean;
-                    notes: string | null;
                     createdAt: string;
                     updatedAt: string;
+                    notes: string | null;
+                    active: boolean;
                     sortOrder: number;
                     cancellationPolicyId: string;
                     cutoffMinutesBefore: number | null;
@@ -677,19 +677,19 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
             input: {};
             output: {
                 data: {
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
                     id: string;
                     name: string;
+                    createdAt: string;
+                    updatedAt: string;
+                    notes: string | null;
                     code: string;
                     currencyCode: string | null;
                     catalogType: "internal" | "other" | "public" | "contract" | "net" | "gross" | "promo";
                     isDefault: boolean;
                     active: boolean;
-                    notes: string | null;
-                    metadata: {
-                        [x: string]: import("hono/utils/types").JSONValue;
-                    } | null;
-                    createdAt: string;
-                    updatedAt: string;
                 } | null;
             };
             outputFormat: "json";
@@ -840,19 +840,19 @@ export declare const pricingCoreRoutes: import("hono/hono-base").HonoBase<Env, {
             input: {};
             output: {
                 data: {
-                    id: string;
-                    name: string;
-                    code: string | null;
-                    active: boolean;
-                    notes: string | null;
                     metadata: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | null;
+                    id: string;
+                    name: string;
                     createdAt: string;
                     updatedAt: string;
+                    notes: string | null;
+                    timezone: string | null;
+                    code: string | null;
+                    active: boolean;
                     priceCatalogId: string;
                     recurrenceRule: string;
-                    timezone: string | null;
                     validFrom: string | null;
                     validTo: string | null;
                     weekdays: string[] | null;

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

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

package/dist/routes-core.js

@@ -1,98 +1,99 @@
+import { parseJsonBody, parseQuery } from "@voyantjs/hono";
 import { Hono } from "hono";
 import { notFound } from "./routes-shared.js";
 import { pricingService } from "./service.js";
 import { cancellationPolicyListQuerySchema, cancellationPolicyRuleListQuerySchema, insertCancellationPolicyRuleSchema, insertCancellationPolicySchema, insertPriceCatalogSchema, insertPriceScheduleSchema, insertPricingCategoryDependencySchema, insertPricingCategorySchema, priceCatalogListQuerySchema, priceScheduleListQuerySchema, pricingCategoryDependencyListQuerySchema, pricingCategoryListQuerySchema, updateCancellationPolicyRuleSchema, updateCancellationPolicySchema, updatePriceCatalogSchema, updatePriceScheduleSchema, updatePricingCategoryDependencySchema, updatePricingCategorySchema, } from "./validation.js";
 export const pricingCoreRoutes = new Hono()
-    .get("/pricing-categories", async (c) => c.json(await pricingService.listPricingCategories(c.get("db"), pricingCategoryListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams)))))
+    .get("/pricing-categories", async (c) => c.json(await pricingService.listPricingCategories(c.get("db"), await parseQuery(c, pricingCategoryListQuerySchema))))
     .post("/pricing-categories", async (c) => c.json({
-    data: await pricingService.createPricingCategory(c.get("db"), insertPricingCategorySchema.parse(await c.req.json())),
+    data: await pricingService.createPricingCategory(c.get("db"), await parseJsonBody(c, insertPricingCategorySchema)),
 }, 201))
     .get("/pricing-categories/:id", async (c) => {
     const row = await pricingService.getPricingCategoryById(c.get("db"), c.req.param("id"));
     return row ? c.json({ data: row }) : notFound(c, "Pricing category not found");
 })
     .patch("/pricing-categories/:id", async (c) => {
-    const row = await pricingService.updatePricingCategory(c.get("db"), c.req.param("id"), updatePricingCategorySchema.parse(await c.req.json()));
+    const row = await pricingService.updatePricingCategory(c.get("db"), c.req.param("id"), await parseJsonBody(c, updatePricingCategorySchema));
     return row ? c.json({ data: row }) : notFound(c, "Pricing category not found");
 })
     .delete("/pricing-categories/:id", async (c) => {
     const row = await pricingService.deletePricingCategory(c.get("db"), c.req.param("id"));
     return row ? c.json({ success: true }) : notFound(c, "Pricing category not found");
 })
-    .get("/pricing-category-dependencies", async (c) => c.json(await pricingService.listPricingCategoryDependencies(c.get("db"), pricingCategoryDependencyListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams)))))
+    .get("/pricing-category-dependencies", async (c) => c.json(await pricingService.listPricingCategoryDependencies(c.get("db"), await parseQuery(c, pricingCategoryDependencyListQuerySchema))))
     .post("/pricing-category-dependencies", async (c) => c.json({
-    data: await pricingService.createPricingCategoryDependency(c.get("db"), insertPricingCategoryDependencySchema.parse(await c.req.json())),
+    data: await pricingService.createPricingCategoryDependency(c.get("db"), await parseJsonBody(c, insertPricingCategoryDependencySchema)),
 }, 201))
     .get("/pricing-category-dependencies/:id", async (c) => {
     const row = await pricingService.getPricingCategoryDependencyById(c.get("db"), c.req.param("id"));
     return row ? c.json({ data: row }) : notFound(c, "Pricing category dependency not found");
 })
     .patch("/pricing-category-dependencies/:id", async (c) => {
-    const row = await pricingService.updatePricingCategoryDependency(c.get("db"), c.req.param("id"), updatePricingCategoryDependencySchema.parse(await c.req.json()));
+    const row = await pricingService.updatePricingCategoryDependency(c.get("db"), c.req.param("id"), await parseJsonBody(c, updatePricingCategoryDependencySchema));
     return row ? c.json({ data: row }) : notFound(c, "Pricing category dependency not found");
 })
     .delete("/pricing-category-dependencies/:id", async (c) => {
     const row = await pricingService.deletePricingCategoryDependency(c.get("db"), c.req.param("id"));
     return row ? c.json({ success: true }) : notFound(c, "Pricing category dependency not found");
 })
-    .get("/cancellation-policies", async (c) => c.json(await pricingService.listCancellationPolicies(c.get("db"), cancellationPolicyListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams)))))
+    .get("/cancellation-policies", async (c) => c.json(await pricingService.listCancellationPolicies(c.get("db"), await parseQuery(c, cancellationPolicyListQuerySchema))))
     .post("/cancellation-policies", async (c) => c.json({
-    data: await pricingService.createCancellationPolicy(c.get("db"), insertCancellationPolicySchema.parse(await c.req.json())),
+    data: await pricingService.createCancellationPolicy(c.get("db"), await parseJsonBody(c, insertCancellationPolicySchema)),
 }, 201))
     .get("/cancellation-policies/:id", async (c) => {
     const row = await pricingService.getCancellationPolicyById(c.get("db"), c.req.param("id"));
     return row ? c.json({ data: row }) : notFound(c, "Cancellation policy not found");
 })
     .patch("/cancellation-policies/:id", async (c) => {
-    const row = await pricingService.updateCancellationPolicy(c.get("db"), c.req.param("id"), updateCancellationPolicySchema.parse(await c.req.json()));
+    const row = await pricingService.updateCancellationPolicy(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateCancellationPolicySchema));
     return row ? c.json({ data: row }) : notFound(c, "Cancellation policy not found");
 })
     .delete("/cancellation-policies/:id", async (c) => {
     const row = await pricingService.deleteCancellationPolicy(c.get("db"), c.req.param("id"));
     return row ? c.json({ success: true }) : notFound(c, "Cancellation policy not found");
 })
-    .get("/cancellation-policy-rules", async (c) => c.json(await pricingService.listCancellationPolicyRules(c.get("db"), cancellationPolicyRuleListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams)))))
+    .get("/cancellation-policy-rules", async (c) => c.json(await pricingService.listCancellationPolicyRules(c.get("db"), await parseQuery(c, cancellationPolicyRuleListQuerySchema))))
     .post("/cancellation-policy-rules", async (c) => c.json({
-    data: await pricingService.createCancellationPolicyRule(c.get("db"), insertCancellationPolicyRuleSchema.parse(await c.req.json())),
+    data: await pricingService.createCancellationPolicyRule(c.get("db"), await parseJsonBody(c, insertCancellationPolicyRuleSchema)),
 }, 201))
     .get("/cancellation-policy-rules/:id", async (c) => {
     const row = await pricingService.getCancellationPolicyRuleById(c.get("db"), c.req.param("id"));
     return row ? c.json({ data: row }) : notFound(c, "Cancellation policy rule not found");
 })
     .patch("/cancellation-policy-rules/:id", async (c) => {
-    const row = await pricingService.updateCancellationPolicyRule(c.get("db"), c.req.param("id"), updateCancellationPolicyRuleSchema.parse(await c.req.json()));
+    const row = await pricingService.updateCancellationPolicyRule(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateCancellationPolicyRuleSchema));
     return row ? c.json({ data: row }) : notFound(c, "Cancellation policy rule not found");
 })
     .delete("/cancellation-policy-rules/:id", async (c) => {
     const row = await pricingService.deleteCancellationPolicyRule(c.get("db"), c.req.param("id"));
     return row ? c.json({ success: true }) : notFound(c, "Cancellation policy rule not found");
 })
-    .get("/price-catalogs", async (c) => c.json(await pricingService.listPriceCatalogs(c.get("db"), priceCatalogListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams)))))
+    .get("/price-catalogs", async (c) => c.json(await pricingService.listPriceCatalogs(c.get("db"), await parseQuery(c, priceCatalogListQuerySchema))))
     .post("/price-catalogs", async (c) => c.json({
-    data: await pricingService.createPriceCatalog(c.get("db"), insertPriceCatalogSchema.parse(await c.req.json())),
+    data: await pricingService.createPriceCatalog(c.get("db"), await parseJsonBody(c, insertPriceCatalogSchema)),
 }, 201))
     .get("/price-catalogs/:id", async (c) => {
     const row = await pricingService.getPriceCatalogById(c.get("db"), c.req.param("id"));
     return row ? c.json({ data: row }) : notFound(c, "Price catalog not found");
 })
     .patch("/price-catalogs/:id", async (c) => {
-    const row = await pricingService.updatePriceCatalog(c.get("db"), c.req.param("id"), updatePriceCatalogSchema.parse(await c.req.json()));
+    const row = await pricingService.updatePriceCatalog(c.get("db"), c.req.param("id"), await parseJsonBody(c, updatePriceCatalogSchema));
     return row ? c.json({ data: row }) : notFound(c, "Price catalog not found");
 })
     .delete("/price-catalogs/:id", async (c) => {
     const row = await pricingService.deletePriceCatalog(c.get("db"), c.req.param("id"));
     return row ? c.json({ success: true }) : notFound(c, "Price catalog not found");
 })
-    .get("/price-schedules", async (c) => c.json(await pricingService.listPriceSchedules(c.get("db"), priceScheduleListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams)))))
+    .get("/price-schedules", async (c) => c.json(await pricingService.listPriceSchedules(c.get("db"), await parseQuery(c, priceScheduleListQuerySchema))))
     .post("/price-schedules", async (c) => c.json({
-    data: await pricingService.createPriceSchedule(c.get("db"), insertPriceScheduleSchema.parse(await c.req.json())),
+    data: await pricingService.createPriceSchedule(c.get("db"), await parseJsonBody(c, insertPriceScheduleSchema)),
 }, 201))
     .get("/price-schedules/:id", async (c) => {
     const row = await pricingService.getPriceScheduleById(c.get("db"), c.req.param("id"));
     return row ? c.json({ data: row }) : notFound(c, "Price schedule not found");
 })
     .patch("/price-schedules/:id", async (c) => {
-    const row = await pricingService.updatePriceSchedule(c.get("db"), c.req.param("id"), updatePriceScheduleSchema.parse(await c.req.json()));
+    const row = await pricingService.updatePriceSchedule(c.get("db"), c.req.param("id"), await parseJsonBody(c, updatePriceScheduleSchema));
     return row ? c.json({ data: row }) : notFound(c, "Price schedule not found");
 })
     .delete("/price-schedules/:id", async (c) => {

package/dist/routes-public.d.ts

@@ -33,7 +33,7 @@ export declare const publicPricingRoutes: import("hono/hono-base").HonoBase<Env,
                         description: string | null;
                         status: "active" | "draft" | "archived";
                         isDefault: boolean;
-                        bookingMode: "other" | "date" | "open" | "date_time" | "stay" | "transfer" | "itinerary";
+                        bookingMode: "date" | "other" | "open" | "date_time" | "stay" | "transfer" | "itinerary";
                         capacityMode: "on_request" | "free_sale" | "limited";
                         pricingRules: {
                             id: string;
@@ -49,7 +49,7 @@ export declare const publicPricingRoutes: import("hono/hono-base").HonoBase<Env,
                                 id: string;
                                 unitId: string;
                                 unitName: string;
-                                unitType: "group" | "room" | "vehicle" | "service" | "other" | "person";
+                                unitType: "service" | "other" | "group" | "room" | "vehicle" | "person";
                                 pricingMode: "per_person" | "per_booking" | "free" | "on_request" | "per_unit" | "included";
                                 sellAmountCents: number | null;
                                 minQuantity: number | null;
@@ -69,7 +69,7 @@ export declare const publicPricingRoutes: import("hono/hono-base").HonoBase<Env,
                                 startTimeId: string;
                                 label: string | null;
                                 startTimeLocal: string;
-                                ruleMode: "included" | "excluded" | "override" | "adjustment";
+                                ruleMode: "override" | "included" | "excluded" | "adjustment";
                                 adjustmentType: "fixed" | "percentage" | null;
                                 sellAdjustmentCents: number | null;
                                 adjustmentBasisPoints: number | null;

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

@@ -1 +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"}
+{"version":3,"file":"routes-public.d.ts","sourceRoot":"","sources":["../src/routes-public.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,GAAG,EAAY,MAAM,oBAAoB,CAAA;AAOvD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAkB5B,CAAA;AAEJ,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAA"}

package/dist/routes-public.js

@@ -1,13 +1,14 @@
+import { parseQuery } from "@voyantjs/hono";
 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)));
+    const snapshot = await publicPricingService.getProductPricingSnapshot(c.get("db"), c.req.param("productId"), parseQuery(c, publicProductPricingQuerySchema));
     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)));
+    const snapshot = await publicPricingService.getAvailabilitySnapshot(c.get("db"), c.req.param("productId"), parseQuery(c, publicAvailabilitySnapshotQuerySchema));
     return snapshot ? c.json(snapshot) : notFound(c, "Public availability snapshot not found");
 });

package/dist/routes-rules.d.ts

@@ -43,23 +43,23 @@ export declare const pricingRuleRoutes: import("hono/hono-base").HonoBase<Env, {
             input: {};
             output: {
                 data: {
-                    id: string;
-                    name: string;
-                    code: string | null;
-                    isDefault: boolean;
-                    active: boolean;
-                    notes: string | null;
                     metadata: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | null;
+                    id: string;
+                    name: string;
                     createdAt: string;
                     updatedAt: string;
+                    notes: string | null;
+                    description: string | null;
+                    code: string | null;
+                    isDefault: boolean;
+                    active: boolean;
                     priceCatalogId: string;
                     productId: string;
                     optionId: string;
                     cancellationPolicyId: string | null;
                     priceScheduleId: string | null;
-                    description: string | null;
                     pricingMode: "per_person" | "per_booking" | "starting_from" | "free" | "on_request";
                     baseSellAmountCents: number | null;
                     baseCostAmountCents: number | null;
@@ -237,14 +237,14 @@ export declare const pricingRuleRoutes: import("hono/hono-base").HonoBase<Env, {
             input: {};
             output: {
                 data: {
-                    id: string;
-                    active: boolean;
-                    notes: string | null;
                     metadata: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | null;
+                    id: string;
                     createdAt: string;
                     updatedAt: string;
+                    notes: string | null;
+                    active: boolean;
                     optionId: string;
                     unitId: string;
                     sortOrder: number;
@@ -387,7 +387,7 @@ export declare const pricingRuleRoutes: import("hono/hono-base").HonoBase<Env, {
                     optionPriceRuleId: string;
                     optionId: string;
                     startTimeId: string;
-                    ruleMode: "included" | "excluded" | "override" | "adjustment";
+                    ruleMode: "override" | "included" | "excluded" | "adjustment";
                     adjustmentType: "fixed" | "percentage" | null;
                     sellAdjustmentCents: number | null;
                     costAdjustmentCents: number | null;
@@ -412,14 +412,14 @@ export declare const pricingRuleRoutes: import("hono/hono-base").HonoBase<Env, {
             output: {
                 data: {
                     id: string;
-                    active: boolean;
-                    notes: string | null;
                     createdAt: string;
                     updatedAt: string;
+                    notes: string | null;
+                    active: boolean;
                     optionId: string;
                     optionPriceRuleId: string;
                     startTimeId: string;
-                    ruleMode: "included" | "excluded" | "override" | "adjustment";
+                    ruleMode: "override" | "included" | "excluded" | "adjustment";
                     adjustmentType: "fixed" | "percentage" | null;
                     sellAdjustmentCents: number | null;
                     costAdjustmentCents: number | null;
@@ -455,7 +455,7 @@ export declare const pricingRuleRoutes: import("hono/hono-base").HonoBase<Env, {
                     optionPriceRuleId: string;
                     optionId: string;
                     startTimeId: string;
-                    ruleMode: "included" | "excluded" | "override" | "adjustment";
+                    ruleMode: "override" | "included" | "excluded" | "adjustment";
                     adjustmentType: "fixed" | "percentage" | null;
                     sellAdjustmentCents: number | null;
                     costAdjustmentCents: number | null;
@@ -495,7 +495,7 @@ export declare const pricingRuleRoutes: import("hono/hono-base").HonoBase<Env, {
                     optionPriceRuleId: string;
                     optionId: string;
                     startTimeId: string;
-                    ruleMode: "included" | "excluded" | "override" | "adjustment";
+                    ruleMode: "override" | "included" | "excluded" | "adjustment";
                     adjustmentType: "fixed" | "percentage" | null;
                     sellAdjustmentCents: number | null;
                     costAdjustmentCents: number | null;
@@ -568,9 +568,9 @@ export declare const pricingRuleRoutes: import("hono/hono-base").HonoBase<Env, {
             output: {
                 data: {
                     id: string;
-                    active: boolean;
                     createdAt: string;
                     updatedAt: string;
+                    active: boolean;
                     sortOrder: number;
                     sellAmountCents: number | null;
                     costAmountCents: number | null;
@@ -717,10 +717,10 @@ export declare const pricingRuleRoutes: import("hono/hono-base").HonoBase<Env, {
             output: {
                 data: {
                     id: string;
-                    active: boolean;
-                    notes: string | null;
                     createdAt: string;
                     updatedAt: string;
+                    notes: string | null;
+                    active: boolean;
                     optionId: string;
                     sortOrder: number;
                     pricingMode: "per_person" | "per_booking" | "on_request" | "included" | "unavailable";
@@ -874,10 +874,10 @@ export declare const pricingRuleRoutes: import("hono/hono-base").HonoBase<Env, {
             output: {
                 data: {
                     id: string;
-                    active: boolean;
-                    notes: string | null;
                     createdAt: string;
                     updatedAt: string;
+                    notes: string | null;
+                    active: boolean;
                     optionId: string;
                     sortOrder: number;
                     pricingMode: "per_person" | "per_booking" | "on_request" | "included" | "unavailable";
@@ -1038,14 +1038,14 @@ export declare const pricingRuleRoutes: import("hono/hono-base").HonoBase<Env, {
             input: {};
             output: {
                 data: {
-                    id: string;
-                    active: boolean;
-                    notes: string | null;
                     metadata: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | null;
+                    id: string;
                     createdAt: string;
                     updatedAt: string;
+                    notes: string | null;
+                    active: boolean;
                     optionId: string;
                     sortOrder: number;
                     pricingMode: "per_person" | "per_booking" | "on_request" | "included" | "unavailable";

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

@@ -1 +1 @@
-{"version":3,"file":"routes-rules.d.ts","sourceRoot":"","sources":["../src/routes-rules.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,GAAG,EAAY,MAAM,oBAAoB,CAAA;AA0BvD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAyP1B,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;AA0BvD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAqP1B,CAAA"}