@voyant-travel/mice 0.2.0 → 0.4.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-rfp.d.ts","sourceRoot":"","sources":["../src/schema-rfp.ts"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,6FAMxB,CAAA;AAEF,eAAO,MAAM,uBAAuB,sFAKlC,CAAA;AAEF,eAAO,MAAM,aAAa,sGAMxB,CAAA;AAEF,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBhB,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgB1B,CAAA;AAED,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBhB,CAAA;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAepB,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAe1B,CAAA;AAED,MAAM,MAAM,GAAG,GAAG,OAAO,IAAI,CAAC,YAAY,CAAA;AAC1C,MAAM,MAAM,MAAM,GAAG,OAAO,IAAI,CAAC,YAAY,CAAA;AAC7C,MAAM,MAAM,aAAa,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA;AAC9D,MAAM,MAAM,gBAAgB,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA;AACjE,MAAM,MAAM,GAAG,GAAG,OAAO,IAAI,CAAC,YAAY,CAAA;AAC1C,MAAM,MAAM,MAAM,GAAG,OAAO,IAAI,CAAC,YAAY,CAAA;AAC7C,MAAM,MAAM,OAAO,GAAG,OAAO,QAAQ,CAAC,YAAY,CAAA;AAClD,MAAM,MAAM,UAAU,GAAG,OAAO,QAAQ,CAAC,YAAY,CAAA;AACrD,MAAM,MAAM,aAAa,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA;AAC9D,MAAM,MAAM,gBAAgB,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA"}

package/dist/schema-rfp.js

@@ -0,0 +1,104 @@
+import { typeId, typeIdRef } from "@voyant-travel/db/lib/typeid-column";
+import { index, integer, jsonb, pgEnum, pgTable, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+import { programs } from "./schema.js";
+/**
+ * Sourcing funnel — RFP → invitations → bids → evaluation → award. CRM
+ * opportunity/quote model single-deal closure, not multi-supplier bid
+ * solicitation/comparison/scoring; this is the gap. See RFC voyant#1489 §3/§5
+ * (Phase 4). Award atomically accepts the winning bid, rejects the rest, and
+ * moves the RFP to `awarded` (downstream contract/block/booking spawn is a
+ * workflow subscriber on `mice.rfp.awarded`).
+ */
+export const rfpStatusEnum = pgEnum("mice_rfp_status", [
+    "draft",
+    "issued",
+    "closed",
+    "awarded",
+    "cancelled",
+]);
+export const rfpInvitationStatusEnum = pgEnum("mice_rfp_invitation_status", [
+    "invited",
+    "viewed",
+    "declined",
+    "responded",
+]);
+export const bidStatusEnum = pgEnum("mice_bid_status", [
+    "draft",
+    "submitted",
+    "under_review",
+    "accepted",
+    "rejected",
+]);
+export const rfps = pgTable("mice_rfps", {
+    id: typeId("mice_rfps"),
+    programId: typeIdRef("program_id")
+        .notNull()
+        .references(() => programs.id, { onDelete: "cascade" }),
+    title: text("title").notNull(),
+    requirements: jsonb("requirements").$type(),
+    status: rfpStatusEnum("status").notNull().default("draft"),
+    issuedAt: timestamp("issued_at", { withTimezone: true }),
+    dueAt: timestamp("due_at", { withTimezone: true }),
+    notes: text("notes"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_mice_rfps_program").on(table.programId),
+    index("idx_mice_rfps_status").on(table.status),
+]);
+export const rfpInvitations = pgTable("mice_rfp_invitations", {
+    id: typeId("mice_rfp_invitations"),
+    rfpId: typeIdRef("rfp_id")
+        .notNull()
+        .references(() => rfps.id, { onDelete: "cascade" }),
+    supplierId: typeIdRef("supplier_id").notNull(), // → distribution suppliers (loose)
+    status: rfpInvitationStatusEnum("status").notNull().default("invited"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_mice_rfp_invitations_supplier").on(table.supplierId),
+    uniqueIndex("uidx_mice_rfp_invitations_rfp_supplier").on(table.rfpId, table.supplierId),
+]);
+export const bids = pgTable("mice_bids", {
+    id: typeId("mice_bids"),
+    rfpId: typeIdRef("rfp_id")
+        .notNull()
+        .references(() => rfps.id, { onDelete: "cascade" }),
+    supplierId: typeIdRef("supplier_id").notNull(), // → distribution suppliers (loose)
+    status: bidStatusEnum("status").notNull().default("draft"),
+    totalCents: integer("total_cents"),
+    currency: text("currency"),
+    proposalDoc: text("proposal_doc"),
+    validUntil: timestamp("valid_until", { withTimezone: true }),
+    notes: text("notes"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_mice_bids_rfp").on(table.rfpId),
+    index("idx_mice_bids_supplier").on(table.supplierId),
+    index("idx_mice_bids_status").on(table.status),
+]);
+export const bidLines = pgTable("mice_bid_lines", {
+    id: typeId("mice_bid_lines"),
+    bidId: typeIdRef("bid_id")
+        .notNull()
+        .references(() => bids.id, { onDelete: "cascade" }),
+    requirementRef: text("requirement_ref"),
+    description: text("description"),
+    quantity: integer("quantity").notNull().default(1),
+    unitCents: integer("unit_cents"),
+    totalCents: integer("total_cents"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [index("idx_mice_bid_lines_bid").on(table.bidId)]);
+export const bidEvaluations = pgTable("mice_bid_evaluations", {
+    id: typeId("mice_bid_evaluations"),
+    bidId: typeIdRef("bid_id")
+        .notNull()
+        .references(() => bids.id, { onDelete: "cascade" }),
+    criterion: text("criterion").notNull(),
+    weight: integer("weight"),
+    score: integer("score"),
+    notes: text("notes"),
+    evaluatedBy: text("evaluated_by"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [index("idx_mice_bid_evaluations_bid").on(table.bidId)]);

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,10 @@ 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-rfp.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,iBAAiB,CAAA;AAC/B,cAAc,qBAAqB,CAAA;AACnC,cAAc,sBAAsB,CAAA"}

package/dist/schema.js

@@ -48,4 +48,8 @@ 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-rfp.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,
+};