@twentyhq/people-data-labs 1.0.0 → 1.0.2

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

@@ -1,313 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { type CoreApiClient } from 'twenty-client-sdk/core';
-
-import { UPDATE_FIELDS_OPTIONS } from 'src/constants/update-fields-options';
-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 { enrichPeopleCore } from 'src/logic-functions/handlers/enrich-people';
-import { enrichPeople } from 'src/logic-functions/utils/enrich-people';
-import { type PersonNode } from 'src/types/person-node';
-
-vi.mock('src/logic-functions/utils/enrich-people', () => ({
-  enrichPeople: vi.fn(),
-}));
-
-const enrichPeopleMock = vi.mocked(enrichPeople);
-
-type Captured = {
-  updatePerson?: Record<string, unknown>;
-  updatePeople?: { filter: unknown; data: Record<string, unknown> };
-  companiesQueried?: boolean;
-  createCompanyCalled?: boolean;
-};
-
-type MutationRequest = {
-  updatePerson?: { __args: { id: string; data: Record<string, unknown> } };
-  updatePeople?: { __args: { filter: unknown; data: Record<string, unknown> } };
-  createCompany?: unknown;
-};
-
-const captureMutation = (captured: Captured) => (request: unknown) => {
-  const mutation = request as MutationRequest;
-  if (mutation.updatePerson) {
-    captured.updatePerson = mutation.updatePerson.__args.data;
-  }
-  if (mutation.updatePeople) {
-    captured.updatePeople = {
-      filter: mutation.updatePeople.__args.filter,
-      data: mutation.updatePeople.__args.data,
-    };
-  }
-  if ('createCompany' in mutation) {
-    captured.createCompanyCalled = true;
-  }
-};
-
-const buildClient = (options: {
-  people: PersonNode[];
-  captured: Captured;
-  createCompanyId?: string;
-}): CoreApiClient =>
-  createCoreApiClientMock({
-    queryResult: (request: unknown) => {
-      if ('companies' in (request as object)) {
-        options.captured.companiesQueried = true;
-
-        return { companies: { edges: [] } };
-      }
-
-      return { people: { edges: options.people.map((node) => ({ node })) } };
-    },
-    mutationResult: (request: unknown) =>
-      'createCompany' in (request as object) &&
-      options.createCompanyId !== undefined
-        ? { createCompany: { id: options.createCompanyId } }
-        : {},
-    onMutation: captureMutation(options.captured),
-  });
-
-const runOne = (client: CoreApiClient, recordId = 'p1') =>
-  enrichPeopleCore({ input: { records: [{ id: recordId }] }, client });
-
-beforeEach(() => {
-  enrichPeopleMock.mockReset();
-});
-
-describe('enrichPeopleCore', () => {
-  it('fills empty standard fields and writes pdl metadata via updatePerson on a match', async () => {
-    enrichPeopleMock.mockResolvedValue([
-      {
-        outcome: 'matched',
-        httpStatus: 200,
-        likelihood: 8,
-        data: {
-          id: 'pdl1',
-          first_name: 'Jane',
-          last_name: 'Doe',
-          work_email: 'jane@acme.com',
-          job_title: 'CEO',
-          linkedin_url: 'https://linkedin.com/in/new',
-        },
-      },
-    ]);
-    const captured: Captured = {};
-    const client = buildClient({ people: [PERSON_NODE_MOCK], captured });
-
-    const result = await runOne(client);
-
-    expect(enrichPeopleMock).toHaveBeenCalledTimes(1);
-    expect(result.matched).toBe(1);
-    expect(captured.updatePerson?.name).toEqual({
-      firstName: 'Jane',
-      lastName: 'Doe',
-    });
-    expect(captured.updatePerson?.jobTitle).toBe('CEO');
-    expect(captured.updatePerson?.emails).toMatchObject({
-      primaryEmail: 'jane@acme.com',
-    });
-    expect(captured.updatePerson?.pdlEnrichmentStatus).toBe('MATCHED');
-    expect(captured.updatePerson?.pdlLikelihood).toBe(8);
-    expect(typeof captured.updatePerson?.pdlLastEnrichedAt).toBe('string');
-    expect(captured.updatePerson?.pdlRawPayload).toMatchObject({ id: 'pdl1' });
-    expect('linkedinLink' in (captured.updatePerson ?? {})).toBe(false);
-  });
-
-  it('links a found-or-created company when the person has none', async () => {
-    enrichPeopleMock.mockResolvedValue([
-      {
-        outcome: 'matched',
-        httpStatus: 200,
-        likelihood: 8,
-        data: {
-          id: 'pdl1',
-          work_email: 'jane@acme.com',
-          job_company_name: 'Acme',
-          job_company_website: 'acme.com',
-        },
-      },
-    ]);
-    const captured: Captured = {};
-    const client = buildClient({
-      people: [PERSON_NODE_MOCK],
-      captured,
-      createCompanyId: 'co-new',
-    });
-
-    await runOne(client);
-
-    expect(captured.updatePerson?.companyId).toBe('co-new');
-  });
-
-  it('does not touch company when the person already has one', async () => {
-    enrichPeopleMock.mockResolvedValue([
-      {
-        outcome: 'matched',
-        httpStatus: 200,
-        likelihood: 8,
-        data: { id: 'pdl1', work_email: 'jane@acme.com', job_company_name: 'Acme' },
-      },
-    ]);
-    const captured: Captured = {};
-    const client = buildClient({
-      people: [{ ...PERSON_NODE_MOCK, company: { id: 'co-existing' } }],
-      captured,
-    });
-
-    await runOne(client);
-
-    expect(captured.companiesQueried).toBeUndefined();
-    expect(captured.createCompanyCalled).toBeUndefined();
-    expect('companyId' in (captured.updatePerson ?? {})).toBe(false);
-  });
-
-  it('does not overwrite a populated standard field', async () => {
-    enrichPeopleMock.mockResolvedValue([
-      {
-        outcome: 'matched',
-        httpStatus: 200,
-        likelihood: 5,
-        data: { id: 'pdl1', job_title: 'CEO' },
-      },
-    ]);
-    const captured: Captured = {};
-    const client = buildClient({
-      people: [{ ...PERSON_NODE_MOCK, jobTitle: 'Existing Title' }],
-      captured,
-    });
-
-    await runOne(client);
-
-    expect('jobTitle' in (captured.updatePerson ?? {})).toBe(false);
-  });
-
-  it('records NOT_FOUND and writes the status via a batched updatePeople', async () => {
-    enrichPeopleMock.mockResolvedValue([{ outcome: 'not_found', httpStatus: 404 }]);
-    const captured: Captured = {};
-    const client = buildClient({ people: [PERSON_NODE_MOCK], captured });
-
-    const result = await runOne(client);
-
-    expect(result.notFound).toBe(1);
-    expect(captured.updatePerson).toBeUndefined();
-    expect(Object.keys(captured.updatePeople?.data ?? {}).sort()).toEqual([
-      'pdlEnrichmentStatus',
-      'pdlLastEnrichedAt',
-    ]);
-    expect(captured.updatePeople?.data.pdlEnrichmentStatus).toBe('NOT_FOUND');
-    expect(captured.updatePeople?.filter).toEqual({ id: { in: ['p1'] } });
-  });
-
-  it('records ERROR and reports failure on a PDL error', async () => {
-    enrichPeopleMock.mockResolvedValue([
-      { outcome: 'error', httpStatus: 500, message: 'boom' },
-    ]);
-    const captured: Captured = {};
-    const client = buildClient({ people: [PERSON_NODE_MOCK], captured });
-
-    const result = await runOne(client);
-
-    expect(result.errored).toBe(1);
-    expect(result.success).toBe(false);
-    expect(result.results[0].error).toBe('boom');
-    expect(captured.updatePeople?.data).toEqual({
-      pdlEnrichmentStatus: 'ERROR',
-      pdlLastEnrichedAt: expect.any(String),
-    });
-  });
-
-  it('overwrites a populated standard field when updateFields is "Yes and overwrite"', async () => {
-    enrichPeopleMock.mockResolvedValue([
-      {
-        outcome: 'matched',
-        httpStatus: 200,
-        likelihood: 5,
-        data: { id: 'pdl1', job_title: 'CEO' },
-      },
-    ]);
-    const captured: Captured = {};
-    const client = buildClient({
-      people: [{ ...PERSON_NODE_MOCK, jobTitle: 'Existing Title' }],
-      captured,
-    });
-
-    await enrichPeopleCore({
-      input: {
-        records: [{ id: 'p1' }],
-        updateFields: UPDATE_FIELDS_OPTIONS.overwrite,
-      },
-      client,
-    });
-
-    expect(captured.updatePerson?.jobTitle).toBe('CEO');
-  });
-
-  it('returns enriched data without writing when updateFields is "No"', async () => {
-    enrichPeopleMock.mockResolvedValue([
-      {
-        outcome: 'matched',
-        httpStatus: 200,
-        likelihood: 8,
-        data: { id: 'pdl1', first_name: 'Jane', job_title: 'CEO' },
-      },
-    ]);
-    const captured: Captured = {};
-    const client = buildClient({ people: [PERSON_NODE_MOCK], captured });
-
-    const result = await enrichPeopleCore({
-      input: { records: [{ id: 'p1' }], updateFields: UPDATE_FIELDS_OPTIONS.no },
-      client,
-    });
-
-    expect(result.matched).toBe(1);
-    expect(result.results[0].updatedFields).toEqual([]);
-    expect(result.results[0].data?.jobTitle).toBe('CEO');
-    expect(captured.updatePerson).toBeUndefined();
-    expect(captured.updatePeople).toBeUndefined();
-    expect(captured.createCompanyCalled).toBeUndefined();
-  });
-
-  it('skips when there is no usable identifier', async () => {
-    const captured: Captured = {};
-    const client = buildClient({
-      people: [{ ...PERSON_NODE_MOCK, linkedinLink: null }],
-      captured,
-    });
-
-    const result = await runOne(client);
-
-    expect(result.skipped).toBe(1);
-    expect(enrichPeopleMock).not.toHaveBeenCalled();
-  });
-
-  it('marks a missing record as ERROR', async () => {
-    const captured: Captured = {};
-    const client = buildClient({ people: [], captured });
-
-    const result = await runOne(client, 'missing');
-
-    expect(result.errored).toBe(1);
-    expect(result.results[0].error).toBe('Person missing not found');
-    expect(enrichPeopleMock).not.toHaveBeenCalled();
-  });
-
-  it('batches the PDL request and the not-found status write across records', async () => {
-    enrichPeopleMock.mockResolvedValue([
-      { outcome: 'not_found', httpStatus: 404 },
-      { outcome: 'not_found', httpStatus: 404 },
-    ]);
-    const captured: Captured = {};
-    const client = buildClient({
-      people: [PERSON_NODE_MOCK, { ...PERSON_NODE_MOCK, id: 'p2' }],
-      captured,
-    });
-
-    const result = await enrichPeopleCore({
-      input: { records: [{ id: 'p1' }, { id: 'p2' }] },
-      client,
-    });
-
-    expect(enrichPeopleMock).toHaveBeenCalledTimes(1);
-    expect(captured.updatePeople?.filter).toEqual({ id: { in: ['p1', 'p2'] } });
-    expect(result.notFound).toBe(2);
-  });
-});

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

@@ -1,198 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { type CoreApiClient } from 'twenty-client-sdk/core';
-
-import { UPDATE_FIELDS_OPTIONS } from 'src/constants/update-fields-options';
-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 { enrichPersonCore } from 'src/logic-functions/handlers/enrich-person';
-import { enrichPerson } from 'src/logic-functions/utils/enrich-person';
-import { type PersonNode } from 'src/types/person-node';
-
-vi.mock('src/logic-functions/utils/enrich-person', () => ({
-  enrichPerson: vi.fn(),
-}));
-
-const enrichPersonMock = vi.mocked(enrichPerson);
-
-type Captured = {
-  updatePerson?: Record<string, unknown>;
-  updatePeople?: { filter: unknown; data: Record<string, unknown> };
-};
-
-type MutationRequest = {
-  updatePerson?: { __args: { id: string; data: Record<string, unknown> } };
-  updatePeople?: { __args: { filter: unknown; data: Record<string, unknown> } };
-};
-
-const captureMutation = (captured: Captured) => (request: unknown) => {
-  const mutation = request as MutationRequest;
-  if (mutation.updatePerson) {
-    captured.updatePerson = mutation.updatePerson.__args.data;
-  }
-  if (mutation.updatePeople) {
-    captured.updatePeople = {
-      filter: mutation.updatePeople.__args.filter,
-      data: mutation.updatePeople.__args.data,
-    };
-  }
-};
-
-const buildClient = (people: PersonNode[], captured: Captured): CoreApiClient =>
-  createCoreApiClientMock({
-    queryResult: { people: { edges: people.map((node) => ({ node })) } },
-    onMutation: captureMutation(captured),
-  });
-
-const runOne = (client: CoreApiClient, recordId = 'p1') =>
-  enrichPersonCore({ input: { recordId }, client });
-
-beforeEach(() => {
-  enrichPersonMock.mockReset();
-});
-
-describe('enrichPersonCore', () => {
-  it('fills empty standard fields and writes pdl metadata via updatePerson on a match', async () => {
-    enrichPersonMock.mockResolvedValue([
-      {
-        outcome: 'matched',
-        httpStatus: 200,
-        likelihood: 8,
-        data: {
-          id: 'pdl1',
-          first_name: 'Jane',
-          last_name: 'Doe',
-          job_title: 'CEO',
-        },
-      },
-    ]);
-    const captured: Captured = {};
-    const client = buildClient([PERSON_NODE_MOCK], captured);
-
-    const result = await runOne(client);
-
-    expect(enrichPersonMock).toHaveBeenCalledTimes(1);
-    expect(result.status).toBe('MATCHED');
-    expect(result.success).toBe(true);
-    expect(result.recordId).toBe('p1');
-    expect(captured.updatePerson?.name).toEqual({
-      firstName: 'Jane',
-      lastName: 'Doe',
-    });
-    expect(captured.updatePerson?.jobTitle).toBe('CEO');
-    expect(captured.updatePerson?.pdlEnrichmentStatus).toBe('MATCHED');
-    expect(captured.updatePerson?.pdlLikelihood).toBe(8);
-  });
-
-  it('records NOT_FOUND and writes the status via updatePeople', async () => {
-    enrichPersonMock.mockResolvedValue([{ outcome: 'not_found', httpStatus: 404 }]);
-    const captured: Captured = {};
-    const client = buildClient([PERSON_NODE_MOCK], captured);
-
-    const result = await runOne(client);
-
-    expect(result.status).toBe('NOT_FOUND');
-    expect(captured.updatePerson).toBeUndefined();
-    expect(captured.updatePeople?.data.pdlEnrichmentStatus).toBe('NOT_FOUND');
-    expect(captured.updatePeople?.filter).toEqual({ id: { in: ['p1'] } });
-  });
-
-  it('records ERROR and reports failure on a PDL error', async () => {
-    enrichPersonMock.mockResolvedValue([
-      { outcome: 'error', httpStatus: 500, message: 'boom' },
-    ]);
-    const captured: Captured = {};
-    const client = buildClient([PERSON_NODE_MOCK], captured);
-
-    const result = await runOne(client);
-
-    expect(result.status).toBe('ERROR');
-    expect(result.success).toBe(false);
-    expect(result.error).toBe('boom');
-    expect(captured.updatePeople?.data).toEqual({
-      pdlEnrichmentStatus: 'ERROR',
-      pdlLastEnrichedAt: expect.any(String),
-    });
-  });
-
-  it('overwrites a populated standard field when updateFields is "Yes and overwrite"', async () => {
-    enrichPersonMock.mockResolvedValue([
-      {
-        outcome: 'matched',
-        httpStatus: 200,
-        likelihood: 5,
-        data: { id: 'pdl1', job_title: 'CEO' },
-      },
-    ]);
-    const captured: Captured = {};
-    const client = buildClient(
-      [{ ...PERSON_NODE_MOCK, jobTitle: 'Existing Title' }],
-      captured,
-    );
-
-    await enrichPersonCore({
-      input: { recordId: 'p1', updateFields: UPDATE_FIELDS_OPTIONS.overwrite },
-      client,
-    });
-
-    expect(captured.updatePerson?.jobTitle).toBe('CEO');
-  });
-
-  it('returns enriched data without writing when updateFields is "No"', async () => {
-    enrichPersonMock.mockResolvedValue([
-      {
-        outcome: 'matched',
-        httpStatus: 200,
-        likelihood: 8,
-        data: { id: 'pdl1', first_name: 'Jane', job_title: 'CEO' },
-      },
-    ]);
-    const captured: Captured = {};
-    const client = buildClient([PERSON_NODE_MOCK], captured);
-
-    const result = await enrichPersonCore({
-      input: { recordId: 'p1', updateFields: UPDATE_FIELDS_OPTIONS.no },
-      client,
-    });
-
-    expect(result.status).toBe('MATCHED');
-    expect(result.updatedFields).toEqual([]);
-    expect(result.data?.jobTitle).toBe('CEO');
-    expect(captured.updatePerson).toBeUndefined();
-    expect(captured.updatePeople).toBeUndefined();
-  });
-
-  it('skips when there is no usable identifier', async () => {
-    const captured: Captured = {};
-    const client = buildClient(
-      [{ ...PERSON_NODE_MOCK, linkedinLink: null }],
-      captured,
-    );
-
-    const result = await runOne(client);
-
-    expect(result.status).toBe('SKIPPED');
-    expect(enrichPersonMock).not.toHaveBeenCalled();
-  });
-
-  it('marks a missing record as ERROR', async () => {
-    const captured: Captured = {};
-    const client = buildClient([], captured);
-
-    const result = await runOne(client, 'missing');
-
-    expect(result.status).toBe('ERROR');
-    expect(result.error).toBe('Person missing not found');
-    expect(enrichPersonMock).not.toHaveBeenCalled();
-  });
-
-  it('returns an ERROR without touching PDL when no record id is provided', async () => {
-    const captured: Captured = {};
-    const client = buildClient([PERSON_NODE_MOCK], captured);
-
-    const result = await enrichPersonCore({ input: {}, client });
-
-    expect(result.status).toBe('ERROR');
-    expect(result.error).toBe('No record id was provided to enrich.');
-    expect(enrichPersonMock).not.toHaveBeenCalled();
-  });
-});

package/src/logic-functions/handlers/__tests__/post-install.spec.ts

@@ -1,153 +0,0 @@
-import { type MetadataApiClient } from 'twenty-client-sdk/metadata';
-import { describe, expect, it, vi } from 'vitest';
-
-import { PDL_LOGIC_FUNCTION_CONSTANTS } from 'src/constants/universal-identifiers';
-import { createCoreApiClientMock } from 'src/logic-functions/__mocks__/create-core-api-client-mock';
-import { postInstallCore } from 'src/logic-functions/handlers/post-install';
-
-type AnyRequest = Record<string, unknown>;
-
-const buildMetadataClient = (
-  logicFunctions: { id: string; universalIdentifier: string }[],
-): MetadataApiClient =>
-  ({
-    query: vi.fn(() =>
-      Promise.resolve({ findManyLogicFunctions: logicFunctions }),
-    ),
-  }) as unknown as MetadataApiClient;
-
-const buildCoreClient = () =>
-  createCoreApiClientMock({
-    queryResult: (request: unknown) => {
-      const req = request as AnyRequest;
-      if ('workflows' in req) {
-        return { workflows: { edges: [] } };
-      }
-      if ('workflowVersions' in req) {
-        return {
-          workflowVersions: {
-            edges: [{ node: { id: 'version-1', status: 'DRAFT' } }],
-          },
-        };
-      }
-      return {};
-    },
-    mutationResult: (request: unknown) =>
-      'createWorkflow' in (request as AnyRequest)
-        ? { createWorkflow: { id: 'workflow-new' } }
-        : {},
-  });
-
-describe('postInstallCore', () => {
-  it('seeds a workflow for each resolvable enrich function', async () => {
-    const metadataClient = buildMetadataClient([
-      {
-        id: 'company-fn',
-        universalIdentifier:
-          PDL_LOGIC_FUNCTION_CONSTANTS.enrichCompanies.universalIdentifier,
-      },
-      {
-        id: 'person-fn',
-        universalIdentifier:
-          PDL_LOGIC_FUNCTION_CONSTANTS.enrichPeople.universalIdentifier,
-      },
-    ]);
-
-    const result = await postInstallCore({
-      coreClient: buildCoreClient(),
-      metadataClient,
-    });
-
-    expect(result.seededWorkflows.map((workflow) => workflow.objectNameSingular)).toEqual([
-      'company',
-      'person',
-    ]);
-    expect(
-      result.seededWorkflows.every((workflow) => workflow.status === 'created'),
-    ).toBe(true);
-  });
-
-  it('skips a workflow when its logic function is not installed', async () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-
-    const metadataClient = buildMetadataClient([
-      {
-        id: 'company-fn',
-        universalIdentifier:
-          PDL_LOGIC_FUNCTION_CONSTANTS.enrichCompanies.universalIdentifier,
-      },
-    ]);
-
-    const result = await postInstallCore({
-      coreClient: buildCoreClient(),
-      metadataClient,
-    });
-
-    expect(result.seededWorkflows).toHaveLength(1);
-    expect(result.seededWorkflows[0]?.objectNameSingular).toBe('company');
-    expect(warnSpy).toHaveBeenCalledTimes(1);
-
-    warnSpy.mockRestore();
-  });
-
-  it('continues seeding remaining workflows when one seed fails', async () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-
-    const metadataClient = buildMetadataClient([
-      {
-        id: 'company-fn',
-        universalIdentifier:
-          PDL_LOGIC_FUNCTION_CONSTANTS.enrichCompanies.universalIdentifier,
-      },
-      {
-        id: 'person-fn',
-        universalIdentifier:
-          PDL_LOGIC_FUNCTION_CONSTANTS.enrichPeople.universalIdentifier,
-      },
-    ]);
-
-    const coreClient = createCoreApiClientMock({
-      queryResult: (request: unknown) => {
-        const req = request as AnyRequest;
-        if ('workflows' in req) {
-          return { workflows: { edges: [] } };
-        }
-        if ('workflowVersions' in req) {
-          return {
-            workflowVersions: {
-              edges: [{ node: { id: 'version-1', status: 'DRAFT' } }],
-            },
-          };
-        }
-        return {};
-      },
-      mutationResult: (request: unknown) => {
-        const req = request as AnyRequest;
-        if ('createWorkflow' in req) {
-          const args = (req.createWorkflow as AnyRequest)?.__args as AnyRequest;
-          const workflowName = (args?.data as AnyRequest)?.name;
-          return workflowName === 'Enrich companies with People Data Labs'
-            ? { createWorkflow: {} }
-            : { createWorkflow: { id: 'workflow-person' } };
-        }
-        return {};
-      },
-    });
-
-    const result = await postInstallCore({ coreClient, metadataClient });
-
-    expect(result.seededWorkflows).toHaveLength(2);
-    expect(result.seededWorkflows[0]).toMatchObject({
-      objectNameSingular: 'company',
-      status: 'failed',
-    });
-    expect(result.seededWorkflows[0]?.error).toBeDefined();
-    expect(result.seededWorkflows[1]).toMatchObject({
-      objectNameSingular: 'person',
-      status: 'created',
-    });
-    expect(warnSpy).toHaveBeenCalledTimes(1);
-
-    warnSpy.mockRestore();
-  });
-});

package/src/logic-functions/handlers/company-enrichment-adapter.ts

@@ -1,42 +0,0 @@
-import { COMPANY_MATCH_COST_DOLLARS } from 'src/constants/company-match-cost-dollars';
-import { buildCompanyMatchedData } from 'src/logic-functions/utils/build-company-matched-data';
-import { enrichCompanies } from 'src/logic-functions/utils/enrich-companies';
-import { extractCompanyMatchParams } from 'src/logic-functions/utils/extract-company-match-params';
-import { readCompanies } from 'src/logic-functions/utils/read-companies';
-import { updateCompaniesStatus } from 'src/logic-functions/utils/update-companies-status';
-import { updateCompanyRecord } from 'src/logic-functions/utils/update-company-record';
-import { type BatchEnrichmentAdapter } from 'src/types/batch-enrichment-adapter';
-import { type CompanyNode } from 'src/types/company-node';
-import { type PdlCompanyData } from 'src/types/pdl-company-data';
-import { type PdlCompanyEnrichParams } from 'src/types/pdl-company-enrich-params';
-
-export const companyEnrichmentAdapter: BatchEnrichmentAdapter<
-  CompanyNode,
-  PdlCompanyData,
-  PdlCompanyEnrichParams
-> = {
-  objectNameSingular: 'Company',
-  noIdentifierMessage:
-    'No usable identifier (domain, LinkedIn, or name) to match against PDL.',
-  costPerMatchDollars: COMPANY_MATCH_COST_DOLLARS,
-  readRecords: readCompanies,
-  getNodeId: (node) => node.id,
-  extractParams: extractCompanyMatchParams,
-  enrichBatch: enrichCompanies,
-  buildMatchedData: ({
-    node,
-    outcome,
-    enrichedAt,
-    overrideExistingValues,
-    shouldPersist,
-  }) =>
-    buildCompanyMatchedData({
-      node,
-      outcome,
-      enrichedAt,
-      overrideExistingValues,
-      shouldPersist,
-    }),
-  updateOne: updateCompanyRecord,
-  updateManyStatus: updateCompaniesStatus,
-};