abmp-npm 10.0.55 → 10.0.57

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/cms-data-methods.js

@@ -148,7 +148,9 @@ function buildMembersSearchQuery(data) {
               latitude: filter.latitude,
               longitude: filter.longitude,
             },
-            findMainAddress(item.addressDisplayOption, item.addresses)
+            findMainAddress(item.addressDisplayOption, item.addresses, {
+              requireValidCoordinates: true,
+            })
           ),
         }));
         const resultWithDistances = {

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
@@ -20,7 +16,8 @@ async function ensureUniqueUrlsInBatch(memberDataList) {
     return memberDataList;
   }
 
-  // Group members by their normalized base URL
+  // Group members by their normalized base URL (case-insensitive to avoid
+  // "John-12" and "john-12" being treated as different when slugs are matched case-insensitively)
   const urlGroups = new Map();
 
   memberDataList.forEach(member => {
@@ -28,16 +25,17 @@ async function ensureUniqueUrlsInBatch(memberDataList) {
       return;
     }
 
-    // Extract the base URL (without any counter) for grouping
     const baseUrl = extractBaseUrl(member.url);
-    if (!urlGroups.has(baseUrl)) {
-      urlGroups.set(baseUrl, []);
+    const groupKey = baseUrl.toLowerCase();
+    if (!urlGroups.has(groupKey)) {
+      urlGroups.set(groupKey, []);
     }
-    urlGroups.get(baseUrl).push(member);
+    urlGroups.get(groupKey).push(member);
   });
 
   // For each group, check database and assign unique URLs sequentially
-  for (const [baseUrl, members] of urlGroups.entries()) {
+  for (const [groupKey, members] of urlGroups.entries()) {
+    const baseUrl = groupKey; // lowercase for consistent slug assignment
     if (members.length <= 1) {
       // Single member - still check DB to ensure it doesn't conflict with other pages
       const member = members[0];
@@ -80,14 +78,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

@@ -3,6 +3,7 @@ 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');
 
 /**
@@ -44,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}`);

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/dev-only-methods.js

@@ -1,6 +1,7 @@
 const { COLLECTIONS } = require('../public/consts');
 
 const { ensureUniqueUrlsInBatch } = require('./daily-pull/bulk-process-methods');
+const { ensureUniqueUrl } = require('./daily-pull/process-member-methods');
 const { wixData } = require('./elevated-modules');
 const { bulkSaveMembers } = require('./members-data-methods');
 const { queryAllItems } = require('./utils');
@@ -27,4 +28,31 @@ async function copyContactIdToWixMemberId() {
   return await bulkSaveMembers(updatedMembers, COLLECTIONS.MEMBERS_DATA);
 }
 
-module.exports = { deduplicateURls, copyContactIdToWixMemberId };
+async function createMissingUrls() {
+  const query = wixData.query(COLLECTIONS.MEMBERS_DATA).isEmpty('url');
+  const members = await queryAllItems(query);
+  console.log(
+    'membersWithoutUrls info',
+    JSON.stringify({
+      count: members.length,
+      membersIds: members.map(m => m.memberId),
+    })
+  );
+
+  const membersWithGeneratedUrlsPromises = members.map(async member => ({
+    ...member,
+    url: await ensureUniqueUrl({
+      url: member.url,
+      memberId: member.memberId,
+      fullName: member.fullName,
+    }),
+  }));
+  const membersWithGeneratedUrls = await Promise.all(membersWithGeneratedUrlsPromises);
+  //recheck urls in same batch to avoid duplicates
+  const uniqueUrlsUpdatedMembers = await ensureUniqueUrlsInBatch(membersWithGeneratedUrls);
+  const urls = uniqueUrlsUpdatedMembers.map(m => m.url).filter(Boolean);
+  console.log('unique urls', [...new Set(urls)]);
+  return await bulkSaveMembers(uniqueUrlsUpdatedMembers, COLLECTIONS.MEMBERS_DATA);
+}
+
+module.exports = { deduplicateURls, copyContactIdToWixMemberId, createMissingUrls };

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

package/backend/utils.js

@@ -164,6 +164,14 @@ const normalizeUrlForComparison = url => {
   return url.toLowerCase().replace(/-\d+$/, '');
 };
 
+const extractUrlCounter = url => {
+  if (!url) return -1;
+  const lastSegment = url.split('-').pop() || '0';
+  return /^\d+$/.test(lastSegment) ? parseInt(lastSegment, 10) : -1;
+};
+
+const sortByUrlCounterDescending = (a, b) => extractUrlCounter(b.url) - extractUrlCounter(a.url);
+
 async function getSecret(secretKey) {
   return (await elevatedGetSecretValue(secretKey)).value;
 }
@@ -209,6 +217,8 @@ module.exports = {
   generateGeoHash,
   isValidArray,
   normalizeUrlForComparison,
+  sortByUrlCounterDescending,
+  extractUrlCounter,
   queryAllItems,
   formatDateToMonthYear,
   isStudent,

package/dev-only-scripts/extract-duplicate-url-groups.js

@@ -0,0 +1,201 @@
+const fs = require('fs');
+const path = require('path');
+
+const csv = require('csv-parser');
+
+/**
+ * Reads a Members Data CSV and extracts groups of non-unique URLs:
+ * each group is a URL plus the list of IDs and memberIds that share that URL.
+ * Only outputs groups where the same URL appears more than once.
+ * Report includes duplicateUrls, memberIdsWithDuplicateUrls (flat array of unique memberIds
+ * in duplicate groups), and nonUniqueMemberIds (memberIds that appear more than once, with count).
+ *
+ * Usage: node dev-only-scripts/extract-duplicate-url-groups.js <path-to-csv> [output-json-path]
+ * Example: node dev-only-scripts/extract-duplicate-url-groups.js "/Users/Besan/Downloads/Members+Data+Latest (17).csv"
+ *
+ * CSV must have columns: "url", "ID", and "memberId" (case-insensitive).
+ */
+function extractDuplicateUrlGroups(csvFilePath, outputJsonPath) {
+  if (!csvFilePath) {
+    console.error('Error: CSV file path is required');
+    console.error(
+      'Usage: node dev-only-scripts/extract-duplicate-url-groups.js <path-to-csv> [output-json-path]'
+    );
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(csvFilePath)) {
+    console.error(`Error: File not found: ${csvFilePath}`);
+    process.exit(1);
+  }
+
+  const urlToRows = new Map(); // url -> [{ id, memberId }, ...]
+  let totalRows = 0;
+  let headersValidated = false;
+  let headers = null;
+  let urlColumnName = null;
+  let idColumnName = null;
+  let memberIdColumnName = null;
+
+  return new Promise((resolve, reject) => {
+    fs.createReadStream(csvFilePath)
+      .pipe(csv())
+      .on('headers', receivedHeaders => {
+        headers = receivedHeaders;
+        const normalizedHeaders = headers.map(h => {
+          const normalized = String(h).trim().replace(/["']/g, '');
+          return normalized.toLowerCase().trim();
+        });
+
+        const urlIndex = normalizedHeaders.indexOf('url');
+        const idIndex = normalizedHeaders.indexOf('id');
+        const memberIdIndex = normalizedHeaders.indexOf('memberid');
+
+        if (urlIndex === -1 || idIndex === -1 || memberIdIndex === -1) {
+          console.error(
+            'Error: CSV must contain "url", "ID", and "memberId" columns (case-insensitive)'
+          );
+          console.error(`Found columns: ${headers.join(', ')}`);
+          process.exit(1);
+        }
+
+        urlColumnName = headers[urlIndex];
+        idColumnName = headers[idIndex];
+        memberIdColumnName = headers[memberIdIndex];
+        headersValidated = true;
+      })
+      .on('data', row => {
+        if (!headersValidated) {
+          headers = Object.keys(row);
+          const normalizedHeaders = headers.map(h => {
+            const normalized = String(h).trim().replace(/["']/g, '');
+            return normalized.toLowerCase().trim();
+          });
+          const urlIndex = normalizedHeaders.indexOf('url');
+          const idIndex = normalizedHeaders.indexOf('id');
+          const memberIdIndex = normalizedHeaders.indexOf('memberid');
+          if (urlIndex === -1 || idIndex === -1 || memberIdIndex === -1) {
+            console.error(
+              'Error: CSV must contain "url", "ID", and "memberId" columns (case-insensitive)'
+            );
+            process.exit(1);
+          }
+          urlColumnName = headers[urlIndex];
+          idColumnName = headers[idIndex];
+          memberIdColumnName = headers[memberIdIndex];
+          headersValidated = true;
+        }
+
+        totalRows++;
+
+        const url = row[urlColumnName];
+        const id = row[idColumnName];
+        const memberId = row[memberIdColumnName];
+
+        if (!url || !id) {
+          return;
+        }
+
+        const trimmedUrl = url.trim();
+        const trimmedId = id.trim();
+        const trimmedMemberId =
+          memberId != null && String(memberId).trim() !== '' ? String(memberId).trim() : null;
+
+        if (!urlToRows.has(trimmedUrl)) {
+          urlToRows.set(trimmedUrl, []);
+        }
+        urlToRows.get(trimmedUrl).push({ id: trimmedId, memberId: trimmedMemberId });
+      })
+      .on('error', error => {
+        console.error('Error reading CSV file:', error.message);
+        reject(error);
+      })
+      .on('end', () => {
+        if (!headersValidated) {
+          console.error('Error: Could not read CSV headers');
+          process.exit(1);
+        }
+
+        const groups = [];
+        for (const [url, rows] of urlToRows.entries()) {
+          if (rows.length > 1) {
+            const ids = rows.map(r => r.id);
+            const memberIds = rows.map(r => r.memberId).filter(Boolean);
+            groups.push({ url, ids, memberIds });
+          }
+        }
+
+        groups.sort((a, b) => {
+          if (b.ids.length !== a.ids.length) return b.ids.length - a.ids.length;
+          return a.url.localeCompare(b.url);
+        });
+
+        const totalIdsInGroups = groups.reduce((sum, g) => sum + g.ids.length, 0);
+        const duplicateUrls = groups.map(g => g.url);
+        const allMemberIdOccurrences = groups.flatMap(g => g.memberIds);
+        const memberIdsWithDuplicateUrls = [...new Set(allMemberIdOccurrences)];
+
+        const memberIdCounts = new Map();
+        for (const memberId of allMemberIdOccurrences) {
+          memberIdCounts.set(memberId, (memberIdCounts.get(memberId) || 0) + 1);
+        }
+        const nonUniqueMemberIds = [...memberIdCounts.entries()]
+          .filter(([, count]) => count > 1)
+          .map(([memberId, count]) => ({ memberId, count }))
+          .sort((a, b) => b.count - a.count);
+
+        const report = {
+          totalRowsProcessed: totalRows,
+          totalDuplicateGroups: groups.length,
+          totalIdsInDuplicateGroups: totalIdsInGroups,
+          totalMemberIdOccurrencesInDuplicateGroups: allMemberIdOccurrences.length,
+          uniqueMemberIdsWithDuplicateUrls: memberIdsWithDuplicateUrls.length,
+          nonUniqueMemberIdsCount: nonUniqueMemberIds.length,
+          duplicateUrls,
+          memberIdsWithDuplicateUrls,
+          nonUniqueMemberIds,
+          groups,
+        };
+
+        if (outputJsonPath) {
+          fs.writeFileSync(outputJsonPath, JSON.stringify(report, null, 2), 'utf8');
+          console.log(`Report written to: ${outputJsonPath}`);
+        } else {
+          const csvDir = path.dirname(csvFilePath);
+          const csvBasename = path.basename(csvFilePath, path.extname(csvFilePath));
+          const defaultPath = path.join(csvDir, `${csvBasename}-duplicate-url-groups.json`);
+          fs.writeFileSync(defaultPath, JSON.stringify(report, null, 2), 'utf8');
+          console.log(`Report written to: ${defaultPath}`);
+        }
+
+        console.log('\n=== Non-unique URL groups (same URL → list of IDs, memberIds) ===');
+        console.log(`Total rows processed: ${totalRows}`);
+        console.log(`Number of duplicate URL groups: ${groups.length}`);
+        console.log(`Total IDs in those groups: ${totalIdsInGroups}`);
+        console.log(`Total memberId occurrences in those groups: ${allMemberIdOccurrences.length}`);
+        console.log(`Unique memberIds in those groups: ${memberIdsWithDuplicateUrls.length}`);
+        console.log(
+          `MemberIds that appear more than once (non-unique): ${nonUniqueMemberIds.length}`
+        );
+        if (duplicateUrls.length > 0) {
+          console.log('\nFirst 15 duplicate URLs:');
+          duplicateUrls.slice(0, 15).forEach((url, i) => {
+            console.log(`  ${i + 1}. ${url}`);
+          });
+        }
+
+        resolve(report);
+      });
+  });
+}
+
+if (require.main === module) {
+  const csvFilePath = process.argv[2];
+  const outputJsonPath = process.argv[3];
+  extractDuplicateUrlGroups(csvFilePath, outputJsonPath).catch(error => {
+    console.error('Fatal error:', error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = { extractDuplicateUrlGroups };

package/dev-only-scripts/find-duplicate-ids.js

@@ -0,0 +1,159 @@
+const fs = require('fs');
+const path = require('path');
+
+const csv = require('csv-parser');
+
+/**
+ * Reads a Members Data CSV and finds duplicate memberIds: any memberId (memberId column)
+ * that appears in more than one row. Outputs a JSON report with the list of
+ * duplicate memberIds and, per memberId, the rows (e.g. ID, url) where it appears.
+ *
+ * Usage: node dev-only-scripts/find-duplicate-ids.js <path-to-csv> [output-json-path]
+ *
+ * CSV must have a "memberId" column (case-insensitive). Optional: "ID", "url" for row details.
+ */
+function findDuplicateMemberIds(csvFilePath, outputJsonPath) {
+  if (!csvFilePath) {
+    console.error('Error: CSV file path is required');
+    console.error(
+      'Usage: node dev-only-scripts/find-duplicate-ids.js <path-to-csv> [output-json-path]'
+    );
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(csvFilePath)) {
+    console.error(`Error: File not found: ${csvFilePath}`);
+    process.exit(1);
+  }
+
+  const memberIdToRows = new Map(); // memberId -> [{ rowNumber, id?, url? }, ...]
+  let totalRows = 0;
+  let headersValidated = false;
+  let headers = null;
+  let memberIdColumnName = null;
+  let idColumnName = null;
+  let urlColumnName = null;
+
+  return new Promise((resolve, reject) => {
+    fs.createReadStream(csvFilePath)
+      .pipe(csv())
+      .on('headers', receivedHeaders => {
+        headers = receivedHeaders;
+        const normalizedHeaders = headers.map(h => {
+          const normalized = String(h).trim().replace(/["']/g, '');
+          return normalized.toLowerCase().trim();
+        });
+
+        const memberIdIndex = normalizedHeaders.indexOf('memberid');
+        if (memberIdIndex === -1) {
+          console.error('Error: CSV must contain a "memberId" column (case-insensitive)');
+          console.error(`Found columns: ${headers.join(', ')}`);
+          process.exit(1);
+        }
+
+        memberIdColumnName = headers[memberIdIndex];
+        idColumnName = headers[normalizedHeaders.indexOf('id')] || null;
+        urlColumnName = headers[normalizedHeaders.indexOf('url')] || null;
+        headersValidated = true;
+      })
+      .on('data', row => {
+        if (!headersValidated) {
+          headers = Object.keys(row);
+          const normalizedHeaders = headers.map(h => {
+            const normalized = String(h).trim().replace(/["']/g, '');
+            return normalized.toLowerCase().trim();
+          });
+          const memberIdIndex = normalizedHeaders.indexOf('memberid');
+          if (memberIdIndex === -1) {
+            console.error('Error: CSV must contain a "memberId" column (case-insensitive)');
+            process.exit(1);
+          }
+          memberIdColumnName = headers[memberIdIndex];
+          idColumnName = headers[normalizedHeaders.indexOf('id')] || null;
+          urlColumnName = headers[normalizedHeaders.indexOf('url')] || null;
+          headersValidated = true;
+        }
+
+        totalRows++;
+        const memberId = row[memberIdColumnName];
+        if (memberId == null || String(memberId).trim() === '') return;
+
+        const trimmedMemberId = String(memberId).trim();
+        const rowInfo = { rowNumber: totalRows };
+        if (idColumnName && row[idColumnName] != null)
+          rowInfo.id = String(row[idColumnName]).trim();
+        if (urlColumnName && row[urlColumnName] != null)
+          rowInfo.url = String(row[urlColumnName]).trim();
+
+        if (!memberIdToRows.has(trimmedMemberId)) {
+          memberIdToRows.set(trimmedMemberId, []);
+        }
+        memberIdToRows.get(trimmedMemberId).push(rowInfo);
+      })
+      .on('error', error => {
+        console.error('Error reading CSV file:', error.message);
+        reject(error);
+      })
+      .on('end', () => {
+        if (!headersValidated) {
+          console.error('Error: Could not read CSV headers');
+          process.exit(1);
+        }
+
+        const groups = [];
+        for (const [memberId, rows] of memberIdToRows.entries()) {
+          if (rows.length > 1) {
+            groups.push({ memberId, count: rows.length, rows });
+          }
+        }
+
+        groups.sort((a, b) => b.count - a.count);
+
+        const duplicateMemberIds = groups.map(g => g.memberId);
+        const totalDuplicateRows = groups.reduce((sum, g) => sum + g.count, 0);
+
+        const report = {
+          totalRowsProcessed: totalRows,
+          totalDuplicateMemberIds: groups.length,
+          totalRowsWithDuplicateMemberIds: totalDuplicateRows,
+          duplicateMemberIds,
+          groups,
+        };
+
+        if (outputJsonPath) {
+          fs.writeFileSync(outputJsonPath, JSON.stringify(report, null, 2), 'utf8');
+          console.log(`Report written to: ${outputJsonPath}`);
+        } else {
+          const csvDir = path.dirname(csvFilePath);
+          const csvBasename = path.basename(csvFilePath, path.extname(csvFilePath));
+          const defaultPath = path.join(csvDir, `${csvBasename}-duplicate-member-ids-report.json`);
+          fs.writeFileSync(defaultPath, JSON.stringify(report, null, 2), 'utf8');
+          console.log(`Report written to: ${defaultPath}`);
+        }
+
+        console.log('\n=== Duplicate memberIds Report ===');
+        console.log(`Total rows processed: ${totalRows}`);
+        console.log(`memberIds that appear more than once: ${groups.length}`);
+        console.log(`Total rows with those memberIds: ${totalDuplicateRows}`);
+        if (groups.length > 0) {
+          console.log('\nDuplicate memberIds (first 20):');
+          groups.slice(0, 20).forEach((g, i) => {
+            console.log(`  ${i + 1}. ${g.memberId} (${g.count} rows)`);
+          });
+        }
+
+        resolve(report);
+      });
+  });
+}
+
+if (require.main === module) {
+  const csvFilePath = process.argv[2];
+  const outputJsonPath = process.argv[3];
+  findDuplicateMemberIds(csvFilePath, outputJsonPath).catch(error => {
+    console.error('Fatal error:', error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = { findDuplicateMemberIds };

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "abmp-npm",
-  "version": "10.0.55",
+  "version": "10.0.57",
   "main": "index.js",
   "scripts": {
     "check-cycles": "madge --circular .",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest backend/__tests__",
     "lint": "npm run check-cycles && eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier --write \"**/*.{js,json,md}\"",
     "format:check": "prettier --check \"**/*.{js,json,md}\"",
     "prepare": "husky",
-    "find-duplicates": "node dev-only-scripts/find-duplicate-urls.js"
+    "find-duplicates": "node dev-only-scripts/find-duplicate-urls.js",
+    "extract-duplicate-url-groups": "node dev-only-scripts/extract-duplicate-url-groups.js",
+    "find-duplicate-ids": "node dev-only-scripts/find-duplicate-ids.js"
   },
   "author": "",
   "license": "ISC",
@@ -25,6 +27,7 @@
     "eslint-plugin-promise": "^7.1.0",
     "globals": "^15.10.0",
     "husky": "^9.1.6",
+    "jest": "^30.3.0",
     "madge": "^8.0.0",
     "prettier": "^3.3.3"
   },
@@ -45,9 +48,9 @@
     "aws4": "^1.13.2",
     "axios": "^1.13.1",
     "crypto": "^1.0.1",
+    "csv-parser": "^3.0.0",
     "jwt-js-decode": "^1.9.0",
     "lodash": "^4.17.21",
-    "csv-parser": "^3.0.0",
     "ngeohash": "^0.6.3",
     "phone": "^3.1.67",
     "psdev-task-manager": "1.1.10",

package/public/Utils/sharedUtils.js

@@ -66,20 +66,31 @@ function debouncedFunction({ func, debounceTimeout, timeoutType, args }) {
 
 const isValidLocation = location => location.latitude && location.longitude;
 
-function findMainAddress(addressDisplayOption = [], addresses = []) {
-  const options = Array.isArray(addressDisplayOption) ? addressDisplayOption : [];
-  const mainOpt = options.find(opt => opt.isMain);
+/**
+ * @param {Array} addressDisplayOption
+ * @param {Array} addresses
+ * @param {Object|boolean} [options] - Optional. Pass { requireValidCoordinates: true } for home search/distance; omit or false for profile display.
+ */
+function findMainAddress(addressDisplayOption = [], addresses = [], options = {}) {
+  const requireValidCoordinates =
+    typeof options === 'boolean' ? options : Boolean(options?.requireValidCoordinates);
+  const optionsArr = Array.isArray(addressDisplayOption) ? addressDisplayOption : [];
+  const mainOpt = optionsArr.find(opt => opt.isMain);
   if (mainOpt) {
     const mainAddr = addresses.find(
-      addr => addr.key === mainOpt.key && addr.addressStatus !== ADDRESS_STATUS_TYPES.DONT_SHOW
+      addr =>
+        addr.key === mainOpt.key &&
+        addr.addressStatus !== ADDRESS_STATUS_TYPES.DONT_SHOW &&
+        (!requireValidCoordinates || isValidLocation(addr))
     );
-    if (mainAddr && isValidLocation(mainAddr)) {
+    if (mainAddr) {
       return mainAddr;
     }
   }
-  // 2) fallback: if there is any visible address, use it
   const visibleAddresses = addresses.filter(
-    addr => addr.addressStatus !== ADDRESS_STATUS_TYPES.DONT_SHOW && isValidLocation(addr)
+    addr =>
+      addr.addressStatus !== ADDRESS_STATUS_TYPES.DONT_SHOW &&
+      (!requireValidCoordinates || isValidLocation(addr))
   );
   if (visibleAddresses.length) {
     return visibleAddresses[0];
@@ -107,8 +118,13 @@ function formatAddress(item) {
   return addressParts.filter(Boolean).join(', ');
 }
 
-function getMainAddress(addressDisplayOption = [], addresses = []) {
-  const mainAddr = findMainAddress(addressDisplayOption, addresses);
+/**
+ * @param {Array} addressDisplayOption
+ * @param {Array} addresses
+ * @param {Object|boolean} [options] - Optional. Pass { requireValidCoordinates: true } for home search/distance; omit or false for profile display.
+ */
+function getMainAddress(addressDisplayOption = [], addresses = [], options = {}) {
+  const mainAddr = findMainAddress(addressDisplayOption, addresses, options);
   if (mainAddr) {
     return formatAddress(mainAddr);
   }