abmp-npm 2.0.56 → 2.0.59

package/backend/__tests__/ensure-unique-urls-in-batch.test.js

@@ -0,0 +1,129 @@
+const { ensureUniqueUrlsInBatch } = require('../daily-pull/bulk-process-methods');
+const membersDataMethods = require('../members-data-methods');
+jest.mock('../members-data-methods');
+
+describe('ensureUniqueUrlsInBatch', () => {
+  beforeEach(() => {
+    membersDataMethods.getMemberBySlug.mockReset();
+  });
+
+  describe('case-insensitivity (regression: avoid creating John-12 AND john-12)', () => {
+    test('merges John-11 and john-11 into one group and assigns unique sequential URLs', async () => {
+      membersDataMethods.getMemberBySlug.mockResolvedValue({ url: 'John-11', memberId: 1 });
+
+      const members = [
+        { memberId: 101, url: 'John-11', fullName: 'John Doe' },
+        { memberId: 102, url: 'john-11', fullName: 'John Doe' },
+      ];
+
+      const result = await ensureUniqueUrlsInBatch(members);
+
+      const urls = result.map(m => m.url);
+
+      expect(urls).toHaveLength(2);
+      expect(new Set(urls).size).toBe(2);
+      expect(urls.some(u => u.endsWith('-12'))).toBe(true);
+      expect(urls.some(u => u.endsWith('-13'))).toBe(true);
+    });
+
+    test('does NOT create both John-12 and john-12 (case duplicate)', async () => {
+      membersDataMethods.getMemberBySlug.mockResolvedValue({ url: 'John-11', memberId: 1 });
+
+      const members = [
+        { memberId: 101, url: 'John-11' },
+        { memberId: 102, url: 'john-11' },
+      ];
+
+      const result = await ensureUniqueUrlsInBatch(members);
+      const urls = result.map(m => m.url);
+
+      const hasJohn12 = urls.some(u => u === 'John-12');
+      const hasjohn12 = urls.some(u => u === 'john-12');
+      expect(hasJohn12 && hasjohn12).toBe(false);
+    });
+
+    test('handles JOHN, John, john variants - all merge into single group', async () => {
+      membersDataMethods.getMemberBySlug.mockResolvedValue(null);
+
+      const members = [
+        { memberId: 101, url: 'JOHN-5' },
+        { memberId: 102, url: 'John-5' },
+        { memberId: 103, url: 'john-5' },
+      ];
+
+      const result = await ensureUniqueUrlsInBatch(members);
+      const urls = result.map(m => m.url);
+
+      expect(urls).toHaveLength(3);
+      expect(new Set(urls).size).toBe(3);
+      const bases = urls.map(u => u.replace(/-\d+$/, '').toLowerCase());
+      expect(new Set(bases).size).toBe(1);
+    });
+  });
+
+  describe('multiple members with same base URL', () => {
+    test('assigns sequential counters starting after batch max and DB max', async () => {
+      membersDataMethods.getMemberBySlug.mockResolvedValue({
+        url: 'firstNameLastName-11',
+        memberId: 1,
+      });
+
+      const members = [
+        { memberId: 201, url: 'firstNameLastName-11' },
+        { memberId: 202, url: 'firstNameLastName-11' },
+        { memberId: 203, url: 'firstNameLastName-11' },
+      ];
+
+      const result = await ensureUniqueUrlsInBatch(members);
+      const urls = result.map(m => m.url).sort();
+
+      expect(urls).toEqual([
+        'firstNameLastName-12',
+        'firstNameLastName-13',
+        'firstNameLastName-14',
+      ]);
+    });
+
+    test('uses batch max when DB has no matches', async () => {
+      membersDataMethods.getMemberBySlug.mockResolvedValue(null);
+
+      const members = [
+        { memberId: 301, url: 'testUser-5' },
+        { memberId: 302, url: 'testUser-5' },
+      ];
+
+      const result = await ensureUniqueUrlsInBatch(members);
+      const urls = result.map(m => m.url).sort();
+
+      expect(urls).toEqual(['testUser-6', 'testUser-7']);
+    });
+  });
+
+  describe('edge cases', () => {
+    test('returns empty array unchanged', async () => {
+      const result = await ensureUniqueUrlsInBatch([]);
+      expect(result).toEqual([]);
+    });
+
+    test('returns non-array unchanged', async () => {
+      const input = { not: 'array' };
+      const result = await ensureUniqueUrlsInBatch(input);
+      expect(result).toBe(input);
+    });
+
+    test('skips members without url', async () => {
+      membersDataMethods.getMemberBySlug.mockResolvedValue(null);
+
+      const members = [
+        { memberId: 401, url: 'validUrl' },
+        { memberId: 402, url: null },
+        { memberId: 403 },
+      ];
+
+      const result = await ensureUniqueUrlsInBatch(members);
+      expect(result).toHaveLength(3);
+      expect(result[0].url).toBe('validUrl');
+      expect(result[1].url).toBeNull();
+    });
+  });
+});

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

@@ -28,14 +28,13 @@ async function ensureUniqueUrlsInBatch(memberDataList) {
     const baseUrl = extractBaseUrl(member.url);
     const groupKey = baseUrl.toLowerCase();
     if (!urlGroups.has(groupKey)) {
-      urlGroups.set(groupKey, []);
+      urlGroups.set(groupKey, { members: [], baseUrl });
     }
-    urlGroups.get(groupKey).push(member);
+    urlGroups.get(groupKey).members.push(member);
   });
 
   // For each group, check database and assign unique URLs sequentially
-  for (const [groupKey, members] of urlGroups.entries()) {
-    const baseUrl = groupKey; // lowercase for consistent slug assignment
+  for (const [, { members, baseUrl }] of urlGroups.entries()) {
     if (members.length <= 1) {
       // Single member - still check DB to ensure it doesn't conflict with other pages
       const member = members[0];

package/backend/jobs.js

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

package/backend/tasks/consts.js

@@ -20,6 +20,8 @@ const TASKS_NAMES = {
   createContactsFromMembers: 'createContactsFromMembers',
   scheduleFixPrimaryAddressForMembers: 'scheduleFixPrimaryAddressForMembers',
   fixPrimaryAddressChunk: 'fixPrimaryAddressChunk',
+  scheduleFixUrlsWithSpaces: 'scheduleFixUrlsWithSpaces',
+  fixUrlsWithSpacesChunk: 'fixUrlsWithSpacesChunk',
 };
 
 module.exports = {

package/backend/tasks/index.js

@@ -5,4 +5,5 @@ module.exports = {
   ...require('./migration-methods'),
   ...require('./url-migration-methods'),
   ...require('./address-primary-methods'),
+  ...require('./url-space-fix-methods'),
 };

package/backend/tasks/tasks-configs.js

@@ -29,6 +29,7 @@ const {
   scheduleGenerateMissingUrls,
   generateUrlsChunk,
 } = require('./url-migration-methods');
+const { scheduleFixUrlsWithSpaces, fixUrlsWithSpacesChunk } = require('./url-space-fix-methods');
 
 const getDailyMembersDataSyncChildTasks = () => {
   // we don't want to sync none action as it means this members data hasn't changed and we don't need to sync it
@@ -187,6 +188,20 @@ const TASKS = {
     shouldSkipCheck: () => false,
     estimatedDurationSec: 80,
   },
+  [TASKS_NAMES.scheduleFixUrlsWithSpaces]: {
+    name: TASKS_NAMES.scheduleFixUrlsWithSpaces,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: scheduleFixUrlsWithSpaces,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
+  [TASKS_NAMES.fixUrlsWithSpacesChunk]: {
+    name: TASKS_NAMES.fixUrlsWithSpacesChunk,
+    getIdentifier: task => task.data,
+    process: fixUrlsWithSpacesChunk,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
 };
 
 module.exports = { TASKS };

package/backend/tasks/url-space-fix-methods.js

@@ -0,0 +1,174 @@
+const { taskManager } = require('psdev-task-manager');
+
+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, getMembersByIds } = require('../members-data-methods');
+const { queryAllItems, chunkArray } = require('../utils');
+
+const { TASKS_NAMES } = require('./consts');
+
+const CHUNK_SIZE = 1000;
+
+const hasSpace = value => typeof value === 'string' && /\s/.test(value);
+
+const normalizeSlug = value => (value || '').replace(/\s+/g, '').trim();
+
+/**
+ * Schedules tasks to fix member URLs that contain spaces.
+ */
+async function scheduleFixUrlsWithSpaces() {
+  console.log('=== Scheduling Fix URLs With Spaces ===');
+
+  try {
+    const membersQuery = await wixData
+      .query(COLLECTIONS.MEMBERS_DATA)
+      .contains('url', ' ')
+      .limit(1000);
+    const members = await queryAllItems(membersQuery);
+    console.log(`Fetched ${members.length} members with spaces in url`);
+
+    const memberIds = [
+      ...new Set(
+        members
+          .map(member => Number(member.memberId))
+          .filter(memberId => Number.isFinite(memberId) && memberId > 0)
+      ),
+    ];
+    console.log(`Members to fix: ${memberIds.length}`);
+
+    if (memberIds.length === 0) {
+      console.log('No members need URL space fixes');
+      return {
+        success: true,
+        message: 'No members need URL space 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.fixUrlsWithSpacesChunk,
+        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 URL space fixes:', error);
+    throw error;
+  }
+}
+
+/**
+ * Processes a chunk of members and fixes URLs with spaces.
+ */
+async function fixUrlsWithSpacesChunk(data) {
+  const { memberIds, chunkIndex, totalChunks } = data;
+  console.log(
+    `Processing URL space fix chunk ${chunkIndex + 1}/${totalChunks} (${memberIds.length} members)`
+  );
+
+  const result = {
+    successful: 0,
+    failed: 0,
+    skipped: 0,
+    errors: [],
+    skippedIds: [],
+    failedIds: [],
+  };
+  const updatedIds = [];
+
+  try {
+    const members = await getMembersByIds(memberIds);
+    console.log(`Loaded ${members.length} members for this chunk`);
+
+    const membersToUpdate = [];
+    for (const member of members) {
+      if (!hasSpace(member.url)) {
+        result.skipped++;
+        result.skippedIds.push(member.memberId);
+        continue;
+      }
+
+      const normalized = normalizeSlug(member.url);
+      const ensuredUrl = await ensureUniqueUrl({
+        url: normalized,
+        memberId: member.memberId,
+        fullName: member.fullName,
+      });
+
+      if (!ensuredUrl || ensuredUrl === member.url) {
+        result.skipped++;
+        result.skippedIds.push(member.memberId);
+        continue;
+      }
+
+      membersToUpdate.push({
+        ...member,
+        url: ensuredUrl,
+      });
+    }
+
+    if (membersToUpdate.length === 0) {
+      console.log('No members need updating in this batch');
+      return result;
+    }
+
+    const uniqueUpdates = await ensureUniqueUrlsInBatch(membersToUpdate);
+    uniqueUpdates.forEach(member => {
+      if (updatedIds.length < 20) {
+        updatedIds.push(member.memberId);
+      }
+    });
+
+    try {
+      await bulkSaveMembers(uniqueUpdates);
+      result.successful += uniqueUpdates.length;
+      console.log(`✅ Successfully updated ${uniqueUpdates.length} members`);
+      if (updatedIds.length > 0) {
+        console.log(`Updated memberIds (sample): ${updatedIds.join(', ')}`);
+      }
+    } catch (error) {
+      console.error('❌ Error bulk saving members:', error);
+      result.failed += uniqueUpdates.length;
+      result.failedIds.push(...uniqueUpdates.map(member => member.memberId));
+      result.errors.push({
+        error: error.message,
+        memberCount: uniqueUpdates.length,
+      });
+    }
+
+    return result;
+  } catch (error) {
+    console.error(`Error processing URL space fix chunk ${chunkIndex}:`, error);
+    throw error;
+  }
+}
+
+module.exports = {
+  scheduleFixUrlsWithSpaces,
+  fixUrlsWithSpacesChunk,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abmp-npm",
-  "version": "2.0.56",
+  "version": "2.0.59",
   "main": "index.js",
   "scripts": {
     "check-cycles": "madge --circular .",