@htlkg/data 0.0.20 → 0.0.21

package/src/mutations/contacts.test.ts

@@ -0,0 +1,604 @@
+/**
+ * Contact Mutation Tests
+ *
+ * Tests for contact CRUD operations including Zod validation,
+ * soft delete, restore, and merge functionality.
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { Contact } from "@htlkg/core/types";
+import {
+	createContact,
+	updateContact,
+	softDeleteContact,
+	restoreContact,
+	deleteContact,
+	mergeContacts,
+	ContactValidationError,
+} from "./contacts";
+
+// 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,
+}));
+
+// Mock the contacts query functions
+vi.mock("../queries/contacts", () => ({
+	getContact: vi.fn(),
+}));
+
+import { getContact as mockGetContact } from "../queries/contacts";
+
+describe("Contact Mutations", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	describe("createContact", () => {
+		const validInput = {
+			brandId: "brand-123",
+			email: "john.doe@example.com",
+			firstName: "John",
+			lastName: "Doe",
+			gdprConsent: true,
+			gdprConsentDate: "2024-01-15T10:00:00Z",
+		};
+
+		it("should create a contact with valid input", async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: { id: "contact-001", ...validInput },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { create: mockCreate },
+				},
+			};
+
+			const result = await createContact(mockClient, validInput);
+
+			expect(result).toBeTruthy();
+			expect(result?.id).toBe("contact-001");
+			expect(mockCreate).toHaveBeenCalledTimes(1);
+		});
+
+		it("should throw ContactValidationError for missing required fields", async () => {
+			const mockClient = {
+				models: {
+					Contact: { create: vi.fn() },
+				},
+			};
+
+			const invalidInput = {
+				brandId: "brand-123",
+				email: "john.doe@example.com",
+				// Missing firstName, lastName, gdprConsent
+			} as any;
+
+			await expect(createContact(mockClient, invalidInput)).rejects.toThrow(
+				ContactValidationError
+			);
+		});
+
+		it("should throw ContactValidationError for invalid email", async () => {
+			const mockClient = {
+				models: {
+					Contact: { create: vi.fn() },
+				},
+			};
+
+			const invalidInput = {
+				...validInput,
+				email: "invalid-email",
+			};
+
+			await expect(createContact(mockClient, invalidInput)).rejects.toThrow(
+				ContactValidationError
+			);
+		});
+
+		it("should throw ContactValidationError for empty brandId", async () => {
+			const mockClient = {
+				models: {
+					Contact: { create: vi.fn() },
+				},
+			};
+
+			const invalidInput = {
+				...validInput,
+				brandId: "",
+			};
+
+			await expect(createContact(mockClient, invalidInput)).rejects.toThrow(
+				ContactValidationError
+			);
+		});
+
+		it("should return null when GraphQL returns errors", async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Database error" }],
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { create: mockCreate },
+				},
+			};
+
+			const result = await createContact(mockClient, validInput);
+
+			expect(result).toBeNull();
+		});
+
+		it("should accept optional fields", async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: { id: "contact-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { create: mockCreate },
+				},
+			};
+
+			const inputWithOptionals = {
+				...validInput,
+				phone: "+1234567890",
+				locale: "en-US",
+				marketingOptIn: true,
+				preferences: { theme: "dark" },
+				tags: ["vip", "returning"],
+				totalVisits: 5,
+				lastVisitDate: "2024-06-01",
+				firstVisitDate: "2023-01-15",
+				legacyId: "legacy-123",
+			};
+
+			await createContact(mockClient, inputWithOptionals);
+
+			expect(mockCreate).toHaveBeenCalledWith(inputWithOptionals);
+		});
+	});
+
+	describe("updateContact", () => {
+		it("should update a contact with valid input", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "contact-001", firstName: "Jane" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { update: mockUpdate },
+				},
+			};
+
+			const result = await updateContact(mockClient, {
+				id: "contact-001",
+				firstName: "Jane",
+			});
+
+			expect(result).toBeTruthy();
+			expect(mockUpdate).toHaveBeenCalledWith({ id: "contact-001", firstName: "Jane" });
+		});
+
+		it("should throw ContactValidationError for missing id", async () => {
+			const mockClient = {
+				models: {
+					Contact: { update: vi.fn() },
+				},
+			};
+
+			await expect(
+				updateContact(mockClient, { id: "" } as any)
+			).rejects.toThrow(ContactValidationError);
+		});
+
+		it("should throw ContactValidationError for invalid email in update", async () => {
+			const mockClient = {
+				models: {
+					Contact: { update: vi.fn() },
+				},
+			};
+
+			await expect(
+				updateContact(mockClient, {
+					id: "contact-001",
+					email: "invalid-email",
+				})
+			).rejects.toThrow(ContactValidationError);
+		});
+
+		it("should return null when GraphQL returns errors", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Update failed" }],
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { update: mockUpdate },
+				},
+			};
+
+			const result = await updateContact(mockClient, {
+				id: "contact-001",
+				firstName: "Jane",
+			});
+
+			expect(result).toBeNull();
+		});
+	});
+
+	describe("softDeleteContact", () => {
+		it("should set deletedAt and deletedBy", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "contact-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { update: mockUpdate },
+				},
+			};
+
+			const result = await softDeleteContact(
+				mockClient,
+				"contact-001",
+				"admin@example.com"
+			);
+
+			expect(result).toBe(true);
+			const callArgs = mockUpdate.mock.calls[0][0];
+			expect(callArgs.id).toBe("contact-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: {
+					Contact: { update: mockUpdate },
+				},
+			};
+
+			const result = await softDeleteContact(
+				mockClient,
+				"contact-001",
+				"admin@example.com"
+			);
+
+			expect(result).toBe(false);
+		});
+	});
+
+	describe("restoreContact", () => {
+		it("should restore a recently deleted contact", async () => {
+			const recentDeletedAt = new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString(); // 5 days ago
+
+			(mockGetContact as any).mockResolvedValue({
+				id: "contact-001",
+				deletedAt: recentDeletedAt,
+			});
+
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "contact-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { get: vi.fn(), update: mockUpdate },
+				},
+			};
+
+			const result = await restoreContact(mockClient, "contact-001");
+
+			expect(result.success).toBe(true);
+			expect(mockUpdate).toHaveBeenCalledWith({
+				id: "contact-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
+
+			(mockGetContact as any).mockResolvedValue({
+				id: "contact-001",
+				deletedAt: oldDeletedAt,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { get: vi.fn(), update: vi.fn() },
+				},
+			};
+
+			const result = await restoreContact(mockClient, "contact-001", 30);
+
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("Retention period");
+		});
+
+		it("should return error when contact not found", async () => {
+			(mockGetContact as any).mockResolvedValue(null);
+
+			const mockClient = {
+				models: {
+					Contact: { get: vi.fn(), update: vi.fn() },
+				},
+			};
+
+			const result = await restoreContact(mockClient, "nonexistent");
+
+			expect(result.success).toBe(false);
+			expect(result.error).toBe("Contact not found");
+		});
+	});
+
+	describe("deleteContact", () => {
+		it("should permanently delete a contact", async () => {
+			const mockDelete = vi.fn().mockResolvedValue({
+				data: { id: "contact-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { delete: mockDelete },
+				},
+			};
+
+			const result = await deleteContact(mockClient, "contact-001");
+
+			expect(result).toBe(true);
+			expect(mockDelete).toHaveBeenCalledWith({ id: "contact-001" });
+		});
+
+		it("should return false on GraphQL error", async () => {
+			const mockDelete = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Cannot delete" }],
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { delete: mockDelete },
+				},
+			};
+
+			const result = await deleteContact(mockClient, "contact-001");
+
+			expect(result).toBe(false);
+		});
+	});
+
+	describe("mergeContacts", () => {
+		const primaryContact: Contact = {
+			id: "contact-primary",
+			brandId: "brand-123",
+			email: "primary@example.com",
+			firstName: "John",
+			lastName: "Doe",
+			gdprConsent: true,
+			totalVisits: 5,
+			firstVisitDate: "2023-06-01",
+			lastVisitDate: "2024-01-15",
+			tags: ["vip"],
+		};
+
+		const duplicateContact: Contact = {
+			id: "contact-dup-1",
+			brandId: "brand-123",
+			email: "duplicate@example.com",
+			firstName: "John",
+			lastName: "Doe",
+			gdprConsent: true,
+			totalVisits: 3,
+			firstVisitDate: "2023-01-15",
+			lastVisitDate: "2024-06-01",
+			tags: ["returning"],
+		};
+
+		it("should merge contacts and aggregate data", async () => {
+			// Mock getContact to return contacts
+			(mockGetContact as any)
+				.mockResolvedValueOnce(primaryContact)
+				.mockResolvedValueOnce(duplicateContact);
+
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "contact-primary" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { update: mockUpdate },
+				},
+			};
+
+			const result = await mergeContacts(
+				mockClient,
+				{
+					primaryId: "contact-primary",
+					duplicateIds: ["contact-dup-1"],
+				},
+				"admin@example.com"
+			);
+
+			expect(result.success).toBe(true);
+			expect(result.deletedIds).toContain("contact-dup-1");
+
+			// Verify aggregated data
+			const updateCall = mockUpdate.mock.calls[0][0];
+			expect(updateCall.totalVisits).toBe(8); // 5 + 3
+			expect(updateCall.firstVisitDate).toBe("2023-01-15"); // Earlier date
+			expect(updateCall.lastVisitDate).toBe("2024-06-01"); // Later date
+			expect(updateCall.tags).toContain("vip");
+			expect(updateCall.tags).toContain("returning");
+		});
+
+		it("should throw ContactValidationError for missing primaryId", async () => {
+			const mockClient = {
+				models: {
+					Contact: { update: vi.fn() },
+				},
+			};
+
+			await expect(
+				mergeContacts(
+					mockClient,
+					{ primaryId: "", duplicateIds: ["contact-dup-1"] },
+					"admin@example.com"
+				)
+			).rejects.toThrow(ContactValidationError);
+		});
+
+		it("should throw ContactValidationError for empty duplicateIds", async () => {
+			const mockClient = {
+				models: {
+					Contact: { update: vi.fn() },
+				},
+			};
+
+			await expect(
+				mergeContacts(
+					mockClient,
+					{ primaryId: "contact-primary", duplicateIds: [] },
+					"admin@example.com"
+				)
+			).rejects.toThrow(ContactValidationError);
+		});
+
+		it("should return error when primary contact not found", async () => {
+			(mockGetContact as any).mockResolvedValueOnce(null);
+
+			const mockClient = {
+				models: {
+					Contact: { update: vi.fn() },
+				},
+			};
+
+			const result = await mergeContacts(
+				mockClient,
+				{
+					primaryId: "nonexistent",
+					duplicateIds: ["contact-dup-1"],
+				},
+				"admin@example.com"
+			);
+
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("Primary contact not found");
+		});
+
+		it("should return error when duplicate contact not found", async () => {
+			(mockGetContact as any)
+				.mockResolvedValueOnce(primaryContact)
+				.mockResolvedValueOnce(null);
+
+			const mockClient = {
+				models: {
+					Contact: { update: vi.fn() },
+				},
+			};
+
+			const result = await mergeContacts(
+				mockClient,
+				{
+					primaryId: "contact-primary",
+					duplicateIds: ["nonexistent"],
+				},
+				"admin@example.com"
+			);
+
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("Duplicate contact not found");
+		});
+
+		it("should handle multiple duplicates", async () => {
+			const duplicate2: Contact = {
+				id: "contact-dup-2",
+				brandId: "brand-123",
+				email: "duplicate2@example.com",
+				firstName: "John",
+				lastName: "Doe",
+				gdprConsent: true,
+				totalVisits: 2,
+				firstVisitDate: "2024-01-01",
+				lastVisitDate: "2024-07-01",
+				tags: ["newsletter"],
+			};
+
+			(mockGetContact as any)
+				.mockResolvedValueOnce(primaryContact)
+				.mockResolvedValueOnce(duplicateContact)
+				.mockResolvedValueOnce(duplicate2);
+
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "contact-primary" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Contact: { update: mockUpdate },
+				},
+			};
+
+			const result = await mergeContacts(
+				mockClient,
+				{
+					primaryId: "contact-primary",
+					duplicateIds: ["contact-dup-1", "contact-dup-2"],
+				},
+				"admin@example.com"
+			);
+
+			expect(result.success).toBe(true);
+
+			// Verify aggregated data from all contacts
+			const updateCall = mockUpdate.mock.calls[0][0];
+			expect(updateCall.totalVisits).toBe(10); // 5 + 3 + 2
+			expect(updateCall.firstVisitDate).toBe("2023-01-15"); // Earliest
+			expect(updateCall.lastVisitDate).toBe("2024-07-01"); // Latest
+			expect(updateCall.tags).toContain("vip");
+			expect(updateCall.tags).toContain("returning");
+			expect(updateCall.tags).toContain("newsletter");
+		});
+	});
+});