@htlkg/data 0.0.20 → 0.0.21

package/src/queries/contacts.test.ts

@@ -0,0 +1,505 @@
+/**
+ * Contact Query Tests
+ *
+ * Tests for contact query functions including filtering,
+ * pagination, and specialized queries.
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import {
+	getContact,
+	listContacts,
+	listContactsByBrand,
+	getContactByEmail,
+	getContactByPhone,
+	searchContacts,
+} from "./contacts";
+
+describe("Contact Queries", () => {
+	const mockContact = {
+		id: "contact-001",
+		brandId: "brand-123",
+		email: "john.doe@example.com",
+		phone: "+1234567890",
+		firstName: "John",
+		lastName: "Doe",
+		locale: "en-US",
+		gdprConsent: true,
+		gdprConsentDate: "2024-01-15T10:00:00Z",
+		marketingOptIn: true,
+		preferences: { theme: "dark" },
+		tags: ["vip", "returning"],
+		totalVisits: 5,
+		lastVisitDate: "2024-06-01",
+		firstVisitDate: "2023-01-15",
+	};
+
+	describe("getContact", () => {
+		it("should return a contact by ID", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: mockContact,
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { get: mockGet },
+				},
+			};
+
+			const result = await getContact(mockClient, "contact-001");
+
+			expect(result).toEqual(mockContact);
+			expect(mockGet).toHaveBeenCalledWith({ id: "contact-001" });
+		});
+
+		it("should return null when contact not found", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Not found" }],
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { get: mockGet },
+				},
+			};
+
+			const result = await getContact(mockClient, "nonexistent");
+
+			expect(result).toBeNull();
+		});
+
+		it("should throw on unexpected error", async () => {
+			const mockGet = vi.fn().mockRejectedValue(new Error("Network error"));
+
+			const mockClient = {
+				models: {
+					Contact: { get: mockGet },
+				},
+			};
+
+			await expect(getContact(mockClient, "contact-001")).rejects.toThrow(
+				"Network error"
+			);
+		});
+	});
+
+	describe("listContacts", () => {
+		const mockContacts = [
+			mockContact,
+			{ ...mockContact, id: "contact-002", email: "jane.doe@example.com" },
+		];
+
+		it("should return a list of contacts", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: mockContacts,
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			const result = await listContacts(mockClient);
+
+			expect(result.items).toHaveLength(2);
+			expect(result.items[0].id).toBe("contact-001");
+		});
+
+		it("should pass filter options to the query", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockContact],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			const filter = { gdprConsent: { eq: true } };
+			await listContacts(mockClient, { filter, limit: 50 });
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter,
+				limit: 50,
+			});
+		});
+
+		it("should return nextToken for pagination", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockContact],
+				errors: null,
+				nextToken: "token-123",
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			const result = await listContacts(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: {
+					Contact: { list: mockList },
+				},
+			};
+
+			const result = await listContacts(mockClient);
+
+			expect(result.items).toHaveLength(0);
+			expect(result.nextToken).toBeUndefined();
+		});
+	});
+
+	describe("listContactsByBrand", () => {
+		it("should filter contacts by brand ID", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockContact],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			await listContactsByBrand(mockClient, "brand-123");
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: { brandId: { eq: "brand-123" } },
+			});
+		});
+
+		it("should pass pagination options", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockContact],
+				errors: null,
+				nextToken: "next-page",
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			const result = await listContactsByBrand(mockClient, "brand-123", {
+				limit: 25,
+				nextToken: "current-page",
+			});
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: { brandId: { eq: "brand-123" } },
+				limit: 25,
+				nextToken: "current-page",
+			});
+			expect(result.nextToken).toBe("next-page");
+		});
+	});
+
+	describe("getContactByEmail", () => {
+		it("should return contact matching email and brand", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockContact],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			const result = await getContactByEmail(
+				mockClient,
+				"john.doe@example.com",
+				"brand-123"
+			);
+
+			expect(result).toEqual(mockContact);
+			expect(mockList).toHaveBeenCalledWith({
+				filter: {
+					and: [
+						{ email: { eq: "john.doe@example.com" } },
+						{ brandId: { eq: "brand-123" } },
+					],
+				},
+				limit: 1,
+			});
+		});
+
+		it("should return null when no matching contact found", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			const result = await getContactByEmail(
+				mockClient,
+				"nonexistent@example.com",
+				"brand-123"
+			);
+
+			expect(result).toBeFalsy();
+		});
+
+		it("should return null on GraphQL error", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Query failed" }],
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			const result = await getContactByEmail(
+				mockClient,
+				"john.doe@example.com",
+				"brand-123"
+			);
+
+			expect(result).toBeNull();
+		});
+
+		it("should throw on unexpected error", async () => {
+			const mockList = vi.fn().mockRejectedValue(new Error("Database error"));
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			await expect(
+				getContactByEmail(mockClient, "john.doe@example.com", "brand-123")
+			).rejects.toThrow("Database error");
+		});
+	});
+
+	describe("getContactByPhone", () => {
+		it("should return contact matching phone and brand", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockContact],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			const result = await getContactByPhone(
+				mockClient,
+				"+1234567890",
+				"brand-123"
+			);
+
+			expect(result).toEqual(mockContact);
+			expect(mockList).toHaveBeenCalledWith({
+				filter: {
+					and: [
+						{ phone: { eq: "+1234567890" } },
+						{ brandId: { eq: "brand-123" } },
+					],
+				},
+				limit: 1,
+			});
+		});
+
+		it("should return null when no matching contact found", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			const result = await getContactByPhone(
+				mockClient,
+				"+9999999999",
+				"brand-123"
+			);
+
+			expect(result).toBeFalsy();
+		});
+
+		it("should return null on GraphQL error", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Query failed" }],
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			const result = await getContactByPhone(
+				mockClient,
+				"+1234567890",
+				"brand-123"
+			);
+
+			expect(result).toBeNull();
+		});
+
+		it("should throw on unexpected error", async () => {
+			const mockList = vi.fn().mockRejectedValue(new Error("Database error"));
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			await expect(
+				getContactByPhone(mockClient, "+1234567890", "brand-123")
+			).rejects.toThrow("Database error");
+		});
+	});
+
+	describe("searchContacts", () => {
+		it("should search contacts by query string within brand", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockContact],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			await searchContacts(mockClient, "john", "brand-123");
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: {
+					and: [
+						{ brandId: { eq: "brand-123" } },
+						{
+							or: [
+								{ email: { contains: "john" } },
+								{ firstName: { contains: "john" } },
+								{ lastName: { contains: "john" } },
+							],
+						},
+					],
+				},
+			});
+		});
+
+		it("should support pagination for search queries", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockContact],
+				errors: null,
+				nextToken: "next-page",
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			const result = await searchContacts(mockClient, "john", "brand-123", {
+				limit: 10,
+				nextToken: "current-page",
+			});
+
+			expect(result.nextToken).toBe("next-page");
+			expect(mockList).toHaveBeenCalledWith({
+				filter: {
+					and: [
+						{ brandId: { eq: "brand-123" } },
+						{
+							or: [
+								{ email: { contains: "john" } },
+								{ firstName: { contains: "john" } },
+								{ lastName: { contains: "john" } },
+							],
+						},
+					],
+				},
+				limit: 10,
+				nextToken: "current-page",
+			});
+		});
+
+		it("should return empty array on GraphQL error", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Search failed" }],
+				nextToken: undefined,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			const result = await searchContacts(mockClient, "john", "brand-123");
+
+			expect(result.items).toHaveLength(0);
+			expect(result.nextToken).toBeUndefined();
+		});
+
+		it("should throw on unexpected error", async () => {
+			const mockList = vi.fn().mockRejectedValue(new Error("Search error"));
+
+			const mockClient = {
+				models: {
+					Contact: { list: mockList },
+				},
+			};
+
+			await expect(
+				searchContacts(mockClient, "john", "brand-123")
+			).rejects.toThrow("Search error");
+		});
+	});
+});