@twentyhq/people-data-labs 1.0.0

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

@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'vitest';
+
+import { PERSON_NODE_MOCK } from 'src/logic-functions/__mocks__/person-node.mock';
+import { extractPersonMatchParams } from 'src/logic-functions/utils/extract-person-match-params';
+
+describe('extractPersonMatchParams', () => {
+  it('prefers an existing pdlId and uses the strong-identifier likelihood', () => {
+    expect(
+      extractPersonMatchParams({
+        node: { ...PERSON_NODE_MOCK, pdlId: 'pdl-1' },
+        input: { records: [] },
+      }),
+    ).toEqual({ pdlId: 'pdl-1', minLikelihood: 2 });
+  });
+
+  it('uses the linkedin profile with the strong-identifier likelihood', () => {
+    expect(
+      extractPersonMatchParams({
+        node: PERSON_NODE_MOCK,
+        input: { records: [] },
+      }),
+    ).toEqual({
+      profile: 'https://linkedin.com/in/existing',
+      minLikelihood: 2,
+    });
+  });
+
+  it('pairs a name with the person company and uses the weak-identifier likelihood', () => {
+    expect(
+      extractPersonMatchParams({
+        node: {
+          ...PERSON_NODE_MOCK,
+          linkedinLink: null,
+          name: { firstName: 'Jane', lastName: 'Doe' },
+          company: { id: 'co-1', name: 'Acme' },
+        },
+        input: { records: [] },
+      }),
+    ).toEqual({ name: 'Jane Doe', company: 'Acme', minLikelihood: 6 });
+  });
+
+  it('returns undefined for a name with no anchoring identifier or company', () => {
+    expect(
+      extractPersonMatchParams({
+        node: {
+          ...PERSON_NODE_MOCK,
+          linkedinLink: null,
+          name: { firstName: 'Jane', lastName: 'Doe' },
+        },
+        input: { records: [] },
+      }),
+    ).toBeUndefined();
+  });
+
+  it('honors an explicit minLikelihood from the input', () => {
+    expect(
+      extractPersonMatchParams({
+        node: PERSON_NODE_MOCK,
+        input: {
+          records: [],
+          minLikelihood: 9,
+        },
+      }),
+    ).toMatchObject({ minLikelihood: 9 });
+  });
+
+  it('returns undefined when there is no usable identifier', () => {
+    expect(
+      extractPersonMatchParams({
+        node: { ...PERSON_NODE_MOCK, linkedinLink: null },
+        input: { records: [] },
+      }),
+    ).toBeUndefined();
+  });
+});

package/src/logic-functions/utils/__tests__/extract-record-ids.spec.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+
+import { extractRecordIds } from 'src/logic-functions/utils/extract-record-ids';
+
+describe('extractRecordIds', () => {
+  it('extracts ids from record objects', () => {
+    expect(extractRecordIds([{ id: 'a' }, { id: 'b' }])).toEqual(['a', 'b']);
+  });
+
+  it('accepts plain id strings', () => {
+    expect(extractRecordIds(['a', 'b'])).toEqual(['a', 'b']);
+  });
+
+  it('drops entries without a usable id', () => {
+    expect(
+      extractRecordIds([{ id: 'a' }, { id: null }, {}, { id: '' }, 'c']),
+    ).toEqual(['a', 'c']);
+  });
+
+  it('accepts a single record object (not wrapped in an array)', () => {
+    expect(extractRecordIds({ id: 'a' })).toEqual(['a']);
+  });
+
+  it('accepts a single id string (not wrapped in an array)', () => {
+    expect(extractRecordIds('a')).toEqual(['a']);
+  });
+
+  it('returns an empty array for nullish input', () => {
+    expect(extractRecordIds(undefined as unknown as [])).toEqual([]);
+    expect(extractRecordIds(null as unknown as [])).toEqual([]);
+  });
+});

package/src/logic-functions/utils/__tests__/find-company-id-by-filter.spec.ts

@@ -0,0 +1,42 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+import { describe, expect, it, vi } from 'vitest';
+
+import { findCompanyIdByFilter } from 'src/logic-functions/utils/find-company-id-by-filter';
+
+describe('findCompanyIdByFilter', () => {
+  it('returns the first matching company id and forwards the filter', async () => {
+    const query = vi.fn(() =>
+      Promise.resolve({ companies: { edges: [{ node: { id: 'co-1' } }] } }),
+    );
+    const client = { query } as unknown as CoreApiClient;
+    const filter = { pdlId: { eq: 'pdl-co-1' } };
+
+    const result = await findCompanyIdByFilter({ client, filter });
+
+    expect(result).toBe('co-1');
+    expect(query).toHaveBeenCalledWith({
+      companies: {
+        __args: { filter, first: 1 },
+        edges: { node: { id: true } },
+      },
+    });
+  });
+
+  it('returns undefined when there are no matches', async () => {
+    const query = vi.fn(() => Promise.resolve({ companies: { edges: [] } }));
+    const client = { query } as unknown as CoreApiClient;
+
+    expect(
+      await findCompanyIdByFilter({ client, filter: { name: { eq: 'Acme' } } }),
+    ).toBeUndefined();
+  });
+
+  it('returns undefined when the companies connection is absent', async () => {
+    const query = vi.fn(() => Promise.resolve({}));
+    const client = { query } as unknown as CoreApiClient;
+
+    expect(
+      await findCompanyIdByFilter({ client, filter: { name: { eq: 'Acme' } } }),
+    ).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,118 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+import { describe, expect, it, vi } from 'vitest';
+
+import { findCompanyId } from 'src/logic-functions/utils/find-company-id';
+
+type CompanyQueryRequest = {
+  companies: { __args: { filter: Record<string, unknown> } };
+};
+
+const filterKeyOf = (request: unknown) =>
+  Object.keys((request as CompanyQueryRequest).companies.__args.filter)[0];
+
+const ALL_KEYS = {
+  pdlId: 'pdl-co-1',
+  website: 'acme.com',
+  linkedinUrl: 'https://linkedin.com/company/acme',
+  name: 'Acme',
+};
+
+describe('findCompanyId', () => {
+  it('matches by pdlId first and does not query the lower-priority keys', async () => {
+    const query = vi.fn((request: unknown) =>
+      Promise.resolve(
+        filterKeyOf(request) === 'pdlId'
+          ? { companies: { edges: [{ node: { id: 'co-pdl' } }] } }
+          : { companies: { edges: [] } },
+      ),
+    );
+    const client = { query } as unknown as CoreApiClient;
+
+    const result = await findCompanyId({ client, matchKeys: ALL_KEYS });
+
+    expect(result).toBe('co-pdl');
+    expect(query).toHaveBeenCalledTimes(1);
+  });
+
+  it('falls through to lower-priority keys in order until one matches', async () => {
+    const queriedKeys: string[] = [];
+    const query = vi.fn((request: unknown) => {
+      const key = filterKeyOf(request);
+      queriedKeys.push(key);
+
+      return Promise.resolve(
+        key === 'name'
+          ? { companies: { edges: [{ node: { id: 'co-name' } }] } }
+          : { companies: { edges: [] } },
+      );
+    });
+    const client = { query } as unknown as CoreApiClient;
+
+    const result = await findCompanyId({ client, matchKeys: ALL_KEYS });
+
+    expect(result).toBe('co-name');
+    expect(queriedKeys).toEqual([
+      'pdlId',
+      'domainName',
+      'linkedinLink',
+      'name',
+    ]);
+  });
+
+  it('skips filters whose match key is absent', async () => {
+    const queriedKeys: string[] = [];
+    const query = vi.fn((request: unknown) => {
+      queriedKeys.push(filterKeyOf(request));
+
+      return Promise.resolve({ companies: { edges: [] } });
+    });
+    const client = { query } as unknown as CoreApiClient;
+
+    await findCompanyId({ client, matchKeys: { name: 'Acme' } });
+
+    expect(queriedKeys).toEqual(['name']);
+  });
+
+  it('returns undefined when no key matches', async () => {
+    const query = vi.fn(() => Promise.resolve({ companies: { edges: [] } }));
+    const client = { query } as unknown as CoreApiClient;
+
+    expect(
+      await findCompanyId({ client, matchKeys: ALL_KEYS }),
+    ).toBeUndefined();
+  });
+
+  it('returns undefined and issues no query when no keys are provided', async () => {
+    const query = vi.fn();
+    const client = { query } as unknown as CoreApiClient;
+
+    expect(await findCompanyId({ client, matchKeys: {} })).toBeUndefined();
+    expect(query).not.toHaveBeenCalled();
+  });
+
+  it('does not link a name match when it is ambiguous', async () => {
+    const query = vi.fn(() =>
+      Promise.resolve({
+        companies: {
+          edges: [{ node: { id: 'co-1' } }, { node: { id: 'co-2' } }],
+        },
+      }),
+    );
+    const client = { query } as unknown as CoreApiClient;
+
+    expect(
+      await findCompanyId({ client, matchKeys: { name: 'Acme' } }),
+    ).toBeUndefined();
+  });
+
+  it('links a unique name match', async () => {
+    const query = vi.fn(() =>
+      Promise.resolve({ companies: { edges: [{ node: { id: 'co-1' } }] } }),
+    );
+    const client = { query } as unknown as CoreApiClient;
+
+    expect(await findCompanyId({ client, matchKeys: { name: 'Acme' } })).toBe(
+      'co-1',
+    );
+  });
+});

package/src/logic-functions/utils/__tests__/find-existing-workflow-id.spec.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+
+import { createCoreApiClientMock } from 'src/logic-functions/__mocks__/create-core-api-client-mock';
+import { findExistingWorkflowId } from 'src/logic-functions/utils/find-existing-workflow-id';
+
+describe('findExistingWorkflowId', () => {
+  it('returns the id of the first matching workflow', async () => {
+    const client = createCoreApiClientMock({
+      queryResult: { workflows: { edges: [{ node: { id: 'workflow-1' } }] } },
+    });
+
+    await expect(
+      findExistingWorkflowId({ client, name: 'Enrich company' }),
+    ).resolves.toBe('workflow-1');
+  });
+
+  it('returns undefined when no workflow matches', async () => {
+    const client = createCoreApiClientMock({
+      queryResult: { workflows: { edges: [] } },
+    });
+
+    await expect(
+      findExistingWorkflowId({ client, name: 'Enrich company' }),
+    ).resolves.toBeUndefined();
+  });
+});

package/src/logic-functions/utils/__tests__/find-or-create-current-company.spec.ts

@@ -0,0 +1,203 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+import { describe, expect, it, vi } from 'vitest';
+
+import { findOrCreateCurrentCompany } from 'src/logic-functions/utils/find-or-create-current-company';
+import { type PdlPersonData } from 'src/types/pdl-person-data';
+
+type CompanyQueryRequest = {
+  companies: { __args: { filter: Record<string, unknown> } };
+};
+type CreateCompanyRequest = {
+  createCompany: { __args: { data: Record<string, unknown> } };
+};
+
+const filterOf = (request: unknown) =>
+  (request as CompanyQueryRequest).companies.__args.filter;
+const createDataOf = (request: unknown) =>
+  (request as CreateCompanyRequest).createCompany.__args.data;
+
+const newCache = () => new Map<string, string | undefined>();
+
+describe('findOrCreateCurrentCompany', () => {
+  it('returns undefined and issues no calls when PDL gives no identifiers', async () => {
+    const query = vi.fn();
+    const mutation = vi.fn();
+    const client = { query, mutation } as unknown as CoreApiClient;
+
+    const result = await findOrCreateCurrentCompany({
+      client,
+      personData: {} as PdlPersonData,
+      companyIdByMatchKeyCache: newCache(),
+    });
+
+    expect(result).toBeUndefined();
+    expect(query).not.toHaveBeenCalled();
+    expect(mutation).not.toHaveBeenCalled();
+  });
+
+  it('links an existing company matched by pdlId alone', async () => {
+    const query = vi.fn(() =>
+      Promise.resolve({ companies: { edges: [{ node: { id: 'co-existing' } }] } }),
+    );
+    const mutation = vi.fn();
+    const client = { query, mutation } as unknown as CoreApiClient;
+
+    const result = await findOrCreateCurrentCompany({
+      client,
+      personData: { job_company_id: 'pdl-co-1' } as PdlPersonData,
+      companyIdByMatchKeyCache: newCache(),
+    });
+
+    expect(result).toBe('co-existing');
+    expect(mutation).not.toHaveBeenCalled();
+  });
+
+  it('attempts a pdlId match but does not create without a name or website', async () => {
+    const query = vi.fn(() => Promise.resolve({ companies: { edges: [] } }));
+    const mutation = vi.fn();
+    const client = { query, mutation } as unknown as CoreApiClient;
+
+    const result = await findOrCreateCurrentCompany({
+      client,
+      personData: { job_company_id: 'pdl-co-1' } as PdlPersonData,
+      companyIdByMatchKeyCache: newCache(),
+    });
+
+    expect(result).toBeUndefined();
+    expect(query).toHaveBeenCalled();
+    expect(mutation).not.toHaveBeenCalled();
+  });
+
+  it('returns an existing company id without creating one', async () => {
+    const query = vi.fn(() =>
+      Promise.resolve({ companies: { edges: [{ node: { id: 'co-existing' } }] } }),
+    );
+    const mutation = vi.fn();
+    const client = { query, mutation } as unknown as CoreApiClient;
+
+    const result = await findOrCreateCurrentCompany({
+      client,
+      personData: {
+        job_company_name: 'Acme',
+      } as PdlPersonData,
+      companyIdByMatchKeyCache: newCache(),
+    });
+
+    expect(result).toBe('co-existing');
+    expect(mutation).not.toHaveBeenCalled();
+  });
+
+  it('creates a company from the PDL data when none matches', async () => {
+    const query = vi.fn(() => Promise.resolve({ companies: { edges: [] } }));
+    let createdData: Record<string, unknown> | undefined;
+    const mutation = vi.fn((request: unknown) => {
+      createdData = createDataOf(request);
+
+      return Promise.resolve({ createCompany: { id: 'co-new' } });
+    });
+    const client = { query, mutation } as unknown as CoreApiClient;
+
+    const result = await findOrCreateCurrentCompany({
+      client,
+      personData: {
+        job_company_id: 'pdl-co-2',
+        job_company_name: 'Acme',
+        job_company_website: 'acme.com',
+      } as PdlPersonData,
+      companyIdByMatchKeyCache: newCache(),
+    });
+
+    expect(result).toBe('co-new');
+    expect(createdData).toMatchObject({ name: 'Acme', pdlId: 'pdl-co-2' });
+  });
+
+  it('throws when the create mutation returns no company id', async () => {
+    const query = vi.fn(() => Promise.resolve({ companies: { edges: [] } }));
+    const mutation = vi.fn(() => Promise.resolve({ createCompany: null }));
+    const client = { query, mutation } as unknown as CoreApiClient;
+
+    await expect(
+      findOrCreateCurrentCompany({
+        client,
+        personData: {
+          job_company_name: 'Acme',
+        } as PdlPersonData,
+        companyIdByMatchKeyCache: newCache(),
+      }),
+    ).rejects.toThrow('Failed to create company: no id returned.');
+  });
+
+  it('re-finds the winner when a concurrent create hits a unique violation', async () => {
+    let created = false;
+    const query = vi.fn((request: unknown) =>
+      Promise.resolve(
+        created && 'pdlId' in filterOf(request)
+          ? { companies: { edges: [{ node: { id: 'co-race' } }] } }
+          : { companies: { edges: [] } },
+      ),
+    );
+    const mutation = vi.fn(() => {
+      created = true;
+
+      return Promise.reject(
+        new Error('duplicate key value violates unique constraint'),
+      );
+    });
+    const client = { query, mutation } as unknown as CoreApiClient;
+
+    const result = await findOrCreateCurrentCompany({
+      client,
+      personData: {
+        job_company_id: 'pdl-co-3',
+        job_company_name: 'Acme',
+      } as PdlPersonData,
+      companyIdByMatchKeyCache: newCache(),
+    });
+
+    expect(result).toBe('co-race');
+  });
+
+  it('rethrows a non-unique-violation create error', async () => {
+    const query = vi.fn(() => Promise.resolve({ companies: { edges: [] } }));
+    const mutation = vi.fn(() => Promise.reject(new Error('network down')));
+    const client = { query, mutation } as unknown as CoreApiClient;
+
+    await expect(
+      findOrCreateCurrentCompany({
+        client,
+        personData: {
+          job_company_name: 'Acme',
+        } as PdlPersonData,
+        companyIdByMatchKeyCache: newCache(),
+      }),
+    ).rejects.toThrow('network down');
+  });
+
+  it('reuses a cached company id for an identical company without re-querying', async () => {
+    const query = vi.fn(() =>
+      Promise.resolve({ companies: { edges: [{ node: { id: 'co-existing' } }] } }),
+    );
+    const mutation = vi.fn();
+    const client = { query, mutation } as unknown as CoreApiClient;
+    const companyIdByMatchKeyCache = newCache();
+    const personData = {
+      job_company_name: 'Acme',
+      job_company_website: 'acme.com',
+    } as PdlPersonData;
+
+    const first = await findOrCreateCurrentCompany({
+      client,
+      personData,
+      companyIdByMatchKeyCache,
+    });
+    const second = await findOrCreateCurrentCompany({
+      client,
+      personData,
+      companyIdByMatchKeyCache,
+    });
+
+    expect(first).toBe('co-existing');
+    expect(second).toBe('co-existing');
+    expect(query).toHaveBeenCalledTimes(1);
+  });
+});

package/src/logic-functions/utils/__tests__/get-pdl-api-key.spec.ts

@@ -0,0 +1,38 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { getPdlApiKey } from 'src/logic-functions/utils/get-pdl-api-key';
+import { PdlConfigError } from 'src/logic-functions/errors/pdl-config-error';
+
+describe('getPdlApiKey', () => {
+  let previousApiKey: string | undefined;
+
+  beforeEach(() => {
+    previousApiKey = process.env.PDL_API_KEY;
+  });
+
+  afterEach(() => {
+    if (previousApiKey === undefined) {
+      delete process.env.PDL_API_KEY;
+    } else {
+      process.env.PDL_API_KEY = previousApiKey;
+    }
+  });
+
+  it('returns the configured key', () => {
+    process.env.PDL_API_KEY = 'secret-key';
+
+    expect(getPdlApiKey()).toBe('secret-key');
+  });
+
+  it('throws a PdlConfigError when the key is missing', () => {
+    delete process.env.PDL_API_KEY;
+
+    expect(() => getPdlApiKey()).toThrow(PdlConfigError);
+  });
+
+  it('throws a PdlConfigError when the key is blank', () => {
+    process.env.PDL_API_KEY = '   ';
+
+    expect(() => getPdlApiKey()).toThrow(PdlConfigError);
+  });
+});

package/src/logic-functions/utils/__tests__/is-empty-address.spec.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+
+import { isEmptyAddress } from 'src/logic-functions/utils/is-empty-address';
+
+describe('isEmptyAddress', () => {
+  it('is true when every address text field is empty or missing', () => {
+    expect(isEmptyAddress(null)).toBe(true);
+    expect(
+      isEmptyAddress({
+        addressStreet1: '',
+        addressCity: '   ',
+        addressCountry: '',
+      }),
+    ).toBe(true);
+  });
+
+  it('is false when at least one address field is present', () => {
+    expect(isEmptyAddress({ addressCity: 'San Francisco' })).toBe(false);
+  });
+});

package/src/logic-functions/utils/__tests__/is-empty-emails.spec.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+
+import { isEmptyEmails } from 'src/logic-functions/utils/is-empty-emails';
+
+describe('isEmptyEmails', () => {
+  it('is true when there is no primary email', () => {
+    expect(isEmptyEmails(null)).toBe(true);
+    expect(isEmptyEmails({ primaryEmail: '' })).toBe(true);
+  });
+
+  it('is false when a primary email is present', () => {
+    expect(isEmptyEmails({ primaryEmail: 'jane@acme.com' })).toBe(false);
+  });
+});

package/src/logic-functions/utils/__tests__/is-empty-full-name.spec.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+
+import { isEmptyFullName } from 'src/logic-functions/utils/is-empty-full-name';
+
+describe('isEmptyFullName', () => {
+  it('is true when both first and last name are empty or missing', () => {
+    expect(isEmptyFullName(null)).toBe(true);
+    expect(isEmptyFullName({ firstName: '', lastName: '' })).toBe(true);
+  });
+
+  it('is false when at least one name part is present', () => {
+    expect(isEmptyFullName({ firstName: 'Jane', lastName: '' })).toBe(false);
+  });
+});

package/src/logic-functions/utils/__tests__/is-empty-links.spec.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+
+import { isEmptyLinks } from 'src/logic-functions/utils/is-empty-links';
+
+describe('isEmptyLinks', () => {
+  it('is true when there is no primary link url', () => {
+    expect(isEmptyLinks(null)).toBe(true);
+    expect(isEmptyLinks({ primaryLinkUrl: '' })).toBe(true);
+  });
+
+  it('is false when a primary link url is present', () => {
+    expect(isEmptyLinks({ primaryLinkUrl: 'https://acme.com' })).toBe(false);
+  });
+});

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

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+
+import { isEmptyPhones } from 'src/logic-functions/utils/is-empty-phones';
+
+describe('isEmptyPhones', () => {
+  it('is true when there is no primary phone number', () => {
+    expect(isEmptyPhones(null)).toBe(true);
+    expect(isEmptyPhones({ primaryPhoneNumber: '' })).toBe(true);
+  });
+
+  it('is false when a primary phone number is present', () => {
+    expect(isEmptyPhones({ primaryPhoneNumber: '5551234' })).toBe(false);
+  });
+});

package/src/logic-functions/utils/__tests__/is-empty-text.spec.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+
+import { isEmptyText } from 'src/logic-functions/utils/is-empty-text';
+
+describe('isEmptyText', () => {
+  it('is true for empty, whitespace and non-string values', () => {
+    expect(isEmptyText('')).toBe(true);
+    expect(isEmptyText('   ')).toBe(true);
+    expect(isEmptyText(null)).toBe(true);
+  });
+
+  it('is false for a non-empty string', () => {
+    expect(isEmptyText('hello')).toBe(false);
+  });
+});

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

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest';
+
+import { PDL_COMPANY_DATA_MOCK } from 'src/logic-functions/__mocks__/pdl-company-data.mock';
+import { mapCompany } from 'src/logic-functions/utils/map-company';
+
+describe('mapCompany', () => {
+  it('maps standard fields including the address composite', () => {
+    const { standard } = mapCompany(PDL_COMPANY_DATA_MOCK);
+
+    expect(standard.name).toBe('Acme Corp');
+    expect(standard.domainName).toMatchObject({ primaryLinkUrl: 'acme.com' });
+    expect(standard.address).toMatchObject({
+      addressCity: 'San Francisco',
+      addressPostcode: '94107',
+      addressCountry: 'United States',
+    });
+  });
+
+  it('converts USD funding to currency micros', () => {
+    const { pdl } = mapCompany(PDL_COMPANY_DATA_MOCK);
+
+    expect(pdl.pdlTotalFunding).toEqual({
+      amountMicros: 1_234_500_000,
+      currencyCode: 'USD',
+    });
+  });
+
+  it('maps select and multi-select funding fields, dropping unknowns', () => {
+    const { pdl } = mapCompany(PDL_COMPANY_DATA_MOCK);
+
+    expect(pdl.pdlSizeRange).toBe('FIFTY_ONE_TO_TWO_HUNDRED');
+    expect(pdl.pdlCompanyType).toBe('PRIVATE');
+    expect(pdl.pdlIndustry).toBe('ACCOUNTING');
+    expect(pdl.pdlLocationContinent).toBe('NORTH_AMERICA');
+    expect(pdl.pdlLatestFundingStage).toBe('SERIES_A');
+    expect(pdl.pdlFundingStages).toEqual(['SEED', 'SERIES_A']);
+  });
+
+  it('maps numbers, dates, arrays and raw json', () => {
+    const { pdl } = mapCompany(PDL_COMPANY_DATA_MOCK);
+
+    expect(pdl.pdlEmployeeCount).toBe(120);
+    expect(pdl.pdlFoundedYear).toBe(2001);
+    expect(pdl.pdlLastFundingDate).toBe('2020-05-01');
+    expect(pdl.pdlTags).toEqual(['saas', 'b2b']);
+    expect(pdl.pdlNaics).toEqual([{ naics_code: '541511' }]);
+  });
+});