abmp-npm 2.0.76 → 2.0.78

package/.claude/worktrees/fix-save-button-disable/backend/__tests__/login-email-sync.test.js

@@ -1,49 +0,0 @@
-const { LOGIN_EMAIL_SYNC_STATUS } = require('../consts');
-const { summarizeLoginEmailOutcomes } = require('../daily-pull/utils');
-
-const { UPDATED, FAILED, SKIPPED } = LOGIN_EMAIL_SYNC_STATUS;
-
-describe('summarizeLoginEmailOutcomes', () => {
-  test('collects only FAILED outcomes as failures and failed ids', () => {
-    const outcomes = [
-      { memberId: 1, wixMemberId: 'w1', desiredEmail: 'a@x.com', status: UPDATED },
-      {
-        memberId: 2,
-        wixMemberId: 'w2',
-        desiredEmail: 'b@x.com',
-        status: FAILED,
-        error: 'duplicate',
-      },
-      { memberId: 3, status: SKIPPED, desiredEmail: 'c@x.com' },
-    ];
-
-    const { failedMemberIds, failures } = summarizeLoginEmailOutcomes(outcomes);
-
-    expect([...failedMemberIds]).toEqual([2]);
-    expect(failures).toEqual([
-      { memberId: 2, wixMemberId: 'w2', desiredEmail: 'b@x.com', error: 'duplicate' },
-    ]);
-  });
-
-  test('UPDATED and SKIPPED never produce failures (CMS email is left to advance/no-op)', () => {
-    const outcomes = [
-      { memberId: 1, status: UPDATED, desiredEmail: 'a@x.com' },
-      { memberId: 2, status: SKIPPED, desiredEmail: 'b@x.com' },
-    ];
-    const { failedMemberIds, failures } = summarizeLoginEmailOutcomes(outcomes);
-    expect(failedMemberIds.size).toBe(0);
-    expect(failures).toEqual([]);
-  });
-
-  test('defaults a missing error message', () => {
-    const { failures } = summarizeLoginEmailOutcomes([
-      { memberId: 9, wixMemberId: 'w9', desiredEmail: 'z@x.com', status: FAILED },
-    ]);
-    expect(failures[0].error).toBe('unknown error');
-  });
-
-  test('handles empty / missing input', () => {
-    expect(summarizeLoginEmailOutcomes([]).failures).toEqual([]);
-    expect(summarizeLoginEmailOutcomes().failures).toEqual([]);
-  });
-});

package/.claude/worktrees/fix-save-button-disable/backend/__tests__/transient-retry-and-bulk-lookup.test.js

@@ -1,129 +0,0 @@
-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/.claude/worktrees/fix-save-button-disable/backend/__tests__/url-uniqueness.test.js

@@ -1,194 +0,0 @@
-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/.claude/worktrees/fix-save-button-disable/backend/automations-methods.js

@@ -1,13 +0,0 @@
-const { customTrigger } = require('@wix/automations');
-const { auth } = require('@wix/essentials');
-const triggerMethod = auth.elevate(customTrigger.runTrigger);
-
-const triggerAutomation = async (triggerId, payload) =>
-  await triggerMethod({
-    triggerId,
-    payload,
-  });
-
-module.exports = {
-  triggerAutomation,
-};

package/.claude/worktrees/fix-save-button-disable/backend/cms-data-methods.js

@@ -1,251 +0,0 @@
-const geohash = require('ngeohash');
-
-const { COLLECTIONS, MEMBERS_FIELDS } = require('../public/consts.js');
-const { findMainAddress } = require('../public/Utils/sharedUtils.js');
-const { calculateDistance, shuffleArray } = require('../public/Utils/sharedUtils.js');
-
-const {
-  GEO_HASH_PRECISION,
-  MAX__MEMBERS_SEARCH_RESULTS,
-  WIX_QUERY_MAX_LIMIT,
-  MEMBERSHIPS_TYPES,
-} = require('./consts.js');
-const { wixData } = require('./elevated-modules');
-
-function buildMembersSearchQuery(data) {
-  console.log('data: ', JSON.stringify(data));
-  const { filter, isSearchingNearby, includeStudents = false } = data;
-  const isUserLocationEnabled = filter.latitude !== 0 || filter.longitude !== 0;
-  filter.searchText = filter.searchText || '';
-  filter.stateSearch = filter.stateSearch || '';
-  filter.practiceAreasSearch = filter.practiceAreasSearch || '';
-  filter.practiceAreas = filter.practiceAreas || [];
-  filter.state = filter.state || [];
-  filter.citySearch = filter.citySearch || '';
-  filter.city = filter.city || [];
-  filter.latitude = filter.latitude || 0;
-  filter.longitude = filter.longitude || 0;
-  filter.postalcode = filter.postalcode || '';
-  return {
-    get: () => {
-      let query = wixData
-        .query(COLLECTIONS.MEMBERS_DATA)
-        .ne('optOut', true)
-        .ne('action', 'drop')
-        .ne('memberships.membertype', MEMBERSHIPS_TYPES.PAC_STAFF)
-        .eq('isVisible', true);
-      let filterConfig = [
-        {
-          filterKey: 'practiceAreas',
-          queryMethod: 'hasSome',
-          queryField: 'areasOfPractices',
-          condition: value => value && value.length > 0,
-          fallback: {
-            filterKey: 'practiceAreasSearch',
-            queryMethod: 'contains',
-            queryField: 'areasOfPractices',
-            condition: value => value && value.trim() !== '',
-          },
-        },
-        {
-          filterKey: 'postalcode',
-          queryMethod: 'contains',
-          queryField: 'addresses.postalcode',
-          condition: value => value && value.trim() !== '',
-        },
-        {
-          filterKey: 'state',
-          queryMethod: 'hasSome',
-          queryField: 'addresses.state',
-          condition: value => value && value.length > 0,
-          fallback: {
-            filterKey: 'stateSearch',
-            queryMethod: 'contains',
-            queryField: 'addresses.state',
-            condition: value => value && value.trim() !== '',
-          },
-        },
-        {
-          filterKey: 'city',
-          queryMethod: 'hasSome',
-          queryField: 'addresses.city',
-          condition: value => value && value.length > 0,
-          fallback: {
-            filterKey: 'citySearch',
-            queryMethod: 'contains',
-            queryField: 'addresses.city',
-            condition: value => value && value.trim() !== '',
-          },
-        },
-      ];
-      //Ignore state, city and postal code when isSearchingNearby is true
-      if (isSearchingNearby) {
-        filterConfig = filterConfig.filter(
-          config => !['state', 'city', 'postalcode'].includes(config.filterKey)
-        );
-      }
-      const applyFilterToQuery = (query, config, filter) => {
-        const filterValue = filter[config.filterKey];
-        if (config.condition(filterValue)) {
-          return query[config.queryMethod](config.queryField, filterValue);
-        } else if (config.fallback) {
-          return applyFilterToQuery(query, config.fallback, filter);
-        }
-        return query;
-      };
-      // Apply filters using the configuration
-      filterConfig.forEach(config => {
-        query = applyFilterToQuery(query, config, filter);
-      });
-      if (isUserLocationEnabled && isSearchingNearby) {
-        const userGeohash = geohash.encode(filter.latitude, filter.longitude, GEO_HASH_PRECISION);
-        const neighborGeohashes = geohash.neighbors(userGeohash);
-        const geohashList = [userGeohash, ...neighborGeohashes];
-        query = query.hasSome('locHash', geohashList);
-      }
-      if (filter.searchText.trim() !== '') {
-        query = query.contains('fullName', filter.searchText);
-      }
-      if (!includeStudents) {
-        query = query.ne('memberships.membertype', MEMBERSHIPS_TYPES.STUDENT);
-      }
-      return query;
-    },
-    run: async query => {
-      const baseQuery = query.ascending('firstName').fields(...Object.values(MEMBERS_FIELDS));
-      const getRandomSkip = totalCount => {
-        let randomSkip = 0;
-        if (totalCount > MAX__MEMBERS_SEARCH_RESULTS) {
-          const maxSkip = totalCount - MAX__MEMBERS_SEARCH_RESULTS;
-          randomSkip = Math.floor(Math.random() * (maxSkip + 1));
-        }
-        return randomSkip;
-      };
-      const getResult = async query => {
-        if (isSearchingNearby) {
-          return fetchAllItemsInParallel(baseQuery);
-        }
-        const totalCount = await query.count();
-        const randomSkip = getRandomSkip(totalCount);
-        const result = await query
-          .skip(randomSkip)
-          .limit(MAX__MEMBERS_SEARCH_RESULTS)
-          .find({ omitTotalCount: true });
-
-        // Shuffle the result items for additional randomization
-        return {
-          ...result,
-          items: shuffleArray(result.items),
-        };
-      };
-
-      const result = await getResult(baseQuery);
-      if (isUserLocationEnabled) {
-        const withDistances = result.items.map(item => ({
-          ...item,
-          distance: calculateDistance(
-            {
-              latitude: filter.latitude,
-              longitude: filter.longitude,
-            },
-            findMainAddress(item.addressDisplayOption, item.addresses, {
-              requireValidCoordinates: true,
-            })
-          ),
-        }));
-        const resultWithDistances = {
-          ...result,
-          items: withDistances,
-        };
-        if (isSearchingNearby) {
-          return {
-            ...resultWithDistances,
-            items: withDistances
-              .filter(item => item.distance !== null)
-              .sort((a, b) => a.distance - b.distance)
-              .slice(0, MAX__MEMBERS_SEARCH_RESULTS),
-          };
-        }
-        return resultWithDistances;
-      }
-      return result;
-    },
-  };
-}
-
-// Generic parallel fetch function for large datasets
-async function fetchAllItemsInParallel(query) {
-  const batchSize = WIX_QUERY_MAX_LIMIT;
-  const allItems = [];
-
-  const firstResult = await query.skip(0).limit(batchSize).find();
-
-  const totalBatches = firstResult.totalPages;
-  allItems.push(...firstResult.items);
-
-  if (totalBatches > 1) {
-    // Create parallel promises for all remaining batches
-    const batchPromises = [];
-    for (let i = 1; i < totalBatches; i++) {
-      const skip = i * batchSize;
-      const promise = query
-        .skip(skip)
-        .limit(batchSize)
-        .find()
-        .then(result => result.items);
-      batchPromises.push(promise);
-    }
-
-    // Execute all batches in parallel
-    const batchResults = await Promise.all(batchPromises);
-    for (const items of batchResults) {
-      if (items.length > 0) {
-        allItems.push(...items);
-      }
-    }
-  }
-
-  return {
-    ...firstResult,
-    items: allItems,
-  };
-}
-
-/**
- * Get all interests from the database
- * @returns {Promise<Array<string>>} Array of interest titles sorted alphabetically
- */
-async function getInterestAll() {
-  try {
-    let res = await wixData.query(COLLECTIONS.INTERESTS).limit(1000).find();
-
-    let interests = res.items.map(x => x.title);
-
-    while (res.hasNext()) {
-      res = await res.next();
-      interests.push(...res.items.map(x => x.title));
-    }
-
-    // Sort the interests alphabetically (case-insensitive)
-    interests = interests.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
-
-    return interests;
-  } catch (e) {
-    console.error('Error in getInterestAll:', e);
-    throw e;
-  }
-}
-async function clearCollection(collectionName) {
-  try {
-    await wixData.truncate(collectionName);
-  } catch (err) {
-    throw new Error(`Failed to clearCollection ${collectionName} with error: ${err.message}`);
-  }
-}
-
-module.exports = {
-  buildMembersSearchQuery,
-  fetchAllItemsInParallel,
-  getInterestAll,
-  clearCollection,
-};

package/.claude/worktrees/fix-save-button-disable/backend/consts.js

@@ -1,58 +0,0 @@
-const PAC_API_URL = 'https://members.abmp.com/eweb/api/Wix';
-const TEST_PAC_API_URL = 'https://members-test.abmp.com/eweb/api/Wix';
-const BACKUP_API_URL = 'https://psdevteamenterpris.wixstudio.com/abmp-backup/_functions';
-const SSO_TOKEN_AUTH_API_URL = 'https://members.professionalassistcorp.com/';
-
-/**
- * Valid configuration keys for getSiteConfigs function
- * @readonly
- * @enum {string}
- */
-const CONFIG_KEYS = {
-  AUTOMATION_EMAIL_TRIGGER_ID: 'AUTOMATION_EMAIL_TRIGGER_ID',
-  SITE_ASSOCIATION: 'SITE_ASSOCIATION',
-  DEFAULT_PROFILE_SEO_DESCRIPTION: 'DEFAULT_PROFILE_SEO_DESCRIPTION',
-  INTERESTS_API_URL: 'INTERESTS_API_URL',
-  SITE_LOGO_URL: 'SITE_LOGO_URL',
-  MEMBERS_EXTERNAL_PORTAL_URL: 'MEMBERS_EXTERNAL_PORTAL_URL',
-  DEFAULT_PROFILE_IMAGE: 'DEFAULT_PROFILE_IMAGE',
-  QA_ALLOW_ANY_MEMBER: 'QA_ALLOW_ANY_MEMBER',
-};
-
-const MAX__MEMBERS_SEARCH_RESULTS = 120;
-const WIX_QUERY_MAX_LIMIT = 1000;
-
-const GEO_HASH_PRECISION = 3;
-
-const COMPILED_FILTERS_FIELDS = {
-  COMPILED_STATE_LIST: 'COMPILED_STATE_LIST',
-  COMPILED_AREAS_OF_PRACTICES: 'COMPILED_AREAS_OF_PRACTICES',
-  COMPILED_STATE_CITY_MAP: 'COMPILED_STATE_CITY_MAP',
-};
-const MEMBERSHIPS_TYPES = {
-  STUDENT: 'Student',
-  PAC_STAFF: 'PAC STAFF',
-};
-
-/**
- * Possible outcomes of attempting to change a Wix member's login email during the sync.
- */
-const LOGIN_EMAIL_SYNC_STATUS = {
-  UPDATED: 'updated', // Wix login email successfully changed to the desired email
-  FAILED: 'failed', // change failed -> keep the CMS login email unchanged and report for manual handling
-  SKIPPED: 'skipped', // member has no wixMemberId, nothing to change
-};
-
-module.exports = {
-  CONFIG_KEYS,
-  MAX__MEMBERS_SEARCH_RESULTS,
-  WIX_QUERY_MAX_LIMIT,
-  GEO_HASH_PRECISION,
-  PAC_API_URL,
-  TEST_PAC_API_URL,
-  COMPILED_FILTERS_FIELDS,
-  MEMBERSHIPS_TYPES,
-  SSO_TOKEN_AUTH_API_URL,
-  BACKUP_API_URL,
-  LOGIN_EMAIL_SYNC_STATUS,
-};