@htlkg/data 0.0.19 → 0.0.21

package/src/queries/contacts.ts

@@ -0,0 +1,237 @@
+/**
+ * Contact Query Functions
+ *
+ * Provides query functions for fetching contact data from the GraphQL API.
+ */
+
+import type { Contact } from "@htlkg/core/types";
+
+/**
+ * Get a single contact by ID
+ *
+ * @example
+ * ```typescript
+ * import { getContact } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const contact = await getContact(client, 'contact-123');
+ * ```
+ */
+export async function getContact<TClient = any>(
+	client: TClient,
+	id: string,
+): Promise<Contact | null> {
+	try {
+		const { data, errors } = await (client as any).models.Contact.get({ id });
+
+		if (errors) {
+			console.error("[getContact] GraphQL errors:", errors);
+			return null;
+		}
+
+		return data as Contact;
+	} catch (error) {
+		console.error("[getContact] Error fetching contact:", error);
+		throw error;
+	}
+}
+
+/**
+ * List all contacts with optional filtering
+ *
+ * @example
+ * ```typescript
+ * import { listContacts } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const contacts = await listContacts(client, {
+ *   filter: { gdprConsent: { eq: true } },
+ *   limit: 50
+ * });
+ * ```
+ */
+export async function listContacts<TClient = any>(
+	client: TClient,
+	options?: {
+		filter?: any;
+		limit?: number;
+		nextToken?: string;
+	},
+): Promise<{ items: Contact[]; nextToken?: string }> {
+	try {
+		const { data, errors, nextToken } = await (
+			client as any
+		).models.Contact.list(options);
+
+		if (errors) {
+			console.error("[listContacts] GraphQL errors:", errors);
+			return { items: [], nextToken: undefined };
+		}
+
+		return {
+			items: (data || []) as Contact[],
+			nextToken,
+		};
+	} catch (error) {
+		console.error("[listContacts] Error fetching contacts:", error);
+		throw error;
+	}
+}
+
+/**
+ * List contacts by brand ID
+ *
+ * @example
+ * ```typescript
+ * import { listContactsByBrand } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const contacts = await listContactsByBrand(client, 'brand-123');
+ * ```
+ */
+export async function listContactsByBrand<TClient = any>(
+	client: TClient,
+	brandId: string,
+	options?: {
+		limit?: number;
+		nextToken?: string;
+	},
+): Promise<{ items: Contact[]; nextToken?: string }> {
+	return listContacts(client, {
+		filter: { brandId: { eq: brandId } },
+		...options,
+	});
+}
+
+/**
+ * Get a contact by email within a brand
+ *
+ * @example
+ * ```typescript
+ * import { getContactByEmail } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const contact = await getContactByEmail(client, 'guest@example.com', 'brand-123');
+ * ```
+ */
+export async function getContactByEmail<TClient = any>(
+	client: TClient,
+	email: string,
+	brandId: string,
+): Promise<Contact | null> {
+	try {
+		const { data, errors } = await (client as any).models.Contact.list({
+			filter: {
+				and: [{ email: { eq: email } }, { brandId: { eq: brandId } }],
+			},
+			limit: 1,
+		});
+
+		if (errors) {
+			console.error("[getContactByEmail] GraphQL errors:", errors);
+			return null;
+		}
+
+		return data?.[0] as Contact | null;
+	} catch (error) {
+		console.error("[getContactByEmail] Error fetching contact:", error);
+		throw error;
+	}
+}
+
+/**
+ * Get a contact by phone within a brand
+ *
+ * @example
+ * ```typescript
+ * import { getContactByPhone } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const contact = await getContactByPhone(client, '+1234567890', 'brand-123');
+ * ```
+ */
+export async function getContactByPhone<TClient = any>(
+	client: TClient,
+	phone: string,
+	brandId: string,
+): Promise<Contact | null> {
+	try {
+		const { data, errors } = await (client as any).models.Contact.list({
+			filter: {
+				and: [{ phone: { eq: phone } }, { brandId: { eq: brandId } }],
+			},
+			limit: 1,
+		});
+
+		if (errors) {
+			console.error("[getContactByPhone] GraphQL errors:", errors);
+			return null;
+		}
+
+		return data?.[0] as Contact | null;
+	} catch (error) {
+		console.error("[getContactByPhone] Error fetching contact:", error);
+		throw error;
+	}
+}
+
+/**
+ * Search contacts by query string within a brand
+ * Searches across email, firstName, and lastName fields
+ *
+ * @example
+ * ```typescript
+ * import { searchContacts } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const contacts = await searchContacts(client, 'john', 'brand-123');
+ * ```
+ */
+export async function searchContacts<TClient = any>(
+	client: TClient,
+	query: string,
+	brandId: string,
+	options?: {
+		limit?: number;
+		nextToken?: string;
+	},
+): Promise<{ items: Contact[]; nextToken?: string }> {
+	try {
+		const { data, errors, nextToken } = await (
+			client as any
+		).models.Contact.list({
+			filter: {
+				and: [
+					{ brandId: { eq: brandId } },
+					{
+						or: [
+							{ email: { contains: query } },
+							{ firstName: { contains: query } },
+							{ lastName: { contains: query } },
+						],
+					},
+				],
+			},
+			...options,
+		});
+
+		if (errors) {
+			console.error("[searchContacts] GraphQL errors:", errors);
+			return { items: [], nextToken: undefined };
+		}
+
+		return {
+			items: (data || []) as Contact[],
+			nextToken,
+		};
+	} catch (error) {
+		console.error("[searchContacts] Error searching contacts:", error);
+		throw error;
+	}
+}

package/src/queries/index.ts

@@ -52,3 +52,24 @@ export {
 	SYSTEM_SETTINGS_KEY,
 	DEFAULT_SOFT_DELETE_RETENTION_DAYS,
 } from "./systemSettings";
+
+// Reservation queries
+export {
+	getReservation,
+	listReservations,
+	listReservationsByBrand,
+	listReservationsByContact,
+	listReservationsByDateRange,
+	getReservationByConfirmation,
+} from "./reservations";
+export type { Reservation } from "./reservations";
+
+// Contact queries
+export {
+	getContact,
+	listContacts,
+	listContactsByBrand,
+	getContactByEmail,
+	getContactByPhone,
+	searchContacts,
+} from "./contacts";

package/src/queries/reservations.test.ts

@@ -0,0 +1,374 @@
+/**
+ * Reservation Query Tests
+ *
+ * Tests for reservation query functions including filtering,
+ * pagination, and specialized queries.
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+	getReservation,
+	listReservations,
+	listReservationsByBrand,
+	listReservationsByContact,
+	listReservationsByDateRange,
+	getReservationByConfirmation,
+	type Reservation,
+} from "./reservations";
+
+describe("Reservation Queries", () => {
+	const mockReservation: Reservation = {
+		id: "reservation-001",
+		brandId: "brand-123",
+		visitId: "visit-456",
+		confirmationCode: "ABC123",
+		checkIn: "2024-06-01",
+		checkOut: "2024-06-05",
+		status: "confirmed",
+		source: "direct",
+		room: "101",
+		nights: 4,
+	};
+
+	describe("getReservation", () => {
+		it("should return a reservation by ID", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: mockReservation,
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { get: mockGet },
+				},
+			};
+
+			const result = await getReservation(mockClient, "reservation-001");
+
+			expect(result).toEqual(mockReservation);
+			expect(mockGet).toHaveBeenCalledWith({ id: "reservation-001" });
+		});
+
+		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 },
+				},
+			};
+
+			const result = await getReservation(mockClient, "nonexistent");
+
+			expect(result).toBeNull();
+		});
+
+		it("should throw on unexpected error", async () => {
+			const mockGet = vi.fn().mockRejectedValue(new Error("Network error"));
+
+			const mockClient = {
+				models: {
+					Reservation: { get: mockGet },
+				},
+			};
+
+			await expect(getReservation(mockClient, "reservation-001")).rejects.toThrow(
+				"Network error"
+			);
+		});
+	});
+
+	describe("listReservations", () => {
+		const mockReservations = [
+			mockReservation,
+			{ ...mockReservation, id: "reservation-002", confirmationCode: "DEF456" },
+		];
+
+		it("should return a list of reservations", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: mockReservations,
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { list: mockList },
+				},
+			};
+
+			const result = await listReservations(mockClient);
+
+			expect(result.items).toHaveLength(2);
+			expect(result.items[0].id).toBe("reservation-001");
+		});
+
+		it("should pass filter options to the query", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockReservation],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { list: mockList },
+				},
+			};
+
+			const filter = { status: { eq: "confirmed" } };
+			await listReservations(mockClient, { filter, limit: 50 });
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter,
+				limit: 50,
+			});
+		});
+
+		it("should return nextToken for pagination", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockReservation],
+				errors: null,
+				nextToken: "token-123",
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { list: mockList },
+				},
+			};
+
+			const result = await listReservations(mockClient, { limit: 1 });
+
+			expect(result.nextToken).toBe("token-123");
+		});
+
+		it("should return empty array on GraphQL error", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Query failed" }],
+				nextToken: undefined,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { list: mockList },
+				},
+			};
+
+			const result = await listReservations(mockClient);
+
+			expect(result.items).toHaveLength(0);
+			expect(result.nextToken).toBeUndefined();
+		});
+	});
+
+	describe("listReservationsByBrand", () => {
+		it("should filter reservations by brand ID", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockReservation],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { list: mockList },
+				},
+			};
+
+			await listReservationsByBrand(mockClient, "brand-123");
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: { brandId: { eq: "brand-123" } },
+				limit: undefined,
+				nextToken: undefined,
+			});
+		});
+
+		it("should combine brand filter with additional filters", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockReservation],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { list: mockList },
+				},
+			};
+
+			await listReservationsByBrand(mockClient, "brand-123", {
+				filter: { status: { eq: "confirmed" } },
+				limit: 50,
+			});
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: {
+					and: [
+						{ brandId: { eq: "brand-123" } },
+						{ status: { eq: "confirmed" } },
+					],
+				},
+				limit: 50,
+				nextToken: undefined,
+			});
+		});
+	});
+
+	describe("listReservationsByContact", () => {
+		it("should filter reservations by contact/visit ID", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockReservation],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { list: mockList },
+				},
+			};
+
+			await listReservationsByContact(mockClient, "visit-456");
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: { visitId: { eq: "visit-456" } },
+				limit: undefined,
+				nextToken: undefined,
+			});
+		});
+	});
+
+	describe("listReservationsByDateRange", () => {
+		it("should filter reservations by date range and brand", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockReservation],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { list: mockList },
+				},
+			};
+
+			await listReservationsByDateRange(
+				mockClient,
+				"brand-123",
+				"2024-06-01",
+				"2024-06-30"
+			);
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: {
+					and: [
+						{ brandId: { eq: "brand-123" } },
+						{ checkIn: { ge: "2024-06-01" } },
+						{ checkIn: { le: "2024-06-30" } },
+					],
+				},
+				limit: undefined,
+				nextToken: undefined,
+			});
+		});
+
+		it("should support pagination for date range queries", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockReservation],
+				errors: null,
+				nextToken: "next-page",
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { list: mockList },
+				},
+			};
+
+			const result = await listReservationsByDateRange(
+				mockClient,
+				"brand-123",
+				"2024-06-01",
+				"2024-06-30",
+				{ limit: 10 }
+			);
+
+			expect(result.nextToken).toBe("next-page");
+		});
+	});
+
+	describe("getReservationByConfirmation", () => {
+		it("should return reservation matching confirmation code and brand", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockReservation],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { list: mockList },
+				},
+			};
+
+			const result = await getReservationByConfirmation(
+				mockClient,
+				"ABC123",
+				"brand-123"
+			);
+
+			expect(result).toEqual(mockReservation);
+			expect(mockList).toHaveBeenCalledWith({
+				filter: {
+					and: [
+						{ confirmationCode: { eq: "ABC123" } },
+						{ brandId: { eq: "brand-123" } },
+					],
+				},
+				limit: 1,
+			});
+		});
+
+		it("should return null when no matching reservation found", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Reservation: { list: mockList },
+				},
+			};
+
+			const result = await getReservationByConfirmation(
+				mockClient,
+				"NONEXISTENT",
+				"brand-123"
+			);
+
+			expect(result).toBeNull();
+		});
+
+		it("should throw on unexpected error", async () => {
+			const mockList = vi.fn().mockRejectedValue(new Error("Database error"));
+
+			const mockClient = {
+				models: {
+					Reservation: { list: mockList },
+				},
+			};
+
+			await expect(
+				getReservationByConfirmation(mockClient, "ABC123", "brand-123")
+			).rejects.toThrow("Database error");
+		});
+	});
+});