@htlkg/data 0.0.19 → 0.0.21

package/src/hooks/useContacts.test.ts

@@ -0,0 +1,159 @@
+/**
+ * useContacts Hook Tests
+ *
+ * Tests for the useContacts Vue composable including structure validation,
+ * computed properties, and filter building.
+ */
+
+import { describe, it, expect } from "vitest";
+import { useContacts } from "./useContacts";
+
+describe("useContacts Hook", () => {
+	describe("structure", () => {
+		it("should be a function", () => {
+			expect(typeof useContacts).toBe("function");
+		});
+
+		it("should return expected properties", () => {
+			const result = useContacts({ autoFetch: false });
+
+			expect(result).toHaveProperty("contacts");
+			expect(result).toHaveProperty("consentedContacts");
+			expect(result).toHaveProperty("marketingContacts");
+			expect(result).toHaveProperty("loading");
+			expect(result).toHaveProperty("error");
+			expect(result).toHaveProperty("refetch");
+			expect(typeof result.refetch).toBe("function");
+		});
+	});
+
+	describe("initial state", () => {
+		it("should have empty contacts array initially", () => {
+			const result = useContacts({ autoFetch: false });
+
+			expect(result.contacts.value).toEqual([]);
+		});
+
+		it("should have loading as false when autoFetch is disabled", () => {
+			const result = useContacts({ autoFetch: false });
+
+			expect(result.loading.value).toBe(false);
+		});
+
+		it("should have error as null initially", () => {
+			const result = useContacts({ autoFetch: false });
+
+			expect(result.error.value).toBeNull();
+		});
+	});
+
+	describe("computed properties", () => {
+		it("should have consentedContacts computed property", () => {
+			const result = useContacts({ autoFetch: false });
+
+			expect(result.consentedContacts).toBeDefined();
+			expect(result.consentedContacts.value).toEqual([]);
+		});
+
+		it("should have marketingContacts computed property", () => {
+			const result = useContacts({ autoFetch: false });
+
+			expect(result.marketingContacts).toBeDefined();
+			expect(result.marketingContacts.value).toEqual([]);
+		});
+	});
+
+	describe("options", () => {
+		it("should accept brandId option", () => {
+			const result = useContacts({
+				brandId: "brand-123",
+				autoFetch: false,
+			});
+
+			expect(result).toBeDefined();
+		});
+
+		it("should accept search option", () => {
+			const result = useContacts({
+				search: "john",
+				autoFetch: false,
+			});
+
+			expect(result).toBeDefined();
+		});
+
+		it("should accept gdprConsent option", () => {
+			const result = useContacts({
+				gdprConsent: true,
+				autoFetch: false,
+			});
+
+			expect(result).toBeDefined();
+		});
+
+		it("should accept marketingOptIn option", () => {
+			const result = useContacts({
+				marketingOptIn: true,
+				autoFetch: false,
+			});
+
+			expect(result).toBeDefined();
+		});
+
+		it("should accept tags option", () => {
+			const result = useContacts({
+				tags: ["vip", "returning"],
+				autoFetch: false,
+			});
+
+			expect(result).toBeDefined();
+		});
+
+		it("should accept limit option", () => {
+			const result = useContacts({
+				limit: 50,
+				autoFetch: false,
+			});
+
+			expect(result).toBeDefined();
+		});
+
+		it("should accept nextToken option", () => {
+			const result = useContacts({
+				nextToken: "token-123",
+				autoFetch: false,
+			});
+
+			expect(result).toBeDefined();
+		});
+
+		it("should accept combined filter options", () => {
+			const result = useContacts({
+				brandId: "brand-123",
+				search: "john",
+				gdprConsent: true,
+				marketingOptIn: true,
+				tags: ["vip"],
+				limit: 25,
+				autoFetch: false,
+			});
+
+			expect(result).toBeDefined();
+		});
+	});
+
+	describe("refetch function", () => {
+		it("should be callable", () => {
+			const result = useContacts({ autoFetch: false });
+
+			expect(() => result.refetch()).not.toThrow();
+		});
+
+		it("should return a Promise", () => {
+			const result = useContacts({ autoFetch: false });
+
+			const refetchResult = result.refetch();
+			expect(refetchResult).toBeInstanceOf(Promise);
+		});
+	});
+});

package/src/hooks/useContacts.ts

@@ -0,0 +1,176 @@
+/**
+ * useContacts Hook
+ *
+ * Vue composable for fetching and managing contact data with reactive state.
+ * Provides loading states, error handling, search, pagination, and refetch capabilities.
+ */
+
+import type { Ref, ComputedRef } from "vue";
+import type { Contact } from "@htlkg/core/types";
+import { createDataHook, type BaseHookOptions } from "./createDataHook";
+
+export interface UseContactsOptions extends BaseHookOptions {
+	/** Filter by brand ID */
+	brandId?: string;
+	/** Search query (searches email, firstName, lastName) */
+	search?: string;
+	/** Filter by GDPR consent */
+	gdprConsent?: boolean;
+	/** Filter by marketing opt-in */
+	marketingOptIn?: boolean;
+	/** Filter by tags (contact must have at least one of these tags) */
+	tags?: string[];
+	/** Pagination token for fetching next page */
+	nextToken?: string;
+}
+
+export interface UseContactsReturn {
+	/** Reactive array of contacts */
+	contacts: Ref<Contact[]>;
+	/** Computed array of contacts with GDPR consent */
+	consentedContacts: ComputedRef<Contact[]>;
+	/** Computed array of contacts opted-in for marketing */
+	marketingContacts: ComputedRef<Contact[]>;
+	/** Loading state */
+	loading: Ref<boolean>;
+	/** Error state */
+	error: Ref<Error | null>;
+	/** Refetch contacts */
+	refetch: () => Promise<void>;
+}
+
+/**
+ * Build filter from hook options
+ */
+function buildFilter(options: UseContactsOptions): any {
+	const conditions: any[] = [];
+
+	// Filter by brand
+	if (options.brandId) {
+		conditions.push({ brandId: { eq: options.brandId } });
+	}
+
+	// Search across email, firstName, lastName
+	if (options.search) {
+		conditions.push({
+			or: [
+				{ email: { contains: options.search } },
+				{ firstName: { contains: options.search } },
+				{ lastName: { contains: options.search } },
+			],
+		});
+	}
+
+	// Filter by GDPR consent
+	if (options.gdprConsent !== undefined) {
+		conditions.push({ gdprConsent: { eq: options.gdprConsent } });
+	}
+
+	// Filter by marketing opt-in
+	if (options.marketingOptIn !== undefined) {
+		conditions.push({ marketingOptIn: { eq: options.marketingOptIn } });
+	}
+
+	// Filter by tags (contact must have at least one of these tags)
+	if (options.tags && options.tags.length > 0) {
+		const tagConditions = options.tags.map((tag) => ({
+			tags: { contains: tag },
+		}));
+		conditions.push({ or: tagConditions });
+	}
+
+	// Include any additional custom filter
+	if (options.filter) {
+		conditions.push(options.filter);
+	}
+
+	if (conditions.length === 0) {
+		return undefined;
+	}
+
+	if (conditions.length === 1) {
+		return conditions[0];
+	}
+
+	return { and: conditions };
+}
+
+/**
+ * Internal hook created by factory
+ */
+const useContactsInternal = createDataHook<
+	Contact,
+	UseContactsOptions,
+	{ consentedContacts: Contact[]; marketingContacts: Contact[] }
+>({
+	model: "Contact",
+	dataPropertyName: "contacts",
+	buildFilter,
+	computedProperties: {
+		consentedContacts: (contacts) =>
+			contacts.filter((c) => c.gdprConsent === true),
+		marketingContacts: (contacts) =>
+			contacts.filter((c) => c.marketingOptIn === true),
+	},
+});
+
+/**
+ * Composable for fetching and managing contacts
+ *
+ * @example
+ * ```typescript
+ * import { useContacts } from '@htlkg/data/hooks';
+ *
+ * const { contacts, loading, error, refetch } = useContacts({
+ *   brandId: 'brand-123',
+ *   limit: 25
+ * });
+ * ```
+ *
+ * @example With search
+ * ```typescript
+ * const { contacts, loading } = useContacts({
+ *   brandId: 'brand-123',
+ *   search: 'john',
+ *   limit: 25
+ * });
+ * ```
+ *
+ * @example With GDPR and marketing filters
+ * ```typescript
+ * const { contacts, marketingContacts } = useContacts({
+ *   brandId: 'brand-123',
+ *   gdprConsent: true,
+ *   marketingOptIn: true
+ * });
+ * ```
+ *
+ * @example With computed properties
+ * ```typescript
+ * const { contacts, consentedContacts, marketingContacts } = useContacts({
+ *   brandId: 'brand-123'
+ * });
+ *
+ * // consentedContacts - contacts with GDPR consent
+ * // marketingContacts - contacts opted-in for marketing
+ * ```
+ *
+ * @example With tag filtering
+ * ```typescript
+ * const { contacts } = useContacts({
+ *   brandId: 'brand-123',
+ *   tags: ['vip', 'returning']
+ * });
+ * ```
+ */
+export function useContacts(options: UseContactsOptions = {}): UseContactsReturn {
+	const result = useContactsInternal(options);
+	return {
+		contacts: result.contacts as Ref<Contact[]>,
+		consentedContacts: result.consentedContacts as ComputedRef<Contact[]>,
+		marketingContacts: result.marketingContacts as ComputedRef<Contact[]>,
+		loading: result.loading,
+		error: result.error,
+		refetch: result.refetch,
+	};
+}

package/src/hooks/useReservations.ts

@@ -0,0 +1,145 @@
+/**
+ * useReservations Hook
+ *
+ * Vue composable for fetching and managing reservation data with reactive state.
+ * Provides loading states, error handling, pagination, and refetch capabilities.
+ */
+
+import type { Ref, ComputedRef } from "vue";
+import type { Reservation } from "../queries/reservations";
+import { createDataHook, type BaseHookOptions } from "./createDataHook";
+
+export interface UseReservationsOptions extends BaseHookOptions {
+	/** 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;
+	/** Pagination token for fetching next page */
+	nextToken?: string;
+}
+
+export interface UseReservationsReturn {
+	/** Reactive array of reservations */
+	reservations: Ref<Reservation[]>;
+	/** Computed array of confirmed reservations */
+	confirmedReservations: ComputedRef<Reservation[]>;
+	/** Computed array of active reservations (confirmed or checked_in) */
+	activeReservations: ComputedRef<Reservation[]>;
+	/** Loading state */
+	loading: Ref<boolean>;
+	/** Error state */
+	error: Ref<Error | null>;
+	/** Refetch reservations */
+	refetch: () => Promise<void>;
+}
+
+/**
+ * Build filter from hook options
+ */
+function buildFilter(options: UseReservationsOptions): 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) {
+		conditions.push(options.filter);
+	}
+
+	if (conditions.length === 0) {
+		return undefined;
+	}
+
+	if (conditions.length === 1) {
+		return conditions[0];
+	}
+
+	return { and: conditions };
+}
+
+/**
+ * Internal hook created by factory
+ */
+const useReservationsInternal = createDataHook<
+	Reservation,
+	UseReservationsOptions,
+	{ confirmedReservations: Reservation[]; activeReservations: Reservation[] }
+>({
+	model: "Reservation",
+	dataPropertyName: "reservations",
+	buildFilter,
+	computedProperties: {
+		confirmedReservations: (reservations) =>
+			reservations.filter((r) => r.status === "confirmed"),
+		activeReservations: (reservations) =>
+			reservations.filter((r) => r.status === "confirmed" || r.status === "checked_in"),
+	},
+});
+
+/**
+ * Composable for fetching and managing reservations
+ *
+ * @example
+ * ```typescript
+ * import { useReservations } from '@htlkg/data/hooks';
+ *
+ * const { reservations, loading, error, refetch } = useReservations({
+ *   brandId: 'brand-123',
+ *   startDate: '2026-01-01',
+ *   endDate: '2026-01-31',
+ *   status: 'confirmed'
+ * });
+ * ```
+ *
+ * @example With contact filter
+ * ```typescript
+ * const { reservations, loading } = useReservations({
+ *   contactId: 'contact-123',
+ *   limit: 50
+ * });
+ * ```
+ *
+ * @example With computed properties
+ * ```typescript
+ * const { reservations, activeReservations, confirmedReservations } = useReservations({
+ *   brandId: 'brand-123'
+ * });
+ *
+ * // activeReservations includes confirmed + checked_in
+ * // confirmedReservations includes only confirmed
+ * ```
+ */
+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[]>,
+		loading: result.loading,
+		error: result.error,
+		refetch: result.refetch,
+	};
+}