@haiiro/docuflow 0.0.0-stage → 0.0.2

package/src/server/bitrix-page.ts

@@ -0,0 +1,52 @@
+import { escapeHtml } from 'src/shared/bitrix/bitrix.util';
+
+const BX24_SDK_URL = 'https://api.bitrix24.com/api/v1/';
+
+export type BitrixPageTask = { title: string; url?: string; dueAt?: string };
+
+// The page shown inside the portal frame. It opens the CRM in a new browser
+// tab: a CRM session in a third-party frame depends on cookie rules the app
+// cannot change on a plain Twenty.
+export const renderBitrixPage = ({
+  title,
+  message,
+  crmUrl,
+  tasks,
+  isInstall,
+}: {
+  title: string;
+  message: string;
+  crmUrl?: string;
+  tasks: BitrixPageTask[];
+  isInstall: boolean;
+}): string => `<!doctype html>
+<html lang="ru">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(title)}</title>
+<script src="${BX24_SDK_URL}"></script>
+<style>
+  body { font-family: -apple-system, "Segoe UI", Roboto, sans-serif; margin: 0; padding: 24px; color: #333; background: #fff; }
+  h1 { font-size: 20px; margin: 0 0 8px; }
+  p { color: #666; margin: 0 0 16px; }
+  a.button { display: inline-block; padding: 8px 16px; border-radius: 8px; background: #1961ed; color: #fff; text-decoration: none; }
+  ul { list-style: none; padding: 0; margin: 16px 0 0; }
+  li { padding: 8px 0; border-top: 1px solid #eee; display: flex; justify-content: space-between; gap: 16px; }
+  li a { color: #1961ed; text-decoration: none; }
+  .due { color: #999; white-space: nowrap; }
+</style>
+</head>
+<body>
+<h1>${escapeHtml(title)}</h1>
+<p>${escapeHtml(message)}</p>
+${crmUrl !== undefined ? `<a class="button" href="${escapeHtml(crmUrl)}" target="_blank" rel="noopener">Открыть документооборот</a>` : ''}
+${tasks.length > 0 ? `<ul>${tasks
+  .map(
+    (task) =>
+      `<li>${task.url !== undefined ? `<a href="${escapeHtml(task.url)}" target="_blank" rel="noopener">${escapeHtml(task.title)}</a>` : escapeHtml(task.title)}<span class="due">${escapeHtml(task.dueAt ?? '')}</span></li>`,
+  )
+  .join('')}</ul>` : ''}
+${isInstall ? '<script>if (window.BX24) { BX24.init(function () { BX24.installFinish(); }); }</script>' : ''}
+</body>
+</html>`;

package/src/server/bitrix-portal.ts

@@ -0,0 +1,67 @@
+import { kv } from 'twenty-sdk/logic-function';
+
+import { type BitrixPortal, type BitrixRequest } from 'src/shared/bitrix/bitrix.type';
+import { BITRIX_PORTAL_KV_KEY } from 'src/shared/bitrix/bitrix.util';
+import {
+  BitrixError,
+  exchangeBitrixRefreshToken,
+  withFreshBitrixToken,
+} from 'src/shared/bitrix/bitrix-client';
+
+// One Bitrix24 portal per workspace: a company works in one portal.
+export const loadBitrixPortal = (): Promise<BitrixPortal | null> =>
+  kv.get<BitrixPortal>(BITRIX_PORTAL_KV_KEY);
+
+export const saveBitrixPortal = (portal: BitrixPortal): Promise<void> =>
+  kv.set(BITRIX_PORTAL_KV_KEY, portal);
+
+export const forgetBitrixPortal = (): Promise<boolean> =>
+  kv.delete(BITRIX_PORTAL_KV_KEY);
+
+// A request from the portal proves itself by its refresh token. The first
+// proven portal is linked; another portal is refused, so a stranger cannot
+// take over the workspace's link.
+export const proveAndLinkBitrixPortal = async (
+  request: BitrixRequest,
+): Promise<BitrixPortal & { bitrixUserId?: string }> => {
+  if (request.refreshId === undefined) {
+    throw new BitrixError('The request carries no refresh token');
+  }
+
+  const grant = await exchangeBitrixRefreshToken(request.refreshId);
+  const linkedPortal = await loadBitrixPortal();
+
+  if (linkedPortal !== null && linkedPortal.memberId !== grant.memberId) {
+    throw new BitrixError('Another Bitrix24 portal is linked to this workspace');
+  }
+
+  const portal: BitrixPortal = {
+    memberId: grant.memberId,
+    portalDomain: grant.portalDomain,
+    restEndpoint: grant.restEndpoint,
+    accessToken: grant.accessToken,
+    refreshToken: grant.refreshToken,
+    expiresAt: grant.expiresAt,
+    applicationToken: linkedPortal?.applicationToken,
+  };
+
+  await saveBitrixPortal(portal);
+
+  return { ...portal, bitrixUserId: grant.bitrixUserId };
+};
+
+export const getLinkedBitrixPortal = async (): Promise<BitrixPortal | null> => {
+  const linkedPortal = await loadBitrixPortal();
+
+  if (linkedPortal === null) {
+    return null;
+  }
+
+  const { portal, isRefreshed } = await withFreshBitrixToken(linkedPortal);
+
+  if (isRefreshed) {
+    await saveBitrixPortal(portal);
+  }
+
+  return portal;
+};

package/src/server/document-capture.ts

@@ -0,0 +1,102 @@
+import { MetadataApiClient } from 'twenty-client-sdk/metadata';
+
+import { restEq } from 'src/shared/api/rest-filter.util';
+import { readRestList, readRestRecord } from 'src/shared/api/rest-response.util';
+import {
+  formatRecordLabel,
+  getDocumentNameFromFile,
+  readFileItems,
+} from 'src/shared/documents/attachment-target.util';
+import { getObjectSummaries } from 'src/shared/api/object-summaries';
+import { getTask, restClient } from 'src/server/records';
+import { DOCUMENT_FILE_UNIVERSAL_IDENTIFIER } from 'src/universal-identifiers';
+
+export type FileCapture = {
+  attachmentId: string;
+  fileId: string;
+  label: string;
+  sourceObjectName: string;
+  sourceRecordId: string;
+  workspaceMemberId: string | null;
+};
+
+export type CaptureResult = 'CREATED' | 'ALREADY_CAPTURED' | 'FILE_GONE';
+
+const findSourceRecordName = async (
+  objectName: string,
+  recordId: string,
+): Promise<string | null> => {
+  const summary = (await getObjectSummaries()).get(objectName);
+
+  if (summary === undefined || summary.labelFieldName === undefined) {
+    return null;
+  }
+
+  const record = readRestRecord<Record<string, unknown>>(
+    await restClient('application')
+      .get(`/rest/${summary.namePlural}/${recordId}`)
+      .catch(() => null),
+  );
+  const label = formatRecordLabel(record?.[summary.labelFieldName]);
+
+  return label === undefined ? summary.labelSingular : `${summary.labelSingular}: ${label}`;
+};
+
+// The document keeps its own copy of the file: a file belongs to one FILES
+// field, and the archive must outlive the record it came from.
+export const captureFile = async (capture: FileCapture): Promise<CaptureResult> => {
+  const existing = readRestList<{ id: string }>(
+    await restClient('application').get('/rest/smbDocuments', {
+      query: { filter: restEq('sourceFileId', capture.fileId), limit: 1 },
+    }),
+  ).records;
+
+  if (existing.length > 0) {
+    return 'ALREADY_CAPTURED';
+  }
+
+  const attachment = readRestRecord<Record<string, unknown>>(
+    await restClient('application').get(`/rest/attachments/${capture.attachmentId}`),
+  );
+  const file = readFileItems(attachment?.file).find(
+    (item) => item.fileId === capture.fileId,
+  );
+
+  if (file?.url === undefined) {
+    return 'FILE_GONE';
+  }
+
+  const download = await fetch(file.url);
+
+  if (!download.ok) {
+    throw new Error(`The file of attachment ${capture.attachmentId} could not be read (${download.status})`);
+  }
+
+  const uploaded = await new MetadataApiClient().uploadFile({
+    fileBuffer: Buffer.from(await download.arrayBuffer()),
+    filename: capture.label,
+    fieldMetadataUniversalIdentifier: DOCUMENT_FILE_UNIVERSAL_IDENTIFIER,
+  });
+
+  const workflowRunId =
+    capture.sourceObjectName === 'task'
+      ? ((await getTask('application', capture.sourceRecordId))?.smbWorkflowRunId ?? null)
+      : null;
+
+  await restClient('application').post('/rest/smbDocuments', {
+    name: getDocumentNameFromFile(capture.label),
+    file: [{ fileId: uploaded.id, label: capture.label }],
+    origin: workflowRunId !== null ? 'PROCESS' : 'RECORD',
+    sourceObjectName: capture.sourceObjectName,
+    sourceRecordId: capture.sourceRecordId,
+    sourceRecordName: await findSourceRecordName(
+      capture.sourceObjectName,
+      capture.sourceRecordId,
+    ),
+    sourceFileId: capture.fileId,
+    workflowRunId,
+    authorId: capture.workspaceMemberId,
+  });
+
+  return 'CREATED';
+};

package/src/server/http-response.ts

@@ -0,0 +1,18 @@
+import { Response } from 'twenty-sdk/logic-function';
+
+export const jsonResponse = (status: number, body: Record<string, unknown>) =>
+  new Response(JSON.stringify(body), {
+    status,
+    headers: { 'content-type': 'application/json; charset=utf-8' },
+  });
+
+export const htmlResponse = (status: number, html: string) =>
+  new Response(html, {
+    status,
+    headers: { 'content-type': 'text/html; charset=utf-8' },
+  });
+
+export const readJsonBody = (body: unknown): Record<string, unknown> =>
+  typeof body === 'object' && body !== null && !Array.isArray(body)
+    ? (body as Record<string, unknown>)
+    : {};

package/src/server/launch-step.ts

@@ -0,0 +1,166 @@
+import { MetadataApiClient } from 'twenty-client-sdk/metadata';
+
+import {
+  callCoreGraphql,
+  CREATE_DRAFT_FROM_WORKFLOW_VERSION_MUTATION,
+  CREATE_WORKFLOW_VERSION_STEP_MUTATION,
+  DELETE_WORKFLOW_VERSION_STEP_MUTATION,
+  UPDATE_WORKFLOW_VERSION_STEP_MUTATION,
+  UPDATE_WORKFLOW_VERSION_TRIGGER_MUTATION,
+} from 'src/shared/api/core-graphql.util';
+import {
+  LAUNCH_PARAMETERS_STEP_INPUT,
+  LAUNCH_PARAMETERS_STEP_NAME,
+  TRIGGER_STEP_ID,
+} from 'src/shared/docflow.constants';
+import { type FormField } from 'src/shared/form/form-field.type';
+import { buildFieldsOutputSchema } from 'src/shared/form/form-field-builder.util';
+import { findLaunchParametersStep } from 'src/shared/workflow/launch-step.util';
+import { listWorkflowVersions, type WorkflowVersionRecord } from 'src/server/records';
+import { LAUNCH_PARAMETERS_STEP_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER } from 'src/universal-identifiers';
+
+export type LaunchStepResult =
+  | { status: 'SAVED'; workflowVersionId: string; stepId: string | null }
+  | { status: 'NOT_MANUAL' };
+
+const MANUAL_TRIGGER = {
+  name: 'Запуск вручную',
+  type: 'MANUAL',
+  position: { x: 0, y: 0 },
+  settings: {
+    outputSchema: {},
+    availability: { type: 'GLOBAL' },
+    icon: 'IconPlayerPlay',
+    isPinned: false,
+  },
+  nextStepIds: [],
+};
+
+// The step of the workflow editor is created with the function's id in this
+// workspace; the app knows the function by its universal identifier.
+const findLaunchStepLogicFunctionId = async (): Promise<string> => {
+  const { findManyLogicFunctions } = await new MetadataApiClient().query({
+    findManyLogicFunctions: { id: true, universalIdentifier: true },
+  });
+  const logicFunction = findManyLogicFunctions.find(
+    ({ universalIdentifier }) =>
+      universalIdentifier === LAUNCH_PARAMETERS_STEP_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+  );
+
+  if (logicFunction === undefined) {
+    throw new Error('The "Launch with parameters" function is not installed');
+  }
+
+  return logicFunction.id;
+};
+
+// Only a draft can change: an existing one, or a new one copied from the
+// latest version, as the editor does when a published process is edited.
+const findOrCreateDraft = async (workflowId: string): Promise<WorkflowVersionRecord | undefined> => {
+  const versions = await listWorkflowVersions('person', workflowId);
+  const draft = versions.find(({ status }) => status === 'DRAFT');
+
+  if (draft !== undefined || versions.length === 0) {
+    return draft;
+  }
+
+  await callCoreGraphql({
+    query: CREATE_DRAFT_FROM_WORKFLOW_VERSION_MUTATION,
+    variables: { input: { workflowId, workflowVersionIdToCopy: versions[0].id } },
+  });
+
+  return (await listWorkflowVersions('person', workflowId)).find(({ status }) => status === 'DRAFT');
+};
+
+// Puts the "Launch with parameters" step right after the manual trigger of the
+// draft and describes its output with the parameter fields, so the editor
+// offers them as variables of later steps. No fields, no step.
+export const syncLaunchStep = async ({
+  workflowId,
+  fields,
+}: {
+  workflowId: string;
+  fields: FormField[];
+}): Promise<LaunchStepResult | undefined> => {
+  let draft = await findOrCreateDraft(workflowId);
+
+  if (draft === undefined) {
+    return undefined;
+  }
+
+  if (draft.trigger === null || draft.trigger === undefined) {
+    await callCoreGraphql({
+      query: UPDATE_WORKFLOW_VERSION_TRIGGER_MUTATION,
+      variables: { input: { workflowVersionId: draft.id, trigger: MANUAL_TRIGGER } },
+    });
+    draft = { ...draft, trigger: MANUAL_TRIGGER };
+  }
+
+  if (draft.trigger?.type !== 'MANUAL') {
+    return { status: 'NOT_MANUAL' };
+  }
+
+  const existingStep = findLaunchParametersStep(draft.steps);
+
+  if (fields.length === 0) {
+    if (existingStep !== undefined) {
+      await callCoreGraphql({
+        query: DELETE_WORKFLOW_VERSION_STEP_MUTATION,
+        variables: { input: { workflowVersionId: draft.id, stepId: existingStep.id } },
+      });
+    }
+
+    return { status: 'SAVED', workflowVersionId: draft.id, stepId: null };
+  }
+
+  let step = existingStep;
+
+  if (step === undefined) {
+    const stepId = crypto.randomUUID();
+
+    await callCoreGraphql({
+      query: CREATE_WORKFLOW_VERSION_STEP_MUTATION,
+      variables: {
+        input: {
+          workflowVersionId: draft.id,
+          id: stepId,
+          stepType: 'LOGIC_FUNCTION',
+          parentStepId: TRIGGER_STEP_ID,
+          nextStepId: draft.trigger.nextStepIds?.[0],
+          defaultSettings: {
+            input: {
+              logicFunctionId: await findLaunchStepLogicFunctionId(),
+              logicFunctionInput: { parameters: LAUNCH_PARAMETERS_STEP_INPUT },
+            },
+          },
+        },
+      },
+    });
+
+    const versions = await listWorkflowVersions('person', workflowId);
+
+    step = versions
+      .find(({ id }) => id === draft?.id)
+      ?.steps?.find(({ id }) => id === stepId);
+
+    if (step === undefined) {
+      throw new Error(`The launch step ${stepId} was not created`);
+    }
+  }
+
+  await callCoreGraphql({
+    query: UPDATE_WORKFLOW_VERSION_STEP_MUTATION,
+    variables: {
+      input: {
+        workflowVersionId: draft.id,
+        step: {
+          ...step,
+          name: LAUNCH_PARAMETERS_STEP_NAME,
+          settings: { ...step.settings, outputSchema: buildFieldsOutputSchema(fields) },
+        },
+      },
+    },
+  });
+
+  return { status: 'SAVED', workflowVersionId: draft.id, stepId: step.id };
+};

package/src/server/process-tasks.ts

@@ -0,0 +1,116 @@
+import { DOCFLOW_SECTION, CRM_SECTION, TASK_DONE_STATUS, TASK_TODO_STATUS } from 'src/shared/docflow.constants';
+import { parseFormFields } from 'src/shared/form/form-fields.util';
+import { getRunTargetRecord } from 'src/shared/workflow/run-target-record.util';
+import { getFormStepTaskRequests } from 'src/shared/workflow/workflow-run.util';
+import {
+  createTask,
+  createTaskTarget,
+  findOpenTasksOfRun,
+  findTaskByThreadId,
+  getWorkflow,
+  getWorkflowRun,
+  updateTask,
+  type WorkflowRunRecord,
+} from 'src/server/records';
+
+export type HandOutResult = 'CREATED' | 'ALREADY_HANDED_OUT' | 'NOT_WAITING';
+
+// Creates the CRM task of one waiting FORM step. The run is read again: the
+// job may run after the step was answered or the task created.
+export const handOutFormStep = async ({
+  workflowRunId,
+  stepId,
+  threadId,
+}: {
+  workflowRunId: string;
+  stepId: string;
+  threadId: string;
+}): Promise<HandOutResult> => {
+  if ((await findTaskByThreadId(threadId)) !== undefined) {
+    return 'ALREADY_HANDED_OUT';
+  }
+
+  const run = await getWorkflowRun('application', workflowRunId);
+  const request = getFormStepTaskRequests({
+    state: run?.state,
+    runStarterWorkspaceMemberId: run?.createdBy?.workspaceMemberId,
+    now: new Date(),
+  }).find(
+    (candidate) => candidate.stepId === stepId && candidate.threadId === threadId,
+  );
+
+  if (run === undefined || request === undefined) {
+    return 'NOT_WAITING';
+  }
+
+  const workflow =
+    typeof run.workflowId === 'string'
+      ? await getWorkflow('application', run.workflowId)
+      : undefined;
+
+  const task = await createTask('application', {
+    title: request.title,
+    assigneeId: request.assigneeWorkspaceMemberId,
+    dueAt: request.dueAt ?? null,
+    status: TASK_TODO_STATUS,
+    smbSection:
+      workflow?.smbSection === DOCFLOW_SECTION ? DOCFLOW_SECTION : CRM_SECTION,
+    smbFormSchema: request.fields,
+    smbFormValues: {},
+    smbWorkflowRunId: run.id,
+    smbWorkflowStepId: request.stepId,
+    smbWorkflowThreadId: request.threadId,
+  });
+
+  const target = getRunTargetRecord(run.state);
+
+  // The task stands without the link: a record deleted meanwhile must not
+  // cancel handing it out.
+  if (task !== undefined && target !== undefined) {
+    await createTaskTarget({
+      taskId: task.id,
+      [target.targetFieldName]: target.recordId,
+    }).catch(() => undefined);
+  }
+
+  return 'CREATED';
+};
+
+// A step answered on the run page or by a launch closes its open task with
+// the answer, so the task does not stay open.
+export const closeTasksOfAnsweredSteps = async (
+  run: WorkflowRunRecord,
+): Promise<number> => {
+  const tasks = await findOpenTasksOfRun(run.id);
+  let closedCount = 0;
+
+  for (const task of tasks) {
+    const stepInfo =
+      typeof task.smbWorkflowStepId === 'string'
+        ? run.state?.stepInfos?.[task.smbWorkflowStepId]
+        : undefined;
+
+    if (
+      stepInfo?.status !== 'SUCCESS' ||
+      stepInfo.threadId !== task.smbWorkflowThreadId
+    ) {
+      continue;
+    }
+
+    const answer =
+      typeof stepInfo.result === 'object' && stepInfo.result !== null
+        ? (stepInfo.result as Record<string, unknown>)
+        : {};
+    const fieldNames = parseFormFields(task.smbFormSchema).map(({ name }) => name);
+
+    await updateTask('application', task.id, {
+      smbFormValues: Object.fromEntries(
+        fieldNames.filter((name) => name in answer).map((name) => [name, answer[name]]),
+      ),
+      status: TASK_DONE_STATUS,
+    });
+    closedCount++;
+  }
+
+  return closedCount;
+};

package/src/server/records.ts

@@ -0,0 +1,132 @@
+import { RestApiClient } from 'twenty-client-sdk/rest';
+
+import { restAnd, restEq, restNeq, restIsNull, restOr } from 'src/shared/api/rest-filter.util';
+import { readRestList, readRestRecord } from 'src/shared/api/rest-response.util';
+import { TASK_DONE_STATUS } from 'src/shared/docflow.constants';
+import {
+  type WorkflowRunState,
+  type WorkflowStep,
+  type WorkflowTrigger,
+} from 'src/shared/workflow/workflow-run.type';
+
+// Every record the server functions read or write goes through here, over
+// the REST API: it is the most stable public surface of Twenty, so a new core
+// version changes at most this file.
+export type RunAs = 'person' | 'application';
+
+const clients: Record<RunAs, RestApiClient> = {
+  person: new RestApiClient(),
+  application: new RestApiClient({ runAs: 'application' }),
+};
+
+export const restClient = (runAs: RunAs): RestApiClient => clients[runAs];
+
+export type DocflowTaskRecord = {
+  id: string;
+  title?: string | null;
+  status?: string | null;
+  assigneeId?: string | null;
+  smbSection?: string | null;
+  smbFormSchema?: unknown;
+  smbFormValues?: unknown;
+  smbWorkflowRunId?: string | null;
+  smbWorkflowStepId?: string | null;
+  smbWorkflowThreadId?: string | null;
+};
+
+export type WorkflowRunRecord = {
+  id: string;
+  name?: string | null;
+  status?: string | null;
+  workflowId?: string | null;
+  state?: WorkflowRunState | null;
+  createdBy?: { workspaceMemberId?: string | null } | null;
+};
+
+export type WorkflowRecord = {
+  id: string;
+  smbSection?: string | null;
+  smbLaunchFields?: unknown;
+};
+
+export type WorkflowVersionRecord = {
+  id: string;
+  status?: string | null;
+  workflowId?: string | null;
+  trigger?: WorkflowTrigger | null;
+  steps?: WorkflowStep[] | null;
+};
+
+export const getTask = async (runAs: RunAs, taskId: string) =>
+  readRestRecord<DocflowTaskRecord>(
+    await restClient(runAs).get(`/rest/tasks/${taskId}`),
+  );
+
+export const updateTask = async (
+  runAs: RunAs,
+  taskId: string,
+  data: Partial<Omit<DocflowTaskRecord, 'id'>> & Record<string, unknown>,
+) =>
+  readRestRecord<DocflowTaskRecord>(
+    await restClient(runAs).patch(`/rest/tasks/${taskId}`, data),
+  );
+
+export const createTask = async (
+  runAs: RunAs,
+  data: Record<string, unknown>,
+) =>
+  readRestRecord<DocflowTaskRecord>(
+    await restClient(runAs).post('/rest/tasks', data),
+  );
+
+export const findTaskByThreadId = async (threadId: string) =>
+  readRestList<DocflowTaskRecord>(
+    await restClient('application').get('/rest/tasks', {
+      query: { filter: restEq('smbWorkflowThreadId', threadId), limit: 1 },
+    }),
+  ).records[0];
+
+export const findOpenTasksOfRun = async (workflowRunId: string) =>
+  readRestList<DocflowTaskRecord>(
+    await restClient('application').get('/rest/tasks', {
+      query: {
+        filter: restAnd(
+          restEq('smbWorkflowRunId', workflowRunId),
+          restOr(restNeq('status', TASK_DONE_STATUS), restIsNull('status')),
+        ),
+        limit: 200,
+      },
+    }),
+  ).records;
+
+export const getWorkflowRun = async (runAs: RunAs, workflowRunId: string) =>
+  readRestRecord<WorkflowRunRecord>(
+    await restClient(runAs).get(`/rest/workflowRuns/${workflowRunId}`),
+  );
+
+export const getWorkflow = async (runAs: RunAs, workflowId: string) =>
+  readRestRecord<WorkflowRecord>(
+    await restClient(runAs).get(`/rest/workflows/${workflowId}`),
+  );
+
+export const getWorkflowVersion = async (
+  runAs: RunAs,
+  workflowVersionId: string,
+) =>
+  readRestRecord<WorkflowVersionRecord>(
+    await restClient(runAs).get(`/rest/workflowVersions/${workflowVersionId}`),
+  );
+
+export const listWorkflowVersions = async (runAs: RunAs, workflowId: string) =>
+  readRestList<WorkflowVersionRecord>(
+    await restClient(runAs).get('/rest/workflowVersions', {
+      query: {
+        filter: restEq('workflowId', workflowId),
+        order_by: 'createdAt[DescNullsLast]',
+        limit: 50,
+      },
+    }),
+  ).records;
+
+export const createTaskTarget = async (data: Record<string, unknown>) =>
+  restClient('application').post('/rest/taskTargets', data);