@twentyhq/people-data-labs 1.0.0

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

@@ -0,0 +1,11 @@
+export const resolveLogicFunctionId = ({
+  logicFunctions,
+  universalIdentifier,
+}: {
+  logicFunctions: { id: string; universalIdentifier?: string | null }[];
+  universalIdentifier: string;
+}): string | undefined =>
+  logicFunctions.find(
+    (logicFunction) =>
+      logicFunction.universalIdentifier === universalIdentifier,
+  )?.id;

package/src/logic-functions/utils/resolve-min-likelihood.ts

@@ -0,0 +1,12 @@
+const DEFAULT_MIN_LIKELIHOOD = 2;
+const WEAK_IDENTIFIER_MIN_LIKELIHOOD = 6;
+
+export const resolveMinLikelihood = ({
+  inputMinLikelihood,
+  hasStrongIdentifier,
+}: {
+  inputMinLikelihood: number | undefined;
+  hasStrongIdentifier: boolean;
+}): number =>
+  inputMinLikelihood ??
+  (hasStrongIdentifier ? DEFAULT_MIN_LIKELIHOOD : WEAK_IDENTIFIER_MIN_LIKELIHOOD);

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

@@ -0,0 +1,16 @@
+import { UPDATE_FIELDS_OPTIONS } from 'src/constants/update-fields-options';
+import { type UpdateFieldsOption } from 'src/types/update-fields-option';
+
+export const resolveUpdateFieldsMode = (
+  updateFields?: UpdateFieldsOption,
+): { shouldPersist: boolean; overrideExistingValues: boolean } => {
+  if (updateFields === UPDATE_FIELDS_OPTIONS.no) {
+    return { shouldPersist: false, overrideExistingValues: false };
+  }
+
+  if (updateFields === UPDATE_FIELDS_OPTIONS.overwrite) {
+    return { shouldPersist: true, overrideExistingValues: true };
+  }
+
+  return { shouldPersist: true, overrideExistingValues: false };
+};

package/src/logic-functions/utils/run-batch-enrichment.ts

@@ -0,0 +1,50 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { aggregateBulkEnrichResult } from 'src/logic-functions/utils/aggregate-bulk-enrich-result';
+import {
+  buildErrorResult,
+  ENRICHMENT_FAILED_MESSAGE,
+} from 'src/logic-functions/utils/build-error-result';
+import { chunk } from 'src/logic-functions/utils/chunk';
+import { enrichChunk } from 'src/logic-functions/utils/enrich-chunk';
+import { extractRecordIds } from 'src/logic-functions/utils/extract-record-ids';
+import { type BatchEnrichmentAdapter } from 'src/types/batch-enrichment-adapter';
+import { type BulkEnrichInput } from 'src/types/bulk-enrich-input';
+import { type BulkEnrichResult } from 'src/types/bulk-enrich-result';
+import { type CompanyIdByMatchKeyCache } from 'src/types/company-id-by-match-key-cache';
+import { type EnrichResult } from 'src/types/enrich-result';
+
+const PDL_BATCH_SIZE = 100;
+
+export const runBatchEnrichment = async <TNode, TData, TParams>({
+  client,
+  input,
+  adapter,
+}: {
+  client: CoreApiClient;
+  input: BulkEnrichInput;
+  adapter: BatchEnrichmentAdapter<TNode, TData, TParams>;
+}): Promise<BulkEnrichResult> => {
+  const recordIds = Array.from(new Set(extractRecordIds(input.records)));
+  const resultById = new Map<string, EnrichResult>();
+  const companyIdByMatchKeyCache: CompanyIdByMatchKeyCache = new Map();
+
+  for (const recordIdsChunk of chunk({ items: recordIds, size: PDL_BATCH_SIZE })) {
+    await enrichChunk({
+      client,
+      recordIds: recordIdsChunk,
+      input,
+      adapter,
+      resultById,
+      companyIdByMatchKeyCache,
+    });
+  }
+
+  const results = recordIds.map(
+    (recordId) =>
+      resultById.get(recordId) ??
+      buildErrorResult({ recordId, error: ENRICHMENT_FAILED_MESSAGE }),
+  );
+
+  return aggregateBulkEnrichResult(results);
+};

package/src/logic-functions/utils/run-single-enrichment.ts

@@ -0,0 +1,44 @@
+import { isNonEmptyString } from '@sniptt/guards';
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import {
+  buildErrorResult,
+  ENRICHMENT_FAILED_MESSAGE,
+} from 'src/logic-functions/utils/build-error-result';
+import { runBatchEnrichment } from 'src/logic-functions/utils/run-batch-enrichment';
+import { type BatchEnrichmentAdapter } from 'src/types/batch-enrichment-adapter';
+import { type EnrichResult } from 'src/types/enrich-result';
+import { type SingleEnrichInput } from 'src/types/single-enrich-input';
+
+const NO_RECORD_ID_MESSAGE = 'No record id was provided to enrich.';
+
+export const runSingleEnrichment = async <TNode, TData, TParams>({
+  client,
+  input,
+  adapter,
+}: {
+  client: CoreApiClient;
+  input: SingleEnrichInput;
+  adapter: BatchEnrichmentAdapter<TNode, TData, TParams>;
+}): Promise<EnrichResult> => {
+  const recordId = input.recordId?.trim();
+
+  if (!isNonEmptyString(recordId)) {
+    return buildErrorResult({ recordId: '', error: NO_RECORD_ID_MESSAGE });
+  }
+
+  const bulkResult = await runBatchEnrichment({
+    client,
+    input: {
+      records: recordId,
+      updateFields: input.updateFields,
+      minLikelihood: input.minLikelihood,
+    },
+    adapter,
+  });
+
+  return (
+    bulkResult.results[0] ??
+    buildErrorResult({ recordId, error: ENRICHMENT_FAILED_MESSAGE })
+  );
+};

package/src/logic-functions/utils/salary-transform.ts

@@ -0,0 +1,18 @@
+import { stripSeparators } from 'src/utils/strip-separators';
+
+const SALARY_LOOKUP: Record<string, string> = {
+  '<20000': 'UNDER_20000',
+  '20000-25000': 'FROM_20000_TO_25000',
+  '25000-35000': 'FROM_25000_TO_35000',
+  '35000-45000': 'FROM_35000_TO_45000',
+  '45000-55000': 'FROM_45000_TO_55000',
+  '55000-70000': 'FROM_55000_TO_70000',
+  '70000-85000': 'FROM_70000_TO_85000',
+  '85000-100000': 'FROM_85000_TO_100000',
+  '100000-150000': 'FROM_100000_TO_150000',
+  '150000-250000': 'FROM_150000_TO_250000',
+  '>250000': 'OVER_250000',
+};
+
+export const salaryTransform = (raw: string): string | undefined =>
+  SALARY_LOOKUP[stripSeparators(raw)];

package/src/logic-functions/utils/seed-enrichment-workflow.ts

@@ -0,0 +1,131 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { PdlOperationError } from 'src/logic-functions/errors/pdl-operation-error';
+import { buildBulkRecordsTrigger } from 'src/logic-functions/utils/build-bulk-records-trigger';
+import { buildLogicFunctionStep } from 'src/logic-functions/utils/build-logic-function-step';
+import { findExistingWorkflowId } from 'src/logic-functions/utils/find-existing-workflow-id';
+import { type EnrichmentWorkflowSeed } from 'src/types/enrichment-workflow-seed';
+import { type SeedEnrichmentWorkflowResult } from 'src/types/seed-enrichment-workflow-result';
+import { isDefined } from 'src/utils/is-defined';
+
+const TRIGGER_STEP_ID = 'trigger';
+
+export const seedEnrichmentWorkflow = async ({
+  client,
+  logicFunctionId,
+  seed,
+}: {
+  client: CoreApiClient;
+  logicFunctionId: string;
+  seed: EnrichmentWorkflowSeed;
+}): Promise<SeedEnrichmentWorkflowResult> => {
+  const existingWorkflowId = await findExistingWorkflowId({
+    client,
+    name: seed.workflowName,
+  });
+
+  if (isDefined(existingWorkflowId)) {
+    return {
+      objectNameSingular: seed.objectNameSingular,
+      workflowName: seed.workflowName,
+      status: 'skipped',
+      workflowId: existingWorkflowId,
+    };
+  }
+
+  const createResult = (await client.mutation({
+    createWorkflow: {
+      __args: { data: { name: seed.workflowName } },
+      id: true,
+    },
+  })) as { createWorkflow?: { id?: string } };
+
+  const workflowId = createResult.createWorkflow?.id;
+
+  if (!isDefined(workflowId)) {
+    throw new PdlOperationError(
+      `Failed to create workflow "${seed.workflowName}": no id returned.`,
+    );
+  }
+
+  const versionsResult = (await client.query({
+    workflowVersions: {
+      __args: { filter: { workflowId: { eq: workflowId } } },
+      edges: { node: { id: true, status: true } },
+    },
+  })) as {
+    workflowVersions?: { edges?: { node?: { id?: string; status?: string } }[] };
+  };
+
+  const draftVersionId = versionsResult.workflowVersions?.edges?.find(
+    (edge) => edge.node?.status === 'DRAFT',
+  )?.node?.id;
+
+  if (!isDefined(draftVersionId)) {
+    throw new PdlOperationError(
+      `No draft version found for workflow "${seed.workflowName}".`,
+    );
+  }
+
+  const stepId = crypto.randomUUID();
+
+  const trigger = buildBulkRecordsTrigger({
+    objectNameSingular: seed.objectNameSingular,
+    name: seed.triggerName,
+    icon: seed.icon,
+  });
+
+  await client.mutation({
+    updateWorkflowVersion: {
+      __args: { id: draftVersionId, data: { trigger } },
+      id: true,
+    },
+  });
+
+  const callMutationNotYetInClientSchema = (
+    request: unknown,
+  ): Promise<unknown> => client.mutation(request as never);
+
+  await callMutationNotYetInClientSchema({
+    createWorkflowVersionStep: {
+      __args: {
+        input: {
+          workflowVersionId: draftVersionId,
+          stepType: 'LOGIC_FUNCTION',
+          parentStepId: TRIGGER_STEP_ID,
+          id: stepId,
+          defaultSettings: { input: { logicFunctionId } },
+        },
+      },
+      triggerDiff: true,
+      stepsDiff: true,
+    },
+  });
+
+  const step = buildLogicFunctionStep({
+    id: stepId,
+    name: seed.stepName,
+    logicFunctionId,
+    logicFunctionInput: seed.logicFunctionInput,
+  });
+
+  await callMutationNotYetInClientSchema({
+    updateWorkflowVersionStep: {
+      __args: { input: { workflowVersionId: draftVersionId, step } },
+      id: true,
+    },
+  });
+
+  await callMutationNotYetInClientSchema({
+    activateWorkflowVersion: {
+      __args: { workflowVersionId: draftVersionId },
+    },
+  });
+
+  return {
+    objectNameSingular: seed.objectNameSingular,
+    workflowName: seed.workflowName,
+    status: 'created',
+    workflowId,
+  };
+};

package/src/logic-functions/utils/size-transform.ts

@@ -0,0 +1,15 @@
+import { stripSeparators } from 'src/utils/strip-separators';
+
+const SIZE_LOOKUP: Record<string, string> = {
+  '1-10': 'ONE_TO_TEN',
+  '11-50': 'ELEVEN_TO_FIFTY',
+  '51-200': 'FIFTY_ONE_TO_TWO_HUNDRED',
+  '201-500': 'TWO_HUNDRED_ONE_TO_FIVE_HUNDRED',
+  '501-1000': 'FIVE_HUNDRED_ONE_TO_ONE_THOUSAND',
+  '1001-5000': 'ONE_THOUSAND_ONE_TO_FIVE_THOUSAND',
+  '5001-10000': 'FIVE_THOUSAND_ONE_TO_TEN_THOUSAND',
+  '10001+': 'TEN_THOUSAND_ONE_PLUS',
+};
+
+export const sizeTransform = (raw: string): string | undefined =>
+  SIZE_LOOKUP[stripSeparators(raw)];

package/src/logic-functions/utils/to-bulk-enrich-input.ts

@@ -0,0 +1,14 @@
+import { isObject } from '@sniptt/guards';
+import { type RoutePayload } from 'twenty-sdk/define';
+
+import { type BulkEnrichInput } from 'src/types/bulk-enrich-input';
+
+type EnrichRouteBody = { recordIds?: string[] };
+
+export type EnrichInput = BulkEnrichInput | RoutePayload<EnrichRouteBody>;
+
+const isRoutePayload = (input: EnrichInput): input is RoutePayload<EnrichRouteBody> =>
+  isObject(input) && 'requestContext' in input;
+
+export const toBulkEnrichInput = (input: EnrichInput): BulkEnrichInput =>
+  isRoutePayload(input) ? { records: input.body?.recordIds ?? [] } : input;

package/src/logic-functions/utils/to-json-array.ts

@@ -0,0 +1,4 @@
+import { isNonEmptyArray } from '@sniptt/guards';
+
+export const toJsonArray = (value: unknown): unknown[] | undefined =>
+  isNonEmptyArray(value) ? value : undefined;

package/src/logic-functions/utils/to-json-object.ts

@@ -0,0 +1,22 @@
+import { isArray, isObject } from '@sniptt/guards';
+
+export const toJsonObject = (
+  value: unknown,
+): Record<string, unknown> | undefined => {
+  if (!isObject(value) || isArray(value)) {
+    return undefined;
+  }
+
+  const valuePrototype = Object.getPrototypeOf(value);
+  const isPlainObject =
+    valuePrototype === Object.prototype || valuePrototype === null;
+  if (!isPlainObject) {
+    return undefined;
+  }
+
+  if (Object.keys(value).length === 0) {
+    return undefined;
+  }
+
+  return value as Record<string, unknown>;
+};

package/src/logic-functions/utils/to-number.ts

@@ -0,0 +1,4 @@
+import { isNumber } from '@sniptt/guards';
+
+export const toNumber = (value: unknown): number | undefined =>
+  isNumber(value) && Number.isFinite(value) ? value : undefined;

package/src/logic-functions/utils/to-string-array.ts

@@ -0,0 +1,28 @@
+import { isArray, isNonEmptyArray } from '@sniptt/guards';
+
+import { toText } from 'src/logic-functions/utils/to-text';
+import { isDefined } from 'src/utils/is-defined';
+
+export const toStringArray = (value: unknown): string[] | undefined => {
+  if (!isArray(value)) {
+    return undefined;
+  }
+
+  const uniqueStrings: string[] = [];
+  const seenLowercaseValues = new Set<string>();
+
+  for (const entry of value) {
+    const stringValue = toText(entry);
+    if (!isDefined(stringValue)) {
+      continue;
+    }
+
+    const lowercaseValue = stringValue.toLowerCase();
+    if (!seenLowercaseValues.has(lowercaseValue)) {
+      seenLowercaseValues.add(lowercaseValue);
+      uniqueStrings.push(stringValue);
+    }
+  }
+
+  return isNonEmptyArray(uniqueStrings) ? uniqueStrings : undefined;
+};

package/src/logic-functions/utils/to-text.ts

@@ -0,0 +1,11 @@
+import { isNonEmptyString, isString } from '@sniptt/guards';
+
+export const toText = (value: unknown): string | undefined => {
+  if (!isString(value)) {
+    return undefined;
+  }
+
+  const trimmed = value.trim();
+
+  return isNonEmptyString(trimmed) ? trimmed : undefined;
+};

package/src/logic-functions/utils/update-companies-status.ts

@@ -0,0 +1,18 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+export const updateCompaniesStatus = async ({
+  client,
+  recordIds,
+  data,
+}: {
+  client: CoreApiClient;
+  recordIds: string[];
+  data: Record<string, unknown>;
+}): Promise<void> => {
+  await client.mutation({
+    updateCompanies: {
+      __args: { filter: { id: { in: recordIds } }, data },
+      id: true,
+    },
+  });
+};

package/src/logic-functions/utils/update-company-record.ts

@@ -0,0 +1,15 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+export const updateCompanyRecord = async ({
+  client,
+  recordId,
+  data,
+}: {
+  client: CoreApiClient;
+  recordId: string;
+  data: Record<string, unknown>;
+}): Promise<void> => {
+  await client.mutation({
+    updateCompany: { __args: { id: recordId, data }, id: true },
+  });
+};

package/src/logic-functions/utils/update-people-status.ts

@@ -0,0 +1,18 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+export const updatePeopleStatus = async ({
+  client,
+  recordIds,
+  data,
+}: {
+  client: CoreApiClient;
+  recordIds: string[];
+  data: Record<string, unknown>;
+}): Promise<void> => {
+  await client.mutation({
+    updatePeople: {
+      __args: { filter: { id: { in: recordIds } }, data },
+      id: true,
+    },
+  });
+};

package/src/logic-functions/utils/update-person-record.ts

@@ -0,0 +1,15 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+export const updatePersonRecord = async ({
+  client,
+  recordId,
+  data,
+}: {
+  client: CoreApiClient;
+  recordId: string;
+  data: Record<string, unknown>;
+}): Promise<void> => {
+  await client.mutation({
+    updatePerson: { __args: { id: recordId, data }, id: true },
+  });
+};

package/src/roles/default-function.role.ts

@@ -0,0 +1,41 @@
+import {
+  defineApplicationRole,
+  STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS,
+  SystemPermissionFlag,
+} from 'twenty-sdk/define';
+
+import { DEFAULT_ROLE_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';
+
+export default defineApplicationRole({
+  universalIdentifier: DEFAULT_ROLE_UNIVERSAL_IDENTIFIER,
+  label: 'People Data Labs enrichment role',
+  description: 'Reads and updates People/Companies to write enrichment data.',
+  canReadAllObjectRecords: false,
+  canUpdateAllObjectRecords: false,
+  canSoftDeleteAllObjectRecords: false,
+  canDestroyAllObjectRecords: false,
+  canUpdateAllSettings: false,
+  canBeAssignedToAgents: false,
+  canBeAssignedToUsers: false,
+  canBeAssignedToApiKeys: false,
+  objectPermissions: [
+    {
+      objectUniversalIdentifier:
+        STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.person.universalIdentifier,
+      canReadObjectRecords: true,
+      canUpdateObjectRecords: true,
+      canSoftDeleteObjectRecords: false,
+      canDestroyObjectRecords: false,
+    },
+    {
+      objectUniversalIdentifier:
+        STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.company.universalIdentifier,
+      canReadObjectRecords: true,
+      canUpdateObjectRecords: true,
+      canSoftDeleteObjectRecords: false,
+      canDestroyObjectRecords: false,
+    },
+  ],
+  fieldPermissions: [],
+  permissionFlagUniversalIdentifiers: [SystemPermissionFlag.WORKFLOWS],
+});

package/src/types/address-parts.ts

@@ -0,0 +1,9 @@
+export type AddressParts = {
+  street1?: string | null;
+  street2?: string | null;
+  city?: string | null;
+  postcode?: string | null;
+  state?: string | null;
+  country?: string | null;
+  geo?: string | null;
+};

package/src/types/address-value.ts

@@ -0,0 +1,10 @@
+export type AddressValue = {
+  addressStreet1: string;
+  addressStreet2: string;
+  addressCity: string;
+  addressPostcode: string;
+  addressState: string;
+  addressCountry: string;
+  addressLat: number | null;
+  addressLng: number | null;
+};

package/src/types/batch-enrichment-adapter.ts

@@ -0,0 +1,43 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { type BulkEnrichInput } from 'src/types/bulk-enrich-input';
+import { type CompanyIdByMatchKeyCache } from 'src/types/company-id-by-match-key-cache';
+import { type PdlEnrichResult } from 'src/types/pdl-enrich-result';
+
+export type BatchEnrichmentAdapter<TNode, TData, TParams> = {
+  objectNameSingular: string;
+  noIdentifierMessage: string;
+  costPerMatchDollars: number;
+  readRecords: (args: {
+    client: CoreApiClient;
+    recordIds: string[];
+  }) => Promise<TNode[]>;
+  getNodeId: (node: TNode) => string;
+  extractParams: (args: {
+    node: TNode;
+    input: BulkEnrichInput;
+  }) => TParams | undefined;
+  enrichBatch: (params: TParams[]) => Promise<PdlEnrichResult<TData>[]>;
+  buildMatchedData: (args: {
+    client: CoreApiClient;
+    node: TNode;
+    outcome: { likelihood?: number; data: TData };
+    enrichedAt: string;
+    companyIdByMatchKeyCache: CompanyIdByMatchKeyCache;
+    overrideExistingValues: boolean;
+    shouldPersist: boolean;
+  }) => Promise<{
+    mappedData: Record<string, unknown>;
+    persistData: Record<string, unknown>;
+  }>;
+  updateOne: (args: {
+    client: CoreApiClient;
+    recordId: string;
+    data: Record<string, unknown>;
+  }) => Promise<void>;
+  updateManyStatus: (args: {
+    client: CoreApiClient;
+    recordIds: string[];
+    data: Record<string, unknown>;
+  }) => Promise<void>;
+};

package/src/types/bulk-enrich-input.ts

@@ -0,0 +1,9 @@
+import { type UpdateFieldsOption } from 'src/types/update-fields-option';
+
+export type RecordInput = string | { id?: string | null };
+
+export type BulkEnrichInput = {
+  records: RecordInput | RecordInput[];
+  updateFields?: UpdateFieldsOption;
+  minLikelihood?: number;
+};

package/src/types/bulk-enrich-result.ts

@@ -0,0 +1,11 @@
+import { type EnrichResult } from 'src/types/enrich-result';
+
+export type BulkEnrichResult = {
+  success: boolean;
+  total: number;
+  matched: number;
+  notFound: number;
+  skipped: number;
+  errored: number;
+  results: EnrichResult[];
+};

package/src/types/company-id-by-match-key-cache.ts

@@ -0,0 +1 @@
+export type CompanyIdByMatchKeyCache = Map<string, string | undefined>;

package/src/types/company-match-keys.ts

@@ -0,0 +1,6 @@
+export type CompanyMatchKeys = {
+  pdlId?: string;
+  website?: string;
+  linkedinUrl?: string;
+  name?: string;
+};

package/src/types/company-node.ts

@@ -0,0 +1,16 @@
+export type CompanyNode = {
+  id: string;
+  name?: string | null;
+  domainName?: { primaryLinkUrl?: string | null } | null;
+  linkedinLink?: { primaryLinkUrl?: string | null } | null;
+  address?: {
+    addressStreet1?: string | null;
+    addressStreet2?: string | null;
+    addressCity?: string | null;
+    addressPostcode?: string | null;
+    addressState?: string | null;
+    addressCountry?: string | null;
+  } | null;
+  pdlId?: string | null;
+  pdlLastEnrichedAt?: string | null;
+};

package/src/types/currency-value.ts

@@ -0,0 +1,4 @@
+export type CurrencyValue = {
+  amountMicros: number;
+  currencyCode: string;
+};

package/src/types/emails-value.ts

@@ -0,0 +1,4 @@
+export type EmailsValue = {
+  primaryEmail: string;
+  additionalEmails: string[] | null;
+};

package/src/types/enrich-result.ts

@@ -0,0 +1,11 @@
+import { type EnrichStatus } from 'src/types/enrich-status';
+
+export type EnrichResult = {
+  success: boolean;
+  recordId: string;
+  status: EnrichStatus;
+  updatedFields: string[];
+  data?: Record<string, unknown>;
+  message: string;
+  error?: string;
+};

package/src/types/enrich-status.ts

@@ -0,0 +1 @@
+export type EnrichStatus = 'MATCHED' | 'NOT_FOUND' | 'ERROR' | 'SKIPPED';

package/src/types/enrichment-workflow-seed.ts

@@ -0,0 +1,9 @@
+export type EnrichmentWorkflowSeed = {
+  objectNameSingular: string;
+  workflowName: string;
+  triggerName: string;
+  icon: string;
+  stepName: string;
+  logicFunctionUniversalIdentifier: string;
+  logicFunctionInput: Record<string, unknown>;
+};