abmp-npm 10.3.9 → 10.3.11

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/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/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/package.json

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