@htlkg/data 0.0.19 → 0.0.21

package/dist/hooks/index.d.ts

@@ -1,12 +1,8 @@
 import { Ref, ComputedRef } from 'vue';
-import { Brand, Account, User, Product, ProductInstance } from '@htlkg/core/types';
-import { b as CreateProductInstanceInput, e as UpdateProductInstanceInput } from '../productInstances-BA3cNsYc.js';
-export { resetSharedClient as resetClientInstance } from '../client/index.js';
-import 'aws-amplify/data';
-import 'aws-amplify';
-import '../server/index.js';
-import 'astro';
-import 'aws-amplify/api/internals';
+import { Brand, Account, User, Product, ProductInstance, Contact } from '@htlkg/core/types';
+import { C as CreateProductInstanceInput, U as UpdateProductInstanceInput } from '../productInstances-BpQv1oLS.js';
+import { R as Reservation } from '../reservations-C0FNm__0.js';
+import '../common-DSxswsZ3.js';
 
 /**
  * Data Hook Factory
@@ -62,7 +58,7 @@ interface DataHookReturn<T, TComputed extends Record<string, any> = Record<strin
         [K in keyof TComputed]: ComputedRef<TComputed[K]>;
     };
 }
-
+declare function resetClientInstance(): void;
 /**
  * Creates a reusable data hook for a specific model
  *
@@ -379,4 +375,160 @@ interface UseProductInstancesReturn {
  */
 declare function useProductInstances(options?: UseProductInstancesOptions): UseProductInstancesReturn;
 
-export { type BaseHookOptions, type CreateDataHookOptions, type DataHookReturn, type InferHookReturn, type UseAccountsOptions, type UseAccountsReturn, type UseBrandsOptions, type UseBrandsReturn, type UseProductInstancesOptions, type UseProductInstancesReturn, type UseProductsOptions, type UseProductsReturn, type UseUsersOptions, type UseUsersReturn, createDataHook, useAccounts, useBrands, useProductInstances, useProducts, useUsers };
+/**
+ * useReservations Hook
+ *
+ * Vue composable for fetching and managing reservation data with reactive state.
+ * Provides loading states, error handling, pagination, and refetch capabilities.
+ */
+
+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;
+}
+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>;
+}
+/**
+ * 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
+ * ```
+ */
+declare function useReservations(options?: UseReservationsOptions): UseReservationsReturn;
+
+/**
+ * useContacts Hook
+ *
+ * Vue composable for fetching and managing contact data with reactive state.
+ * Provides loading states, error handling, search, pagination, and refetch capabilities.
+ */
+
+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;
+}
+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>;
+}
+/**
+ * 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']
+ * });
+ * ```
+ */
+declare function useContacts(options?: UseContactsOptions): UseContactsReturn;
+
+export { type BaseHookOptions, type CreateDataHookOptions, type DataHookReturn, type InferHookReturn, type UseAccountsOptions, type UseAccountsReturn, type UseBrandsOptions, type UseBrandsReturn, type UseContactsOptions, type UseContactsReturn, type UseProductInstancesOptions, type UseProductInstancesReturn, type UseProductsOptions, type UseProductsReturn, type UseReservationsOptions, type UseReservationsReturn, type UseUsersOptions, type UseUsersReturn, createDataHook, resetClientInstance, useAccounts, useBrands, useContacts, useProductInstances, useProducts, useReservations, useUsers };

package/dist/hooks/index.js

@@ -1,38 +1,61 @@
 // src/hooks/createDataHook.ts
 import { ref, computed, onMounted } from "vue";
 
-// src/client/index.ts
-import { generateClient as generateDataClient } from "aws-amplify/data";
-import { Amplify } from "aws-amplify";
-
-// src/client/server.ts
-import {
-  generateClientWithAmplifyInstance
-} from "aws-amplify/api/internals";
-import { getAmplifyServerContext } from "aws-amplify/adapter-core/internals";
-import { createRunWithAmplifyServerContext, createLogger } from "@htlkg/core/amplify-astro-adapter";
-var log = createLogger("server-client");
-
-// src/client/index.ts
-var sharedClientInstance = null;
-function getSharedClient() {
-  if (!sharedClientInstance) {
-    sharedClientInstance = generateDataClient();
+// src/client/proxy.ts
+var DEFAULT_ENDPOINT = "/api/graphql";
+async function query(model, operation, data, options) {
+  return proxyRequest(model, operation, data, options);
+}
+async function proxyRequest(model, operation, data, options) {
+  const endpoint = options?.endpoint ?? DEFAULT_ENDPOINT;
+  try {
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      credentials: "include",
+      // Important: include cookies
+      ...options?.fetchOptions,
+      body: JSON.stringify({ model, operation, data })
+    });
+    const result = await response.json();
+    if (response.status === 401) {
+      console.error("[GraphQL Proxy] Unauthorized - session may have expired");
+    }
+    return result;
+  } catch (error) {
+    console.error("[GraphQL Proxy] Request failed:", error);
+    return {
+      data: null,
+      errors: [
+        {
+          message: error instanceof Error ? error.message : "Network error"
+        }
+      ]
+    };
   }
-  return sharedClientInstance;
 }
-function resetSharedClient() {
-  sharedClientInstance = null;
+function hasErrors(response) {
+  return !!response.errors && response.errors.length > 0;
+}
+function getErrorMessage(response) {
+  if (!response.errors || response.errors.length === 0) {
+    return null;
+  }
+  return response.errors[0].message;
 }
 
 // src/hooks/createDataHook.ts
+function resetClientInstance() {
+}
 function createDataHook(config) {
   const {
     model,
     defaultLimit,
     selectionSet,
     transform,
-    buildFilter: buildFilter5,
+    buildFilter: buildFilter7,
     computedProperties,
     dataPropertyName = "data"
   } = config;
@@ -42,8 +65,8 @@ function createDataHook(config) {
     const loading = ref(false);
     const error = ref(null);
     const getFilter = () => {
-      if (buildFilter5) {
-        return buildFilter5(options);
+      if (buildFilter7) {
+        return buildFilter7(options);
       }
       return baseFilter && Object.keys(baseFilter).length > 0 ? baseFilter : void 0;
     };
@@ -51,19 +74,22 @@ function createDataHook(config) {
       loading.value = true;
       error.value = null;
       try {
-        const client = getSharedClient();
-        const queryOptions = {
-          filter: getFilter(),
-          limit
-        };
+        const queryOptions = {};
+        const filter = getFilter();
+        if (filter) {
+          queryOptions.filter = filter;
+        }
+        if (limit) {
+          queryOptions.limit = limit;
+        }
         if (selectionSet) {
           queryOptions.selectionSet = selectionSet;
         }
-        const { data: responseData, errors } = await client.models[model].list(queryOptions);
-        if (errors) {
-          throw new Error(errors[0]?.message || `Failed to fetch ${model}`);
+        const response = await query(model, "list", queryOptions);
+        if (hasErrors(response)) {
+          throw new Error(getErrorMessage(response) || `Failed to fetch ${model}`);
         }
-        const items = responseData || [];
+        const items = response.data || [];
         data.value = transform ? items.map(transform) : items;
       } catch (e) {
         error.value = e;
@@ -198,6 +224,27 @@ function useProducts(options = {}) {
   };
 }
 
+// src/client/index.ts
+import { generateClient as generateDataClient } from "aws-amplify/data";
+import { Amplify } from "aws-amplify";
+
+// src/client/server.ts
+import {
+  generateClientWithAmplifyInstance
+} from "aws-amplify/api/internals";
+import { getAmplifyServerContext } from "aws-amplify/adapter-core/internals";
+import { createRunWithAmplifyServerContext, createLogger } from "@htlkg/core/amplify-astro-adapter";
+var log = createLogger("server-client");
+
+// src/client/index.ts
+var sharedClientInstance = null;
+function getSharedClient() {
+  if (!sharedClientInstance) {
+    sharedClientInstance = generateDataClient();
+  }
+  return sharedClientInstance;
+}
+
 // src/mutations/productInstances/productInstances.ts
 import { getClientUser } from "@htlkg/core/auth";
 import { getCurrentTimestamp } from "@htlkg/core/utils";
@@ -417,13 +464,124 @@ function useProductInstances(options = {}) {
     toggleEnabled
   };
 }
+
+// src/hooks/useReservations.ts
+function buildFilter5(options) {
+  const conditions = [];
+  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 void 0;
+  }
+  if (conditions.length === 1) {
+    return conditions[0];
+  }
+  return { and: conditions };
+}
+var useReservationsInternal = createDataHook({
+  model: "Reservation",
+  dataPropertyName: "reservations",
+  buildFilter: buildFilter5,
+  computedProperties: {
+    confirmedReservations: (reservations) => reservations.filter((r) => r.status === "confirmed"),
+    activeReservations: (reservations) => reservations.filter((r) => r.status === "confirmed" || r.status === "checked_in")
+  }
+});
+function useReservations(options = {}) {
+  const result = useReservationsInternal(options);
+  return {
+    reservations: result.reservations,
+    confirmedReservations: result.confirmedReservations,
+    activeReservations: result.activeReservations,
+    loading: result.loading,
+    error: result.error,
+    refetch: result.refetch
+  };
+}
+
+// src/hooks/useContacts.ts
+function buildFilter6(options) {
+  const conditions = [];
+  if (options.brandId) {
+    conditions.push({ brandId: { eq: options.brandId } });
+  }
+  if (options.search) {
+    conditions.push({
+      or: [
+        { email: { contains: options.search } },
+        { firstName: { contains: options.search } },
+        { lastName: { contains: options.search } }
+      ]
+    });
+  }
+  if (options.gdprConsent !== void 0) {
+    conditions.push({ gdprConsent: { eq: options.gdprConsent } });
+  }
+  if (options.marketingOptIn !== void 0) {
+    conditions.push({ marketingOptIn: { eq: options.marketingOptIn } });
+  }
+  if (options.tags && options.tags.length > 0) {
+    const tagConditions = options.tags.map((tag) => ({
+      tags: { contains: tag }
+    }));
+    conditions.push({ or: tagConditions });
+  }
+  if (options.filter) {
+    conditions.push(options.filter);
+  }
+  if (conditions.length === 0) {
+    return void 0;
+  }
+  if (conditions.length === 1) {
+    return conditions[0];
+  }
+  return { and: conditions };
+}
+var useContactsInternal = createDataHook({
+  model: "Contact",
+  dataPropertyName: "contacts",
+  buildFilter: buildFilter6,
+  computedProperties: {
+    consentedContacts: (contacts) => contacts.filter((c) => c.gdprConsent === true),
+    marketingContacts: (contacts) => contacts.filter((c) => c.marketingOptIn === true)
+  }
+});
+function useContacts(options = {}) {
+  const result = useContactsInternal(options);
+  return {
+    contacts: result.contacts,
+    consentedContacts: result.consentedContacts,
+    marketingContacts: result.marketingContacts,
+    loading: result.loading,
+    error: result.error,
+    refetch: result.refetch
+  };
+}
 export {
   createDataHook,
-  resetSharedClient as resetClientInstance,
+  resetClientInstance,
   useAccounts,
   useBrands,
+  useContacts,
   useProductInstances,
   useProducts,
+  useReservations,
   useUsers
 };
 //# sourceMappingURL=index.js.map