12336 updating to include some gmail email sync error handling

Author: mdvertola

packages/twenty-server/src/modules/messaging/message-import-manager/drivers/gmail/utils/parse-gmail-message.util.ts

@@ -7,6 +7,20 @@ import { getAttachmentData } from 'src/modules/messaging/message-import-manager/
 import { getBodyData } from 'src/modules/messaging/message-import-manager/drivers/gmail/utils/get-body-data.util';
 import { getPropertyFromHeaders } from 'src/modules/messaging/message-import-manager/drivers/gmail/utils/get-property-from-headers.util';
 
+/**
+ * Safely parses an email address string using addressparser
+ * Returns undefined if parsing fails
+ */
+const safeParseAddress = (address: string | undefined) => {
+  if (!address) return undefined;
+  try {
+    return addressparser(address);
+  } catch (error) {
+    console.error('Error parsing address:', error);
+    return undefined;
+  }
+};
+
 export const parseGmailMessage = (message: gmail_v1.Schema$Message) => {
   const subject = getPropertyFromHeaders(message, 'Subject');
   const rawFrom = getPropertyFromHeaders(message, 'From');
@@ -36,11 +50,11 @@ export const parseGmailMessage = (message: gmail_v1.Schema$Message) => {
     historyId,
     internalDate,
     subject,
-    from: rawFrom ? addressparser(rawFrom) : undefined,
-    deliveredTo: rawDeliveredTo ? addressparser(rawDeliveredTo) : undefined,
-    to: rawTo ? addressparser(rawTo) : undefined,
-    cc: rawCc ? addressparser(rawCc) : undefined,
-    bcc: rawBcc ? addressparser(rawBcc) : undefined,
+    from: safeParseAddress(rawFrom),
+    deliveredTo: safeParseAddress(rawDeliveredTo),
+    to: safeParseAddress(rawTo),
+    cc: safeParseAddress(rawCc),
+    bcc: safeParseAddress(rawBcc),
     text,
     attachments,
   };

packages/twenty-server/src/modules/messaging/message-import-manager/drivers/gmail/utils/sanitize-string.util.ts

@@ -1,3 +1,32 @@
 export const sanitizeString = (str: string) => {
   return str.replace(/\0/g, '');
 };
+
+/**
+ * Sanitizes an email address to ensure it's in a valid format
+ * - Removes null characters
+ * - Normalizes Unicode characters
+ * - Ensures proper encoding
+ */
+export const sanitizeEmailAddress = (email: string): string => {
+  if (!email) return '';
+  
+  // Remove null characters
+  let sanitized = email.replace(/\0/g, '');
+  
+  // Normalize Unicode characters
+  sanitized = sanitized.normalize('NFKC');
+  
+  // Remove any non-printable characters
+  sanitized = sanitized.replace(/[\x00-\x1F\x7F-\x9F]/g, '');
+  
+  // Ensure proper email format
+  const parts = sanitized.split('@');
+  if (parts.length !== 2) return sanitized;
+  
+  // Sanitize local part and domain separately
+  const localPart = parts[0].replace(/[^\w.!#$%&'*+/=?^`{|}~-]/g, '');
+  const domain = parts[1].replace(/[^\w.-]/g, '');
+  
+  return `${localPart}@${domain}`.toLowerCase();
+};

packages/twenty-server/src/modules/messaging/message-import-manager/utils/format-address-object-as-participants.util.ts

@@ -1,6 +1,7 @@
 import addressparser from 'addressparser';
 
 import { Participant } from 'src/modules/messaging/message-import-manager/drivers/gmail/types/gmail-message.type';
+import { sanitizeEmailAddress } from 'src/modules/messaging/message-import-manager/drivers/gmail/utils/sanitize-string.util';
 
 const formatAddressObjectAsArray = (
   addressObject: addressparser.EmailAddress | addressparser.EmailAddress[],
@@ -12,6 +13,9 @@ const removeSpacesAndLowerCase = (email: string): string => {
   return email.replace(/\s/g, '').toLowerCase();
 };
 
+/**
+ * Formats an address object into participants with proper error handling and sanitization
+ */
 export const formatAddressObjectAsParticipants = (
   addressObject:
     | addressparser.EmailAddress
@@ -20,17 +24,38 @@ export const formatAddressObjectAsParticipants = (
   role: 'from' | 'to' | 'cc' | 'bcc',
 ): Participant[] => {
   if (!addressObject) return [];
-  const addressObjects = formatAddressObjectAsArray(addressObject);
+  
+  try {
+    const addressObjects = formatAddressObjectAsArray(addressObject);
 
-  const participants = addressObjects.map((addressObject) => {
-    const address = addressObject.address;
+    const participants = addressObjects.map((addressObject) => {
+      const address = addressObject.address;
+      
+      // Skip invalid addresses
+      if (!address) {
+        return null;
+      }
 
-    return {
-      role,
-      handle: address ? removeSpacesAndLowerCase(address) : '',
-      displayName: addressObject.name || '',
-    };
-  });
+      // Sanitize the email address
+      const sanitizedAddress = sanitizeEmailAddress(address);
+      
+      // Skip if sanitization resulted in an invalid email
+      if (!sanitizedAddress.includes('@')) {
+        return null;
+      }
 
-  return participants.flat();
+      return {
+        role,
+        handle: removeSpacesAndLowerCase(sanitizedAddress),
+        displayName: addressObject.name ? addressObject.name.normalize('NFKC') : '',
+      };
+    });
+
+    // Filter out any null entries from failed parsing
+    return participants.filter((p): p is Participant => p !== null);
+  } catch (error) {
+    // Log the error but don't throw - return empty array instead
+    console.error('Error formatting address object:', error);
+    return [];
+  }
 };