abmp-npm 2.0.77 → 2.0.78

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

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

package/backend/__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/backend/__tests__/map-link.test.js

@@ -1,115 +0,0 @@
-const { ADDRESS_STATUS_TYPES } = require('../../public/consts');
-const { buildMapLink } = require('../../public/Utils/sharedUtils');
-
-// ─── Helpers ─────────────────────────────────────────────────────────
-
-const fullAddress = (overrides = {}) => ({
-  line1: '1366 4th Ave',
-  line2: '',
-  city: 'Coraopolis',
-  state: 'PA',
-  postalcode: '15108-1675',
-  latitude: 40.4129180908203,
-  longitude: -80.0293197631836,
-  addressStatus: ADDRESS_STATUS_TYPES.FULL_ADDRESS,
-  ...overrides,
-});
-
-const queryOf = url => decodeURIComponent((url.split('?q=')[1] || '').replace(/\+/g, ' '));
-
-// ─── Monday 12596102059 ──────────────────────────────────────────────
-// NetForum's address verifier returned coordinates ~10.8 miles from the real
-// address for member 1806273. The directions link should resolve from the
-// address text, which is correct, rather than from the coordinates.
-
-describe('buildMapLink - prefers the address over coordinates', () => {
-  it('builds the link from the street address, not the lat/long', () => {
-    const url = buildMapLink(fullAddress());
-
-    expect(url).toContain('maps.google.com');
-    expect(queryOf(url)).toBe('1366 4th Ave, Coraopolis, PA, 15108');
-  });
-
-  it('does not put the stored coordinates in the link when an address exists', () => {
-    const url = buildMapLink(fullAddress());
-
-    expect(url).not.toContain('40.4129');
-    expect(url).not.toContain('-80.0293');
-  });
-
-  it('still resolves correctly when the coordinates are wrong', () => {
-    // Coordinates deliberately far from the address - the link must ignore them.
-    const url = buildMapLink(fullAddress({ latitude: 0, longitude: 0 }));
-
-    expect(queryOf(url)).toBe('1366 4th Ave, Coraopolis, PA, 15108');
-  });
-
-  it('url-encodes the address so spaces do not break the link', () => {
-    const url = buildMapLink(fullAddress());
-
-    expect(url).not.toMatch(/\?q=.*\s/);
-  });
-});
-
-// ─── Privacy ─────────────────────────────────────────────────────────
-// formatAddress omits line1 for anything other than full_address. Callers gate
-// on full_address before showing the button, but the helper must not leak a
-// hidden street address even if it is called directly.
-
-describe('buildMapLink - does not leak a hidden street address', () => {
-  it('omits the street line for a state_city_zip address', () => {
-    const url = buildMapLink(fullAddress({ addressStatus: ADDRESS_STATUS_TYPES.STATE_CITY_ZIP }));
-
-    expect(url).not.toContain('4th');
-    expect(queryOf(url)).toBe('Coraopolis, PA, 15108');
-  });
-
-  it('falls back to coordinates rather than the street line for dont_show', () => {
-    const url = buildMapLink(fullAddress({ addressStatus: ADDRESS_STATUS_TYPES.DONT_SHOW }));
-
-    expect(url).not.toContain('4th');
-    expect(url).toBe('https://maps.google.com/?q=40.4129180908203,-80.0293197631836');
-  });
-
-  it('truncates the postal code to five digits', () => {
-    const url = buildMapLink(fullAddress());
-
-    expect(url).not.toContain('1675');
-  });
-});
-
-// ─── Fallbacks ───────────────────────────────────────────────────────
-
-describe('buildMapLink - fallbacks', () => {
-  it('uses coordinates when the address has no printable parts', () => {
-    const url = buildMapLink({
-      line1: '',
-      line2: '',
-      city: '',
-      state: '',
-      postalcode: '',
-      latitude: 40.5,
-      longitude: -80.1,
-      addressStatus: ADDRESS_STATUS_TYPES.FULL_ADDRESS,
-    });
-
-    expect(url).toBe('https://maps.google.com/?q=40.5,-80.1');
-  });
-
-  it('returns an empty string when there is neither an address nor coordinates', () => {
-    expect(
-      buildMapLink({
-        line1: '',
-        city: '',
-        state: '',
-        postalcode: '',
-        addressStatus: ADDRESS_STATUS_TYPES.FULL_ADDRESS,
-      })
-    ).toBe('');
-  });
-
-  it('returns an empty string for a missing address', () => {
-    expect(buildMapLink(null)).toBe('');
-    expect(buildMapLink(undefined)).toBe('');
-  });
-});

package/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/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/backend/__tests__/url-validation.test.js

@@ -1,69 +0,0 @@
-const { isNotValidUrl } = require('../../public/Utils/personalDetailsUtils');
-
-// ─── Helpers ─────────────────────────────────────────────────────────
-
-const isValid = url => !isNotValidUrl(url);
-
-// ─── Regression: digits in the hostname ──────────────────────────────
-// Monday bug 12663709539 - a member could not save the booking link
-// https://patty-10439.square.site because the host character class was
-// written `[da-z.-]` instead of `[\da-z.-]`, rejecting every domain
-// containing a digit.
-
-describe('isNotValidUrl - digits in hostname', () => {
-  it('accepts the exact URL from the bug report', () => {
-    expect(isValid('https://patty-10439.square.site')).toBe(true);
-  });
-
-  it.each([
-    'https://my-spa123.com',
-    'https://massage4u.net',
-    'https://booksy.com/en-us/698924_therapist_health-fitness_119607_city',
-    'https://www.genbook.com/bookings/slot/reservation/30241562?bookingSourceId=1000',
-    'www.spa2go.com',
-    'https://123.example.com',
-  ])('accepts %s', url => {
-    expect(isValid(url)).toBe(true);
-  });
-});
-
-describe('isNotValidUrl - case insensitivity', () => {
-  it.each(['https://Patty-10439.Square.Site', 'HTTPS://EXAMPLE.COM', 'WWW.Example.Com'])(
-    'accepts %s',
-    url => {
-      expect(isValid(url)).toBe(true);
-    }
-  );
-});
-
-// ─── Guard against regressions in the previously-working cases ───────
-
-describe('isNotValidUrl - previously valid URLs stay valid', () => {
-  it.each([
-    'https://square.site',
-    'https://patty.square.site',
-    'http://healinghut.massagetherapy.com',
-    'www.example.com',
-    'https://example.co.uk',
-    'https://example.com/path/to/page',
-    'https://example.com?foo=bar',
-    'https://example.com#anchor',
-  ])('accepts %s', url => {
-    expect(isValid(url)).toBe(true);
-  });
-});
-
-describe('isNotValidUrl - invalid input is still rejected', () => {
-  it.each(['not a url', 'example', 'ftp://example.com', 'justtext.c', 'http://'])(
-    'rejects %s',
-    url => {
-      expect(isValid(url)).toBe(false);
-    }
-  );
-
-  it('treats an empty value as valid because the field is optional', () => {
-    expect(isValid('')).toBe(true);
-    expect(isValid(undefined)).toBe(true);
-    expect(isValid(null)).toBe(true);
-  });
-});