@voyant-travel/mice 0.2.0 → 0.3.0

package/dist/schema-rooming.d.ts

@@ -0,0 +1,333 @@
+/**
+ * First-class rooming manifest (§9-Q3) — program-centric, replacing the
+ * fragmented roomTypeId + sharingGroupId + allocations-JSONB on booking
+ * traveler details. A shared room is one assignment with MANY delegates via the
+ * explicit join (§9-Q5). See RFC voyant#1489 (Phase 3).
+ */
+export declare const roomingAssignments: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "mice_rooming_assignments";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_rooming_assignments";
+            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;
+        }, {}, {}>;
+        programId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_rooming_assignments";
+            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;
+        }, {}, {}>;
+        roomBlockId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_rooming_assignments";
+            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;
+        }, {}, {}>;
+        roomTypeId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_rooming_assignments";
+            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;
+        }, {}, {}>;
+        bedConfig: import("drizzle-orm/pg-core").PgColumn<{
+            name: "bed_config";
+            tableName: "mice_rooming_assignments";
+            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;
+        }, {}, {}>;
+        sharingGroupId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sharing_group_id";
+            tableName: "mice_rooming_assignments";
+            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;
+        }, {}, {}>;
+        checkIn: import("drizzle-orm/pg-core").PgColumn<{
+            name: "check_in";
+            tableName: "mice_rooming_assignments";
+            dataType: "string";
+            columnType: "PgDateString";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        checkOut: import("drizzle-orm/pg-core").PgColumn<{
+            name: "check_out";
+            tableName: "mice_rooming_assignments";
+            dataType: "string";
+            columnType: "PgDateString";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        specialRequests: import("drizzle-orm/pg-core").PgColumn<{
+            name: "special_requests";
+            tableName: "mice_rooming_assignments";
+            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: "mice_rooming_assignments";
+            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: "mice_rooming_assignments";
+            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: "mice_rooming_assignments";
+            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 roomingAssignmentDelegates: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "mice_rooming_assignment_delegates";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_rooming_assignment_delegates";
+            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;
+        }, {}, {}>;
+        roomingAssignmentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_rooming_assignment_delegates";
+            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;
+        }, {}, {}>;
+        delegateId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_rooming_assignment_delegates";
+            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;
+        }, {}, {}>;
+        isPrimary: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_primary";
+            tableName: "mice_rooming_assignment_delegates";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        bedLabel: import("drizzle-orm/pg-core").PgColumn<{
+            name: "bed_label";
+            tableName: "mice_rooming_assignment_delegates";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "mice_rooming_assignment_delegates";
+            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 RoomingAssignment = typeof roomingAssignments.$inferSelect;
+export type NewRoomingAssignment = typeof roomingAssignments.$inferInsert;
+export type RoomingAssignmentDelegate = typeof roomingAssignmentDelegates.$inferSelect;
+export type NewRoomingAssignmentDelegate = typeof roomingAssignmentDelegates.$inferInsert;
+//# sourceMappingURL=schema-rooming.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-rooming.d.ts","sourceRoot":"","sources":["../src/schema-rooming.ts"],"names":[],"mappings":"AAcA;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwB9B,CAAA;AAED,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBtC,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,OAAO,kBAAkB,CAAC,YAAY,CAAA;AACtE,MAAM,MAAM,oBAAoB,GAAG,OAAO,kBAAkB,CAAC,YAAY,CAAA;AACzE,MAAM,MAAM,yBAAyB,GAAG,OAAO,0BAA0B,CAAC,YAAY,CAAA;AACtF,MAAM,MAAM,4BAA4B,GAAG,OAAO,0BAA0B,CAAC,YAAY,CAAA"}

package/dist/schema-rooming.js

@@ -0,0 +1,47 @@
+import { typeId, typeIdRef } from "@voyant-travel/db/lib/typeid-column";
+import { boolean, date, index, jsonb, pgTable, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+import { programs } from "./schema.js";
+import { programDelegates } from "./schema-delegates.js";
+/**
+ * First-class rooming manifest (§9-Q3) — program-centric, replacing the
+ * fragmented roomTypeId + sharingGroupId + allocations-JSONB on booking
+ * traveler details. A shared room is one assignment with MANY delegates via the
+ * explicit join (§9-Q5). See RFC voyant#1489 (Phase 3).
+ */
+export const roomingAssignments = pgTable("mice_rooming_assignments", {
+    id: typeId("mice_rooming_assignments"),
+    // Intra-package FK:
+    programId: typeIdRef("program_id")
+        .notNull()
+        .references(() => programs.id, { onDelete: "cascade" }),
+    // Cross-package → loose columns + defineLink at the deployment:
+    roomBlockId: typeIdRef("room_block_id"), // → accommodations.roomBlocks
+    roomTypeId: typeIdRef("room_type_id"), // → accommodations.roomTypes
+    bedConfig: text("bed_config"),
+    sharingGroupId: text("sharing_group_id"),
+    checkIn: date("check_in"),
+    checkOut: date("check_out"),
+    specialRequests: text("special_requests"),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_mice_rooming_assignments_program").on(table.programId),
+    index("idx_mice_rooming_assignments_room_block").on(table.roomBlockId),
+]);
+export const roomingAssignmentDelegates = pgTable("mice_rooming_assignment_delegates", {
+    id: typeId("mice_rooming_assignment_delegates"),
+    roomingAssignmentId: typeIdRef("rooming_assignment_id")
+        .notNull()
+        .references(() => roomingAssignments.id, { onDelete: "cascade" }),
+    delegateId: typeIdRef("delegate_id")
+        .notNull()
+        .references(() => programDelegates.id, { onDelete: "cascade" }),
+    isPrimary: boolean("is_primary").notNull().default(false),
+    bedLabel: text("bed_label"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_mice_rooming_assignment_delegates_assignment").on(table.roomingAssignmentId),
+    // A delegate appears at most once per rooming assignment.
+    uniqueIndex("uidx_mice_rooming_assignment_delegates_pair").on(table.roomingAssignmentId, table.delegateId),
+]);

package/dist/schema.d.ts

@@ -326,5 +326,9 @@ export declare const programs: import("drizzle-orm/pg-core").PgTableWithColumns<
 }>;
 export type Program = typeof programs.$inferSelect;
 export type NewProgram = typeof programs.$inferInsert;
+export type { BookingMiceDetail, NewBookingMiceDetail } from "./booking-extension.js";
+export { bookingMiceDetails } from "./booking-extension.js";
+export * from "./schema-delegates.js";
+export * from "./schema-rooming.js";
 export * from "./schema-sessions.js";
 //# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,qGAM1B,CAAA;AAEF,eAAO,MAAM,iBAAiB,iHAO5B,CAAA;AAEF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BpB,CAAA;AAED,MAAM,MAAM,OAAO,GAAG,OAAO,QAAQ,CAAC,YAAY,CAAA;AAClD,MAAM,MAAM,UAAU,GAAG,OAAO,QAAQ,CAAC,YAAY,CAAA;AAErD,cAAc,sBAAsB,CAAA"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,qGAM1B,CAAA;AAEF,eAAO,MAAM,iBAAiB,iHAO5B,CAAA;AAEF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BpB,CAAA;AAED,MAAM,MAAM,OAAO,GAAG,OAAO,QAAQ,CAAC,YAAY,CAAA;AAClD,MAAM,MAAM,UAAU,GAAG,OAAO,QAAQ,CAAC,YAAY,CAAA;AAErD,YAAY,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AACrF,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,sBAAsB,CAAA"}

package/dist/schema.js

@@ -48,4 +48,7 @@ export const programs = pgTable("mice_programs", {
     index("idx_mice_programs_status").on(table.status),
     index("idx_mice_programs_dates").on(table.startDate, table.endDate),
 ]);
+export { bookingMiceDetails } from "./booking-extension.js";
+export * from "./schema-delegates.js";
+export * from "./schema-rooming.js";
 export * from "./schema-sessions.js";

package/dist/service-delegates.d.ts

@@ -0,0 +1,40 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type DelegateSessionEnrollment, type ProgramDelegate } from "./schema-delegates.js";
+import type { CreateDelegateBody, DelegateListQuery, EnrollDelegateBody, UpdateDelegateBody } from "./validation-delegates.js";
+export type CreateDelegateOutcome = {
+    status: "ok";
+    delegate: ProgramDelegate;
+} | {
+    status: "program_not_found";
+};
+export declare function createDelegate(db: PostgresJsDatabase, input: CreateDelegateBody): Promise<CreateDelegateOutcome>;
+export declare function getDelegate(db: PostgresJsDatabase, id: string): Promise<(ProgramDelegate & {
+    enrollments: DelegateSessionEnrollment[];
+}) | null>;
+export declare function listDelegates(db: PostgresJsDatabase, query: DelegateListQuery): Promise<{
+    data: ProgramDelegate[];
+    limit: number;
+    offset: number;
+}>;
+export declare function updateDelegate(db: PostgresJsDatabase, id: string, input: UpdateDelegateBody): Promise<ProgramDelegate | null>;
+export type EnrollDelegateOutcome = {
+    status: "ok";
+    enrollment: DelegateSessionEnrollment;
+    idempotent: boolean;
+} | {
+    status: "delegate_not_found";
+} | {
+    status: "session_not_found";
+} | {
+    status: "program_mismatch";
+};
+/** Enroll a delegate in a session. Idempotent on (delegate, session). */
+export declare function enrollDelegate(db: PostgresJsDatabase, delegateId: string, input: EnrollDelegateBody): Promise<EnrollDelegateOutcome>;
+export declare const delegateService: {
+    createDelegate: typeof createDelegate;
+    getDelegate: typeof getDelegate;
+    listDelegates: typeof listDelegates;
+    updateDelegate: typeof updateDelegate;
+    enrollDelegate: typeof enrollDelegate;
+};
+//# sourceMappingURL=service-delegates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-delegates.d.ts","sourceRoot":"","sources":["../src/service-delegates.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EACL,KAAK,yBAAyB,EAE9B,KAAK,eAAe,EAErB,MAAM,uBAAuB,CAAA;AAE9B,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,2BAA2B,CAAA;AAYlC,MAAM,MAAM,qBAAqB,GAC7B;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,GAC3C;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAAA;AAEnC,wBAAsB,cAAc,CAClC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,qBAAqB,CAAC,CAUhC;AAED,wBAAsB,WAAW,CAC/B,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,CAAC,eAAe,GAAG;IAAE,WAAW,EAAE,yBAAyB,EAAE,CAAA;CAAE,CAAC,GAAG,IAAI,CAAC,CAYlF;AAED,wBAAsB,aAAa,CACjC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC;IAAE,IAAI,EAAE,eAAe,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAYrE;AAED,wBAAsB,cAAc,CAClC,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAOjC;AAED,MAAM,MAAM,qBAAqB,GAC7B;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,yBAAyB,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,GAC5E;IAAE,MAAM,EAAE,oBAAoB,CAAA;CAAE,GAChC;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,GAC/B;IAAE,MAAM,EAAE,kBAAkB,CAAA;CAAE,CAAA;AAElC,yEAAyE;AACzE,wBAAsB,cAAc,CAClC,EAAE,EAAE,kBAAkB,EACtB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,qBAAqB,CAAC,CAqChC;AAED,eAAO,MAAM,eAAe;;;;;;CAM3B,CAAA"}

package/dist/service-delegates.js

@@ -0,0 +1,107 @@
+import { and, asc, eq } from "drizzle-orm";
+import { programs } from "./schema.js";
+import { delegateSessionEnrollments, programDelegates, } from "./schema-delegates.js";
+import { programSessions } from "./schema-sessions.js";
+/** Coerce ISO datetime strings (from validation) into Date for timestamp columns. */
+function withTimestamps(input) {
+    const { arrivalAt, departureAt, ...rest } = input;
+    return {
+        ...rest,
+        ...(arrivalAt !== undefined ? { arrivalAt: new Date(arrivalAt) } : {}),
+        ...(departureAt !== undefined ? { departureAt: new Date(departureAt) } : {}),
+    };
+}
+export async function createDelegate(db, input) {
+    const [program] = await db
+        .select({ id: programs.id })
+        .from(programs)
+        .where(eq(programs.id, input.programId))
+        .limit(1);
+    if (!program)
+        return { status: "program_not_found" };
+    const [delegate] = await db.insert(programDelegates).values(withTimestamps(input)).returning();
+    if (!delegate)
+        throw new Error("createDelegate: insert returned no rows");
+    return { status: "ok", delegate };
+}
+export async function getDelegate(db, id) {
+    const [delegate] = await db
+        .select()
+        .from(programDelegates)
+        .where(eq(programDelegates.id, id))
+        .limit(1);
+    if (!delegate)
+        return null;
+    const enrollments = await db
+        .select()
+        .from(delegateSessionEnrollments)
+        .where(eq(delegateSessionEnrollments.delegateId, id));
+    return { ...delegate, enrollments };
+}
+export async function listDelegates(db, query) {
+    const conditions = [eq(programDelegates.programId, query.programId)];
+    if (query.status)
+        conditions.push(eq(programDelegates.status, query.status));
+    if (query.role)
+        conditions.push(eq(programDelegates.role, query.role));
+    const data = await db
+        .select()
+        .from(programDelegates)
+        .where(and(...conditions))
+        .orderBy(asc(programDelegates.createdAt))
+        .limit(query.limit)
+        .offset(query.offset);
+    return { data, limit: query.limit, offset: query.offset };
+}
+export async function updateDelegate(db, id, input) {
+    const [delegate] = await db
+        .update(programDelegates)
+        .set({ ...withTimestamps(input), updatedAt: new Date() })
+        .where(eq(programDelegates.id, id))
+        .returning();
+    return delegate ?? null;
+}
+/** Enroll a delegate in a session. Idempotent on (delegate, session). */
+export async function enrollDelegate(db, delegateId, input) {
+    return db.transaction(async (tx) => {
+        const [delegate] = await tx
+            .select({ id: programDelegates.id, programId: programDelegates.programId })
+            .from(programDelegates)
+            .where(eq(programDelegates.id, delegateId))
+            .limit(1);
+        if (!delegate)
+            return { status: "delegate_not_found" };
+        const [session] = await tx
+            .select({ id: programSessions.id, programId: programSessions.programId })
+            .from(programSessions)
+            .where(eq(programSessions.id, input.sessionId))
+            .limit(1);
+        if (!session)
+            return { status: "session_not_found" };
+        // The session must belong to the delegate's program — neither the FK nor the
+        // unique index includes program_id, so guard against cross-program enrollment.
+        if (session.programId !== delegate.programId)
+            return { status: "program_mismatch" };
+        const [existing] = await tx
+            .select()
+            .from(delegateSessionEnrollments)
+            .where(and(eq(delegateSessionEnrollments.delegateId, delegateId), eq(delegateSessionEnrollments.sessionId, input.sessionId)))
+            .limit(1);
+        if (existing)
+            return { status: "ok", enrollment: existing, idempotent: true };
+        const [enrollment] = await tx
+            .insert(delegateSessionEnrollments)
+            .values({ delegateId, sessionId: input.sessionId, status: input.status })
+            .returning();
+        if (!enrollment)
+            throw new Error("enrollDelegate: insert returned no rows");
+        return { status: "ok", enrollment, idempotent: false };
+    });
+}
+export const delegateService = {
+    createDelegate,
+    getDelegate,
+    listDelegates,
+    updateDelegate,
+    enrollDelegate,
+};

package/dist/service-rooming.d.ts

@@ -0,0 +1,50 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type RoomingAssignment, type RoomingAssignmentDelegate } from "./schema-rooming.js";
+import type { CreateRoomingAssignmentBody, RoomingDelegateInput, UpdateRoomingAssignmentBody } from "./validation-rooming.js";
+export type CreateRoomingAssignmentOutcome = {
+    status: "ok";
+    assignment: RoomingAssignment;
+} | {
+    status: "program_not_found";
+};
+export declare function createRoomingAssignment(db: PostgresJsDatabase, input: CreateRoomingAssignmentBody): Promise<CreateRoomingAssignmentOutcome>;
+export declare function getRoomingAssignment(db: PostgresJsDatabase, id: string): Promise<(RoomingAssignment & {
+    delegates: RoomingAssignmentDelegate[];
+}) | null>;
+export declare function listRoomingAssignments(db: PostgresJsDatabase, query: {
+    programId: string;
+    limit: number;
+    offset: number;
+}): Promise<{
+    data: RoomingAssignment[];
+    limit: number;
+    offset: number;
+}>;
+export declare function updateRoomingAssignment(db: PostgresJsDatabase, id: string, input: UpdateRoomingAssignmentBody): Promise<RoomingAssignment | null>;
+export type SetRoomingDelegatesOutcome = {
+    status: "ok";
+    delegates: RoomingAssignmentDelegate[];
+} | {
+    status: "assignment_not_found";
+} | {
+    status: "delegate_not_found";
+    missing: string[];
+} | {
+    status: "program_mismatch";
+    offending: string[];
+};
+/**
+ * Replace the occupants of a rooming assignment (full replace). Validates the
+ * assignment and that every delegate exists AND belongs to the assignment's
+ * program before touching the join — a stale id is a 4xx (not an FK 500) and a
+ * cross-program delegate can't corrupt the program-scoped manifest.
+ */
+export declare function setRoomingDelegates(db: PostgresJsDatabase, assignmentId: string, delegates: RoomingDelegateInput[]): Promise<SetRoomingDelegatesOutcome>;
+export declare const roomingService: {
+    createRoomingAssignment: typeof createRoomingAssignment;
+    getRoomingAssignment: typeof getRoomingAssignment;
+    listRoomingAssignments: typeof listRoomingAssignments;
+    updateRoomingAssignment: typeof updateRoomingAssignment;
+    setRoomingDelegates: typeof setRoomingDelegates;
+};
+//# sourceMappingURL=service-rooming.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-rooming.d.ts","sourceRoot":"","sources":["../src/service-rooming.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,EAG/B,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EACV,2BAA2B,EAC3B,oBAAoB,EACpB,2BAA2B,EAC5B,MAAM,yBAAyB,CAAA;AAEhC,MAAM,MAAM,8BAA8B,GACtC;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,iBAAiB,CAAA;CAAE,GAC/C;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAAA;AAEnC,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,2BAA2B,GACjC,OAAO,CAAC,8BAA8B,CAAC,CAUzC;AAED,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,CAAC,iBAAiB,GAAG;IAAE,SAAS,EAAE,yBAAyB,EAAE,CAAA;CAAE,CAAC,GAAG,IAAI,CAAC,CAYlF;AAED,wBAAsB,sBAAsB,CAC1C,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC1D,OAAO,CAAC;IAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CASvE;AAED,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,2BAA2B,GACjC,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAOnC;AAED,MAAM,MAAM,0BAA0B,GAClC;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,yBAAyB,EAAE,CAAA;CAAE,GACxD;IAAE,MAAM,EAAE,sBAAsB,CAAA;CAAE,GAClC;IAAE,MAAM,EAAE,oBAAoB,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,GACnD;IAAE,MAAM,EAAE,kBAAkB,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AAEvD;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,kBAAkB,EACtB,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,oBAAoB,EAAE,GAChC,OAAO,CAAC,0BAA0B,CAAC,CAuCrC;AAED,eAAO,MAAM,cAAc;;;;;;CAM1B,CAAA"}