abmp-npm 1.1.135 → 1.1.136

package/backend/__tests__/url-uniqueness.test.js

@@ -0,0 +1,194 @@
+const { incrementUrlCounter, extractBaseUrl } = require('../daily-pull/utils');
+const {
+  normalizeUrlForComparison,
+  sortByUrlCounterDescending,
+  extractUrlCounter,
+} = require('../utils');
+
+// ─── Helpers ─────────────────────────────────────────────────────────
+
+/**
+ * Simulates getMemberBySlug's normalized-comparison branch using
+ * the ACTUAL production sort comparator imported from utils.js.
+ */
+function simulateGetHighestMember(allMembers, slug) {
+  const matching = allMembers.filter(
+    m => m.url && normalizeUrlForComparison(m.url) === slug.toLowerCase()
+  );
+  matching.sort(sortByUrlCounterDescending);
+  return matching[0] || null;
+}
+
+/**
+ * Simulates ensureUniqueUrl's counter-increment logic given the
+ * "highest" member returned by getMemberBySlug.
+ */
+function simulateEnsureUniqueUrl(baseSlug, highestMember) {
+  if (!highestMember || !highestMember.url) return baseSlug;
+  return incrementUrlCounter(highestMember?.url, baseSlug);
+}
+
+// ─── Test data ───────────────────────────────────────────────────────
+
+function buildMembersInDb() {
+  return [
+    { memberId: 1, url: 'firstNameLastName' },
+    { memberId: 2, url: 'firstNameLastName-1' },
+    { memberId: 3, url: 'firstNameLastName-2' },
+    { memberId: 4, url: 'firstNameLastName-3' },
+    { memberId: 5, url: 'firstNameLastName-4' },
+    { memberId: 6, url: 'firstNameLastName-5' },
+    { memberId: 7, url: 'firstNameLastName-6' },
+    { memberId: 8, url: 'firstNameLastName-7' },
+    { memberId: 9, url: 'firstNameLastName-8' },
+    { memberId: 10, url: 'firstNameLastName-9' },
+    { memberId: 11, url: 'firstNameLastName-10' },
+    { memberId: 12, url: 'firstNameLastName-11' },
+    { memberId: 13, url: 'firstNameLastName-12' },
+  ];
+}
+
+function buildLargeCounterMembers() {
+  const members = [];
+  for (let i = 0; i <= 105; i++) {
+    members.push({ memberId: i, url: i === 0 ? 'testUser' : `testUser-${i}` });
+  }
+  return members;
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────
+
+describe('Production sort: getMemberBySlug must return the HIGHEST counter', () => {
+  test('should return -12 as the highest URL (not -9)', () => {
+    const members = buildMembersInDb();
+    const highest = simulateGetHighestMember(members, 'firstnamelastname');
+
+    expect(highest.url).toBe('firstNameLastName-12');
+  });
+
+  test('should sort -12 above -9 in descending order', () => {
+    const members = buildMembersInDb();
+    const sorted = [...members]
+      .filter(m => normalizeUrlForComparison(m.url) === 'firstnamelastname')
+      .sort(sortByUrlCounterDescending);
+    const sortedUrls = sorted.map(m => m.url);
+
+    const indexOf9 = sortedUrls.indexOf('firstNameLastName-9');
+    const indexOf12 = sortedUrls.indexOf('firstNameLastName-12');
+
+    expect(indexOf12).toBeLessThan(indexOf9);
+  });
+
+  test('should handle large counters (100+) correctly', () => {
+    const members = buildLargeCounterMembers();
+    const highest = simulateGetHighestMember(members, 'testuser');
+
+    expect(highest.url).toBe('testUser-105');
+  });
+
+  test('should handle hyphenated names (mary-jane) correctly', () => {
+    const members = [
+      { memberId: 1, url: 'mary-jane' },
+      { memberId: 2, url: 'mary-jane-1' },
+      { memberId: 3, url: 'mary-jane-2' },
+      { memberId: 4, url: 'mary-jane-10' },
+    ];
+
+    const highest = simulateGetHighestMember(members, 'mary-jane');
+    expect(highest.url).toBe('mary-jane-10');
+  });
+});
+
+describe('Production sort: ensureUniqueUrl must generate a truly unique URL', () => {
+  test('should generate -13 (not -10) when DB has URLs up to -12', () => {
+    const members = buildMembersInDb();
+    const highest = simulateGetHighestMember(members, 'firstnamelastname');
+    const newUrl = simulateEnsureUniqueUrl('firstNameLastName', highest);
+
+    expect(newUrl).toBe('firstNameLastName-13');
+
+    const existingUrls = members.map(m => m.url);
+    expect(existingUrls).not.toContain(newUrl);
+  });
+
+  test('repeated daily pulls should produce sequential unique URLs', () => {
+    const members = buildMembersInDb();
+    const generatedUrls = [];
+
+    for (let day = 0; day < 5; day++) {
+      const highest = simulateGetHighestMember(members, 'firstnamelastname');
+      const newUrl = simulateEnsureUniqueUrl('firstNameLastName', highest);
+      generatedUrls.push(newUrl);
+      members.push({ memberId: 100 + day, url: newUrl });
+    }
+
+    expect(new Set(generatedUrls).size).toBe(5);
+    expect(generatedUrls).toEqual([
+      'firstNameLastName-13',
+      'firstNameLastName-14',
+      'firstNameLastName-15',
+      'firstNameLastName-16',
+      'firstNameLastName-17',
+    ]);
+  });
+
+  test('should NOT produce duplicates (the -10 bug)', () => {
+    const members = buildMembersInDb();
+    const highest = simulateGetHighestMember(members, 'firstnamelastname');
+    const newUrl = simulateEnsureUniqueUrl('firstNameLastName', highest);
+
+    expect(newUrl).not.toBe('firstNameLastName-10');
+  });
+});
+
+describe('Production sort: ensureUniqueUrlsInBatch single-member path', () => {
+  test('incrementUrlCounter should produce a unique URL from highest DB member', () => {
+    const members = buildMembersInDb();
+    const dbMember = simulateGetHighestMember(members, 'firstnamelastname');
+    const result = incrementUrlCounter(dbMember.url, 'firstNameLastName');
+
+    expect(result).toBe('firstNameLastName-13');
+
+    const existingUrls = members.map(m => m.url);
+    expect(existingUrls).not.toContain(result);
+  });
+});
+
+describe('Utility functions', () => {
+  test('normalizeUrlForComparison strips trailing counter', () => {
+    expect(normalizeUrlForComparison('firstNameLastName')).toBe('firstnamelastname');
+    expect(normalizeUrlForComparison('firstNameLastName-1')).toBe('firstnamelastname');
+    expect(normalizeUrlForComparison('firstNameLastName-9')).toBe('firstnamelastname');
+    expect(normalizeUrlForComparison('firstNameLastName-10')).toBe('firstnamelastname');
+    expect(normalizeUrlForComparison('firstNameLastName-100')).toBe('firstnamelastname');
+  });
+
+  test('extractUrlCounter returns numeric counter', () => {
+    expect(extractUrlCounter('firstNameLastName')).toBe(-1);
+    expect(extractUrlCounter('firstNameLastName-1')).toBe(1);
+    expect(extractUrlCounter('firstNameLastName-9')).toBe(9);
+    expect(extractUrlCounter('firstNameLastName-10')).toBe(10);
+    expect(extractUrlCounter('firstNameLastName-100')).toBe(100);
+    expect(extractUrlCounter(null)).toBe(-1);
+    expect(extractUrlCounter('')).toBe(-1);
+  });
+
+  test('extractBaseUrl strips numeric counter', () => {
+    expect(extractBaseUrl('firstNameLastName-10')).toBe('firstNameLastName');
+    expect(extractBaseUrl('firstNameLastName-1')).toBe('firstNameLastName');
+    expect(extractBaseUrl('firstNameLastName')).toBe('firstNameLastName');
+    expect(extractBaseUrl('john-doe-3')).toBe('john-doe');
+  });
+
+  test('incrementUrlCounter increments correctly', () => {
+    expect(incrementUrlCounter('firstNameLastName-9', 'firstNameLastName')).toBe(
+      'firstNameLastName-10'
+    );
+    expect(incrementUrlCounter('firstNameLastName-10', 'firstNameLastName')).toBe(
+      'firstNameLastName-11'
+    );
+    expect(incrementUrlCounter('firstNameLastName', 'firstNameLastName')).toBe(
+      'firstNameLastName-1'
+    );
+  });
+});

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

@@ -1,12 +1,8 @@
 const { bulkSaveMembers, getMemberBySlug } = require('../members-data-methods');
+const { extractUrlCounter } = require('../utils');
 
 const { generateUpdatedMemberData } = require('./process-member-methods');
-const {
-  changeWixMembersEmails,
-  extractUrlCounter,
-  incrementUrlCounter,
-  extractBaseUrl,
-} = require('./utils');
+const { changeWixMembersEmails, incrementUrlCounter, extractBaseUrl } = require('./utils');
 
 /**
  * Ensures unique URLs within a batch of members by deduplicating URLs
@@ -80,14 +76,9 @@ async function ensureUniqueUrlsInBatch(memberDataList) {
     let batchMaxCounter = -1;
     members.forEach(member => {
       const originalUrl = member.url;
-      const urlParts = originalUrl.split('-');
-      const lastSegment = urlParts[urlParts.length - 1];
-      const isNumeric = /^\d+$/.test(lastSegment);
-      if (isNumeric) {
-        const counter = parseInt(lastSegment, 10);
-        if (counter > batchMaxCounter) {
-          batchMaxCounter = counter;
-        }
+      const urlCounter = extractUrlCounter(originalUrl);
+      if (urlCounter > batchMaxCounter) {
+        batchMaxCounter = urlCounter;
       }
     });
 

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

@@ -1,7 +1,9 @@
+const { ADDRESS_STATUS_TYPES } = require('../../public/consts');
 const { findMemberById, getMemberBySlug } = require('../members-data-methods');
 const { isValidArray, generateGeoHash } = require('../utils');
 
 const { MEMBER_ACTIONS, DEFAULT_MEMBER_DISPLAY_SETTINGS } = require('./consts');
+const { incrementUrlCounter } = require('./utils');
 const { validateCoreMemberData, containsNonEnglish, createFullName } = require('./utils');
 
 /**
@@ -43,9 +45,7 @@ const ensureUniqueUrl = async ({ url, memberId, fullName }) => {
     console.log(
       `Found member with same url ${existingMember.url} for memberId ${memberId} and URL ${uniqueUrl}, increasing counter by 1`
     );
-    const lastSegment = existingMember.url.split('-').pop() || '0';
-    const lastCounter = parseInt(lastSegment, 10) || 0;
-    uniqueUrl = `${uniqueUrl}-${lastCounter + 1}`;
+    uniqueUrl = incrementUrlCounter(existingMember.url, uniqueUrl);
   }
   if (uniqueUrl !== baseUrl) {
     console.log(`URL conflict resolved: ${baseUrl} -> ${uniqueUrl} for member ${memberId}`);
@@ -82,7 +82,21 @@ async function generateUpdatedMemberData({ inputMemberData, currentPageNumber })
 
   // Only add address data for new members
   if (!existingDbMember && isValidArray(inputMemberData.addresses)) {
-    updatedMemberData.addresses = inputMemberData.addresses;
+    const normalizedAddresses = inputMemberData.addresses.map((address, index) => {
+      const key = address?.key || `address_${index}`;
+      const rawStatus = address?.addressStatus;
+      const resolvedStatus =
+        index === 0 && rawStatus === ADDRESS_STATUS_TYPES.DONT_SHOW
+          ? ADDRESS_STATUS_TYPES.STATE_CITY_ZIP
+          : rawStatus || ADDRESS_STATUS_TYPES.STATE_CITY_ZIP;
+      return {
+        ...address,
+        key,
+        addressStatus: resolvedStatus,
+      };
+    });
+    updatedMemberData.addresses = normalizedAddresses;
+    updatedMemberData.addressDisplayOption = [{ key: normalizedAddresses[0].key, isMain: true }];
   }
 
   return { ...updatedMemberData, isNewToDb: !existingDbMember };

package/backend/daily-pull/utils.js

@@ -1,4 +1,5 @@
 const { updateWixMemberLoginEmail } = require('../members-area-methods');
+const { extractUrlCounter } = require('../utils');
 
 const { MEMBER_ACTIONS } = require('./consts');
 
@@ -15,21 +16,12 @@ const changeWixMembersEmails = async toChangeWixMembersEmails => {
   );
 };
 
-const extractUrlCounter = url => {
-  if (!url) return -1;
-  const lastSegment = url.split('-').pop() || '0';
-  const isNumeric = /^\d+$/.test(lastSegment);
-  return isNumeric ? parseInt(lastSegment, 10) : -1;
-};
-
 const extractBaseUrl = url => {
   if (!url) return url;
-  const urlParts = url.split('-');
-  const lastSegment = urlParts[urlParts.length - 1];
-  const isNumeric = /^\d+$/.test(lastSegment);
-  if (isNumeric && urlParts.length > 1) {
+  const lastCounter = extractUrlCounter(url);
+  if (lastCounter > 0) {
     // Remove the numeric counter to get the base URL
-    return urlParts.slice(0, -1).join('-');
+    return url.split('-').slice(0, -1).join('-');
   }
   // No counter found, return the URL as-is
   return url;
@@ -49,9 +41,7 @@ const incrementUrlCounter = (existingUrl, baseUrl) => {
     console.log(
       `Found member with same url ${existingUrl} for baseUrl ${baseUrl}, increasing counter by 1`
     );
-    const lastSegment = existingUrl.split('-').pop() || '0';
-    const isNumeric = /^\d+$/.test(lastSegment);
-    const lastCounter = isNumeric ? parseInt(lastSegment, 10) : 0;
+    const lastCounter = Math.max(0, extractUrlCounter(existingUrl));
     return `${baseUrl}-${lastCounter + 1}`;
   }
 
@@ -118,7 +108,6 @@ module.exports = {
   validateCoreMemberData,
   containsNonEnglish,
   createFullName,
-  extractUrlCounter,
   incrementUrlCounter,
   extractBaseUrl,
 };

package/backend/jobs.js

@@ -68,6 +68,20 @@ async function scheduleCreateContactsFromMembersTask() {
   }
 }
 
+async function scheduleFixPrimaryAddressForMembersTask() {
+  try {
+    console.log('scheduleFixPrimaryAddressForMembers started!');
+    return await taskManager().schedule({
+      name: TASKS_NAMES.scheduleFixPrimaryAddressForMembers,
+      data: {},
+      type: 'scheduled',
+    });
+  } catch (error) {
+    console.error(`Failed to scheduleFixPrimaryAddressForMembers: ${error.message}`);
+    throw new Error(`Failed to scheduleFixPrimaryAddressForMembers: ${error.message}`);
+  }
+}
+
 async function updateSiteMapS3() {
   try {
     return await taskManager().schedule({
@@ -85,4 +99,5 @@ module.exports = {
   scheduleDailyPullTask,
   updateSiteMapS3,
   scheduleCreateContactsFromMembersTask,
+  scheduleFixPrimaryAddressForMembersTask,
 };

package/backend/members-data-methods.js

@@ -10,6 +10,7 @@ const { createSiteMember, getCurrentMember } = require('./members-area-methods')
 const {
   chunkArray,
   normalizeUrlForComparison,
+  sortByUrlCounterDescending,
   queryAllItems,
   generateGeoHash,
   searchAllItems,
@@ -176,7 +177,7 @@ async function getMemberBySlug({
           //remove trailing "-1", "-2", etc.
           item => item.url && normalizeUrlForComparison(item.url) === slug.toLowerCase()
         )
-        .sort((a, b) => b.url.toLowerCase().localeCompare(a.url.toLowerCase()));
+        .sort(sortByUrlCounterDescending);
     }
     if (matchingMembers.length > 1) {
       const queryResultMsg = `Multiple members found with same slug ${slug} membersIds are : [${matchingMembers
@@ -410,7 +411,8 @@ async function getMembersWithWixUrl() {
     .eq('showWixUrl', true)
     .ne('action', MEMBER_ACTIONS.DROP)
     .ne('memberships.membertype', MEMBERSHIPS_TYPES.PAC_STAFF)
-    .isNotEmpty('url')
+    .ne('memberships.membertype', MEMBERSHIPS_TYPES.STUDENT)
+    //.isNotEmpty('url') - not used because it's not working as expected
     .limit(1000);
   let currentResults = await membersQuery.find();
   let i = 0;
@@ -422,7 +424,9 @@ async function getMembersWithWixUrl() {
     i++;
   }
   console.log('i is ', i);
-  const filtered = allItems.filter(item => typeof item.url === 'string' && !item.url.includes('/'));
+  const filtered = allItems.filter(
+    item => typeof item.url === 'string' && !item.url.includes('/') && item.url !== ''
+  );
   console.log('filtered is ', filtered.length);
   return filtered;
 }

package/backend/routers/methods.js

@@ -47,10 +47,12 @@ const createRoutersHandlers = wixRouterMethods => {
         }
         const profileUrl = `${request.baseUrl}/${PAGES_PATHS.PROFILE}/${profileData.url}`;
         const isPrivateMember = profileData.isPrivateMember;
+        const isStudent = profileData.shouldHaveStudentBadge;
+        const shouldNoIndex = isPrivateMember || isStudent;
         const seoData = {
           title: seoTitle,
           description: description,
-          noIndex: isPrivateMember,
+          noIndex: shouldNoIndex,
           metaTags: [
             {
               name: 'description',
@@ -69,7 +71,7 @@ const createRoutersHandlers = wixRouterMethods => {
             },
             {
               name: 'robots',
-              content: isPrivateMember ? 'noindex, nofollow' : 'index, follow',
+              content: shouldNoIndex ? 'noindex, nofollow' : 'index, follow',
             },
             // Open Graph tags
             {

package/backend/routers/utils.js

@@ -66,6 +66,11 @@ function transformMemberToProfileData(member, siteAssociation) {
           numeric: true,
         })
       ) || [];
+
+  const phones = Array.isArray(member.phones) ? member.phones : [];
+  const toShowPhone = member.toShowPhone || '';
+  const phone = toShowPhone && phones.includes(toShowPhone) ? toShowPhone : '';
+
   return {
     mainAddress,
     testimonials: member.testimonial || [],
@@ -84,7 +89,7 @@ function transformMemberToProfileData(member, siteAssociation) {
     bookingUrl: member.bookingUrl,
     aboutService: member.aboutService,
     businessName: (member.showBusinessName && member.businessName) || '',
-    phone: member.toShowPhone || '',
+    phone,
     areasOfPractices,
     gallery: member.gallery,
     bannerImages: member.bannerImages,

package/backend/tasks/address-primary-methods.js

@@ -0,0 +1,256 @@
+const { taskManager } = require('psdev-task-manager');
+
+const { COLLECTIONS } = require('../../public/consts');
+const { wixData } = require('../elevated-modules');
+const { bulkSaveMembers, getMembersByIds } = require('../members-data-methods');
+const { chunkArray, queryAllItems } = require('../utils');
+
+const { TASKS_NAMES } = require('./consts');
+
+const CHUNK_SIZE = 1000;
+
+const getAddressKey = (address, index) =>
+  address?.key || address?.addressid || address?.addressId || `address_${index}`;
+
+const hasPrimaryAddress = addressDisplayOption =>
+  Array.isArray(addressDisplayOption) &&
+  addressDisplayOption.some(option => option?.isMain === true);
+
+/**
+ * Schedules tasks to fix members with multiple addresses and no primary address.
+ */
+async function scheduleFixPrimaryAddressForMembers() {
+  console.log('=== Scheduling Fix Primary Address Tasks ===');
+
+  try {
+    const membersQuery = await wixData
+      .query(COLLECTIONS.MEMBERS_DATA)
+      .isNotEmpty('addresses')
+      .limit(1000);
+    const members = await queryAllItems(membersQuery);
+    console.log(`Fetched ${members.length} members with addresses`);
+
+    const membersToFix = members.filter(member => {
+      const addresses = Array.isArray(member.addresses) ? member.addresses : [];
+      if (addresses.length === 0) {
+        return false;
+      }
+      return !hasPrimaryAddress(member.addressDisplayOption);
+    });
+
+    const memberIds = [
+      ...new Set(
+        membersToFix
+          .map(member => Number(member.memberId))
+          .filter(memberId => Number.isFinite(memberId) && memberId > 0)
+      ),
+    ];
+    console.log(`Members with addresses and no primary: ${memberIds.length}`);
+
+    if (memberIds.length === 0) {
+      console.log('No members need primary address fixes');
+      return {
+        success: true,
+        message: 'No members need primary address fixes',
+        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.fixPrimaryAddressChunk,
+        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(`Sample memberIds: ${memberIds.slice(0, 10).join(', ')}`);
+    console.log(JSON.stringify(result, null, 2));
+
+    return result;
+  } catch (error) {
+    console.error('Error scheduling primary address fix:', error);
+    throw error;
+  }
+}
+
+/**
+ * Processes a chunk of members and sets the first address as primary
+ * when a member has multiple addresses and no primary address.
+ */
+async function fixPrimaryAddressChunk(data) {
+  const { memberIds, chunkIndex, totalChunks } = data;
+  console.log(
+    `Processing primary address fix chunk ${chunkIndex + 1}/${totalChunks} (${memberIds.length} members)`
+  );
+
+  const result = {
+    successful: 0,
+    failed: 0,
+    skipped: 0,
+    errors: [],
+    skippedIds: [],
+    failedIds: [],
+  };
+  const skippedNoAddress = [];
+  const skippedHasPrimary = [];
+  const updatedIds = [];
+
+  try {
+    const members = await getMembersByIds(memberIds);
+    console.log(`Loaded ${members.length} members for this chunk`);
+    const membersToUpdate = [];
+
+    members.forEach(member => {
+      const addresses = Array.isArray(member.addresses) ? member.addresses : [];
+      if (addresses.length === 0) {
+        result.skipped++;
+        result.skippedIds.push(member.memberId);
+        if (skippedNoAddress.length < 20) {
+          skippedNoAddress.push(member.memberId);
+        }
+        return;
+      }
+      if (hasPrimaryAddress(member.addressDisplayOption)) {
+        result.skipped++;
+        result.skippedIds.push(member.memberId);
+        if (skippedHasPrimary.length < 20) {
+          skippedHasPrimary.push(member.memberId);
+        }
+        return;
+      }
+
+      const firstKey = getAddressKey(addresses[0], 0);
+      const normalizedAddresses = addresses.map((address, index) => {
+        if (index !== 0 || address?.key) {
+          return address;
+        }
+        return { ...address, key: firstKey };
+      });
+
+      const updatedDisplayOptions = Array.isArray(member.addressDisplayOption)
+        ? member.addressDisplayOption.map(option => ({
+            ...option,
+            isMain: false,
+          }))
+        : [];
+
+      const existingOption = updatedDisplayOptions.find(option => option?.key === firstKey);
+      if (existingOption) {
+        existingOption.isMain = true;
+      } else {
+        updatedDisplayOptions.push({ key: firstKey, isMain: true });
+      }
+
+      membersToUpdate.push({
+        ...member,
+        addresses: normalizedAddresses,
+        addressDisplayOption: updatedDisplayOptions,
+      });
+      if (updatedIds.length < 20) {
+        updatedIds.push(member.memberId);
+      }
+    });
+
+    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 updated ${membersToUpdate.length} members`);
+      if (updatedIds.length > 0) {
+        console.log(`Updated memberIds (sample): ${updatedIds.join(', ')}`);
+      }
+    } 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,
+      });
+    }
+
+    if (skippedNoAddress.length > 0) {
+      console.log(`Skipped (no addresses) sample: ${skippedNoAddress.join(', ')}`);
+    }
+    if (skippedHasPrimary.length > 0) {
+      console.log(`Skipped (already has primary) sample: ${skippedHasPrimary.join(', ')}`);
+    }
+
+    return result;
+  } catch (error) {
+    console.error(`Error processing primary address fix chunk ${chunkIndex}:`, error);
+    throw error;
+  }
+}
+
+/**
+ * Returns count of members with addresses but no primary address.
+ */
+async function countMembersMissingPrimaryAddress() {
+  console.log('=== Counting Members Missing Primary Address ===');
+
+  try {
+    const membersQuery = await wixData
+      .query(COLLECTIONS.MEMBERS_DATA)
+      .isNotEmpty('addresses')
+      .limit(1000);
+    const members = await queryAllItems(membersQuery);
+    console.log(`Fetched ${members.length} members with addresses`);
+
+    const membersToFix = members.filter(member => {
+      const addresses = Array.isArray(member.addresses) ? member.addresses : [];
+      if (addresses.length === 0) {
+        return false;
+      }
+      return !hasPrimaryAddress(member.addressDisplayOption);
+    });
+
+    const memberIds = [
+      ...new Set(
+        membersToFix
+          .map(member => Number(member.memberId))
+          .filter(memberId => Number.isFinite(memberId) && memberId > 0)
+      ),
+    ];
+
+    const result = {
+      success: true,
+      totalMembers: memberIds.length,
+      sampleMemberIds: memberIds.slice(0, 20),
+    };
+
+    console.log(JSON.stringify(result, null, 2));
+    return result;
+  } catch (error) {
+    console.error('Error counting members missing primary address:', error);
+    throw error;
+  }
+}
+
+module.exports = {
+  scheduleFixPrimaryAddressForMembers,
+  fixPrimaryAddressChunk,
+  countMembersMissingPrimaryAddress,
+};