@twentyhq/people-data-labs 1.0.0 → 1.0.2

package/src/logic-functions/utils/__tests__/build-matched-result.spec.ts

@@ -1,33 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { buildMatchedResult } from 'src/logic-functions/utils/build-matched-result';
-
-describe('buildMatchedResult', () => {
-  it('builds a MATCHED result summarizing the written fields', () => {
-    expect(
-      buildMatchedResult({ recordId: 'p1', updatedFields: ['name', 'jobTitle'] }),
-    ).toEqual({
-      success: true,
-      recordId: 'p1',
-      status: 'MATCHED',
-      updatedFields: ['name', 'jobTitle'],
-      data: undefined,
-      message: 'Enriched with People Data Labs (2 fields).',
-    });
-  });
-
-  it('carries the enriched data when provided', () => {
-    expect(
-      buildMatchedResult({
-        recordId: 'p1',
-        updatedFields: [],
-        data: { name: { firstName: 'Jane' } },
-      }),
-    ).toMatchObject({
-      status: 'MATCHED',
-      updatedFields: [],
-      data: { name: { firstName: 'Jane' } },
-      message: 'Matched People Data Labs data; no fields updated.',
-    });
-  });
-});

package/src/logic-functions/utils/__tests__/build-not-found-result.spec.ts

@@ -1,15 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { buildNotFoundResult } from 'src/logic-functions/utils/build-not-found-result';
-
-describe('buildNotFoundResult', () => {
-  it('builds a NOT_FOUND result', () => {
-    expect(buildNotFoundResult('p1')).toEqual({
-      success: true,
-      recordId: 'p1',
-      status: 'NOT_FOUND',
-      updatedFields: [],
-      message: 'People Data Labs returned no confident match.',
-    });
-  });
-});

package/src/logic-functions/utils/__tests__/build-person-matched-data.spec.ts

@@ -1,117 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { createCoreApiClientMock } from 'src/logic-functions/__mocks__/create-core-api-client-mock';
-import { PERSON_NODE_MOCK } from 'src/logic-functions/__mocks__/person-node.mock';
-import { buildPersonMatchedData } from 'src/logic-functions/utils/build-person-matched-data';
-
-const ENRICHED_AT = '2026-01-01T00:00:00.000Z';
-
-describe('buildPersonMatchedData', () => {
-  it('fills empty fields, writes pdl metadata, and skips company lookup when there is none', async () => {
-    const client = createCoreApiClientMock();
-
-    const { mappedData, persistData } = await buildPersonMatchedData({
-      client,
-      node: PERSON_NODE_MOCK,
-      outcome: {
-        likelihood: 8,
-        data: {
-          id: 'pdl1',
-          first_name: 'Jane',
-          last_name: 'Doe',
-          work_email: 'jane@acme.com',
-          job_title: 'CEO',
-        },
-      },
-      enrichedAt: ENRICHED_AT,
-      companyIdByMatchKeyCache: new Map(),
-      overrideExistingValues: false,
-      shouldPersist: true,
-    });
-
-    expect(persistData.name).toEqual({ firstName: 'Jane', lastName: 'Doe' });
-    expect(persistData.jobTitle).toBe('CEO');
-    expect(persistData.pdlLikelihood).toBe(8);
-    expect(persistData.pdlEnrichmentStatus).toBe('MATCHED');
-    expect(persistData.pdlLastEnrichedAt).toBe(ENRICHED_AT);
-    expect('companyId' in persistData).toBe(false);
-
-    expect(mappedData.name).toEqual({ firstName: 'Jane', lastName: 'Doe' });
-    expect(mappedData.jobTitle).toBe('CEO');
-    expect('pdlEnrichmentStatus' in mappedData).toBe(false);
-    expect('pdlRawPayload' in mappedData).toBe(false);
-  });
-
-  it('overwrites a populated standard field when overrideExistingValues is set', async () => {
-    const client = createCoreApiClientMock();
-
-    const { persistData } = await buildPersonMatchedData({
-      client,
-      node: { ...PERSON_NODE_MOCK, jobTitle: 'Existing Title' },
-      outcome: { likelihood: 8, data: { id: 'pdl1', job_title: 'CEO' } },
-      enrichedAt: ENRICHED_AT,
-      companyIdByMatchKeyCache: new Map(),
-      overrideExistingValues: true,
-      shouldPersist: true,
-    });
-
-    expect(persistData.jobTitle).toBe('CEO');
-  });
-
-  it('links a found-or-created company when the person has none', async () => {
-    const client = createCoreApiClientMock({
-      queryResult: { companies: { edges: [] } },
-      mutationResult: { createCompany: { id: 'co-new' } },
-    });
-
-    const { persistData } = await buildPersonMatchedData({
-      client,
-      node: PERSON_NODE_MOCK,
-      outcome: {
-        likelihood: 8,
-        data: {
-          id: 'pdl1',
-          work_email: 'jane@acme.com',
-          job_company_name: 'Acme',
-          job_company_website: 'acme.com',
-        },
-      },
-      enrichedAt: ENRICHED_AT,
-      companyIdByMatchKeyCache: new Map(),
-      overrideExistingValues: false,
-      shouldPersist: true,
-    });
-
-    expect(persistData.companyId).toBe('co-new');
-  });
-
-  it('returns mapped data with no persist data or company lookup when not persisting', async () => {
-    const client = createCoreApiClientMock({
-      queryResult: { companies: { edges: [] } },
-      mutationResult: { createCompany: { id: 'co-new' } },
-    });
-
-    const { mappedData, persistData } = await buildPersonMatchedData({
-      client,
-      node: PERSON_NODE_MOCK,
-      outcome: {
-        likelihood: 8,
-        data: {
-          id: 'pdl1',
-          first_name: 'Jane',
-          job_title: 'CEO',
-          job_company_name: 'Acme',
-          job_company_website: 'acme.com',
-        },
-      },
-      enrichedAt: ENRICHED_AT,
-      companyIdByMatchKeyCache: new Map(),
-      overrideExistingValues: false,
-      shouldPersist: false,
-    });
-
-    expect(mappedData.jobTitle).toBe('CEO');
-    expect(persistData).toEqual({});
-    expect(client.mutation).not.toHaveBeenCalled();
-  });
-});

package/src/logic-functions/utils/__tests__/build-person-name-param.spec.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { buildPersonNameParam } from 'src/logic-functions/utils/build-person-name-param';
-
-describe('buildPersonNameParam', () => {
-  it('joins a full first and last name', () => {
-    expect(buildPersonNameParam({ firstName: 'Jane', lastName: 'Doe' })).toBe(
-      'Jane Doe',
-    );
-  });
-
-  it('returns undefined unless both name parts are present', () => {
-    expect(buildPersonNameParam({ firstName: 'Jane', lastName: '' })).toBeUndefined();
-    expect(buildPersonNameParam({ firstName: '', lastName: 'Doe' })).toBeUndefined();
-    expect(buildPersonNameParam({ firstName: '', lastName: null })).toBeUndefined();
-  });
-});

package/src/logic-functions/utils/__tests__/build-phones.spec.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { buildPhones } from 'src/logic-functions/utils/build-phones';
-
-describe('buildPhones', () => {
-  it('uses the first present number as the primary phone', () => {
-    expect(buildPhones([null, '', '+15551234'])).toEqual({
-      primaryPhoneNumber: '+15551234',
-      primaryPhoneCountryCode: '',
-      primaryPhoneCallingCode: '',
-      additionalPhones: null,
-    });
-  });
-
-  it('keeps additional numbers and dedupes', () => {
-    expect(
-      buildPhones(['+15551234', '+15555678', '+15551234', '+15559999']),
-    ).toEqual({
-      primaryPhoneNumber: '+15551234',
-      primaryPhoneCountryCode: '',
-      primaryPhoneCallingCode: '',
-      additionalPhones: [
-        { number: '+15555678', countryCode: '', callingCode: '' },
-        { number: '+15559999', countryCode: '', callingCode: '' },
-      ],
-    });
-  });
-
-  it('returns undefined when there is no number', () => {
-    expect(buildPhones([null, undefined])).toBeUndefined();
-  });
-});

package/src/logic-functions/utils/__tests__/build-skipped-result.spec.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { buildSkippedResult } from 'src/logic-functions/utils/build-skipped-result';
-
-describe('buildSkippedResult', () => {
-  it('builds a successful skipped result with no updated fields', () => {
-    expect(
-      buildSkippedResult({ recordId: 'record-1', message: 'no identifier' }),
-    ).toEqual({
-      success: true,
-      recordId: 'record-1',
-      status: 'SKIPPED',
-      updatedFields: [],
-      message: 'no identifier',
-    });
-  });
-});

package/src/logic-functions/utils/__tests__/capitalize-name.spec.ts

@@ -1,26 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { capitalizeName } from 'src/logic-functions/utils/capitalize-name';
-
-describe('capitalizeName', () => {
-  it('capitalizes a lowercase single token', () => {
-    expect(capitalizeName('sean')).toBe('Sean');
-  });
-
-  it('capitalizes every whitespace-separated token', () => {
-    expect(capitalizeName('sean thorne')).toBe('Sean Thorne');
-  });
-
-  it('capitalizes after hyphens and apostrophes', () => {
-    expect(capitalizeName('mary-jane')).toBe('Mary-Jane');
-    expect(capitalizeName("o'brien")).toBe("O'Brien");
-  });
-
-  it('leaves already-capitalized names untouched', () => {
-    expect(capitalizeName('Jane Doe')).toBe('Jane Doe');
-  });
-
-  it('returns an empty string unchanged', () => {
-    expect(capitalizeName('')).toBe('');
-  });
-});

package/src/logic-functions/utils/__tests__/capitalize-name.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { capitalizeName } from 'src/logic-functions/utils/capitalize-name';
-
-describe('capitalizeName', () => {
-  it('should capitalize the first letter of each word', () => {
-    expect(capitalizeName('john doe')).toBe('John Doe');
-  });
-
-  it('should capitalize letters after hyphens and apostrophes', () => {
-    expect(capitalizeName("jean-luc o'brien")).toBe("Jean-Luc O'Brien");
-  });
-
-  it('should return an empty string unchanged', () => {
-    expect(capitalizeName('')).toBe('');
-  });
-});

package/src/logic-functions/utils/__tests__/charge-matched-enrichments.spec.ts

@@ -1,56 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { chargeCredits } from 'twenty-sdk/billing';
-
-import { COMPANY_MATCH_COST_DOLLARS } from 'src/constants/company-match-cost-dollars';
-import { PERSON_MATCH_COST_DOLLARS } from 'src/constants/person-match-cost-dollars';
-import { chargeMatchedEnrichments } from 'src/logic-functions/utils/charge-matched-enrichments';
-
-vi.mock('twenty-sdk/billing', () => ({
-  chargeCredits: vi.fn(async () => undefined),
-}));
-
-describe('chargeMatchedEnrichments', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('charges person matches at PDL list price plus margin', async () => {
-    await chargeMatchedEnrichments({
-      matchedCount: 3,
-      costPerMatchDollars: PERSON_MATCH_COST_DOLLARS,
-      resourceContext: 'pdl/person',
-    });
-
-    expect(chargeCredits).toHaveBeenCalledExactlyOnceWith({
-      creditsUsedMicro: 3 * 336_000,
-      operationType: 'CODE_EXECUTION',
-      quantity: 3,
-      resourceContext: 'pdl/person',
-    });
-  });
-
-  it('charges company matches at PDL list price plus margin', async () => {
-    await chargeMatchedEnrichments({
-      matchedCount: 2,
-      costPerMatchDollars: COMPANY_MATCH_COST_DOLLARS,
-      resourceContext: 'pdl/company',
-    });
-
-    expect(chargeCredits).toHaveBeenCalledExactlyOnceWith({
-      creditsUsedMicro: 2 * 120_000,
-      operationType: 'CODE_EXECUTION',
-      quantity: 2,
-      resourceContext: 'pdl/company',
-    });
-  });
-
-  it('does not charge when nothing matched', async () => {
-    await chargeMatchedEnrichments({
-      matchedCount: 0,
-      costPerMatchDollars: PERSON_MATCH_COST_DOLLARS,
-      resourceContext: 'pdl/person',
-    });
-
-    expect(chargeCredits).not.toHaveBeenCalled();
-  });
-});

package/src/logic-functions/utils/__tests__/chunk.spec.ts

@@ -1,25 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { chunk } from 'src/logic-functions/utils/chunk';
-
-describe('chunk', () => {
-  it('splits an array into chunks of the given size', () => {
-    expect(chunk({ items: [1, 2, 3, 4, 5], size: 2 })).toEqual([
-      [1, 2],
-      [3, 4],
-      [5],
-    ]);
-  });
-
-  it('returns a single chunk when the array is smaller than the size', () => {
-    expect(chunk({ items: [1, 2], size: 10 })).toEqual([[1, 2]]);
-  });
-
-  it('returns an empty array for empty input', () => {
-    expect(chunk({ items: [], size: 10 })).toEqual([]);
-  });
-
-  it('returns the whole array as one chunk for a non-positive size', () => {
-    expect(chunk({ items: [1, 2, 3], size: 0 })).toEqual([[1, 2, 3]]);
-  });
-});

package/src/logic-functions/utils/__tests__/enrich-companies.spec.ts

@@ -1,26 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { enrichCompanies } from 'src/logic-functions/utils/enrich-companies';
-import { postPdlBulkEnrich } from 'src/logic-functions/utils/post-pdl-enrich';
-
-vi.mock('src/logic-functions/utils/post-pdl-enrich', () => ({
-  postPdlBulkEnrich: vi.fn(() => Promise.resolve([])),
-}));
-
-const postPdlBulkEnrichMock = vi.mocked(postPdlBulkEnrich);
-
-describe('enrichCompanies', () => {
-  beforeEach(() => {
-    postPdlBulkEnrichMock.mockClear();
-  });
-
-  it('posts every record to the company bulk endpoint with only the provided params', async () => {
-    await enrichCompanies([{ website: 'acme.com' }, { pdlId: 'abc' }]);
-
-    expect(postPdlBulkEnrichMock).toHaveBeenCalledTimes(1);
-    expect(postPdlBulkEnrichMock).toHaveBeenCalledWith({
-      path: '/company/enrich/bulk',
-      requests: [{ website: 'acme.com' }, { pdl_id: 'abc' }],
-    });
-  });
-});

package/src/logic-functions/utils/__tests__/enrich-company.spec.ts

@@ -1,54 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { enrichCompany } from 'src/logic-functions/utils/enrich-company';
-import { postPdlSingleEnrich } from 'src/logic-functions/utils/post-pdl-single-enrich';
-
-vi.mock('src/logic-functions/utils/post-pdl-single-enrich', () => ({
-  postPdlSingleEnrich: vi.fn(() =>
-    Promise.resolve({ outcome: 'not_found', httpStatus: 404 }),
-  ),
-}));
-
-const postPdlSingleEnrichMock = vi.mocked(postPdlSingleEnrich);
-
-describe('enrichCompany', () => {
-  beforeEach(() => {
-    postPdlSingleEnrichMock.mockClear();
-  });
-
-  it('posts each record to the single company enrich endpoint with only the provided params', async () => {
-    await enrichCompany([{ website: 'acme.com' }, { pdlId: 'abc' }]);
-
-    expect(postPdlSingleEnrichMock).toHaveBeenCalledTimes(2);
-    expect(postPdlSingleEnrichMock).toHaveBeenNthCalledWith(1, {
-      path: '/company/enrich',
-      params: { website: 'acme.com' },
-    });
-    expect(postPdlSingleEnrichMock).toHaveBeenNthCalledWith(2, {
-      path: '/company/enrich',
-      params: { pdl_id: 'abc' },
-    });
-  });
-
-  it('forwards min_likelihood when provided', async () => {
-    await enrichCompany([{ name: 'Acme', minLikelihood: 2 }]);
-
-    expect(postPdlSingleEnrichMock).toHaveBeenCalledWith({
-      path: '/company/enrich',
-      params: { name: 'Acme', min_likelihood: 2 },
-    });
-  });
-
-  it('returns one outcome per request, preserving order', async () => {
-    postPdlSingleEnrichMock
-      .mockResolvedValueOnce({ outcome: 'matched', httpStatus: 200, data: { id: '1' } })
-      .mockResolvedValueOnce({ outcome: 'not_found', httpStatus: 404 });
-
-    const results = await enrichCompany([{ website: 'a.com' }, { website: 'b.com' }]);
-
-    expect(results).toEqual([
-      { outcome: 'matched', httpStatus: 200, data: { id: '1' } },
-      { outcome: 'not_found', httpStatus: 404 },
-    ]);
-  });
-});

package/src/logic-functions/utils/__tests__/enrich-people.spec.ts

@@ -1,32 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { enrichPeople } from 'src/logic-functions/utils/enrich-people';
-import { postPdlBulkEnrich } from 'src/logic-functions/utils/post-pdl-enrich';
-
-vi.mock('src/logic-functions/utils/post-pdl-enrich', () => ({
-  postPdlBulkEnrich: vi.fn(() => Promise.resolve([])),
-}));
-
-const postPdlBulkEnrichMock = vi.mocked(postPdlBulkEnrich);
-
-describe('enrichPeople', () => {
-  beforeEach(() => {
-    postPdlBulkEnrichMock.mockClear();
-  });
-
-  it('posts every record to the person bulk endpoint with only the provided params', async () => {
-    await enrichPeople([
-      { email: 'jane@acme.com', minLikelihood: 6 },
-      { pdlId: 'abc' },
-    ]);
-
-    expect(postPdlBulkEnrichMock).toHaveBeenCalledTimes(1);
-    expect(postPdlBulkEnrichMock).toHaveBeenCalledWith({
-      path: '/person/bulk',
-      requests: [
-        { email: 'jane@acme.com', min_likelihood: 6 },
-        { pdl_id: 'abc' },
-      ],
-    });
-  });
-});

package/src/logic-functions/utils/__tests__/enrich-person.spec.ts

@@ -1,62 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { enrichPerson } from 'src/logic-functions/utils/enrich-person';
-import { postPdlSingleEnrich } from 'src/logic-functions/utils/post-pdl-single-enrich';
-
-vi.mock('src/logic-functions/utils/post-pdl-single-enrich', () => ({
-  postPdlSingleEnrich: vi.fn(() =>
-    Promise.resolve({ outcome: 'not_found', httpStatus: 404 }),
-  ),
-}));
-
-const postPdlSingleEnrichMock = vi.mocked(postPdlSingleEnrich);
-
-describe('enrichPerson', () => {
-  beforeEach(() => {
-    postPdlSingleEnrichMock.mockClear();
-  });
-
-  it('posts each record to the single person enrich endpoint with only the provided params', async () => {
-    await enrichPerson([
-      { email: 'a@b.com' },
-      { pdlId: 'abc', name: 'Jane Doe', company: 'Acme' },
-    ]);
-
-    expect(postPdlSingleEnrichMock).toHaveBeenCalledTimes(2);
-    expect(postPdlSingleEnrichMock).toHaveBeenNthCalledWith(1, {
-      path: '/person/enrich',
-      params: { email: 'a@b.com' },
-    });
-    expect(postPdlSingleEnrichMock).toHaveBeenNthCalledWith(2, {
-      path: '/person/enrich',
-      params: { pdl_id: 'abc', name: 'Jane Doe', company: 'Acme' },
-    });
-  });
-
-  it('forwards min_likelihood when provided', async () => {
-    await enrichPerson([{ profile: 'linkedin.com/in/jane', minLikelihood: 6 }]);
-
-    expect(postPdlSingleEnrichMock).toHaveBeenCalledWith({
-      path: '/person/enrich',
-      params: { profile: 'linkedin.com/in/jane', min_likelihood: 6 },
-    });
-  });
-
-  it('returns one outcome per request, preserving order', async () => {
-    postPdlSingleEnrichMock
-      .mockResolvedValueOnce({
-        outcome: 'matched',
-        httpStatus: 200,
-        likelihood: 9,
-        data: { id: '1' },
-      })
-      .mockResolvedValueOnce({ outcome: 'not_found', httpStatus: 404 });
-
-    const results = await enrichPerson([{ email: 'a@b.com' }, { email: 'b@b.com' }]);
-
-    expect(results).toEqual([
-      { outcome: 'matched', httpStatus: 200, likelihood: 9, data: { id: '1' } },
-      { outcome: 'not_found', httpStatus: 404 },
-    ]);
-  });
-});

package/src/logic-functions/utils/__tests__/extract-company-match-params.spec.ts

@@ -1,86 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { COMPANY_NODE_MOCK } from 'src/logic-functions/__mocks__/company-node.mock';
-import { extractCompanyMatchParams } from 'src/logic-functions/utils/extract-company-match-params';
-
-const INPUT = { records: [] };
-
-describe('extractCompanyMatchParams', () => {
-  it('prefers an existing pdlId with the strong-identifier likelihood', () => {
-    expect(
-      extractCompanyMatchParams({
-        node: { ...COMPANY_NODE_MOCK, pdlId: 'pdl-c' },
-        input: INPUT,
-      }),
-    ).toEqual({ pdlId: 'pdl-c', minLikelihood: 2 });
-  });
-
-  it('uses the domain and name with the strong-identifier likelihood', () => {
-    expect(
-      extractCompanyMatchParams({
-        node: { ...COMPANY_NODE_MOCK, name: 'Acme' },
-        input: INPUT,
-      }),
-    ).toEqual({ website: 'acme.com', name: 'Acme', minLikelihood: 2 });
-  });
-
-  it('uses the linkedin profile as a strong identifier, stripped to the PDL path format', () => {
-    expect(
-      extractCompanyMatchParams({
-        node: {
-          ...COMPANY_NODE_MOCK,
-          domainName: null,
-          linkedinLink: {
-            primaryLinkUrl: 'https://www.linkedin.com/company/acme/',
-          },
-          name: 'Acme',
-        },
-        input: INPUT,
-      }),
-    ).toEqual({
-      profile: 'linkedin.com/company/acme',
-      name: 'Acme',
-      minLikelihood: 2,
-    });
-  });
-
-  it('strips the scheme and www from the website before matching', () => {
-    expect(
-      extractCompanyMatchParams({
-        node: {
-          ...COMPANY_NODE_MOCK,
-          domainName: { primaryLinkUrl: 'https://www.acme.com/' },
-          name: 'Acme',
-        },
-        input: INPUT,
-      }),
-    ).toEqual({ website: 'acme.com', name: 'Acme', minLikelihood: 2 });
-  });
-
-  it('raises the likelihood when only a name is available', () => {
-    expect(
-      extractCompanyMatchParams({
-        node: { ...COMPANY_NODE_MOCK, domainName: null, name: 'Acme' },
-        input: INPUT,
-      }),
-    ).toEqual({ name: 'Acme', minLikelihood: 6 });
-  });
-
-  it('honors an explicit minLikelihood from the input', () => {
-    expect(
-      extractCompanyMatchParams({
-        node: { ...COMPANY_NODE_MOCK, name: 'Acme' },
-        input: { records: [], minLikelihood: 9 },
-      }),
-    ).toMatchObject({ minLikelihood: 9 });
-  });
-
-  it('returns undefined when there is no usable identifier', () => {
-    expect(
-      extractCompanyMatchParams({
-        node: { ...COMPANY_NODE_MOCK, domainName: null, name: '' },
-        input: INPUT,
-      }),
-    ).toBeUndefined();
-  });
-});

package/src/logic-functions/utils/__tests__/extract-pdl-error-message.spec.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { extractPdlErrorMessage } from 'src/logic-functions/utils/extract-pdl-error-message';
-
-describe('extractPdlErrorMessage', () => {
-  it('reads the nested PDL error message', () => {
-    expect(
-      extractPdlErrorMessage({ json: { error: { message: 'boom' } }, httpStatus: 500 }),
-    ).toBe('boom');
-  });
-
-  it('falls back to a generic message when none is present', () => {
-    expect(extractPdlErrorMessage({ json: {}, httpStatus: 503 })).toBe(
-      'PDL request failed (HTTP 503).',
-    );
-  });
-});