@htlkg/data 0.0.20 → 0.0.22

package/src/hooks/accounts/usePaginatedAccounts.ts

@@ -0,0 +1,166 @@
+/**
+ * Paginated Accounts Hooks
+ *
+ * Vue composables for fetching accounts with server-side pagination.
+ * Provides separate hooks for active and deleted accounts to enable
+ * efficient tab-based filtering in large datasets.
+ */
+
+import type { Ref, ComputedRef } from "vue";
+import {
+	createPaginatedDataHook,
+	ACTIVE_FILTER,
+	DELETED_FILTER,
+	type PaginatedHookOptions,
+	type PaginationState,
+} from "../createPaginatedDataHook";
+import type { AccountWithBrands } from "./useAccounts";
+
+export interface UsePaginatedAccountsOptions extends PaginatedHookOptions {
+	// Add any account-specific filters here if needed
+}
+
+export interface UsePaginatedAccountsReturn {
+	/** Reactive array of accounts with brands */
+	accounts: Ref<AccountWithBrands[]>;
+	/** 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>;
+}
+
+/**
+ * Transform account data to include brandCount
+ */
+function transformAccount(account: any): AccountWithBrands {
+	const brands = account.brands || [];
+	return {
+		...account,
+		brands,
+		brandCount: brands.length,
+	};
+}
+
+/**
+ * Selection set for account queries
+ */
+const ACCOUNT_SELECTION_SET = [
+	"id",
+	"name",
+	"logo",
+	"subscription",
+	"settings",
+	"status",
+	"deletedAt",
+	"deletedBy",
+	"brands.id",
+	"brands.name",
+	"brands.status",
+];
+
+/**
+ * Internal hook for active accounts
+ */
+const useActiveAccountsInternal = createPaginatedDataHook<AccountWithBrands, UsePaginatedAccountsOptions>({
+	model: "Account",
+	dataPropertyName: "accounts",
+	defaultPageSize: 25,
+	selectionSet: ACCOUNT_SELECTION_SET,
+	transform: transformAccount,
+	baseFilter: ACTIVE_FILTER,
+});
+
+/**
+ * Internal hook for deleted accounts
+ */
+const useDeletedAccountsInternal = createPaginatedDataHook<AccountWithBrands, UsePaginatedAccountsOptions>({
+	model: "Account",
+	dataPropertyName: "accounts",
+	defaultPageSize: 25,
+	selectionSet: ACCOUNT_SELECTION_SET,
+	transform: transformAccount,
+	baseFilter: DELETED_FILTER,
+});
+
+/**
+ * Composable for fetching active (non-deleted) accounts with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useActiveAccounts } from '@htlkg/data/hooks';
+ *
+ * const { accounts, loading, hasMore, loadMore, refetch } = useActiveAccounts({
+ *   pageSize: 25,
+ * });
+ *
+ * // Load more when user scrolls or clicks "Load More"
+ * async function onLoadMore() {
+ *   await loadMore();
+ * }
+ * ```
+ */
+export function useActiveAccounts(options: UsePaginatedAccountsOptions = {}): UsePaginatedAccountsReturn {
+	const result = useActiveAccountsInternal(options);
+	return {
+		accounts: result.accounts as Ref<AccountWithBrands[]>,
+		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 accounts with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useDeletedAccounts } from '@htlkg/data/hooks';
+ *
+ * const { accounts, loading, hasMore, loadMore, refetch } = useDeletedAccounts({
+ *   pageSize: 25,
+ * });
+ * ```
+ */
+export function useDeletedAccounts(options: UsePaginatedAccountsOptions = {}): UsePaginatedAccountsReturn {
+	const result = useDeletedAccountsInternal(options);
+	return {
+		accounts: result.accounts as Ref<AccountWithBrands[]>,
+		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/brands/index.ts

@@ -0,0 +1,2 @@
+export * from "./useBrands";
+export * from "./usePaginatedBrands";

package/src/hooks/{useBrands.ts → brands/useBrands.ts}

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

package/src/hooks/brands/usePaginatedBrands.ts

@@ -0,0 +1,206 @@
+/**
+ * Paginated Brands Hooks
+ *
+ * Vue composables for fetching brands with server-side pagination.
+ * Provides separate hooks for active and deleted brands to enable
+ * efficient tab-based filtering in large datasets.
+ */
+
+import type { Ref, ComputedRef } from "vue";
+import type { Brand } from "@htlkg/core/types";
+import {
+	createPaginatedDataHook,
+	ACTIVE_FILTER,
+	DELETED_FILTER,
+	type PaginatedHookOptions,
+	type PaginationState,
+} from "../createPaginatedDataHook";
+
+/** Extended Brand type with computed fields */
+export type BrandWithCounts = Brand & {
+	accountName?: string;
+	enabledProductCount?: number;
+	totalProductCount?: number;
+	deletedAt?: string;
+	deletedBy?: string;
+};
+
+export interface UsePaginatedBrandsOptions extends PaginatedHookOptions {
+	/** Filter by account ID */
+	accountId?: string;
+}
+
+export interface UsePaginatedBrandsReturn {
+	/** Reactive array of brands */
+	brands: Ref<BrandWithCounts[]>;
+	/** 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: UsePaginatedBrandsOptions): any {
+	const conditions: any[] = [];
+
+	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 brand data
+ */
+function transformBrand(brand: any): BrandWithCounts {
+	return {
+		...brand,
+		accountName: brand.account?.name || "",
+	};
+}
+
+/**
+ * Selection set for brand queries
+ */
+const BRAND_SELECTION_SET = [
+	"id",
+	"name",
+	"accountId",
+	"logo",
+	"timezone",
+	"status",
+	"settings",
+	"deletedAt",
+	"deletedBy",
+	"account.name",
+];
+
+/**
+ * Internal hook for active brands
+ */
+const useActiveBrandsInternal = createPaginatedDataHook<BrandWithCounts, UsePaginatedBrandsOptions>({
+	model: "Brand",
+	dataPropertyName: "brands",
+	defaultPageSize: 25,
+	selectionSet: BRAND_SELECTION_SET,
+	transform: transformBrand,
+	buildFilter,
+	baseFilter: ACTIVE_FILTER,
+});
+
+/**
+ * Internal hook for deleted brands
+ */
+const useDeletedBrandsInternal = createPaginatedDataHook<BrandWithCounts, UsePaginatedBrandsOptions>({
+	model: "Brand",
+	dataPropertyName: "brands",
+	defaultPageSize: 25,
+	selectionSet: BRAND_SELECTION_SET,
+	transform: transformBrand,
+	buildFilter,
+	baseFilter: DELETED_FILTER,
+});
+
+/**
+ * Composable for fetching active (non-deleted) brands with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useActiveBrands } from '@htlkg/data/hooks';
+ *
+ * const { brands, loading, hasMore, loadMore, refetch } = useActiveBrands({
+ *   pageSize: 25,
+ * });
+ *
+ * // Load more when user scrolls or clicks "Load More"
+ * async function onLoadMore() {
+ *   await loadMore();
+ * }
+ * ```
+ *
+ * @example With account filter
+ * ```typescript
+ * const { brands, loading } = useActiveBrands({
+ *   accountId: 'account-123',
+ *   pageSize: 50
+ * });
+ * ```
+ */
+export function useActiveBrands(options: UsePaginatedBrandsOptions = {}): UsePaginatedBrandsReturn {
+	const result = useActiveBrandsInternal(options);
+	return {
+		brands: result.brands as Ref<BrandWithCounts[]>,
+		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 brands with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useDeletedBrands } from '@htlkg/data/hooks';
+ *
+ * const { brands, loading, hasMore, loadMore, refetch } = useDeletedBrands({
+ *   pageSize: 25,
+ * });
+ * ```
+ */
+export function useDeletedBrands(options: UsePaginatedBrandsOptions = {}): UsePaginatedBrandsReturn {
+	const result = useDeletedBrandsInternal(options);
+	return {
+		brands: result.brands as Ref<BrandWithCounts[]>,
+		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,
+	};
+}