@voyant-travel/accommodations 0.106.1 → 0.108.0

package/dist/index.d.ts

@@ -1,8 +1,26 @@
+import type { LinkableDefinition, Module } from "@voyant-travel/core";
+import type { HonoModule } from "@voyant-travel/hono/module";
+/**
+ * Room blocks are the accommodations module's first linkable surface — a
+ * standard, package-owned allotment primitive that any deployment can use
+ * (the MICE spine merely links to it). See RFC voyant#1489.
+ */
+export declare const roomBlockLinkable: LinkableDefinition;
+export declare const accommodationsLinkable: {
+    roomBlock: LinkableDefinition;
+};
+export declare const accommodationsModule: Module;
+export declare const accommodationsHonoModule: HonoModule;
+export declare const accommodationsHonoModules: readonly [HonoModule];
 export * from "./booking-engine/index.js";
 export * from "./catalog-policy.js";
 export * from "./content-shape.js";
 export * from "./draft-shape.js";
+export type { RoomBlockAdminRoutes } from "./routes-room-blocks.js";
+export { roomBlockAdminRoutes } from "./routes-room-blocks.js";
 export * from "./service-catalog-plane.js";
 export * from "./service-content.js";
 export * from "./service-content-synthesizer.js";
+export * from "./service-room-blocks.js";
+export * from "./validation-room-blocks.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAA;AACzC,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,sBAAsB,CAAA;AACpC,cAAc,kCAAkC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAI5D;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,kBAK/B,CAAA;AAED,eAAO,MAAM,sBAAsB;;CAElC,CAAA;AAED,eAAO,MAAM,oBAAoB,EAAE,MAKlC,CAAA;AAED,eAAO,MAAM,wBAAwB,EAAE,UAGtC,CAAA;AAED,eAAO,MAAM,yBAAyB,uBAAsC,CAAA;AAE5E,cAAc,2BAA2B,CAAA;AACzC,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,YAAY,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAC9D,cAAc,4BAA4B,CAAA;AAC1C,cAAc,sBAAsB,CAAA;AACpC,cAAc,kCAAkC,CAAA;AAChD,cAAc,0BAA0B,CAAA;AACxC,cAAc,6BAA6B,CAAA"}

package/dist/index.js

@@ -1,7 +1,36 @@
+import { roomBlockAdminRoutes } from "./routes-room-blocks.js";
+/**
+ * Room blocks are the accommodations module's first linkable surface — a
+ * standard, package-owned allotment primitive that any deployment can use
+ * (the MICE spine merely links to it). See RFC voyant#1489.
+ */
+export const roomBlockLinkable = {
+    module: "accommodations",
+    entity: "roomBlock",
+    table: "room_blocks",
+    idPrefix: "hrbl",
+};
+export const accommodationsLinkable = {
+    roomBlock: roomBlockLinkable,
+};
+export const accommodationsModule = {
+    name: "accommodations",
+    // Pickup / reversal / cutoff mutate per-night counters under a transaction.
+    requiresTransactionalDb: true,
+    linkable: accommodationsLinkable,
+};
+export const accommodationsHonoModule = {
+    module: accommodationsModule,
+    adminRoutes: roomBlockAdminRoutes,
+};
+export const accommodationsHonoModules = [accommodationsHonoModule];
 export * from "./booking-engine/index.js";
 export * from "./catalog-policy.js";
 export * from "./content-shape.js";
 export * from "./draft-shape.js";
+export { roomBlockAdminRoutes } from "./routes-room-blocks.js";
 export * from "./service-catalog-plane.js";
 export * from "./service-content.js";
 export * from "./service-content-synthesizer.js";
+export * from "./service-room-blocks.js";
+export * from "./validation-room-blocks.js";

package/dist/routes-room-blocks.d.ts

@@ -0,0 +1,302 @@
+/**
+ * Room-block admin routes. Mounted by the deployment under
+ * `/v1/admin/accommodations` (so these resolve at
+ * `/v1/admin/accommodations/room-blocks/*`). The accommodations module sets
+ * `requiresTransactionalDb`, so the pickup/reversal/release mutations run on
+ * the transactional DB. See RFC voyant#1489 §4.2/§8.
+ *
+ * Routes stay thin: validate input, call `roomBlockService`, serialize.
+ */
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+type Env = {
+    Variables: {
+        db: PostgresJsDatabase;
+        userId?: string;
+    };
+};
+export declare const roomBlockAdminRoutes: import("hono/hono-base").HonoBase<Env, {
+    "/room-blocks": {
+        $post: {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    createdAt: string;
+                    updatedAt: string;
+                    propertyId: string | null;
+                    supplierId: string | null;
+                    name: string;
+                    currency: string;
+                    status: "held" | "confirmed" | "cancelled" | "expired" | "inquiry" | "released";
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    notes: string | null;
+                    roomTypeId: string;
+                    programId: string | null;
+                    netRateCents: number | null;
+                    sellRateCents: number | null;
+                    optionDate: string | null;
+                    cutoffDate: string | null;
+                    attritionTerms: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    depositTerms: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                };
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/room-blocks/:id": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    block: {
+                        id: string;
+                        createdAt: string;
+                        updatedAt: string;
+                        propertyId: string | null;
+                        supplierId: string | null;
+                        name: string;
+                        currency: string;
+                        status: "held" | "confirmed" | "cancelled" | "expired" | "inquiry" | "released";
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
+                        notes: string | null;
+                        roomTypeId: string;
+                        programId: string | null;
+                        netRateCents: number | null;
+                        sellRateCents: number | null;
+                        optionDate: string | null;
+                        cutoffDate: string | null;
+                        attritionTerms: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
+                        depositTerms: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
+                    };
+                    summary: {
+                        blockId: string;
+                        status: import("./schema-room-blocks.js").RoomBlock["status"];
+                        totalHeld: number;
+                        totalPickedUp: number;
+                        totalReleased: number;
+                        totalRemaining: number;
+                        pickupProgress: import("@voyant-travel/allotments").PickupProgress;
+                    } | null;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/room-blocks/:id/nights": {
+        $put: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    blockId: string;
+                    status: import("./schema-room-blocks.js").RoomBlock["status"];
+                    totalHeld: number;
+                    totalPickedUp: number;
+                    totalReleased: number;
+                    totalRemaining: number;
+                    pickupProgress: import("@voyant-travel/allotments").PickupProgress;
+                } | null;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/room-blocks/:id/pickups": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    status: "active" | "reversed";
+                    bookingId: string | null;
+                    rooms: number;
+                    checkIn: string;
+                    checkOut: string;
+                    stayBookingItemId: string | null;
+                    blockId: string;
+                    pickedUpAt: string;
+                    reversedAt: string | null;
+                };
+            };
+            outputFormat: "json";
+            status: 200 | 201;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 409;
+        };
+    };
+} & {
+    "/room-blocks/:id/pickups/reverse": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    status: "active" | "reversed";
+                    bookingId: string | null;
+                    rooms: number;
+                    checkIn: string;
+                    checkOut: string;
+                    stayBookingItemId: string | null;
+                    blockId: string;
+                    pickedUpAt: string;
+                    reversedAt: string | null;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/room-blocks/:id/release": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    releasedRooms: number;
+                    block: {
+                        id: string;
+                        createdAt: string;
+                        updatedAt: string;
+                        propertyId: string | null;
+                        supplierId: string | null;
+                        name: string;
+                        currency: string;
+                        status: "held" | "confirmed" | "cancelled" | "expired" | "inquiry" | "released";
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
+                        notes: string | null;
+                        roomTypeId: string;
+                        programId: string | null;
+                        netRateCents: number | null;
+                        sellRateCents: number | null;
+                        optionDate: string | null;
+                        cutoffDate: string | null;
+                        attritionTerms: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
+                        depositTerms: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
+                    };
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/room-blocks/:id/release">;
+export type RoomBlockAdminRoutes = typeof roomBlockAdminRoutes;
+export {};
+//# sourceMappingURL=routes-room-blocks.d.ts.map

package/dist/routes-room-blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-room-blocks.d.ts","sourceRoot":"","sources":["../src/routes-room-blocks.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAmBjE,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCA2D7B,CAAA;AAEJ,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA"}

package/dist/routes-room-blocks.js

@@ -0,0 +1,72 @@
+/**
+ * Room-block admin routes. Mounted by the deployment under
+ * `/v1/admin/accommodations` (so these resolve at
+ * `/v1/admin/accommodations/room-blocks/*`). The accommodations module sets
+ * `requiresTransactionalDb`, so the pickup/reversal/release mutations run on
+ * the transactional DB. See RFC voyant#1489 §4.2/§8.
+ *
+ * Routes stay thin: validate input, call `roomBlockService`, serialize.
+ */
+import { parseJsonBody } from "@voyant-travel/hono";
+import { Hono } from "hono";
+import { createRoomBlock, getRoomBlock, pickupRoomBlock, releaseRoomBlockAtCutoff, reverseRoomBlockPickup, setRoomBlockNights, summarizeRoomBlock, } from "./service-room-blocks.js";
+import { createRoomBlockSchema, reverseRoomBlockPickupSchema, roomBlockPickupSchema, setRoomBlockNightsSchema, } from "./validation-room-blocks.js";
+export const roomBlockAdminRoutes = new Hono()
+    .post("/room-blocks", async (c) => {
+    const body = await parseJsonBody(c, createRoomBlockSchema);
+    return c.json({ data: await createRoomBlock(c.get("db"), body) }, 201);
+})
+    .get("/room-blocks/:id", async (c) => {
+    const id = c.req.param("id");
+    const block = await getRoomBlock(c.get("db"), id);
+    if (!block)
+        return c.json({ error: "Room block not found" }, 404);
+    const summary = await summarizeRoomBlock(c.get("db"), id);
+    return c.json({ data: { block, summary } });
+})
+    .put("/room-blocks/:id/nights", async (c) => {
+    const id = c.req.param("id");
+    const block = await getRoomBlock(c.get("db"), id);
+    if (!block)
+        return c.json({ error: "Room block not found" }, 404);
+    const { nights } = await parseJsonBody(c, setRoomBlockNightsSchema);
+    await setRoomBlockNights(c.get("db"), id, nights);
+    return c.json({ data: await summarizeRoomBlock(c.get("db"), id) });
+})
+    .post("/room-blocks/:id/pickups", async (c) => {
+    const body = await parseJsonBody(c, roomBlockPickupSchema);
+    const outcome = await pickupRoomBlock(c.get("db"), { blockId: c.req.param("id"), ...body });
+    switch (outcome.status) {
+        case "ok":
+            return c.json({ data: outcome.pickup }, outcome.idempotent ? 200 : 201);
+        case "block_not_found":
+            return c.json({ error: "Room block not found" }, 404);
+        case "invalid_range":
+            return c.json({ error: "Invalid check-in/check-out range" }, 400);
+        case "block_not_active":
+            return c.json({ error: "Room block is no longer accepting pickups" }, 409);
+        case "night_unavailable":
+            return c.json({
+                error: "Insufficient inventory",
+                detail: { date: outcome.date, remaining: outcome.remaining, needed: outcome.needed },
+            }, 409);
+    }
+})
+    .post("/room-blocks/:id/pickups/reverse", async (c) => {
+    const body = await parseJsonBody(c, reverseRoomBlockPickupSchema);
+    const outcome = await reverseRoomBlockPickup(c.get("db"), {
+        blockId: c.req.param("id"),
+        ...body,
+    });
+    if (outcome.status === "pickup_not_found") {
+        return c.json({ error: "Active pickup not found" }, 404);
+    }
+    return c.json({ data: outcome.pickup });
+})
+    .post("/room-blocks/:id/release", async (c) => {
+    const outcome = await releaseRoomBlockAtCutoff(c.get("db"), { blockId: c.req.param("id") });
+    if (outcome.status === "block_not_found") {
+        return c.json({ error: "Room block not found" }, 404);
+    }
+    return c.json({ data: { releasedRooms: outcome.releasedRooms, block: outcome.block } });
+});

package/dist/schema-bookings.d.ts

@@ -279,7 +279,7 @@ export declare const stayBookingItems: import("drizzle-orm/pg-core").PgTableWith
             tableName: "stay_booking_items";
             dataType: "string";
             columnType: "PgEnumColumn";
-            data: "cancelled" | "reserved" | "no_show";
+            data: "cancelled" | "no_show" | "reserved";
             driverParam: string;
             notNull: true;
             hasDefault: true;