The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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 };
};