Files
kandev/apps/web/components/settings/workflow-card-actions.ts
T
2026-07-17 18:47:27 +01:00

595 lines
18 KiB
TypeScript

"use client";
import { useEffect } from "react";
import type { Workflow, WorkflowStep } from "@/lib/types/http";
import { useToast } from "@/components/toast-provider";
import { useRequest } from "@/lib/http/use-request";
import {
createWorkflowAction,
createWorkflowStepAction,
updateWorkflowStepAction,
deleteWorkflowStepAction,
reorderWorkflowStepsAction,
listWorkflowStepsAction,
getStepTaskCount,
getWorkflowTaskCount,
exportWorkflowAction,
bulkMoveTasks,
} from "@/app/actions/workspaces";
import type { WorkflowMutationGuardController } from "./workflow-mutation-guard";
import {
addLocalStep,
addRemoteStep,
applyWorkflowStepUpdates,
newWorkflowStep,
removeLocalStep,
updateRemoteWorkflowStep,
} from "./workflow-step-mutations";
const FALLBACK_ERROR_MESSAGE = "Request failed";
type WorkflowStepActionsParams = {
workflow: Workflow;
isNewWorkflow: boolean;
readOnly?: boolean;
workflowSteps: WorkflowStep[];
setWorkflowSteps: (updater: ((prev: WorkflowStep[]) => WorkflowStep[]) | WorkflowStep[]) => void;
setStepToDelete: (id: string | null) => void;
setStepTaskCount: (count: number | null) => void;
setTargetStepForMigration: (id: string) => void;
setStepDeleteOpen: (open: boolean) => void;
toast: ReturnType<typeof useToast>["toast"];
mutationGuard: WorkflowMutationGuardController;
};
type RemoveStepParams = {
stepId: string;
workflowSteps: WorkflowStep[];
setWorkflowSteps: (updater: (prev: WorkflowStep[]) => WorkflowStep[]) => void;
setStepToDelete: (id: string | null) => void;
setStepTaskCount: (count: number | null) => void;
setTargetStepForMigration: (id: string) => void;
setStepDeleteOpen: (open: boolean) => void;
toast: ReturnType<typeof useToast>["toast"];
};
async function removeWorkflowStep({
stepId,
workflowSteps,
setWorkflowSteps,
setStepToDelete,
setStepTaskCount,
setTargetStepForMigration,
setStepDeleteOpen,
toast,
}: RemoveStepParams) {
try {
const { task_count } = await getStepTaskCount(stepId);
if (task_count === 0) {
await deleteWorkflowStepAction(stepId);
setWorkflowSteps((previous) =>
previous
.filter((step) => step.id !== stepId)
.map((step, position) => ({ ...step, position })),
);
return;
}
setStepToDelete(stepId);
setStepTaskCount(task_count);
const otherSteps = workflowSteps.filter((s) => s.id !== stepId);
setTargetStepForMigration(otherSteps.length > 0 ? otherSteps[0].id : "");
setStepDeleteOpen(true);
} catch (error) {
toast({
title: "Failed to check step tasks",
description: error instanceof Error ? error.message : FALLBACK_ERROR_MESSAGE,
variant: "error",
});
}
}
export function useWorkflowStepActions({
workflow,
isNewWorkflow,
readOnly = false,
workflowSteps,
setWorkflowSteps,
setStepToDelete,
setStepTaskCount,
setTargetStepForMigration,
setStepDeleteOpen,
toast,
mutationGuard,
}: WorkflowStepActionsParams) {
const handleUpdateWorkflowStep = async (stepId: string, updates: Partial<WorkflowStep>) => {
if (readOnly) return;
if (isNewWorkflow) {
setWorkflowSteps((prev) => applyWorkflowStepUpdates(prev, stepId, updates));
return;
}
const proposedSteps = applyWorkflowStepUpdates(workflowSteps, stepId, updates);
await mutationGuard.guardMutation({
proposedSteps,
operation: () => updateRemoteWorkflowStep({ stepId, updates, setWorkflowSteps, toast }),
});
};
const handleAddWorkflowStep = async () => {
if (readOnly) return;
if (isNewWorkflow) {
addLocalStep(workflow, setWorkflowSteps);
return;
}
const proposedSteps = [
...workflowSteps,
newWorkflowStep(workflow, workflowSteps.length, `proposed-step-${workflow.id}`),
];
await mutationGuard.guardMutation({
proposedSteps,
operation: () => addRemoteStep(workflow, workflowSteps.length, setWorkflowSteps, toast),
});
};
const handleRemoveWorkflowStep = async (stepId: string) => {
if (readOnly) return;
if (isNewWorkflow) {
removeLocalStep(stepId, setWorkflowSteps);
return;
}
const proposedSteps = workflowSteps
.filter((step) => step.id !== stepId)
.map((step, position) => ({ ...step, position }));
await mutationGuard.guardMutation({
proposedSteps,
operation: () =>
removeWorkflowStep({
stepId,
workflowSteps,
setWorkflowSteps,
setStepToDelete,
setStepTaskCount,
setTargetStepForMigration,
setStepDeleteOpen,
toast,
}),
});
};
const handleReorderWorkflowSteps = async (reorderedSteps: WorkflowStep[]) => {
if (readOnly) return;
const proposedSteps = reorderedSteps.map((step, position) => ({ ...step, position }));
if (isNewWorkflow) {
setWorkflowSteps(proposedSteps);
return;
}
await mutationGuard.guardMutation({
proposedSteps,
operation: async () => {
setWorkflowSteps(proposedSteps);
try {
const response = await reorderWorkflowStepsAction(
workflow.id,
proposedSteps.map((step) => step.id),
);
setWorkflowSteps(response.steps);
} catch (error) {
toast({
title: "Failed to reorder workflow steps",
description: error instanceof Error ? error.message : FALLBACK_ERROR_MESSAGE,
variant: "error",
});
setWorkflowSteps(workflowSteps);
}
},
});
};
return {
handleUpdateWorkflowStep,
handleAddWorkflowStep,
handleRemoveWorkflowStep,
handleReorderWorkflowSteps,
};
}
type WorkflowDeleteHandlersParams = {
workflow: Workflow;
isNewWorkflow: boolean;
readOnly?: boolean;
otherWorkflows: Workflow[];
wfDel: {
setDeleteOpen: (v: boolean) => void;
setWorkflowTaskCount: (v: number | null) => void;
setWorkflowDeleteLoading: (v: boolean) => void;
setTargetWorkflowId: (v: string) => void;
setTargetWorkflowSteps: (v: WorkflowStep[]) => void;
setTargetStepId: (v: string) => void;
targetWorkflowId: string;
targetStepId: string;
setMigrateLoading: (v: boolean) => void;
};
deleteWorkflowRun: () => Promise<unknown>;
toast: ReturnType<typeof useToast>["toast"];
};
export function useWorkflowDeleteHandlers({
workflow,
isNewWorkflow,
readOnly = false,
otherWorkflows,
wfDel,
deleteWorkflowRun,
toast,
}: WorkflowDeleteHandlersParams) {
useEffect(() => {
if (!wfDel.targetWorkflowId) {
wfDel.setTargetWorkflowSteps([]);
wfDel.setTargetStepId("");
return;
}
let cancelled = false;
listWorkflowStepsAction(wfDel.targetWorkflowId)
.then((res) => {
if (!cancelled) {
const steps = res.steps ?? [];
wfDel.setTargetWorkflowSteps(steps);
wfDel.setTargetStepId(steps.length > 0 ? steps[0].id : "");
}
})
.catch(() => {
if (!cancelled) wfDel.setTargetWorkflowSteps([]);
});
return () => {
cancelled = true;
};
}, [wfDel.targetWorkflowId]); // eslint-disable-line react-hooks/exhaustive-deps
const handleDeleteWorkflowClick = async () => {
if (readOnly) return;
if (isNewWorkflow) {
wfDel.setWorkflowTaskCount(0);
wfDel.setDeleteOpen(true);
return;
}
wfDel.setWorkflowDeleteLoading(true);
try {
const { task_count } = await getWorkflowTaskCount(workflow.id);
wfDel.setWorkflowTaskCount(task_count);
if (task_count > 0 && otherWorkflows.length > 0)
wfDel.setTargetWorkflowId(otherWorkflows[0].id);
wfDel.setDeleteOpen(true);
} catch (error) {
toast({
title: "Failed to check workflow tasks",
description: error instanceof Error ? error.message : FALLBACK_ERROR_MESSAGE,
variant: "error",
});
} finally {
wfDel.setWorkflowDeleteLoading(false);
}
};
const handleDeleteWorkflow = async () => {
if (readOnly) return;
try {
await deleteWorkflowRun();
wfDel.setDeleteOpen(false);
} catch (error) {
toast({
title: "Failed to delete workflow",
description: error instanceof Error ? error.message : FALLBACK_ERROR_MESSAGE,
variant: "error",
});
}
};
const handleMigrateAndDeleteWorkflow = async () => {
if (readOnly) return;
if (!wfDel.targetWorkflowId || !wfDel.targetStepId) return;
wfDel.setMigrateLoading(true);
try {
await bulkMoveTasks({
source_workflow_id: workflow.id,
target_workflow_id: wfDel.targetWorkflowId,
target_step_id: wfDel.targetStepId,
});
await deleteWorkflowRun();
wfDel.setDeleteOpen(false);
} catch (error) {
toast({
title: "Failed to migrate tasks",
description: error instanceof Error ? error.message : FALLBACK_ERROR_MESSAGE,
variant: "error",
});
} finally {
wfDel.setMigrateLoading(false);
}
};
return { handleDeleteWorkflowClick, handleDeleteWorkflow, handleMigrateAndDeleteWorkflow };
}
type StepDeleteHandlersParams = {
workflow: Workflow;
stepDel: {
stepToDelete: string | null;
targetStepForMigration: string;
setStepMigrateLoading: (v: boolean) => void;
setStepDeleteOpen: (v: boolean) => void;
setStepToDelete: (v: string | null) => void;
};
setWorkflowSteps: (updater: (prev: WorkflowStep[]) => WorkflowStep[]) => void;
toast: ReturnType<typeof useToast>["toast"];
};
export function useStepDeleteHandlers({
workflow,
stepDel,
setWorkflowSteps,
toast,
}: StepDeleteHandlersParams) {
const handleMigrateAndDeleteStep = async () => {
if (!stepDel.stepToDelete || !stepDel.targetStepForMigration) return;
const stepId = stepDel.stepToDelete;
stepDel.setStepMigrateLoading(true);
try {
await bulkMoveTasks({
source_workflow_id: workflow.id,
source_step_id: stepId,
target_workflow_id: workflow.id,
target_step_id: stepDel.targetStepForMigration,
});
await deleteWorkflowStepAction(stepId);
setWorkflowSteps((previous) =>
previous
.filter((step) => step.id !== stepId)
.map((step, position) => ({ ...step, position })),
);
stepDel.setStepDeleteOpen(false);
stepDel.setStepToDelete(null);
} catch (error) {
toast({
title: "Failed to migrate tasks",
description: error instanceof Error ? error.message : FALLBACK_ERROR_MESSAGE,
variant: "error",
});
} finally {
stepDel.setStepMigrateLoading(false);
}
};
const handleDeleteStepAndTasks = async () => {
if (!stepDel.stepToDelete) return;
const stepId = stepDel.stepToDelete;
stepDel.setStepMigrateLoading(true);
try {
await deleteWorkflowStepAction(stepId);
setWorkflowSteps((previous) =>
previous
.filter((step) => step.id !== stepId)
.map((step, position) => ({ ...step, position })),
);
stepDel.setStepDeleteOpen(false);
stepDel.setStepToDelete(null);
} catch (error) {
toast({
title: "Failed to delete step",
description: error instanceof Error ? error.message : FALLBACK_ERROR_MESSAGE,
variant: "error",
});
} finally {
stepDel.setStepMigrateLoading(false);
}
};
return { handleMigrateAndDeleteStep, handleDeleteStepAndTasks };
}
/**
* Compare user step edits against backend steps for reconciliation.
* NOTE: We intentionally do NOT compare events here. The backend creates steps
* with properly remapped step_id references (template aliases → real UUIDs).
* If we compared events, the template aliases would overwrite the backend's UUIDs.
*/
function remapPullFromStepID(
pullFromStepID: string | null | undefined,
stepIDByDraftID: Map<string, string>,
) {
if (!pullFromStepID) return "";
return stepIDByDraftID.get(pullFromStepID) ?? pullFromStepID;
}
function diffStepUpdates(
userStep: WorkflowStep,
backendStep: WorkflowStep,
stepIDByDraftID: Map<string, string>,
): Partial<WorkflowStep> {
const updates: Partial<WorkflowStep> = {};
if (userStep.name !== backendStep.name) updates.name = userStep.name;
if (userStep.color !== backendStep.color) updates.color = userStep.color;
if (userStep.prompt !== backendStep.prompt) updates.prompt = userStep.prompt;
if (userStep.is_start_step !== backendStep.is_start_step)
updates.is_start_step = userStep.is_start_step;
if (userStep.allow_manual_move !== backendStep.allow_manual_move)
updates.allow_manual_move = userStep.allow_manual_move;
if ((userStep.wip_limit ?? 0) !== (backendStep.wip_limit ?? 0))
updates.wip_limit = userStep.wip_limit ?? 0;
const pullFromStepID = remapPullFromStepID(userStep.pull_from_step_id, stepIDByDraftID);
if (pullFromStepID !== (backendStep.pull_from_step_id ?? ""))
updates.pull_from_step_id = pullFromStepID;
// Events are NOT compared - backend has correct step_id UUIDs, user has template aliases
return updates;
}
function stepPayload(workflowId: string, step: WorkflowStep) {
return {
workflow_id: workflowId,
name: step.name,
position: step.position,
color: step.color,
prompt: step.prompt,
events: step.events,
is_start_step: step.is_start_step,
allow_manual_move: step.allow_manual_move,
wip_limit: step.wip_limit ?? 0,
pull_from_step_id: step.pull_from_step_id ?? "",
};
}
function stepPayloadWithoutPullSource(workflowId: string, step: WorkflowStep) {
return { ...stepPayload(workflowId, step), pull_from_step_id: "" };
}
async function createStepsThenRemapPullSources(
workflowId: string,
steps: WorkflowStep[],
existingStepIDByDraftID = new Map<string, string>(),
) {
const createdByDraftID = new Map(existingStepIDByDraftID);
const addedStepIDByDraftID = new Map<string, string>();
const createdByPosition = new Map<number, string>();
for (const step of steps) {
const created = await createWorkflowStepAction(stepPayloadWithoutPullSource(workflowId, step));
createdByDraftID.set(step.id, created.id);
addedStepIDByDraftID.set(step.id, created.id);
createdByPosition.set(step.position, created.id);
}
for (const step of steps) {
const pullFromStepID = remapPullFromStepID(step.pull_from_step_id, createdByDraftID);
if (!pullFromStepID) continue;
const createdID = addedStepIDByDraftID.get(step.id) ?? createdByPosition.get(step.position);
if (createdID) await updateWorkflowStepAction(createdID, { pull_from_step_id: pullFromStepID });
}
return addedStepIDByDraftID;
}
async function reconcileTemplateSteps(
createdId: string,
userSteps: WorkflowStep[],
templateStepCount: number,
) {
const { steps: backendSteps = [] } = await listWorkflowStepsAction(createdId);
const stepIDByDraftID = new Map<string, string>();
for (const backendStep of backendSteps) {
const userStep = userSteps.find((s) => s.position === backendStep.position);
if (userStep) stepIDByDraftID.set(userStep.id, backendStep.id);
}
// Create added steps first so template-step updates can remap pull sources
// that point at a newly-added step.
const addedSteps = userSteps.filter((step) => step.position >= templateStepCount);
const addedStepIDByDraftID = await createStepsThenRemapPullSources(
createdId,
addedSteps,
stepIDByDraftID,
);
for (const [draftID, createdID] of addedStepIDByDraftID) {
stepIDByDraftID.set(draftID, createdID);
}
// Reconcile user edits (name, color, etc.) with backend steps.
// We do NOT touch events - the backend has correct step_id UUIDs.
for (const backendStep of backendSteps) {
const userStep = userSteps.find((s) => s.position === backendStep.position);
if (!userStep) continue;
const updates = diffStepUpdates(userStep, backendStep, stepIDByDraftID);
if (Object.keys(updates).length > 0) await updateWorkflowStepAction(backendStep.id, updates);
}
}
type WorkflowSaveActionsParams = {
workflow: Workflow;
isNewWorkflow: boolean;
readOnly?: boolean;
workflowSteps: WorkflowStep[];
templateStepCount: number;
onSaveWorkflow: () => Promise<unknown>;
onWorkflowCreated?: (created: Workflow) => void;
toast: ReturnType<typeof useToast>["toast"];
mutationGuard: WorkflowMutationGuardController;
};
export function useWorkflowSaveActions({
workflow,
isNewWorkflow,
readOnly = false,
workflowSteps,
templateStepCount,
onSaveWorkflow,
onWorkflowCreated,
toast,
mutationGuard,
}: WorkflowSaveActionsParams) {
const saveWorkflowRequest = useRequest(onSaveWorkflow);
const saveNewWorkflowRequest = useRequest(async () => {
const templateId = workflow.workflow_template_id;
const created = await createWorkflowAction({
workspace_id: workflow.workspace_id,
name: workflow.name.trim() || "New Workflow",
workflow_template_id: templateId || undefined,
});
if (templateId) {
// Backend creates template steps with remapped step_id references.
// Reconcile user edits and additions on top.
await reconcileTemplateSteps(created.id, workflowSteps, templateStepCount);
} else {
await createStepsThenRemapPullSources(created.id, workflowSteps);
}
onWorkflowCreated?.(created);
});
const activeSaveRequest = isNewWorkflow ? saveNewWorkflowRequest : saveWorkflowRequest;
const runSaveWorkflow = async () => {
try {
if (isNewWorkflow) await saveNewWorkflowRequest.run();
else await saveWorkflowRequest.run();
} catch (error) {
toast({
title: "Failed to save workflow changes",
description: error instanceof Error ? error.message : FALLBACK_ERROR_MESSAGE,
variant: "error",
});
}
};
const handleSaveWorkflow = async () => {
if (readOnly) return;
if (!isNewWorkflow) {
await runSaveWorkflow();
return;
}
await mutationGuard.guardMutation({
baselineSteps: [],
proposedSteps: workflowSteps,
intent: "create",
operation: runSaveWorkflow,
});
};
return { activeSaveRequest, handleSaveWorkflow, mutationGuard };
}
type WorkflowExportActionsParams = {
workflowId: string;
setExportYaml: (yaml: string) => void;
setExportOpen: (open: boolean) => void;
toast: ReturnType<typeof useToast>["toast"];
};
export async function handleExportWorkflow({
workflowId,
setExportYaml,
setExportOpen,
toast,
}: WorkflowExportActionsParams) {
try {
const yamlText = await exportWorkflowAction(workflowId);
setExportYaml(yamlText);
setExportOpen(true);
} catch (error) {
toast({
title: "Failed to export workflow",
description: error instanceof Error ? error.message : FALLBACK_ERROR_MESSAGE,
variant: "error",
});
}
}