@htlkg/data 0.0.21 → 0.0.22

package/src/hooks/users/usePaginatedUsers.ts

@@ -0,0 +1,213 @@
+/**
+ * Paginated Users Hooks
+ *
+ * Vue composables for fetching users with server-side pagination.
+ * Provides separate hooks for active and deleted users to enable
+ * efficient tab-based filtering in large datasets.
+ */
+
+import type { Ref, ComputedRef } from "vue";
+import type { User } from "@htlkg/core/types";
+import {
+	createPaginatedDataHook,
+	ACTIVE_FILTER,
+	DELETED_FILTER,
+	type PaginatedHookOptions,
+	type PaginationState,
+} from "../createPaginatedDataHook";
+
+/** Extended User type with computed fields */
+export type UserWithRelations = User & {
+	accountName?: string;
+	brandNames?: string[];
+	deletedAt?: string;
+	deletedBy?: string;
+};
+
+export interface UsePaginatedUsersOptions extends PaginatedHookOptions {
+	/** Filter by brand ID */
+	brandId?: string;
+	/** Filter by account ID */
+	accountId?: string;
+}
+
+export interface UsePaginatedUsersReturn {
+	/** Reactive array of users */
+	users: Ref<UserWithRelations[]>;
+	/** Loading state (true during any fetch) */
+	loading: Ref<boolean>;
+	/** Loading state for initial fetch */
+	initialLoading: Ref<boolean>;
+	/** Loading state for loadMore */
+	loadingMore: Ref<boolean>;
+	/** Error state */
+	error: Ref<Error | null>;
+	/** Pagination state */
+	pagination: Ref<PaginationState>;
+	/** Whether there are more items to load */
+	hasMore: ComputedRef<boolean>;
+	/** Load next page of data */
+	loadMore: () => Promise<void>;
+	/** Refetch data (resets to first page) */
+	refetch: () => Promise<void>;
+	/** Reset data and pagination state */
+	reset: () => void;
+	/** Update search filter and refetch from server (searches ALL data) */
+	setSearchFilter: (filter: any) => Promise<void>;
+	/** Current search filter */
+	searchFilter: Ref<any>;
+}
+
+/**
+ * Build additional filter from hook options
+ */
+function buildFilter(options: UsePaginatedUsersOptions): any {
+	const conditions: any[] = [];
+
+	if (options.brandId) {
+		conditions.push({ brandIds: { contains: options.brandId } });
+	}
+
+	if (options.accountId) {
+		conditions.push({ accountId: { eq: options.accountId } });
+	}
+
+	if (options.filter && Object.keys(options.filter).length > 0) {
+		conditions.push(options.filter);
+	}
+
+	if (conditions.length === 0) {
+		return undefined;
+	}
+	if (conditions.length === 1) {
+		return conditions[0];
+	}
+	return { and: conditions };
+}
+
+/**
+ * Transform user data
+ */
+function transformUser(user: any): UserWithRelations {
+	return {
+		...user,
+		accountName: user.account?.name || "",
+	};
+}
+
+/**
+ * Selection set for user queries
+ */
+const USER_SELECTION_SET = [
+	"id",
+	"email",
+	"accountId",
+	"brandIds",
+	"roles",
+	"status",
+	"lastLogin",
+	"createdAt",
+	"deletedAt",
+	"deletedBy",
+	"account.name",
+];
+
+/**
+ * Internal hook for active users
+ */
+const useActiveUsersInternal = createPaginatedDataHook<UserWithRelations, UsePaginatedUsersOptions>({
+	model: "User",
+	dataPropertyName: "users",
+	defaultPageSize: 25,
+	selectionSet: USER_SELECTION_SET,
+	transform: transformUser,
+	buildFilter,
+	baseFilter: ACTIVE_FILTER,
+});
+
+/**
+ * Internal hook for deleted users
+ */
+const useDeletedUsersInternal = createPaginatedDataHook<UserWithRelations, UsePaginatedUsersOptions>({
+	model: "User",
+	dataPropertyName: "users",
+	defaultPageSize: 25,
+	selectionSet: USER_SELECTION_SET,
+	transform: transformUser,
+	buildFilter,
+	baseFilter: DELETED_FILTER,
+});
+
+/**
+ * Composable for fetching active (non-deleted) users with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useActiveUsers } from '@htlkg/data/hooks';
+ *
+ * const { users, loading, hasMore, loadMore, refetch } = useActiveUsers({
+ *   pageSize: 25,
+ * });
+ *
+ * // Load more when user scrolls or clicks "Load More"
+ * async function onLoadMore() {
+ *   await loadMore();
+ * }
+ * ```
+ *
+ * @example With filters
+ * ```typescript
+ * const { users, loading } = useActiveUsers({
+ *   accountId: 'account-123',
+ *   brandId: 'brand-456',
+ *   pageSize: 50
+ * });
+ * ```
+ */
+export function useActiveUsers(options: UsePaginatedUsersOptions = {}): UsePaginatedUsersReturn {
+	const result = useActiveUsersInternal(options);
+	return {
+		users: result.users as Ref<UserWithRelations[]>,
+		loading: result.loading,
+		initialLoading: result.initialLoading,
+		loadingMore: result.loadingMore,
+		error: result.error,
+		pagination: result.pagination,
+		hasMore: result.hasMore,
+		loadMore: result.loadMore,
+		refetch: result.refetch,
+		reset: result.reset,
+		setSearchFilter: result.setSearchFilter,
+		searchFilter: result.searchFilter,
+	};
+}
+
+/**
+ * Composable for fetching deleted users with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useDeletedUsers } from '@htlkg/data/hooks';
+ *
+ * const { users, loading, hasMore, loadMore, refetch } = useDeletedUsers({
+ *   pageSize: 25,
+ * });
+ * ```
+ */
+export function useDeletedUsers(options: UsePaginatedUsersOptions = {}): UsePaginatedUsersReturn {
+	const result = useDeletedUsersInternal(options);
+	return {
+		users: result.users as Ref<UserWithRelations[]>,
+		loading: result.loading,
+		initialLoading: result.initialLoading,
+		loadingMore: result.loadingMore,
+		error: result.error,
+		pagination: result.pagination,
+		hasMore: result.hasMore,
+		loadMore: result.loadMore,
+		refetch: result.refetch,
+		reset: result.reset,
+		setSearchFilter: result.setSearchFilter,
+		searchFilter: result.searchFilter,
+	};
+}

package/src/hooks/{useUsers.ts → users/useUsers.ts}

@@ -7,7 +7,7 @@
 
 import type { Ref } from "vue";
 import type { User } from "@htlkg/core/types";
-import { createDataHook, type BaseHookOptions } from "./createDataHook";
+import { createDataHook, type BaseHookOptions } from "../createDataHook";
 
 export interface UseUsersOptions extends BaseHookOptions {
 	/** Filter criteria for users */

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