@htlkg/data 0.0.18 → 0.0.20

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,
+	};
+}

package/src/mutations/accounts.ts

@@ -9,26 +9,29 @@ import {
 	checkRestoreEligibility,
 	DEFAULT_SOFT_DELETE_RETENTION_DAYS,
 } from "../queries/systemSettings";
+import type { CreateAuditFields, UpdateWithSoftDeleteFields } from "./common";
 
 /**
  * Input type for creating an account
  */
-export interface CreateAccountInput {
+export interface CreateAccountInput extends CreateAuditFields {
 	name: string;
 	logo?: string;
 	subscription?: Record<string, any>;
 	settings?: Record<string, any>;
+	status?: "active" | "inactive" | "deleted";
 }
 
 /**
  * Input type for updating an account
  */
-export interface UpdateAccountInput {
+export interface UpdateAccountInput extends UpdateWithSoftDeleteFields {
 	id: string;
 	name?: string;
 	logo?: string;
 	subscription?: Record<string, any>;
 	settings?: Record<string, any>;
+	status?: "active" | "inactive" | "deleted";
 }
 
 /**

package/src/mutations/brands.ts

@@ -9,28 +9,29 @@ import {
 	checkRestoreEligibility,
 	DEFAULT_SOFT_DELETE_RETENTION_DAYS,
 } from "../queries/systemSettings";
+import type { CreateAuditFields, UpdateWithSoftDeleteFields } from "./common";
 
 /**
  * Input type for creating a brand
  */
-export interface CreateBrandInput {
+export interface CreateBrandInput extends CreateAuditFields {
 	accountId: string;
 	name: string;
 	logo?: string;
 	timezone?: string;
-	status?: "active" | "inactive" | "maintenance" | "suspended";
+	status?: "active" | "inactive" | "maintenance" | "suspended" | "deleted";
 	settings?: Record<string, any>;
 }
 
 /**
  * Input type for updating a brand
  */
-export interface UpdateBrandInput {
+export interface UpdateBrandInput extends UpdateWithSoftDeleteFields {
 	id: string;
 	name?: string;
 	logo?: string;
 	timezone?: string;
-	status?: "active" | "inactive" | "maintenance" | "suspended";
+	status?: "active" | "inactive" | "maintenance" | "suspended" | "deleted";
 	settings?: Record<string, any>;
 }
 

package/src/mutations/common.ts

@@ -0,0 +1,41 @@
+/**
+ * Common Mutation Input Base Types
+ *
+ * Provides reusable base interfaces for audit fields to avoid duplication
+ * across all mutation input types.
+ */
+
+/**
+ * Audit fields for creation operations
+ * Includes timestamps and user tracking
+ */
+export interface CreateAuditFields {
+	createdAt?: string;
+	createdBy?: string;
+	updatedAt?: string;
+	updatedBy?: string;
+}
+
+/**
+ * Audit fields for update operations
+ * Includes timestamps and user tracking
+ */
+export interface UpdateAuditFields {
+	updatedAt?: string;
+	updatedBy?: string;
+}
+
+/**
+ * Soft delete fields for entities that support soft deletion
+ * Tracks when and by whom an entity was deleted
+ */
+export interface SoftDeleteFields {
+	deletedAt?: string | null;
+	deletedBy?: string | null;
+}
+
+/**
+ * Complete audit trail for entities with soft delete support
+ * Combines update and soft delete fields
+ */
+export interface UpdateWithSoftDeleteFields extends UpdateAuditFields, SoftDeleteFields {}

package/src/mutations/index.ts

@@ -4,6 +4,14 @@
  * Provides mutation functions for creating, updating, and deleting data via the GraphQL API.
  */
 
+// Common base types
+export type {
+	CreateAuditFields,
+	UpdateAuditFields,
+	SoftDeleteFields,
+	UpdateWithSoftDeleteFields,
+} from "./common";
+
 // Brand mutations
 export {
 	createBrand,
@@ -53,3 +61,17 @@ export {
 	initializeSystemSettings,
 	type UpdateSystemSettingsInput,
 } from "./systemSettings";
+
+// Reservation mutations
+export {
+	createReservation,
+	updateReservation,
+	deleteReservation,
+	softDeleteReservation,
+	restoreReservation,
+	updateReservationStatus,
+	ReservationValidationError,
+	type CreateReservationInput,
+	type UpdateReservationInput,
+	type ReservationStatus,
+} from "./reservations";

package/src/mutations/productInstances/productInstances.test.ts

@@ -132,7 +132,7 @@ describe('ProductInstance Mutations', () => {
 					accountId: 'account-789',
 					enabled: true,
 					version: '1.0.0',
-					lastUpdated: mockTimestamp,
+					updatedAt: mockTimestamp,
 					updatedBy: mockUserId,
 				})
 			);
@@ -183,7 +183,7 @@ describe('ProductInstance Mutations', () => {
 			await createProductInstance(mockClient, validInput);
 
 			const callArgs = mockCreate.mock.calls[0][0];
-			expect(callArgs.lastUpdated).toBe(mockTimestamp);
+			expect(callArgs.updatedAt).toBe(mockTimestamp);
 		});
 
 		it('should use provided updatedBy if specified', async () => {
@@ -358,7 +358,7 @@ describe('ProductInstance Mutations', () => {
 			await updateProductInstance(mockClient, validInput);
 
 			const callArgs = mockUpdate.mock.calls[0][0];
-			expect(callArgs.lastUpdated).toBe(mockTimestamp);
+			expect(callArgs.updatedAt).toBe(mockTimestamp);
 			expect(callArgs.updatedBy).toBe(mockUserId);
 		});
 

package/src/mutations/productInstances/productInstances.ts

@@ -9,6 +9,7 @@ import type { ProductInstance } from "@htlkg/core/types";
 import { getClientUser } from "@htlkg/core/auth";
 import { getCurrentTimestamp } from "@htlkg/core/utils";
 import { AppError } from "@htlkg/core/errors";
+import type { CreateAuditFields, UpdateAuditFields } from "../common";
 
 /**
  * Get current user identifier for audit trails
@@ -29,7 +30,7 @@ async function getUserIdentifier(fallback = "system"): Promise<string> {
 /**
  * Input type for creating a product instance
  */
-export interface CreateProductInstanceInput {
+export interface CreateProductInstanceInput extends CreateAuditFields {
 	productId: string;
 	brandId: string;
 	accountId: string;
@@ -37,21 +38,16 @@ export interface CreateProductInstanceInput {
 	enabled: boolean;
 	config?: Record<string, any>;
 	version?: string;
-	createdBy?: string;
-	lastUpdated?: string;
-	updatedBy?: string;
 }
 
 /**
  * Input type for updating a product instance
  */
-export interface UpdateProductInstanceInput {
+export interface UpdateProductInstanceInput extends UpdateAuditFields {
 	id: string;
 	enabled?: boolean;
 	config?: Record<string, any>;
 	version?: string;
-	lastUpdated?: string;
-	updatedBy?: string;
 }
 
 /**
@@ -81,6 +77,7 @@ export async function createProductInstance<TClient = any>(
 		const userIdentifier = input.createdBy || input.updatedBy || await getUserIdentifier();
 
 		// Build input - manually construct to avoid Vue Proxy issues
+		const timestamp = input.createdAt || getCurrentTimestamp();
 		const createInput: any = {
 			productId: input.productId,
 			productName: input.productName,
@@ -88,8 +85,9 @@ export async function createProductInstance<TClient = any>(
 			accountId: input.accountId,
 			enabled: input.enabled,
 			version: input.version,
+			createdAt: timestamp,
 			createdBy: userIdentifier,
-			lastUpdated: input.lastUpdated || getCurrentTimestamp(),
+			updatedAt: input.updatedAt || timestamp,
 			updatedBy: userIdentifier,
 		};
 
@@ -154,7 +152,7 @@ export async function updateProductInstance<TClient = any>(
 		// Convert config from Vue Proxy to plain object
 		const updateInput: any = {
 			...input,
-			lastUpdated: input.lastUpdated || getCurrentTimestamp(),
+			updatedAt: input.updatedAt || getCurrentTimestamp(),
 			updatedBy: input.updatedBy || await getUserIdentifier(),
 		};