Skip to content

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

fix(builder): stop losing edits on failed saves, quick publish, or leaving (#16495)

Othman Abu Ajamieh756fef69913b
diff --git a/packages/web/public/locales/en/translation.json b/packages/web/public/locales/en/translation.json
index 0ef5c58e048..6e7809398eb 100644
--- a/packages/web/public/locales/en/translation.json
+++ b/packages/web/public/locales/en/translation.json
@@ -3525,5 +3525,7 @@
"{apps}+ apps": "{apps}+ apps",
"URL or config": "URL or config",
"Give your AI secure access to {apps}": "Give your AI secure access to {apps}",
- "plus your flows and tables, with granular access control.": "plus your flows and tables, with granular access control."
+ "plus your flows and tables, with granular access control.": "plus your flows and tables, with granular access control.",
+ "Your change was not saved": "Your change was not saved",
+ "The builder now shows the last saved version of the flow.": "The builder now shows the last saved version of the flow."
}
diff --git a/packages/web/src/app/builder/builder-header/builder-header.tsx b/packages/web/src/app/builder/builder-header/builder-header.tsx
index 5747621f96c..dcb64b29dbd 100644
--- a/packages/web/src/app/builder/builder-header/builder-header.tsx
+++ b/packages/web/src/app/builder/builder-header/builder-header.tsx
@@ -66,12 +66,14 @@ export const BuilderHeader = () => {
moveToFolderClientSide,
applyOperation,
setRightSidebar,
+ savePendingEdits,
] = useBuilderStateContext((state) => [
state.flow,
state.flowVersion,
state.moveToFolderClientSide,
state.applyOperation,
state.setRightSidebar,
+ state.savePendingEdits,
]);
const { embedState } = useEmbedding();
@@ -149,6 +151,7 @@ export const BuilderHeader = () => {
setRightSidebar(RightSideBarType.VERSIONS);
}}
insideBuilder={true}
+ savePendingEdits={savePendingEdits}
flow={flow}
flowVersion={flowVersion}
readonly={!isLatestVersion}
diff --git a/packages/web/src/app/builder/flow-canvas/hooks.tsx b/packages/web/src/app/builder/flow-canvas/hooks.tsx
index 1e37a0ddf01..c45b4f958ac 100644
--- a/packages/web/src/app/builder/flow-canvas/hooks.tsx
+++ b/packages/web/src/app/builder/flow-canvas/hooks.tsx
@@ -96,6 +96,24 @@ const useShowBuilderIsSavingWarningBeforeLeaving = () => {
}, [isSaving, isEmbedded]);
};
+const useFlushPendingEditsOnLeave = () => {
+ const flushPendingEdits = useBuilderStateContext(
+ (state) => state.flushPendingEdits,
+ );
+ useEffect(() => {
+ const flushWhenHidden = () => {
+ if (document.visibilityState === 'hidden') {
+ flushPendingEdits();
+ }
+ };
+ document.addEventListener('visibilitychange', flushWhenHidden);
+ return () => {
+ document.removeEventListener('visibilitychange', flushWhenHidden);
+ flushPendingEdits();
+ };
+ }, [flushPendingEdits]);
+};
+
export const useSwitchToDraft = () => {
const [flowVersion, setVersion, clearRun, setFlow] = useBuilderStateContext(
(state) => [
@@ -229,6 +247,7 @@ export const useResizeCanvas = (
export const flowCanvasHooks = {
useSetSocketListener,
useShowBuilderIsSavingWarningBeforeLeaving,
+ useFlushPendingEditsOnLeave,
useIsFocusInsideListMapperModeInput,
useFocusOnStep,
useResizeCanvas,
diff --git a/packages/web/src/app/builder/flow-canvas/nodes/note-node/index.tsx b/packages/web/src/app/builder/flow-canvas/nodes/note-node/index.tsx
index 5883155708b..2a6c4393da7 100644
--- a/packages/web/src/app/builder/flow-canvas/nodes/note-node/index.tsx
+++ b/packages/web/src/app/builder/flow-canvas/nodes/note-node/index.tsx
@@ -4,7 +4,6 @@ import { Editor } from '@tiptap/core';
import { NodeProps, NodeResizeControl } from '@xyflow/react';
import { t } from 'i18next';
import { useRef, useState } from 'react';
-import { useDebouncedCallback } from 'use-debounce';
import { MarkdownInput } from '@/components/custom/markdown-input';
import {
@@ -124,13 +123,6 @@ const NoteContent = ({ note, isDragging }: NoteContentProps) => {
state.updateContent,
state.readonly,
]);
- const debouncedUpdateContent = useDebouncedCallback(
- (id: string, content: string) => {
- updateContent(id, content);
- },
- 500,
- );
-
const editorRef = useRef<Editor | null>(null);
return (
<div
@@ -198,7 +190,7 @@ const NoteContent = ({ note, isDragging }: NoteContentProps) => {
onChange={(value: string) => {
if (value !== localNote.content) {
setLocalNote({ ...localNote, content: value });
- debouncedUpdateContent(id, value);
+ updateContent(id, value);
}
}}
/>
diff --git a/packages/web/src/app/builder/flow-canvas/widgets/discard-draft.ts b/packages/web/src/app/builder/flow-canvas/widgets/discard-draft.ts
index 9164e5e3c5b..ad6cb8b901f 100644
--- a/packages/web/src/app/builder/flow-canvas/widgets/discard-draft.ts
+++ b/packages/web/src/app/builder/flow-canvas/widgets/discard-draft.ts
@@ -1,7 +1,13 @@
-import { GetFlowQueryParamsRequest, PopulatedFlow } from '@activepieces/shared';
+import {
+ GetFlowQueryParamsRequest,
+ isNil,
+ PopulatedFlow,
+ tryCatch,
+} from '@activepieces/shared';
export type RunDiscardDeps = {
flow: { id: string; publishedVersionId?: string | null };
+ savePendingEdits: () => Promise<void>;
overWriteDraftWithVersion: (params: {
flowId: string;
versionId: string;
@@ -19,6 +25,10 @@ export async function runDiscard(deps: RunDiscardDeps): Promise<void> {
if (!flow.publishedVersionId) {
return;
}
+ const { error: saveError } = await tryCatch(deps.savePendingEdits);
+ if (!isNil(saveError)) {
+ return;
+ }
await deps.overWriteDraftWithVersion({
flowId: flow.id,
versionId: flow.publishedVersionId,
diff --git a/packages/web/src/app/builder/flow-canvas/widgets/flow-approval-banner.tsx b/packages/web/src/app/builder/flow-canvas/widgets/flow-approval-banner.tsx
index a743a1f90c4..4278909970a 100644
--- a/packages/web/src/app/builder/flow-canvas/widgets/flow-approval-banner.tsx
+++ b/packages/web/src/app/builder/flow-canvas/widgets/flow-approval-banner.tsx
@@ -3,6 +3,7 @@ import {
FlowVersionState,
isNil,
Permission,
+ tryCatch,
} from '@activepieces/shared';
import { t } from 'i18next';
import { ShieldAlert } from 'lucide-react';
@@ -36,14 +37,21 @@ import { useBuilderStateContext } from '../../builder-hooks';
import LargeWidgetWrapper from './large-widget-wrapper';
const FlowApprovalBanner = () => {
- const [flow, flowVersion, setFlow, setVersion, setRightSidebar] =
- useBuilderStateContext((state) => [
- state.flow,
- state.flowVersion,
- state.setFlow,
- state.setVersion,
- state.setRightSidebar,
- ]);
+ const [
+ flow,
+ flowVersion,
+ setFlow,
+ setVersion,
+ setRightSidebar,
+ savePendingEdits,
+ ] = useBuilderStateContext((state) => [
+ state.flow,
+ state.flowVersion,
+ state.setFlow,
+ state.setVersion,
+ state.setRightSidebar,
+ state.savePendingEdits,
+ ]);
const { platform } = platformHooks.useCurrentPlatform();
const { checkAccess } = useAuthorization();
const featureEnabled = platform.plan.environmentsEnabled;
@@ -58,6 +66,10 @@ const FlowApprovalBanner = () => {
const { mutateAsync: withdraw, isPending: isWithdrawing } =
flowApprovalsHooks.useWithdraw();
const handleWithdraw = async (requestId: string) => {
+ const { error: saveError } = await tryCatch(savePendingEdits);
+ if (!isNil(saveError)) {
+ return;
+ }
const previousVersion = flowVersion;
setVersion({ ...flowVersion, state: FlowVersionState.DRAFT });
setRightSidebar(RightSideBarType.NONE);
diff --git a/packages/web/src/app/builder/flow-canvas/widgets/publish-flow-reminder-widget.tsx b/packages/web/src/app/builder/flow-canvas/widgets/publish-flow-reminder-widget.tsx
index 1d08c6ec741..49ae5fc47be 100644
--- a/packages/web/src/app/builder/flow-canvas/widgets/publish-flow-reminder-widget.tsx
+++ b/packages/web/src/app/builder/flow-canvas/widgets/publish-flow-reminder-widget.tsx
@@ -1,4 +1,4 @@
-import { isNil, Permission } from '@activepieces/core-utils';
+import { isNil, Permission, tryCatch } from '@activepieces/core-utils';
import {
FlowRun,
FlowVersion,
@@ -45,6 +45,7 @@ const PublishFlowReminderWidget = () => {
setRightSidebar,
flowVersion,
run,
+ savePendingEdits,
] = useBuilderStateContext((state) => [
state.saving,
state.isPublishing,
@@ -56,6 +57,7 @@ const PublishFlowReminderWidget = () => {
state.setRightSidebar,
state.flowVersion,
state.run,
+ state.savePendingEdits,
]);
const showShouldPublishButton = useShouldShowPublishButton({
flowVersion,
@@ -78,6 +80,7 @@ const PublishFlowReminderWidget = () => {
mutationFn: () =>
runDiscard({
flow,
+ savePendingEdits,
overWriteDraftWithVersion,
fetchFlow: flowsApi.get,
setFlow,
@@ -105,6 +108,11 @@ const PublishFlowReminderWidget = () => {
});
const handlePublish = async () => {
setIsPublishing(true);
+ const { error: saveError } = await tryCatch(savePendingEdits);
+ if (!isNil(saveError)) {
+ setIsPublishing(false);
+ return;
+ }
const failedCheck = await checkRequiredActions(flowVersion);
if (failedCheck) {
setIsPublishing(false);
diff --git a/packages/web/src/app/builder/flow-versions/overwrite-draft-dialog.tsx b/packages/web/src/app/builder/flow-versions/overwrite-draft-dialog.tsx
index 6deef1e54ce..add1ae93419 100644
--- a/packages/web/src/app/builder/flow-versions/overwrite-draft-dialog.tsx
+++ b/packages/web/src/app/builder/flow-versions/overwrite-draft-dialog.tsx
@@ -1,4 +1,4 @@
-import { Permission } from '@activepieces/core-utils';
+import { isNil, Permission, tryCatch } from '@activepieces/core-utils';
import { t } from 'i18next';
import { useState } from 'react';
@@ -27,18 +27,25 @@ const OverwriteDraftDialog = ({
versionNumber,
}: OverwriteDraftDialogProps) => {
const { checkAccess } = useAuthorization();
- const [setVersion, setRightSidebar, flow] = useBuilderStateContext(
- (state) => [state.setVersion, state.setRightSidebar, state.flow],
- );
+ const [setVersion, setRightSidebar, flow, savePendingEdits] =
+ useBuilderStateContext((state) => [
+ state.setVersion,
+ state.setRightSidebar,
+ state.flow,
+ state.savePendingEdits,
+ ]);
+ const [open, setOpen] = useState(false);
+ const [isSavingPendingEdits, setIsSavingPendingEdits] = useState(false);
const { mutate: overWriteDraftWithVersion, isPending: isOverwritingDraft } =
flowHooks.useOverWriteDraftWithVersion({
onSuccess: (updatedFlow) => {
setVersion(updatedFlow.version);
setRightSidebar(RightSideBarType.NONE);
+ setOpen(false);
+ onConfirm?.();
},
});
const userHasPermissionToWriteFlow = checkAccess(Permission.WRITE_FLOW);
- const [open, setOpen] = useState(false);
return (
<Dialog open={open} onOpenChange={setOpen}>
<DialogTrigger
@@ -65,20 +72,23 @@ const OverwriteDraftDialog = ({
<DialogClose asChild>
<Button variant={'outline'}>{t('Cancel')}</Button>
</DialogClose>
- <DialogClose asChild>
- <Button
- loading={isOverwritingDraft}
- onClick={() => {
- overWriteDraftWithVersion({
- flowId: flow.id,
- versionId: versionId,
- });
- onConfirm?.();
- }}
- >
- {t('Overwrite')}
- </Button>
- </DialogClose>
+ <Button
+ loading={isSavingPendingEdits || isOverwritingDraft}
+ onClick={async () => {
+ setIsSavingPendingEdits(true);
+ const { error: saveError } = await tryCatch(savePendingEdits);
+ setIsSavingPendingEdits(false);
+ if (!isNil(saveError)) {
+ return;
+ }
+ overWriteDraftWithVersion({
+ flowId: flow.id,
+ versionId: versionId,
+ });
+ }}
+ >
+ {t('Overwrite')}
+ </Button>
</DialogFooter>
</DialogContent>
</Dialog>
diff --git a/packages/web/src/app/builder/index.tsx b/packages/web/src/app/builder/index.tsx
index 68690b0d325..9a0e792abc4 100644
--- a/packages/web/src/app/builder/index.tsx
+++ b/packages/web/src/app/builder/index.tsx
@@ -75,6 +75,7 @@ const BuilderPage = () => {
};
}, [removeAllStepTestsListeners]);
flowCanvasHooks.useShowBuilderIsSavingWarningBeforeLeaving();
+ flowCanvasHooks.useFlushPendingEditsOnLeave();
const middlePanelRef = useRef<HTMLDivElement>(null);
const middlePanelSize = useElementSize(middlePanelRef);
const [isDraggingHandle, setIsDraggingHandle] = useState(false);
diff --git a/packages/web/src/app/builder/state/flow-state.ts b/packages/web/src/app/builder/state/flow-state.ts
index 18a8000b003..62a5757b6eb 100644
--- a/packages/web/src/app/builder/state/flow-state.ts
+++ b/packages/web/src/app/builder/state/flow-state.ts
@@ -1,4 +1,4 @@
-import { isNil, debounce } from '@activepieces/core-utils';
+import { isNil, tryCatch } from '@activepieces/core-utils';
import {
FlowOperationRequest,
FlowOperationType,
@@ -11,15 +11,22 @@ import {
FlowTriggerType,
} from '@activepieces/shared';
import { QueryClient } from '@tanstack/react-query';
+import { AxiosError } from 'axios';
+import { t } from 'i18next';
+import { toast } from 'sonner';
import { StoreApi } from 'zustand';
import { RightSideBarType } from '@/app/builder/types';
+import { internalErrorToast } from '@/components/ui/sonner';
import { flowsApi, sampleDataHooks } from '@/features/flows';
import {
PieceSelectorItem,
PieceSelectorOperation,
pieceSelectorUtils,
} from '@/features/pieces';
+import { api } from '@/lib/api';
+import { wait } from '@/lib/dom-utils';
+import { KeyedDebounce } from '@/lib/keyed-debounce';
import { PromiseQueue } from '@/lib/promise-queue';
import { BuilderState } from '../builder-hooks';
@@ -37,6 +44,8 @@ export type FlowState = {
operation: FlowOperationRequest,
onSuccess?: () => void,
) => void;
+ savePendingEdits: () => Promise<void>;
+ flushPendingEdits: () => void;
setFlow: (flow: PopulatedFlow) => void;
setSampleDataLocally: (params: {
stepName: string;
@@ -85,12 +94,25 @@ export const createFlowState = (
set: StoreApi<BuilderState>['setState'],
): FlowState => {
const flowUpdatesQueue = new PromiseQueue();
- const debouncedAddToFlowUpdatesQueue = debounce(
- (updateRequest: () => Promise<void>) => {
- flowUpdatesQueue.add(updateRequest);
- },
- 1000,
- );
+ const flowUpdatesDebounce = new KeyedDebounce({ wait: 1000, maxWait: 5000 });
+ const addToFlowUpdatesQueue = (task: () => Promise<void>) => {
+ flowUpdatesQueue.add(async () => {
+ try {
+ await task();
+ } finally {
+ set({
+ saving:
+ flowUpdatesQueue.size() !== 0 || !flowUpdatesDebounce.isEmpty(),
+ });
+ }
+ });
+ };
+ const addToFlowUpdatesQueueAfterPendingEdits = (
+ task: () => Promise<void>,
+ ) => {
+ flowUpdatesDebounce.flush();
+ addToFlowUpdatesQueue(task);
+ };
return {
saving: false,
outputSampleData: initialState.outputSampleData,
@@ -181,11 +203,10 @@ export const createFlowState = (
set({ saving: true });
const updateRequest = async () => {
try {
- const { version: serverFlowVersion } = await flowsApi.update(
- state.flow.id,
+ const { version: serverFlowVersion } = await saveOperation({
+ flowId: state.flow.id,
operation,
- true,
- );
+ });
if (operation.type === FlowOperationType.SAVE_SAMPLE_DATA) {
sampleDataHooks.invalidateSampleData(
serverFlowVersion.id,
@@ -205,33 +226,36 @@ export const createFlowState = (
id: serverFlowVersion.id,
state: serverFlowVersion.state,
},
- saving: flowUpdatesQueue.size() !== 0,
};
});
onSuccess?.();
} catch (error) {
console.error(error);
- flowUpdatesQueue.halt();
+ showFailedSaveToast(error);
+ addToFlowUpdatesQueueAfterPendingEdits(() => refetchDraft(get));
+ throw error;
}
};
switch (operation.type) {
case FlowOperationType.SAVE_SAMPLE_DATA: {
- flowUpdatesQueue.add(updateRequest);
+ addToFlowUpdatesQueueAfterPendingEdits(updateRequest);
break;
}
case FlowOperationType.UPDATE_TRIGGER:
case FlowOperationType.UPDATE_ACTION: {
- debouncedAddToFlowUpdatesQueue(
- operation.request.name,
- updateRequest,
- );
+ flowUpdatesDebounce.schedule({
+ key: operation.request.name,
+ run: () => addToFlowUpdatesQueue(updateRequest),
+ });
break;
}
case FlowOperationType.UPDATE_NOTE:
- case FlowOperationType.DELETE_NOTE:
- case FlowOperationType.ADD_NOTE: {
- debouncedAddToFlowUpdatesQueue(operation.request.id, updateRequest);
+ case FlowOperationType.DELETE_NOTE: {
+ flowUpdatesDebounce.schedule({
+ key: operation.request.id,
+ run: () => addToFlowUpdatesQueue(updateRequest),
+ });
break;
}
case FlowOperationType.DELETE_ACTION: {
@@ -248,16 +272,26 @@ export const createFlowState = (
outputSampleData,
};
});
- flowUpdatesQueue.add(updateRequest);
+ addToFlowUpdatesQueueAfterPendingEdits(updateRequest);
break;
}
default: {
- flowUpdatesQueue.add(updateRequest);
+ addToFlowUpdatesQueueAfterPendingEdits(updateRequest);
}
}
return { flowVersion: newFlowVersion };
}),
+ savePendingEdits: async () => {
+ get().flushPendingEdits();
+ await flowUpdatesQueue.drain();
+ if (!flowUpdatesDebounce.isEmpty()) {
+ await get().savePendingEdits();
+ }
+ },
+ flushPendingEdits: () => {
+ flowUpdatesDebounce.flush();
+ },
setVersion: (
flowVersion: FlowVersion,
shouldReselectInitialStep: boolean = true,
@@ -420,6 +454,99 @@ export const createFlowState = (
},
};
};
+
+async function refetchDraft(get: StoreApi<BuilderState>['getState']) {
+ const { flow, setFlow, setVersion } = get();
+ const { data: serverFlow, error } = await tryCatch(() =>
+ failAfterTimeout(() => flowsApi.get(flow.id)),
+ );
+ if (error !== null) {
+ internalErrorToast();
+ throw error;
+ }
+ setFlow(serverFlow);
+ setVersion(serverFlow.version);
+}
+
+function saveOperation({
+ flowId,
+ operation,
+}: {
+ flowId: string;
+ operation: FlowOperationRequest;
+}): Promise<PopulatedFlow> {
+ return sendWithRetries({
+ send: () => failAfterTimeout(() => flowsApi.update(flowId, operation)),
+ retryDelaysMs: IDEMPOTENT_OPERATION_TYPES.includes(operation.type)
+ ? SAVE_RETRY_DELAYS_MS
+ : [],
+ });
+}
+
+async function sendWithRetries({
+ send,
+ retryDelaysMs,
+}: {
+ send: () => Promise<PopulatedFlow>;
+ retryDelaysMs: number[];
+}): Promise<PopulatedFlow> {
+ const { data: savedFlow, error } = await tryCatch(send);
+ if (error === null) {
+ return savedFlow;
+ }
+ const [delayMs, ...laterDelaysMs] = retryDelaysMs;
+ if (isNil(delayMs) || !isTransientSaveError(error)) {
+ throw error;
+ }
+ await wait(delayMs);
+ return sendWithRetries({ send, retryDelaysMs: laterDelaysMs });
+}
+
+async function failAfterTimeout<T>(send: () => Promise<T>): Promise<T> {
+ let timer: ReturnType<typeof setTimeout> | undefined;
+ const timedOut = new Promise<never>((_, reject) => {
+ timer = setTimeout(
+ () =>
+ reject(
+ new AxiosError(
+ `timeout of ${FLOW_REQUEST_TIMEOUT_MS}ms exceeded`,
+ AxiosError.ETIMEDOUT,
+ ),
+ ),
+ FLOW_REQUEST_TIMEOUT_MS,
+ );
+ });
+ try {
+ return await Promise.race([send(), timedOut]);
+ } finally {
+ clearTimeout(timer);
+ }
+}
+
+function isTransientSaveError(error: unknown) {
+ if (!api.isError(error)) {
+ return false;
+ }
+ if (isNil(error.response)) {
+ return true;
+ }
+ const { status } = error.response;
+ return (
+ status === api.httpStatus.RequestTimeout ||
+ status === api.httpStatus.TooManyRequests ||
+ status >= api.httpStatus.InternalServerError
+ );
+}
+
+function showFailedSaveToast(error: unknown) {
+ toast.error(t('Your change was not saved'), {
+ id: 'failed-flow-save',
+ description:
+ api.serverErrorMessage(error) ??
+ t('The builder now shows the last saved version of the flow.'),
+ });
+}
+
/**Because the server creates the sample data files ids and we need to update the local flow version with the new sample data files ids so when an update happens again in the future it doesn't get unset */
const handleUpdatingSampleDataForStepLocallyAfterServerUpdate = ({
operation,
@@ -453,3 +580,17 @@ const handleUpdatingSampleDataForStepLocallyAfterServerUpdate = ({
},
});
};
+
+const SAVE_RETRY_DELAYS_MS = [1000, 2000, 4000];
+
+const FLOW_REQUEST_TIMEOUT_MS = 60_000;
+
+const IDEMPOTENT_OPERATION_TYPES = [
+ FlowOperationType.UPDATE_ACTION,
+ FlowOperationType.UPDATE_TRIGGER,
+ FlowOperationType.UPDATE_NOTE,
+ FlowOperationType.CHANGE_NAME,
+ FlowOperationType.SET_SKIP_ACTION,
+ FlowOperationType.UPDATE_SAMPLE_DATA_INFO,
+ FlowOperationType.IMPORT_FLOW,
+];
diff --git a/packages/web/src/app/components/flow-actions-menu.tsx b/packages/web/src/app/components/flow-actions-menu.tsx
index 3f8fbff119c..32ec4701dac 100644
--- a/packages/web/src/app/components/flow-actions-menu.tsx
+++ b/packages/web/src/app/components/flow-actions-menu.tsx
@@ -62,8 +62,16 @@ type FlowActionMenuProps = {
onDelete: () => void;
onOwnerChange?: () => void;
} & (
- | { insideBuilder: true; onVersionsListClick: () => void }
- | { insideBuilder: false; onVersionsListClick: null }
+ | {
+ insideBuilder: true;
+ onVersionsListClick: () => void;
+ savePendingEdits: () => Promise<void>;
+ }
+ | {
+ insideBuilder: false;
+ onVersionsListClick: null;
+ savePendingEdits: null;
+ }
);
const FlowActionMenu: React.FC<FlowActionMenuProps> = ({
@@ -78,6 +86,7 @@ const FlowActionMenu: React.FC<FlowActionMenuProps> = ({
onOwnerChange,
onVersionsListClick,
insideBuilder,
+ savePendingEdits,
}) => {
const isRunsPage = useLocation().pathname.includes('/runs');
const { platform } = platformHooks.useCurrentPlatform();
@@ -315,7 +324,11 @@ const FlowActionMenu: React.FC<FlowActionMenuProps> = ({
<PermissionNeededTooltip
hasPermission={userHasPermissionToUpdateFlow}
>
- <ImportFlowDialog insideBuilder={true} flowId={flow.id}>
+ <ImportFlowDialog
+ insideBuilder={true}
+ flowId={flow.id}
+ savePendingEdits={savePendingEdits}
+ >
<DropdownMenuItem
disabled={!userHasPermissionToUpdateFlow}
onSelect={(e) => e.preventDefault()}
diff --git a/packages/web/src/components/ui/sonner.tsx b/packages/web/src/components/ui/sonner.tsx
index 23eb94a750b..20e690c3c61 100644
--- a/packages/web/src/components/ui/sonner.tsx
+++ b/packages/web/src/components/ui/sonner.tsx
@@ -22,15 +22,6 @@ export function internalErrorToast() {
});
}
-export const UNSAVED_CHANGES_TOAST = {
- id: 'unsaved-changes',
- title: 'Unsaved Changes',
- description:
- 'Something went wrong and there are unsaved changes, please refresh and contact support if the problem persists.',
- variant: 'destructive',
- duration: Infinity,
-};
-
function Toaster({ ...props }: ToasterProps) {
const { resolvedTheme } = useTheme();
diff --git a/packages/web/src/features/flows/api/flows-api.tsx b/packages/web/src/features/flows/api/flows-api.tsx
index 37bf95d1955..6eb9bb349e1 100644
--- a/packages/web/src/features/flows/api/flows-api.tsx
+++ b/packages/web/src/features/flows/api/flows-api.tsx
@@ -12,9 +12,7 @@ import {
SharedTemplate,
CountFlowsRequest,
} from '@activepieces/shared';
-import { toast } from 'sonner';
-import { UNSAVED_CHANGES_TOAST } from '@/components/ui/sonner';
import { projectCollectionUtils } from '@/features/projects/stores/project-collection';
import { api } from '@/lib/api';
@@ -31,23 +29,9 @@ export const flowsApi = {
return flow;
});
},
- update(
- flowId: string,
- request: FlowOperationRequest,
- showErrorToast = false,
- ) {
+ update(flowId: string, request: FlowOperationRequest) {
return api
.post<PopulatedFlow>(`/v1/flows/${flowId}`, request)
- .catch((error) => {
- if (showErrorToast) {
- toast.error(UNSAVED_CHANGES_TOAST.title, {
- description: UNSAVED_CHANGES_TOAST.description,
- duration: UNSAVED_CHANGES_TOAST.duration,
- id: UNSAVED_CHANGES_TOAST.id,
- });
- }
- throw error;
- })
.then((flow) => {
projectCollectionUtils.markFlowActivity({
projectId: flow.projectId,
diff --git a/packages/web/src/features/flows/components/import-flow-dialog.tsx b/packages/web/src/features/flows/components/import-flow-dialog.tsx
index ac4d1e7d78a..8289488a995 100644
--- a/packages/web/src/features/flows/components/import-flow-dialog.tsx
+++ b/packages/web/src/features/flows/components/import-flow-dialog.tsx
@@ -1,4 +1,4 @@
-import { isNil } from '@activepieces/core-utils';
+import { isNil, tryCatch } from '@activepieces/core-utils';
import {
PopulatedFlow,
TelemetryEventName,
@@ -56,6 +56,7 @@ export type ImportFlowDialogProps =
| {
insideBuilder: true;
flowId: string;
+ savePendingEdits: () => Promise<void>;
};
const readTemplateJson = async (
@@ -175,6 +176,12 @@ const ImportFlowDialog = (
);
} else {
setErrorMessage('');
+ if (props.insideBuilder) {
+ const { error: saveError } = await tryCatch(props.savePendingEdits);
+ if (!isNil(saveError)) {
+ return;
+ }
+ }
importFlows(templates);
}
};
diff --git a/packages/web/src/features/tables/stores/store/ap-tables-server-state.ts b/packages/web/src/features/tables/stores/store/ap-tables-server-state.ts
index 7948f771d4a..f46193893e4 100644
--- a/packages/web/src/features/tables/stores/store/ap-tables-server-state.ts
+++ b/packages/web/src/features/tables/stores/store/ap-tables-server-state.ts
@@ -1,3 +1,4 @@
+import { isNil, tryCatch } from '@activepieces/core-utils';
import {
CreateFieldRequest,
Field,
@@ -6,6 +7,7 @@ import {
UpdateTableRequest,
} from '@activepieces/shared';
+import { errorReporting } from '@/lib/error-reporting';
import { PromiseQueue } from '@/lib/promise-queue';
import { fieldsApi } from '../../api/fields-api';
@@ -29,7 +31,11 @@ export const createServerState = (
function addPromiseToQueue(promise: () => Promise<void>) {
queue.add(async () => {
updateSavingStatus(true);
- await promise();
+ const { error } = await tryCatch(promise);
+ if (!isNil(error)) {
+ errorReporting.report({ error, source: 'table-save' });
+ throw error;
+ }
updateSavingStatus(queue.size() === 1);
});
}
diff --git a/packages/web/src/lib/error-reporting.ts b/packages/web/src/lib/error-reporting.ts
index cf3ee2ca563..2252385278e 100644
--- a/packages/web/src/lib/error-reporting.ts
+++ b/packages/web/src/lib/error-reporting.ts
@@ -154,4 +154,5 @@ export type FrontendErrorSource =
| 'window-error'
| 'unhandled-rejection'
| 'chunk-preload'
- | 'query';
+ | 'query'
+ | 'table-save';
diff --git a/packages/web/src/lib/keyed-debounce.ts b/packages/web/src/lib/keyed-debounce.ts
new file mode 100644
index 00000000000..b584b1b6c36
--- /dev/null
+++ b/packages/web/src/lib/keyed-debounce.ts
@@ -0,0 +1,48 @@
+import { isNil } from '@activepieces/core-utils';
+
+export class KeyedDebounce {
+ private readonly pending = new Map<string, PendingCall>();
+ private readonly wait: number;
+ private readonly maxWait: number;
+
+ constructor({ wait, maxWait }: { wait: number; maxWait: number }) {
+ this.wait = wait;
+ this.maxWait = maxWait;
+ }
+
+ schedule({ key, run }: { key: string; run: () => void }) {
+ const now = Date.now();
+ const previous = this.pending.get(key);
+ clearTimeout(previous?.timer);
+ const deadline = previous?.deadline ?? now + this.maxWait;
+ const timer = setTimeout(
+ () => this.fire(key),
+ Math.min(this.wait, deadline - now),
+ );
+ this.pending.set(key, { run, deadline, timer });
+ }
+
+ flush() {
+ [...this.pending.keys()].forEach((key) => this.fire(key));
+ }
+
+ isEmpty() {
+ return this.pending.size === 0;
+ }
+
+ private fire(key: string) {
+ const call = this.pending.get(key);
+ if (isNil(call)) {
+ return;
+ }
+ clearTimeout(call.timer);
+ this.pending.delete(key);
+ call.run();
+ }
+}
+
+type PendingCall = {
+ run: () => void;
+ deadline: number;
+ timer: ReturnType<typeof setTimeout>;
+};
diff --git a/packages/web/src/lib/promise-queue.ts b/packages/web/src/lib/promise-queue.ts
index e409f81778c..3b6b81bb3d9 100644
--- a/packages/web/src/lib/promise-queue.ts
+++ b/packages/web/src/lib/promise-queue.ts
@@ -1,29 +1,45 @@
import { Mutex } from 'async-mutex';
export class PromiseQueue {
- private queue: (() => Promise<unknown>)[] = [];
private lock: Mutex = new Mutex();
- private halted = false;
+ private waiting = 0;
+ private unsettled = new Set<Promise<void>>();
- add(promise: () => Promise<unknown>) {
- this.queue.push(promise);
- this.run();
+ add(task: () => Promise<unknown>) {
+ this.waiting++;
+ const completion = this.lock.runExclusive(async () => {
+ this.waiting--;
+ await task();
+ });
+ this.unsettled.add(completion);
+ const forget = () => {
+ this.unsettled.delete(completion);
+ };
+ completion.then(forget, forget);
}
- halt() {
- this.halted = true;
- }
size() {
- return this.queue.length;
+ return this.waiting;
}
- private run() {
- this.lock.runExclusive(async () => {
- const promise = this.queue.shift()!;
- if (this.halted) {
- return;
- }
- await promise();
- });
+ async drain(): Promise<void> {
+ const failure = await this.firstFailureUntilIdle();
+ if (failure) {
+ throw failure.reason;
+ }
+ }
+
+ private async firstFailureUntilIdle(): Promise<
+ PromiseRejectedResult | undefined
+ > {
+ const results = await Promise.allSettled([...this.unsettled]);
+ const failure = results.find(
+ (result): result is PromiseRejectedResult => result.status === 'rejected',
+ );
+ if (this.unsettled.size === 0) {
+ return failure;
+ }
+ const laterFailure = await this.firstFailureUntilIdle();
+ return failure ?? laterFailure;
}
}
diff --git a/packages/web/test/app/builder/flow-canvas/hooks.test.tsx b/packages/web/test/app/builder/flow-canvas/hooks.test.tsx
new file mode 100644
index 00000000000..dc629373167
--- /dev/null
+++ b/packages/web/test/app/builder/flow-canvas/hooks.test.tsx
@@ -0,0 +1,190 @@
+// @vitest-environment jsdom
+import {
+ EmptyTrigger,
+ FlowOperationRequest,
+ FlowOperationStatus,
+ FlowOperationType,
+ FlowStatus,
+ FlowTriggerType,
+ FlowVersionState,
+ PopulatedFlow,
+} from '@activepieces/shared';
+import { QueryClient } from '@tanstack/react-query';
+import { act } from 'react';
+import { createRoot, type Root } from 'react-dom/client';
+import { io } from 'socket.io-client';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+ BuilderStateContext,
+ BuilderStore,
+ createBuilderStore,
+} from '@/app/builder/builder-hooks';
+import { flowCanvasHooks } from '@/app/builder/flow-canvas/hooks';
+
+declare global {
+ // eslint-disable-next-line no-var
+ var IS_REACT_ACT_ENVIRONMENT: boolean;
+}
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+
+const flowsApiMock = vi.hoisted(() => ({
+ update:
+ vi.fn<
+ (
+ flowId: string,
+ operation: FlowOperationRequest,
+ ) => Promise<PopulatedFlow>
+ >(),
+ get: vi.fn<(flowId: string) => Promise<PopulatedFlow>>(),
+}));
+
+vi.mock('i18next', () => ({ t: (key: string) => key }));
+
+vi.mock('@/features/flows/api/flows-api', () => ({
+ flowsApi: flowsApiMock,
+}));
+
+describe('useFlushPendingEditsOnLeave', () => {
+ let container: HTMLDivElement;
+ let root: Root;
+
+ beforeEach(() => {
+ vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'Date'] });
+ flowsApiMock.update.mockReset();
+ flowsApiMock.update.mockResolvedValue(flowWithDraftVersion('draft-1'));
+ container = document.createElement('div');
+ document.body.appendChild(container);
+ root = createRoot(container);
+ });
+
+ afterEach(() => {
+ act(() => root.unmount());
+ container.remove();
+ vi.restoreAllMocks();
+ vi.useRealTimers();
+ });
+
+ it('sends a pending edit when the tab becomes hidden', async () => {
+ const store = createStore(flowWithDraftVersion('draft-1'));
+ mount(store);
+
+ store.getState().applyOperation(renameTrigger('New order'));
+ hideTab();
+ await vi.advanceTimersByTimeAsync(0);
+
+ expect(sentOperations()).toEqual([renameTrigger('New order')]);
+ });
+
+ it('sends a pending edit when the builder unmounts, and the save completes after it', async () => {
+ const save = Promise.withResolvers<PopulatedFlow>();
+ flowsApiMock.update.mockReturnValue(save.promise);
+ const store = createStore(flowWithDraftVersion('draft-1'));
+ mount(store);
+
+ store.getState().applyOperation(renameTrigger('New order'));
+ act(() => root.unmount());
+ await vi.advanceTimersByTimeAsync(0);
+ expect(sentOperations()).toEqual([renameTrigger('New order')]);
+
+ save.resolve(flowWithDraftVersion('draft-2'));
+ await vi.advanceTimersByTimeAsync(0);
+ expect(store.getState().flowVersion.id).toBe('draft-2');
+ expect(store.getState().saving).toBe(false);
+ });
+
+ function mount(store: BuilderStore) {
+ act(() => {
+ root.render(
+ <BuilderStateContext.Provider value={store}>
+ <LeaveWatcher />
+ </BuilderStateContext.Provider>,
+ );
+ });
+ }
+});
+
+function LeaveWatcher() {
+ flowCanvasHooks.useFlushPendingEditsOnLeave();
+ return null;
+}
+
+function hideTab() {
+ vi.spyOn(document, 'visibilityState', 'get').mockReturnValue('hidden');
+ document.dispatchEvent(new Event('visibilitychange'));
+}
+
+function renameTrigger(displayName: string): FlowOperationRequest {
+ return {
+ type: FlowOperationType.UPDATE_TRIGGER,
+ request: {
+ name: 'trigger',
+ valid: false,
+ displayName,
+ type: FlowTriggerType.EMPTY,
+ settings: {},
+ },
+ };
+}
+
+function sentOperations(): FlowOperationRequest[] {
+ return flowsApiMock.update.mock.calls.map(([, operation]) => operation);
+}
+
+function createStore(flow: PopulatedFlow): BuilderStore {
+ return createBuilderStore({
+ flow,
+ flowVersion: flow.version,
+ readonly: false,
+ hideTestWidget: false,
+ run: null,
+ outputSampleData: {},
+ inputSampleData: {},
+ socket: io({ autoConnect: false }),
+ queryClient: new QueryClient(),
+ });
+}
+
+function flowWithDraftVersion(versionId: string): PopulatedFlow {
+ const trigger: EmptyTrigger = {
+ name: 'trigger',
+ valid: false,
+ displayName: 'Select Trigger',
+ type: FlowTriggerType.EMPTY,
+ settings: {},
+ lastUpdatedDate: '2026-01-01T00:00:00.000Z',
+ };
+ return {
+ id: 'flow-1',
+ created: '2026-01-01T00:00:00.000Z',
+ updated: '2026-01-01T00:00:00.000Z',
+ projectId: 'project-1',
+ externalId: 'flow-1',
+ ownerId: null,
+ folderId: null,
+ status: FlowStatus.DISABLED,
+ publishedVersionId: null,
+ metadata: null,
+ operationStatus: FlowOperationStatus.NONE,
+ timeSavedPerRun: null,
+ templateId: null,
+ createdBy: null,
+ version: {
+ id: versionId,
+ created: '2026-01-01T00:00:00.000Z',
+ updated: '2026-01-01T00:00:00.000Z',
+ flowId: 'flow-1',
+ displayName: 'Order lookup',
+ trigger,
+ updatedBy: null,
+ valid: false,
+ schemaVersion: null,
+ agentIds: [],
+ state: FlowVersionState.DRAFT,
+ connectionIds: [],
+ backupFiles: null,
+ notes: [],
+ },
+ };
+}
diff --git a/packages/web/test/app/builder/flow-canvas/nodes/note-node/index.test.tsx b/packages/web/test/app/builder/flow-canvas/nodes/note-node/index.test.tsx
new file mode 100644
index 00000000000..11aff7450e6
--- /dev/null
+++ b/packages/web/test/app/builder/flow-canvas/nodes/note-node/index.test.tsx
@@ -0,0 +1,185 @@
+// @vitest-environment jsdom
+import {
+ EmptyTrigger,
+ FlowOperationRequest,
+ FlowOperationStatus,
+ FlowOperationType,
+ FlowStatus,
+ FlowTriggerType,
+ FlowVersionState,
+ Note,
+ NoteColorVariant,
+ PopulatedFlow,
+} from '@activepieces/shared';
+import { QueryClient } from '@tanstack/react-query';
+import { act } from 'react';
+import { createRoot, type Root } from 'react-dom/client';
+import { io } from 'socket.io-client';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+ BuilderStateContext,
+ BuilderStore,
+ createBuilderStore,
+} from '@/app/builder/builder-hooks';
+import { flowCanvasHooks } from '@/app/builder/flow-canvas/hooks';
+import { NoteContent } from '@/app/builder/flow-canvas/nodes/note-node';
+
+declare global {
+ // eslint-disable-next-line no-var
+ var IS_REACT_ACT_ENVIRONMENT: boolean;
+}
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+
+const flowsApiMock = vi.hoisted(() => ({
+ update:
+ vi.fn<
+ (
+ flowId: string,
+ operation: FlowOperationRequest,
+ ) => Promise<PopulatedFlow>
+ >(),
+ get: vi.fn<(flowId: string) => Promise<PopulatedFlow>>(),
+}));
+
+const noteEditor = vi.hoisted((): { type: (value: string) => void } => ({
+ type: () => undefined,
+}));
+
+vi.mock('i18next', () => ({ t: (key: string) => key }));
+
+vi.mock('@/features/flows/api/flows-api', () => ({
+ flowsApi: flowsApiMock,
+}));
+
+vi.mock('@/components/custom/markdown-input', () => ({
+ MarkdownInput: ({ onChange }: { onChange: (value: string) => void }) => {
+ noteEditor.type = onChange;
+ return null;
+ },
+}));
+
+describe('NoteContent', () => {
+ let container: HTMLDivElement;
+ let root: Root;
+
+ beforeEach(() => {
+ vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'Date'] });
+ flowsApiMock.update.mockReset();
+ flowsApiMock.update.mockResolvedValue(flowWithNote(note()));
+ container = document.createElement('div');
+ document.body.appendChild(container);
+ root = createRoot(container);
+ });
+
+ afterEach(() => {
+ act(() => root.unmount());
+ container.remove();
+ vi.useRealTimers();
+ });
+
+ it('saves a note edit typed just before the builder unmounts', async () => {
+ const store = createStore(flowWithNote(note()));
+ act(() => {
+ root.render(
+ <BuilderStateContext.Provider value={store}>
+ <BuilderWithNote />
+ </BuilderStateContext.Provider>,
+ );
+ });
+
+ act(() => noteEditor.type('Call the customer'));
+ act(() => root.unmount());
+ await vi.advanceTimersByTimeAsync(0);
+
+ expect(sentOperations()).toEqual([
+ {
+ type: FlowOperationType.UPDATE_NOTE,
+ request: expect.objectContaining({
+ id: 'note-1',
+ content: 'Call the customer',
+ }),
+ },
+ ]);
+ });
+});
+
+function BuilderWithNote() {
+ flowCanvasHooks.useFlushPendingEditsOnLeave();
+ return <NoteContent note={note()} isDragging={false} />;
+}
+
+function sentOperations(): FlowOperationRequest[] {
+ return flowsApiMock.update.mock.calls.map(([, operation]) => operation);
+}
+
+function createStore(flow: PopulatedFlow): BuilderStore {
+ return createBuilderStore({
+ flow,
+ flowVersion: flow.version,
+ readonly: false,
+ hideTestWidget: false,
+ run: null,
+ outputSampleData: {},
+ inputSampleData: {},
+ socket: io({ autoConnect: false }),
+ queryClient: new QueryClient(),
+ });
+}
+
+function note(): Note {
+ return {
+ id: 'note-1',
+ content: 'Check the order',
+ ownerId: null,
+ color: NoteColorVariant.YELLOW,
+ position: { x: 0, y: 0 },
+ size: { width: 200, height: 200 },
+ createdAt: '2026-01-01T00:00:00.000Z',
+ updatedAt: '2026-01-01T00:00:00.000Z',
+ };
+}
+
+function flowWithNote(flowNote: Note): PopulatedFlow {
+ const trigger: EmptyTrigger = {
+ name: 'trigger',
+ valid: false,
+ displayName: 'Select Trigger',
+ type: FlowTriggerType.EMPTY,
+ settings: {},
+ lastUpdatedDate: '2026-01-01T00:00:00.000Z',
+ };
+ return {
+ id: 'flow-1',
+ created: '2026-01-01T00:00:00.000Z',
+ updated: '2026-01-01T00:00:00.000Z',
+ projectId: 'project-1',
+ externalId: 'flow-1',
+ ownerId: null,
+ folderId: null,
+ status: FlowStatus.DISABLED,
+ publishedVersionId: null,
+ metadata: null,
+ operationStatus: FlowOperationStatus.NONE,
+ timeSavedPerRun: null,
+ templateId: null,
+ createdBy: null,
+ version: {
+ id: 'draft-1',
+ created: '2026-01-01T00:00:00.000Z',
+ updated: '2026-01-01T00:00:00.000Z',
+ flowId: 'flow-1',
+ displayName: 'Order lookup',
+ trigger,
+ updatedBy: null,
+ valid: false,
+ schemaVersion: null,
+ agentIds: [],
+ state: FlowVersionState.DRAFT,
+ connectionIds: [],
+ backupFiles: null,
+ notes: [flowNote],
+ },
+ };
+}
diff --git a/packages/web/test/app/builder/flow-canvas/widgets/discard-draft.test.ts b/packages/web/test/app/builder/flow-canvas/widgets/discard-draft.test.ts
index 981aa87517d..fd831e45aa3 100644
--- a/packages/web/test/app/builder/flow-canvas/widgets/discard-draft.test.ts
+++ b/packages/web/test/app/builder/flow-canvas/widgets/discard-draft.test.ts
@@ -15,6 +15,7 @@ const makePublishedFlow = () =>
const makeDeps = (overrides: Partial<RunDiscardDeps> = {}): RunDiscardDeps => ({
flow: { id: 'flow-1', publishedVersionId: 'v3' },
+ savePendingEdits: vi.fn(async () => undefined),
overWriteDraftWithVersion: vi.fn(async () => undefined),
fetchFlow: vi.fn(async () => makePublishedFlow()),
setFlow: vi.fn(),
@@ -36,6 +37,35 @@ describe('runDiscard', () => {
expect(deps.setVersion).not.toHaveBeenCalled();
});
+ it('saves the pending edits before it overwrites the draft', async () => {
+ const order: string[] = [];
+ const deps = makeDeps({
+ savePendingEdits: vi.fn(async () => {
+ order.push('save');
+ }),
+ overWriteDraftWithVersion: vi.fn(async () => {
+ order.push('overwrite');
+ }),
+ });
+
+ await runDiscard(deps);
+
+ expect(order).toEqual(['save', 'overwrite']);
+ });
+
+ it('stops quietly when a pending edit fails to save', async () => {
+ const deps = makeDeps({
+ savePendingEdits: vi.fn(async () => {
+ throw new Error('Request failed with status code 400');
+ }),
+ });
+
+ await expect(runDiscard(deps)).resolves.toBeUndefined();
+
+ expect(deps.overWriteDraftWithVersion).not.toHaveBeenCalled();
+ expect(deps.setFlow).not.toHaveBeenCalled();
+ });
+
it('overwrites the draft with the published version content first', async () => {
const deps = makeDeps();
diff --git a/packages/web/test/app/builder/flow-canvas/widgets/publish-flow-reminder-widget.test.tsx b/packages/web/test/app/builder/flow-canvas/widgets/publish-flow-reminder-widget.test.tsx
new file mode 100644
index 00000000000..80c8f00c468
--- /dev/null
+++ b/packages/web/test/app/builder/flow-canvas/widgets/publish-flow-reminder-widget.test.tsx
@@ -0,0 +1,252 @@
+// @vitest-environment jsdom
+import {
+ FlowOperationRequest,
+ FlowOperationStatus,
+ FlowOperationType,
+ FlowStatus,
+ FlowTriggerType,
+ FlowVersionState,
+ PopulatedFlow,
+} from '@activepieces/shared';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act } from 'react';
+import { createRoot, type Root } from 'react-dom/client';
+import { io } from 'socket.io-client';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+ BuilderStateContext,
+ BuilderStore,
+ createBuilderStore,
+} from '@/app/builder/builder-hooks';
+import { PublishFlowReminderWidget } from '@/app/builder/flow-canvas/widgets/publish-flow-reminder-widget';
+
+declare global {
+ // eslint-disable-next-line no-var
+ var IS_REACT_ACT_ENVIRONMENT: boolean;
+}
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+
+const flowsApiMock = vi.hoisted(() => ({
+ update:
+ vi.fn<
+ (
+ flowId: string,
+ operation: FlowOperationRequest,
+ ) => Promise<PopulatedFlow>
+ >(),
+ get: vi.fn<(flowId: string) => Promise<PopulatedFlow>>(),
+}));
+
+vi.mock('i18next', () => ({ t: (key: string) => key }));
+
+vi.mock('@/features/flows/api/flows-api', () => ({
+ flowsApi: flowsApiMock,
+}));
+
+vi.mock('@/hooks/platform-hooks', () => ({
+ platformHooks: {
+ useCurrentPlatform: () => ({
+ platform: { plan: { environmentsEnabled: false } },
+ }),
+ },
+}));
+
+vi.mock('@/hooks/flags-hooks', () => ({
+ flagsHooks: { useFlag: () => ({ data: true }) },
+}));
+
+vi.mock('@/hooks/authorization-hooks', () => ({
+ useAuthorization: () => ({ checkAccess: () => true }),
+}));
+
+vi.mock('@/features/projects', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('@/features/projects')>()),
+ projectCollectionUtils: {
+ useCurrentProject: () => ({ project: { sensitive: false } }),
+ },
+}));
+
+vi.mock('@/app/builder/flow-canvas/widgets/required-actions-dialog', () => ({
+ useRequiredActionsCheck: () => ({
+ checkRequiredActions: async () => null,
+ explainServerRejection: async () => null,
+ }),
+ RequiredActionsDialog: () => null,
+}));
+
+describe('PublishFlowReminderWidget', () => {
+ let container: HTMLDivElement;
+ let root: Root;
+
+ beforeEach(() => {
+ vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'Date'] });
+ flowsApiMock.update.mockReset();
+ flowsApiMock.update.mockResolvedValue(validDraftFlow());
+ container = document.createElement('div');
+ document.body.appendChild(container);
+ root = createRoot(container);
+ });
+
+ afterEach(() => {
+ act(() => root.unmount());
+ container.remove();
+ vi.useRealTimers();
+ });
+
+ it('shows Publish only after an edit in the debounce is saved, and publishes it', async () => {
+ const store = createStore(validDraftFlow());
+ store.getState().applyOperation(changeName('Orders'));
+ store.getState().applyOperation(renameTrigger('New order'));
+ await act(async () => root.render(<Widget store={store} />));
+ await settle();
+ expect(findPublishButton()).toBeNull();
+
+ await act(() => vi.advanceTimersByTimeAsync(1000));
+ await act(async () => publishButton().click());
+ await settle();
+
+ expect(sentOperationTypes()).toEqual([
+ FlowOperationType.CHANGE_NAME,
+ FlowOperationType.UPDATE_TRIGGER,
+ FlowOperationType.LOCK_AND_PUBLISH,
+ ]);
+ });
+
+ it('publishes only after the pending edits are saved', async () => {
+ const pendingEdits = Promise.withResolvers<void>();
+ const store = createStore(validDraftFlow());
+ store.setState({ savePendingEdits: () => pendingEdits.promise });
+ await act(async () => root.render(<Widget store={store} />));
+
+ await act(async () => publishButton().click());
+ await settle();
+ expect(sentOperationTypes()).toEqual([]);
+
+ pendingEdits.resolve();
+ await settle();
+ expect(sentOperationTypes()).toEqual([FlowOperationType.LOCK_AND_PUBLISH]);
+ });
+
+ it('does not publish when a pending edit fails to save', async () => {
+ const store = createStore(validDraftFlow());
+ store.setState({
+ savePendingEdits: () =>
+ Promise.reject(new Error('Request failed with status code 400')),
+ });
+ await act(async () => root.render(<Widget store={store} />));
+
+ await act(async () => publishButton().click());
+ await settle();
+
+ expect(sentOperationTypes()).toEqual([]);
+ expect(store.getState().isPublishing).toBe(false);
+ });
+});
+
+function Widget({ store }: { store: BuilderStore }) {
+ return (
+ <QueryClientProvider client={new QueryClient()}>
+ <BuilderStateContext.Provider value={store}>
+ <PublishFlowReminderWidget />
+ </BuilderStateContext.Provider>
+ </QueryClientProvider>
+ );
+}
+
+function publishButton(): HTMLButtonElement {
+ const button = findPublishButton();
+ if (!button) {
+ throw new Error('The Publish button is not on the page');
+ }
+ return button;
+}
+
+function findPublishButton(): HTMLButtonElement | null {
+ return document.querySelector<HTMLButtonElement>('button[name="Publish"]');
+}
+
+async function settle() {
+ await act(() => vi.advanceTimersByTimeAsync(100));
+}
+
+function sentOperationTypes(): FlowOperationType[] {
+ return flowsApiMock.update.mock.calls.map(([, operation]) => operation.type);
+}
+
+function changeName(displayName: string): FlowOperationRequest {
+ return {
+ type: FlowOperationType.CHANGE_NAME,
+ request: { displayName },
+ };
+}
+
+function renameTrigger(displayName: string): FlowOperationRequest {
+ return {
+ type: FlowOperationType.UPDATE_TRIGGER,
+ request: {
+ name: 'trigger',
+ valid: true,
+ displayName,
+ type: FlowTriggerType.EMPTY,
+ settings: {},
+ },
+ };
+}
+
+function createStore(flow: PopulatedFlow): BuilderStore {
+ return createBuilderStore({
+ flow,
+ flowVersion: flow.version,
+ readonly: false,
+ hideTestWidget: false,
+ run: null,
+ outputSampleData: {},
+ inputSampleData: {},
+ socket: io({ autoConnect: false }),
+ queryClient: new QueryClient(),
+ });
+}
+
+function validDraftFlow(): PopulatedFlow {
+ return {
+ id: 'flow-1',
+ created: '2026-01-01T00:00:00.000Z',
+ updated: '2026-01-01T00:00:00.000Z',
+ projectId: 'project-1',
+ externalId: 'flow-1',
+ ownerId: null,
+ folderId: null,
+ status: FlowStatus.DISABLED,
+ publishedVersionId: null,
+ metadata: null,
+ operationStatus: FlowOperationStatus.NONE,
+ timeSavedPerRun: null,
+ templateId: null,
+ createdBy: null,
+ version: {
+ id: 'draft-1',
+ created: '2026-01-01T00:00:00.000Z',
+ updated: '2026-01-01T00:00:00.000Z',
+ flowId: 'flow-1',
+ displayName: 'Order lookup',
+ trigger: {
+ name: 'trigger',
+ valid: true,
+ displayName: 'Select Trigger',
+ type: FlowTriggerType.EMPTY,
+ settings: {},
+ lastUpdatedDate: '2026-01-01T00:00:00.000Z',
+ },
+ updatedBy: null,
+ valid: true,
+ schemaVersion: null,
+ agentIds: [],
+ state: FlowVersionState.DRAFT,
+ connectionIds: [],
+ backupFiles: null,
+ notes: [],
+ },
+ };
+}
diff --git a/packages/web/test/app/builder/flow-versions/overwrite-draft-dialog.test.tsx b/packages/web/test/app/builder/flow-versions/overwrite-draft-dialog.test.tsx
new file mode 100644
index 00000000000..4c3efbe4a87
--- /dev/null
+++ b/packages/web/test/app/builder/flow-versions/overwrite-draft-dialog.test.tsx
@@ -0,0 +1,125 @@
+// @vitest-environment jsdom
+import {
+ FlowOperationStatus,
+ FlowStatus,
+ FlowTriggerType,
+ FlowVersionState,
+ PopulatedFlow,
+} from '@activepieces/shared';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { io } from 'socket.io-client';
+import { describe, expect, it, vi } from 'vitest';
+
+const flowsApiMock = vi.hoisted(() => ({ update: vi.fn(), get: vi.fn() }));
+
+vi.mock('i18next', () => ({ t: (key: string) => key }));
+
+vi.mock('@/features/flows/api/flows-api', () => ({
+ flowsApi: flowsApiMock,
+}));
+
+vi.mock('@/hooks/authorization-hooks', () => ({
+ useAuthorization: () => ({ checkAccess: () => true }),
+}));
+
+import {
+ BuilderStateContext,
+ createBuilderStore,
+} from '@/app/builder/builder-hooks';
+import { OverwriteDraftDialog } from '@/app/builder/flow-versions/overwrite-draft-dialog';
+
+describe('OverwriteDraftDialog', () => {
+ it('stays open and busy while the pending edits save, and closes after the overwrite', async () => {
+ const flow = draftFlow();
+ const store = createBuilderStore({
+ flow,
+ flowVersion: flow.version,
+ readonly: false,
+ hideTestWidget: false,
+ run: null,
+ outputSampleData: {},
+ inputSampleData: {},
+ socket: io({ autoConnect: false }),
+ queryClient: new QueryClient(),
+ });
+ const pendingEdits = Promise.withResolvers<void>();
+ store.setState({ savePendingEdits: () => pendingEdits.promise });
+ flowsApiMock.update.mockResolvedValue(flow);
+ const onConfirm = vi.fn();
+ render(
+ <QueryClientProvider client={new QueryClient()}>
+ <BuilderStateContext.Provider value={store}>
+ <OverwriteDraftDialog
+ versionId="version-0"
+ versionNumber="1"
+ onConfirm={onConfirm}
+ >
+ <span>Use as Draft</span>
+ </OverwriteDraftDialog>
+ </BuilderStateContext.Provider>
+ </QueryClientProvider>,
+ );
+ fireEvent.click(screen.getByText('Use as Draft'));
+ const overwrite = screen.getByRole('button', { name: 'Overwrite' });
+
+ fireEvent.click(overwrite);
+
+ await waitFor(() => {
+ expect(overwrite.hasAttribute('disabled')).toBe(true);
+ });
+ expect(screen.getByText('Overwrite Draft')).toBeTruthy();
+ expect(flowsApiMock.update).not.toHaveBeenCalled();
+ expect(onConfirm).not.toHaveBeenCalled();
+
+ pendingEdits.resolve();
+
+ await waitFor(() => {
+ expect(screen.queryByText('Overwrite Draft')).toBeNull();
+ });
+ expect(flowsApiMock.update).toHaveBeenCalledTimes(1);
+ expect(onConfirm).toHaveBeenCalledTimes(1);
+ });
+});
+
+function draftFlow(): PopulatedFlow {
+ return {
+ id: 'flow-1',
+ created: '2026-01-01T00:00:00.000Z',
+ updated: '2026-01-01T00:00:00.000Z',
+ projectId: 'project-1',
+ externalId: 'flow-1',
+ ownerId: null,
+ folderId: null,
+ status: FlowStatus.DISABLED,
+ publishedVersionId: null,
+ metadata: null,
+ operationStatus: FlowOperationStatus.NONE,
+ timeSavedPerRun: null,
+ templateId: null,
+ createdBy: null,
+ version: {
+ id: 'version-1',
+ created: '2026-01-01T00:00:00.000Z',
+ updated: '2026-01-01T00:00:00.000Z',
+ flowId: 'flow-1',
+ displayName: 'Order lookup',
+ trigger: {
+ name: 'trigger',
+ valid: false,
+ displayName: 'Select Trigger',
+ type: FlowTriggerType.EMPTY,
+ settings: {},
+ lastUpdatedDate: '2026-01-01T00:00:00.000Z',
+ },
+ updatedBy: null,
+ valid: false,
+ schemaVersion: null,
+ agentIds: [],
+ state: FlowVersionState.DRAFT,
+ connectionIds: [],
+ backupFiles: null,
+ notes: [],
+ },
+ };
+}
diff --git a/packages/web/test/app/builder/state/flow-state.test.ts b/packages/web/test/app/builder/state/flow-state.test.ts
new file mode 100644
index 00000000000..258a9455905
--- /dev/null
+++ b/packages/web/test/app/builder/state/flow-state.test.ts
@@ -0,0 +1,779 @@
+// @vitest-environment jsdom
+import { tryCatch } from '@activepieces/core-utils';
+import {
+ EmptyTrigger,
+ FlowOperationRequest,
+ FlowOperationStatus,
+ FlowOperationType,
+ FlowStatus,
+ FlowTriggerType,
+ FlowVersionState,
+ NoteColorVariant,
+ PopulatedFlow,
+ SampleDataFileType,
+ flowOperations,
+} from '@activepieces/shared';
+import { QueryClient } from '@tanstack/react-query';
+import { AxiosError, AxiosHeaders } from 'axios';
+import { toast } from 'sonner';
+import { io } from 'socket.io-client';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { BuilderStore, createBuilderStore } from '@/app/builder/builder-hooks';
+
+const flowsApiMock = vi.hoisted(() => ({
+ update: vi.fn(),
+ get: vi.fn(),
+}));
+
+vi.mock('i18next', () => ({ t: (key: string) => key }));
+
+vi.mock('@/features/flows/api/flows-api', () => ({
+ flowsApi: flowsApiMock,
+}));
+
+describe('flow state save path', () => {
+ beforeEach(() => {
+ flowsApiMock.update.mockReset();
+ flowsApiMock.get.mockReset();
+ vi.spyOn(toast, 'error').mockReset();
+ });
+
+ it('saves the next edit after a failed save', async () => {
+ flowsApiMock.update
+ .mockRejectedValueOnce(httpError({ status: 400 }))
+ .mockResolvedValue(draftFlow('Second name'));
+ flowsApiMock.get.mockResolvedValue(draftFlow('Order lookup'));
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(changeName('First name'));
+ await flushPromises();
+ store.getState().applyOperation(changeName('Second name'));
+ await flushPromises();
+
+ expect(sentOperations()).toEqual([
+ changeName('First name'),
+ changeName('Second name'),
+ ]);
+ });
+
+ it('sends the saves behind a failed save before it refetches the draft', async () => {
+ flowsApiMock.update
+ .mockRejectedValueOnce(httpError({ status: 400 }))
+ .mockResolvedValue(draftFlow('Second name'));
+ flowsApiMock.get.mockResolvedValue(draftFlow('Second name'));
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(changeName('First name'));
+ store.getState().applyOperation(changeName('Second name'));
+ await flushPromises();
+
+ expect(sentOperations()).toEqual([
+ changeName('First name'),
+ changeName('Second name'),
+ ]);
+ const [, queuedSaveOrder] = flowsApiMock.update.mock.invocationCallOrder;
+ const [refetchOrder] = flowsApiMock.get.mock.invocationCallOrder;
+ expect(refetchOrder).toBeGreaterThan(queuedSaveOrder);
+ expect(store.getState().flowVersion.displayName).toBe('Second name');
+ });
+
+ it('shows the message of a failed save', async () => {
+ flowsApiMock.update.mockRejectedValue(
+ serverError('Loop step parent step_9 not found'),
+ );
+ flowsApiMock.get.mockResolvedValue(draftFlow('Order lookup'));
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(changeName('First name'));
+ await flushPromises();
+
+ expect(toast.error).toHaveBeenCalledWith(
+ 'Your change was not saved',
+ expect.objectContaining({
+ description: 'Loop step parent step_9 not found',
+ }),
+ );
+ });
+
+ it('shows the draft on the server after a failed save', async () => {
+ flowsApiMock.update.mockRejectedValue(httpError({ status: 400 }));
+ flowsApiMock.get.mockResolvedValue(draftFlow('Name on the server'));
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(changeName('First name'));
+ expect(store.getState().flowVersion.displayName).toBe('First name');
+ await flushPromises();
+
+ expect(store.getState().flowVersion.displayName).toBe('Name on the server');
+ });
+
+ it('clears the saving flag after a failed save', async () => {
+ flowsApiMock.update.mockRejectedValue(httpError({ status: 400 }));
+ flowsApiMock.get.mockResolvedValue(draftFlow('Order lookup'));
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(changeName('First name'));
+ expect(store.getState().saving).toBe(true);
+ await flushPromises();
+
+ expect(store.getState().saving).toBe(false);
+ });
+
+ it('shows an error when the draft refetch after a failed save fails', async () => {
+ flowsApiMock.update.mockRejectedValue(httpError({ status: 400 }));
+ flowsApiMock.get.mockRejectedValue(new Error('Network Error'));
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(changeName('First name'));
+ await flushPromises();
+
+ expect(toast.error).toHaveBeenCalledWith(
+ 'Something went wrong',
+ expect.anything(),
+ );
+ });
+});
+
+describe('flow state step edits', () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ flowsApiMock.update.mockReset();
+ flowsApiMock.update.mockResolvedValue(draftFlow('Order lookup'));
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ it('saves a long typing burst in one step at least every 5 s', async () => {
+ const store = createStore(draftFlow('Order lookup'));
+
+ for (let elapsed = 0; elapsed < 12_000; elapsed += 200) {
+ store.getState().applyOperation(renameTrigger(`New order ${elapsed}`));
+ await vi.advanceTimersByTimeAsync(200);
+ }
+
+ expect(flowsApiMock.update.mock.calls.length).toBeGreaterThanOrEqual(2);
+ });
+
+ it('saves an edit 1 s after it when no keystroke follows', async () => {
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(renameTrigger('New order'));
+ await vi.advanceTimersByTimeAsync(999);
+ expect(sentOperations()).toEqual([]);
+
+ await vi.advanceTimersByTimeAsync(1);
+ expect(sentOperations()).toEqual([renameTrigger('New order')]);
+ });
+});
+
+describe('flow state pending edits', () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ flowsApiMock.update.mockReset();
+ flowsApiMock.update.mockResolvedValue(draftFlow('Order lookup'));
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ it('sends an edit inside the debounce at once', async () => {
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(renameTrigger('New order'));
+ await store.getState().savePendingEdits();
+
+ expect(sentOperations()).toEqual([renameTrigger('New order')]);
+ });
+
+ it('settles only after the save of the edit ends', async () => {
+ const save = Promise.withResolvers<PopulatedFlow>();
+ flowsApiMock.update.mockReturnValue(save.promise);
+ const store = createStore(draftFlow('Order lookup'));
+ const settled = vi.fn();
+
+ store.getState().applyOperation(renameTrigger('New order'));
+ const savingEdits = store.getState().savePendingEdits().then(settled);
+ await vi.advanceTimersByTimeAsync(0);
+ expect(settled).not.toHaveBeenCalled();
+
+ save.resolve(draftFlow('Order lookup'));
+ await savingEdits;
+ expect(settled).toHaveBeenCalled();
+ });
+
+ it('fails when the save of the edit fails, and shows the failed-save message', async () => {
+ const failure = httpError({ status: 400 });
+ flowsApiMock.update.mockRejectedValue(failure);
+ flowsApiMock.get.mockResolvedValue(draftFlow('Order lookup'));
+ vi.spyOn(toast, 'error').mockReset();
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(renameTrigger('New order'));
+
+ await expect(store.getState().savePendingEdits()).rejects.toBe(failure);
+ expect(toast.error).toHaveBeenCalledWith(
+ 'Your change was not saved',
+ expect.anything(),
+ );
+ });
+
+ it('sends an edit inside the debounce at once on a flush', async () => {
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(renameTrigger('New order'));
+ store.getState().flushPendingEdits();
+ await vi.advanceTimersByTimeAsync(0);
+
+ expect(sentOperations()).toEqual([renameTrigger('New order')]);
+ });
+});
+
+describe('flow state note edits', () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ flowsApiMock.update.mockReset();
+ flowsApiMock.update.mockResolvedValue(draftFlow('Order lookup'));
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ it('saves a new note when an edit of it follows within 1 s', async () => {
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(addNote());
+ await vi.advanceTimersByTimeAsync(300);
+ store.getState().applyOperation(updateNote('Call the customer'));
+ await vi.advanceTimersByTimeAsync(1000);
+
+ expect(sentOperations()).toEqual([
+ addNote(),
+ updateNote('Call the customer'),
+ ]);
+ });
+});
+
+describe('flow state save retries', () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ flowsApiMock.update.mockReset();
+ flowsApiMock.get.mockReset();
+ flowsApiMock.get.mockResolvedValue(draftFlow('Name on the server'));
+ vi.spyOn(toast, 'error').mockReset();
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ it('retries a save with no response after 1 s, 2 s and 4 s', async () => {
+ const start = Date.now();
+ const attemptTimes: number[] = [];
+ flowsApiMock.update.mockImplementation(async () => {
+ attemptTimes.push(Date.now() - start);
+ throw networkError();
+ });
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(changeName('First name'));
+ await vi.advanceTimersByTimeAsync(10_000);
+
+ expect(attemptTimes).toEqual([0, 1000, 3000, 7000]);
+ });
+
+ it.each([408, 429, 500, 503])(
+ 'retries a save with a %i status',
+ async (status) => {
+ flowsApiMock.update.mockRejectedValue(httpError({ status }));
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(changeName('First name'));
+ await vi.advanceTimersByTimeAsync(10_000);
+
+ expect(flowsApiMock.update).toHaveBeenCalledTimes(4);
+ },
+ );
+
+ it.each([400, 404, 409])(
+ 'never retries a save with a %i status',
+ async (status) => {
+ flowsApiMock.update.mockRejectedValue(httpError({ status }));
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(changeName('First name'));
+ await vi.advanceTimersByTimeAsync(10_000);
+
+ expect(flowsApiMock.update).toHaveBeenCalledTimes(1);
+ },
+ );
+
+ it('keeps the edit when a retry succeeds', async () => {
+ flowsApiMock.update
+ .mockRejectedValueOnce(networkError())
+ .mockResolvedValue(draftFlow('First name'));
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(changeName('First name'));
+ await vi.advanceTimersByTimeAsync(500);
+ expect(store.getState().saving).toBe(true);
+
+ await vi.advanceTimersByTimeAsync(10_000);
+
+ expect(store.getState().flowVersion.displayName).toBe('First name');
+ expect(store.getState().saving).toBe(false);
+ expect(flowsApiMock.get).not.toHaveBeenCalled();
+ expect(toast.error).not.toHaveBeenCalled();
+ });
+
+ it('sends later saves after the retries, in order', async () => {
+ flowsApiMock.update
+ .mockRejectedValueOnce(networkError())
+ .mockRejectedValueOnce(networkError())
+ .mockResolvedValue(draftFlow('Second name'));
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(changeName('First name'));
+ store.getState().applyOperation(changeName('Second name'));
+ await vi.advanceTimersByTimeAsync(10_000);
+
+ expect(sentOperations()).toEqual([
+ changeName('First name'),
+ changeName('First name'),
+ changeName('First name'),
+ changeName('Second name'),
+ ]);
+ });
+
+ it('runs the failure path after the last retry', async () => {
+ flowsApiMock.update.mockRejectedValue(networkError());
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(changeName('First name'));
+ await vi.advanceTimersByTimeAsync(6_999);
+ expect(toast.error).not.toHaveBeenCalled();
+ expect(flowsApiMock.get).not.toHaveBeenCalled();
+
+ await vi.advanceTimersByTimeAsync(1);
+ expect(toast.error).toHaveBeenCalledWith(
+ 'Your change was not saved',
+ expect.anything(),
+ );
+ expect(store.getState().flowVersion.displayName).toBe(
+ 'Name on the server',
+ );
+
+ await vi.advanceTimersByTimeAsync(10_000);
+ expect(toast.error).toHaveBeenCalledTimes(1);
+ expect(flowsApiMock.get).toHaveBeenCalledTimes(1);
+ expect(store.getState().saving).toBe(false);
+ });
+
+ it.each([deleteBranch(), deleteSteps(), saveSampleData()])(
+ 'never retries a $type save',
+ async (operation) => {
+ flowsApiMock.update.mockRejectedValue(networkError());
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(operation);
+ await vi.advanceTimersByTimeAsync(0);
+ expect(toast.error).toHaveBeenCalledWith(
+ 'Your change was not saved',
+ expect.anything(),
+ );
+
+ await vi.advanceTimersByTimeAsync(10_000);
+ expect(flowsApiMock.update).toHaveBeenCalledTimes(1);
+ },
+ );
+});
+
+describe('flow state edit order', () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ flowsApiMock.update.mockReset();
+ flowsApiMock.get.mockReset();
+ vi.spyOn(toast, 'error').mockReset();
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ it('sends a step edit that waits in the debounce before a later operation', async () => {
+ flowsApiMock.update.mockResolvedValue(draftFlow('Order lookup'));
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(renameTrigger('New order'));
+ store.getState().applyOperation(changeName('New name'));
+ await vi.advanceTimersByTimeAsync(0);
+
+ expect(sentOperations()).toEqual([
+ renameTrigger('New order'),
+ changeName('New name'),
+ ]);
+ });
+
+ it('saves a step edit that waits in the debounce before it refetches the draft after a failed save', async () => {
+ const server = serverThatKeepsTheDraft({
+ rejectedType: FlowOperationType.CHANGE_NAME,
+ });
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(renameTrigger('New order'));
+ store.getState().applyOperation(changeName('Bad name'));
+ await vi.advanceTimersByTimeAsync(5000);
+
+ expect(server.draft().version.trigger.displayName).toBe('New order');
+ expect(store.getState().flowVersion.trigger.displayName).toBe('New order');
+ });
+});
+
+describe('flow state saving flag', () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ flowsApiMock.update.mockReset();
+ flowsApiMock.get.mockReset();
+ vi.spyOn(toast, 'error').mockReset();
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ it('stays on while an edit waits in the debounce after a save ends', async () => {
+ const nameSave = Promise.withResolvers<PopulatedFlow>();
+ flowsApiMock.update
+ .mockReturnValueOnce(nameSave.promise)
+ .mockResolvedValue(draftFlow('New name'));
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(changeName('New name'));
+ await vi.advanceTimersByTimeAsync(0);
+ store.getState().applyOperation(renameTrigger('New order'));
+ nameSave.resolve(draftFlow('New name'));
+ await vi.advanceTimersByTimeAsync(0);
+ expect(store.getState().saving).toBe(true);
+
+ await vi.advanceTimersByTimeAsync(1000);
+ expect(store.getState().saving).toBe(false);
+ });
+
+ it('stays on while a pending step edit saves after a failed save', async () => {
+ const triggerSave = Promise.withResolvers<PopulatedFlow>();
+ flowsApiMock.update.mockImplementation(
+ (_flowId: string, operation: FlowOperationRequest) =>
+ operation.type === FlowOperationType.CHANGE_NAME
+ ? Promise.reject(httpError({ status: 400 }))
+ : triggerSave.promise,
+ );
+ flowsApiMock.get.mockResolvedValue(draftFlow('Order lookup'));
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(renameTrigger('New order'));
+ store.getState().applyOperation(changeName('Bad name'));
+ await vi.advanceTimersByTimeAsync(0);
+ expect(store.getState().saving).toBe(true);
+
+ triggerSave.resolve(draftFlow('Order lookup'));
+ await vi.advanceTimersByTimeAsync(0);
+ expect(store.getState().saving).toBe(false);
+ });
+});
+
+describe('flow state pending edits made during a save of pending edits', () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ flowsApiMock.update.mockReset();
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ it('settles only after an edit made during the wait is saved', async () => {
+ const firstSave = Promise.withResolvers<PopulatedFlow>();
+ const laterSave = Promise.withResolvers<PopulatedFlow>();
+ flowsApiMock.update
+ .mockReturnValueOnce(firstSave.promise)
+ .mockReturnValueOnce(laterSave.promise);
+ const store = createStore(draftFlow('Order lookup'));
+ const settled = vi.fn();
+
+ store.getState().applyOperation(renameTrigger('New order'));
+ const savingEdits = store.getState().savePendingEdits().then(settled);
+ store.getState().applyOperation(renameTrigger('Newer order'));
+ firstSave.resolve(draftFlow('Order lookup'));
+ await vi.advanceTimersByTimeAsync(0);
+
+ expect(sentOperations()).toEqual([
+ renameTrigger('New order'),
+ renameTrigger('Newer order'),
+ ]);
+ expect(settled).not.toHaveBeenCalled();
+
+ laterSave.resolve(draftFlow('Order lookup'));
+ await savingEdits;
+ expect(settled).toHaveBeenCalled();
+ });
+});
+
+describe('flow state request timeout', () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ flowsApiMock.update.mockReset();
+ flowsApiMock.get.mockReset();
+ vi.spyOn(toast, 'error').mockReset();
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ it('fails a save that gets no answer in 60 s', async () => {
+ flowsApiMock.update.mockReturnValue(new Promise(() => undefined));
+ flowsApiMock.get.mockResolvedValue(draftFlow('Order lookup'));
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(deleteSteps());
+ const savingEdits = tryCatch(() => store.getState().savePendingEdits());
+ await vi.advanceTimersByTimeAsync(59_999);
+ expect(toast.error).not.toHaveBeenCalled();
+
+ await vi.advanceTimersByTimeAsync(1);
+ const { error } = await savingEdits;
+ expect(error?.message).toBe('timeout of 60000ms exceeded');
+ expect(toast.error).toHaveBeenCalledWith(
+ 'Your change was not saved',
+ expect.anything(),
+ );
+ expect(store.getState().saving).toBe(false);
+ });
+
+ it('retries an idempotent save that gets no answer in 60 s', async () => {
+ flowsApiMock.update
+ .mockReturnValueOnce(new Promise(() => undefined))
+ .mockResolvedValue(draftFlow('New name'));
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(changeName('New name'));
+ await vi.advanceTimersByTimeAsync(60_999);
+ expect(flowsApiMock.update).toHaveBeenCalledTimes(1);
+
+ await vi.advanceTimersByTimeAsync(1);
+ expect(flowsApiMock.update).toHaveBeenCalledTimes(2);
+ expect(toast.error).not.toHaveBeenCalled();
+ });
+
+ it('fails a draft refetch that gets no answer in 60 s, and saves the next edit', async () => {
+ flowsApiMock.update
+ .mockRejectedValueOnce(httpError({ status: 400 }))
+ .mockResolvedValue(draftFlow('Second name'));
+ flowsApiMock.get.mockReturnValue(new Promise(() => undefined));
+ const store = createStore(draftFlow('Order lookup'));
+
+ store.getState().applyOperation(changeName('First name'));
+ await vi.advanceTimersByTimeAsync(60_000);
+ expect(toast.error).toHaveBeenCalledWith(
+ 'Something went wrong',
+ expect.anything(),
+ );
+
+ store.getState().applyOperation(changeName('Second name'));
+ await vi.advanceTimersByTimeAsync(0);
+ expect(sentOperations()).toEqual([
+ changeName('First name'),
+ changeName('Second name'),
+ ]);
+ });
+});
+
+function serverThatKeepsTheDraft({
+ rejectedType,
+}: {
+ rejectedType: FlowOperationType;
+}) {
+ let draft = draftFlow('Order lookup');
+ flowsApiMock.update.mockImplementation(
+ async (_flowId: string, operation: FlowOperationRequest) => {
+ if (operation.type === rejectedType) {
+ throw httpError({ status: 400 });
+ }
+ draft = {
+ ...draft,
+ version: flowOperations.apply(draft.version, operation),
+ };
+ return draft;
+ },
+ );
+ flowsApiMock.get.mockImplementation(async () => draft);
+ return { draft: () => draft };
+}
+
+function networkError() {
+ return new AxiosError('Network Error', AxiosError.ERR_NETWORK, undefined, {});
+}
+
+function serverError(message: string) {
+ return httpError({
+ status: 400,
+ data: { code: 'FLOW_OPERATION_INVALID', params: { message } },
+ });
+}
+
+function httpError({ status, data = {} }: { status: number; data?: unknown }) {
+ return new AxiosError(
+ `Request failed with status code ${status}`,
+ status >= 500 ? AxiosError.ERR_BAD_RESPONSE : AxiosError.ERR_BAD_REQUEST,
+ undefined,
+ {},
+ {
+ data,
+ status,
+ statusText: '',
+ headers: {},
+ config: { headers: new AxiosHeaders() },
+ },
+ );
+}
+
+function changeName(displayName: string): FlowOperationRequest {
+ return {
+ type: FlowOperationType.CHANGE_NAME,
+ request: { displayName },
+ };
+}
+
+function deleteBranch(): FlowOperationRequest {
+ return {
+ type: FlowOperationType.DELETE_BRANCH,
+ request: { stepName: 'step_1', branchIndex: 0 },
+ };
+}
+
+function deleteSteps(): FlowOperationRequest {
+ return {
+ type: FlowOperationType.DELETE_ACTION,
+ request: { names: ['step_1'] },
+ };
+}
+
+function saveSampleData(): FlowOperationRequest {
+ return {
+ type: FlowOperationType.SAVE_SAMPLE_DATA,
+ request: {
+ stepName: 'trigger',
+ payload: { orderId: 'order-1' },
+ type: SampleDataFileType.OUTPUT,
+ },
+ };
+}
+
+function addNote(): FlowOperationRequest {
+ return {
+ type: FlowOperationType.ADD_NOTE,
+ request: {
+ id: 'note-1',
+ content: '',
+ color: NoteColorVariant.YELLOW,
+ position: { x: 0, y: 0 },
+ size: { width: 200, height: 200 },
+ },
+ };
+}
+
+function updateNote(content: string): FlowOperationRequest {
+ return {
+ type: FlowOperationType.UPDATE_NOTE,
+ request: {
+ id: 'note-1',
+ content,
+ ownerId: null,
+ color: NoteColorVariant.YELLOW,
+ position: { x: 0, y: 0 },
+ size: { width: 200, height: 200 },
+ },
+ };
+}
+
+function renameTrigger(displayName: string): FlowOperationRequest {
+ return {
+ type: FlowOperationType.UPDATE_TRIGGER,
+ request: {
+ name: 'trigger',
+ valid: false,
+ displayName,
+ type: FlowTriggerType.EMPTY,
+ settings: {},
+ },
+ };
+}
+
+function sentOperations(): FlowOperationRequest[] {
+ return flowsApiMock.update.mock.calls.map(([, operation]) => operation);
+}
+
+function createStore(flow: PopulatedFlow): BuilderStore {
+ return createBuilderStore({
+ flow,
+ flowVersion: flow.version,
+ readonly: false,
+ hideTestWidget: false,
+ run: null,
+ outputSampleData: {},
+ inputSampleData: {},
+ socket: io({ autoConnect: false }),
+ queryClient: new QueryClient(),
+ });
+}
+
+async function flushPromises() {
+ await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+function draftFlow(displayName: string): PopulatedFlow {
+ const trigger: EmptyTrigger = {
+ name: 'trigger',
+ valid: false,
+ displayName: 'Select Trigger',
+ type: FlowTriggerType.EMPTY,
+ settings: {},
+ lastUpdatedDate: '2026-01-01T00:00:00.000Z',
+ };
+ return {
+ id: 'flow-1',
+ created: '2026-01-01T00:00:00.000Z',
+ updated: '2026-01-01T00:00:00.000Z',
+ projectId: 'project-1',
+ externalId: 'flow-1',
+ ownerId: null,
+ folderId: null,
+ status: FlowStatus.DISABLED,
+ publishedVersionId: null,
+ metadata: null,
+ operationStatus: FlowOperationStatus.NONE,
+ timeSavedPerRun: null,
+ templateId: null,
+ createdBy: null,
+ version: {
+ id: 'draft-1',
+ created: '2026-01-01T00:00:00.000Z',
+ updated: '2026-01-01T00:00:00.000Z',
+ flowId: 'flow-1',
+ displayName,
+ trigger,
+ updatedBy: null,
+ valid: false,
+ schemaVersion: null,
+ agentIds: [],
+ state: FlowVersionState.DRAFT,
+ connectionIds: [],
+ backupFiles: null,
+ notes: [],
+ },
+ };
+}
diff --git a/packages/web/test/features/tables/ap-tables-server-state.test.ts b/packages/web/test/features/tables/ap-tables-server-state.test.ts
new file mode 100644
index 00000000000..d7478853d44
--- /dev/null
+++ b/packages/web/test/features/tables/ap-tables-server-state.test.ts
@@ -0,0 +1,47 @@
+// @vitest-environment jsdom
+import { FieldType, Table, TableAutomationStatus } from '@activepieces/shared';
+import { describe, expect, it, vi } from 'vitest';
+
+import { createServerState } from '@/features/tables/stores/store/ap-tables-server-state';
+
+const fieldsApiMock = vi.hoisted(() => ({ create: vi.fn() }));
+const errorReportingMock = vi.hoisted(() => ({ report: vi.fn() }));
+
+vi.mock('@/features/tables/api/fields-api', () => ({
+ fieldsApi: fieldsApiMock,
+}));
+
+vi.mock('@/lib/error-reporting', () => ({
+ errorReporting: errorReportingMock,
+}));
+
+const table: Table = {
+ id: 'table-1',
+ created: '2026-08-12T00:00:00.000Z',
+ updated: '2026-08-12T00:00:00.000Z',
+ name: 'New Table',
+ projectId: 'project-1',
+ externalId: 'table-1',
+ status: TableAutomationStatus.ENABLED,
+ trigger: null,
+};
+
+describe('createServerState', () => {
+ it('reports a failed table save', async () => {
+ const failure = new Error('field create failed');
+ fieldsApiMock.create.mockRejectedValue(failure);
+ const serverState = createServerState(table, [], [], () => undefined);
+
+ serverState.createField({
+ name: 'Email',
+ type: FieldType.TEXT,
+ tableId: table.id,
+ });
+ await new Promise((resolve) => setTimeout(resolve, 0));
+
+ expect(errorReportingMock.report).toHaveBeenCalledWith({
+ error: failure,
+ source: 'table-save',
+ });
+ });
+});
diff --git a/packages/web/test/lib/keyed-debounce.test.ts b/packages/web/test/lib/keyed-debounce.test.ts
new file mode 100644
index 00000000000..e2d6d432a2d
--- /dev/null
+++ b/packages/web/test/lib/keyed-debounce.test.ts
@@ -0,0 +1,100 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { KeyedDebounce } from '@/lib/keyed-debounce';
+
+describe('KeyedDebounce', () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ describe('isEmpty', () => {
+ it('is true only while no call waits', () => {
+ const debounce = new KeyedDebounce({ wait: 1000, maxWait: 5000 });
+ expect(debounce.isEmpty()).toBe(true);
+
+ debounce.schedule({ key: 'step_1', run: () => undefined });
+ expect(debounce.isEmpty()).toBe(false);
+
+ vi.advanceTimersByTime(1000);
+ expect(debounce.isEmpty()).toBe(true);
+ });
+ });
+
+ describe('flush', () => {
+ it('sends the pending call of every key at once', () => {
+ const debounce = new KeyedDebounce({ wait: 1000, maxWait: 5000 });
+ const sent: string[] = [];
+
+ debounce.schedule({ key: 'step_1', run: () => sent.push('step_1 edit') });
+ debounce.schedule({ key: 'note_1', run: () => sent.push('note_1 edit') });
+ debounce.flush();
+ expect(sent).toEqual(['step_1 edit', 'note_1 edit']);
+
+ vi.advanceTimersByTime(5000);
+ expect(sent).toEqual(['step_1 edit', 'note_1 edit']);
+ });
+
+ it('starts a new wait for a call after the flush', () => {
+ const debounce = new KeyedDebounce({ wait: 1000, maxWait: 5000 });
+ const sent: string[] = [];
+
+ debounce.schedule({ key: 'step_1', run: () => sent.push('Ord') });
+ vi.advanceTimersByTime(500);
+ debounce.flush();
+ debounce.schedule({ key: 'step_1', run: () => sent.push('Order') });
+ vi.advanceTimersByTime(999);
+ expect(sent).toEqual(['Ord']);
+
+ vi.advanceTimersByTime(1);
+ expect(sent).toEqual(['Ord', 'Order']);
+ });
+ });
+
+ it('sends only the latest call of a key, after the wait', () => {
+ const debounce = new KeyedDebounce({ wait: 1000, maxWait: 5000 });
+ const sent: string[] = [];
+
+ debounce.schedule({ key: 'step_1', run: () => sent.push('Ord') });
+ vi.advanceTimersByTime(500);
+ debounce.schedule({ key: 'step_1', run: () => sent.push('Order') });
+ vi.advanceTimersByTime(999);
+ expect(sent).toEqual([]);
+
+ vi.advanceTimersByTime(1);
+ expect(sent).toEqual(['Order']);
+ });
+
+ it('keeps one timer for each key', () => {
+ const debounce = new KeyedDebounce({ wait: 1000, maxWait: 5000 });
+ const sent: string[] = [];
+
+ debounce.schedule({ key: 'step_1', run: () => sent.push('step_1 first') });
+ vi.advanceTimersByTime(500);
+ debounce.schedule({ key: 'note_1', run: () => sent.push('note_1 edit') });
+ vi.advanceTimersByTime(400);
+ debounce.schedule({ key: 'step_1', run: () => sent.push('step_1 second') });
+ vi.advanceTimersByTime(600);
+ expect(sent).toEqual(['note_1 edit']);
+
+ vi.advanceTimersByTime(400);
+ expect(sent).toEqual(['note_1 edit', 'step_1 second']);
+ });
+
+ it('sends a continuous burst of calls at least every 5 s', () => {
+ const debounce = new KeyedDebounce({ wait: 1000, maxWait: 5000 });
+ const sent: number[] = [];
+
+ for (let elapsed = 0; elapsed < 12_000; elapsed += 200) {
+ debounce.schedule({ key: 'step_1', run: () => sent.push(elapsed) });
+ vi.advanceTimersByTime(200);
+ }
+ expect(sent).toEqual([4800, 9800]);
+
+ vi.advanceTimersByTime(800);
+ expect(sent).toEqual([4800, 9800, 11_800]);
+ });
+});
diff --git a/packages/web/test/lib/promise-queue.test.ts b/packages/web/test/lib/promise-queue.test.ts
new file mode 100644
index 00000000000..75b17656e34
--- /dev/null
+++ b/packages/web/test/lib/promise-queue.test.ts
@@ -0,0 +1,142 @@
+import { describe, expect, it } from 'vitest';
+
+import { PromiseQueue } from '@/lib/promise-queue';
+
+describe('PromiseQueue', () => {
+ it('runs the next task after a task fails', async () => {
+ const queue = new PromiseQueue();
+ const ran: string[] = [];
+
+ queue.add(async () => {
+ throw new Error('save failed');
+ });
+ queue.add(async () => {
+ ran.push('next save');
+ });
+ await flushPromises();
+
+ expect(ran).toEqual(['next save']);
+ });
+
+ describe('drain', () => {
+ it('settles at once on an empty queue', async () => {
+ const queue = new PromiseQueue();
+
+ await expect(queue.drain()).resolves.toBeUndefined();
+ });
+
+ it('settles after the save in flight and the queued saves', async () => {
+ const queue = new PromiseQueue();
+ const saveInFlight = controlledSave();
+ const queuedSave = controlledSave();
+ queue.add(saveInFlight.run);
+ queue.add(queuedSave.run);
+ await flushPromises();
+
+ const drained = trackSettled(queue.drain());
+ saveInFlight.finish();
+ await flushPromises();
+ expect(drained.settled).toBe(false);
+
+ queuedSave.finish();
+ await flushPromises();
+ expect(drained.settled).toBe(true);
+ });
+
+ it('rejects when a save in the queue fails', async () => {
+ const queue = new PromiseQueue();
+ queue.add(async () => {
+ throw new Error('save failed');
+ });
+ queue.add(async () => undefined);
+
+ await expect(queue.drain()).rejects.toThrow('save failed');
+ });
+
+ it('rejects only after the saves behind a failed save settle', async () => {
+ const queue = new PromiseQueue();
+ queue.add(async () => {
+ throw new Error('save failed');
+ });
+ const queuedSave = controlledSave();
+ queue.add(queuedSave.run);
+
+ const drained = trackSettled(queue.drain());
+ await flushPromises();
+ expect(drained.settled).toBe(false);
+
+ queuedSave.finish();
+ await flushPromises();
+ expect(drained.settled).toBe(true);
+ });
+
+ it('settles only after a save added during the drain', async () => {
+ const queue = new PromiseQueue();
+ const firstSave = controlledSave();
+ const laterSave = controlledSave();
+ queue.add(firstSave.run);
+
+ const drained = trackSettled(queue.drain());
+ queue.add(laterSave.run);
+ firstSave.finish();
+ await flushPromises();
+ expect(drained.settled).toBe(false);
+
+ laterSave.finish();
+ await flushPromises();
+ expect(drained.settled).toBe(true);
+ });
+
+ it('rejects when a save added during the drain fails', async () => {
+ const queue = new PromiseQueue();
+ const firstSave = controlledSave();
+ queue.add(firstSave.run);
+
+ const drained = queue.drain();
+ queue.add(async () => {
+ throw new Error('later save failed');
+ });
+ firstSave.finish();
+
+ await expect(drained).rejects.toThrow('later save failed');
+ });
+
+ it('ignores a failed save that settled before the drain', async () => {
+ const queue = new PromiseQueue();
+ queue.add(async () => {
+ throw new Error('save failed');
+ });
+ await flushPromises();
+
+ await expect(queue.drain()).resolves.toBeUndefined();
+ });
+ });
+});
+
+function controlledSave() {
+ let finish: () => void = () => undefined;
+ const done = new Promise<void>((resolve) => {
+ finish = resolve;
+ });
+ return {
+ run: () => done,
+ finish: () => finish(),
+ };
+}
+
+function trackSettled(promise: Promise<unknown>) {
+ const tracker = { settled: false };
+ promise.then(
+ () => {
+ tracker.settled = true;
+ },
+ () => {
+ tracker.settled = true;
+ },
+ );
+ return tracker;
+}
+
+async function flushPromises() {
+ await new Promise((resolve) => setTimeout(resolve, 0));
+}