@twentyhq/people-data-labs 1.0.0

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

@@ -0,0 +1,15 @@
+import { companyEnrichmentAdapter } from 'src/logic-functions/handlers/company-enrichment-adapter';
+import { enrichCompany } from 'src/logic-functions/utils/enrich-company';
+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 companySingleEnrichmentAdapter: BatchEnrichmentAdapter<
+  CompanyNode,
+  PdlCompanyData,
+  PdlCompanyEnrichParams
+> = {
+  ...companyEnrichmentAdapter,
+  enrichBatch: enrichCompany,
+};

package/src/logic-functions/handlers/enrich-companies.ts

@@ -0,0 +1,15 @@
+import { CoreApiClient } from 'twenty-client-sdk/core';
+
+import { companyEnrichmentAdapter } from 'src/logic-functions/handlers/company-enrichment-adapter';
+import { runBatchEnrichment } from 'src/logic-functions/utils/run-batch-enrichment';
+import { type BulkEnrichInput } from 'src/types/bulk-enrich-input';
+import { type BulkEnrichResult } from 'src/types/bulk-enrich-result';
+
+export const enrichCompaniesCore = ({
+  input,
+  client = new CoreApiClient(),
+}: {
+  input: BulkEnrichInput;
+  client?: CoreApiClient;
+}): Promise<BulkEnrichResult> =>
+  runBatchEnrichment({ client, input, adapter: companyEnrichmentAdapter });

package/src/logic-functions/handlers/enrich-company.ts

@@ -0,0 +1,19 @@
+import { CoreApiClient } from 'twenty-client-sdk/core';
+
+import { companySingleEnrichmentAdapter } from 'src/logic-functions/handlers/company-single-enrichment-adapter';
+import { runSingleEnrichment } from 'src/logic-functions/utils/run-single-enrichment';
+import { type EnrichResult } from 'src/types/enrich-result';
+import { type SingleEnrichInput } from 'src/types/single-enrich-input';
+
+export const enrichCompanyCore = ({
+  input,
+  client = new CoreApiClient(),
+}: {
+  input: SingleEnrichInput;
+  client?: CoreApiClient;
+}): Promise<EnrichResult> =>
+  runSingleEnrichment({
+    client,
+    input,
+    adapter: companySingleEnrichmentAdapter,
+  });

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

@@ -0,0 +1,15 @@
+import { CoreApiClient } from 'twenty-client-sdk/core';
+
+import { personEnrichmentAdapter } from 'src/logic-functions/handlers/person-enrichment-adapter';
+import { runBatchEnrichment } from 'src/logic-functions/utils/run-batch-enrichment';
+import { type BulkEnrichInput } from 'src/types/bulk-enrich-input';
+import { type BulkEnrichResult } from 'src/types/bulk-enrich-result';
+
+export const enrichPeopleCore = ({
+  input,
+  client = new CoreApiClient(),
+}: {
+  input: BulkEnrichInput;
+  client?: CoreApiClient;
+}): Promise<BulkEnrichResult> =>
+  runBatchEnrichment({ client, input, adapter: personEnrichmentAdapter });

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

@@ -0,0 +1,19 @@
+import { CoreApiClient } from 'twenty-client-sdk/core';
+
+import { personSingleEnrichmentAdapter } from 'src/logic-functions/handlers/person-single-enrichment-adapter';
+import { runSingleEnrichment } from 'src/logic-functions/utils/run-single-enrichment';
+import { type EnrichResult } from 'src/types/enrich-result';
+import { type SingleEnrichInput } from 'src/types/single-enrich-input';
+
+export const enrichPersonCore = ({
+  input,
+  client = new CoreApiClient(),
+}: {
+  input: SingleEnrichInput;
+  client?: CoreApiClient;
+}): Promise<EnrichResult> =>
+  runSingleEnrichment({
+    client,
+    input,
+    adapter: personSingleEnrichmentAdapter,
+  });

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

@@ -0,0 +1,29 @@
+import { PERSON_MATCH_COST_DOLLARS } from 'src/constants/person-match-cost-dollars';
+import { buildPersonMatchedData } from 'src/logic-functions/utils/build-person-matched-data';
+import { enrichPeople } from 'src/logic-functions/utils/enrich-people';
+import { extractPersonMatchParams } from 'src/logic-functions/utils/extract-person-match-params';
+import { readPeople } from 'src/logic-functions/utils/read-people';
+import { updatePeopleStatus } from 'src/logic-functions/utils/update-people-status';
+import { updatePersonRecord } from 'src/logic-functions/utils/update-person-record';
+import { type BatchEnrichmentAdapter } from 'src/types/batch-enrichment-adapter';
+import { type PdlPersonData } from 'src/types/pdl-person-data';
+import { type PdlPersonEnrichParams } from 'src/types/pdl-person-enrich-params';
+import { type PersonNode } from 'src/types/person-node';
+
+export const personEnrichmentAdapter: BatchEnrichmentAdapter<
+  PersonNode,
+  PdlPersonData,
+  PdlPersonEnrichParams
+> = {
+  objectNameSingular: 'Person',
+  noIdentifierMessage:
+    'No usable identifier (email, LinkedIn, PDL id, or name paired with a company) to match against PDL.',
+  costPerMatchDollars: PERSON_MATCH_COST_DOLLARS,
+  readRecords: readPeople,
+  getNodeId: (node) => node.id,
+  extractParams: extractPersonMatchParams,
+  enrichBatch: enrichPeople,
+  buildMatchedData: buildPersonMatchedData,
+  updateOne: updatePersonRecord,
+  updateManyStatus: updatePeopleStatus,
+};

package/src/logic-functions/handlers/person-single-enrichment-adapter.ts

@@ -0,0 +1,15 @@
+import { personEnrichmentAdapter } from 'src/logic-functions/handlers/person-enrichment-adapter';
+import { enrichPerson } from 'src/logic-functions/utils/enrich-person';
+import { type BatchEnrichmentAdapter } from 'src/types/batch-enrichment-adapter';
+import { type PdlPersonData } from 'src/types/pdl-person-data';
+import { type PdlPersonEnrichParams } from 'src/types/pdl-person-enrich-params';
+import { type PersonNode } from 'src/types/person-node';
+
+export const personSingleEnrichmentAdapter: BatchEnrichmentAdapter<
+  PersonNode,
+  PdlPersonData,
+  PdlPersonEnrichParams
+> = {
+  ...personEnrichmentAdapter,
+  enrichBatch: enrichPerson,
+};

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

@@ -0,0 +1,69 @@
+import { CoreApiClient } from 'twenty-client-sdk/core';
+import { MetadataApiClient } from 'twenty-client-sdk/metadata';
+
+import { ENRICHMENT_WORKFLOW_SEEDS } from 'src/constants/enrichment-workflow-seeds';
+import { resolveLogicFunctionId } from 'src/logic-functions/utils/resolve-logic-function-id';
+import { seedEnrichmentWorkflow } from 'src/logic-functions/utils/seed-enrichment-workflow';
+import { type PostInstallResult } from 'src/types/post-install-result';
+import { type SeedEnrichmentWorkflowResult } from 'src/types/seed-enrichment-workflow-result';
+import { isDefined } from 'src/utils/is-defined';
+
+export const postInstallCore = async ({
+  coreClient = new CoreApiClient(),
+  metadataClient = new MetadataApiClient(),
+}: {
+  coreClient?: CoreApiClient;
+  metadataClient?: MetadataApiClient;
+} = {}): Promise<PostInstallResult> => {
+  const { findManyLogicFunctions: logicFunctions } = await metadataClient.query(
+    {
+      findManyLogicFunctions: {
+        id: true,
+        universalIdentifier: true,
+      },
+    },
+  );
+
+  const seededWorkflows: SeedEnrichmentWorkflowResult[] = [];
+
+  for (const seed of ENRICHMENT_WORKFLOW_SEEDS) {
+    const logicFunctionId = resolveLogicFunctionId({
+      logicFunctions,
+      universalIdentifier: seed.logicFunctionUniversalIdentifier,
+    });
+
+    if (!isDefined(logicFunctionId)) {
+      console.warn(
+        `[people-data-labs] Skipping "${seed.workflowName}": logic function ${seed.logicFunctionUniversalIdentifier} is not installed.`,
+      );
+      continue;
+    }
+
+    try {
+      const result = await seedEnrichmentWorkflow({
+        client: coreClient,
+        logicFunctionId,
+        seed,
+      });
+
+      seededWorkflows.push(result);
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+
+      console.warn(
+        `[people-data-labs] Failed to seed "${seed.workflowName}": ${errorMessage}`,
+        error,
+      );
+
+      seededWorkflows.push({
+        objectNameSingular: seed.objectNameSingular,
+        workflowName: seed.workflowName,
+        status: 'failed',
+        error: errorMessage,
+      });
+    }
+  }
+
+  return { seededWorkflows };
+};

package/src/logic-functions/post-install.function.ts

@@ -0,0 +1,17 @@
+import { definePostInstallLogicFunction } from 'twenty-sdk/define';
+
+import { PDL_LOGIC_FUNCTION_CONSTANTS } from 'src/constants/universal-identifiers';
+
+const handler = async () => {
+  return { seededWorkflows: [] };
+};
+
+export default definePostInstallLogicFunction({
+  universalIdentifier: PDL_LOGIC_FUNCTION_CONSTANTS.postInstall.universalIdentifier,
+  name: 'post-install',
+  description:
+    'Post-install hook for the People Data Labs app (workflow seeding is not currently wired up).',
+  timeoutSeconds: 30,
+  handler,
+  shouldRunSynchronously: true,
+});

package/src/logic-functions/utils/__tests__/aggregate-bulk-enrich-result.spec.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest';
+
+import { aggregateBulkEnrichResult } from 'src/logic-functions/utils/aggregate-bulk-enrich-result';
+import { type EnrichResult } from 'src/types/enrich-result';
+
+const result = (status: EnrichResult['status'], recordId: string): EnrichResult => ({
+  success: status !== 'ERROR',
+  recordId,
+  status,
+  updatedFields: [],
+  message: 'message',
+});
+
+describe('aggregateBulkEnrichResult', () => {
+  it('counts each status and flags failure when something errored', () => {
+    expect(
+      aggregateBulkEnrichResult([
+        result('MATCHED', 'a'),
+        result('NOT_FOUND', 'b'),
+        result('SKIPPED', 'c'),
+        result('ERROR', 'd'),
+      ]),
+    ).toMatchObject({
+      total: 4,
+      matched: 1,
+      notFound: 1,
+      skipped: 1,
+      errored: 1,
+      success: false,
+    });
+  });
+
+  it('reports success when there are no errors', () => {
+    expect(aggregateBulkEnrichResult([result('MATCHED', 'a')])).toMatchObject({
+      success: true,
+      errored: 0,
+      total: 1,
+    });
+  });
+
+  it('returns an empty summary for no results', () => {
+    expect(aggregateBulkEnrichResult([])).toEqual({
+      success: true,
+      total: 0,
+      matched: 0,
+      notFound: 0,
+      skipped: 0,
+      errored: 0,
+      results: [],
+    });
+  });
+});

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

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildAddress } from 'src/logic-functions/utils/build-address';
+
+describe('buildAddress', () => {
+  it('maps parts to the address composite using addressPostcode', () => {
+    expect(
+      buildAddress({
+        city: 'San Francisco',
+        state: 'California',
+        postcode: '94107',
+        country: 'United States',
+        geo: '37.77,-122.41',
+      }),
+    ).toEqual({
+      addressStreet1: '',
+      addressStreet2: '',
+      addressCity: 'San Francisco',
+      addressPostcode: '94107',
+      addressState: 'California',
+      addressCountry: 'United States',
+      addressLat: 37.77,
+      addressLng: -122.41,
+    });
+  });
+
+  it('returns undefined when no part has a value', () => {
+    expect(buildAddress({ city: '', country: null })).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildAllowedValues } from 'src/logic-functions/utils/build-allowed-values';
+
+describe('buildAllowedValues', () => {
+  it('builds a set of the option values', () => {
+    const allowed = buildAllowedValues([
+      { key: 'a', value: 'A', label: 'A', color: 'blue', position: 0 },
+      { key: 'b', value: 'B', label: 'B', color: 'red', position: 1 },
+    ]);
+
+    expect(allowed.has('A')).toBe(true);
+    expect(allowed.has('B')).toBe(true);
+    expect(allowed.size).toBe(2);
+  });
+});

package/src/logic-functions/utils/__tests__/build-bulk-records-trigger.spec.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildBulkRecordsTrigger } from 'src/logic-functions/utils/build-bulk-records-trigger';
+
+describe('buildBulkRecordsTrigger', () => {
+  it('builds a bulk-records manual trigger with no next step wired', () => {
+    const trigger = buildBulkRecordsTrigger({
+      objectNameSingular: 'person',
+      name: 'When people are selected',
+      icon: 'IconSparkles',
+    });
+
+    expect(trigger).toEqual({
+      name: 'When people are selected',
+      type: 'MANUAL',
+      settings: {
+        objectType: 'person',
+        availability: { type: 'BULK_RECORDS', objectNameSingular: 'person' },
+        outputSchema: {},
+        icon: 'IconSparkles',
+        isPinned: false,
+      },
+      nextStepIds: [],
+    });
+  });
+});

package/src/logic-functions/utils/__tests__/build-company-create-data.spec.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildCompanyCreateData } from 'src/logic-functions/utils/build-company-create-data';
+import { type PdlPersonData } from 'src/types/pdl-person-data';
+
+describe('buildCompanyCreateData', () => {
+  it('maps job_company_* onto Company standard and pdl fields', () => {
+    const data = buildCompanyCreateData({
+      job_company_id: 'pdl-co-1',
+      job_company_name: 'Acme',
+      job_company_website: 'acme.com',
+      job_company_linkedin_url: 'https://linkedin.com/company/acme',
+      job_company_industry: 'accounting',
+      job_company_size: '11-50',
+    } as PdlPersonData);
+
+    expect(data).toMatchObject({
+      name: 'Acme',
+      pdlId: 'pdl-co-1',
+      pdlIndustry: 'ACCOUNTING',
+      pdlSizeRange: 'ELEVEN_TO_FIFTY',
+    });
+    expect(data.domainName).toMatchObject({ primaryLinkUrl: 'acme.com' });
+    expect(data.linkedinLink).toMatchObject({
+      primaryLinkUrl: 'linkedin.com/company/acme',
+    });
+  });
+
+  it('omits fields PDL did not return and drops unknown select values', () => {
+    const data = buildCompanyCreateData({
+      job_company_name: 'Acme',
+      job_company_industry: 'not-a-real-industry',
+    } as PdlPersonData);
+
+    expect(data).toEqual({ name: 'Acme' });
+  });
+});

package/src/logic-functions/utils/__tests__/build-company-match-keys.spec.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildCompanyMatchKeys } from 'src/logic-functions/utils/build-company-match-keys';
+import { type PdlPersonData } from 'src/types/pdl-person-data';
+
+describe('buildCompanyMatchKeys', () => {
+  it('extracts and trims the company identifiers from PDL data', () => {
+    const keys = buildCompanyMatchKeys({
+      job_company_id: '  pdl-co-1 ',
+      job_company_website: 'acme.com',
+      job_company_linkedin_url: 'https://linkedin.com/company/acme',
+      job_company_name: 'Acme',
+    } as PdlPersonData);
+
+    expect(keys).toEqual({
+      pdlId: 'pdl-co-1',
+      website: 'acme.com',
+      linkedinUrl: 'linkedin.com/company/acme',
+      name: 'Acme',
+    });
+  });
+
+  it('omits identifiers PDL did not return or that are blank', () => {
+    expect(
+      buildCompanyMatchKeys({
+        job_company_name: '   ',
+        job_company_website: 'acme.com',
+      } as PdlPersonData),
+    ).toEqual({ website: 'acme.com' });
+  });
+
+  it('returns an empty object when no company identifiers are present', () => {
+    expect(buildCompanyMatchKeys({} as PdlPersonData)).toEqual({});
+  });
+});

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

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest';
+
+import { COMPANY_NODE_MOCK } from 'src/logic-functions/__mocks__/company-node.mock';
+import { PDL_COMPANY_DATA_MOCK } from 'src/logic-functions/__mocks__/pdl-company-data.mock';
+import { buildCompanyMatchedData } from 'src/logic-functions/utils/build-company-matched-data';
+
+const ENRICHED_AT = '2026-01-01T00:00:00.000Z';
+
+describe('buildCompanyMatchedData', () => {
+  it('fills empty standard fields and always writes pdl metadata', async () => {
+    const { mappedData, persistData } = await buildCompanyMatchedData({
+      node: COMPANY_NODE_MOCK,
+      outcome: { data: PDL_COMPANY_DATA_MOCK },
+      enrichedAt: ENRICHED_AT,
+      overrideExistingValues: false,
+      shouldPersist: true,
+    });
+
+    expect(persistData.name).toBe('Acme Corp');
+    expect(persistData.pdlIndustry).toBe('ACCOUNTING');
+    expect(persistData.pdlEnrichmentStatus).toBe('MATCHED');
+    expect(persistData.pdlLastEnrichedAt).toBe(ENRICHED_AT);
+    expect('domainName' in persistData).toBe(false);
+
+    expect(mappedData.name).toBe('Acme Corp');
+    expect(mappedData.pdlIndustry).toBe('ACCOUNTING');
+    expect('pdlEnrichmentStatus' in mappedData).toBe(false);
+    expect('pdlRawPayload' in mappedData).toBe(false);
+  });
+
+  it('overwrites a populated standard field when overrideExistingValues is set', async () => {
+    const { persistData } = await buildCompanyMatchedData({
+      node: COMPANY_NODE_MOCK,
+      outcome: { data: PDL_COMPANY_DATA_MOCK },
+      enrichedAt: ENRICHED_AT,
+      overrideExistingValues: true,
+      shouldPersist: true,
+    });
+
+    expect('domainName' in persistData).toBe(true);
+  });
+
+  it('returns mapped data with no persist data when not persisting', async () => {
+    const { mappedData, persistData } = await buildCompanyMatchedData({
+      node: COMPANY_NODE_MOCK,
+      outcome: { data: PDL_COMPANY_DATA_MOCK },
+      enrichedAt: ENRICHED_AT,
+      overrideExistingValues: false,
+      shouldPersist: false,
+    });
+
+    expect(mappedData.name).toBe('Acme Corp');
+    expect(mappedData.pdlIndustry).toBe('ACCOUNTING');
+    expect(persistData).toEqual({});
+  });
+});

package/src/logic-functions/utils/__tests__/build-currency-from-usd.spec.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildCurrencyFromUsd } from 'src/logic-functions/utils/build-currency-from-usd';
+
+describe('buildCurrencyFromUsd', () => {
+  it('converts a USD amount to micros', () => {
+    expect(buildCurrencyFromUsd(1234.5)).toEqual({
+      amountMicros: 1_234_500_000,
+      currencyCode: 'USD',
+    });
+  });
+
+  it('returns undefined for non-finite or non-number input', () => {
+    expect(buildCurrencyFromUsd(Number.NaN)).toBeUndefined();
+    expect(buildCurrencyFromUsd('1000')).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildEmails } from 'src/logic-functions/utils/build-emails';
+
+describe('buildEmails', () => {
+  it('keeps the first email as primary and the rest as additional', () => {
+    expect(buildEmails(['work@acme.com', 'home@me.com'])).toEqual({
+      primaryEmail: 'work@acme.com',
+      additionalEmails: ['home@me.com'],
+    });
+  });
+
+  it('dedupes case-insensitively and skips blanks', () => {
+    expect(buildEmails(['work@acme.com', 'WORK@acme.com', '', null])).toEqual({
+      primaryEmail: 'work@acme.com',
+      additionalEmails: null,
+    });
+  });
+
+  it('returns undefined when there are no emails', () => {
+    expect(buildEmails([null, undefined, ''])).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildErrorResult } from 'src/logic-functions/utils/build-error-result';
+
+describe('buildErrorResult', () => {
+  it('builds an ERROR result carrying the error detail', () => {
+    expect(buildErrorResult({ recordId: 'p1', error: 'boom' })).toEqual({
+      success: false,
+      recordId: 'p1',
+      status: 'ERROR',
+      updatedFields: [],
+      message: 'People Data Labs enrichment failed.',
+      error: 'boom',
+    });
+  });
+});

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

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildFullName } from 'src/logic-functions/utils/build-full-name';
+
+describe('buildFullName', () => {
+  it('uses explicit first and last name when present', () => {
+    expect(
+      buildFullName({ firstName: 'Jane', lastName: 'Doe', fullName: undefined }),
+    ).toEqual({
+      firstName: 'Jane',
+      lastName: 'Doe',
+    });
+  });
+
+  it('fills only the part that is present', () => {
+    expect(
+      buildFullName({ firstName: 'Jane', lastName: undefined, fullName: undefined }),
+    ).toEqual({
+      firstName: 'Jane',
+      lastName: '',
+    });
+  });
+
+  it('splits a full name on the first whitespace run', () => {
+    expect(
+      buildFullName({
+        firstName: undefined,
+        lastName: undefined,
+        fullName: 'Jane Mary Doe',
+      }),
+    ).toEqual({
+      firstName: 'Jane',
+      lastName: 'Mary Doe',
+    });
+  });
+
+  it('capitalizes lowercase names returned by PDL', () => {
+    expect(
+      buildFullName({ firstName: 'sean', lastName: 'thorne', fullName: undefined }),
+    ).toEqual({
+      firstName: 'Sean',
+      lastName: 'Thorne',
+    });
+  });
+
+  it('capitalizes a lowercase full name when split', () => {
+    expect(
+      buildFullName({
+        firstName: undefined,
+        lastName: undefined,
+        fullName: 'sean fong thorne',
+      }),
+    ).toEqual({
+      firstName: 'Sean',
+      lastName: 'Fong Thorne',
+    });
+  });
+
+  it('returns undefined when there is no name', () => {
+    expect(
+      buildFullName({ firstName: undefined, lastName: undefined, fullName: undefined }),
+    ).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildLinks } from 'src/logic-functions/utils/build-links';
+
+describe('buildLinks', () => {
+  it('builds a links value with a blank label by default', () => {
+    expect(buildLinks({ url: 'https://acme.com' })).toEqual({
+      primaryLinkUrl: 'https://acme.com',
+      primaryLinkLabel: '',
+      secondaryLinks: null,
+    });
+  });
+
+  it('uses the provided label', () => {
+    expect(buildLinks({ url: 'https://acme.com', label: 'Acme' })).toEqual({
+      primaryLinkUrl: 'https://acme.com',
+      primaryLinkLabel: 'Acme',
+      secondaryLinks: null,
+    });
+  });
+
+  it('returns undefined when the url is empty', () => {
+    expect(buildLinks({ url: '' })).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildLogicFunctionStep } from 'src/logic-functions/utils/build-logic-function-step';
+
+describe('buildLogicFunctionStep', () => {
+  it('builds a logic-function step carrying the resolved id and input', () => {
+    const step = buildLogicFunctionStep({
+      id: 'step-1',
+      name: 'Enrich with People Data Labs',
+      logicFunctionId: 'logic-function-1',
+      logicFunctionInput: { records: '{{trigger.companies}}' },
+    });
+
+    expect(step).toEqual({
+      id: 'step-1',
+      name: 'Enrich with People Data Labs',
+      type: 'LOGIC_FUNCTION',
+      valid: true,
+      settings: {
+        input: {
+          logicFunctionId: 'logic-function-1',
+          logicFunctionInput: { records: '{{trigger.companies}}' },
+        },
+        outputSchema: {},
+        errorHandlingOptions: {
+          retryOnFailure: { value: false },
+          continueOnFailure: { value: false },
+        },
+      },
+      nextStepIds: [],
+    });
+  });
+});