@haiiro/docuflow 0.0.1 → 0.0.3

package/src/server/document-capture.ts

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

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

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

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

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

package/src/server/task-completion.ts

@@ -1,100 +0,0 @@
-import { CoreGraphqlError } from 'src/shared/api/core-graphql.util';
-import { TASK_DONE_STATUS } from 'src/shared/docflow.constants';
-import { isAppEngine } from 'src/shared/engine';
-import { type FormValues } from 'src/shared/form/form-field.type';
-import {
-  findMissingRequiredFields,
-  parseFormFields,
-  parseFormValues,
-} from 'src/shared/form/form-fields.util';
-import { getTask, getWorkflowRun, updateTask, type DocflowTaskRecord } from 'src/server/records';
-import { answerFormStep } from 'src/server/workflow-engine';
-
-export type CompleteTaskResult =
-  | { status: 'DONE' }
-  | { status: 'NOT_FOUND' }
-  | { status: 'MISSING_REQUIRED'; labels: string[] }
-  | { status: 'FAILED'; message: string };
-
-export const isProcessTask = (task: DocflowTaskRecord): boolean =>
-  typeof task.smbWorkflowThreadId === 'string' &&
-  task.smbWorkflowThreadId.length > 0 &&
-  typeof task.smbWorkflowRunId === 'string' &&
-  typeof task.smbWorkflowStepId === 'string';
-
-// Answers the process step of a task as the person completing it. A step
-// that is no longer waiting (answered elsewhere, run stopped) is not an error.
-export const answerStepOfTask = async (
-  task: DocflowTaskRecord,
-  values: FormValues,
-): Promise<CompleteTaskResult | undefined> => {
-  if (!isProcessTask(task) || !isAppEngine()) {
-    return undefined;
-  }
-
-  const run = await getWorkflowRun('person', task.smbWorkflowRunId as string);
-
-  try {
-    const result = await answerFormStep({
-      state: run?.state,
-      stepId: task.smbWorkflowStepId as string,
-      threadId: task.smbWorkflowThreadId as string,
-      values,
-    });
-
-    return result.status === 'MISSING_REQUIRED'
-      ? { status: 'MISSING_REQUIRED', labels: result.labels }
-      : undefined;
-  } catch (error) {
-    const refreshedRun = await getWorkflowRun('person', task.smbWorkflowRunId as string);
-
-    if (refreshedRun?.state?.stepInfos?.[task.smbWorkflowStepId as string]?.status === 'SUCCESS') {
-      return undefined;
-    }
-
-    return {
-      status: 'FAILED',
-      message:
-        error instanceof CoreGraphqlError && error.userMessage !== undefined
-          ? error.userMessage
-          : 'Процесс не принял ответ. Для ответа на шаги процессов нужно право «Рабочие процессы».',
-    };
-  }
-};
-
-export const completeTask = async ({
-  taskId,
-  values,
-}: {
-  taskId: string;
-  values: FormValues | undefined;
-}): Promise<CompleteTaskResult> => {
-  const task = await getTask('person', taskId);
-
-  if (task === undefined) {
-    return { status: 'NOT_FOUND' };
-  }
-
-  const fields = parseFormFields(task.smbFormSchema);
-  const currentValues = values ?? parseFormValues(task.smbFormValues);
-
-  if (values !== undefined) {
-    await updateTask('person', taskId, { smbFormValues: values });
-  }
-
-  const missingFields = findMissingRequiredFields({ fields, values: currentValues });
-
-  if (missingFields.length > 0) {
-    return { status: 'MISSING_REQUIRED', labels: missingFields.map(({ label }) => label) };
-  }
-
-  const stepResult = await answerStepOfTask(task, currentValues);
-
-  if (stepResult !== undefined) {
-    return stepResult;
-  }
-
-  await updateTask('person', taskId, { status: TASK_DONE_STATUS });
-
-  return { status: 'DONE' };
-};