@twentyhq/people-data-labs 1.0.0 → 1.0.2

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

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

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

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

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

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