@voyantjs/hospitality 0.1.0

package/dist/service.js

@@ -0,0 +1,1007 @@
+import { and, asc, desc, eq, gte, ilike, lte, or, sql } from "drizzle-orm";
+import { housekeepingTasks, maintenanceBlocks, mealPlans, ratePlanInventoryOverrides, ratePlanRoomTypes, ratePlans, roomBlocks, roomInventory, roomTypeBedConfigs, roomTypeRates, roomTypes, roomUnitStatusEvents, roomUnits, stayBookingItems, stayCheckpoints, stayDailyRates, stayFolioLines, stayFolios, stayOperations, stayRules, stayServicePosts, } from "./schema.js";
+async function paginate(rowsQuery, countQuery, limit, offset) {
+    const [data, countResult] = await Promise.all([rowsQuery, countQuery]);
+    return { data, total: countResult[0]?.count ?? 0, limit, offset };
+}
+function toDateOrNull(value) {
+    return value ? new Date(value) : null;
+}
+export const hospitalityService = {
+    async listRoomTypes(db, query) {
+        const conditions = [];
+        if (query.propertyId)
+            conditions.push(eq(roomTypes.propertyId, query.propertyId));
+        if (query.active !== undefined)
+            conditions.push(eq(roomTypes.active, query.active));
+        if (query.inventoryMode)
+            conditions.push(eq(roomTypes.inventoryMode, query.inventoryMode));
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(roomTypes.name, term), ilike(roomTypes.code, term)));
+        }
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(roomTypes)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(roomTypes.sortOrder), asc(roomTypes.name)), db.select({ count: sql `count(*)::int` }).from(roomTypes).where(where), query.limit, query.offset);
+    },
+    async getRoomTypeById(db, id) {
+        const [row] = await db.select().from(roomTypes).where(eq(roomTypes.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createRoomType(db, data) {
+        const [row] = await db.insert(roomTypes).values(data).returning();
+        return row ?? null;
+    },
+    async updateRoomType(db, id, data) {
+        const [row] = await db
+            .update(roomTypes)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(roomTypes.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteRoomType(db, id) {
+        const [row] = await db
+            .delete(roomTypes)
+            .where(eq(roomTypes.id, id))
+            .returning({ id: roomTypes.id });
+        return row ?? null;
+    },
+    async listRoomTypeBedConfigs(db, query) {
+        const conditions = [];
+        if (query.roomTypeId)
+            conditions.push(eq(roomTypeBedConfigs.roomTypeId, query.roomTypeId));
+        if (query.bedType)
+            conditions.push(eq(roomTypeBedConfigs.bedType, query.bedType));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(roomTypeBedConfigs)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(roomTypeBedConfigs.isPrimary), asc(roomTypeBedConfigs.createdAt)), db.select({ count: sql `count(*)::int` }).from(roomTypeBedConfigs).where(where), query.limit, query.offset);
+    },
+    async getRoomTypeBedConfigById(db, id) {
+        const [row] = await db
+            .select()
+            .from(roomTypeBedConfigs)
+            .where(eq(roomTypeBedConfigs.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createRoomTypeBedConfig(db, data) {
+        const [row] = await db.insert(roomTypeBedConfigs).values(data).returning();
+        return row ?? null;
+    },
+    async updateRoomTypeBedConfig(db, id, data) {
+        const [row] = await db
+            .update(roomTypeBedConfigs)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(roomTypeBedConfigs.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteRoomTypeBedConfig(db, id) {
+        const [row] = await db
+            .delete(roomTypeBedConfigs)
+            .where(eq(roomTypeBedConfigs.id, id))
+            .returning({ id: roomTypeBedConfigs.id });
+        return row ?? null;
+    },
+    async listRoomUnits(db, query) {
+        const conditions = [];
+        if (query.propertyId)
+            conditions.push(eq(roomUnits.propertyId, query.propertyId));
+        if (query.roomTypeId)
+            conditions.push(eq(roomUnits.roomTypeId, query.roomTypeId));
+        if (query.status)
+            conditions.push(eq(roomUnits.status, query.status));
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(roomUnits.code, term), ilike(roomUnits.roomNumber, term), ilike(roomUnits.notes, term)));
+        }
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(roomUnits)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(roomUnits.roomNumber), asc(roomUnits.code)), db.select({ count: sql `count(*)::int` }).from(roomUnits).where(where), query.limit, query.offset);
+    },
+    async getRoomUnitById(db, id) {
+        const [row] = await db.select().from(roomUnits).where(eq(roomUnits.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createRoomUnit(db, data) {
+        const [row] = await db.insert(roomUnits).values(data).returning();
+        return row ?? null;
+    },
+    async updateRoomUnit(db, id, data) {
+        const [row] = await db
+            .update(roomUnits)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(roomUnits.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteRoomUnit(db, id) {
+        const [row] = await db
+            .delete(roomUnits)
+            .where(eq(roomUnits.id, id))
+            .returning({ id: roomUnits.id });
+        return row ?? null;
+    },
+    async listMealPlans(db, query) {
+        const conditions = [];
+        if (query.propertyId)
+            conditions.push(eq(mealPlans.propertyId, query.propertyId));
+        if (query.active !== undefined)
+            conditions.push(eq(mealPlans.active, query.active));
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(mealPlans.name, term), ilike(mealPlans.code, term)));
+        }
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(mealPlans)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(mealPlans.sortOrder), asc(mealPlans.name)), db.select({ count: sql `count(*)::int` }).from(mealPlans).where(where), query.limit, query.offset);
+    },
+    async getMealPlanById(db, id) {
+        const [row] = await db.select().from(mealPlans).where(eq(mealPlans.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createMealPlan(db, data) {
+        const [row] = await db.insert(mealPlans).values(data).returning();
+        return row ?? null;
+    },
+    async updateMealPlan(db, id, data) {
+        const [row] = await db
+            .update(mealPlans)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(mealPlans.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteMealPlan(db, id) {
+        const [row] = await db
+            .delete(mealPlans)
+            .where(eq(mealPlans.id, id))
+            .returning({ id: mealPlans.id });
+        return row ?? null;
+    },
+    async listRatePlans(db, query) {
+        const conditions = [];
+        if (query.propertyId)
+            conditions.push(eq(ratePlans.propertyId, query.propertyId));
+        if (query.mealPlanId)
+            conditions.push(eq(ratePlans.mealPlanId, query.mealPlanId));
+        if (query.marketId)
+            conditions.push(eq(ratePlans.marketId, query.marketId));
+        if (query.active !== undefined)
+            conditions.push(eq(ratePlans.active, query.active));
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(ratePlans.name, term), ilike(ratePlans.code, term)));
+        }
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(ratePlans)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(ratePlans.sortOrder), asc(ratePlans.name)), db.select({ count: sql `count(*)::int` }).from(ratePlans).where(where), query.limit, query.offset);
+    },
+    async getRatePlanById(db, id) {
+        const [row] = await db.select().from(ratePlans).where(eq(ratePlans.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createRatePlan(db, data) {
+        const [row] = await db.insert(ratePlans).values(data).returning();
+        return row ?? null;
+    },
+    async updateRatePlan(db, id, data) {
+        const [row] = await db
+            .update(ratePlans)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(ratePlans.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteRatePlan(db, id) {
+        const [row] = await db
+            .delete(ratePlans)
+            .where(eq(ratePlans.id, id))
+            .returning({ id: ratePlans.id });
+        return row ?? null;
+    },
+    async listRatePlanRoomTypes(db, query) {
+        const conditions = [];
+        if (query.ratePlanId)
+            conditions.push(eq(ratePlanRoomTypes.ratePlanId, query.ratePlanId));
+        if (query.roomTypeId)
+            conditions.push(eq(ratePlanRoomTypes.roomTypeId, query.roomTypeId));
+        if (query.productId)
+            conditions.push(eq(ratePlanRoomTypes.productId, query.productId));
+        if (query.active !== undefined)
+            conditions.push(eq(ratePlanRoomTypes.active, query.active));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(ratePlanRoomTypes)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(ratePlanRoomTypes.sortOrder), asc(ratePlanRoomTypes.createdAt)), db.select({ count: sql `count(*)::int` }).from(ratePlanRoomTypes).where(where), query.limit, query.offset);
+    },
+    async getRatePlanRoomTypeById(db, id) {
+        const [row] = await db
+            .select()
+            .from(ratePlanRoomTypes)
+            .where(eq(ratePlanRoomTypes.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createRatePlanRoomType(db, data) {
+        const [row] = await db.insert(ratePlanRoomTypes).values(data).returning();
+        return row ?? null;
+    },
+    async updateRatePlanRoomType(db, id, data) {
+        const [row] = await db
+            .update(ratePlanRoomTypes)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(ratePlanRoomTypes.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteRatePlanRoomType(db, id) {
+        const [row] = await db
+            .delete(ratePlanRoomTypes)
+            .where(eq(ratePlanRoomTypes.id, id))
+            .returning({ id: ratePlanRoomTypes.id });
+        return row ?? null;
+    },
+    async listStayRules(db, query) {
+        const conditions = [];
+        if (query.propertyId)
+            conditions.push(eq(stayRules.propertyId, query.propertyId));
+        if (query.ratePlanId)
+            conditions.push(eq(stayRules.ratePlanId, query.ratePlanId));
+        if (query.roomTypeId)
+            conditions.push(eq(stayRules.roomTypeId, query.roomTypeId));
+        if (query.active !== undefined)
+            conditions.push(eq(stayRules.active, query.active));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(stayRules)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(stayRules.priority), asc(stayRules.createdAt)), db.select({ count: sql `count(*)::int` }).from(stayRules).where(where), query.limit, query.offset);
+    },
+    async getStayRuleById(db, id) {
+        const [row] = await db.select().from(stayRules).where(eq(stayRules.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createStayRule(db, data) {
+        const [row] = await db.insert(stayRules).values(data).returning();
+        return row ?? null;
+    },
+    async updateStayRule(db, id, data) {
+        const [row] = await db
+            .update(stayRules)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(stayRules.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteStayRule(db, id) {
+        const [row] = await db
+            .delete(stayRules)
+            .where(eq(stayRules.id, id))
+            .returning({ id: stayRules.id });
+        return row ?? null;
+    },
+    async listRoomInventory(db, query) {
+        const conditions = [];
+        if (query.propertyId)
+            conditions.push(eq(roomInventory.propertyId, query.propertyId));
+        if (query.roomTypeId)
+            conditions.push(eq(roomInventory.roomTypeId, query.roomTypeId));
+        if (query.stopSell !== undefined)
+            conditions.push(eq(roomInventory.stopSell, query.stopSell));
+        if (query.dateFrom)
+            conditions.push(gte(roomInventory.date, query.dateFrom));
+        if (query.dateTo)
+            conditions.push(lte(roomInventory.date, query.dateTo));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(roomInventory)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(roomInventory.date)), db.select({ count: sql `count(*)::int` }).from(roomInventory).where(where), query.limit, query.offset);
+    },
+    async getRoomInventoryById(db, id) {
+        const [row] = await db.select().from(roomInventory).where(eq(roomInventory.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createRoomInventory(db, data) {
+        const [row] = await db.insert(roomInventory).values(data).returning();
+        return row ?? null;
+    },
+    async updateRoomInventory(db, id, data) {
+        const [row] = await db
+            .update(roomInventory)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(roomInventory.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteRoomInventory(db, id) {
+        const [row] = await db
+            .delete(roomInventory)
+            .where(eq(roomInventory.id, id))
+            .returning({ id: roomInventory.id });
+        return row ?? null;
+    },
+    async listRatePlanInventoryOverrides(db, query) {
+        const conditions = [];
+        if (query.ratePlanId)
+            conditions.push(eq(ratePlanInventoryOverrides.ratePlanId, query.ratePlanId));
+        if (query.roomTypeId)
+            conditions.push(eq(ratePlanInventoryOverrides.roomTypeId, query.roomTypeId));
+        if (query.dateFrom)
+            conditions.push(gte(ratePlanInventoryOverrides.date, query.dateFrom));
+        if (query.dateTo)
+            conditions.push(lte(ratePlanInventoryOverrides.date, query.dateTo));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(ratePlanInventoryOverrides)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(ratePlanInventoryOverrides.date)), db
+            .select({ count: sql `count(*)::int` })
+            .from(ratePlanInventoryOverrides)
+            .where(where), query.limit, query.offset);
+    },
+    async getRatePlanInventoryOverrideById(db, id) {
+        const [row] = await db
+            .select()
+            .from(ratePlanInventoryOverrides)
+            .where(eq(ratePlanInventoryOverrides.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createRatePlanInventoryOverride(db, data) {
+        const [row] = await db.insert(ratePlanInventoryOverrides).values(data).returning();
+        return row ?? null;
+    },
+    async updateRatePlanInventoryOverride(db, id, data) {
+        const [row] = await db
+            .update(ratePlanInventoryOverrides)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(ratePlanInventoryOverrides.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteRatePlanInventoryOverride(db, id) {
+        const [row] = await db
+            .delete(ratePlanInventoryOverrides)
+            .where(eq(ratePlanInventoryOverrides.id, id))
+            .returning({ id: ratePlanInventoryOverrides.id });
+        return row ?? null;
+    },
+    async listRoomTypeRates(db, query) {
+        const conditions = [];
+        if (query.ratePlanId)
+            conditions.push(eq(roomTypeRates.ratePlanId, query.ratePlanId));
+        if (query.roomTypeId)
+            conditions.push(eq(roomTypeRates.roomTypeId, query.roomTypeId));
+        if (query.priceScheduleId)
+            conditions.push(eq(roomTypeRates.priceScheduleId, query.priceScheduleId));
+        if (query.active !== undefined)
+            conditions.push(eq(roomTypeRates.active, query.active));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(roomTypeRates)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(roomTypeRates.createdAt)), db.select({ count: sql `count(*)::int` }).from(roomTypeRates).where(where), query.limit, query.offset);
+    },
+    async getRoomTypeRateById(db, id) {
+        const [row] = await db.select().from(roomTypeRates).where(eq(roomTypeRates.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createRoomTypeRate(db, data) {
+        const [row] = await db.insert(roomTypeRates).values(data).returning();
+        return row ?? null;
+    },
+    async updateRoomTypeRate(db, id, data) {
+        const [row] = await db
+            .update(roomTypeRates)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(roomTypeRates.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteRoomTypeRate(db, id) {
+        const [row] = await db
+            .delete(roomTypeRates)
+            .where(eq(roomTypeRates.id, id))
+            .returning({ id: roomTypeRates.id });
+        return row ?? null;
+    },
+    async listStayBookingItems(db, query) {
+        const conditions = [];
+        if (query.bookingItemId)
+            conditions.push(eq(stayBookingItems.bookingItemId, query.bookingItemId));
+        if (query.propertyId)
+            conditions.push(eq(stayBookingItems.propertyId, query.propertyId));
+        if (query.roomTypeId)
+            conditions.push(eq(stayBookingItems.roomTypeId, query.roomTypeId));
+        if (query.roomUnitId)
+            conditions.push(eq(stayBookingItems.roomUnitId, query.roomUnitId));
+        if (query.ratePlanId)
+            conditions.push(eq(stayBookingItems.ratePlanId, query.ratePlanId));
+        if (query.status)
+            conditions.push(eq(stayBookingItems.status, query.status));
+        if (query.dateFrom)
+            conditions.push(gte(stayBookingItems.checkInDate, query.dateFrom));
+        if (query.dateTo)
+            conditions.push(lte(stayBookingItems.checkOutDate, query.dateTo));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(stayBookingItems)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(stayBookingItems.checkInDate)), db.select({ count: sql `count(*)::int` }).from(stayBookingItems).where(where), query.limit, query.offset);
+    },
+    async getStayBookingItemById(db, id) {
+        const [row] = await db
+            .select()
+            .from(stayBookingItems)
+            .where(eq(stayBookingItems.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createStayBookingItem(db, data) {
+        const [row] = await db.insert(stayBookingItems).values(data).returning();
+        return row ?? null;
+    },
+    async updateStayBookingItem(db, id, data) {
+        const [row] = await db
+            .update(stayBookingItems)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(stayBookingItems.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteStayBookingItem(db, id) {
+        const [row] = await db
+            .delete(stayBookingItems)
+            .where(eq(stayBookingItems.id, id))
+            .returning({ id: stayBookingItems.id });
+        return row ?? null;
+    },
+    async listStayDailyRates(db, query) {
+        const conditions = [];
+        if (query.stayBookingItemId)
+            conditions.push(eq(stayDailyRates.stayBookingItemId, query.stayBookingItemId));
+        if (query.dateFrom)
+            conditions.push(gte(stayDailyRates.date, query.dateFrom));
+        if (query.dateTo)
+            conditions.push(lte(stayDailyRates.date, query.dateTo));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(stayDailyRates)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(stayDailyRates.date)), db.select({ count: sql `count(*)::int` }).from(stayDailyRates).where(where), query.limit, query.offset);
+    },
+    async getStayDailyRateById(db, id) {
+        const [row] = await db.select().from(stayDailyRates).where(eq(stayDailyRates.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createStayDailyRate(db, data) {
+        const [row] = await db.insert(stayDailyRates).values(data).returning();
+        return row ?? null;
+    },
+    async updateStayDailyRate(db, id, data) {
+        const [row] = await db
+            .update(stayDailyRates)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(stayDailyRates.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteStayDailyRate(db, id) {
+        const [row] = await db
+            .delete(stayDailyRates)
+            .where(eq(stayDailyRates.id, id))
+            .returning({ id: stayDailyRates.id });
+        return row ?? null;
+    },
+    async listRoomBlocks(db, query) {
+        const conditions = [];
+        if (query.propertyId)
+            conditions.push(eq(roomBlocks.propertyId, query.propertyId));
+        if (query.roomTypeId)
+            conditions.push(eq(roomBlocks.roomTypeId, query.roomTypeId));
+        if (query.roomUnitId)
+            conditions.push(eq(roomBlocks.roomUnitId, query.roomUnitId));
+        if (query.status)
+            conditions.push(eq(roomBlocks.status, query.status));
+        if (query.startsOn)
+            conditions.push(gte(roomBlocks.startsOn, query.startsOn));
+        if (query.endsOn)
+            conditions.push(lte(roomBlocks.endsOn, query.endsOn));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(roomBlocks)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(roomBlocks.startsOn)), db.select({ count: sql `count(*)::int` }).from(roomBlocks).where(where), query.limit, query.offset);
+    },
+    async getRoomBlockById(db, id) {
+        const [row] = await db.select().from(roomBlocks).where(eq(roomBlocks.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createRoomBlock(db, data) {
+        const [row] = await db
+            .insert(roomBlocks)
+            .values({ ...data, releaseAt: toDateOrNull(data.releaseAt) })
+            .returning();
+        return row ?? null;
+    },
+    async updateRoomBlock(db, id, data) {
+        const [row] = await db
+            .update(roomBlocks)
+            .set({ ...data, releaseAt: toDateOrNull(data.releaseAt), updatedAt: new Date() })
+            .where(eq(roomBlocks.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteRoomBlock(db, id) {
+        const [row] = await db
+            .delete(roomBlocks)
+            .where(eq(roomBlocks.id, id))
+            .returning({ id: roomBlocks.id });
+        return row ?? null;
+    },
+    async listRoomUnitStatusEvents(db, query) {
+        const conditions = [];
+        if (query.roomUnitId)
+            conditions.push(eq(roomUnitStatusEvents.roomUnitId, query.roomUnitId));
+        if (query.statusCode)
+            conditions.push(eq(roomUnitStatusEvents.statusCode, query.statusCode));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(roomUnitStatusEvents)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(roomUnitStatusEvents.effectiveFrom)), db.select({ count: sql `count(*)::int` }).from(roomUnitStatusEvents).where(where), query.limit, query.offset);
+    },
+    async getRoomUnitStatusEventById(db, id) {
+        const [row] = await db
+            .select()
+            .from(roomUnitStatusEvents)
+            .where(eq(roomUnitStatusEvents.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createRoomUnitStatusEvent(db, data) {
+        const [row] = await db
+            .insert(roomUnitStatusEvents)
+            .values({
+            ...data,
+            effectiveFrom: toDateOrNull(data.effectiveFrom) ?? new Date(),
+            effectiveTo: toDateOrNull(data.effectiveTo),
+        })
+            .returning();
+        return row ?? null;
+    },
+    async updateRoomUnitStatusEvent(db, id, data) {
+        const [row] = await db
+            .update(roomUnitStatusEvents)
+            .set({
+            ...data,
+            effectiveFrom: data.effectiveFrom ? new Date(data.effectiveFrom) : undefined,
+            effectiveTo: data.effectiveTo ? new Date(data.effectiveTo) : undefined,
+        })
+            .where(eq(roomUnitStatusEvents.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteRoomUnitStatusEvent(db, id) {
+        const [row] = await db
+            .delete(roomUnitStatusEvents)
+            .where(eq(roomUnitStatusEvents.id, id))
+            .returning({ id: roomUnitStatusEvents.id });
+        return row ?? null;
+    },
+    async listMaintenanceBlocks(db, query) {
+        const conditions = [];
+        if (query.propertyId)
+            conditions.push(eq(maintenanceBlocks.propertyId, query.propertyId));
+        if (query.roomTypeId)
+            conditions.push(eq(maintenanceBlocks.roomTypeId, query.roomTypeId));
+        if (query.roomUnitId)
+            conditions.push(eq(maintenanceBlocks.roomUnitId, query.roomUnitId));
+        if (query.status)
+            conditions.push(eq(maintenanceBlocks.status, query.status));
+        if (query.startsOn)
+            conditions.push(gte(maintenanceBlocks.startsOn, query.startsOn));
+        if (query.endsOn)
+            conditions.push(lte(maintenanceBlocks.endsOn, query.endsOn));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(maintenanceBlocks)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(maintenanceBlocks.startsOn)), db.select({ count: sql `count(*)::int` }).from(maintenanceBlocks).where(where), query.limit, query.offset);
+    },
+    async getMaintenanceBlockById(db, id) {
+        const [row] = await db
+            .select()
+            .from(maintenanceBlocks)
+            .where(eq(maintenanceBlocks.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createMaintenanceBlock(db, data) {
+        const [row] = await db.insert(maintenanceBlocks).values(data).returning();
+        return row ?? null;
+    },
+    async updateMaintenanceBlock(db, id, data) {
+        const [row] = await db
+            .update(maintenanceBlocks)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(maintenanceBlocks.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteMaintenanceBlock(db, id) {
+        const [row] = await db
+            .delete(maintenanceBlocks)
+            .where(eq(maintenanceBlocks.id, id))
+            .returning({ id: maintenanceBlocks.id });
+        return row ?? null;
+    },
+    async listHousekeepingTasks(db, query) {
+        const conditions = [];
+        if (query.propertyId)
+            conditions.push(eq(housekeepingTasks.propertyId, query.propertyId));
+        if (query.roomUnitId)
+            conditions.push(eq(housekeepingTasks.roomUnitId, query.roomUnitId));
+        if (query.stayBookingItemId)
+            conditions.push(eq(housekeepingTasks.stayBookingItemId, query.stayBookingItemId));
+        if (query.status)
+            conditions.push(eq(housekeepingTasks.status, query.status));
+        if (query.taskType)
+            conditions.push(eq(housekeepingTasks.taskType, query.taskType));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(housekeepingTasks)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(housekeepingTasks.priority), asc(housekeepingTasks.dueAt)), db.select({ count: sql `count(*)::int` }).from(housekeepingTasks).where(where), query.limit, query.offset);
+    },
+    async getHousekeepingTaskById(db, id) {
+        const [row] = await db
+            .select()
+            .from(housekeepingTasks)
+            .where(eq(housekeepingTasks.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createHousekeepingTask(db, data) {
+        const [row] = await db
+            .insert(housekeepingTasks)
+            .values({
+            ...data,
+            dueAt: toDateOrNull(data.dueAt),
+            startedAt: toDateOrNull(data.startedAt),
+            completedAt: toDateOrNull(data.completedAt),
+        })
+            .returning();
+        return row ?? null;
+    },
+    async updateHousekeepingTask(db, id, data) {
+        const [row] = await db
+            .update(housekeepingTasks)
+            .set({
+            ...data,
+            dueAt: toDateOrNull(data.dueAt),
+            startedAt: toDateOrNull(data.startedAt),
+            completedAt: toDateOrNull(data.completedAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(housekeepingTasks.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteHousekeepingTask(db, id) {
+        const [row] = await db
+            .delete(housekeepingTasks)
+            .where(eq(housekeepingTasks.id, id))
+            .returning({ id: housekeepingTasks.id });
+        return row ?? null;
+    },
+    async listStayOperations(db, query) {
+        const conditions = [];
+        if (query.stayBookingItemId)
+            conditions.push(eq(stayOperations.stayBookingItemId, query.stayBookingItemId));
+        if (query.propertyId)
+            conditions.push(eq(stayOperations.propertyId, query.propertyId));
+        if (query.roomUnitId)
+            conditions.push(eq(stayOperations.roomUnitId, query.roomUnitId));
+        if (query.operationStatus)
+            conditions.push(eq(stayOperations.operationStatus, query.operationStatus));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(stayOperations)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(stayOperations.createdAt)), db.select({ count: sql `count(*)::int` }).from(stayOperations).where(where), query.limit, query.offset);
+    },
+    async getStayOperationById(db, id) {
+        const [row] = await db.select().from(stayOperations).where(eq(stayOperations.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createStayOperation(db, data) {
+        const [row] = await db
+            .insert(stayOperations)
+            .values({
+            ...data,
+            expectedArrivalAt: toDateOrNull(data.expectedArrivalAt),
+            expectedDepartureAt: toDateOrNull(data.expectedDepartureAt),
+            checkedInAt: toDateOrNull(data.checkedInAt),
+            checkedOutAt: toDateOrNull(data.checkedOutAt),
+            noShowRecordedAt: toDateOrNull(data.noShowRecordedAt),
+        })
+            .returning();
+        return row ?? null;
+    },
+    async updateStayOperation(db, id, data) {
+        const [row] = await db
+            .update(stayOperations)
+            .set({
+            ...data,
+            expectedArrivalAt: toDateOrNull(data.expectedArrivalAt),
+            expectedDepartureAt: toDateOrNull(data.expectedDepartureAt),
+            checkedInAt: toDateOrNull(data.checkedInAt),
+            checkedOutAt: toDateOrNull(data.checkedOutAt),
+            noShowRecordedAt: toDateOrNull(data.noShowRecordedAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(stayOperations.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteStayOperation(db, id) {
+        const [row] = await db
+            .delete(stayOperations)
+            .where(eq(stayOperations.id, id))
+            .returning({ id: stayOperations.id });
+        return row ?? null;
+    },
+    async listStayCheckpoints(db, query) {
+        const conditions = [];
+        if (query.stayOperationId)
+            conditions.push(eq(stayCheckpoints.stayOperationId, query.stayOperationId));
+        if (query.checkpointType)
+            conditions.push(eq(stayCheckpoints.checkpointType, query.checkpointType));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(stayCheckpoints)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(stayCheckpoints.occurredAt)), db.select({ count: sql `count(*)::int` }).from(stayCheckpoints).where(where), query.limit, query.offset);
+    },
+    async getStayCheckpointById(db, id) {
+        const [row] = await db.select().from(stayCheckpoints).where(eq(stayCheckpoints.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createStayCheckpoint(db, data) {
+        const [row] = await db
+            .insert(stayCheckpoints)
+            .values({ ...data, occurredAt: toDateOrNull(data.occurredAt) ?? new Date() })
+            .returning();
+        return row ?? null;
+    },
+    async updateStayCheckpoint(db, id, data) {
+        const [row] = await db
+            .update(stayCheckpoints)
+            .set({
+            ...data,
+            occurredAt: data.occurredAt ? new Date(data.occurredAt) : undefined,
+        })
+            .where(eq(stayCheckpoints.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteStayCheckpoint(db, id) {
+        const [row] = await db
+            .delete(stayCheckpoints)
+            .where(eq(stayCheckpoints.id, id))
+            .returning({ id: stayCheckpoints.id });
+        return row ?? null;
+    },
+    async listStayServicePosts(db, query) {
+        const conditions = [];
+        if (query.stayOperationId)
+            conditions.push(eq(stayServicePosts.stayOperationId, query.stayOperationId));
+        if (query.bookingItemId)
+            conditions.push(eq(stayServicePosts.bookingItemId, query.bookingItemId));
+        if (query.kind)
+            conditions.push(eq(stayServicePosts.kind, query.kind));
+        if (query.serviceDateFrom)
+            conditions.push(gte(stayServicePosts.serviceDate, query.serviceDateFrom));
+        if (query.serviceDateTo)
+            conditions.push(lte(stayServicePosts.serviceDate, query.serviceDateTo));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(stayServicePosts)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(stayServicePosts.serviceDate)), db.select({ count: sql `count(*)::int` }).from(stayServicePosts).where(where), query.limit, query.offset);
+    },
+    async getStayServicePostById(db, id) {
+        const [row] = await db
+            .select()
+            .from(stayServicePosts)
+            .where(eq(stayServicePosts.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createStayServicePost(db, data) {
+        const [row] = await db.insert(stayServicePosts).values(data).returning();
+        return row ?? null;
+    },
+    async updateStayServicePost(db, id, data) {
+        const [row] = await db
+            .update(stayServicePosts)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(stayServicePosts.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteStayServicePost(db, id) {
+        const [row] = await db
+            .delete(stayServicePosts)
+            .where(eq(stayServicePosts.id, id))
+            .returning({ id: stayServicePosts.id });
+        return row ?? null;
+    },
+    async listStayFolios(db, query) {
+        const conditions = [];
+        if (query.stayOperationId)
+            conditions.push(eq(stayFolios.stayOperationId, query.stayOperationId));
+        if (query.status)
+            conditions.push(eq(stayFolios.status, query.status));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(stayFolios)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(stayFolios.openedAt)), db.select({ count: sql `count(*)::int` }).from(stayFolios).where(where), query.limit, query.offset);
+    },
+    async getStayFolioById(db, id) {
+        const [row] = await db.select().from(stayFolios).where(eq(stayFolios.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createStayFolio(db, data) {
+        const [row] = await db
+            .insert(stayFolios)
+            .values({
+            ...data,
+            openedAt: toDateOrNull(data.openedAt) ?? new Date(),
+            closedAt: toDateOrNull(data.closedAt),
+        })
+            .returning();
+        return row ?? null;
+    },
+    async updateStayFolio(db, id, data) {
+        const [row] = await db
+            .update(stayFolios)
+            .set({
+            ...data,
+            openedAt: data.openedAt ? new Date(data.openedAt) : undefined,
+            closedAt: data.closedAt ? new Date(data.closedAt) : undefined,
+            updatedAt: new Date(),
+        })
+            .where(eq(stayFolios.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteStayFolio(db, id) {
+        const [row] = await db
+            .delete(stayFolios)
+            .where(eq(stayFolios.id, id))
+            .returning({ id: stayFolios.id });
+        return row ?? null;
+    },
+    async listStayFolioLines(db, query) {
+        const conditions = [];
+        if (query.stayFolioId)
+            conditions.push(eq(stayFolioLines.stayFolioId, query.stayFolioId));
+        if (query.servicePostId)
+            conditions.push(eq(stayFolioLines.servicePostId, query.servicePostId));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(stayFolioLines)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(stayFolioLines.postedAt)), db.select({ count: sql `count(*)::int` }).from(stayFolioLines).where(where), query.limit, query.offset);
+    },
+    async getStayFolioLineById(db, id) {
+        const [row] = await db.select().from(stayFolioLines).where(eq(stayFolioLines.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createStayFolioLine(db, data) {
+        const [row] = await db
+            .insert(stayFolioLines)
+            .values({ ...data, postedAt: toDateOrNull(data.postedAt) ?? new Date() })
+            .returning();
+        return row ?? null;
+    },
+    async updateStayFolioLine(db, id, data) {
+        const [row] = await db
+            .update(stayFolioLines)
+            .set({
+            ...data,
+            postedAt: data.postedAt ? new Date(data.postedAt) : undefined,
+            updatedAt: new Date(),
+        })
+            .where(eq(stayFolioLines.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteStayFolioLine(db, id) {
+        const [row] = await db
+            .delete(stayFolioLines)
+            .where(eq(stayFolioLines.id, id))
+            .returning({ id: stayFolioLines.id });
+        return row ?? null;
+    },
+};