@htlkg/data 0.0.19 → 0.0.20

package/src/hooks/useReservations.ts

@@ -0,0 +1,145 @@
+/**
+ * useReservations Hook
+ *
+ * Vue composable for fetching and managing reservation data with reactive state.
+ * Provides loading states, error handling, pagination, and refetch capabilities.
+ */
+
+import type { Ref, ComputedRef } from "vue";
+import type { Reservation } from "../queries/reservations";
+import { createDataHook, type BaseHookOptions } from "./createDataHook";
+
+export interface UseReservationsOptions extends BaseHookOptions {
+	/** Filter by brand ID */
+	brandId?: string;
+	/** Filter by start date (check-in date >= startDate) */
+	startDate?: string;
+	/** Filter by end date (check-in date <= endDate) */
+	endDate?: string;
+	/** Filter by reservation status */
+	status?: Reservation["status"];
+	/** Filter by contact/visit ID */
+	contactId?: string;
+	/** Pagination token for fetching next page */
+	nextToken?: string;
+}
+
+export interface UseReservationsReturn {
+	/** Reactive array of reservations */
+	reservations: Ref<Reservation[]>;
+	/** Computed array of confirmed reservations */
+	confirmedReservations: ComputedRef<Reservation[]>;
+	/** Computed array of active reservations (confirmed or checked_in) */
+	activeReservations: ComputedRef<Reservation[]>;
+	/** Loading state */
+	loading: Ref<boolean>;
+	/** Error state */
+	error: Ref<Error | null>;
+	/** Refetch reservations */
+	refetch: () => Promise<void>;
+}
+
+/**
+ * Build filter from hook options
+ */
+function buildFilter(options: UseReservationsOptions): any {
+	const conditions: any[] = [];
+
+	if (options.brandId) {
+		conditions.push({ brandId: { eq: options.brandId } });
+	}
+
+	if (options.status) {
+		conditions.push({ status: { eq: options.status } });
+	}
+
+	if (options.contactId) {
+		conditions.push({ visitId: { eq: options.contactId } });
+	}
+
+	if (options.startDate) {
+		conditions.push({ checkIn: { ge: options.startDate } });
+	}
+
+	if (options.endDate) {
+		conditions.push({ checkIn: { le: options.endDate } });
+	}
+
+	if (options.filter) {
+		conditions.push(options.filter);
+	}
+
+	if (conditions.length === 0) {
+		return undefined;
+	}
+
+	if (conditions.length === 1) {
+		return conditions[0];
+	}
+
+	return { and: conditions };
+}
+
+/**
+ * Internal hook created by factory
+ */
+const useReservationsInternal = createDataHook<
+	Reservation,
+	UseReservationsOptions,
+	{ confirmedReservations: Reservation[]; activeReservations: Reservation[] }
+>({
+	model: "Reservation",
+	dataPropertyName: "reservations",
+	buildFilter,
+	computedProperties: {
+		confirmedReservations: (reservations) =>
+			reservations.filter((r) => r.status === "confirmed"),
+		activeReservations: (reservations) =>
+			reservations.filter((r) => r.status === "confirmed" || r.status === "checked_in"),
+	},
+});
+
+/**
+ * Composable for fetching and managing reservations
+ *
+ * @example
+ * ```typescript
+ * import { useReservations } from '@htlkg/data/hooks';
+ *
+ * const { reservations, loading, error, refetch } = useReservations({
+ *   brandId: 'brand-123',
+ *   startDate: '2026-01-01',
+ *   endDate: '2026-01-31',
+ *   status: 'confirmed'
+ * });
+ * ```
+ *
+ * @example With contact filter
+ * ```typescript
+ * const { reservations, loading } = useReservations({
+ *   contactId: 'contact-123',
+ *   limit: 50
+ * });
+ * ```
+ *
+ * @example With computed properties
+ * ```typescript
+ * const { reservations, activeReservations, confirmedReservations } = useReservations({
+ *   brandId: 'brand-123'
+ * });
+ *
+ * // activeReservations includes confirmed + checked_in
+ * // confirmedReservations includes only confirmed
+ * ```
+ */
+export function useReservations(options: UseReservationsOptions = {}): UseReservationsReturn {
+	const result = useReservationsInternal(options);
+	return {
+		reservations: result.reservations as Ref<Reservation[]>,
+		confirmedReservations: result.confirmedReservations as ComputedRef<Reservation[]>,
+		activeReservations: result.activeReservations as ComputedRef<Reservation[]>,
+		loading: result.loading,
+		error: result.error,
+		refetch: result.refetch,
+	};
+}

package/src/mutations/index.ts

@@ -61,3 +61,17 @@ export {
 	initializeSystemSettings,
 	type UpdateSystemSettingsInput,
 } from "./systemSettings";
+
+// Reservation mutations
+export {
+	createReservation,
+	updateReservation,
+	deleteReservation,
+	softDeleteReservation,
+	restoreReservation,
+	updateReservationStatus,
+	ReservationValidationError,
+	type CreateReservationInput,
+	type UpdateReservationInput,
+	type ReservationStatus,
+} from "./reservations";

package/src/mutations/productInstances/productInstances.test.ts

@@ -132,7 +132,7 @@ describe('ProductInstance Mutations', () => {
 					accountId: 'account-789',
 					enabled: true,
 					version: '1.0.0',
-					lastUpdated: mockTimestamp,
+					updatedAt: mockTimestamp,
 					updatedBy: mockUserId,
 				})
 			);
@@ -183,7 +183,7 @@ describe('ProductInstance Mutations', () => {
 			await createProductInstance(mockClient, validInput);
 
 			const callArgs = mockCreate.mock.calls[0][0];
-			expect(callArgs.lastUpdated).toBe(mockTimestamp);
+			expect(callArgs.updatedAt).toBe(mockTimestamp);
 		});
 
 		it('should use provided updatedBy if specified', async () => {
@@ -358,7 +358,7 @@ describe('ProductInstance Mutations', () => {
 			await updateProductInstance(mockClient, validInput);
 
 			const callArgs = mockUpdate.mock.calls[0][0];
-			expect(callArgs.lastUpdated).toBe(mockTimestamp);
+			expect(callArgs.updatedAt).toBe(mockTimestamp);
 			expect(callArgs.updatedBy).toBe(mockUserId);
 		});
 

package/src/mutations/reservations.test.ts

@@ -0,0 +1,459 @@
+/**
+ * Reservation Mutation Tests
+ *
+ * Tests for reservation CRUD operations including date validation,
+ * status transitions, soft delete, and restoration.
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+	createReservation,
+	updateReservation,
+	softDeleteReservation,
+	restoreReservation,
+	deleteReservation,
+	updateReservationStatus,
+	ReservationValidationError,
+	type ReservationStatus,
+} from "./reservations";
+
+// Mock the systemSettings query functions
+vi.mock("../queries/systemSettings", () => ({
+	checkRestoreEligibility: vi.fn((deletedAt: string | null, retentionDays: number) => {
+		if (!deletedAt) {
+			return { canRestore: false, daysRemaining: 0, daysExpired: 0 };
+		}
+		const deletedDate = new Date(deletedAt);
+		const now = new Date();
+		const diffMs = now.getTime() - deletedDate.getTime();
+		const diffDays = diffMs / (1000 * 60 * 60 * 24);
+
+		if (diffDays > retentionDays) {
+			return {
+				canRestore: false,
+				daysRemaining: 0,
+				daysExpired: Math.floor(diffDays - retentionDays),
+			};
+		}
+
+		return {
+			canRestore: true,
+			daysRemaining: Math.ceil(retentionDays - diffDays),
+			daysExpired: 0,
+		};
+	}),
+	DEFAULT_SOFT_DELETE_RETENTION_DAYS: 30,
+}));
+
+describe("Reservation Mutations", () => {
+	describe("createReservation", () => {
+		const validInput = {
+			brandId: "brand-123",
+			visitId: "visit-456",
+			confirmationCode: "ABC123",
+			checkIn: "2024-06-01",
+			checkOut: "2024-06-05",
+			status: "confirmed" as const,
+			source: "direct",
+			room: "101",
+		};
+
+		it("should create a reservation with valid dates", async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001", ...validInput },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { create: mockCreate },
+				},
+			};
+
+			const result = await createReservation(mockClient, validInput);
+
+			expect(result).toBeTruthy();
+			expect(result?.id).toBe("reservation-001");
+			expect(mockCreate).toHaveBeenCalledTimes(1);
+		});
+
+		it("should calculate nights automatically when not provided", async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { create: mockCreate },
+				},
+			};
+
+			await createReservation(mockClient, validInput);
+
+			const callArgs = mockCreate.mock.calls[0][0];
+			expect(callArgs.nights).toBe(4); // June 1 to June 5 = 4 nights
+		});
+
+		it("should throw ReservationValidationError for invalid check-in date", async () => {
+			const mockClient = {
+				models: {
+					Reservation: { create: vi.fn() },
+				},
+			};
+
+			const invalidInput = {
+				...validInput,
+				checkIn: "invalid-date",
+			};
+
+			await expect(createReservation(mockClient, invalidInput)).rejects.toThrow(
+				ReservationValidationError
+			);
+		});
+
+		it("should throw ReservationValidationError when check-out is before check-in", async () => {
+			const mockClient = {
+				models: {
+					Reservation: { create: vi.fn() },
+				},
+			};
+
+			const invalidInput = {
+				...validInput,
+				checkIn: "2024-06-05",
+				checkOut: "2024-06-01",
+			};
+
+			await expect(createReservation(mockClient, invalidInput)).rejects.toThrow(
+				"Check-out date must be after check-in date"
+			);
+		});
+
+		it("should throw ReservationValidationError for minimum stay violation", async () => {
+			const mockClient = {
+				models: {
+					Reservation: { create: vi.fn() },
+				},
+			};
+
+			const invalidInput = {
+				...validInput,
+				checkIn: "2024-06-01T10:00:00",
+				checkOut: "2024-06-01T11:00:00", // Only 1 hour
+			};
+
+			await expect(createReservation(mockClient, invalidInput)).rejects.toThrow(
+				"Minimum stay is 4 hours"
+			);
+		});
+
+		it("should return null when GraphQL returns errors", async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Database error" }],
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { create: mockCreate },
+				},
+			};
+
+			const result = await createReservation(mockClient, validInput);
+
+			expect(result).toBeNull();
+		});
+	});
+
+	describe("updateReservation", () => {
+		it("should update a reservation without status change", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001", room: "202" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { update: mockUpdate },
+				},
+			};
+
+			const result = await updateReservation(mockClient, {
+				id: "reservation-001",
+				room: "202",
+			});
+
+			expect(result).toBeTruthy();
+			expect(mockUpdate).toHaveBeenCalledWith({ id: "reservation-001", room: "202" });
+		});
+
+		it("should validate status transition when status is being changed", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001", status: "checked_out" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: {
+						get: mockGet,
+						update: vi.fn(),
+					},
+				},
+			};
+
+			// Try to change from checked_out to confirmed (not allowed)
+			await expect(
+				updateReservation(mockClient, {
+					id: "reservation-001",
+					status: "confirmed",
+				})
+			).rejects.toThrow(ReservationValidationError);
+		});
+
+		it("should recalculate nights when dates are updated", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { update: mockUpdate },
+				},
+			};
+
+			await updateReservation(mockClient, {
+				id: "reservation-001",
+				checkIn: "2024-06-01",
+				checkOut: "2024-06-10",
+			});
+
+			const callArgs = mockUpdate.mock.calls[0][0];
+			expect(callArgs.nights).toBe(9); // 9 nights
+		});
+	});
+
+	describe("updateReservationStatus", () => {
+		const statusTransitionTests: Array<{
+			from: ReservationStatus;
+			to: ReservationStatus;
+			allowed: boolean;
+		}> = [
+			{ from: "confirmed", to: "checked_in", allowed: true },
+			{ from: "confirmed", to: "cancelled", allowed: true },
+			{ from: "confirmed", to: "no_show", allowed: true },
+			{ from: "confirmed", to: "checked_out", allowed: false },
+			{ from: "checked_in", to: "checked_out", allowed: true },
+			{ from: "checked_in", to: "cancelled", allowed: true },
+			{ from: "checked_in", to: "confirmed", allowed: false },
+			{ from: "checked_out", to: "confirmed", allowed: false },
+			{ from: "checked_out", to: "checked_in", allowed: false },
+			{ from: "cancelled", to: "confirmed", allowed: false },
+			{ from: "no_show", to: "confirmed", allowed: false },
+		];
+
+		statusTransitionTests.forEach(({ from, to, allowed }) => {
+			it(`should ${allowed ? "allow" : "reject"} transition from '${from}' to '${to}'`, async () => {
+				const mockGet = vi.fn().mockResolvedValue({
+					data: { id: "reservation-001", status: from },
+					errors: null,
+				});
+				const mockUpdate = vi.fn().mockResolvedValue({
+					data: { id: "reservation-001", status: to },
+					errors: null,
+				});
+
+				const mockClient = {
+					models: {
+						Reservation: {
+							get: mockGet,
+							update: mockUpdate,
+						},
+					},
+				};
+
+				if (allowed) {
+					const result = await updateReservationStatus(mockClient, "reservation-001", to);
+					expect(result).toBeTruthy();
+					expect(mockUpdate).toHaveBeenCalledWith({ id: "reservation-001", status: to });
+				} else {
+					await expect(
+						updateReservationStatus(mockClient, "reservation-001", to)
+					).rejects.toThrow(ReservationValidationError);
+				}
+			});
+		});
+
+		it("should return null when reservation not found", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Not found" }],
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { get: mockGet, update: vi.fn() },
+				},
+			};
+
+			const result = await updateReservationStatus(mockClient, "nonexistent", "checked_in");
+
+			expect(result).toBeNull();
+		});
+	});
+
+	describe("softDeleteReservation", () => {
+		it("should set deletedAt and deletedBy", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { update: mockUpdate },
+				},
+			};
+
+			const result = await softDeleteReservation(
+				mockClient,
+				"reservation-001",
+				"admin@example.com"
+			);
+
+			expect(result).toBe(true);
+			const callArgs = mockUpdate.mock.calls[0][0];
+			expect(callArgs.id).toBe("reservation-001");
+			expect(callArgs.deletedAt).toBeDefined();
+			expect(callArgs.deletedBy).toBe("admin@example.com");
+		});
+
+		it("should return false on GraphQL error", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Error" }],
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { update: mockUpdate },
+				},
+			};
+
+			const result = await softDeleteReservation(
+				mockClient,
+				"reservation-001",
+				"admin@example.com"
+			);
+
+			expect(result).toBe(false);
+		});
+	});
+
+	describe("restoreReservation", () => {
+		it("should restore a recently deleted reservation", async () => {
+			const recentDeletedAt = new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString(); // 5 days ago
+
+			const mockGet = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001", deletedAt: recentDeletedAt },
+				errors: null,
+			});
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { get: mockGet, update: mockUpdate },
+				},
+			};
+
+			const result = await restoreReservation(mockClient, "reservation-001");
+
+			expect(result.success).toBe(true);
+			expect(mockUpdate).toHaveBeenCalledWith({
+				id: "reservation-001",
+				deletedAt: null,
+				deletedBy: null,
+			});
+		});
+
+		it("should reject restoration after retention period expires", async () => {
+			const oldDeletedAt = new Date(Date.now() - 60 * 24 * 60 * 60 * 1000).toISOString(); // 60 days ago
+
+			const mockGet = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001", deletedAt: oldDeletedAt },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { get: mockGet, update: vi.fn() },
+				},
+			};
+
+			const result = await restoreReservation(mockClient, "reservation-001", 30);
+
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("Retention period");
+		});
+
+		it("should return error when reservation not found", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Not found" }],
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { get: mockGet, update: vi.fn() },
+				},
+			};
+
+			const result = await restoreReservation(mockClient, "nonexistent");
+
+			expect(result.success).toBe(false);
+			expect(result.error).toBe("Reservation not found");
+		});
+	});
+
+	describe("deleteReservation", () => {
+		it("should permanently delete a reservation", async () => {
+			const mockDelete = vi.fn().mockResolvedValue({
+				data: { id: "reservation-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { delete: mockDelete },
+				},
+			};
+
+			const result = await deleteReservation(mockClient, "reservation-001");
+
+			expect(result).toBe(true);
+			expect(mockDelete).toHaveBeenCalledWith({ id: "reservation-001" });
+		});
+
+		it("should return false on GraphQL error", async () => {
+			const mockDelete = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Cannot delete" }],
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { delete: mockDelete },
+				},
+			};
+
+			const result = await deleteReservation(mockClient, "reservation-001");
+
+			expect(result).toBe(false);
+		});
+	});
+});