@htlkg/data 0.0.21 → 0.0.23

package/src/mutations/users/users.test.ts

@@ -0,0 +1,289 @@
+/**
+ * User Mutation Tests
+ *
+ * Tests for user CRUD operations including soft delete and restoration.
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import {
+	createUser,
+	updateUser,
+	softDeleteUser,
+	restoreUser,
+	deleteUser,
+} from "./users";
+
+// 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("User Mutations", () => {
+	describe("createUser", () => {
+		const validInput = {
+			cognitoId: "cognito-123",
+			email: "user@example.com",
+			accountId: "account-123",
+			roles: ["BRAND_ADMIN"],
+			status: "active" as const,
+		};
+
+		it("should create a user with valid input", async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: { id: "user-001", ...validInput },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					User: { create: mockCreate },
+				},
+			};
+
+			const result = await createUser(mockClient, validInput);
+
+			expect(result).toBeTruthy();
+			expect(result?.id).toBe("user-001");
+			expect(mockCreate).toHaveBeenCalledWith(validInput);
+		});
+
+		it("should return null when GraphQL returns errors", async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Validation error" }],
+			});
+
+			const mockClient = {
+				models: {
+					User: { create: mockCreate },
+				},
+			};
+
+			const result = await createUser(mockClient, validInput);
+
+			expect(result).toBeNull();
+		});
+
+		it("should throw on unexpected error", async () => {
+			const mockCreate = vi.fn().mockRejectedValue(new Error("Network error"));
+
+			const mockClient = {
+				models: {
+					User: { create: mockCreate },
+				},
+			};
+
+			await expect(createUser(mockClient, validInput)).rejects.toThrow("Network error");
+		});
+	});
+
+	describe("updateUser", () => {
+		it("should update a user", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "user-001", email: "updated@example.com" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					User: { update: mockUpdate },
+				},
+			};
+
+			const result = await updateUser(mockClient, {
+				id: "user-001",
+				email: "updated@example.com",
+			});
+
+			expect(result).toBeTruthy();
+			expect(result?.email).toBe("updated@example.com");
+		});
+
+		it("should return null on GraphQL error", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Update failed" }],
+			});
+
+			const mockClient = {
+				models: {
+					User: { update: mockUpdate },
+				},
+			};
+
+			const result = await updateUser(mockClient, { id: "user-001" });
+
+			expect(result).toBeNull();
+		});
+	});
+
+	describe("softDeleteUser", () => {
+		it("should set deletedAt and deletedBy", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "user-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					User: { update: mockUpdate },
+				},
+			};
+
+			const result = await softDeleteUser(mockClient, "user-001", "admin@example.com");
+
+			expect(result).toBe(true);
+			const callArgs = mockUpdate.mock.calls[0][0];
+			expect(callArgs.id).toBe("user-001");
+			expect(callArgs.status).toBe("deleted");
+			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: {
+					User: { update: mockUpdate },
+				},
+			};
+
+			const result = await softDeleteUser(mockClient, "user-001", "admin@example.com");
+
+			expect(result).toBe(false);
+		});
+	});
+
+	describe("restoreUser", () => {
+		it("should restore a recently deleted user", async () => {
+			const recentDeletedAt = new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString();
+
+			const mockGet = vi.fn().mockResolvedValue({
+				data: { id: "user-001", deletedAt: recentDeletedAt },
+				errors: null,
+			});
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "user-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					User: { get: mockGet, update: mockUpdate },
+				},
+			};
+
+			const result = await restoreUser(mockClient, "user-001");
+
+			expect(result.success).toBe(true);
+			expect(mockUpdate).toHaveBeenCalledWith({
+				id: "user-001",
+				status: "active",
+				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();
+
+			const mockGet = vi.fn().mockResolvedValue({
+				data: { id: "user-001", deletedAt: oldDeletedAt },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					User: { get: mockGet, update: vi.fn() },
+				},
+			};
+
+			const result = await restoreUser(mockClient, "user-001", 30);
+
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("Retention period");
+		});
+
+		it("should return error when user not found", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Not found" }],
+			});
+
+			const mockClient = {
+				models: {
+					User: { get: mockGet, update: vi.fn() },
+				},
+			};
+
+			const result = await restoreUser(mockClient, "nonexistent");
+
+			expect(result.success).toBe(false);
+			expect(result.error).toBe("User not found");
+		});
+	});
+
+	describe("deleteUser", () => {
+		it("should permanently delete a user", async () => {
+			const mockDelete = vi.fn().mockResolvedValue({
+				data: { id: "user-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					User: { delete: mockDelete },
+				},
+			};
+
+			const result = await deleteUser(mockClient, "user-001");
+
+			expect(result).toBe(true);
+			expect(mockDelete).toHaveBeenCalledWith({ id: "user-001" });
+		});
+
+		it("should return false on GraphQL error", async () => {
+			const mockDelete = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Cannot delete" }],
+			});
+
+			const mockClient = {
+				models: {
+					User: { delete: mockDelete },
+				},
+			};
+
+			const result = await deleteUser(mockClient, "user-001");
+
+			expect(result).toBe(false);
+		});
+	});
+});

package/src/mutations/{users.ts → users/users.ts}

@@ -8,8 +8,8 @@ import type { User } from "@htlkg/core/types";
 import {
 	checkRestoreEligibility,
 	DEFAULT_SOFT_DELETE_RETENTION_DAYS,
-} from "../queries/systemSettings";
-import type { CreateAuditFields, UpdateWithSoftDeleteFields } from "./common";
+} from "../../queries/systemSettings";
+import type { CreateAuditFields, UpdateWithSoftDeleteFields } from "../common";
 
 /**
  * Input type for creating a user

package/src/queries/accounts/accounts.test.ts

@@ -0,0 +1,228 @@
+/**
+ * Account Query Tests
+ *
+ * Tests for account query functions including filtering and relations.
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import {
+	getAccount,
+	listAccounts,
+	getAccountWithBrands,
+} from "./accounts";
+
+describe("Account Queries", () => {
+	const mockAccount = {
+		id: "account-001",
+		name: "Test Account",
+		logo: "logo.png",
+		subscription: { plan: "premium" },
+		settings: {},
+		status: "active",
+	};
+
+	describe("getAccount", () => {
+		it("should return an account by ID", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: mockAccount,
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Account: { get: mockGet },
+				},
+			};
+
+			const result = await getAccount(mockClient, "account-001");
+
+			expect(result).toEqual(mockAccount);
+			expect(mockGet).toHaveBeenCalledWith({ id: "account-001" });
+		});
+
+		it("should return null when account not found", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Not found" }],
+			});
+
+			const mockClient = {
+				models: {
+					Account: { get: mockGet },
+				},
+			};
+
+			const result = await getAccount(mockClient, "nonexistent");
+
+			expect(result).toBeNull();
+		});
+
+		it("should throw on unexpected error", async () => {
+			const mockGet = vi.fn().mockRejectedValue(new Error("Network error"));
+
+			const mockClient = {
+				models: {
+					Account: { get: mockGet },
+				},
+			};
+
+			await expect(getAccount(mockClient, "account-001")).rejects.toThrow("Network error");
+		});
+	});
+
+	describe("listAccounts", () => {
+		const mockAccounts = [
+			mockAccount,
+			{ ...mockAccount, id: "account-002", name: "Second Account" },
+		];
+
+		it("should return a list of accounts", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: mockAccounts,
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Account: { list: mockList },
+				},
+			};
+
+			const result = await listAccounts(mockClient);
+
+			expect(result.items).toHaveLength(2);
+			expect(result.items[0].id).toBe("account-001");
+		});
+
+		it("should pass filter options to the query", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockAccount],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Account: { list: mockList },
+				},
+			};
+
+			const filter = { status: { eq: "active" } };
+			await listAccounts(mockClient, { filter, limit: 50 });
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter,
+				limit: 50,
+			});
+		});
+
+		it("should return nextToken for pagination", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockAccount],
+				errors: null,
+				nextToken: "token-123",
+			});
+
+			const mockClient = {
+				models: {
+					Account: { list: mockList },
+				},
+			};
+
+			const result = await listAccounts(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: {
+					Account: { list: mockList },
+				},
+			};
+
+			const result = await listAccounts(mockClient);
+
+			expect(result.items).toHaveLength(0);
+			expect(result.nextToken).toBeUndefined();
+		});
+	});
+
+	describe("getAccountWithBrands", () => {
+		it("should return account with brands", async () => {
+			const accountWithBrands = {
+				...mockAccount,
+				brands: [
+					{ id: "brand-001", name: "Brand One" },
+					{ id: "brand-002", name: "Brand Two" },
+				],
+			};
+
+			const mockGet = vi.fn().mockResolvedValue({
+				data: accountWithBrands,
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Account: { get: mockGet },
+				},
+			};
+
+			const result = await getAccountWithBrands(mockClient, "account-001");
+
+			expect(result).toEqual(accountWithBrands);
+			expect(mockGet).toHaveBeenCalledWith(
+				{ id: "account-001" },
+				{
+					selectionSet: [
+						"id",
+						"name",
+						"logo",
+						"subscription",
+						"settings",
+						"brands.*",
+					],
+				}
+			);
+		});
+
+		it("should return null on error", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Not found" }],
+			});
+
+			const mockClient = {
+				models: {
+					Account: { get: mockGet },
+				},
+			};
+
+			const result = await getAccountWithBrands(mockClient, "nonexistent");
+
+			expect(result).toBeNull();
+		});
+
+		it("should throw on unexpected error", async () => {
+			const mockGet = vi.fn().mockRejectedValue(new Error("Database error"));
+
+			const mockClient = {
+				models: {
+					Account: { get: mockGet },
+				},
+			};
+
+			await expect(getAccountWithBrands(mockClient, "account-001")).rejects.toThrow(
+				"Database error"
+			);
+		});
+	});
+});

package/src/queries/accounts/index.ts

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