@htlkg/data 0.0.21 → 0.0.22

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

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