Skip to content

The open alternative to Salesforce, designed for AI.

6.3 KB
Raw Blame
import { RunCoreWorkflowVersionDocument } from '~/generated/graphql';
import { triggerCreateRecordsOptimisticEffect } from '@/apollo/optimistic-effect/utils/triggerCreateRecordsOptimisticEffect';
import { currentWorkspaceMemberState } from '@/auth/states/currentWorkspaceMemberState';
import { useOpenRecordInSidePanel } from '@/side-panel/hooks/useOpenRecordInSidePanel';
import { useApolloCoreClient } from '@/object-metadata/hooks/useApolloCoreClient';
import { useObjectMetadataItem } from '@/object-metadata/hooks/useObjectMetadataItem';
import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
import { CoreObjectNameSingular } from 'twenty-shared/types';
import { useCreateOneRecordInCache } from '@/object-record/cache/hooks/useCreateOneRecordInCache';
import { useUpsertFindOneRecordQueryInCache } from '@/object-record/cache/hooks/useUpsertFindOneRecordQueryInCache';
import { getObjectTypename } from '@/object-record/cache/utils/getObjectTypename';
import { getRecordNodeFromRecord } from '@/object-record/cache/utils/getRecordNodeFromRecord';
import { useGenerateDepthRecordGqlFieldsFromObject } from '@/object-record/graphql/record-gql-fields/hooks/useGenerateDepthRecordGqlFieldsFromObject';
import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions';
import { useUpsertRecordsInStore } from '@/object-record/record-store/hooks/useUpsertRecordsInStore';
import { recordStoreFamilyState } from '@/object-record/record-store/states/recordStoreFamilyState';
import { computeOptimisticCreateRecordBaseRecordInput } from '@/object-record/utils/computeOptimisticCreateRecordBaseRecordInput';
import { computeOptimisticRecordFromInput } from '@/object-record/utils/computeOptimisticRecordFromInput';
import { useChangeQueryListenState } from '@/sse-db-event/hooks/useChangeQueryListenState';
import { getWorkflowRunSseQueryId } from '@/workflow/utils/getWorkflowRunSseQueryId';
import { type WorkflowRun } from '@/workflow/types/Workflow';
import { useAtomStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomStateValue';
import { useCallback } from 'react';
import { useMutation } from '@apollo/client/react';
import { isDefined } from 'twenty-shared/utils';
import { doNotTranslate } from 'twenty-shared/i18n';
import { v4 } from 'uuid';
import { useStore } from 'jotai';

export const useRunWorkflowVersion = () => {
  const store = useStore();
  const apolloCoreClient = useApolloCoreClient();
  const [mutateCore] = useMutation(RunCoreWorkflowVersionDocument, {
    client: apolloCoreClient,
  });
  const { upsertRecordsInStore } = useUpsertRecordsInStore();

  const { objectMetadataItem } = useObjectMetadataItem({
    objectNameSingular: CoreObjectNameSingular.WorkflowRun,
  });

  const { objectMetadataItems } = useObjectMetadataItems();
  const { objectPermissionsByObjectMetadataId } = useObjectPermissions();
  const createOneRecordInCache = useCreateOneRecordInCache<WorkflowRun>({
    objectMetadataItem,
  });
  const currentWorkspaceMember = useAtomStateValue(currentWorkspaceMemberState);

  const computedRecordGqlFields = useGenerateDepthRecordGqlFieldsFromObject({
    objectNameSingular: CoreObjectNameSingular.WorkflowRun,
    depth: 1,
  });

  const { upsertFindOneRecordQueryInCache } =
    useUpsertFindOneRecordQueryInCache({
      objectMetadataItem,
      recordGqlFields: computedRecordGqlFields,
    });

  const { openRecordInSidePanel } = useOpenRecordInSidePanel();
  const { changeQueryIdListenState } = useChangeQueryListenState();

  const setRecordInStore = useCallback(
    (workflowRun: WorkflowRun) => {
      store.set(recordStoreFamilyState.atomFamily(workflowRun.id), workflowRun);
    },
    [store],
  );

  const runWorkflowVersion = async ({
    workflowId,
    workflowVersionId,
    payload,
  }: {
    workflowId: string;
    workflowVersionId: string;
    payload?: Record<string, unknown>;
  }) => {
    const workflowRunId = v4();

    const recordInput: Partial<WorkflowRun> = {
      name: '#0',
      status: 'NOT_STARTED',
      coreWorkflowVersionId: workflowVersionId,
      coreWorkflowId: workflowId,
      createdAt: new Date().toISOString(),
    };

    const optimisticRecordInput = computeOptimisticRecordFromInput({
      cache: apolloCoreClient.cache,
      currentWorkspaceMember: currentWorkspaceMember,
      objectMetadataItem,
      objectMetadataItems,
      recordInput: {
        ...computeOptimisticCreateRecordBaseRecordInput(objectMetadataItem),
        ...recordInput,
        id: workflowRunId,
      },
      objectPermissionsByObjectMetadataId,
    });

    const recordCreatedInCache = createOneRecordInCache({
      ...optimisticRecordInput,
      id: workflowRunId,
      __typename: getObjectTypename(objectMetadataItem.nameSingular),
    });

    const recordNodeCreatedInCache = getRecordNodeFromRecord({
      objectMetadataItem,
      objectMetadataItems,
      record: recordCreatedInCache,
      computeReferences: false,
    });

    if (!isDefined(recordNodeCreatedInCache)) {
      throw new Error(
        doNotTranslate('The record should have been created in cache'),
      );
    }

    upsertFindOneRecordQueryInCache({
      objectRecordToOverwrite: recordCreatedInCache,
      objectRecordId: workflowRunId,
    });

    triggerCreateRecordsOptimisticEffect({
      cache: apolloCoreClient.cache,
      objectMetadataItem,
      recordsToCreate: [recordNodeCreatedInCache],
      objectMetadataItems,
      shouldMatchRootQueryFilter: true,
      objectPermissionsByObjectMetadataId,
      upsertRecordsInStore,
    });

    setRecordInStore(recordCreatedInCache);

    const sseQueryId = getWorkflowRunSseQueryId(workflowRunId);
    const sseOperationSignature = {
      objectNameSingular: CoreObjectNameSingular.WorkflowRun,
      variables: {
        filter: { id: { eq: workflowRunId } },
      },
    };

    changeQueryIdListenState(true, sseQueryId, sseOperationSignature);

    try {
      await mutateCore({
        variables: {
          input: {
            coreWorkflowVersionId: workflowVersionId,
            workflowRunId,
            payload,
          },
        },
      });
    } catch (error) {
      changeQueryIdListenState(false, sseQueryId, sseOperationSignature);
      throw error;
    }

    openRecordInSidePanel({
      objectNameSingular: CoreObjectNameSingular.WorkflowRun,
      recordId: workflowRunId,
    });
  };

  return { runWorkflowVersion };
};