@voyantjs/bookings 0.4.5 → 0.5.0

package/dist/schema-groups.d.ts

@@ -0,0 +1,261 @@
+export declare const bookingGroupKindEnum: import("drizzle-orm/pg-core").PgEnum<["shared_room", "other"]>;
+export declare const bookingGroupMemberRoleEnum: import("drizzle-orm/pg-core").PgEnum<["primary", "shared"]>;
+export declare const bookingGroups: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "booking_groups";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "booking_groups";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "kind";
+            tableName: "booking_groups";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "other" | "shared_room";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["shared_room", "other"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        label: import("drizzle-orm/pg-core").PgColumn<{
+            name: "label";
+            tableName: "booking_groups";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        primaryBookingId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "booking_groups";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        productId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "product_id";
+            tableName: "booking_groups";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        optionUnitId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "option_unit_id";
+            tableName: "booking_groups";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "booking_groups";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "booking_groups";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "booking_groups";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const bookingGroupMembers: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "booking_group_members";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "booking_group_members";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        groupId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "booking_group_members";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        bookingId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "booking_group_members";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        role: import("drizzle-orm/pg-core").PgColumn<{
+            name: "role";
+            tableName: "booking_group_members";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "primary" | "shared";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["primary", "shared"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "booking_group_members";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type BookingGroup = typeof bookingGroups.$inferSelect;
+export type NewBookingGroup = typeof bookingGroups.$inferInsert;
+export type BookingGroupMember = typeof bookingGroupMembers.$inferSelect;
+export type NewBookingGroupMember = typeof bookingGroupMembers.$inferInsert;
+//# sourceMappingURL=schema-groups.d.ts.map

package/dist/schema-groups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-groups.d.ts","sourceRoot":"","sources":["../src/schema-groups.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,oBAAoB,gEAAyD,CAAA;AAE1F,eAAO,MAAM,0BAA0B,6DAA6D,CAAA;AAEpG,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBzB,CAAA;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiB/B,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,OAAO,aAAa,CAAC,YAAY,CAAA;AAC5D,MAAM,MAAM,eAAe,GAAG,OAAO,aAAa,CAAC,YAAY,CAAA;AAC/D,MAAM,MAAM,kBAAkB,GAAG,OAAO,mBAAmB,CAAC,YAAY,CAAA;AACxE,MAAM,MAAM,qBAAqB,GAAG,OAAO,mBAAmB,CAAC,YAAY,CAAA"}

package/dist/schema-groups.js

@@ -0,0 +1,34 @@
+import { typeId, typeIdRef } from "@voyantjs/db/lib/typeid-column";
+import { index, jsonb, pgEnum, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+import { bookings } from "./schema-core";
+export const bookingGroupKindEnum = pgEnum("booking_group_kind", ["shared_room", "other"]);
+export const bookingGroupMemberRoleEnum = pgEnum("booking_group_member_role", ["primary", "shared"]);
+export const bookingGroups = pgTable("booking_groups", {
+    id: typeId("booking_groups"),
+    kind: bookingGroupKindEnum("kind").notNull().default("shared_room"),
+    label: text("label").notNull(),
+    primaryBookingId: typeIdRef("primary_booking_id"),
+    productId: text("product_id"),
+    optionUnitId: text("option_unit_id"),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_booking_groups_kind").on(table.kind),
+    index("idx_booking_groups_product").on(table.productId),
+    index("idx_booking_groups_option_unit").on(table.optionUnitId),
+]);
+export const bookingGroupMembers = pgTable("booking_group_members", {
+    id: typeId("booking_group_members"),
+    groupId: typeIdRef("group_id")
+        .notNull()
+        .references(() => bookingGroups.id, { onDelete: "cascade" }),
+    bookingId: typeIdRef("booking_id")
+        .notNull()
+        .references(() => bookings.id, { onDelete: "cascade" }),
+    role: bookingGroupMemberRoleEnum("role").notNull().default("shared"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    uniqueIndex("booking_group_members_booking_unique").on(table.bookingId),
+    index("idx_booking_group_members_group").on(table.groupId),
+]);

package/dist/schema-relations.d.ts

@@ -9,6 +9,14 @@ export declare const bookingsRelations: import("drizzle-orm").Relations<"booking
     redemptionEvents: import("drizzle-orm").Many<"booking_redemption_events">;
     items: import("drizzle-orm").Many<"booking_items">;
     allocations: import("drizzle-orm").Many<"booking_allocations">;
+    groupMemberships: import("drizzle-orm").Many<"booking_group_members">;
+}>;
+export declare const bookingGroupsRelations: import("drizzle-orm").Relations<"booking_groups", {
+    members: import("drizzle-orm").Many<"booking_group_members">;
+}>;
+export declare const bookingGroupMembersRelations: import("drizzle-orm").Relations<"booking_group_members", {
+    group: import("drizzle-orm").One<"booking_groups", true>;
+    booking: import("drizzle-orm").One<"bookings", true>;
 }>;
 export declare const bookingParticipantsRelations: import("drizzle-orm").Relations<"booking_participants", {
     booking: import("drizzle-orm").One<"bookings", true>;

package/dist/schema-relations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-relations.d.ts","sourceRoot":"","sources":["../src/schema-relations.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,iBAAiB;;;;;;;;;;;EAW3B,CAAA;AAEH,eAAO,MAAM,4BAA4B;;;;;;EAMtC,CAAA;AAEH,eAAO,MAAM,qBAAqB;;;;;;EAM/B,CAAA;AAEH,eAAO,MAAM,2BAA2B;;;;EAUrC,CAAA;AAEH,eAAO,MAAM,gCAAgC;;;EAS1C,CAAA;AAEH,eAAO,MAAM,gCAAgC;;EAK1C,CAAA;AAEH,eAAO,MAAM,4BAA4B;;;;EAUtC,CAAA;AAEH,eAAO,MAAM,gCAAgC;;;;EAa1C,CAAA;AAEH,eAAO,MAAM,2BAA2B;;EAErC,CAAA;AAEH,eAAO,MAAM,6BAA6B;;EAKvC,CAAA;AAEH,eAAO,MAAM,qBAAqB;;EAE/B,CAAA;AAEH,eAAO,MAAM,yBAAyB;;;EAMnC,CAAA"}
+{"version":3,"file":"schema-relations.d.ts","sourceRoot":"","sources":["../src/schema-relations.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;EAY3B,CAAA;AAEH,eAAO,MAAM,sBAAsB;;EAEhC,CAAA;AAEH,eAAO,MAAM,4BAA4B;;;EAStC,CAAA;AAEH,eAAO,MAAM,4BAA4B;;;;;;EAMtC,CAAA;AAEH,eAAO,MAAM,qBAAqB;;;;;;EAM/B,CAAA;AAEH,eAAO,MAAM,2BAA2B;;;;EAUrC,CAAA;AAEH,eAAO,MAAM,gCAAgC;;;EAS1C,CAAA;AAEH,eAAO,MAAM,gCAAgC;;EAK1C,CAAA;AAEH,eAAO,MAAM,4BAA4B;;;;EAUtC,CAAA;AAEH,eAAO,MAAM,gCAAgC;;;;EAa1C,CAAA;AAEH,eAAO,MAAM,2BAA2B;;EAErC,CAAA;AAEH,eAAO,MAAM,6BAA6B;;EAKvC,CAAA;AAEH,eAAO,MAAM,qBAAqB;;EAE/B,CAAA;AAEH,eAAO,MAAM,yBAAyB;;;EAMnC,CAAA"}

package/dist/schema-relations.js

@@ -1,6 +1,7 @@
 import { relations } from "drizzle-orm";
 import { availabilitySlotsRef } from "./availability-ref.js";
 import { bookingParticipants, bookings } from "./schema-core";
+import { bookingGroupMembers, bookingGroups } from "./schema-groups";
 import { bookingAllocations, bookingFulfillments, bookingItemParticipants, bookingItems, bookingRedemptionEvents, } from "./schema-items";
 import { bookingActivityLog, bookingDocuments, bookingNotes, bookingSessionStates, bookingSupplierStatuses, } from "./schema-operations";
 export const bookingsRelations = relations(bookings, ({ many }) => ({
@@ -14,6 +15,20 @@ export const bookingsRelations = relations(bookings, ({ many }) => ({
     redemptionEvents: many(bookingRedemptionEvents),
     items: many(bookingItems),
     allocations: many(bookingAllocations),
+    groupMemberships: many(bookingGroupMembers),
+}));
+export const bookingGroupsRelations = relations(bookingGroups, ({ many }) => ({
+    members: many(bookingGroupMembers),
+}));
+export const bookingGroupMembersRelations = relations(bookingGroupMembers, ({ one }) => ({
+    group: one(bookingGroups, {
+        fields: [bookingGroupMembers.groupId],
+        references: [bookingGroups.id],
+    }),
+    booking: one(bookings, {
+        fields: [bookingGroupMembers.bookingId],
+        references: [bookings.id],
+    }),
 }));
 export const bookingParticipantsRelations = relations(bookingParticipants, ({ one, many }) => ({
     booking: one(bookings, { fields: [bookingParticipants.bookingId], references: [bookings.id] }),

package/dist/schema.d.ts

@@ -1,4 +1,5 @@
 export * from "./schema-core";
+export * from "./schema-groups";
 export * from "./schema-items";
 export * from "./schema-operations";
 export * from "./schema-relations";

package/dist/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA"}

package/dist/schema.js

@@ -1,4 +1,5 @@
 export * from "./schema-core";
+export * from "./schema-groups";
 export * from "./schema-items";
 export * from "./schema-operations";
 export * from "./schema-relations";

package/dist/service-groups.d.ts

@@ -0,0 +1,69 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import { type Booking, type BookingPassenger } from "./schema-core.js";
+import { type BookingGroup, type BookingGroupMember } from "./schema-groups.js";
+import type { addBookingGroupMemberSchema, bookingGroupListQuerySchema, insertBookingGroupSchema, updateBookingGroupSchema } from "./validation.js";
+export type BookingGroupListQuery = z.infer<typeof bookingGroupListQuerySchema>;
+export type CreateBookingGroupInput = z.infer<typeof insertBookingGroupSchema>;
+export type UpdateBookingGroupInput = z.infer<typeof updateBookingGroupSchema>;
+export type AddBookingGroupMemberInput = z.infer<typeof addBookingGroupMemberSchema>;
+export type BookingGroupMemberWithBooking = BookingGroupMember & {
+    booking: Booking | null;
+};
+export declare function listBookingGroups(db: PostgresJsDatabase, query: BookingGroupListQuery): Promise<{
+    data: BookingGroup[];
+    total: number;
+    limit: number;
+    offset: number;
+}>;
+export declare function getBookingGroupById(db: PostgresJsDatabase, id: string): Promise<BookingGroup | null>;
+export declare function createBookingGroup(db: PostgresJsDatabase, data: CreateBookingGroupInput): Promise<BookingGroup>;
+export declare function updateBookingGroup(db: PostgresJsDatabase, id: string, data: UpdateBookingGroupInput): Promise<BookingGroup | null>;
+export declare function deleteBookingGroup(db: PostgresJsDatabase, id: string): Promise<{
+    id: string;
+} | null>;
+export declare function listGroupMembers(db: PostgresJsDatabase, groupId: string): Promise<BookingGroupMemberWithBooking[]>;
+export declare function getBookingGroupForBooking(db: PostgresJsDatabase, bookingId: string): Promise<(BookingGroup & {
+    membership: BookingGroupMember;
+}) | null>;
+export declare function addGroupMember(db: PostgresJsDatabase, groupId: string, data: AddBookingGroupMemberInput): Promise<{
+    status: "ok";
+    member: BookingGroupMember;
+} | {
+    status: "group_not_found";
+} | {
+    status: "booking_not_found";
+} | {
+    status: "already_in_group";
+    currentGroupId: string;
+}>;
+export declare function removeGroupMember(db: PostgresJsDatabase, groupId: string, bookingId: string): Promise<{
+    id: string;
+} | null>;
+/**
+ * Dissolve or slim down a booking group after a member is cancelled.
+ *
+ * - 3+ active members remain: no-op (group stays intact)
+ * - 1 active member remains: dissolve (delete last member + group)
+ * - 0 active members remain: delete the group
+ */
+export declare function cleanupGroupOnBookingCancelled(db: PostgresJsDatabase, bookingId: string): Promise<void>;
+/**
+ * Returns all passengers across every member booking in a group.
+ * Used by rooming-list exports to show shared-room occupants as one unit.
+ */
+export declare function listGroupBookingPassengers(db: PostgresJsDatabase, groupId: string): Promise<BookingPassenger[]>;
+export declare const bookingGroupsService: {
+    listBookingGroups: typeof listBookingGroups;
+    getBookingGroupById: typeof getBookingGroupById;
+    createBookingGroup: typeof createBookingGroup;
+    updateBookingGroup: typeof updateBookingGroup;
+    deleteBookingGroup: typeof deleteBookingGroup;
+    listGroupMembers: typeof listGroupMembers;
+    getBookingGroupForBooking: typeof getBookingGroupForBooking;
+    addGroupMember: typeof addGroupMember;
+    removeGroupMember: typeof removeGroupMember;
+    cleanupGroupOnBookingCancelled: typeof cleanupGroupOnBookingCancelled;
+    listGroupBookingPassengers: typeof listGroupBookingPassengers;
+};
+//# sourceMappingURL=service-groups.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-groups.d.ts","sourceRoot":"","sources":["../src/service-groups.ts"],"names":[],"mappings":"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"}

package/dist/service-groups.js

@@ -0,0 +1,199 @@
+import { and, asc, eq, inArray, sql } from "drizzle-orm";
+import { bookingPassengers, bookings } from "./schema-core.js";
+import { bookingGroupMembers, bookingGroups, } from "./schema-groups.js";
+export async function listBookingGroups(db, query) {
+    const conditions = [];
+    if (query.kind)
+        conditions.push(eq(bookingGroups.kind, query.kind));
+    if (query.productId)
+        conditions.push(eq(bookingGroups.productId, query.productId));
+    if (query.optionUnitId)
+        conditions.push(eq(bookingGroups.optionUnitId, query.optionUnitId));
+    const where = conditions.length ? and(...conditions) : undefined;
+    const [rows, countResult] = await Promise.all([
+        db
+            .select()
+            .from(bookingGroups)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(bookingGroups.createdAt)),
+        db.select({ count: sql `count(*)::int` }).from(bookingGroups).where(where),
+    ]);
+    return {
+        data: rows,
+        total: countResult[0]?.count ?? 0,
+        limit: query.limit,
+        offset: query.offset,
+    };
+}
+export async function getBookingGroupById(db, id) {
+    const [row] = await db.select().from(bookingGroups).where(eq(bookingGroups.id, id)).limit(1);
+    return row ?? null;
+}
+export async function createBookingGroup(db, data) {
+    const [row] = await db.insert(bookingGroups).values(data).returning();
+    if (!row)
+        throw new Error("Failed to create booking group");
+    return row;
+}
+export async function updateBookingGroup(db, id, data) {
+    const [row] = await db
+        .update(bookingGroups)
+        .set({ ...data, updatedAt: new Date() })
+        .where(eq(bookingGroups.id, id))
+        .returning();
+    return row ?? null;
+}
+export async function deleteBookingGroup(db, id) {
+    const [row] = await db
+        .delete(bookingGroups)
+        .where(eq(bookingGroups.id, id))
+        .returning({ id: bookingGroups.id });
+    return row ?? null;
+}
+export async function listGroupMembers(db, groupId) {
+    const rows = await db
+        .select()
+        .from(bookingGroupMembers)
+        .where(eq(bookingGroupMembers.groupId, groupId))
+        .orderBy(asc(bookingGroupMembers.createdAt));
+    if (rows.length === 0)
+        return [];
+    const bookingIds = rows.map((r) => r.bookingId);
+    const bookingRows = await db.select().from(bookings).where(inArray(bookings.id, bookingIds));
+    const bookingMap = new Map(bookingRows.map((b) => [b.id, b]));
+    return rows.map((member) => ({
+        ...member,
+        booking: bookingMap.get(member.bookingId) ?? null,
+    }));
+}
+export async function getBookingGroupForBooking(db, bookingId) {
+    const [membership] = await db
+        .select()
+        .from(bookingGroupMembers)
+        .where(eq(bookingGroupMembers.bookingId, bookingId))
+        .limit(1);
+    if (!membership)
+        return null;
+    const [group] = await db
+        .select()
+        .from(bookingGroups)
+        .where(eq(bookingGroups.id, membership.groupId))
+        .limit(1);
+    if (!group)
+        return null;
+    return { ...group, membership };
+}
+export async function addGroupMember(db, groupId, data) {
+    const [group] = await db
+        .select({ id: bookingGroups.id })
+        .from(bookingGroups)
+        .where(eq(bookingGroups.id, groupId))
+        .limit(1);
+    if (!group)
+        return { status: "group_not_found" };
+    const [booking] = await db
+        .select({ id: bookings.id })
+        .from(bookings)
+        .where(eq(bookings.id, data.bookingId))
+        .limit(1);
+    if (!booking)
+        return { status: "booking_not_found" };
+    const [existing] = await db
+        .select({ groupId: bookingGroupMembers.groupId })
+        .from(bookingGroupMembers)
+        .where(eq(bookingGroupMembers.bookingId, data.bookingId))
+        .limit(1);
+    if (existing) {
+        return { status: "already_in_group", currentGroupId: existing.groupId };
+    }
+    const [member] = await db
+        .insert(bookingGroupMembers)
+        .values({
+        groupId,
+        bookingId: data.bookingId,
+        role: data.role,
+    })
+        .returning();
+    if (!member)
+        throw new Error("Failed to add group member");
+    return { status: "ok", member };
+}
+export async function removeGroupMember(db, groupId, bookingId) {
+    const [row] = await db
+        .delete(bookingGroupMembers)
+        .where(and(eq(bookingGroupMembers.groupId, groupId), eq(bookingGroupMembers.bookingId, bookingId)))
+        .returning({ id: bookingGroupMembers.id });
+    return row ?? null;
+}
+/**
+ * Dissolve or slim down a booking group after a member is cancelled.
+ *
+ * - 3+ active members remain: no-op (group stays intact)
+ * - 1 active member remains: dissolve (delete last member + group)
+ * - 0 active members remain: delete the group
+ */
+export async function cleanupGroupOnBookingCancelled(db, bookingId) {
+    const [membership] = await db
+        .select()
+        .from(bookingGroupMembers)
+        .where(eq(bookingGroupMembers.bookingId, bookingId))
+        .limit(1);
+    if (!membership)
+        return;
+    // Remove the cancelled booking's membership
+    await db.delete(bookingGroupMembers).where(eq(bookingGroupMembers.id, membership.id));
+    // Count remaining members with an active (not-cancelled) booking
+    const remaining = await db
+        .select({
+        memberId: bookingGroupMembers.id,
+        bookingId: bookingGroupMembers.bookingId,
+        status: bookings.status,
+    })
+        .from(bookingGroupMembers)
+        .innerJoin(bookings, eq(bookings.id, bookingGroupMembers.bookingId))
+        .where(eq(bookingGroupMembers.groupId, membership.groupId));
+    const active = remaining.filter((r) => r.status !== "cancelled");
+    if (active.length === 0) {
+        // No active members — delete the group (cascades any non-active members)
+        await db.delete(bookingGroups).where(eq(bookingGroups.id, membership.groupId));
+        return;
+    }
+    if (active.length === 1) {
+        // Only one active member left — dissolve the group
+        await db.delete(bookingGroupMembers).where(eq(bookingGroupMembers.groupId, membership.groupId));
+        await db.delete(bookingGroups).where(eq(bookingGroups.id, membership.groupId));
+    }
+}
+/**
+ * Returns all passengers across every member booking in a group.
+ * Used by rooming-list exports to show shared-room occupants as one unit.
+ */
+export async function listGroupBookingPassengers(db, groupId) {
+    const members = await db
+        .select({ bookingId: bookingGroupMembers.bookingId })
+        .from(bookingGroupMembers)
+        .where(eq(bookingGroupMembers.groupId, groupId));
+    if (members.length === 0)
+        return [];
+    const bookingIds = members.map((m) => m.bookingId);
+    return db
+        .select()
+        .from(bookingPassengers)
+        .where(inArray(bookingPassengers.bookingId, bookingIds))
+        .orderBy(asc(bookingPassengers.createdAt));
+}
+export const bookingGroupsService = {
+    listBookingGroups,
+    getBookingGroupById,
+    createBookingGroup,
+    updateBookingGroup,
+    deleteBookingGroup,
+    listGroupMembers,
+    getBookingGroupForBooking,
+    addGroupMember,
+    removeGroupMember,
+    cleanupGroupOnBookingCancelled,
+    listGroupBookingPassengers,
+};

package/dist/service.d.ts

@@ -2620,6 +2620,7 @@ export declare const bookingsService: {
         metadata: Record<string, unknown> | null;
         sellCurrency: string;
         bookingId: string;
+        optionUnitId: string | null;
         title: string;
         description: string | null;
         itemType: "other" | "unit" | "extra" | "service" | "fee" | "tax" | "discount" | "adjustment" | "accommodation" | "transport";
@@ -2630,7 +2631,6 @@ export declare const bookingsService: {
         costCurrency: string | null;
         unitCostAmountCents: number | null;
         totalCostAmountCents: number | null;
-        optionUnitId: string | null;
         pricingCategoryId: string | null;
         sourceSnapshotId: string | null;
         sourceOfferId: string | null;