@htlkg/data 0.0.21 → 0.0.23

package/src/mutations/accounts/accounts.test.ts

@@ -0,0 +1,287 @@
+/**
+ * Account Mutation Tests
+ *
+ * Tests for account CRUD operations including soft delete and restoration.
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import {
+	createAccount,
+	updateAccount,
+	softDeleteAccount,
+	restoreAccount,
+	deleteAccount,
+} from "./accounts";
+
+// 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("Account Mutations", () => {
+	describe("createAccount", () => {
+		const validInput = {
+			name: "Test Account",
+			subscription: { plan: "premium" },
+			status: "active" as const,
+		};
+
+		it("should create an account with valid input", async () => {
+			const mockCreate = vi.fn().mockResolvedValue({
+				data: { id: "account-001", ...validInput },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Account: { create: mockCreate },
+				},
+			};
+
+			const result = await createAccount(mockClient, validInput);
+
+			expect(result).toBeTruthy();
+			expect(result?.id).toBe("account-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: {
+					Account: { create: mockCreate },
+				},
+			};
+
+			const result = await createAccount(mockClient, validInput);
+
+			expect(result).toBeNull();
+		});
+
+		it("should throw on unexpected error", async () => {
+			const mockCreate = vi.fn().mockRejectedValue(new Error("Network error"));
+
+			const mockClient = {
+				models: {
+					Account: { create: mockCreate },
+				},
+			};
+
+			await expect(createAccount(mockClient, validInput)).rejects.toThrow("Network error");
+		});
+	});
+
+	describe("updateAccount", () => {
+		it("should update an account", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "account-001", name: "Updated Account" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Account: { update: mockUpdate },
+				},
+			};
+
+			const result = await updateAccount(mockClient, {
+				id: "account-001",
+				name: "Updated Account",
+			});
+
+			expect(result).toBeTruthy();
+			expect(result?.name).toBe("Updated Account");
+		});
+
+		it("should return null on GraphQL error", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Update failed" }],
+			});
+
+			const mockClient = {
+				models: {
+					Account: { update: mockUpdate },
+				},
+			};
+
+			const result = await updateAccount(mockClient, { id: "account-001" });
+
+			expect(result).toBeNull();
+		});
+	});
+
+	describe("softDeleteAccount", () => {
+		it("should set deletedAt and deletedBy", async () => {
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "account-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Account: { update: mockUpdate },
+				},
+			};
+
+			const result = await softDeleteAccount(mockClient, "account-001", "admin@example.com");
+
+			expect(result).toBe(true);
+			const callArgs = mockUpdate.mock.calls[0][0];
+			expect(callArgs.id).toBe("account-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: {
+					Account: { update: mockUpdate },
+				},
+			};
+
+			const result = await softDeleteAccount(mockClient, "account-001", "admin@example.com");
+
+			expect(result).toBe(false);
+		});
+	});
+
+	describe("restoreAccount", () => {
+		it("should restore a recently deleted account", async () => {
+			const recentDeletedAt = new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString();
+
+			const mockGet = vi.fn().mockResolvedValue({
+				data: { id: "account-001", deletedAt: recentDeletedAt },
+				errors: null,
+			});
+			const mockUpdate = vi.fn().mockResolvedValue({
+				data: { id: "account-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Account: { get: mockGet, update: mockUpdate },
+				},
+			};
+
+			const result = await restoreAccount(mockClient, "account-001");
+
+			expect(result.success).toBe(true);
+			expect(mockUpdate).toHaveBeenCalledWith({
+				id: "account-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: "account-001", deletedAt: oldDeletedAt },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Account: { get: mockGet, update: vi.fn() },
+				},
+			};
+
+			const result = await restoreAccount(mockClient, "account-001", 30);
+
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("Retention period");
+		});
+
+		it("should return error when account not found", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Not found" }],
+			});
+
+			const mockClient = {
+				models: {
+					Account: { get: mockGet, update: vi.fn() },
+				},
+			};
+
+			const result = await restoreAccount(mockClient, "nonexistent");
+
+			expect(result.success).toBe(false);
+			expect(result.error).toBe("Account not found");
+		});
+	});
+
+	describe("deleteAccount", () => {
+		it("should permanently delete an account", async () => {
+			const mockDelete = vi.fn().mockResolvedValue({
+				data: { id: "account-001" },
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Account: { delete: mockDelete },
+				},
+			};
+
+			const result = await deleteAccount(mockClient, "account-001");
+
+			expect(result).toBe(true);
+			expect(mockDelete).toHaveBeenCalledWith({ id: "account-001" });
+		});
+
+		it("should return false on GraphQL error", async () => {
+			const mockDelete = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Cannot delete" }],
+			});
+
+			const mockClient = {
+				models: {
+					Account: { delete: mockDelete },
+				},
+			};
+
+			const result = await deleteAccount(mockClient, "account-001");
+
+			expect(result).toBe(false);
+		});
+	});
+});

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

@@ -8,8 +8,8 @@ import type { Account } 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 an account

package/src/mutations/accounts/index.ts

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

package/src/mutations/brands/brands.test.ts

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

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

@@ -8,8 +8,8 @@ import type { Brand } 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 brand

package/src/mutations/brands/index.ts

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

package/src/mutations/reservations/index.ts

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

package/src/mutations/{reservations.test.ts → reservations/reservations.test.ts}

@@ -18,7 +18,7 @@ import {
 } from "./reservations";
 
 // Mock the systemSettings query functions
-vi.mock("../queries/systemSettings", () => ({
+vi.mock("../../queries/systemSettings", () => ({
 	checkRestoreEligibility: vi.fn((deletedAt: string | null, retentionDays: number) => {
 		if (!deletedAt) {
 			return { canRestore: false, daysRemaining: 0, daysExpired: 0 };

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

@@ -8,8 +8,8 @@
 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";
 
 /**
  * Reservation status type

package/src/mutations/users/index.ts

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