@twentyhq/people-data-labs 1.0.0

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

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

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

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

@@ -0,0 +1,42 @@
+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,
+};