@voyant-travel/inventory 0.1.0

package/dist/extras/draft-shape.js

@@ -0,0 +1,69 @@
+/**
+ * Project an `ExtraContent` payload into a `BookingDraftShape`.
+ *
+ * Extras are booking add-ons (excursions, transfers, insurance) —
+ * they're never standalone bookable on their own; they always layer
+ * onto a parent product. So the descriptor here is **degenerate**:
+ *
+ *   - `showsConfigure: false` (no configure step — extras are picked
+ *     during the parent product's add-on step).
+ *   - `showsTravelers: false` (extras don't have their own pax flow).
+ *   - `showsPayment: false` (extras roll up into the parent's pricing).
+ *   - `addons.catalog`: the extra itself + its sub-options projected
+ *     as a small catalog. Useful for journey contexts that want to
+ *     render an add-on detail view (e.g. ops admin reviewing a
+ *     supplier's extras).
+ *
+ * In practice templates rarely call this directly — the parent
+ * product's `BookingDraftShape` aggregates extras via the journey's
+ * cross-product composer. This function is the building block.
+ */
+import { defaultBookingFields, defaultDraftShapeFlags, defaultTravelerFields, paxBandsAllowedTotalFrom, } from "@voyant-travel/catalog/booking-engine";
+const DEGENERATE_PAX_BANDS = [
+    { code: "adult", label: "Adult", minCount: 0, maxCount: 8 },
+];
+export function buildExtraDraftShape(content, options = {}) {
+    const flags = defaultDraftShapeFlags();
+    const standalone = options.standalone ?? false;
+    // Project the extra + its options as add-on offers. The extra
+    // itself becomes the lead item; sub-options follow.
+    const items = [
+        {
+            id: content.extra.id,
+            name: content.extra.name,
+            description: content.extra.description ?? null,
+            kind: kindForExtraCategory(content.extra.category ?? null),
+            pricingMode: content.extra.pricing_mode ?? null,
+        },
+        ...content.options.map((opt) => ({
+            id: opt.id,
+            name: opt.name,
+            description: opt.description ?? null,
+            kind: "extras",
+            pricingMode: null,
+        })),
+    ];
+    return {
+        ...flags,
+        showsConfigure: standalone,
+        showsTravelers: standalone,
+        showsPayment: standalone,
+        showsAddons: true,
+        paxBands: DEGENERATE_PAX_BANDS,
+        paxBandsAllowedTotal: paxBandsAllowedTotalFrom(DEGENERATE_PAX_BANDS),
+        travelerFields: standalone ? defaultTravelerFields() : [],
+        bookingFields: standalone ? defaultBookingFields() : [],
+        addons: { catalog: items },
+        paymentIntents: standalone ? ["hold", "card"] : [],
+    };
+}
+function kindForExtraCategory(category) {
+    if (!category)
+        return "extras";
+    const lower = category.toLowerCase();
+    if (lower.includes("excursion") || lower.includes("tour"))
+        return "excursions";
+    if (lower.includes("insurance"))
+        return "insurance";
+    return "extras";
+}

package/dist/extras/routes.d.ts

@@ -0,0 +1,380 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+type Env = {
+    Variables: {
+        db: PostgresJsDatabase;
+    };
+};
+export declare const inventoryExtrasRoutes: import("hono/hono-base").HonoBase<Env, {
+    "/product-extras": {
+        $get: {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    productId: string;
+                    supplierId: string | null;
+                    code: string | null;
+                    name: string;
+                    description: string | null;
+                    selectionType: "optional" | "required" | "default_selected" | "unavailable";
+                    pricingMode: "on_request" | "per_booking" | "per_person" | "free" | "included" | "quantity_based";
+                    pricedPerPerson: boolean;
+                    collectionMode: "none" | "external" | "included" | "booking_total" | "cash_on_trip";
+                    showOnSlotManifest: boolean;
+                    minQuantity: number | null;
+                    maxQuantity: number | null;
+                    defaultQuantity: number | null;
+                    active: boolean;
+                    sortOrder: number;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
+                }[];
+                total: number;
+                limit: number;
+                offset: number;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/product-extras": {
+        $post: {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    name: string;
+                    active: boolean;
+                    description: string | null;
+                    supplierId: string | null;
+                    createdAt: string;
+                    updatedAt: string;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    code: string | null;
+                    productId: string;
+                    sortOrder: number;
+                    minQuantity: number | null;
+                    maxQuantity: number | null;
+                    pricingMode: "on_request" | "per_booking" | "per_person" | "free" | "included" | "quantity_based";
+                    selectionType: "optional" | "required" | "default_selected" | "unavailable";
+                    pricedPerPerson: boolean;
+                    collectionMode: "none" | "external" | "included" | "booking_total" | "cash_on_trip";
+                    showOnSlotManifest: boolean;
+                    defaultQuantity: number | null;
+                } | null;
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/product-extras/:id": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    productId: string;
+                    supplierId: string | null;
+                    code: string | null;
+                    name: string;
+                    description: string | null;
+                    selectionType: "optional" | "required" | "default_selected" | "unavailable";
+                    pricingMode: "on_request" | "per_booking" | "per_person" | "free" | "included" | "quantity_based";
+                    pricedPerPerson: boolean;
+                    collectionMode: "none" | "external" | "included" | "booking_total" | "cash_on_trip";
+                    showOnSlotManifest: boolean;
+                    minQuantity: number | null;
+                    maxQuantity: number | null;
+                    defaultQuantity: number | null;
+                    active: boolean;
+                    sortOrder: number;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/product-extras/:id": {
+        $patch: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    productId: string;
+                    supplierId: string | null;
+                    code: string | null;
+                    name: string;
+                    description: string | null;
+                    selectionType: "optional" | "required" | "default_selected" | "unavailable";
+                    pricingMode: "on_request" | "per_booking" | "per_person" | "free" | "included" | "quantity_based";
+                    pricedPerPerson: boolean;
+                    collectionMode: "none" | "external" | "included" | "booking_total" | "cash_on_trip";
+                    showOnSlotManifest: boolean;
+                    minQuantity: number | null;
+                    maxQuantity: number | null;
+                    defaultQuantity: number | null;
+                    active: boolean;
+                    sortOrder: number;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/product-extras/:id": {
+        $delete: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                success: true;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/option-extra-configs": {
+        $get: {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    optionId: string;
+                    productExtraId: string;
+                    selectionType: "optional" | "required" | "default_selected" | "unavailable" | null;
+                    pricingMode: "on_request" | "per_booking" | "per_person" | "free" | "included" | "quantity_based" | null;
+                    pricedPerPerson: boolean | null;
+                    minQuantity: number | null;
+                    maxQuantity: number | null;
+                    defaultQuantity: number | null;
+                    isDefault: boolean;
+                    active: boolean;
+                    sortOrder: number;
+                    notes: string | null;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
+                }[];
+                total: number;
+                limit: number;
+                offset: number;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/option-extra-configs": {
+        $post: {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    active: boolean;
+                    createdAt: string;
+                    updatedAt: string;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    notes: string | null;
+                    isDefault: boolean;
+                    sortOrder: number;
+                    optionId: string;
+                    minQuantity: number | null;
+                    maxQuantity: number | null;
+                    pricingMode: "on_request" | "per_booking" | "per_person" | "free" | "included" | "quantity_based" | null;
+                    selectionType: "optional" | "required" | "default_selected" | "unavailable" | null;
+                    pricedPerPerson: boolean | null;
+                    defaultQuantity: number | null;
+                    productExtraId: string;
+                } | null;
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/option-extra-configs/:id": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    optionId: string;
+                    productExtraId: string;
+                    selectionType: "optional" | "required" | "default_selected" | "unavailable" | null;
+                    pricingMode: "on_request" | "per_booking" | "per_person" | "free" | "included" | "quantity_based" | null;
+                    pricedPerPerson: boolean | null;
+                    minQuantity: number | null;
+                    maxQuantity: number | null;
+                    defaultQuantity: number | null;
+                    isDefault: boolean;
+                    active: boolean;
+                    sortOrder: number;
+                    notes: string | null;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/option-extra-configs/:id": {
+        $patch: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    optionId: string;
+                    productExtraId: string;
+                    selectionType: "optional" | "required" | "default_selected" | "unavailable" | null;
+                    pricingMode: "on_request" | "per_booking" | "per_person" | "free" | "included" | "quantity_based" | null;
+                    pricedPerPerson: boolean | null;
+                    minQuantity: number | null;
+                    maxQuantity: number | null;
+                    defaultQuantity: number | null;
+                    isDefault: boolean;
+                    active: boolean;
+                    sortOrder: number;
+                    notes: string | null;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/option-extra-configs/:id": {
+        $delete: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                success: true;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/option-extra-configs/:id">;
+export type InventoryExtrasRoutes = typeof inventoryExtrasRoutes;
+export {};
+//# sourceMappingURL=routes.d.ts.map

package/dist/extras/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/extras/routes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAajE,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;KACvB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAuE9B,CAAA;AAEJ,MAAM,MAAM,qBAAqB,GAAG,OAAO,qBAAqB,CAAA"}

package/dist/extras/routes.js

@@ -0,0 +1,59 @@
+import { parseJsonBody, parseQuery } from "@voyant-travel/hono";
+import { Hono } from "hono";
+import { inventoryExtrasService } from "./service.js";
+import { insertOptionExtraConfigSchema, insertProductExtraSchema, optionExtraConfigListQuerySchema, productExtraListQuerySchema, updateOptionExtraConfigSchema, updateProductExtraSchema, } from "./validation.js";
+export const inventoryExtrasRoutes = new Hono()
+    .get("/product-extras", async (c) => {
+    const query = await parseQuery(c, productExtraListQuerySchema);
+    return c.json(await inventoryExtrasService.listProductExtras(c.get("db"), query));
+})
+    .post("/product-extras", async (c) => {
+    return c.json({
+        data: await inventoryExtrasService.createProductExtra(c.get("db"), await parseJsonBody(c, insertProductExtraSchema)),
+    }, 201);
+})
+    .get("/product-extras/:id", async (c) => {
+    const row = await inventoryExtrasService.getProductExtraById(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Product extra not found" }, 404);
+    return c.json({ data: row });
+})
+    .patch("/product-extras/:id", async (c) => {
+    const row = await inventoryExtrasService.updateProductExtra(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateProductExtraSchema));
+    if (!row)
+        return c.json({ error: "Product extra not found" }, 404);
+    return c.json({ data: row });
+})
+    .delete("/product-extras/:id", async (c) => {
+    const row = await inventoryExtrasService.deleteProductExtra(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Product extra not found" }, 404);
+    return c.json({ success: true });
+})
+    .get("/option-extra-configs", async (c) => {
+    const query = await parseQuery(c, optionExtraConfigListQuerySchema);
+    return c.json(await inventoryExtrasService.listOptionExtraConfigs(c.get("db"), query));
+})
+    .post("/option-extra-configs", async (c) => {
+    return c.json({
+        data: await inventoryExtrasService.createOptionExtraConfig(c.get("db"), await parseJsonBody(c, insertOptionExtraConfigSchema)),
+    }, 201);
+})
+    .get("/option-extra-configs/:id", async (c) => {
+    const row = await inventoryExtrasService.getOptionExtraConfigById(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Option extra config not found" }, 404);
+    return c.json({ data: row });
+})
+    .patch("/option-extra-configs/:id", async (c) => {
+    const row = await inventoryExtrasService.updateOptionExtraConfig(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateOptionExtraConfigSchema));
+    if (!row)
+        return c.json({ error: "Option extra config not found" }, 404);
+    return c.json({ data: row });
+})
+    .delete("/option-extra-configs/:id", async (c) => {
+    const row = await inventoryExtrasService.deleteOptionExtraConfig(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Option extra config not found" }, 404);
+    return c.json({ success: true });
+});