abmp-npm 2.0.68 → 2.0.70

package/backend/__tests__/login-email-sync.test.js

@@ -0,0 +1,49 @@
+const { LOGIN_EMAIL_SYNC_STATUS } = require('../consts');
+const { summarizeLoginEmailOutcomes } = require('../daily-pull/utils');
+
+const { UPDATED, FAILED, SKIPPED } = LOGIN_EMAIL_SYNC_STATUS;
+
+describe('summarizeLoginEmailOutcomes', () => {
+  test('collects only FAILED outcomes as failures and failed ids', () => {
+    const outcomes = [
+      { memberId: 1, wixMemberId: 'w1', desiredEmail: 'a@x.com', status: UPDATED },
+      {
+        memberId: 2,
+        wixMemberId: 'w2',
+        desiredEmail: 'b@x.com',
+        status: FAILED,
+        error: 'duplicate',
+      },
+      { memberId: 3, status: SKIPPED, desiredEmail: 'c@x.com' },
+    ];
+
+    const { failedMemberIds, failures } = summarizeLoginEmailOutcomes(outcomes);
+
+    expect([...failedMemberIds]).toEqual([2]);
+    expect(failures).toEqual([
+      { memberId: 2, wixMemberId: 'w2', desiredEmail: 'b@x.com', error: 'duplicate' },
+    ]);
+  });
+
+  test('UPDATED and SKIPPED never produce failures (CMS email is left to advance/no-op)', () => {
+    const outcomes = [
+      { memberId: 1, status: UPDATED, desiredEmail: 'a@x.com' },
+      { memberId: 2, status: SKIPPED, desiredEmail: 'b@x.com' },
+    ];
+    const { failedMemberIds, failures } = summarizeLoginEmailOutcomes(outcomes);
+    expect(failedMemberIds.size).toBe(0);
+    expect(failures).toEqual([]);
+  });
+
+  test('defaults a missing error message', () => {
+    const { failures } = summarizeLoginEmailOutcomes([
+      { memberId: 9, wixMemberId: 'w9', desiredEmail: 'z@x.com', status: FAILED },
+    ]);
+    expect(failures[0].error).toBe('unknown error');
+  });
+
+  test('handles empty / missing input', () => {
+    expect(summarizeLoginEmailOutcomes([]).failures).toEqual([]);
+    expect(summarizeLoginEmailOutcomes().failures).toEqual([]);
+  });
+});

package/backend/consts.js

@@ -34,6 +34,15 @@ const MEMBERSHIPS_TYPES = {
   PAC_STAFF: 'PAC STAFF',
 };
 
+/**
+ * Possible outcomes of attempting to change a Wix member's login email during the sync.
+ */
+const LOGIN_EMAIL_SYNC_STATUS = {
+  UPDATED: 'updated', // Wix login email successfully changed to the desired email
+  FAILED: 'failed', // change failed -> keep the CMS login email unchanged and report for manual handling
+  SKIPPED: 'skipped', // member has no wixMemberId, nothing to change
+};
+
 module.exports = {
   CONFIG_KEYS,
   MAX__MEMBERS_SEARCH_RESULTS,
@@ -45,4 +54,5 @@ module.exports = {
   MEMBERSHIPS_TYPES,
   SSO_TOKEN_AUTH_API_URL,
   BACKUP_API_URL,
+  LOGIN_EMAIL_SYNC_STATUS,
 };

package/backend/contacts-methods.js

@@ -28,6 +28,9 @@ async function createSiteContact(contactData) {
     },
   };
   console.log('[createSiteContact]contactInfo', JSON.stringify(contactInfo, null, 2));
+  // Intentionally NOT passing allowDuplicates: Wix CRM enforces email uniqueness
+  // case-insensitively, which is the guard we want against two different members sharing an
+  // email. Same-member cases never reach here — they collapse to a single entity upstream.
   const createContactResponse = await elevatedCreateContact(contactInfo);
   console.log(
     '[createSiteContact]createContactResponse',

package/backend/daily-pull/bulk-process-methods.js

@@ -2,7 +2,12 @@ const { bulkSaveMembers, getMemberBySlug } = require('../members-data-methods');
 const { extractUrlCounter } = require('../utils');
 
 const { generateUpdatedMemberData } = require('./process-member-methods');
-const { changeWixMembersEmails, incrementUrlCounter, extractBaseUrl } = require('./utils');
+const {
+  changeWixMembersEmails,
+  summarizeLoginEmailOutcomes,
+  incrementUrlCounter,
+  extractBaseUrl,
+} = require('./utils');
 
 /**
  * Ensures unique URLs within a batch of members by deduplicating URLs
@@ -151,28 +156,55 @@ const bulkProcessAndSaveMemberData = async ({ memberDataList, currentPageNumber
     // Ensure unique URLs within the batch to prevent duplicates (also checks DB for cross-page conflicts)
     const uniqueUrlsNewToDBMembersList = await ensureUniqueUrlsInBatch(newMembers);
     const uniqueUrlsMembersData = [...uniqueUrlsNewToDBMembersList, ...existingMembers];
-    const toChangeWixMembersEmails = [];
+
+    // Change Wix login emails FIRST so we know which succeeded before saving the CMS records.
+    const toChangeWixMembersEmails = uniqueUrlsMembersData.filter(
+      member => member.wixMemberId && member.isLoginEmailChanged
+    );
+    let failedLoginEmailIds = new Set();
+    let loginEmailFailures = [];
+    if (toChangeWixMembersEmails.length > 0) {
+      const outcomes = await changeWixMembersEmails(toChangeWixMembersEmails);
+      ({ failedMemberIds: failedLoginEmailIds, failures: loginEmailFailures } =
+        summarizeLoginEmailOutcomes(outcomes));
+    }
+
     const toSaveMembersData = uniqueUrlsMembersData.map(member => {
-      const { isLoginEmailChanged, isNewToDb: _isNewToDb, ...restMemberData } = member;
-      if (member.wixMemberId && isLoginEmailChanged) {
-        toChangeWixMembersEmails.push(member);
+      // Transient flags only drive the sync above; never persist them.
+      const {
+        isLoginEmailChanged: _isLoginEmailChanged,
+        isNewToDb: _isNewToDb,
+        previousLoginEmail,
+        ...restMemberData
+      } = member;
+      // If the Wix login-email change failed, keep the CMS login email unchanged (revert to the
+      // previous value) so the CMS stays consistent with Wix; the failure is reported below for
+      // manual handling.
+      if (failedLoginEmailIds.has(member.memberId) && previousLoginEmail !== undefined) {
+        return { ...restMemberData, email: previousLoginEmail };
       }
-      return restMemberData; //we don't want to store the isLoginEmailChanged in the database, it's just a flag to know if we need to change the login email in Members area
+      return restMemberData;
     });
     const saveResult = await bulkSaveMembers(toSaveMembersData);
-    // Change login emails for users who was dropped but now are back to system as new members and have different loginEmail for users with action DROP
-    if (toChangeWixMembersEmails.length > 0) {
-      await changeWixMembersEmails(toChangeWixMembersEmails);
-    }
     const totalFailed = memberDataList.length - validMemberData.length;
     const processingTime = Date.now() - startTime;
 
+    if (loginEmailFailures.length > 0) {
+      console.error(
+        `[loginEmailSync] ${loginEmailFailures.length} login-email change(s) failed on page ${currentPageNumber}; CMS login email left unchanged for memberIds: [${loginEmailFailures
+          .map(failure => failure.memberId)
+          .join(', ')}]`
+      );
+    }
+
     return {
       ...saveResult,
       totalProcessed: memberDataList.length,
       totalSaved: validMemberData.length,
       totalFailed: totalFailed,
       processingTime: processingTime,
+      loginEmailFailedCount: loginEmailFailures.length,
+      loginEmailFailures,
     };
   } catch (error) {
     throw new Error(`Bulk operation failed: ${error.message}`);

package/backend/daily-pull/process-member-methods.js

@@ -165,10 +165,12 @@ async function createCoreMemberData(inputMemberData, existingDbMember, currentPa
       newEmail &&
       existingDbMember.email !== newEmail;
     if (isMemberReinstatedWithNewEmail) {
-      // If exists in DB, and email was changed means this user was dropped before that's why it exists in DB, then only update loginEmail not contactFormEmail
+      // If exists in DB, and email was changed means this user was dropped before that's why it exists in DB, then only update loginEmail not contactFormEmail.
+      // previousLoginEmail lets the caller keep the old email if the Wix login-email change fails.
       return {
         email: newEmail,
         isLoginEmailChanged: true,
+        previousLoginEmail: existingDbMember.email,
       };
     }
     //If exists in DB but not reinstated with new email, then don't update emails

package/backend/daily-pull/utils.js

@@ -1,3 +1,4 @@
+const { LOGIN_EMAIL_SYNC_STATUS } = require('../consts');
 const { updateWixMemberLoginEmail } = require('../members-area-methods');
 const { extractUrlCounter } = require('../utils');
 
@@ -7,13 +8,49 @@ const isUpdatedMember = member => member.action !== MEMBER_ACTIONS.NONE;
 const isSiteAssociatedMember = (member, siteAssociation) =>
   member.memberships.some(membership => membership.association === siteAssociation);
 
+/**
+ * Attempts to change Wix login emails for the given members and returns one structured
+ * outcome per member (see updateWixMemberLoginEmail). Never throws for an individual member.
+ * @param {Array} toChangeWixMembersEmails
+ * @returns {Promise<Array>} outcomes
+ */
 const changeWixMembersEmails = async toChangeWixMembersEmails => {
   console.log(
-    `Changing login emails for ${toChangeWixMembersEmails.length} members with ids: [${toChangeWixMembersEmails.map(member => member.memberId).join(', ')}]`
+    `[loginEmailSync] changing login emails for ${toChangeWixMembersEmails.length} members with ids: [${toChangeWixMembersEmails.map(member => member.memberId).join(', ')}]`
   );
-  return await Promise.all(
-    toChangeWixMembersEmails.map(member => updateWixMemberLoginEmail(member, {}))
+  const outcomes = await Promise.all(
+    toChangeWixMembersEmails.map(member => updateWixMemberLoginEmail(member))
   );
+  const summary = outcomes.reduce((acc, outcome) => {
+    acc[outcome.status] = (acc[outcome.status] || 0) + 1;
+    return acc;
+  }, {});
+  console.log(`[loginEmailSync] results summary: ${JSON.stringify(summary)}`);
+  return outcomes;
+};
+
+/**
+ * Summarizes login-email sync outcomes for manual handling via the task result.
+ * Pure function so it can be unit-tested without Wix.
+ * @param {Array} outcomes - from updateWixMemberLoginEmail / changeWixMembersEmails
+ * @returns {{ failedMemberIds: Set, failures: Array }} set of failed memberIds (whose CMS login
+ *   email must be left unchanged) and the failure records to surface in the task result
+ */
+const summarizeLoginEmailOutcomes = (outcomes = []) => {
+  const failedMemberIds = new Set();
+  const failures = [];
+  outcomes.forEach(outcome => {
+    if (outcome.status === LOGIN_EMAIL_SYNC_STATUS.FAILED) {
+      failedMemberIds.add(outcome.memberId);
+      failures.push({
+        memberId: outcome.memberId,
+        wixMemberId: outcome.wixMemberId,
+        desiredEmail: outcome.desiredEmail,
+        error: outcome.error || 'unknown error',
+      });
+    }
+  });
+  return { failedMemberIds, failures };
 };
 
 const extractBaseUrl = url => {
@@ -105,6 +142,7 @@ module.exports = {
   isUpdatedMember,
   isSiteAssociatedMember,
   changeWixMembersEmails,
+  summarizeLoginEmailOutcomes,
   validateCoreMemberData,
   containsNonEnglish,
   createFullName,

package/backend/jobs.js

@@ -97,6 +97,20 @@ async function scheduleFixUrlsWithSpacesTask() {
   }
 }
 
+async function scheduleNormalizeMemberEmailsTask() {
+  try {
+    console.log('scheduleNormalizeMemberEmails started!');
+    return await taskManager().schedule({
+      name: TASKS_NAMES.scheduleNormalizeMemberEmails,
+      data: {},
+      type: 'scheduled',
+    });
+  } catch (error) {
+    console.error(`Failed to scheduleNormalizeMemberEmails: ${error.message}`);
+    throw new Error(`Failed to scheduleNormalizeMemberEmails: ${error.message}`);
+  }
+}
+
 async function runDailyPullExecutionCheck() {
   try {
     console.log('runDailyPullExecutionCheck started!');
@@ -126,5 +140,6 @@ module.exports = {
   scheduleCreateContactsFromMembersTask,
   scheduleFixPrimaryAddressForMembersTask,
   scheduleFixUrlsWithSpacesTask,
+  scheduleNormalizeMemberEmailsTask,
   runDailyPullExecutionCheck,
 };

package/backend/login/generate-member-session-token.js

@@ -0,0 +1,27 @@
+const { auth } = require('@wix/essentials');
+const { authentication } = require('@wix/identity');
+
+const elevatedSignOn = auth.elevate(authentication.signOn);
+
+/**
+ * Creates a Wix member session token for SSO / QA login using @wix/identity signOn (elevated).
+ * @param {string} email - Member login email
+ * @returns {Promise<string>} Session token for authentication.applySessionToken on the client
+ */
+async function generateMemberSessionToken(email) {
+  const trimmedEmail = (email || '').trim();
+  if (!trimmedEmail) {
+    throw new Error('Email is required to generate a session token');
+  }
+
+  const response = await elevatedSignOn({ email: trimmedEmail });
+  const sessionToken = response?.sessionToken;
+  if (!sessionToken) {
+    throw new Error('Failed to generate session token: empty response from signOn');
+  }
+  return sessionToken;
+}
+
+module.exports = {
+  generateMemberSessionToken,
+};

package/backend/login/index.js

@@ -1,7 +1,8 @@
-const { createLoginMethods } = require('./login-methods-factory');
-const { validateMemberToken } = require('./sso-methods');
+const { loginQAMember } = require('./qa-login-methods');
+const { validateMemberToken, authenticateSSOToken } = require('./sso-methods');
 
 module.exports = {
-  createLoginMethods,
+  loginQAMember,
   validateMemberToken,
+  authenticateSSOToken,
 };

package/backend/login/qa-login-methods.js

@@ -2,6 +2,8 @@ const { CONFIG_KEYS } = require('../consts');
 const { prepareMemberForQALogin, getQAUsers } = require('../members-data-methods');
 const { getSecret, getSiteConfigs } = require('../utils');
 
+const { generateMemberSessionToken } = require('./generate-member-session-token');
+
 const validateQAUser = async userEmail => {
   const qaUsers = await getQAUsers();
   const matchingUserEmail = qaUsers.find(user => user.email === userEmail)?.email;
@@ -16,10 +18,9 @@ const validateQAUser = async userEmail => {
  * @param {Object} params - The parameters for the login
  * @param {string} params.userEmail - The email of the user to login
  * @param {string} params.secret - The secret of the user to login
- * @param {Function} generateSessionToken - a dependency of the method, injected by the createLoginMethods function
  * @returns {Promise<Object>} The result of the login
  */
-const loginQAMember = async ({ userEmail, secret }, generateSessionToken) => {
+const loginQAMember = async ({ userEmail, secret }) => {
   try {
     const [qaSecret, allowAnyMember] = await Promise.all([
       getSecret('ABMP_QA_SECRET'),
@@ -36,7 +37,7 @@ const loginQAMember = async ({ userEmail, secret }, generateSessionToken) => {
     }
 
     const memberData = await prepareMemberForQALogin(userEmail);
-    const token = await generateSessionToken(memberData.email, qaSecret);
+    const token = await generateMemberSessionToken(memberData.email);
     return {
       success: true,
       token,

package/backend/login/sso-methods.js

@@ -15,6 +15,8 @@ const {
   getSecret,
 } = require('../utils');
 
+const { generateMemberSessionToken } = require('./generate-member-session-token');
+
 /**
  * Validates member token and retrieves member data
  * @param {string} memberIdInput - The member ID to validate
@@ -112,10 +114,9 @@ async function checkAndFetchSSO(token) {
  * Authenticate an SSO token
  * @param {Object} params - The parameters for the authentication
  * @param {string} params.token - The token to authenticate
- * @param {Function} generateSessionToken - a dependency of the method, injected by the createLoginMethods function
  * @returns {Promise<Object>} The result of the authentication
  */
-const authenticateSSOToken = async ({ token }, generateSessionToken) => {
+const authenticateSSOToken = async ({ token }) => {
   const responseToken = await checkAndFetchSSO(token);
   const isValidToken = Boolean(
     responseToken && typeof responseToken === 'string' && responseToken?.trim()
@@ -135,7 +136,7 @@ const authenticateSSOToken = async ({ token }, generateSessionToken) => {
     const payload = jwt.payload;
     const memberData = await prepareMemberForSSOLogin(payload);
     console.log('memberDataCollectionId', memberData._id);
-    const sessionToken = await generateSessionToken(memberData.email);
+    const sessionToken = await generateMemberSessionToken(memberData.email);
     const authObj = {
       type: 'success',
       memberId: memberData._id,

package/backend/member-contact-orchestration.js

@@ -2,6 +2,8 @@
  * Orchestrates syncing between Wix Members and CRM Contacts.
  * Returns member data to save; caller does a single updateMember to avoid double-write.
  */
+const { emailsMatch } = require('../public/Utils/sharedUtils');
+
 const { createSiteContact, updateContactInfo, deleteSiteContact } = require('./contacts-methods');
 
 /**
@@ -18,7 +20,10 @@ async function updateContactEmail(newContactEmail, existingMemberData) {
 
   const { wixContactId, wixMemberId, email: loginEmail } = existingMemberData;
   const isSingleEntity = wixContactId === wixMemberId;
-  const contactEmailDiffersFromLogin = loginEmail !== newContactEmail;
+  // Compare case-insensitively: Wix CRM enforces email uniqueness without regard to case,
+  // so a contact email that equals the login email (e.g. different casing) must collapse to
+  // a single entity rather than attempt a duplicate contact write.
+  const contactEmailDiffersFromLogin = !emailsMatch(loginEmail, newContactEmail);
 
   if (!contactEmailDiffersFromLogin) {
     if (isSingleEntity) {

package/backend/members-area-methods.js

@@ -1,8 +1,13 @@
 const { auth } = require('@wix/essentials');
 const { members, authentication } = require('@wix/members');
+
+const { LOGIN_EMAIL_SYNC_STATUS } = require('./consts');
+
 const elevatedCreateMember = auth.elevate(members.createMember);
 const elevatedChangeLoginEmail = auth.elevate(authentication.changeLoginEmail);
 
+const LOG = '[loginEmailSync]';
+
 function prepareMemberData(partner) {
   const options = {
     member: {
@@ -37,48 +42,42 @@ const getCurrentMember = async () => {
 };
 
 /**
- * Updates Wix member login email if the member has a wixMemberId (registered Wix member)
- * @param {Object} member - Member object with wixMemberId and email
- * @param {Object} result - Result object to track Wix member updates
+ * Attempts to change a Wix member's login email to `member.email` and reports a structured
+ * outcome instead of swallowing failures. Never throws.
+ *
+ * Outcomes:
+ *  - SKIPPED: member has no wixMemberId, nothing to change.
+ *  - UPDATED: Wix login email changed successfully.
+ *  - FAILED:  change failed. The caller keeps the CMS login email unchanged (so it stays
+ *             consistent with Wix) and reports the member in the task result for manual handling.
+ *
+ * @param {Object} member - Member with { memberId, wixMemberId, email }
+ * @returns {Promise<Object>} outcome
  */
-async function updateWixMemberLoginEmail(member, result = {}) {
+async function updateWixMemberLoginEmail(member) {
+  const desiredEmail = member.email;
+  const base = { memberId: member.memberId, wixMemberId: member.wixMemberId, desiredEmail };
+
   if (!member.wixMemberId) {
-    console.log(`Member ${member.memberId} has no wixMemberId - skipping Wix login email update`);
-    return;
+    console.log(`${LOG} member ${member.memberId} has no wixMemberId - skipping`);
+    return { ...base, status: LOGIN_EMAIL_SYNC_STATUS.SKIPPED };
   }
 
-  try {
-    console.log(
-      `Updating Wix login email for member ${member.memberId} (wixMemberId: ${member.wixMemberId})`
-    );
-
-    const updatedWixMember = await elevatedChangeLoginEmail(member.wixMemberId, member.email);
+  console.log(
+    `${LOG} attempting login-email change for member ${member.memberId} (wixMemberId: ${member.wixMemberId}) -> ${desiredEmail}`
+  );
 
+  try {
+    const updatedWixMember = await elevatedChangeLoginEmail(member.wixMemberId, desiredEmail);
     console.log(
-      `✅ Successfully updated Wix login email for member ${member.memberId}: ${updatedWixMember.loginEmail}`
+      `${LOG} ✅ updated member ${member.memberId} (wixMemberId: ${member.wixMemberId}) -> ${updatedWixMember.loginEmail}`
     );
-
-    if (!result.wixMemberUpdates) {
-      result.wixMemberUpdates = { successful: 0, failed: 0 };
-    }
-    result.wixMemberUpdates.successful++;
+    return { ...base, status: LOGIN_EMAIL_SYNC_STATUS.UPDATED };
   } catch (error) {
-    console.error(`❌ Failed to update Wix login email for member ${member.memberId}:`, error);
-
-    if (!result.wixMemberUpdates) {
-      result.wixMemberUpdates = { successful: 0, failed: 0 };
-    }
-    result.wixMemberUpdates.failed++;
-
-    if (!result.wixMemberErrors) {
-      result.wixMemberErrors = [];
-    }
-    result.wixMemberErrors.push({
-      memberId: member.memberId,
-      wixMemberId: member.wixMemberId,
-      email: member.email,
-      error: error.message,
-    });
+    console.error(
+      `${LOG} ❌ login-email change failed for member ${member.memberId} (wixMemberId: ${member.wixMemberId}) -> ${desiredEmail}: ${error.message}`
+    );
+    return { ...base, status: LOGIN_EMAIL_SYNC_STATUS.FAILED, error: error.message };
   }
 }
 

package/backend/members-data-methods.js

@@ -1,5 +1,5 @@
 const { COLLECTIONS } = require('../public/consts');
-const { isWixHostedImage } = require('../public/Utils/sharedUtils');
+const { isWixHostedImage, emailsMatch, normalizeEmail } = require('../public/Utils/sharedUtils');
 
 const { MEMBERSHIPS_TYPES } = require('./consts');
 const { createSiteContact } = require('./contacts-methods');
@@ -35,7 +35,42 @@ async function findMemberByWixDataId(memberId) {
 }
 
 const hasDifferentEmails = memberData =>
-  memberData.contactFormEmail && memberData.contactFormEmail !== memberData.email;
+  Boolean(memberData.contactFormEmail) &&
+  !emailsMatch(memberData.contactFormEmail, memberData.email);
+
+/**
+ * Returns a shallow copy of a member record with its email fields normalized
+ * (lowercased + trimmed). Wix CRM and our uniqueness checks treat emails
+ * case-insensitively, so we persist them in canonical form to keep `.eq` lookups
+ * reliable. Only rewrites string values that are actually present.
+ * @param {Object} memberData
+ * @returns {Object}
+ */
+const normalizeMemberEmailFields = memberData => {
+  if (!memberData || typeof memberData !== 'object') return memberData;
+  const normalized = { ...memberData };
+  if (typeof normalized.email === 'string') {
+    normalized.email = normalizeEmail(normalized.email);
+  }
+  if (typeof normalized.contactFormEmail === 'string') {
+    normalized.contactFormEmail = normalizeEmail(normalized.contactFormEmail);
+  }
+  return normalized;
+};
+
+/**
+ * Whether a member's stored email fields are not already in canonical form
+ * (lowercased + trimmed) and therefore need the normalization backfill.
+ * @param {Object} member
+ * @returns {boolean}
+ */
+const memberNeedsEmailNormalization = member =>
+  (typeof member.email === 'string' &&
+    member.email.length > 0 &&
+    member.email !== normalizeEmail(member.email)) ||
+  (typeof member.contactFormEmail === 'string' &&
+    member.contactFormEmail.length > 0 &&
+    member.contactFormEmail !== normalizeEmail(member.contactFormEmail));
 
 async function createContactAndMemberIfNew(memberData) {
   if (!memberData) {
@@ -97,8 +132,14 @@ async function bulkSaveMembers(memberDataList, collectionName = COLLECTIONS.MEMB
   }
 
   try {
+    // Normalize email fields only for the members collection; other collections passed here
+    // (e.g. staging copies) don't have these fields and must be saved untouched.
+    const listToSave =
+      collectionName === COLLECTIONS.MEMBERS_DATA
+        ? memberDataList.map(normalizeMemberEmailFields)
+        : memberDataList;
     // bulkSave all with batches of 1000 items as this is the Velo limit for bulkSave
-    const batches = chunkArray(memberDataList, 1000);
+    const batches = chunkArray(listToSave, 1000);
     return await Promise.all(batches.map(batch => wixData.bulkSave(collectionName, batch)));
   } catch (error) {
     console.error('Error bulk saving members:', error);
@@ -244,24 +285,48 @@ const getAllEmptyAboutYouMembers = async () => {
  */
 async function updateMember(memberToUpdate) {
   try {
-    const updatedMember = await wixData.update(COLLECTIONS.MEMBERS_DATA, memberToUpdate);
+    const updatedMember = await wixData.update(
+      COLLECTIONS.MEMBERS_DATA,
+      normalizeMemberEmailFields(memberToUpdate)
+    );
     return updatedMember;
   } catch (error) {
     throw new Error(`Failed to update member data: ${error.message}`);
   }
 }
+/**
+ * Whether the given email is already used by a DIFFERENT member (case-insensitive).
+ * Returns false when the email is free or belongs to the same member, so a member can
+ * always keep/normalize their own email.
+ * @param {string} email
+ * @param {string|number} memberId - The member requesting the change
+ * @returns {Promise<boolean>}
+ */
 async function isEmailAlreadyUsed(email, memberId) {
   const member = await getMemberByContactEmail(email);
-  return member !== null && member.memberId !== memberId;
+  return member !== null && String(member.memberId) !== String(memberId);
 }
+/**
+ * Finds the member that owns an email (in either the login or contact-form field),
+ * matching case-insensitively. Emails are normalized (lowercased + trimmed) on write and
+ * backfilled by the email-normalization migration, so stored values are canonical: a single
+ * `.eq` against the normalized email is an exact, case-insensitive lookup.
+ * Throws if two DIFFERENT members share the email (a data-integrity violation).
+ * @param {string} email
+ * @returns {Promise<Object|null>}
+ */
 async function getMemberByContactEmail(email) {
+  const normalized = normalizeEmail(email);
+  if (!normalized) return null;
+
   const members = await wixData
     .query(COLLECTIONS.MEMBERS_DATA)
-    .eq('contactFormEmail', email)
-    .or(wixData.query(COLLECTIONS.MEMBERS_DATA).eq('email', email))
+    .eq('contactFormEmail', normalized)
+    .or(wixData.query(COLLECTIONS.MEMBERS_DATA).eq('email', normalized))
     .limit(2)
     .find()
     .then(res => res.items);
+
   if (members.length > 1) {
     throw new Error(
       `[getMemberByContactEmail] Multiple members found with same loginemail or contactFormEmail ${email} membersIds are : [${members.map(member => member.memberId).join(', ')}]`
@@ -451,6 +516,29 @@ const getAllMembersWithoutContactFormEmail = async () => {
   }
 };
 
+/**
+ * Gets all members whose email or contactFormEmail is stored with non-canonical casing
+ * (or surrounding whitespace) and therefore needs the normalization backfill.
+ * Wix Data cannot compare a field to its own lowercase form, so we fetch members that have
+ * an email set and filter in memory.
+ * @returns {Promise<Array>} - Array of member data
+ */
+const getAllMembersNeedingEmailNormalization = async () => {
+  try {
+    const membersQuery = wixData
+      .query(COLLECTIONS.MEMBERS_DATA)
+      .isNotEmpty('email')
+      .or(wixData.query(COLLECTIONS.MEMBERS_DATA).isNotEmpty('contactFormEmail'))
+      .limit(1000);
+
+    const allItems = await queryAllItems(membersQuery);
+    return allItems.filter(memberNeedsEmailNormalization);
+  } catch (error) {
+    console.error('Error getting members needing email normalization:', error);
+    throw new Error(`Failed to get members needing email normalization: ${error.message}`);
+  }
+};
+
 /* Gets all updated login emails from the updated emails database
  * @returns {Promise<Array>} - Array of updated email data
  */
@@ -488,9 +576,13 @@ const getMembersByIds = async memberIds => {
 
 const getMemberByEmail = async email => {
   try {
+    // Login emails are normalized on write, so match against the normalized value (see
+    // getMemberByContactEmail) — an exact `.eq` is a case-insensitive lookup.
+    const normalized = normalizeEmail(email);
+    if (!normalized) return null;
     const members = await wixData
       .query(COLLECTIONS.MEMBERS_DATA)
-      .eq('email', email)
+      .eq('email', normalized)
       .limit(2)
       .find()
       .then(res => res.items);
@@ -638,6 +730,8 @@ module.exports = {
   getAllMembersWithExternalImages,
   getMembersWithWixUrl,
   getAllMembersWithoutContactFormEmail,
+  getAllMembersNeedingEmailNormalization,
+  memberNeedsEmailNormalization,
   getAllUpdatedLoginEmails,
   getMembersByIds,
   getMemberByEmail,

package/backend/tasks/consts.js

@@ -22,6 +22,8 @@ const TASKS_NAMES = {
   fixPrimaryAddressChunk: 'fixPrimaryAddressChunk',
   scheduleFixUrlsWithSpaces: 'scheduleFixUrlsWithSpaces',
   fixUrlsWithSpacesChunk: 'fixUrlsWithSpacesChunk',
+  scheduleNormalizeMemberEmails: 'scheduleNormalizeMemberEmails',
+  normalizeMemberEmailsChunk: 'normalizeMemberEmailsChunk',
   dailyPullExecutionCheck: 'dailyPullExecutionCheck',
 };
 

package/backend/tasks/email-normalize-methods.js

@@ -0,0 +1,134 @@
+const { taskManager } = require('psdev-task-manager');
+
+const {
+  bulkSaveMembers,
+  getMembersByIds,
+  getAllMembersNeedingEmailNormalization,
+  memberNeedsEmailNormalization,
+} = require('../members-data-methods');
+const { chunkArray } = require('../utils');
+
+const { TASKS_NAMES } = require('./consts');
+
+const CHUNK_SIZE = 1000;
+
+/**
+ * One-off backfill: schedules tasks to normalize (lowercase + trim) the email and
+ * contactFormEmail fields of existing members so stored values match the normalize-on-write
+ * behavior, keeping case-insensitive uniqueness lookups reliable.
+ */
+async function scheduleNormalizeMemberEmails() {
+  console.log('=== Scheduling Member Email Normalization ===');
+
+  try {
+    const members = await getAllMembersNeedingEmailNormalization();
+    console.log(`Fetched ${members.length} members needing email normalization`);
+
+    const memberIds = [
+      ...new Set(
+        members
+          .map(member => Number(member.memberId))
+          .filter(memberId => Number.isFinite(memberId) && memberId > 0)
+      ),
+    ];
+    console.log(`Members to normalize: ${memberIds.length}`);
+
+    if (memberIds.length === 0) {
+      console.log('No members need email normalization');
+      return {
+        success: true,
+        message: 'No members need email normalization',
+        totalMembers: 0,
+        tasksScheduled: 0,
+      };
+    }
+
+    const chunks = chunkArray(memberIds, CHUNK_SIZE);
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const task = {
+        name: TASKS_NAMES.normalizeMemberEmailsChunk,
+        data: {
+          memberIds: chunk,
+          chunkIndex: i,
+          totalChunks: chunks.length,
+        },
+        type: 'scheduled',
+      };
+      await taskManager().schedule(task);
+      console.log(`Scheduled task ${i + 1}/${chunks.length} (${chunk.length} members)`);
+    }
+
+    const result = {
+      success: true,
+      message: `Scheduled ${chunks.length} tasks for ${memberIds.length} members`,
+      totalMembers: memberIds.length,
+      tasksScheduled: chunks.length,
+    };
+
+    console.log('=== Scheduling Complete ===');
+    console.log(JSON.stringify(result, null, 2));
+
+    return result;
+  } catch (error) {
+    console.error('Error scheduling member email normalization:', error);
+    throw error;
+  }
+}
+
+/**
+ * Processes a chunk of members, normalizing their email fields.
+ * bulkSaveMembers normalizes on write, so we only need to select the members that still
+ * have non-canonical values and save them.
+ */
+async function normalizeMemberEmailsChunk(data) {
+  const { memberIds, chunkIndex, totalChunks } = data;
+  console.log(
+    `Processing email normalization chunk ${chunkIndex + 1}/${totalChunks} (${memberIds.length} members)`
+  );
+
+  const result = {
+    successful: 0,
+    failed: 0,
+    skipped: 0,
+    errors: [],
+    failedIds: [],
+  };
+
+  try {
+    const members = await getMembersByIds(memberIds);
+    console.log(`Loaded ${members.length} members for this chunk`);
+
+    const membersToUpdate = members.filter(memberNeedsEmailNormalization);
+    result.skipped = members.length - membersToUpdate.length;
+
+    if (membersToUpdate.length === 0) {
+      console.log('No members need updating in this batch');
+      return result;
+    }
+
+    try {
+      await bulkSaveMembers(membersToUpdate);
+      result.successful += membersToUpdate.length;
+      console.log(`✅ Successfully normalized ${membersToUpdate.length} members`);
+    } catch (error) {
+      console.error('❌ Error bulk saving members:', error);
+      result.failed += membersToUpdate.length;
+      result.failedIds.push(...membersToUpdate.map(member => member.memberId));
+      result.errors.push({
+        error: error.message,
+        memberCount: membersToUpdate.length,
+      });
+    }
+
+    return result;
+  } catch (error) {
+    console.error(`Error processing email normalization chunk ${chunkIndex}:`, error);
+    throw error;
+  }
+}
+
+module.exports = {
+  scheduleNormalizeMemberEmails,
+  normalizeMemberEmailsChunk,
+};

package/backend/tasks/tasks-configs.js

@@ -10,6 +10,10 @@ const {
 } = require('./address-primary-methods');
 const { TASKS_NAMES } = require('./consts');
 const { dailyPullExecutionCheck } = require('./daily-pull-check-methods');
+const {
+  scheduleNormalizeMemberEmails,
+  normalizeMemberEmailsChunk,
+} = require('./email-normalize-methods');
 const {
   scheduleTaskForEmptyAboutYouMembers,
   convertAboutYouHtmlToRichContent,
@@ -203,6 +207,20 @@ const TASKS = {
     shouldSkipCheck: () => false,
     estimatedDurationSec: 80,
   },
+  [TASKS_NAMES.scheduleNormalizeMemberEmails]: {
+    name: TASKS_NAMES.scheduleNormalizeMemberEmails,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: scheduleNormalizeMemberEmails,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
+  [TASKS_NAMES.normalizeMemberEmailsChunk]: {
+    name: TASKS_NAMES.normalizeMemberEmailsChunk,
+    getIdentifier: task => task.data,
+    process: normalizeMemberEmailsChunk,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
   [TASKS_NAMES.dailyPullExecutionCheck]: {
     name: TASKS_NAMES.dailyPullExecutionCheck,
     getIdentifier: task => task.data,

package/backend/tasks/tasks-process-methods.js

@@ -1,9 +1,9 @@
 const { taskManager } = require('psdev-task-manager');
 
 const { COLLECTIONS } = require('../../public/consts');
-const { COMPILED_FILTERS_FIELDS, CONFIG_KEYS } = require('../consts');
+const { COMPILED_FILTERS_FIELDS, CONFIG_KEYS, LOGIN_EMAIL_SYNC_STATUS } = require('../consts');
+const { changeWixMembersEmails, summarizeLoginEmailOutcomes } = require('../daily-pull/utils');
 const { wixData } = require('../elevated-modules');
-const { updateWixMemberLoginEmail } = require('../members-area-methods');
 const {
   getAllEmptyAboutYouMembers,
   getAllMembersWithExternalImages,
@@ -481,6 +481,7 @@ const syncMemberLoginEmails = async data => {
       membersToUpdate.push({
         ...member,
         email: newEmail,
+        previousLoginEmail: member.email,
       });
     }
 
@@ -497,14 +498,35 @@ const syncMemberLoginEmails = async data => {
 
     for (const chunk of updateChunks) {
       try {
-        await bulkSaveMembers(chunk);
-
-        for (const member of chunk) {
-          await updateWixMemberLoginEmail(member, result);
-        }
-
-        result.successful += chunk.length;
-        console.log(`✅ Successfully updated ${chunkIndex} ${chunk.length} members`);
+        // Change Wix login emails first; only advance the CMS login email for the ones that
+        // succeeded. Failures keep their previous email (CMS stays consistent with Wix) and are
+        // reported in result.errors for manual handling.
+        const outcomes = await changeWixMembersEmails(chunk);
+        const { failedMemberIds } = summarizeLoginEmailOutcomes(outcomes);
+        const toSave = chunk.map(member => {
+          const { previousLoginEmail, ...restMember } = member;
+          if (failedMemberIds.has(member.memberId) && previousLoginEmail !== undefined) {
+            return { ...restMember, email: previousLoginEmail };
+          }
+          return restMember;
+        });
+        await bulkSaveMembers(toSave);
+
+        outcomes.forEach(outcome => {
+          if (outcome.status === LOGIN_EMAIL_SYNC_STATUS.UPDATED) {
+            result.successful++;
+          } else if (outcome.status === LOGIN_EMAIL_SYNC_STATUS.FAILED) {
+            result.failed++;
+            result.errors.push({
+              memberId: outcome.memberId,
+              wixMemberId: outcome.wixMemberId,
+              desiredEmail: outcome.desiredEmail,
+              error: outcome.error,
+            });
+          } else {
+            result.skipped++;
+          }
+        });
       } catch (error) {
         console.error(`❌ Error updating chunk ${chunkIndex}:`, error);
         result.failed += chunk.length;
@@ -515,14 +537,8 @@ const syncMemberLoginEmails = async data => {
         });
       }
     }
-    // Log comprehensive results including Wix member updates
-    const wixStats = result.wixMemberUpdates || { successful: 0, failed: 0 };
-    console.log(`Login Emails sync task completed:`);
-    console.log(
-      `  - Member data updates: ${result.successful} successful, ${result.failed} failed, ${result.skipped} skipped`
-    );
     console.log(
-      `  - Wix member login emails: ${wixStats.successful} successful, ${wixStats.failed} failed`
+      `Login Emails sync task completed: ${result.successful} synced, ${result.failed} failed, ${result.skipped} skipped`
     );
 
     return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abmp-npm",
-  "version": "2.0.68",
+  "version": "2.0.70",
   "main": "index.js",
   "scripts": {
     "check-cycles": "madge --circular .",
@@ -35,8 +35,8 @@
     "@wix/automations": "^1.0.261",
     "@wix/crm": "^1.0.1061",
     "@wix/data": "^1.0.349",
-    "@wix/essentials": "^0.1.28",
-    "@wix/identity": "^1.0.178",
+    "@wix/essentials": "^1.0.7",
+    "@wix/identity": "^1.0.195",
     "@wix/media": "^1.0.213",
     "@wix/members": "^1.0.365",
     "@wix/secrets": "^1.0.62",

package/public/Utils/sharedUtils.js

@@ -195,6 +195,28 @@ function normalizeExternalUrl(url) {
   return `https://${trimmed}`;
 }
 
+/**
+ * Normalizes an email for comparison (lowercased + trimmed).
+ * Wix CRM treats emails as case-insensitive, so comparisons must too.
+ * @param {string} email
+ * @returns {string}
+ */
+function normalizeEmail(email) {
+  return typeof email === 'string' ? email.trim().toLowerCase() : '';
+}
+
+/**
+ * Case-insensitive email equality. Two empty/missing emails are not considered a match.
+ * @param {string} a
+ * @param {string} b
+ * @returns {boolean}
+ */
+function emailsMatch(a, b) {
+  const normalizedA = normalizeEmail(a);
+  const normalizedB = normalizeEmail(b);
+  return Boolean(normalizedA) && normalizedA === normalizedB;
+}
+
 module.exports = {
   checkAddressIsVisible,
   formatPracticeAreasForDisplay,
@@ -208,4 +230,6 @@ module.exports = {
   formatAddress,
   isWixHostedImage,
   normalizeExternalUrl,
+  normalizeEmail,
+  emailsMatch,
 };

package/backend/login/login-methods-factory.js

@@ -1,24 +0,0 @@
-const { loginQAMember } = require('./qa-login-methods');
-const { authenticateSSOToken } = require('./sso-methods');
-
-/**
- * Creates login methods with injected generateSessionToken dependency
- * @param {Function} generateSessionToken - The Velo generateSessionToken function to inject
- * @returns {Object} Object containing loginQAMember and authenticateSSOToken methods
- */
-const createLoginMethods = generateSessionToken => {
-  //There is no generateSessionToken SDK version,  and the signOn of @wix/identity returns 403 error regardless that the permissions are valid
-  //Therefore, as a workaround we need to inject the Velo version of generateSessionToken to the login methods.
-  const injectGenerateSessionTokenToMethod =
-    method =>
-    async (...args) =>
-      await method(...args, generateSessionToken);
-  return {
-    loginQAMember: injectGenerateSessionTokenToMethod(loginQAMember),
-    authenticateSSOToken: injectGenerateSessionTokenToMethod(authenticateSSOToken),
-  };
-};
-
-module.exports = {
-  createLoginMethods,
-};