@twentyhq/people-data-labs 1.0.0

package/src/logic-functions/utils/map-person.ts

@@ -0,0 +1,136 @@
+import { isArray, isString } from '@sniptt/guards';
+
+import { INDUSTRY_OPTIONS } from 'src/constants/industry-options';
+import { INFERRED_SALARY_OPTIONS } from 'src/constants/inferred-salary-options';
+import { JOB_ROLE_OPTIONS } from 'src/constants/job-role-options';
+import { JOB_TITLE_CLASS_OPTIONS } from 'src/constants/job-title-class-options';
+import { JOB_TITLE_SUB_ROLE_OPTIONS } from 'src/constants/job-title-sub-role-options';
+import { METRO_OPTIONS } from 'src/constants/metro-options';
+import { SENIORITY_OPTIONS } from 'src/constants/seniority-options';
+import { SEX_OPTIONS } from 'src/constants/sex-options';
+import { toJsonArray } from 'src/logic-functions/utils/to-json-array';
+import { toNumber } from 'src/logic-functions/utils/to-number';
+import { toStringArray } from 'src/logic-functions/utils/to-string-array';
+import { toText } from 'src/logic-functions/utils/to-text';
+import { buildAddress } from 'src/logic-functions/utils/build-address';
+import { buildEmails } from 'src/logic-functions/utils/build-emails';
+import { buildFullName } from 'src/logic-functions/utils/build-full-name';
+import { buildLinks } from 'src/logic-functions/utils/build-links';
+import { buildPhones } from 'src/logic-functions/utils/build-phones';
+import { parsePartialDate } from 'src/logic-functions/utils/parse-partial-date';
+import { buildAllowedValues } from 'src/logic-functions/utils/build-allowed-values';
+import { pickMultiSelect } from 'src/logic-functions/utils/pick-multi-select';
+import { pickSelect } from 'src/logic-functions/utils/pick-select';
+import { salaryTransform } from 'src/logic-functions/utils/salary-transform';
+import { type MappedRecord } from 'src/types/mapped-record';
+import { type PdlPersonData } from 'src/types/pdl-person-data';
+import { pruneUndefined } from 'src/utils/prune-undefined';
+
+const SENIORITY_VALUES = buildAllowedValues(SENIORITY_OPTIONS);
+const JOB_ROLE_VALUES = buildAllowedValues(JOB_ROLE_OPTIONS);
+const JOB_TITLE_CLASS_VALUES = buildAllowedValues(JOB_TITLE_CLASS_OPTIONS);
+const JOB_TITLE_SUB_ROLE_VALUES = buildAllowedValues(JOB_TITLE_SUB_ROLE_OPTIONS);
+const INDUSTRY_VALUES = buildAllowedValues(INDUSTRY_OPTIONS);
+const INFERRED_SALARY_VALUES = buildAllowedValues(INFERRED_SALARY_OPTIONS);
+const SEX_VALUES = buildAllowedValues(SEX_OPTIONS);
+const METRO_VALUES = buildAllowedValues(METRO_OPTIONS);
+
+export const mapPerson = (personData: PdlPersonData): MappedRecord => {
+  const emailEntries = (isArray(personData.emails) ? personData.emails : []).map(
+    (rawEmail) => (isString(rawEmail) ? rawEmail : rawEmail.address),
+  );
+
+  const standard = pruneUndefined({
+    name: buildFullName({
+      firstName: personData.first_name,
+      lastName: personData.last_name,
+      fullName: personData.full_name,
+    }),
+    emails: buildEmails([
+      personData.work_email,
+      personData.recommended_personal_email,
+      ...(isArray(personData.personal_emails) ? personData.personal_emails : []),
+      ...emailEntries,
+    ]),
+    phones: buildPhones([
+      personData.mobile_phone,
+      ...(isArray(personData.phone_numbers) ? personData.phone_numbers : []),
+    ]),
+    jobTitle: toText(personData.job_title),
+    linkedinLink: buildLinks({ url: personData.linkedin_url }),
+  });
+
+  const pdl = pruneUndefined({
+    pdlId: toText(personData.id),
+
+    pdlSeniority: pickMultiSelect({
+      rawValues: personData.job_title_levels,
+      allowedValues: SENIORITY_VALUES,
+    }),
+    pdlJobRole: pickSelect({
+      raw: personData.job_title_role,
+      allowedValues: JOB_ROLE_VALUES,
+    }),
+    pdlJobTitleClass: pickSelect({
+      raw: personData.job_title_class,
+      allowedValues: JOB_TITLE_CLASS_VALUES,
+    }),
+    pdlJobTitleSubRole: pickSelect({
+      raw: personData.job_title_sub_role,
+      allowedValues: JOB_TITLE_SUB_ROLE_VALUES,
+    }),
+    pdlIndustry: pickSelect({
+      raw: personData.industry,
+      allowedValues: INDUSTRY_VALUES,
+    }),
+    pdlInferredSalary: pickSelect({
+      raw: personData.inferred_salary,
+      allowedValues: INFERRED_SALARY_VALUES,
+      transform: salaryTransform,
+    }),
+    pdlSex: pickSelect({ raw: personData.sex, allowedValues: SEX_VALUES }),
+    pdlLocationMetro: pickSelect({
+      raw: personData.location_metro,
+      allowedValues: METRO_VALUES,
+    }),
+
+    pdlHeadline: toText(personData.headline),
+    pdlSummary: toText(personData.summary),
+    pdlJobSummary: toText(personData.job_summary),
+    pdlJobOnetCode: toText(personData.job_onet_code),
+    pdlLinkedinUsername: toText(personData.linkedin_username),
+
+    pdlYearsExperience: toNumber(personData.inferred_years_experience),
+    pdlLinkedinConnections: toNumber(personData.linkedin_connections),
+    pdlBirthYear: toNumber(personData.birth_year),
+
+    pdlBirthDate: parsePartialDate(personData.birth_date),
+    pdlJobStartDate: parsePartialDate(personData.job_start_date),
+
+    pdlGithubUrl: buildLinks({ url: personData.github_url }),
+    pdlTwitterUrl: buildLinks({ url: personData.twitter_url }),
+    pdlFacebookUrl: buildLinks({ url: personData.facebook_url }),
+
+    pdlSkills: toStringArray(personData.skills),
+    pdlInterests: toStringArray(personData.interests),
+    pdlNameAliases: toStringArray(personData.name_aliases),
+
+    pdlExperience: toJsonArray(personData.experience),
+    pdlEducation: toJsonArray(personData.education),
+    pdlCertifications: toJsonArray(personData.certifications),
+    pdlProfiles: toJsonArray(personData.profiles),
+    pdlLanguages: toJsonArray(personData.languages),
+
+    pdlLocation: buildAddress({
+      street1: personData.location_street_address,
+      street2: personData.location_address_line_2,
+      city: personData.location_locality,
+      postcode: personData.location_postal_code,
+      state: personData.location_region,
+      country: personData.location_country,
+      geo: personData.location_geo,
+    }),
+  });
+
+  return { standard, pdl };
+};

package/src/logic-functions/utils/normalize-domain.ts

@@ -0,0 +1,22 @@
+import { toText } from 'src/logic-functions/utils/to-text';
+import { isDefined } from 'src/utils/is-defined';
+
+const SCHEME_REGEX = /^[a-z][a-z0-9+.-]*:\/\//;
+const LEADING_WWW_REGEX = /^www\./;
+
+export const normalizeDomain = (
+  rawDomainValue: unknown,
+): string | undefined => {
+  const domainText = toText(rawDomainValue);
+  if (!isDefined(domainText)) {
+    return undefined;
+  }
+
+  const bareHost = domainText
+    .toLowerCase()
+    .replace(SCHEME_REGEX, '')
+    .split('/')[0]
+    .replace(LEADING_WWW_REGEX, '');
+
+  return bareHost === '' ? undefined : bareHost;
+};

package/src/logic-functions/utils/normalize-linkedin-url.ts

@@ -0,0 +1,23 @@
+import { toText } from 'src/logic-functions/utils/to-text';
+import { isDefined } from 'src/utils/is-defined';
+
+const SCHEME_REGEX = /^[a-z][a-z0-9+.-]*:\/\//;
+const LEADING_WWW_REGEX = /^www\./;
+const TRAILING_SLASHES_REGEX = /\/+$/;
+
+export const normalizeLinkedinUrl = (
+  rawLinkedinUrl: unknown,
+): string | undefined => {
+  const linkedinUrlText = toText(rawLinkedinUrl);
+  if (!isDefined(linkedinUrlText)) {
+    return undefined;
+  }
+
+  const canonicalUrlWithPath = linkedinUrlText
+    .toLowerCase()
+    .replace(SCHEME_REGEX, '')
+    .replace(LEADING_WWW_REGEX, '')
+    .replace(TRAILING_SLASHES_REGEX, '');
+
+  return canonicalUrlWithPath === '' ? undefined : canonicalUrlWithPath;
+};

package/src/logic-functions/utils/now-iso.ts

@@ -0,0 +1 @@
+export const nowIso = (): string => new Date().toISOString();

package/src/logic-functions/utils/parse-geo.ts

@@ -0,0 +1,33 @@
+import { toText } from 'src/logic-functions/utils/to-text';
+import { isDefined } from 'src/utils/is-defined';
+
+const NULL_COORDINATES = { lat: null, lng: null } as const;
+
+export const parseGeo = (
+  geo: unknown,
+): { lat: number | null; lng: number | null } => {
+  const geoText = toText(geo);
+
+  if (!isDefined(geoText)) {
+    return { ...NULL_COORDINATES };
+  }
+
+  const latitudeAndLongitudeParts = geoText.split(',');
+  if (latitudeAndLongitudeParts.length !== 2) {
+    return { ...NULL_COORDINATES };
+  }
+
+  const latitude = Number.parseFloat(latitudeAndLongitudeParts[0]);
+  const longitude = Number.parseFloat(latitudeAndLongitudeParts[1]);
+
+  const isLatitudeInRange =
+    Number.isFinite(latitude) && latitude >= -90 && latitude <= 90;
+  const isLongitudeInRange =
+    Number.isFinite(longitude) && longitude >= -180 && longitude <= 180;
+
+  if (!isLatitudeInRange || !isLongitudeInRange) {
+    return { ...NULL_COORDINATES };
+  }
+
+  return { lat: latitude, lng: longitude };
+};

package/src/logic-functions/utils/parse-partial-date.ts

@@ -0,0 +1,33 @@
+import { toText } from 'src/logic-functions/utils/to-text';
+import { isDefined } from 'src/utils/is-defined';
+
+const PARTIAL_DATE_REGEX = /^(\d{4})(?:-(\d{2}))?(?:-(\d{2}))?$/;
+
+export const parsePartialDate = (raw: unknown): string | undefined => {
+  const dateText = toText(raw);
+
+  if (!isDefined(dateText)) {
+    return undefined;
+  }
+
+  const partialDateMatch = dateText.match(PARTIAL_DATE_REGEX);
+  if (!isDefined(partialDateMatch)) {
+    return undefined;
+  }
+
+  const [, year, month = '01', day = '01'] = partialDateMatch;
+  const monthNumber = Number(month);
+  const dayNumber = Number(day);
+
+  const candidateDate = new Date(`${year}-${month}-${day}T00:00:00Z`);
+  const isRealCalendarDate =
+    !Number.isNaN(candidateDate.getTime()) &&
+    candidateDate.getUTCMonth() + 1 === monthNumber &&
+    candidateDate.getUTCDate() === dayNumber;
+
+  if (!isRealCalendarDate) {
+    return undefined;
+  }
+
+  return `${year}-${month}-${day}`;
+};

package/src/logic-functions/utils/parse-pdl-item.ts

@@ -0,0 +1,82 @@
+import { isNumber, isObject } from '@sniptt/guards';
+
+import { extractPdlErrorMessage } from 'src/logic-functions/utils/extract-pdl-error-message';
+import { type PdlEnrichResult } from 'src/types/pdl-enrich-result';
+import { isDefined } from 'src/utils/is-defined';
+
+const ASSUMED_SUCCESS_STATUS_WHEN_MISSING = 200;
+
+const ENVELOPE_FIELD_NAMES = new Set(['status', 'likelihood']);
+
+const extractMatchedData = (
+  responseItem: Record<string, unknown>,
+): Record<string, unknown> => {
+  if (isObject(responseItem.data)) {
+    return responseItem.data as Record<string, unknown>;
+  }
+
+  return Object.fromEntries(
+    Object.entries(responseItem).filter(
+      ([fieldName]) => !ENVELOPE_FIELD_NAMES.has(fieldName),
+    ),
+  );
+};
+
+export const parsePdlItem = <TData>({
+  item,
+  requestedMinLikelihood,
+}: {
+  item: unknown;
+  requestedMinLikelihood?: number;
+}): PdlEnrichResult<TData> => {
+  if (!isObject(item)) {
+    return {
+      outcome: 'error',
+      httpStatus: 0,
+      message: 'People Data Labs returned a malformed response item.',
+    };
+  }
+
+  const responseItem = item as Record<string, unknown>;
+  const httpStatus = isNumber(responseItem.status)
+    ? responseItem.status
+    : ASSUMED_SUCCESS_STATUS_WHEN_MISSING;
+
+  if (httpStatus === 404) {
+    return { outcome: 'not_found', httpStatus: 404 };
+  }
+
+  if (httpStatus < 200 || httpStatus >= 300) {
+    return {
+      outcome: 'error',
+      httpStatus,
+      message: extractPdlErrorMessage({ json: responseItem, httpStatus }),
+    };
+  }
+
+  const matchedData = extractMatchedData(responseItem);
+
+  if (Object.keys(matchedData).length === 0) {
+    return { outcome: 'not_found', httpStatus };
+  }
+
+  const matchLikelihood = isNumber(responseItem.likelihood)
+    ? responseItem.likelihood
+    : undefined;
+
+  const isMatchBelowRequestedThreshold =
+    isDefined(requestedMinLikelihood) &&
+    isDefined(matchLikelihood) &&
+    matchLikelihood < requestedMinLikelihood;
+
+  if (isMatchBelowRequestedThreshold) {
+    return { outcome: 'not_found', httpStatus };
+  }
+
+  return {
+    outcome: 'matched',
+    httpStatus,
+    likelihood: matchLikelihood,
+    data: matchedData as TData,
+  };
+};

package/src/logic-functions/utils/pick-multi-select.ts

@@ -0,0 +1,32 @@
+import { isArray, isNonEmptyArray } from '@sniptt/guards';
+
+import { pickSelect } from 'src/logic-functions/utils/pick-select';
+import { isDefined } from 'src/utils/is-defined';
+import { normalizeEnumValue } from 'src/utils/normalize-enum-value';
+
+export const pickMultiSelect = ({
+  rawValues,
+  allowedValues,
+  transform = normalizeEnumValue,
+}: {
+  rawValues: unknown;
+  allowedValues: Set<string>;
+  transform?: (value: string) => string | undefined;
+}): string[] | undefined => {
+  if (!isArray(rawValues)) {
+    return undefined;
+  }
+
+  const values: string[] = [];
+  const seenValues = new Set<string>();
+
+  for (const raw of rawValues) {
+    const value = pickSelect({ raw, allowedValues, transform });
+    if (isDefined(value) && !seenValues.has(value)) {
+      seenValues.add(value);
+      values.push(value);
+    }
+  }
+
+  return isNonEmptyArray(values) ? values : undefined;
+};

package/src/logic-functions/utils/pick-select.ts

@@ -0,0 +1,30 @@
+import { isNonEmptyString, isString } from '@sniptt/guards';
+
+import { isDefined } from 'src/utils/is-defined';
+import { normalizeEnumValue } from 'src/utils/normalize-enum-value';
+
+export const pickSelect = ({
+  raw,
+  allowedValues,
+  transform = normalizeEnumValue,
+}: {
+  raw: unknown;
+  allowedValues: Set<string>;
+  transform?: (value: string) => string | undefined;
+}): string | undefined => {
+  if (!isString(raw)) {
+    return undefined;
+  }
+
+  const trimmed = raw.trim();
+  if (!isNonEmptyString(trimmed)) {
+    return undefined;
+  }
+
+  const candidate = transform(trimmed);
+  if (!isDefined(candidate) || !allowedValues.has(candidate)) {
+    return undefined;
+  }
+
+  return candidate;
+};

package/src/logic-functions/utils/pick-writable-standard.ts

@@ -0,0 +1,27 @@
+import { isDefined } from 'src/utils/is-defined';
+
+export const pickWritableStandard = ({
+  standard,
+  current,
+  emptyChecks,
+  overrideExistingValues,
+}: {
+  standard: Record<string, unknown>;
+  current: Record<string, unknown>;
+  emptyChecks: Record<string, (current: unknown) => boolean>;
+  overrideExistingValues?: boolean;
+}): Record<string, unknown> => {
+  const writableFields: Record<string, unknown> = {};
+
+  for (const [fieldName, fieldValue] of Object.entries(standard)) {
+    const isEmptyCheck = emptyChecks[fieldName];
+    if (
+      isDefined(isEmptyCheck) &&
+      (overrideExistingValues === true || isEmptyCheck(current[fieldName]))
+    ) {
+      writableFields[fieldName] = fieldValue;
+    }
+  }
+
+  return writableFields;
+};

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

@@ -0,0 +1,89 @@
+import { isNumber, isObject } from '@sniptt/guards';
+
+import { PDL_BASE_URL } from 'src/constants/pdl-base-url';
+import { extractPdlErrorMessage } from 'src/logic-functions/utils/extract-pdl-error-message';
+import { getPdlApiKey } from 'src/logic-functions/utils/get-pdl-api-key';
+import { parsePdlItem } from 'src/logic-functions/utils/parse-pdl-item';
+import { type PdlEnrichResult } from 'src/types/pdl-enrich-result';
+
+export const postPdlBulkEnrich = async <TData>({
+  path,
+  requests,
+}: {
+  path: string;
+  requests: Record<string, unknown>[];
+}): Promise<PdlEnrichResult<TData>[]> => {
+  if (requests.length === 0) {
+    return [];
+  }
+
+  const apiKey = getPdlApiKey();
+
+  const failAll = ({
+    message,
+    httpStatus,
+  }: {
+    message: string;
+    httpStatus: number;
+  }): PdlEnrichResult<TData>[] =>
+    requests.map(() => ({ outcome: 'error', httpStatus, message }));
+
+  let response: Response;
+  try {
+    response = await fetch(`${PDL_BASE_URL}${path}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Api-Key': apiKey,
+      },
+      body: JSON.stringify({ requests: requests.map((params) => ({ params })) }),
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+
+    return failAll({ message: `PDL request failed: ${message}`, httpStatus: 0 });
+  }
+
+  let json: unknown;
+  try {
+    json = await response.json();
+  } catch {
+    return failAll({
+      message: `PDL returned a non-JSON response (HTTP ${response.status}).`,
+      httpStatus: response.status,
+    });
+  }
+
+  if (!response.ok) {
+    const message = isObject(json)
+      ? extractPdlErrorMessage({
+          json: json as Record<string, unknown>,
+          httpStatus: response.status,
+        })
+      : `PDL request failed (HTTP ${response.status}).`;
+
+    return failAll({ message, httpStatus: response.status });
+  }
+
+  const responseItems = Array.isArray(json)
+    ? json
+    : isObject(json) && Array.isArray((json as Record<string, unknown>).responses)
+      ? ((json as Record<string, unknown>).responses as unknown[])
+      : [];
+
+  if (responseItems.length !== requests.length) {
+    return failAll({
+      message: `People Data Labs returned ${responseItems.length} results for ${requests.length} requests (HTTP ${response.status}).`,
+      httpStatus: response.status,
+    });
+  }
+
+  return requests.map((requestParams, index) =>
+    parsePdlItem<TData>({
+      item: responseItems[index],
+      requestedMinLikelihood: isNumber(requestParams.min_likelihood)
+        ? requestParams.min_likelihood
+        : undefined,
+    }),
+  );
+};

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

@@ -0,0 +1,59 @@
+import { isNumber, isObject } from '@sniptt/guards';
+
+import { PDL_BASE_URL } from 'src/constants/pdl-base-url';
+import { getPdlApiKey } from 'src/logic-functions/utils/get-pdl-api-key';
+import { parsePdlItem } from 'src/logic-functions/utils/parse-pdl-item';
+import { type PdlEnrichResult } from 'src/types/pdl-enrich-result';
+
+export const postPdlSingleEnrich = async <TData>({
+  path,
+  params,
+}: {
+  path: string;
+  params: Record<string, unknown>;
+}): Promise<PdlEnrichResult<TData>> => {
+  const apiKey = getPdlApiKey();
+
+  let response: Response;
+  try {
+    response = await fetch(`${PDL_BASE_URL}${path}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Api-Key': apiKey,
+      },
+      body: JSON.stringify(params),
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+
+    return {
+      outcome: 'error',
+      httpStatus: 0,
+      message: `PDL request failed: ${message}`,
+    };
+  }
+
+  let json: unknown;
+  try {
+    json = await response.json();
+  } catch {
+    return {
+      outcome: 'error',
+      httpStatus: response.status,
+      message: `PDL returned a non-JSON response (HTTP ${response.status}).`,
+    };
+  }
+
+  const responseItem = isObject(json) ? (json as Record<string, unknown>) : {};
+  const responseItemWithStatus = isNumber(responseItem.status)
+    ? responseItem
+    : { ...responseItem, status: response.status };
+
+  return parsePdlItem<TData>({
+    item: responseItemWithStatus,
+    requestedMinLikelihood: isNumber(params.min_likelihood)
+      ? params.min_likelihood
+      : undefined,
+  });
+};

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

@@ -0,0 +1,53 @@
+import { isNonEmptyString, isObject } from '@sniptt/guards';
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { type CompanyNode } from 'src/types/company-node';
+
+export const readCompanies = async ({
+  client,
+  recordIds,
+}: {
+  client: CoreApiClient;
+  recordIds: string[];
+}): Promise<CompanyNode[]> => {
+  if (recordIds.length === 0) {
+    return [];
+  }
+
+  const result = (await client.query({
+    companies: {
+      __args: { filter: { id: { in: recordIds } }, first: recordIds.length },
+      edges: {
+        node: {
+          id: true,
+          name: true,
+          domainName: { primaryLinkUrl: true },
+          linkedinLink: { primaryLinkUrl: true },
+          address: {
+            addressStreet1: true,
+            addressStreet2: true,
+            addressCity: true,
+            addressPostcode: true,
+            addressState: true,
+            addressCountry: true,
+          },
+          pdlId: true,
+          pdlLastEnrichedAt: true,
+        },
+      },
+    },
+  })) as { companies?: { edges?: { node: CompanyNode }[] } };
+
+  const edges = result.companies?.edges;
+  if (!Array.isArray(edges)) {
+    return [];
+  }
+
+  return edges
+    .map((edge) => edge?.node)
+    .filter(
+      (companyNode): companyNode is CompanyNode =>
+        isObject(companyNode) &&
+        isNonEmptyString((companyNode as { id?: unknown }).id),
+    );
+};

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

@@ -0,0 +1,48 @@
+import { isNonEmptyString, isObject } from '@sniptt/guards';
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { type PersonNode } from 'src/types/person-node';
+
+export const readPeople = async ({
+  client,
+  recordIds,
+}: {
+  client: CoreApiClient;
+  recordIds: string[];
+}): Promise<PersonNode[]> => {
+  if (recordIds.length === 0) {
+    return [];
+  }
+
+  const result = (await client.query({
+    people: {
+      __args: { filter: { id: { in: recordIds } }, first: recordIds.length },
+      edges: {
+        node: {
+          id: true,
+          name: { firstName: true, lastName: true },
+          emails: { primaryEmail: true },
+          phones: { primaryPhoneNumber: true },
+          jobTitle: true,
+          linkedinLink: { primaryLinkUrl: true },
+          company: { id: true, name: true },
+          pdlId: true,
+          pdlLastEnrichedAt: true,
+        },
+      },
+    },
+  })) as { people?: { edges?: { node: PersonNode }[] } };
+
+  const edges = result.people?.edges;
+  if (!Array.isArray(edges)) {
+    return [];
+  }
+
+  return edges
+    .map((edge) => edge?.node)
+    .filter(
+      (personNode): personNode is PersonNode =>
+        isObject(personNode) &&
+        isNonEmptyString((personNode as { id?: unknown }).id),
+    );
+};