@htlkg/data 0.0.20 → 0.0.22

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

@@ -63,3 +63,13 @@ export {
 	getReservationByConfirmation,
 } from "./reservations";
 export type { Reservation } from "./reservations";
+
+// Contact queries
+export {
+	getContact,
+	listContacts,
+	listContactsByBrand,
+	getContactByEmail,
+	getContactByPhone,
+	searchContacts,
+} from "./contacts";

package/src/queries/products/index.ts

@@ -0,0 +1 @@
+export * from "./products";

package/src/queries/products/products.test.ts

@@ -0,0 +1,347 @@
+/**
+ * Product Query Tests
+ *
+ * Tests for product and product instance query functions.
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import {
+	getProduct,
+	listProducts,
+	listActiveProducts,
+	getProductInstance,
+	listProductInstancesByBrand,
+	listProductInstancesByAccount,
+	listEnabledProductInstancesByBrand,
+} from "./products";
+
+describe("Product Queries", () => {
+	const mockProduct = {
+		id: "product-001",
+		name: "WiFi Portal",
+		version: "1.0.0",
+		isActive: true,
+		schema: {},
+		uiSchema: {},
+		defaultConfig: {},
+	};
+
+	const mockProductInstance = {
+		id: "instance-001",
+		productId: "product-001",
+		brandId: "brand-001",
+		accountId: "account-001",
+		enabled: true,
+		config: {},
+	};
+
+	describe("getProduct", () => {
+		it("should return a product by ID", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: mockProduct,
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Product: { get: mockGet },
+				},
+			};
+
+			const result = await getProduct(mockClient, "product-001");
+
+			expect(result).toEqual(mockProduct);
+			expect(mockGet).toHaveBeenCalledWith({ id: "product-001" });
+		});
+
+		it("should return null when product not found", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Not found" }],
+			});
+
+			const mockClient = {
+				models: {
+					Product: { get: mockGet },
+				},
+			};
+
+			const result = await getProduct(mockClient, "nonexistent");
+
+			expect(result).toBeNull();
+		});
+
+		it("should throw on unexpected error", async () => {
+			const mockGet = vi.fn().mockRejectedValue(new Error("Network error"));
+
+			const mockClient = {
+				models: {
+					Product: { get: mockGet },
+				},
+			};
+
+			await expect(getProduct(mockClient, "product-001")).rejects.toThrow("Network error");
+		});
+	});
+
+	describe("listProducts", () => {
+		const mockProducts = [
+			mockProduct,
+			{ ...mockProduct, id: "product-002", name: "WhatsApp CRM" },
+		];
+
+		it("should return a list of products", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: mockProducts,
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Product: { list: mockList },
+				},
+			};
+
+			const result = await listProducts(mockClient);
+
+			expect(result.items).toHaveLength(2);
+			expect(result.items[0].id).toBe("product-001");
+		});
+
+		it("should pass filter options to the query", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockProduct],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Product: { list: mockList },
+				},
+			};
+
+			const filter = { isActive: { eq: true } };
+			await listProducts(mockClient, { filter, limit: 50 });
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter,
+				limit: 50,
+			});
+		});
+
+		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: {
+					Product: { list: mockList },
+				},
+			};
+
+			const result = await listProducts(mockClient);
+
+			expect(result.items).toHaveLength(0);
+		});
+	});
+
+	describe("listActiveProducts", () => {
+		it("should filter products by active status", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockProduct],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Product: { list: mockList },
+				},
+			};
+
+			await listActiveProducts(mockClient);
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: { isActive: { eq: true } },
+			});
+		});
+	});
+
+	describe("getProductInstance", () => {
+		it("should return a product instance by ID", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: mockProductInstance,
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: { get: mockGet },
+				},
+			};
+
+			const result = await getProductInstance(mockClient, "instance-001");
+
+			expect(result).toEqual(mockProductInstance);
+			expect(mockGet).toHaveBeenCalledWith({ id: "instance-001" });
+		});
+
+		it("should return null when not found", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Not found" }],
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: { get: mockGet },
+				},
+			};
+
+			const result = await getProductInstance(mockClient, "nonexistent");
+
+			expect(result).toBeNull();
+		});
+	});
+
+	describe("listProductInstancesByBrand", () => {
+		it("should filter instances by brand ID", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockProductInstance],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: { list: mockList },
+				},
+			};
+
+			await listProductInstancesByBrand(mockClient, "brand-001");
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: { brandId: { eq: "brand-001" } },
+			});
+		});
+
+		it("should support pagination", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockProductInstance],
+				errors: null,
+				nextToken: "next-page",
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: { list: mockList },
+				},
+			};
+
+			const result = await listProductInstancesByBrand(mockClient, "brand-001", {
+				limit: 10,
+			});
+
+			expect(result.nextToken).toBe("next-page");
+		});
+
+		it("should return empty array on error", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Error" }],
+				nextToken: undefined,
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: { list: mockList },
+				},
+			};
+
+			const result = await listProductInstancesByBrand(mockClient, "brand-001");
+
+			expect(result.items).toHaveLength(0);
+		});
+	});
+
+	describe("listProductInstancesByAccount", () => {
+		it("should filter instances by account ID", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockProductInstance],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: { list: mockList },
+				},
+			};
+
+			await listProductInstancesByAccount(mockClient, "account-001");
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: { accountId: { eq: "account-001" } },
+			});
+		});
+	});
+
+	describe("listEnabledProductInstancesByBrand", () => {
+		it("should filter by brand ID and enabled status", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockProductInstance],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: { list: mockList },
+				},
+			};
+
+			await listEnabledProductInstancesByBrand(mockClient, "brand-001");
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: {
+					brandId: { eq: "brand-001" },
+					enabled: { eq: true },
+				},
+			});
+		});
+
+		it("should support pagination options", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockProductInstance],
+				errors: null,
+				nextToken: "token-123",
+			});
+
+			const mockClient = {
+				models: {
+					ProductInstance: { list: mockList },
+				},
+			};
+
+			const result = await listEnabledProductInstancesByBrand(mockClient, "brand-001", {
+				limit: 5,
+				nextToken: "prev-token",
+			});
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: {
+					brandId: { eq: "brand-001" },
+					enabled: { eq: true },
+				},
+				limit: 5,
+				nextToken: "prev-token",
+			});
+			expect(result.nextToken).toBe("token-123");
+		});
+	});
+});

package/src/queries/reservations/index.ts

@@ -0,0 +1 @@
+export * from "./reservations";

package/src/queries/users/index.ts

@@ -0,0 +1 @@
+export * from "./users";