@htlkg/data 0.0.19 → 0.0.21

package/dist/mutations/index.js

@@ -509,26 +509,512 @@ async function initializeSystemSettings(client, initializedBy) {
     throw error;
   }
 }
+
+// src/mutations/reservations.ts
+var STATUS_TRANSITIONS = {
+  confirmed: ["checked_in", "cancelled", "no_show"],
+  checked_in: ["checked_out", "cancelled"],
+  checked_out: [],
+  // Terminal state - no transitions allowed
+  cancelled: [],
+  // Terminal state - no transitions allowed
+  no_show: []
+  // Terminal state - no transitions allowed
+};
+var ReservationValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ReservationValidationError";
+  }
+};
+function validateDates(checkIn, checkOut) {
+  const checkInDate = new Date(checkIn);
+  const checkOutDate = new Date(checkOut);
+  if (isNaN(checkInDate.getTime())) {
+    throw new ReservationValidationError("Invalid check-in date");
+  }
+  if (isNaN(checkOutDate.getTime())) {
+    throw new ReservationValidationError("Invalid check-out date");
+  }
+  if (checkOutDate <= checkInDate) {
+    throw new ReservationValidationError(
+      "Check-out date must be after check-in date"
+    );
+  }
+  const minStayHours = 4;
+  const stayDuration = checkOutDate.getTime() - checkInDate.getTime();
+  const hoursDiff = stayDuration / (1e3 * 60 * 60);
+  if (hoursDiff < minStayHours) {
+    throw new ReservationValidationError(
+      `Minimum stay is ${minStayHours} hours`
+    );
+  }
+}
+function validateStatusTransition(currentStatus, newStatus) {
+  const allowedTransitions = STATUS_TRANSITIONS[currentStatus];
+  if (!allowedTransitions.includes(newStatus)) {
+    throw new ReservationValidationError(
+      `Invalid status transition from '${currentStatus}' to '${newStatus}'. Allowed transitions: ${allowedTransitions.length > 0 ? allowedTransitions.join(", ") : "none (terminal state)"}`
+    );
+  }
+}
+async function createReservation(client, input) {
+  try {
+    validateDates(input.checkIn, input.checkOut);
+    if (!input.nights) {
+      const checkInDate = new Date(input.checkIn);
+      const checkOutDate = new Date(input.checkOut);
+      const diffTime = checkOutDate.getTime() - checkInDate.getTime();
+      const diffDays = Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
+      input.nights = diffDays;
+    }
+    const { data, errors } = await client.models.Reservation.create(input);
+    if (errors) {
+      console.error("[createReservation] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof ReservationValidationError) {
+      console.error("[createReservation] Validation error:", error.message);
+      throw error;
+    }
+    console.error("[createReservation] Error creating reservation:", error);
+    throw error;
+  }
+}
+async function updateReservation(client, input) {
+  try {
+    if (input.checkIn && input.checkOut) {
+      validateDates(input.checkIn, input.checkOut);
+      const checkInDate = new Date(input.checkIn);
+      const checkOutDate = new Date(input.checkOut);
+      const diffTime = checkOutDate.getTime() - checkInDate.getTime();
+      const diffDays = Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
+      input.nights = diffDays;
+    }
+    if (input.status) {
+      const { data: currentReservation, errors: getErrors } = await client.models.Reservation.get({ id: input.id });
+      if (getErrors || !currentReservation) {
+        console.error("[updateReservation] Error fetching current reservation:", getErrors);
+        return null;
+      }
+      const currentStatus = currentReservation.status;
+      validateStatusTransition(currentStatus, input.status);
+    }
+    const { data, errors } = await client.models.Reservation.update(input);
+    if (errors) {
+      console.error("[updateReservation] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof ReservationValidationError) {
+      console.error("[updateReservation] Validation error:", error.message);
+      throw error;
+    }
+    console.error("[updateReservation] Error updating reservation:", error);
+    throw error;
+  }
+}
+async function softDeleteReservation(client, id, deletedBy) {
+  try {
+    const { errors } = await client.models.Reservation.update({
+      id,
+      deletedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      deletedBy
+    });
+    if (errors) {
+      console.error("[softDeleteReservation] GraphQL errors:", errors);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error("[softDeleteReservation] Error soft-deleting reservation:", error);
+    throw error;
+  }
+}
+async function restoreReservation(client, id, retentionDays = DEFAULT_SOFT_DELETE_RETENTION_DAYS) {
+  try {
+    const { data: reservation, errors: getErrors } = await client.models.Reservation.get({ id });
+    if (getErrors || !reservation) {
+      console.error("[restoreReservation] Error fetching reservation:", getErrors);
+      return { success: false, error: "Reservation not found" };
+    }
+    const eligibility = checkRestoreEligibility(reservation.deletedAt, retentionDays);
+    if (!eligibility.canRestore) {
+      const errorMsg = `Cannot restore reservation. Retention period of ${retentionDays} days has expired. Item was deleted ${eligibility.daysExpired} days ago.`;
+      console.error("[restoreReservation]", errorMsg);
+      return { success: false, error: errorMsg };
+    }
+    const { errors } = await client.models.Reservation.update({
+      id,
+      deletedAt: null,
+      deletedBy: null
+    });
+    if (errors) {
+      console.error("[restoreReservation] GraphQL errors:", errors);
+      return { success: false, error: "Failed to restore reservation" };
+    }
+    return { success: true };
+  } catch (error) {
+    console.error("[restoreReservation] Error restoring reservation:", error);
+    throw error;
+  }
+}
+async function deleteReservation(client, id) {
+  try {
+    const { errors } = await client.models.Reservation.delete({ id });
+    if (errors) {
+      console.error("[deleteReservation] GraphQL errors:", errors);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error("[deleteReservation] Error deleting reservation:", error);
+    throw error;
+  }
+}
+async function updateReservationStatus(client, id, newStatus) {
+  try {
+    const { data: currentReservation, errors: getErrors } = await client.models.Reservation.get({ id });
+    if (getErrors || !currentReservation) {
+      console.error("[updateReservationStatus] Error fetching reservation:", getErrors);
+      return null;
+    }
+    const currentStatus = currentReservation.status;
+    validateStatusTransition(currentStatus, newStatus);
+    const { data, errors } = await client.models.Reservation.update({
+      id,
+      status: newStatus
+    });
+    if (errors) {
+      console.error("[updateReservationStatus] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof ReservationValidationError) {
+      console.error("[updateReservationStatus] Validation error:", error.message);
+      throw error;
+    }
+    console.error("[updateReservationStatus] Error updating status:", error);
+    throw error;
+  }
+}
+
+// src/mutations/contacts.ts
+import { z } from "zod";
+
+// 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;
+  }
+}
+
+// src/mutations/contacts.ts
+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;
+  }
+}
 export {
+  ContactValidationError,
+  ReservationValidationError,
   createAccount,
   createBrand,
+  createContact,
+  createContactSchema,
   createProductInstance,
+  createReservation,
   createUser,
   deleteAccount,
   deleteBrand,
+  deleteContact,
   deleteProductInstance,
+  deleteReservation,
   deleteUser,
   initializeSystemSettings,
+  mergeContacts,
+  mergeContactsSchema,
   restoreAccount,
   restoreBrand,
+  restoreContact,
+  restoreReservation,
   restoreUser,
   softDeleteAccount,
   softDeleteBrand,
+  softDeleteContact,
+  softDeleteReservation,
   softDeleteUser,
   toggleProductInstanceEnabled,
   updateAccount,
   updateBrand,
+  updateContact,
+  updateContactSchema,
   updateProductInstance,
+  updateReservation,
+  updateReservationStatus,
   updateSystemSettings,
   updateUser
 };