@htlkg/data 0.0.21 → 0.0.22

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";

package/src/queries/users/users.test.ts

@@ -0,0 +1,301 @@
+/**
+ * User Query Tests
+ *
+ * Tests for user query functions including filtering and pagination.
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import {
+	getUser,
+	getUserByCognitoId,
+	getUserByEmail,
+	listUsers,
+	listUsersByAccount,
+	listActiveUsers,
+} from "./users";
+
+describe("User Queries", () => {
+	const mockUser = {
+		id: "user-001",
+		cognitoId: "cognito-123",
+		email: "user@example.com",
+		accountId: "account-123",
+		brandIds: ["brand-001"],
+		roles: ["BRAND_ADMIN"],
+		status: "active",
+	};
+
+	describe("getUser", () => {
+		it("should return a user by ID", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: mockUser,
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					User: { get: mockGet },
+				},
+			};
+
+			const result = await getUser(mockClient, "user-001");
+
+			expect(result).toEqual(mockUser);
+			expect(mockGet).toHaveBeenCalledWith({ id: "user-001" });
+		});
+
+		it("should return null when user not found", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Not found" }],
+			});
+
+			const mockClient = {
+				models: {
+					User: { get: mockGet },
+				},
+			};
+
+			const result = await getUser(mockClient, "nonexistent");
+
+			expect(result).toBeNull();
+		});
+
+		it("should throw on unexpected error", async () => {
+			const mockGet = vi.fn().mockRejectedValue(new Error("Network error"));
+
+			const mockClient = {
+				models: {
+					User: { get: mockGet },
+				},
+			};
+
+			await expect(getUser(mockClient, "user-001")).rejects.toThrow("Network error");
+		});
+	});
+
+	describe("getUserByCognitoId", () => {
+		it("should return user by Cognito ID", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockUser],
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					User: { list: mockList },
+				},
+			};
+
+			const result = await getUserByCognitoId(mockClient, "cognito-123");
+
+			expect(result).toEqual(mockUser);
+			expect(mockList).toHaveBeenCalledWith({
+				filter: { cognitoId: { eq: "cognito-123" } },
+				limit: 1,
+			});
+		});
+
+		it("should return undefined when no user found", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [],
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					User: { list: mockList },
+				},
+			};
+
+			const result = await getUserByCognitoId(mockClient, "nonexistent");
+
+			expect(result).toBeUndefined();
+		});
+
+		it("should return null on GraphQL error", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Query failed" }],
+			});
+
+			const mockClient = {
+				models: {
+					User: { list: mockList },
+				},
+			};
+
+			const result = await getUserByCognitoId(mockClient, "cognito-123");
+
+			expect(result).toBeNull();
+		});
+	});
+
+	describe("getUserByEmail", () => {
+		it("should return user by email", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockUser],
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					User: { list: mockList },
+				},
+			};
+
+			const result = await getUserByEmail(mockClient, "user@example.com");
+
+			expect(result).toEqual(mockUser);
+			expect(mockList).toHaveBeenCalledWith({
+				filter: { email: { eq: "user@example.com" } },
+				limit: 1,
+			});
+		});
+
+		it("should return undefined when no user found", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [],
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					User: { list: mockList },
+				},
+			};
+
+			const result = await getUserByEmail(mockClient, "notfound@example.com");
+
+			expect(result).toBeUndefined();
+		});
+	});
+
+	describe("listUsers", () => {
+		const mockUsers = [
+			mockUser,
+			{ ...mockUser, id: "user-002", email: "user2@example.com" },
+		];
+
+		it("should return a list of users", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: mockUsers,
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					User: { list: mockList },
+				},
+			};
+
+			const result = await listUsers(mockClient);
+
+			expect(result.items).toHaveLength(2);
+			expect(result.items[0].id).toBe("user-001");
+		});
+
+		it("should pass filter options to the query", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockUser],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					User: { list: mockList },
+				},
+			};
+
+			const filter = { status: { eq: "active" } };
+			await listUsers(mockClient, { filter, limit: 50 });
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter,
+				limit: 50,
+			});
+		});
+
+		it("should return nextToken for pagination", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockUser],
+				errors: null,
+				nextToken: "token-123",
+			});
+
+			const mockClient = {
+				models: {
+					User: { list: mockList },
+				},
+			};
+
+			const result = await listUsers(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: {
+					User: { list: mockList },
+				},
+			};
+
+			const result = await listUsers(mockClient);
+
+			expect(result.items).toHaveLength(0);
+		});
+	});
+
+	describe("listUsersByAccount", () => {
+		it("should filter users by account ID", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockUser],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					User: { list: mockList },
+				},
+			};
+
+			await listUsersByAccount(mockClient, "account-123");
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: { accountId: { eq: "account-123" } },
+			});
+		});
+	});
+
+	describe("listActiveUsers", () => {
+		it("should filter users by active status", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockUser],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					User: { list: mockList },
+				},
+			};
+
+			await listActiveUsers(mockClient);
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: { status: { eq: "active" } },
+			});
+		});
+	});
+});