abmp-npm 2.0.70 → 2.0.73

package/backend/__tests__/daily-pull-execution-check.test.js

@@ -0,0 +1,124 @@
+jest.mock('../elevated-modules', () => ({
+  wixData: { query: jest.fn() },
+}));
+jest.mock('psdev-task-manager', () => ({ taskManager: jest.fn() }));
+
+const { taskManager } = require('psdev-task-manager');
+
+const { buildDailyPullTasks } = require('../daily-pull/schedule-methods');
+const { wixData } = require('../elevated-modules');
+const { TASKS_NAMES } = require('../tasks/consts');
+const { dailyPullExecutionCheck } = require('../tasks/daily-pull-check-methods');
+
+const makeQueryResult = items => ({ items, hasNext: () => false });
+
+const mockTasksQuery = items => {
+  const query = {
+    hasSome: jest.fn().mockReturnThis(),
+    ge: jest.fn().mockReturnThis(),
+    find: jest.fn().mockResolvedValue(makeQueryResult(items)),
+  };
+  wixData.query.mockReturnValue(query);
+  return query;
+};
+
+describe('buildDailyPullTasks', () => {
+  test('schedules one ScheduleMembersDataPerAction task per action, excluding none by default', () => {
+    const tasks = buildDailyPullTasks();
+
+    expect(tasks.map(task => task.data.action).sort()).toEqual(['drop', 'new', 'update']);
+    tasks.forEach(task => {
+      expect(task.name).toBe(TASKS_NAMES.ScheduleMembersDataPerAction);
+      expect(task.type).toBe('scheduled');
+      expect(task.data).toEqual({ action: task.data.action });
+    });
+  });
+
+  test('includes the none action and flag when includeNone is set', () => {
+    const tasks = buildDailyPullTasks({ includeNone: true });
+
+    expect(tasks.map(task => task.data.action).sort()).toEqual(['drop', 'new', 'none', 'update']);
+    tasks.forEach(task => expect(task.data.includeNone).toBe(true));
+  });
+
+  test('propagates isTestEnvironment and backupDate to every task', () => {
+    const tasks = buildDailyPullTasks({ isTestEnvironment: true, backupDate: '2026-06-01' });
+
+    tasks.forEach(task => {
+      expect(task.data.isTestEnvironment).toBe(true);
+      expect(task.data.backupDate).toBe('2026-06-01');
+    });
+  });
+});
+
+describe('dailyPullExecutionCheck', () => {
+  let scheduleInBulk;
+
+  beforeEach(() => {
+    wixData.query.mockReset();
+    scheduleInBulk = jest.fn().mockResolvedValue(undefined);
+    taskManager.mockReturnValue({ scheduleInBulk });
+  });
+
+  test('counts the per-action tasks the cron creates as evidence the pull ran', async () => {
+    const query = mockTasksQuery([{ name: TASKS_NAMES.ScheduleMembersDataPerAction }]);
+
+    const result = await dailyPullExecutionCheck({});
+
+    expect(query.hasSome).toHaveBeenCalledWith('name', [
+      TASKS_NAMES.ScheduleMembersDataPerAction,
+      TASKS_NAMES.ScheduleDailyMembersDataSync,
+    ]);
+    expect(result.success).toBe(true);
+    expect(result.fallbackScheduled).toBeUndefined();
+    expect(scheduleInBulk).not.toHaveBeenCalled();
+  });
+
+  test('schedules the per-action fallback with environment flags when no pull is found', async () => {
+    mockTasksQuery([]);
+
+    const result = await dailyPullExecutionCheck({ isTestEnvironment: true, includeNone: true });
+
+    expect(result.success).toBe(false);
+    expect(result.fallbackScheduled).toBe(true);
+    expect(scheduleInBulk).toHaveBeenCalledTimes(1);
+    const scheduledTasks = scheduleInBulk.mock.calls[0][0];
+    expect(scheduledTasks.map(task => task.data.action).sort()).toEqual([
+      'drop',
+      'new',
+      'none',
+      'update',
+    ]);
+    scheduledTasks.forEach(task => {
+      expect(task.name).toBe(TASKS_NAMES.ScheduleMembersDataPerAction);
+      expect(task.data.isTestEnvironment).toBe(true);
+      expect(task.data.includeNone).toBe(true);
+    });
+  });
+
+  test('fallback defaults to production flags when no task data is provided', async () => {
+    mockTasksQuery([]);
+
+    await dailyPullExecutionCheck(undefined);
+
+    const scheduledTasks = scheduleInBulk.mock.calls[0][0];
+    expect(scheduledTasks.map(task => task.data.action).sort()).toEqual(['drop', 'new', 'update']);
+    scheduledTasks.forEach(task => {
+      expect(task.data.isTestEnvironment).toBeUndefined();
+      expect(task.data.includeNone).toBeUndefined();
+    });
+  });
+
+  test('uses the provided lookback window', async () => {
+    const query = mockTasksQuery([{ name: TASKS_NAMES.ScheduleDailyMembersDataSync }]);
+    const before = Date.now();
+
+    const result = await dailyPullExecutionCheck({ hoursBack: 12 });
+
+    const sinceDate = query.ge.mock.calls[0][1];
+    expect(query.ge).toHaveBeenCalledWith('_createdDate', expect.any(Date));
+    const expectedSince = before - 12 * 60 * 60 * 1000;
+    expect(Math.abs(sinceDate.getTime() - expectedSince)).toBeLessThan(5000);
+    expect(result.success).toBe(true);
+  });
+});

package/backend/__tests__/transient-retry-and-bulk-lookup.test.js

@@ -0,0 +1,129 @@
+jest.mock('../elevated-modules', () => ({
+  wixData: { query: jest.fn() },
+}));
+
+const { wixData } = require('../elevated-modules');
+const { findMembersByIds } = require('../members-data-methods');
+const { withTransientErrorRetry, isTransientNetworkError } = require('../utils');
+
+const makeQueryResult = items => ({ items, hasNext: () => false });
+
+const mockQueryReturning = find => {
+  const query = {
+    hasSome: jest.fn().mockReturnThis(),
+    limit: jest.fn().mockReturnThis(),
+    find,
+  };
+  wixData.query.mockReturnValue(query);
+  return query;
+};
+
+describe('isTransientNetworkError', () => {
+  test('matches undici "fetch failed" and common network error codes', () => {
+    expect(isTransientNetworkError(new Error('fetch failed'))).toBe(true);
+    expect(isTransientNetworkError({ message: 'request failed', code: 'ECONNRESET' })).toBe(true);
+    expect(
+      isTransientNetworkError({ message: 'fetch failed', cause: { code: 'UND_ERR_SOCKET' } })
+    ).toBe(true);
+  });
+
+  test('does not match application errors', () => {
+    expect(isTransientNetworkError(new Error('Multiple members found with memberId 1'))).toBe(
+      false
+    );
+    expect(isTransientNetworkError(new Error('WDE0025: validation failed'))).toBe(false);
+  });
+});
+
+describe('withTransientErrorRetry', () => {
+  test('retries transient failures and resolves with the eventual result', async () => {
+    const operation = jest
+      .fn()
+      .mockRejectedValueOnce(new Error('fetch failed'))
+      .mockResolvedValueOnce('ok');
+
+    await expect(withTransientErrorRetry(operation, { baseDelayMs: 1 })).resolves.toBe('ok');
+    expect(operation).toHaveBeenCalledTimes(2);
+  });
+
+  test('rethrows immediately on non-transient errors', async () => {
+    const operation = jest.fn().mockRejectedValue(new Error('validation failed'));
+
+    await expect(withTransientErrorRetry(operation, { baseDelayMs: 1 })).rejects.toThrow(
+      'validation failed'
+    );
+    expect(operation).toHaveBeenCalledTimes(1);
+  });
+
+  test('gives up after the configured number of retries', async () => {
+    const operation = jest.fn().mockRejectedValue(new Error('fetch failed'));
+
+    await expect(
+      withTransientErrorRetry(operation, { retries: 2, baseDelayMs: 1 })
+    ).rejects.toThrow('fetch failed');
+    expect(operation).toHaveBeenCalledTimes(3);
+  });
+});
+
+describe('findMembersByIds', () => {
+  beforeEach(() => {
+    wixData.query.mockReset();
+  });
+
+  test('returns a map of String(memberId) to member record', async () => {
+    mockQueryReturning(
+      jest.fn().mockResolvedValue(
+        makeQueryResult([
+          { _id: 'a', memberId: 1 },
+          { _id: 'b', memberId: 2 },
+        ])
+      )
+    );
+
+    const membersById = await findMembersByIds([1, 2, 3]);
+
+    expect(membersById.get('1')).toEqual({ _id: 'a', memberId: 1 });
+    expect(membersById.get('2')).toEqual({ _id: 'b', memberId: 2 });
+    expect(membersById.has('3')).toBe(false);
+  });
+
+  test('deduplicates input IDs and skips null/undefined before querying', async () => {
+    const query = mockQueryReturning(jest.fn().mockResolvedValue(makeQueryResult([])));
+
+    await findMembersByIds([1, 1, null, undefined, 2]);
+
+    expect(query.hasSome).toHaveBeenCalledWith('memberId', [1, 2]);
+  });
+
+  test('returns an empty map without querying when there are no IDs', async () => {
+    const membersById = await findMembersByIds([]);
+
+    expect(membersById.size).toBe(0);
+    expect(wixData.query).not.toHaveBeenCalled();
+  });
+
+  test('chunks large ID lists into multiple queries', async () => {
+    const query = mockQueryReturning(jest.fn().mockResolvedValue(makeQueryResult([])));
+    const ids = Array.from({ length: 250 }, (_, i) => i + 1);
+
+    await findMembersByIds(ids);
+
+    expect(query.hasSome).toHaveBeenCalledTimes(3);
+    expect(query.hasSome.mock.calls.map(call => call[1].length)).toEqual([100, 100, 50]);
+  });
+
+  test('throws when multiple records share the same memberId', async () => {
+    mockQueryReturning(
+      jest.fn().mockResolvedValue(
+        makeQueryResult([
+          { _id: 'a', memberId: 1 },
+          { _id: 'b', memberId: 1 },
+        ])
+      )
+    );
+
+    await expect(findMembersByIds([1])).rejects.toThrow(
+      'Multiple members found with memberId(s): [1]'
+    );
+  });
+});

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

@@ -1,4 +1,4 @@
-const { bulkSaveMembers, getMemberBySlug } = require('../members-data-methods');
+const { bulkSaveMembers, getMemberBySlug, findMembersByIds } = require('../members-data-methods');
 const { extractUrlCounter } = require('../utils');
 
 const { generateUpdatedMemberData } = require('./process-member-methods');
@@ -132,10 +132,18 @@ const bulkProcessAndSaveMemberData = async ({ memberDataList, currentPageNumber
   const startTime = Date.now();
 
   try {
+    // Prefetch all existing members for this page in a few chunked queries instead of
+    // one query per member — thousands of parallel lookups made the whole page fail
+    // whenever a single one hit a transient network error.
+    const existingMembersById = await findMembersByIds(
+      memberDataList.map(memberData => memberData?.memberid)
+    );
+
     const processedMemberDataPromises = memberDataList.map(memberData =>
       generateUpdatedMemberData({
         inputMemberData: memberData,
         currentPageNumber,
+        existingDbMember: existingMembersById.get(String(memberData?.memberid)) ?? null,
       })
     );
 

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

@@ -58,16 +58,26 @@ const ensureUniqueUrl = async ({ url, memberId, fullName }) => {
  * @param {Object} options - The options object
  * @param {Object} options.inputMemberData - Raw member data from API
  * @param {number} options.currentPageNumber - Current page number being processed
+ * @param {Object|null} [options.existingDbMember] - Prefetched DB member (null if none exists).
+ *   Pass it when processing members in bulk to avoid one DB query per member; when omitted,
+ *   the member is looked up individually.
  * @returns {Promise<Object|null>} - Complete updated member data or null if validation fails
  */
-async function generateUpdatedMemberData({ inputMemberData, currentPageNumber }) {
+async function generateUpdatedMemberData({
+  inputMemberData,
+  currentPageNumber,
+  existingDbMember: prefetchedDbMember,
+}) {
   if (!validateCoreMemberData(inputMemberData)) {
     throw new Error(
       'Invalid member data: memberid, email (valid string), and memberships (array) are required'
     );
   }
 
-  const existingDbMember = await findMemberById(inputMemberData.memberid);
+  const existingDbMember =
+    prefetchedDbMember === undefined
+      ? await findMemberById(inputMemberData.memberid)
+      : prefetchedDbMember;
 
   const updatedMemberData = await createCoreMemberData(
     inputMemberData,

package/backend/daily-pull/schedule-methods.js

@@ -0,0 +1,41 @@
+const { taskManager } = require('psdev-task-manager');
+
+const { TASKS_NAMES } = require('../tasks/consts');
+
+const { MEMBER_ACTIONS } = require('./consts');
+
+/**
+ * Builds the per-action daily pull tasks. Single source of truth for what a
+ * "daily pull" schedules, shared by the cron job and the execution-check
+ * fallback so both produce identical tasks (same names, same environment flags).
+ * @param {Object} [options]
+ * @param {string} [options.backupDate] - Optional backup date (YYYY-MM-DD) to pull from the backup endpoint
+ * @param {boolean} [options.isTestEnvironment=false] - Whether to pull from the test PAC API
+ * @param {boolean} [options.includeNone=false] - Whether to also sync the NONE action
+ * @returns {Array<Object>} - Task definitions for taskManager().scheduleInBulk
+ */
+const buildDailyPullTasks = ({ backupDate, isTestEnvironment, includeNone } = {}) => {
+  const actionsToSync = includeNone
+    ? Object.values(MEMBER_ACTIONS)
+    : Object.values(MEMBER_ACTIONS).filter(action => action !== MEMBER_ACTIONS.NONE);
+  return actionsToSync.map(action => ({
+    name: TASKS_NAMES.ScheduleMembersDataPerAction,
+    data: {
+      action,
+      ...(backupDate ? { backupDate } : {}),
+      ...(isTestEnvironment ? { isTestEnvironment } : {}),
+      ...(includeNone ? { includeNone } : {}),
+    },
+    type: 'scheduled',
+  }));
+};
+
+/**
+ * Schedules the daily pull (one ScheduleMembersDataPerAction task per action).
+ * @param {Object} [options] - Same options as buildDailyPullTasks
+ * @returns {Promise<any>}
+ */
+const scheduleDailyPullTasks = options =>
+  taskManager().scheduleInBulk(buildDailyPullTasks(options));
+
+module.exports = { buildDailyPullTasks, scheduleDailyPullTasks };

package/backend/jobs.js

@@ -1,6 +1,6 @@
 const { taskManager } = require('psdev-task-manager');
 
-const { MEMBER_ACTIONS } = require('./daily-pull/consts');
+const { scheduleDailyPullTasks } = require('./daily-pull/schedule-methods');
 const { TASKS_NAMES } = require('./tasks/consts');
 const { dailyPullExecutionCheck } = require('./tasks/daily-pull-check-methods');
 const { TASKS } = require('./tasks/tasks-configs');
@@ -34,21 +34,7 @@ async function scheduleDailyPullTask(options = null) {
     console.log(`isTestEnvironment: ${isTestEnvironment}`);
     console.log(`includeNone: ${includeNone}`);
 
-    const actionsToSync = includeNone
-      ? Object.values(MEMBER_ACTIONS)
-      : Object.values(MEMBER_ACTIONS).filter(action => action !== MEMBER_ACTIONS.NONE);
-    const toScheduleTasks = actionsToSync.map(action => ({
-      name: TASKS_NAMES.ScheduleMembersDataPerAction,
-      data: {
-        action,
-        ...(backupDate ? { backupDate } : {}),
-        ...(isTestEnvironment ? { isTestEnvironment } : {}),
-        ...(includeNone ? { includeNone } : {}),
-      },
-      type: 'scheduled',
-    }));
-
-    return await taskManager().scheduleInBulk(toScheduleTasks);
+    return await scheduleDailyPullTasks({ backupDate, isTestEnvironment, includeNone });
   } catch (error) {
     console.error(`Failed to scheduleDailyPullTask: ${error.message}`);
     throw new Error(`Failed to scheduleDailyPullTask: ${error.message}`);
@@ -111,10 +97,36 @@ async function scheduleNormalizeMemberEmailsTask() {
   }
 }
 
-async function runDailyPullExecutionCheck() {
+/**
+ * Schedules setting ALL addresses for ALL members that have any address to STATE_CITY_ZIP
+ * (show city/state/zip, hide the street). Manually triggered one-off maintenance task.
+ */
+async function scheduleSetAddressesToCityStateTask() {
+  try {
+    console.log('scheduleSetAddressesToCityState started!');
+    return await taskManager().schedule({
+      name: TASKS_NAMES.scheduleSetAddressesToCityState,
+      data: {},
+      type: 'scheduled',
+    });
+  } catch (error) {
+    console.error(`Failed to scheduleSetAddressesToCityState: ${error.message}`);
+    throw new Error(`Failed to scheduleSetAddressesToCityState: ${error.message}`);
+  }
+}
+
+/**
+ * Runs the daily pull execution check (watchdog).
+ * @param {Object} [options]
+ * @param {number} [options.hoursBack=4] - Lookback window in hours
+ * @param {boolean} [options.isTestEnvironment=false] - Pull from the test PAC API if the fallback fires
+ * @param {boolean} [options.includeNone=false] - Include the NONE action if the fallback fires
+ * @returns {Promise<Object>} - Check result
+ */
+async function runDailyPullExecutionCheck(options = {}) {
   try {
     console.log('runDailyPullExecutionCheck started!');
-    return await dailyPullExecutionCheck({});
+    return await dailyPullExecutionCheck(options || {});
   } catch (error) {
     console.error(`Failed to runDailyPullExecutionCheck: ${error.message}`);
     throw new Error(`Failed to runDailyPullExecutionCheck: ${error.message}`);
@@ -141,5 +153,6 @@ module.exports = {
   scheduleFixPrimaryAddressForMembersTask,
   scheduleFixUrlsWithSpacesTask,
   scheduleNormalizeMemberEmailsTask,
+  scheduleSetAddressesToCityStateTask,
   runDailyPullExecutionCheck,
 };

package/backend/members-data-methods.js

@@ -15,6 +15,7 @@ const {
   generateGeoHash,
   searchAllItems,
   runIf,
+  withTransientErrorRetry,
 } = require('./utils');
 
 /**
@@ -158,11 +159,9 @@ async function findMemberById(memberId) {
   }
 
   try {
-    const queryResult = await wixData
-      .query(COLLECTIONS.MEMBERS_DATA)
-      .eq('memberId', memberId)
-      .limit(2)
-      .find();
+    const queryResult = await withTransientErrorRetry(() =>
+      wixData.query(COLLECTIONS.MEMBERS_DATA).eq('memberId', memberId).limit(2).find()
+    );
     if (queryResult.items.length > 1) {
       throw new Error(
         `Multiple members found with memberId ${memberId} members _ids are : [${queryResult.items.map(member => member._id).join(', ')}]`
@@ -175,6 +174,51 @@ async function findMemberById(memberId) {
   }
 }
 
+/**
+ * Retrieves existing members for a list of member IDs in bulk.
+ * Uses chunked `hasSome` queries so a full page of members costs a handful of
+ * requests instead of one query per member (the per-member fan-out made a whole
+ * page fail whenever a single query hit a transient "fetch failed").
+ * @param {Array<string|number>} memberIds - Member IDs to look up
+ * @returns {Promise<Map<string, Object>>} - Map of String(memberId) to member record (missing IDs are absent)
+ */
+async function findMembersByIds(memberIds) {
+  const uniqueIds = [...new Set((memberIds || []).filter(id => id !== undefined && id !== null))];
+  const membersById = new Map();
+  if (uniqueIds.length === 0) {
+    return membersById;
+  }
+
+  try {
+    const idChunks = chunkArray(uniqueIds, 100);
+    const chunkResults = await Promise.all(
+      idChunks.map(idsChunk =>
+        withTransientErrorRetry(() =>
+          queryAllItems(
+            wixData.query(COLLECTIONS.MEMBERS_DATA).hasSome('memberId', idsChunk).limit(1000)
+          )
+        )
+      )
+    );
+
+    const duplicateIds = new Set();
+    chunkResults.flat().forEach(member => {
+      const key = String(member.memberId);
+      if (membersById.has(key)) {
+        duplicateIds.add(key);
+      }
+      membersById.set(key, member);
+    });
+    if (duplicateIds.size > 0) {
+      throw new Error(`Multiple members found with memberId(s): [${[...duplicateIds].join(', ')}]`);
+    }
+    return membersById;
+  } catch (error) {
+    console.error('Error finding members by IDs:', error);
+    throw new Error(`Failed to retrieve member data: ${error.message}`);
+  }
+}
+
 /**
  * Method to get member by slug with flexible filtering options
  * @param {Object} options - Query options
@@ -723,6 +767,7 @@ module.exports = {
   saveRegistrationData,
   bulkSaveMembers,
   findMemberById,
+  findMembersByIds,
   getMemberBySlug,
   getCMSMemberByWixMemberId,
   getAllEmptyAboutYouMembers,

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

@@ -0,0 +1,160 @@
+const { taskManager } = require('psdev-task-manager');
+
+const { COLLECTIONS, ADDRESS_STATUS_TYPES } = 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;
+
+// Target visibility for every address: show city / state / zip, hide the street address.
+const TARGET_STATUS = ADDRESS_STATUS_TYPES.STATE_CITY_ZIP;
+
+const getMemberAddresses = member => (Array.isArray(member.addresses) ? member.addresses : []);
+
+/**
+ * Whether a member has at least one address not already at the target status.
+ * @param {Object} member
+ * @returns {boolean}
+ */
+const needsCityStateUpdate = member =>
+  getMemberAddresses(member).some(address => address && address.addressStatus !== TARGET_STATUS);
+
+/**
+ * Sets every address on a member to STATE_CITY_ZIP (other address fields are preserved).
+ * @param {Object} member
+ * @returns {Array} the member's addresses with addressStatus set to STATE_CITY_ZIP
+ */
+const setAddressesToCityState = member =>
+  getMemberAddresses(member).map(address => ({
+    ...address,
+    addressStatus: TARGET_STATUS,
+  }));
+
+/**
+ * Schedules tasks to set ALL addresses for ALL members to STATE_CITY_ZIP (show city/state/zip,
+ * hide the street). Manually triggered (not cron-wired).
+ */
+async function scheduleSetAddressesToCityState() {
+  console.log('=== Scheduling Set Addresses To City/State 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`);
+
+    // Only members that still have an address not at the target status need updating.
+    const memberIds = [
+      ...new Set(
+        members
+          .filter(needsCityStateUpdate)
+          .map(member => Number(member.memberId))
+          .filter(memberId => Number.isFinite(memberId) && memberId > 0)
+      ),
+    ];
+    console.log(`Members needing a city/state update: ${memberIds.length}`);
+
+    if (memberIds.length === 0) {
+      console.log('No members need their addresses set to city/state');
+      return {
+        success: true,
+        message: 'No members need their addresses set to city/state',
+        totalMembers: 0,
+        tasksScheduled: 0,
+      };
+    }
+
+    const chunks = chunkArray(memberIds, CHUNK_SIZE);
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      await taskManager().schedule({
+        name: TASKS_NAMES.setAddressesToCityStateChunk,
+        data: {
+          memberIds: chunk,
+          chunkIndex: i,
+          totalChunks: chunks.length,
+        },
+        type: 'scheduled',
+      });
+      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 set-addresses-to-city-state:', error);
+    throw error;
+  }
+}
+
+/**
+ * Processes a chunk of members and sets every address to STATE_CITY_ZIP.
+ * @param {Object} data
+ * @param {Array<number|string>} data.memberIds
+ * @param {number} data.chunkIndex
+ * @param {number} data.totalChunks
+ */
+async function setAddressesToCityStateChunk(data) {
+  const { memberIds, chunkIndex, totalChunks } = data;
+  console.log(
+    `Processing set-city-state 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.forEach(member => {
+      // Skip members that have no address or are already all at the target status.
+      if (!needsCityStateUpdate(member)) {
+        result.skipped++;
+        return;
+      }
+      membersToUpdate.push({
+        ...member,
+        addresses: setAddressesToCityState(member),
+      });
+    });
+
+    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(`✅ Set addresses to city/state for ${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 set-city-state chunk ${chunkIndex}:`, error);
+    throw error;
+  }
+}
+
+module.exports = {
+  scheduleSetAddressesToCityState,
+  setAddressesToCityStateChunk,
+};

package/backend/tasks/consts.js

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

package/backend/tasks/daily-pull-check-methods.js

@@ -1,6 +1,6 @@
-const { taskManager } = require('psdev-task-manager');
 const { COLLECTIONS } = require('psdev-task-manager/public/consts');
 
+const { scheduleDailyPullTasks } = require('../daily-pull/schedule-methods');
 const { wixData } = require('../elevated-modules');
 const { queryAllItems } = require('../utils');
 
@@ -8,43 +8,63 @@ const { TASKS_NAMES } = require('./consts');
 
 const DEFAULT_HOURS_BACK = 4;
 
+// The cron path (scheduleDailyPullTask) creates ScheduleMembersDataPerAction tasks
+// directly; ScheduleDailyMembersDataSync only exists when the pull is triggered via
+// the root task. Either one in the window is evidence the daily pull was scheduled.
+const DAILY_PULL_TASK_NAMES = [
+  TASKS_NAMES.ScheduleMembersDataPerAction,
+  TASKS_NAMES.ScheduleDailyMembersDataSync,
+];
+
 /**
- * Detects whether the daily pull was scheduled (cron / root task).
- * If no `ScheduleDailyMembersDataSync` task exists in the lookback window, schedules it.
+ * Detects whether the daily pull was scheduled in the lookback window.
+ * If no daily pull task exists, re-schedules the same per-action tasks the cron
+ * would have created, propagating the environment flags from the task data so a
+ * test site's fallback pulls from the test PAC API.
+ * @param {Object} [taskData]
+ * @param {number} [taskData.hoursBack=4] - Lookback window in hours
+ * @param {boolean} [taskData.isTestEnvironment=false] - Pull from the test PAC API on fallback
+ * @param {boolean} [taskData.includeNone=false] - Include the NONE action on fallback
+ * @returns {Promise<Object>} - Check result
  */
 async function dailyPullExecutionCheck(taskData) {
   const hoursBack =
     taskData?.hoursBack && Number.isFinite(taskData.hoursBack)
       ? taskData.hoursBack
       : DEFAULT_HOURS_BACK;
+  const isTestEnvironment = Boolean(taskData?.isTestEnvironment);
+  const includeNone = Boolean(taskData?.includeNone);
   const sinceDate = new Date(Date.now() - hoursBack * 60 * 60 * 1000);
 
-  console.log('dailyPullExecutionCheck started', { hoursBack, sinceDate });
+  console.log('dailyPullExecutionCheck started', {
+    hoursBack,
+    sinceDate,
+    isTestEnvironment,
+    includeNone,
+  });
 
-  const rootTasksQuery = wixData
+  const dailyPullTasksQuery = wixData
     .query(COLLECTIONS.TASKS)
-    .eq('name', TASKS_NAMES.ScheduleDailyMembersDataSync)
+    .hasSome('name', DAILY_PULL_TASK_NAMES)
     .ge('_createdDate', sinceDate);
 
-  const rootTasks = await queryAllItems(rootTasksQuery);
-  const rootTaskScheduled = rootTasks.length > 0;
+  const dailyPullTasks = await queryAllItems(dailyPullTasksQuery);
+  const dailyPullScheduled = dailyPullTasks.length > 0;
 
   const result = {
-    success: rootTaskScheduled,
+    success: dailyPullScheduled,
     sinceDate: sinceDate.toISOString(),
-    rootTaskName: TASKS_NAMES.ScheduleDailyMembersDataSync,
-    rootTasksFound: rootTasks.length,
+    checkedTaskNames: DAILY_PULL_TASK_NAMES,
+    dailyPullTasksFound: dailyPullTasks.length,
   };
 
-  if (!rootTaskScheduled) {
-    console.log('ScheduleDailyMembersDataSync missing in window; scheduling root daily pull', {
+  if (!dailyPullScheduled) {
+    console.log('No daily pull tasks found in window; re-scheduling per-action pull tasks', {
       hoursBack,
+      isTestEnvironment,
+      includeNone,
     });
-    await taskManager().schedule({
-      name: TASKS_NAMES.ScheduleDailyMembersDataSync,
-      data: {},
-      type: 'scheduled',
-    });
+    await scheduleDailyPullTasks({ isTestEnvironment, includeNone });
     result.fallbackScheduled = true;
   }
 

package/backend/tasks/tasks-configs.js

@@ -8,6 +8,10 @@ const {
   scheduleFixPrimaryAddressForMembers,
   fixPrimaryAddressChunk,
 } = require('./address-primary-methods');
+const {
+  scheduleSetAddressesToCityState,
+  setAddressesToCityStateChunk,
+} = require('./address-visibility-methods');
 const { TASKS_NAMES } = require('./consts');
 const { dailyPullExecutionCheck } = require('./daily-pull-check-methods');
 const {
@@ -207,6 +211,20 @@ const TASKS = {
     shouldSkipCheck: () => false,
     estimatedDurationSec: 80,
   },
+  [TASKS_NAMES.scheduleSetAddressesToCityState]: {
+    name: TASKS_NAMES.scheduleSetAddressesToCityState,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: scheduleSetAddressesToCityState,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
+  [TASKS_NAMES.setAddressesToCityStateChunk]: {
+    name: TASKS_NAMES.setAddressesToCityStateChunk,
+    getIdentifier: task => task.data,
+    process: setAddressesToCityStateChunk,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
   [TASKS_NAMES.scheduleNormalizeMemberEmails]: {
     name: TASKS_NAMES.scheduleNormalizeMemberEmails,
     getIdentifier: () => 'SHOULD_NEVER_SKIP',

package/backend/utils.js

@@ -210,6 +210,46 @@ function formatDateOnly(dateStr) {
 
 const runIf = (condition, asyncFn) => (condition ? asyncFn() : Promise.resolve(null));
 
+/**
+ * Whether an error looks like a transient network failure that is safe to retry,
+ * e.g. undici's generic "fetch failed" thrown by the Wix SDKs, connection resets
+ * or DNS hiccups under heavy load.
+ * @param {Error} error
+ * @returns {boolean}
+ */
+const isTransientNetworkError = error => {
+  const message = `${error?.message || ''} ${error?.cause?.message || ''} ${error?.code || ''} ${error?.cause?.code || ''}`;
+  return /fetch failed|ECONNRESET|ETIMEDOUT|ECONNREFUSED|EAI_AGAIN|EPIPE|UND_ERR|socket hang up|network error/i.test(
+    message
+  );
+};
+
+/**
+ * Runs an async operation, retrying with exponential backoff when it fails with a
+ * transient network error. Non-transient errors are rethrown immediately.
+ * @param {Function} operation - Async function to run
+ * @param {Object} [options]
+ * @param {number} [options.retries=2] - Maximum number of retries after the first attempt
+ * @param {number} [options.baseDelayMs=500] - Delay before the first retry, doubled each retry
+ * @returns {Promise<any>} - The operation's resolved value
+ */
+const withTransientErrorRetry = async (operation, { retries = 2, baseDelayMs = 500 } = {}) => {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (attempt >= retries || !isTransientNetworkError(error)) {
+        throw error;
+      }
+      const delayMs = baseDelayMs * 2 ** attempt;
+      console.warn(
+        `Transient network error (attempt ${attempt + 1}/${retries + 1}): ${error.message}. Retrying in ${delayMs}ms`
+      );
+      await new Promise(resolve => setTimeout(resolve, delayMs));
+    }
+  }
+};
+
 module.exports = {
   getSiteConfigs,
   retrieveAllItems,
@@ -232,4 +272,6 @@ module.exports = {
   isPAC_STAFF,
   searchAllItems,
   runIf,
+  isTransientNetworkError,
+  withTransientErrorRetry,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abmp-npm",
-  "version": "2.0.70",
+  "version": "2.0.73",
   "main": "index.js",
   "scripts": {
     "check-cycles": "madge --circular .",
@@ -49,6 +49,7 @@
     "axios": "^1.13.1",
     "crypto": "^1.0.1",
     "csv-parser": "^3.0.0",
+    "debug": "^4.4.3",
     "jwt-js-decode": "^1.9.0",
     "lodash": "^4.17.21",
     "ngeohash": "^0.6.3",

package/pages/personalDetails.js

@@ -975,31 +975,18 @@ async function personalDetailsOnReady({
     });
   }
 
-  async function handleItemDelete(event, getTextSelector, arrayRef, matchField, renderFn) {
-    const result = await wixWindow.openLightbox(LIGHTBOX_NAMES.DELETE_CONFIRM);
-
-    if (result && result.toDelete) {
-      const $clickedItem = _$w.at(event.context);
-      const textToRemove = $clickedItem(getTextSelector).text;
-
-      arrayRef.splice(
-        0,
-        arrayRef.length,
-        ...arrayRef.filter(item =>
-          typeof item === 'string' ? item !== textToRemove : item[matchField] !== textToRemove
-        )
-      );
-
-      renderFn();
-      checkFormChanges(FORM_SECTION_HANDLER_MAP.BUSINESS_SERVICES);
-    }
-  }
-
   async function setInterestData() {
     const interestsData = await getInterestAll();
 
-    _$w('#removeServiceButton').onClick(event => {
-      handleItemDelete(event, '#serviceNameText', selectedServices, 'label', renderServices);
+    _$w('#removeServiceButton').onClick(async event => {
+      const itemId = event.context.itemId;
+      const result = await wixWindow.openLightbox(LIGHTBOX_NAMES.DELETE_CONFIRM);
+
+      if (result && result.toDelete) {
+        selectedServices = selectedServices.filter(service => service._id !== itemId);
+        renderServices();
+        checkFormChanges(FORM_SECTION_HANDLER_MAP.BUSINESS_SERVICES);
+      }
     });
 
     if (Array.isArray(interestsData) && interestsData.length > 0) {
@@ -1077,7 +1064,7 @@ async function personalDetailsOnReady({
   }
 
   function renderServices() {
-    setupRepeater('#servicesRepeater', selectedServices);
+    setupRepeater('#servicesRepeater', [...selectedServices]);
   }
 
   function setupRepeater(repeaterId, data) {
@@ -1339,14 +1326,21 @@ async function personalDetailsOnReady({
     const addTestimonialButton = _$w('#addTestimonialButton');
 
     addTestimonialButton.onClick(handleAddTestimonial);
-    _$w('#deleteTestimonialButton').onClick(event => {
-      handleItemDelete(
-        event,
-        '#testimonialText',
-        itemMemberObj.testimonial,
-        null,
-        renderTestimonials
-      );
+    _$w('#deleteTestimonialButton').onClick(async event => {
+      const data = _$w('#testimonialRepeater').data || [];
+      const clickedIndex = data.findIndex(item => item._id === event.context.itemId);
+      const result = await wixWindow.openLightbox(LIGHTBOX_NAMES.DELETE_CONFIRM);
+
+      if (
+        result &&
+        result.toDelete &&
+        clickedIndex > 0 &&
+        Array.isArray(itemMemberObj.testimonial)
+      ) {
+        itemMemberObj.testimonial.splice(clickedIndex - 1, 1);
+        renderTestimonials();
+        checkFormChanges(FORM_SECTION_HANDLER_MAP.BUSINESS_SERVICES);
+      }
     });
 
     renderTestimonials();