@htlkg/data 0.0.21 → 0.0.23

package/src/queries/brands/brands.test.ts

@@ -0,0 +1,288 @@
+/**
+ * Brand Query Tests
+ *
+ * Tests for brand query functions including filtering and pagination.
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import {
+	getBrand,
+	listBrands,
+	getBrandWithProducts,
+	listBrandsByAccount,
+	listActiveBrands,
+} from "./brands";
+
+describe("Brand Queries", () => {
+	const mockBrand = {
+		id: "brand-001",
+		name: "Test Brand",
+		accountId: "account-123",
+		logo: "logo.png",
+		timezone: "America/New_York",
+		status: "active",
+		settings: {},
+	};
+
+	describe("getBrand", () => {
+		it("should return a brand by ID", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: mockBrand,
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Brand: { get: mockGet },
+				},
+			};
+
+			const result = await getBrand(mockClient, "brand-001");
+
+			expect(result).toEqual(mockBrand);
+			expect(mockGet).toHaveBeenCalledWith({ id: "brand-001" });
+		});
+
+		it("should return null when brand not found", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Not found" }],
+			});
+
+			const mockClient = {
+				models: {
+					Brand: { get: mockGet },
+				},
+			};
+
+			const result = await getBrand(mockClient, "nonexistent");
+
+			expect(result).toBeNull();
+		});
+
+		it("should throw on unexpected error", async () => {
+			const mockGet = vi.fn().mockRejectedValue(new Error("Network error"));
+
+			const mockClient = {
+				models: {
+					Brand: { get: mockGet },
+				},
+			};
+
+			await expect(getBrand(mockClient, "brand-001")).rejects.toThrow("Network error");
+		});
+	});
+
+	describe("listBrands", () => {
+		const mockBrands = [
+			mockBrand,
+			{ ...mockBrand, id: "brand-002", name: "Second Brand" },
+		];
+
+		it("should return a list of brands", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: mockBrands,
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Brand: { list: mockList },
+				},
+			};
+
+			const result = await listBrands(mockClient);
+
+			expect(result.items).toHaveLength(2);
+			expect(result.items[0].id).toBe("brand-001");
+		});
+
+		it("should pass filter options to the query", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockBrand],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Brand: { list: mockList },
+				},
+			};
+
+			const filter = { status: { eq: "active" } };
+			await listBrands(mockClient, { filter, limit: 50 });
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter,
+				limit: 50,
+			});
+		});
+
+		it("should return nextToken for pagination", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockBrand],
+				errors: null,
+				nextToken: "token-123",
+			});
+
+			const mockClient = {
+				models: {
+					Brand: { list: mockList },
+				},
+			};
+
+			const result = await listBrands(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: {
+					Brand: { list: mockList },
+				},
+			};
+
+			const result = await listBrands(mockClient);
+
+			expect(result.items).toHaveLength(0);
+			expect(result.nextToken).toBeUndefined();
+		});
+	});
+
+	describe("getBrandWithProducts", () => {
+		it("should return brand with product instances", async () => {
+			const brandWithProducts = {
+				...mockBrand,
+				productInstances: [
+					{ id: "pi-001", productId: "prod-001", enabled: true },
+				],
+			};
+
+			const mockGet = vi.fn().mockResolvedValue({
+				data: brandWithProducts,
+				errors: null,
+			});
+
+			const mockClient = {
+				models: {
+					Brand: { get: mockGet },
+				},
+			};
+
+			const result = await getBrandWithProducts(mockClient, "brand-001");
+
+			expect(result).toEqual(brandWithProducts);
+			expect(mockGet).toHaveBeenCalledWith(
+				{ id: "brand-001" },
+				{
+					selectionSet: [
+						"id",
+						"name",
+						"accountId",
+						"logo",
+						"timezone",
+						"status",
+						"settings",
+						"productInstances.*",
+					],
+				}
+			);
+		});
+
+		it("should return null on error", async () => {
+			const mockGet = vi.fn().mockResolvedValue({
+				data: null,
+				errors: [{ message: "Not found" }],
+			});
+
+			const mockClient = {
+				models: {
+					Brand: { get: mockGet },
+				},
+			};
+
+			const result = await getBrandWithProducts(mockClient, "nonexistent");
+
+			expect(result).toBeNull();
+		});
+	});
+
+	describe("listBrandsByAccount", () => {
+		it("should filter brands by account ID", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockBrand],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Brand: { list: mockList },
+				},
+			};
+
+			await listBrandsByAccount(mockClient, "account-123");
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: { accountId: { eq: "account-123" } },
+			});
+		});
+
+		it("should support pagination options", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockBrand],
+				errors: null,
+				nextToken: "next-page",
+			});
+
+			const mockClient = {
+				models: {
+					Brand: { list: mockList },
+				},
+			};
+
+			const result = await listBrandsByAccount(mockClient, "account-123", {
+				limit: 10,
+				nextToken: "current-token",
+			});
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: { accountId: { eq: "account-123" } },
+				limit: 10,
+				nextToken: "current-token",
+			});
+			expect(result.nextToken).toBe("next-page");
+		});
+	});
+
+	describe("listActiveBrands", () => {
+		it("should filter brands by active status", async () => {
+			const mockList = vi.fn().mockResolvedValue({
+				data: [mockBrand],
+				errors: null,
+				nextToken: null,
+			});
+
+			const mockClient = {
+				models: {
+					Brand: { list: mockList },
+				},
+			};
+
+			await listActiveBrands(mockClient);
+
+			expect(mockList).toHaveBeenCalledWith({
+				filter: { status: { eq: "active" } },
+			});
+		});
+	});
+});

package/src/queries/brands/index.ts

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

package/src/queries/products/index.ts

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

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