@htlkg/data 0.0.20 → 0.0.21

package/dist/index.js

@@ -563,6 +563,109 @@ async function getReservationByConfirmation(client, confirmationCode, brandId) {
   }
 }
 
+// src/queries/contacts.ts
+async function getContact(client, id) {
+  try {
+    const { data, errors } = await client.models.Contact.get({ id });
+    if (errors) {
+      console.error("[getContact] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[getContact] Error fetching contact:", error);
+    throw error;
+  }
+}
+async function listContacts(client, options) {
+  try {
+    const { data, errors, nextToken } = await client.models.Contact.list(options);
+    if (errors) {
+      console.error("[listContacts] GraphQL errors:", errors);
+      return { items: [], nextToken: void 0 };
+    }
+    return {
+      items: data || [],
+      nextToken
+    };
+  } catch (error) {
+    console.error("[listContacts] Error fetching contacts:", error);
+    throw error;
+  }
+}
+async function listContactsByBrand(client, brandId, options) {
+  return listContacts(client, {
+    filter: { brandId: { eq: brandId } },
+    ...options
+  });
+}
+async function getContactByEmail(client, email, brandId) {
+  try {
+    const { data, errors } = await client.models.Contact.list({
+      filter: {
+        and: [{ email: { eq: email } }, { brandId: { eq: brandId } }]
+      },
+      limit: 1
+    });
+    if (errors) {
+      console.error("[getContactByEmail] GraphQL errors:", errors);
+      return null;
+    }
+    return data?.[0];
+  } catch (error) {
+    console.error("[getContactByEmail] Error fetching contact:", error);
+    throw error;
+  }
+}
+async function getContactByPhone(client, phone, brandId) {
+  try {
+    const { data, errors } = await client.models.Contact.list({
+      filter: {
+        and: [{ phone: { eq: phone } }, { brandId: { eq: brandId } }]
+      },
+      limit: 1
+    });
+    if (errors) {
+      console.error("[getContactByPhone] GraphQL errors:", errors);
+      return null;
+    }
+    return data?.[0];
+  } catch (error) {
+    console.error("[getContactByPhone] Error fetching contact:", error);
+    throw error;
+  }
+}
+async function searchContacts(client, query2, brandId, options) {
+  try {
+    const { data, errors, nextToken } = await client.models.Contact.list({
+      filter: {
+        and: [
+          { brandId: { eq: brandId } },
+          {
+            or: [
+              { email: { contains: query2 } },
+              { firstName: { contains: query2 } },
+              { lastName: { contains: query2 } }
+            ]
+          }
+        ]
+      },
+      ...options
+    });
+    if (errors) {
+      console.error("[searchContacts] GraphQL errors:", errors);
+      return { items: [], nextToken: void 0 };
+    }
+    return {
+      items: data || [],
+      nextToken
+    };
+  } catch (error) {
+    console.error("[searchContacts] Error searching contacts:", error);
+    throw error;
+  }
+}
+
 // src/mutations/brands.ts
 async function createBrand(client, input) {
   try {
@@ -1234,6 +1337,265 @@ async function updateReservationStatus2(client, id, newStatus) {
   }
 }
 
+// src/mutations/contacts.ts
+import { z } from "zod";
+var createContactSchema = z.object({
+  brandId: z.string().min(1, "Brand ID is required"),
+  email: z.string().email("Invalid email address"),
+  phone: z.string().optional(),
+  firstName: z.string().min(1, "First name is required"),
+  lastName: z.string().min(1, "Last name is required"),
+  locale: z.string().optional(),
+  gdprConsent: z.boolean(),
+  gdprConsentDate: z.string().optional(),
+  marketingOptIn: z.boolean().optional(),
+  preferences: z.record(z.any()).optional(),
+  tags: z.array(z.string()).optional(),
+  totalVisits: z.number().int().min(0).optional(),
+  lastVisitDate: z.string().optional(),
+  firstVisitDate: z.string().optional(),
+  legacyId: z.string().optional(),
+  // Audit fields
+  createdAt: z.string().optional(),
+  createdBy: z.string().optional(),
+  updatedAt: z.string().optional(),
+  updatedBy: z.string().optional()
+});
+var updateContactSchema = z.object({
+  id: z.string().min(1, "Contact ID is required"),
+  brandId: z.string().min(1).optional(),
+  email: z.string().email("Invalid email address").optional(),
+  phone: z.string().optional(),
+  firstName: z.string().min(1).optional(),
+  lastName: z.string().min(1).optional(),
+  locale: z.string().optional(),
+  gdprConsent: z.boolean().optional(),
+  gdprConsentDate: z.string().optional(),
+  marketingOptIn: z.boolean().optional(),
+  preferences: z.record(z.any()).optional(),
+  tags: z.array(z.string()).optional(),
+  totalVisits: z.number().int().min(0).optional(),
+  lastVisitDate: z.string().optional(),
+  firstVisitDate: z.string().optional(),
+  legacyId: z.string().optional(),
+  // Audit fields
+  updatedAt: z.string().optional(),
+  updatedBy: z.string().optional(),
+  deletedAt: z.string().nullable().optional(),
+  deletedBy: z.string().nullable().optional()
+});
+var mergeContactsSchema = z.object({
+  primaryId: z.string().min(1, "Primary contact ID is required"),
+  duplicateIds: z.array(z.string().min(1)).min(1, "At least one duplicate ID is required")
+});
+var ContactValidationError = class extends Error {
+  issues;
+  constructor(message, issues = []) {
+    super(message);
+    this.name = "ContactValidationError";
+    this.issues = issues;
+  }
+};
+async function createContact(client, input) {
+  try {
+    const validationResult = createContactSchema.safeParse(input);
+    if (!validationResult.success) {
+      const errorMessage = validationResult.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
+      throw new ContactValidationError(
+        `Validation failed: ${errorMessage}`,
+        validationResult.error.issues
+      );
+    }
+    const { data, errors } = await client.models.Contact.create(input);
+    if (errors) {
+      console.error("[createContact] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof ContactValidationError) {
+      console.error("[createContact] Validation error:", error.message);
+      throw error;
+    }
+    console.error("[createContact] Error creating contact:", error);
+    throw error;
+  }
+}
+async function updateContact(client, input) {
+  try {
+    const validationResult = updateContactSchema.safeParse(input);
+    if (!validationResult.success) {
+      const errorMessage = validationResult.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
+      throw new ContactValidationError(
+        `Validation failed: ${errorMessage}`,
+        validationResult.error.issues
+      );
+    }
+    const { data, errors } = await client.models.Contact.update(input);
+    if (errors) {
+      console.error("[updateContact] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof ContactValidationError) {
+      console.error("[updateContact] Validation error:", error.message);
+      throw error;
+    }
+    console.error("[updateContact] Error updating contact:", error);
+    throw error;
+  }
+}
+async function softDeleteContact(client, id, deletedBy) {
+  try {
+    const { errors } = await client.models.Contact.update({
+      id,
+      deletedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      deletedBy
+    });
+    if (errors) {
+      console.error("[softDeleteContact] GraphQL errors:", errors);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error("[softDeleteContact] Error soft-deleting contact:", error);
+    throw error;
+  }
+}
+async function restoreContact(client, id, retentionDays = DEFAULT_SOFT_DELETE_RETENTION_DAYS) {
+  try {
+    const contact = await getContact(client, id);
+    if (!contact) {
+      console.error("[restoreContact] Contact not found");
+      return { success: false, error: "Contact not found" };
+    }
+    const eligibility = checkRestoreEligibility(
+      contact.deletedAt,
+      retentionDays
+    );
+    if (!eligibility.canRestore) {
+      const errorMsg = `Cannot restore contact. Retention period of ${retentionDays} days has expired. Item was deleted ${eligibility.daysExpired} days ago.`;
+      console.error("[restoreContact]", errorMsg);
+      return { success: false, error: errorMsg };
+    }
+    const { errors } = await client.models.Contact.update({
+      id,
+      deletedAt: null,
+      deletedBy: null
+    });
+    if (errors) {
+      console.error("[restoreContact] GraphQL errors:", errors);
+      return { success: false, error: "Failed to restore contact" };
+    }
+    return { success: true };
+  } catch (error) {
+    console.error("[restoreContact] Error restoring contact:", error);
+    throw error;
+  }
+}
+async function deleteContact(client, id) {
+  try {
+    const { errors } = await client.models.Contact.delete({ id });
+    if (errors) {
+      console.error("[deleteContact] GraphQL errors:", errors);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error("[deleteContact] Error deleting contact:", error);
+    throw error;
+  }
+}
+async function mergeContacts(client, input, mergedBy) {
+  try {
+    const validationResult = mergeContactsSchema.safeParse(input);
+    if (!validationResult.success) {
+      const errorMessage = validationResult.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
+      throw new ContactValidationError(
+        `Validation failed: ${errorMessage}`,
+        validationResult.error.issues
+      );
+    }
+    const { primaryId, duplicateIds } = input;
+    const primaryContact = await getContact(client, primaryId);
+    if (!primaryContact) {
+      return {
+        success: false,
+        error: `Primary contact not found: ${primaryId}`
+      };
+    }
+    const duplicateContacts = [];
+    for (const duplicateId of duplicateIds) {
+      const duplicate = await getContact(client, duplicateId);
+      if (!duplicate) {
+        return {
+          success: false,
+          error: `Duplicate contact not found: ${duplicateId}`
+        };
+      }
+      duplicateContacts.push(duplicate);
+    }
+    let totalVisits = primaryContact.totalVisits || 0;
+    let firstVisitDate = primaryContact.firstVisitDate;
+    let lastVisitDate = primaryContact.lastVisitDate;
+    const allTags = new Set(primaryContact.tags || []);
+    for (const duplicate of duplicateContacts) {
+      totalVisits += duplicate.totalVisits || 0;
+      if (duplicate.firstVisitDate) {
+        if (!firstVisitDate || duplicate.firstVisitDate < firstVisitDate) {
+          firstVisitDate = duplicate.firstVisitDate;
+        }
+      }
+      if (duplicate.lastVisitDate) {
+        if (!lastVisitDate || duplicate.lastVisitDate > lastVisitDate) {
+          lastVisitDate = duplicate.lastVisitDate;
+        }
+      }
+      if (duplicate.tags) {
+        duplicate.tags.forEach((tag) => allTags.add(tag));
+      }
+    }
+    const updateInput = {
+      id: primaryId,
+      totalVisits,
+      firstVisitDate,
+      lastVisitDate,
+      tags: Array.from(allTags),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedBy: mergedBy
+    };
+    const updatedPrimary = await updateContact(client, updateInput);
+    if (!updatedPrimary) {
+      return {
+        success: false,
+        error: "Failed to update primary contact with merged data"
+      };
+    }
+    const deletedIds = [];
+    for (const duplicateId of duplicateIds) {
+      const deleted = await softDeleteContact(client, duplicateId, mergedBy);
+      if (deleted) {
+        deletedIds.push(duplicateId);
+      } else {
+        console.error(`[mergeContacts] Failed to soft-delete duplicate: ${duplicateId}`);
+      }
+    }
+    return {
+      success: true,
+      mergedContact: updatedPrimary,
+      deletedIds
+    };
+  } catch (error) {
+    if (error instanceof ContactValidationError) {
+      console.error("[mergeContacts] Validation error:", error.message);
+      throw error;
+    }
+    console.error("[mergeContacts] Error merging contacts:", error);
+    throw error;
+  }
+}
+
 // src/hooks/createDataHook.ts
 import { ref, computed, onMounted } from "vue";
 function resetClientInstance() {
@@ -1244,7 +1606,7 @@ function createDataHook(config) {
     defaultLimit,
     selectionSet,
     transform,
-    buildFilter: buildFilter6,
+    buildFilter: buildFilter7,
     computedProperties,
     dataPropertyName = "data"
   } = config;
@@ -1254,8 +1616,8 @@ function createDataHook(config) {
     const loading = ref(false);
     const error = ref(null);
     const getFilter = () => {
-      if (buildFilter6) {
-        return buildFilter6(options);
+      if (buildFilter7) {
+        return buildFilter7(options);
       }
       return baseFilter && Object.keys(baseFilter).length > 0 ? baseFilter : void 0;
     };
@@ -1531,6 +1893,65 @@ function useReservations(options = {}) {
   };
 }
 
+// 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
+  };
+}
+
 // ../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/clean-stores/index.js
 var clean = /* @__PURE__ */ Symbol("clean");
 
@@ -1634,12 +2055,15 @@ function createSingleStore(shared, name, defaultValue) {
   return shared(name, atom(defaultValue));
 }
 export {
+  ContactValidationError,
   DEFAULT_SOFT_DELETE_RETENTION_DAYS,
   ReservationValidationError,
   SYSTEM_SETTINGS_KEY,
   checkRestoreEligibility,
   createAccount,
   createBrand,
+  createContact,
+  createContactSchema,
   createDataHook,
   createProductInstance,
   createReservation2 as createReservation,
@@ -1649,6 +2073,7 @@ export {
   createUser,
   deleteAccount,
   deleteBrand,
+  deleteContact,
   deleteProductInstance,
   deleteReservation2 as deleteReservation,
   deleteUser,
@@ -1660,6 +2085,9 @@ export {
   getAccountWithBrands,
   getBrand,
   getBrandWithProducts,
+  getContact,
+  getContactByEmail,
+  getContactByPhone,
   getErrorMessage,
   getProduct,
   getProductInstance,
@@ -1679,6 +2107,8 @@ export {
   listActiveUsers,
   listBrands,
   listBrandsByAccount,
+  listContacts,
+  listContactsByBrand,
   listEnabledProductInstancesByBrand,
   listProductInstancesByAccount,
   listProductInstancesByBrand,
@@ -1689,21 +2119,28 @@ export {
   listReservationsByDateRange,
   listUsers,
   listUsersByAccount,
+  mergeContacts,
+  mergeContactsSchema,
   mutate,
   query,
   resetClientInstance,
   resetSharedClient,
   restoreAccount,
   restoreBrand,
+  restoreContact,
   restoreReservation2 as restoreReservation,
   restoreUser,
+  searchContacts,
   softDeleteAccount,
   softDeleteBrand,
+  softDeleteContact,
   softDeleteReservation2 as softDeleteReservation,
   softDeleteUser,
   toggleProductInstanceEnabled,
   updateAccount,
   updateBrand,
+  updateContact,
+  updateContactSchema,
   updateProductInstance,
   updateReservation2 as updateReservation,
   updateReservationStatus2 as updateReservationStatus,
@@ -1711,6 +2148,7 @@ export {
   updateUser,
   useAccounts,
   useBrands,
+  useContacts,
   useProductInstances,
   useProducts,
   useReservations,