@htlkg/data 0.0.21 → 0.0.23

package/src/hooks/reservations/usePaginatedReservations.ts

@@ -0,0 +1,258 @@
+/**
+ * Paginated Reservations Hooks
+ *
+ * Vue composables for fetching reservations with server-side pagination.
+ * Provides separate hooks for active and deleted reservations to enable
+ * efficient tab-based filtering in large datasets.
+ */
+
+import type { Ref, ComputedRef } from "vue";
+import type { Reservation } from "../../queries/reservations";
+import {
+	createPaginatedDataHook,
+	ACTIVE_FILTER,
+	DELETED_FILTER,
+	type PaginatedHookOptions,
+	type PaginationState,
+} from "../createPaginatedDataHook";
+import type { ReservationWithRelations } from "./useReservations";
+
+export interface UsePaginatedReservationsOptions extends PaginatedHookOptions {
+	/** Filter by brand ID */
+	brandId?: string;
+	/** Filter by start date (check-in date >= startDate) */
+	startDate?: string;
+	/** Filter by end date (check-in date <= endDate) */
+	endDate?: string;
+	/** Filter by reservation status */
+	status?: Reservation["status"];
+	/** Filter by contact/visit ID */
+	contactId?: string;
+}
+
+export interface UsePaginatedReservationsReturn {
+	/** Reactive array of reservations with brand and guest info */
+	reservations: Ref<ReservationWithRelations[]>;
+	/** 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: UsePaginatedReservationsOptions): any {
+	const conditions: any[] = [];
+
+	if (options.brandId) {
+		conditions.push({ brandId: { eq: options.brandId } });
+	}
+
+	if (options.status) {
+		conditions.push({ status: { eq: options.status } });
+	}
+
+	if (options.contactId) {
+		conditions.push({ visitId: { eq: options.contactId } });
+	}
+
+	if (options.startDate) {
+		conditions.push({ checkIn: { ge: options.startDate } });
+	}
+
+	if (options.endDate) {
+		conditions.push({ checkIn: { le: options.endDate } });
+	}
+
+	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 reservation data to include brandName and guest info from visit.snapshot
+ */
+function transformReservation(r: any): ReservationWithRelations {
+	// Parse snapshot if it's a string (handles double-stringification from import)
+	let snapshot = r.visit?.snapshot;
+	if (typeof snapshot === "string") {
+		try {
+			snapshot = JSON.parse(snapshot);
+		} catch {
+			snapshot = null;
+		}
+	}
+
+	return {
+		...r,
+		brandName: r.brand?.name || "Unknown Brand",
+		guestName: snapshot
+			? `${snapshot.firstName || ""} ${snapshot.lastName || ""}`.trim() || "Unknown Guest"
+			: "Unknown Guest",
+		guestEmail: snapshot?.email || "",
+		guestPhone: snapshot?.phone || "",
+	};
+}
+
+/**
+ * Selection set for reservation queries
+ */
+const RESERVATION_SELECTION_SET = [
+	"id",
+	"brandId",
+	"visitId",
+	"checkIn",
+	"checkOut",
+	"room",
+	"roomType",
+	"status",
+	"source",
+	"channel",
+	"confirmationCode",
+	"totalAmount",
+	"currency",
+	"nights",
+	"deletedAt",
+	"deletedBy",
+	"brand.name",
+	"visit.snapshot",
+];
+
+/**
+ * Internal hook for active reservations
+ */
+const useActiveReservationsInternal = createPaginatedDataHook<
+	ReservationWithRelations,
+	UsePaginatedReservationsOptions
+>({
+	model: "Reservation",
+	dataPropertyName: "reservations",
+	defaultPageSize: 25,
+	selectionSet: RESERVATION_SELECTION_SET,
+	transform: transformReservation,
+	buildFilter,
+	baseFilter: ACTIVE_FILTER,
+});
+
+/**
+ * Internal hook for deleted reservations
+ */
+const useDeletedReservationsInternal = createPaginatedDataHook<
+	ReservationWithRelations,
+	UsePaginatedReservationsOptions
+>({
+	model: "Reservation",
+	dataPropertyName: "reservations",
+	defaultPageSize: 25,
+	selectionSet: RESERVATION_SELECTION_SET,
+	transform: transformReservation,
+	buildFilter,
+	baseFilter: DELETED_FILTER,
+});
+
+/**
+ * Composable for fetching active (non-deleted) reservations with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useActiveReservations } from '@htlkg/data/hooks';
+ *
+ * const { reservations, loading, hasMore, loadMore, refetch } = useActiveReservations({
+ *   pageSize: 25,
+ *   brandId: 'brand-123',
+ * });
+ *
+ * // Load more when user scrolls or clicks "Load More"
+ * async function onLoadMore() {
+ *   await loadMore();
+ * }
+ * ```
+ *
+ * @example With date filters
+ * ```typescript
+ * const { reservations, loading } = useActiveReservations({
+ *   brandId: 'brand-123',
+ *   startDate: '2026-01-01',
+ *   endDate: '2026-01-31',
+ *   status: 'confirmed'
+ * });
+ * ```
+ */
+export function useActiveReservations(
+	options: UsePaginatedReservationsOptions = {},
+): UsePaginatedReservationsReturn {
+	const result = useActiveReservationsInternal(options);
+	return {
+		reservations: result.reservations as Ref<ReservationWithRelations[]>,
+		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 reservations with pagination
+ *
+ * @example
+ * ```typescript
+ * import { useDeletedReservations } from '@htlkg/data/hooks';
+ *
+ * const { reservations, loading, hasMore, loadMore, refetch } = useDeletedReservations({
+ *   pageSize: 25,
+ * });
+ * ```
+ */
+export function useDeletedReservations(
+	options: UsePaginatedReservationsOptions = {},
+): UsePaginatedReservationsReturn {
+	const result = useDeletedReservationsInternal(options);
+	return {
+		reservations: result.reservations as Ref<ReservationWithRelations[]>,
+		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/{useReservations.ts → reservations/useReservations.ts}

@@ -6,8 +6,8 @@
  */
 
 import type { Ref, ComputedRef } from "vue";
-import type { Reservation } from "../queries/reservations";
-import { createDataHook, type BaseHookOptions } from "./createDataHook";
+import type { Reservation } from "../../queries/reservations";
+import { createDataHook, type BaseHookOptions } from "../createDataHook";
 
 export interface UseReservationsOptions extends BaseHookOptions {
 	/** Filter by brand ID */
@@ -24,13 +24,21 @@ export interface UseReservationsOptions extends BaseHookOptions {
 	nextToken?: string;
 }
 
+/** Extended reservation type with related data */
+export type ReservationWithRelations = Reservation & {
+	brandName: string;
+	guestName: string;
+	guestEmail: string;
+	guestPhone: string;
+};
+
 export interface UseReservationsReturn {
-	/** Reactive array of reservations */
-	reservations: Ref<Reservation[]>;
+	/** Reactive array of reservations with brand and guest info */
+	reservations: Ref<ReservationWithRelations[]>;
 	/** Computed array of confirmed reservations */
-	confirmedReservations: ComputedRef<Reservation[]>;
+	confirmedReservations: ComputedRef<ReservationWithRelations[]>;
 	/** Computed array of active reservations (confirmed or checked_in) */
-	activeReservations: ComputedRef<Reservation[]>;
+	activeReservations: ComputedRef<ReservationWithRelations[]>;
 	/** Loading state */
 	loading: Ref<boolean>;
 	/** Error state */
@@ -80,17 +88,64 @@ function buildFilter(options: UseReservationsOptions): any {
 	return { and: conditions };
 }
 
+/**
+ * Transform reservation data to include brandName and guest info from visit.snapshot
+ */
+function transformReservation(r: any): Reservation & { brandName: string; guestName: string; guestEmail: string; guestPhone: string } {
+	// Parse snapshot if it's a string (handles double-stringification from import)
+	let snapshot = r.visit?.snapshot;
+	if (typeof snapshot === "string") {
+		try {
+			snapshot = JSON.parse(snapshot);
+		} catch {
+			snapshot = null;
+		}
+	}
+
+	return {
+		...r,
+		brandName: r.brand?.name || "Unknown Brand",
+		guestName: snapshot
+			? `${snapshot.firstName || ""} ${snapshot.lastName || ""}`.trim() || "Unknown Guest"
+			: "Unknown Guest",
+		guestEmail: snapshot?.email || "",
+		guestPhone: snapshot?.phone || "",
+	};
+}
+
 /**
  * Internal hook created by factory
  */
 const useReservationsInternal = createDataHook<
-	Reservation,
+	Reservation & { brandName: string; guestName: string; guestEmail: string; guestPhone: string },
 	UseReservationsOptions,
 	{ confirmedReservations: Reservation[]; activeReservations: Reservation[] }
 >({
 	model: "Reservation",
 	dataPropertyName: "reservations",
 	buildFilter,
+	// Include related data for brand name and guest info
+	selectionSet: [
+		"id",
+		"brandId",
+		"visitId",
+		"checkIn",
+		"checkOut",
+		"room",
+		"roomType",
+		"status",
+		"source",
+		"channel",
+		"confirmationCode",
+		"totalAmount",
+		"currency",
+		"nights",
+		"deletedAt",
+		"deletedBy",
+		"brand.name",
+		"visit.snapshot",
+	],
+	transform: transformReservation,
 	computedProperties: {
 		confirmedReservations: (reservations) =>
 			reservations.filter((r) => r.status === "confirmed"),
@@ -135,9 +190,9 @@ const useReservationsInternal = createDataHook<
 export function useReservations(options: UseReservationsOptions = {}): UseReservationsReturn {
 	const result = useReservationsInternal(options);
 	return {
-		reservations: result.reservations as Ref<Reservation[]>,
-		confirmedReservations: result.confirmedReservations as ComputedRef<Reservation[]>,
-		activeReservations: result.activeReservations as ComputedRef<Reservation[]>,
+		reservations: result.reservations as Ref<ReservationWithRelations[]>,
+		confirmedReservations: result.confirmedReservations as ComputedRef<ReservationWithRelations[]>,
+		activeReservations: result.activeReservations as ComputedRef<ReservationWithRelations[]>,
 		loading: result.loading,
 		error: result.error,
 		refetch: result.refetch,

package/src/hooks/users/index.ts

@@ -0,0 +1,2 @@
+export * from "./useUsers";
+export * from "./usePaginatedUsers";

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 */