@voyant-travel/mice 0.1.0

package/dist/schema.d.ts

@@ -0,0 +1,330 @@
+/**
+ * The MICE group-program spine (Phase 1: the minimal umbrella). A Program is a
+ * group engagement a buyer org runs over a date range; room blocks (owned by
+ * accommodations) link to it via `programId`. Sessions, delegates, rooming, and
+ * RFP/bid land in later phases. See RFC voyant#1489.
+ *
+ * Cross-package associations (`organizationId`, `primaryContactPersonId`) are
+ * loose `typeIdRef` columns linked via `defineLink` at the deployment.
+ */
+export declare const programTypeEnum: import("drizzle-orm/pg-core").PgEnum<["meeting", "incentive", "conference", "exhibition", "other"]>;
+export declare const programStatusEnum: import("drizzle-orm/pg-core").PgEnum<["lead", "planning", "contracted", "operating", "completed", "cancelled"]>;
+export declare const programs: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "mice_programs";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_programs";
+            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;
+        }, {}, {}>;
+        organizationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_programs";
+            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;
+        }, {}, {}>;
+        primaryContactPersonId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_programs";
+            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;
+        }, {}, {}>;
+        accountManagerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "account_manager_id";
+            tableName: "mice_programs";
+            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;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "mice_programs";
+            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;
+        }, {}, {}>;
+        code: import("drizzle-orm/pg-core").PgColumn<{
+            name: "code";
+            tableName: "mice_programs";
+            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;
+        }, {}, {}>;
+        type: import("drizzle-orm/pg-core").PgColumn<{
+            name: "type";
+            tableName: "mice_programs";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "meeting" | "incentive" | "conference" | "exhibition" | "other";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["meeting", "incentive", "conference", "exhibition", "other"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "mice_programs";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "lead" | "planning" | "contracted" | "operating" | "completed" | "cancelled";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["lead", "planning", "contracted", "operating", "completed", "cancelled"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        destination: import("drizzle-orm/pg-core").PgColumn<{
+            name: "destination";
+            tableName: "mice_programs";
+            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;
+        }, {}, {}>;
+        startDate: import("drizzle-orm/pg-core").PgColumn<{
+            name: "start_date";
+            tableName: "mice_programs";
+            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;
+        }, {}, {}>;
+        endDate: import("drizzle-orm/pg-core").PgColumn<{
+            name: "end_date";
+            tableName: "mice_programs";
+            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;
+        }, {}, {}>;
+        estimatedPax: import("drizzle-orm/pg-core").PgColumn<{
+            name: "estimated_pax";
+            tableName: "mice_programs";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        confirmedPax: import("drizzle-orm/pg-core").PgColumn<{
+            name: "confirmed_pax";
+            tableName: "mice_programs";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        currency: import("drizzle-orm/pg-core").PgColumn<{
+            name: "currency";
+            tableName: "mice_programs";
+            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;
+        }, {}, {}>;
+        budgetAmountCents: import("drizzle-orm/pg-core").PgColumn<{
+            name: "budget_amount_cents";
+            tableName: "mice_programs";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "mice_programs";
+            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_programs";
+            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_programs";
+            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 Program = typeof programs.$inferSelect;
+export type NewProgram = typeof programs.$inferInsert;
+export * from "./schema-sessions.js";
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +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"}

package/dist/schema.js

@@ -0,0 +1,51 @@
+import { typeId, typeIdRef } from "@voyant-travel/db/lib/typeid-column";
+import { date, index, integer, jsonb, pgEnum, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+/**
+ * The MICE group-program spine (Phase 1: the minimal umbrella). A Program is a
+ * group engagement a buyer org runs over a date range; room blocks (owned by
+ * accommodations) link to it via `programId`. Sessions, delegates, rooming, and
+ * RFP/bid land in later phases. See RFC voyant#1489.
+ *
+ * Cross-package associations (`organizationId`, `primaryContactPersonId`) are
+ * loose `typeIdRef` columns linked via `defineLink` at the deployment.
+ */
+export const programTypeEnum = pgEnum("mice_program_type", [
+    "meeting",
+    "incentive",
+    "conference",
+    "exhibition",
+    "other",
+]);
+export const programStatusEnum = pgEnum("mice_program_status", [
+    "lead",
+    "planning",
+    "contracted",
+    "operating",
+    "completed",
+    "cancelled",
+]);
+export const programs = pgTable("mice_programs", {
+    id: typeId("mice_programs"),
+    organizationId: typeIdRef("organization_id"), // → relationships.organizations (buyer)
+    primaryContactPersonId: typeIdRef("primary_contact_person_id"), // → relationships.people
+    accountManagerId: text("account_manager_id"), // owning staff user (auth)
+    name: text("name").notNull(),
+    code: text("code"),
+    type: programTypeEnum("type").notNull().default("conference"),
+    status: programStatusEnum("status").notNull().default("lead"),
+    destination: text("destination"),
+    startDate: date("start_date"),
+    endDate: date("end_date"),
+    estimatedPax: integer("estimated_pax"),
+    confirmedPax: integer("confirmed_pax"),
+    currency: text("currency"),
+    budgetAmountCents: integer("budget_amount_cents"),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_mice_programs_org").on(table.organizationId),
+    index("idx_mice_programs_status").on(table.status),
+    index("idx_mice_programs_dates").on(table.startDate, table.endDate),
+]);
+export * from "./schema-sessions.js";

package/dist/service-sessions.d.ts

@@ -0,0 +1,25 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type ProgramSession, type SessionInclusion } from "./schema-sessions.js";
+import type { CreateSessionBody, SessionInclusionInput, SessionListQuery, UpdateSessionBody } from "./validation-sessions.js";
+export declare function createSession(db: PostgresJsDatabase, input: CreateSessionBody): Promise<ProgramSession>;
+export declare function getSession(db: PostgresJsDatabase, id: string): Promise<(ProgramSession & {
+    inclusions: SessionInclusion[];
+}) | null>;
+export declare function listSessions(db: PostgresJsDatabase, query: SessionListQuery): Promise<{
+    data: ProgramSession[];
+    limit: number;
+    offset: number;
+}>;
+export declare function updateSession(db: PostgresJsDatabase, id: string, input: UpdateSessionBody): Promise<ProgramSession | null>;
+export declare function deleteSession(db: PostgresJsDatabase, id: string): Promise<boolean>;
+/** Replace a session's inclusions (delete-all + insert) in one transaction. */
+export declare function setSessionInclusions(db: PostgresJsDatabase, sessionId: string, inclusions: SessionInclusionInput[]): Promise<SessionInclusion[]>;
+export declare const sessionService: {
+    createSession: typeof createSession;
+    getSession: typeof getSession;
+    listSessions: typeof listSessions;
+    updateSession: typeof updateSession;
+    deleteSession: typeof deleteSession;
+    setSessionInclusions: typeof setSessionInclusions;
+};
+//# sourceMappingURL=service-sessions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-sessions.d.ts","sourceRoot":"","sources":["../src/service-sessions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EACL,KAAK,cAAc,EAEnB,KAAK,gBAAgB,EAEtB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,KAAK,EACV,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,0BAA0B,CAAA;AAYjC,wBAAsB,aAAa,CACjC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,cAAc,CAAC,CAIzB;AAED,wBAAsB,UAAU,CAC9B,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,CAAC,cAAc,GAAG;IAAE,UAAU,EAAE,gBAAgB,EAAE,CAAA;CAAE,CAAC,GAAG,IAAI,CAAC,CAYvE;AAED,wBAAsB,YAAY,CAChC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC;IAAE,IAAI,EAAE,cAAc,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAWpE;AAED,wBAAsB,aAAa,CACjC,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAOhC;AAED,wBAAsB,aAAa,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAGxF;AAED,+EAA+E;AAC/E,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,kBAAkB,EACtB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,qBAAqB,EAAE,GAClC,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAS7B;AAED,eAAO,MAAM,cAAc;;;;;;;CAO1B,CAAA"}

package/dist/service-sessions.js

@@ -0,0 +1,76 @@
+import { and, asc, eq } from "drizzle-orm";
+import { programSessions, sessionInclusions, } from "./schema-sessions.js";
+/** Coerce ISO datetime strings (from validation) into Date for timestamp columns. */
+function withTimestamps(input) {
+    const { startsAt, endsAt, ...rest } = input;
+    return {
+        ...rest,
+        ...(startsAt !== undefined ? { startsAt: new Date(startsAt) } : {}),
+        ...(endsAt !== undefined ? { endsAt: new Date(endsAt) } : {}),
+    };
+}
+export async function createSession(db, input) {
+    const [session] = await db.insert(programSessions).values(withTimestamps(input)).returning();
+    if (!session)
+        throw new Error("createSession: insert returned no rows");
+    return session;
+}
+export async function getSession(db, id) {
+    const [session] = await db
+        .select()
+        .from(programSessions)
+        .where(eq(programSessions.id, id))
+        .limit(1);
+    if (!session)
+        return null;
+    const inclusions = await db
+        .select()
+        .from(sessionInclusions)
+        .where(eq(sessionInclusions.sessionId, id));
+    return { ...session, inclusions };
+}
+export async function listSessions(db, query) {
+    const conditions = [eq(programSessions.programId, query.programId)];
+    if (query.sessionType)
+        conditions.push(eq(programSessions.sessionType, query.sessionType));
+    const data = await db
+        .select()
+        .from(programSessions)
+        .where(and(...conditions))
+        .orderBy(asc(programSessions.dayDate), asc(programSessions.startsAt))
+        .limit(query.limit)
+        .offset(query.offset);
+    return { data, limit: query.limit, offset: query.offset };
+}
+export async function updateSession(db, id, input) {
+    const [session] = await db
+        .update(programSessions)
+        .set({ ...withTimestamps(input), updatedAt: new Date() })
+        .where(eq(programSessions.id, id))
+        .returning();
+    return session ?? null;
+}
+export async function deleteSession(db, id) {
+    const [row] = await db.delete(programSessions).where(eq(programSessions.id, id)).returning();
+    return !!row;
+}
+/** Replace a session's inclusions (delete-all + insert) in one transaction. */
+export async function setSessionInclusions(db, sessionId, inclusions) {
+    return db.transaction(async (tx) => {
+        await tx.delete(sessionInclusions).where(eq(sessionInclusions.sessionId, sessionId));
+        if (inclusions.length === 0)
+            return [];
+        return tx
+            .insert(sessionInclusions)
+            .values(inclusions.map((i) => ({ sessionId, ...i })))
+            .returning();
+    });
+}
+export const sessionService = {
+    createSession,
+    getSession,
+    listSessions,
+    updateSession,
+    deleteSession,
+    setSessionInclusions,
+};

package/dist/service.d.ts

@@ -0,0 +1,18 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type Program } from "./schema.js";
+import type { CreateProgramBody, ProgramListQuery, UpdateProgramBody } from "./validation.js";
+export declare function createProgram(db: PostgresJsDatabase, input: CreateProgramBody): Promise<Program>;
+export declare function getProgram(db: PostgresJsDatabase, id: string): Promise<Program | null>;
+export declare function listPrograms(db: PostgresJsDatabase, query: ProgramListQuery): Promise<{
+    data: Program[];
+    limit: number;
+    offset: number;
+}>;
+export declare function updateProgram(db: PostgresJsDatabase, id: string, input: UpdateProgramBody): Promise<Program | null>;
+export declare const miceService: {
+    createProgram: typeof createProgram;
+    getProgram: typeof getProgram;
+    listPrograms: typeof listPrograms;
+    updateProgram: typeof updateProgram;
+};
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EAAE,KAAK,OAAO,EAAY,MAAM,aAAa,CAAA;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAE7F,wBAAsB,aAAa,CACjC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,OAAO,CAAC,CAIlB;AAED,wBAAsB,UAAU,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAG5F;AAED,wBAAsB,YAAY,CAChC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC;IAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAe7D;AAED,wBAAsB,aAAa,CACjC,EAAE,EAAE,kBAAkB,EACtB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAOzB;AAED,eAAO,MAAM,WAAW;;;;;CAKvB,CAAA"}

package/dist/service.js

@@ -0,0 +1,44 @@
+import { and, desc, eq } from "drizzle-orm";
+import { programs } from "./schema.js";
+export async function createProgram(db, input) {
+    const [program] = await db.insert(programs).values(input).returning();
+    if (!program)
+        throw new Error("createProgram: insert returned no rows");
+    return program;
+}
+export async function getProgram(db, id) {
+    const [program] = await db.select().from(programs).where(eq(programs.id, id)).limit(1);
+    return program ?? null;
+}
+export async function listPrograms(db, query) {
+    const conditions = [];
+    if (query.status)
+        conditions.push(eq(programs.status, query.status));
+    if (query.type)
+        conditions.push(eq(programs.type, query.type));
+    if (query.organizationId)
+        conditions.push(eq(programs.organizationId, query.organizationId));
+    const where = conditions.length ? and(...conditions) : undefined;
+    const data = await db
+        .select()
+        .from(programs)
+        .where(where)
+        .orderBy(desc(programs.createdAt))
+        .limit(query.limit)
+        .offset(query.offset);
+    return { data, limit: query.limit, offset: query.offset };
+}
+export async function updateProgram(db, id, input) {
+    const [program] = await db
+        .update(programs)
+        .set({ ...input, updatedAt: new Date() })
+        .where(eq(programs.id, id))
+        .returning();
+    return program ?? null;
+}
+export const miceService = {
+    createProgram,
+    getProgram,
+    listPrograms,
+    updateProgram,
+};

package/dist/validation-sessions.d.ts

@@ -0,0 +1,92 @@
+import { z } from "zod";
+export declare const sessionTypeSchema: z.ZodEnum<{
+    keynote: "keynote";
+    breakout: "breakout";
+    meal: "meal";
+    networking: "networking";
+    gala: "gala";
+    excursion: "excursion";
+    free: "free";
+}>;
+export declare const sessionInclusionKindSchema: z.ZodEnum<{
+    other: "other";
+    fnb: "fnb";
+    av: "av";
+    materials: "materials";
+    signage: "signage";
+}>;
+export declare const createSessionSchema: z.ZodObject<{
+    programId: z.ZodString;
+    title: z.ZodString;
+    sessionType: z.ZodDefault<z.ZodEnum<{
+        keynote: "keynote";
+        breakout: "breakout";
+        meal: "meal";
+        networking: "networking";
+        gala: "gala";
+        excursion: "excursion";
+        free: "free";
+    }>>;
+    functionSpaceId: z.ZodOptional<z.ZodString>;
+    dayDate: z.ZodOptional<z.ZodString>;
+    startsAt: z.ZodOptional<z.ZodString>;
+    endsAt: z.ZodOptional<z.ZodString>;
+    track: z.ZodOptional<z.ZodString>;
+    capacity: z.ZodOptional<z.ZodNumber>;
+    requiresRegistration: z.ZodOptional<z.ZodBoolean>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const updateSessionSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    sessionType: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        keynote: "keynote";
+        breakout: "breakout";
+        meal: "meal";
+        networking: "networking";
+        gala: "gala";
+        excursion: "excursion";
+        free: "free";
+    }>>>;
+    functionSpaceId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    dayDate: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    startsAt: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    endsAt: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    track: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    capacity: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    requiresRegistration: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    notes: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const sessionListQuerySchema: z.ZodObject<{
+    programId: z.ZodString;
+    sessionType: z.ZodOptional<z.ZodEnum<{
+        keynote: "keynote";
+        breakout: "breakout";
+        meal: "meal";
+        networking: "networking";
+        gala: "gala";
+        excursion: "excursion";
+        free: "free";
+    }>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export declare const setSessionInclusionsSchema: z.ZodObject<{
+    inclusions: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            other: "other";
+            fnb: "fnb";
+            av: "av";
+            materials: "materials";
+            signage: "signage";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+        quantity: z.ZodDefault<z.ZodNumber>;
+        costAmountCents: z.ZodOptional<z.ZodNumber>;
+        currency: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CreateSessionBody = z.infer<typeof createSessionSchema>;
+export type UpdateSessionBody = z.infer<typeof updateSessionSchema>;
+export type SessionListQuery = z.infer<typeof sessionListQuerySchema>;
+export type SessionInclusionInput = z.infer<typeof setSessionInclusionsSchema>["inclusions"][number];
+//# sourceMappingURL=validation-sessions.d.ts.map

package/dist/validation-sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-sessions.d.ts","sourceRoot":"","sources":["../src/validation-sessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,iBAAiB;;;;;;;;EAQ5B,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;EAAyD,CAAA;AAEhG,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;iBAY9B,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;iBAA0D,CAAA;AAE1F,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;iBAKjC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;iBAUrC,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AACnE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AACnE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAA"}