@voyantjs/pricing 0.2.0 → 0.3.1

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

@@ -0,0 +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"}

package/dist/routes-core.js

@@ -0,0 +1,101 @@
+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)))))
+    .post("/pricing-categories", async (c) => c.json({
+    data: await pricingService.createPricingCategory(c.get("db"), insertPricingCategorySchema.parse(await c.req.json())),
+}, 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()));
+    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)))))
+    .post("/pricing-category-dependencies", async (c) => c.json({
+    data: await pricingService.createPricingCategoryDependency(c.get("db"), insertPricingCategoryDependencySchema.parse(await c.req.json())),
+}, 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()));
+    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)))))
+    .post("/cancellation-policies", async (c) => c.json({
+    data: await pricingService.createCancellationPolicy(c.get("db"), insertCancellationPolicySchema.parse(await c.req.json())),
+}, 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()));
+    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)))))
+    .post("/cancellation-policy-rules", async (c) => c.json({
+    data: await pricingService.createCancellationPolicyRule(c.get("db"), insertCancellationPolicyRuleSchema.parse(await c.req.json())),
+}, 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()));
+    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)))))
+    .post("/price-catalogs", async (c) => c.json({
+    data: await pricingService.createPriceCatalog(c.get("db"), insertPriceCatalogSchema.parse(await c.req.json())),
+}, 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()));
+    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)))))
+    .post("/price-schedules", async (c) => c.json({
+    data: await pricingService.createPriceSchedule(c.get("db"), insertPriceScheduleSchema.parse(await c.req.json())),
+}, 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()));
+    return row ? c.json({ data: row }) : notFound(c, "Price schedule not found");
+})
+    .delete("/price-schedules/:id", async (c) => {
+    const row = await pricingService.deletePriceSchedule(c.get("db"), c.req.param("id"));
+    return row ? c.json({ success: true }) : notFound(c, "Price schedule not found");
+});

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");
+});