@twentyhq/people-data-labs 1.0.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,17 @@
+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).',
+    );
+  });
+});