@twentyhq/people-data-labs 1.0.0

package/src/logic-functions/utils/__tests__/post-pdl-single-enrich.spec.ts

@@ -0,0 +1,172 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { postPdlSingleEnrich } from 'src/logic-functions/utils/post-pdl-single-enrich';
+
+type FetchResponse = {
+  status: number;
+  ok: boolean;
+  json: () => Promise<unknown>;
+};
+
+const buildResponse = (
+  status: number,
+  json: unknown,
+  jsonThrows = false,
+): FetchResponse => ({
+  status,
+  ok: status >= 200 && status < 300,
+  json: () =>
+    jsonThrows ? Promise.reject(new Error('invalid json')) : Promise.resolve(json),
+});
+
+const stubFetch = (response: FetchResponse | Error) => {
+  const fetchMock = vi.fn((_url: string, _init?: RequestInit) =>
+    response instanceof Error
+      ? Promise.reject(response)
+      : Promise.resolve(response),
+  );
+  vi.stubGlobal('fetch', fetchMock);
+
+  return fetchMock;
+};
+
+describe('postPdlSingleEnrich', () => {
+  beforeEach(() => {
+    process.env.PDL_API_KEY = 'secret-key';
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    delete process.env.PDL_API_KEY;
+  });
+
+  it('posts the params directly in the body (not wrapped under requests)', async () => {
+    const fetchMock = stubFetch(buildResponse(200, { status: 200, data: {} }));
+
+    await postPdlSingleEnrich({
+      path: '/person/enrich',
+      params: { email: 'a@b.com' },
+    });
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe('https://api.peopledatalabs.com/v5/person/enrich');
+    expect(JSON.parse(init.body as string)).toEqual({ email: 'a@b.com' });
+  });
+
+  it('maps a 200 person match with a data envelope', async () => {
+    stubFetch(
+      buildResponse(200, { status: 200, likelihood: 8, data: { id: 'a' } }),
+    );
+
+    const result = await postPdlSingleEnrich({
+      path: '/person/enrich',
+      params: { email: 'a@b.com' },
+    });
+
+    expect(result).toEqual({
+      outcome: 'matched',
+      httpStatus: 200,
+      likelihood: 8,
+      data: { id: 'a' },
+    });
+  });
+
+  it('maps a 200 company match whose fields are at the top level', async () => {
+    stubFetch(
+      buildResponse(200, { status: 200, likelihood: 6, id: 'c1', name: 'Acme' }),
+    );
+
+    const result = await postPdlSingleEnrich({
+      path: '/company/enrich',
+      params: { name: 'Acme' },
+    });
+
+    expect(result).toEqual({
+      outcome: 'matched',
+      httpStatus: 200,
+      likelihood: 6,
+      data: { id: 'c1', name: 'Acme' },
+    });
+  });
+
+  it('treats a 404 no-match as not_found from the body status', async () => {
+    stubFetch(buildResponse(404, { status: 404, error: { message: 'no match' } }));
+
+    const result = await postPdlSingleEnrich({
+      path: '/person/enrich',
+      params: { email: 'a@b.com' },
+    });
+
+    expect(result).toEqual({ outcome: 'not_found', httpStatus: 404 });
+  });
+
+  it('falls back to the HTTP status when the body omits status', async () => {
+    stubFetch(buildResponse(404, { error: { message: 'no match' } }));
+
+    const result = await postPdlSingleEnrich({
+      path: '/person/enrich',
+      params: { email: 'a@b.com' },
+    });
+
+    expect(result).toEqual({ outcome: 'not_found', httpStatus: 404 });
+  });
+
+  it('reports an error on a non-2xx response with an error body', async () => {
+    stubFetch(buildResponse(401, { status: 401, error: { message: 'unauthorized' } }));
+
+    const result = await postPdlSingleEnrich({
+      path: '/person/enrich',
+      params: { email: 'a@b.com' },
+    });
+
+    expect(result).toEqual({
+      outcome: 'error',
+      httpStatus: 401,
+      message: 'unauthorized',
+    });
+  });
+
+  it('reports an error when fetch throws', async () => {
+    stubFetch(new Error('network down'));
+
+    const result = await postPdlSingleEnrich({
+      path: '/person/enrich',
+      params: { email: 'a@b.com' },
+    });
+
+    expect(result).toEqual({
+      outcome: 'error',
+      httpStatus: 0,
+      message: 'PDL request failed: network down',
+    });
+  });
+
+  it('reports an error on a non-JSON response', async () => {
+    stubFetch(buildResponse(200, null, true));
+
+    const result = await postPdlSingleEnrich({
+      path: '/person/enrich',
+      params: { email: 'a@b.com' },
+    });
+
+    expect(result).toEqual({
+      outcome: 'error',
+      httpStatus: 200,
+      message: 'PDL returned a non-JSON response (HTTP 200).',
+    });
+  });
+
+  it('drops a match below the requested min_likelihood', async () => {
+    stubFetch(
+      buildResponse(200, { status: 200, likelihood: 3, data: { id: 'a' } }),
+    );
+
+    const result = await postPdlSingleEnrich({
+      path: '/person/enrich',
+      params: { email: 'a@b.com', min_likelihood: 6 },
+    });
+
+    expect(result).toEqual({ outcome: 'not_found', httpStatus: 200 });
+  });
+});

package/src/logic-functions/utils/__tests__/read-companies.spec.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'vitest';
+
+import { createCoreApiClientMock } from 'src/logic-functions/__mocks__/create-core-api-client-mock';
+import { readCompanies } from 'src/logic-functions/utils/read-companies';
+
+type QueryRequest = {
+  companies: { __args: { filter: { id: { in: string[] } }; first: number } };
+};
+
+describe('readCompanies', () => {
+  it('queries companies by an id-in filter and returns the matching nodes', async () => {
+    const nodes = [{ id: 'c1' }, { id: 'c2' }];
+    let capturedRequest: unknown;
+    const client = createCoreApiClientMock({
+      queryResult: (request: unknown) => {
+        capturedRequest = request;
+
+        return { companies: { edges: nodes.map((node) => ({ node })) } };
+      },
+    });
+
+    const result = await readCompanies({ client, recordIds: ['c1', 'c2'] });
+
+    expect(result).toEqual(nodes);
+    expect((capturedRequest as QueryRequest).companies.__args.filter).toEqual({
+      id: { in: ['c1', 'c2'] },
+    });
+  });
+
+  it('returns an empty array without querying when there are no ids', async () => {
+    const client = createCoreApiClientMock({
+      queryResult: () => {
+        throw new Error('should not query');
+      },
+    });
+
+    expect(await readCompanies({ client, recordIds: [] })).toEqual([]);
+  });
+});

package/src/logic-functions/utils/__tests__/read-people.spec.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+
+import { createCoreApiClientMock } from 'src/logic-functions/__mocks__/create-core-api-client-mock';
+import { readPeople } from 'src/logic-functions/utils/read-people';
+
+type QueryRequest = {
+  people: { __args: { filter: { id: { in: string[] } }; first: number } };
+};
+
+describe('readPeople', () => {
+  it('queries people by an id-in filter and returns the matching nodes', async () => {
+    const nodes = [{ id: 'p1' }, { id: 'p2' }];
+    let capturedRequest: unknown;
+    const client = createCoreApiClientMock({
+      queryResult: (request: unknown) => {
+        capturedRequest = request;
+
+        return { people: { edges: nodes.map((node) => ({ node })) } };
+      },
+    });
+
+    const result = await readPeople({ client, recordIds: ['p1', 'p2'] });
+
+    expect(result).toEqual(nodes);
+    expect((capturedRequest as QueryRequest).people.__args.filter).toEqual({
+      id: { in: ['p1', 'p2'] },
+    });
+    expect((capturedRequest as QueryRequest).people.__args.first).toBe(2);
+  });
+
+  it('returns an empty array without querying when there are no ids', async () => {
+    const client = createCoreApiClientMock({
+      queryResult: () => {
+        throw new Error('should not query');
+      },
+    });
+
+    expect(await readPeople({ client, recordIds: [] })).toEqual([]);
+  });
+});

package/src/logic-functions/utils/__tests__/resolve-logic-function-id.spec.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+
+import { resolveLogicFunctionId } from 'src/logic-functions/utils/resolve-logic-function-id';
+
+describe('resolveLogicFunctionId', () => {
+  const logicFunctions = [
+    { id: 'id-a', universalIdentifier: 'uid-a' },
+    { id: 'id-b', universalIdentifier: 'uid-b' },
+  ];
+
+  it('returns the id matching the universal identifier', () => {
+    expect(
+      resolveLogicFunctionId({ logicFunctions, universalIdentifier: 'uid-b' }),
+    ).toBe('id-b');
+  });
+
+  it('returns undefined when no logic function matches', () => {
+    expect(
+      resolveLogicFunctionId({
+        logicFunctions,
+        universalIdentifier: 'uid-missing',
+      }),
+    ).toBeUndefined();
+  });
+});

package/src/logic-functions/utils/__tests__/resolve-update-fields-mode.spec.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+
+import { UPDATE_FIELDS_OPTIONS } from 'src/constants/update-fields-options';
+import { resolveUpdateFieldsMode } from 'src/logic-functions/utils/resolve-update-fields-mode';
+
+describe('resolveUpdateFieldsMode', () => {
+  it('persists and overwrites for "Yes and overwrite"', () => {
+    expect(resolveUpdateFieldsMode(UPDATE_FIELDS_OPTIONS.overwrite)).toEqual({
+      shouldPersist: true,
+      overrideExistingValues: true,
+    });
+  });
+
+  it('persists without overwriting for "Yes and don\'t overwrite"', () => {
+    expect(resolveUpdateFieldsMode(UPDATE_FIELDS_OPTIONS.fillEmpty)).toEqual({
+      shouldPersist: true,
+      overrideExistingValues: false,
+    });
+  });
+
+  it('does not persist for "No"', () => {
+    expect(resolveUpdateFieldsMode(UPDATE_FIELDS_OPTIONS.no)).toEqual({
+      shouldPersist: false,
+      overrideExistingValues: false,
+    });
+  });
+
+  it('defaults to fill-empty persisting when omitted', () => {
+    expect(resolveUpdateFieldsMode(undefined)).toEqual({
+      shouldPersist: true,
+      overrideExistingValues: false,
+    });
+  });
+});