abmp-npm 2.0.73 → 2.0.74

package/.claude/worktrees/fix-save-button-disable/.husky/pre-commit

@@ -0,0 +1,19 @@
+echo "Running ESLint check..."
+npm run lint
+
+if [ $? -ne 0 ]; then
+  echo "❌ ESLint check failed. Please fix the linting errors before committing."
+  exit 1
+fi
+
+echo "Running Prettier check..."
+npm run format:check
+
+if [ $? -ne 0 ]; then
+  echo "❌ Prettier check failed. Please format your code before committing."
+  echo "Run 'npm run format' to automatically format your files."
+  exit 1
+fi
+
+echo "✅ All checks passed!"
+

package/.claude/worktrees/fix-save-button-disable/.prettierignore

@@ -0,0 +1,7 @@
+node_modules
+dist
+build
+coverage
+*.min.js
+package-lock.json
+

package/.claude/worktrees/fix-save-button-disable/.prettierrc.json

@@ -0,0 +1,16 @@
+{
+  "singleQuote": true,
+  "trailingComma": "es5",
+  "printWidth": 100,
+  "tabWidth": 2,
+  "semi": true,
+  "bracketSpacing": true,
+  "bracketSameLine": false,
+  "arrowParens": "avoid",
+  "endOfLine": "lf",
+  "quoteProps": "as-needed",
+  "jsxSingleQuote": false,
+  "requirePragma": false,
+  "insertPragma": false,
+  "proseWrap": "preserve"
+}

package/.claude/worktrees/fix-save-button-disable/README.md

@@ -0,0 +1 @@
+# abmp-npm

package/.claude/worktrees/fix-save-button-disable/backend/README-member-contact-flows.md

@@ -0,0 +1,136 @@
+# Member–Contact Flows
+
+How Wix **Members** (login identity) and **CRM Contacts** (form/submission identity) stay in sync in ABMP.
+
+## Concepts
+
+| Concept                | Meaning                                                                                                    |
+| ---------------------- | ---------------------------------------------------------------------------------------------------------- |
+| **Single entity**      | Member and contact use the same Wix ID (`wixContactId === wixMemberId`). One person, one record.           |
+| **Separate contact**   | Member has a login email; contact has a different “form” email. Two Wix entities: one Member, one Contact. |
+| **Login email**        | `memberData.email` — used to sign in (Wix Member).                                                         |
+| **Contact form email** | `memberData.contactFormEmail` — email used on forms; can differ from login.                                |
+
+---
+
+## 1. Login / first-time flow: `createContactAndMemberIfNew`
+
+**Used when:** A user logs in or is created and we need to ensure they have both a Wix Member and (if needed) a CRM Contact.
+
+**File:** `members-data-methods.js` → `createContactAndMemberIfNew(memberData)`
+
+### Logic in short
+
+- If no **Wix Member** → create one (login identity).
+- If no **Wix Contact** and contact form email **differs** from login email → create a separate Contact.
+- If contact form email **equals** login email → no separate contact; we use the member ID as the contact ID (single entity).
+- Persist `wixMemberId` and `wixContactId` on the member record.
+
+### Flow diagram
+
+```mermaid
+flowchart TD
+    A[createContactAndMemberIfNew] --> B{Has wixMemberId?}
+    B -->|No| C[Create Wix Member]
+    B -->|Yes| D{Has wixContactId?}
+    C --> D
+    D -->|No| E{contactFormEmail !== email?}
+    D -->|Yes| K[Keep existing IDs]
+    E -->|Yes| F[Create Wix Contact]
+    E -->|No| G[Use member ID as contact ID]
+    F --> H[Resolve IDs]
+    G --> H
+    K --> H
+    H[newWixContactId = createdContact OR memberId] --> I[Set wixMemberId, wixContactId on member]
+    I --> J[updateMember + return]
+```
+
+### Parallel work
+
+```
+                    ┌─────────────────────────────────────┐
+                    │  createContactAndMemberIfNew         │
+                    └─────────────────────────────────────┘
+                                        │
+                    ┌───────────────────┴───────────────────┐
+                    │           Promise.all([              │
+                    │  runIf(needsWixMember, createMember),  │
+                    │  runIf(needsContact && differentEmail, │
+                    │        createContact)                 │
+                    │           ])                          │
+                    └───────────────────┬───────────────────┘
+                                        │
+          newWixContactId = createdWixContactId || newWixMemberId
+          (if no separate contact, member ID is the contact ID)
+                                        │
+                    ┌───────────────────┴───────────────────┐
+                    │  updateMember({ ...memberData,        │
+                    │    wixMemberId, wixContactId })      │
+                    └───────────────────────────────────────┘
+```
+
+### Outcome
+
+| Scenario                                | wixMemberId   | wixContactId                        |
+| --------------------------------------- | ------------- | ----------------------------------- |
+| New user, same email for login and form | New member ID | Same as wixMemberId (single entity) |
+| New user, form email ≠ login email      | New member ID | New contact ID (separate contact)   |
+| Existing user (already has both IDs)    | Unchanged     | Unchanged                           |
+
+---
+
+## 2. Update contact email flow: `updateContactEmail`
+
+**Used when:** User changes their contact/form email in the app and we need to update CRM and optionally the member record.
+
+**File:** `member-contact-orchestration.js` → `updateContactEmail(newContactEmail, existingMemberData)` (used by `updateMemberContactInfo`).
+
+### Logic in short
+
+- **Single entity** (`wixContactId === wixMemberId`):
+  - If new email **equals** login → no change.
+  - If new email **differs** → create a new Contact with the new email and point the member to it (we now have a separate contact).
+- **Separate contact** (different IDs):
+  - If new email **equals** login → delete the extra contact and set `wixContactId = wixMemberId` (collapse to single entity).
+  - If new email **differs** → update the existing contact’s email in CRM.
+
+### Flow diagram
+
+```mermaid
+flowchart TD
+    A[updateContactEmail] --> B{contactEmail === loginEmail?}
+    B -->|Yes| C{Single entity?}
+    B -->|No| D{Single entity?}
+    C -->|Yes| E[No-op: already in sync]
+    C -->|No| F[Delete contact\nSet wixContactId = wixMemberId]
+    D -->|Yes| G[Create new Contact with new email\nUpdate member wixContactId]
+    D -->|No| H[Update existing contact email in CRM]
+```
+
+### Decision table
+
+| Single entity? | New email vs login | Action                                                            |
+| -------------- | ------------------ | ----------------------------------------------------------------- |
+| Yes            | Same               | No-op                                                             |
+| Yes            | Different          | Create new Contact; set member’s `wixContactId` to new contact ID |
+| No             | Same               | Delete Contact; set member’s `wixContactId = wixMemberId`         |
+| No             | Different          | Update existing Contact’s email in CRM (no member change)         |
+
+### Where it’s used
+
+`updateContactEmail` is called from `updateMemberContactInfo` when the **contactFormEmail** field changes (e.g. profile or form update). So:
+
+- **Login flow** → `createContactAndMemberIfNew` (ensure member + contact exist and IDs stored).
+- **Profile/form email change** → `updateMemberContactInfo` → `updateContactEmail` (keep contact and member in sync).
+
+---
+
+## File roles
+
+| File                              | Role                                                                                                                                |
+| --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| `contacts-methods.js`             | Contact CRUD only: create/update/delete contact in Wix CRM.                                                                         |
+| `member-contact-orchestration.js` | Orchestration: when to create/update/delete contact and when to update member’s `wixContactId`. Uses injected `updateMember`.       |
+| `members-data-methods.js`         | Member CRUD, `createContactAndMemberIfNew`; requires `updateMemberContactInfo` and calls `updateMember` once with its return value. |
+
+Dependency direction: **members-data** → **member-contact-orchestration** → **contacts** (no cycle).

package/.claude/worktrees/fix-save-button-disable/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/.claude/worktrees/fix-save-button-disable/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/.claude/worktrees/fix-save-button-disable/backend/__tests__/login-email-sync.test.js

@@ -0,0 +1,49 @@
+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

@@ -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]'
+    );
+  });
+});