From 79c9eba1dfa717f2c938549abe30a64f8011ad1a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=BF=85=E8=86=80?= Date: Sat, 17 Oct 2026 15:48:21 +0800 Subject: [PATCH] fix(editors): scope async results and fragment writes to sessions A completed save or dry run must not close or overwrite a newer editor. Keep fragment state scoped by group, reject writes until the real list is ready, and retain in-flight fragment locks across navigation. --- app/components/ConsolePage.vue | 16 ++++++++-- app/components/RouteEditor.vue | 51 ++++++++++++++++++++++++------ app/composables/useFragments.ts | 55 ++++++++++++++++++++++++++++----- app/composables/useI18n.ts | 2 ++ 4 files changed, 106 insertions(+), 18 deletions(-) diff --git a/app/components/ConsolePage.vue b/app/components/ConsolePage.vue index 462d6e0..1cbba2d 100644 --- a/app/components/ConsolePage.vue +++ b/app/components/ConsolePage.vue @@ -410,6 +410,8 @@ + { onBeforeUnmount(() => window.removeEventListener("keydown", onReorderKey)); function openNew(): void { + routeEditorSession++; editing.value = null; editorOpen.value = true; } function openEdit(route: Route): void { + routeEditorSession++; editing.value = route; editorOpen.value = true; } @@ -946,6 +954,7 @@ function openEdit(route: Route): void { async function onSave(route: Route): Promise { const group = selectedGroup.value; if (!group || !canWriteRoutes()) return; + const session = routeEditorSession; saving.value = true; try { let next: Route[]; @@ -959,7 +968,7 @@ async function onSave(route: Route): Promise { next = [...groupRoutes.value, route]; } await saveGroupRoutes(group.id, next); - editorOpen.value = false; + if (session === routeEditorSession) editorOpen.value = false; push(t("toast.routesSaved")); } catch (err) { push(t("toast.saveFailed", { msg: err instanceof Error ? err.message : String(err) }), "bad"); @@ -1008,11 +1017,13 @@ async function onDelete(route: Route): Promise { } function openNewGroup(): void { + groupEditorSession++; editingGroup.value = null; groupEditorOpen.value = true; } function openEditGroup(group: Group): void { + groupEditorSession++; editingGroup.value = group; groupEditorOpen.value = true; } @@ -1032,6 +1043,7 @@ async function onSaveGroupFromPanel(group: Group): Promise { } async function onSaveGroup(group: Group): Promise { + const session = groupEditorSession; savingGroup.value = true; try { const editing = editingGroup.value; @@ -1053,7 +1065,7 @@ async function onSaveGroup(group: Group): Promise { next = [...groups.value, group]; } await saveGroups(next); - groupEditorOpen.value = false; + if (session === groupEditorSession) groupEditorOpen.value = false; push(t("toast.groupSaved")); await loadGroups(); } catch (err) { diff --git a/app/components/RouteEditor.vue b/app/components/RouteEditor.vue index 3b36cc0..2f37dc4 100644 --- a/app/components/RouteEditor.vue +++ b/app/components/RouteEditor.vue @@ -75,7 +75,14 @@ provide( ); const eventSuggestions = computed(() => eventOptions(locale.value)); -const { fragments, load: loadFragments, save: saveFragments } = useFragmentsApi(); +const { + fragments, + readyFor: fragmentsReadyFor, + load: loadFragments, + save: saveFragments, +} = useFragmentsApi(); +/** This group's fragments are loaded and no fragment write is running. */ +const fragmentsWritable = computed(() => !!props.groupId && fragmentsReadyFor(props.groupId)); const fragmentName = ref(""); const fragmentError = ref(""); @@ -266,6 +273,13 @@ function onOpenChange(open: boolean): void { if (!open && !isBackdropClose()) close(); } +/** + * Bumped whenever the editor opens or closes. The console keeps one editor + * for every group, so an async result (a test run, a fragment write) only + * lands in the session that started it. + */ +let session = 0; + async function runTest(): Promise { testError.value = ""; testResult.value = null; @@ -290,19 +304,21 @@ async function runTest(): Promise { testError.value = t("routeEditor.errAddFilter"); return; } + const mine = session; testing.value = true; try { - testResult.value = await apiFetch<{ matched: boolean; explanation: string }>( + const result = await apiFetch<{ matched: boolean; explanation: string }>( "/admin/api/test-match", { method: "POST", body: JSON.stringify({ node, event: testEvent.value.trim() || undefined, payload }), }, ); + if (mine === session) testResult.value = result; } catch (err) { - testError.value = err instanceof Error ? err.message : String(err); + if (mine === session) testError.value = err instanceof Error ? err.message : String(err); } finally { - testing.value = false; + if (mine === session) testing.value = false; } } @@ -332,6 +348,11 @@ async function saveAsFragment(): Promise { return; } if (!props.groupId) return; + // A save replaces the group's whole list: never from one not loaded yet. + if (!fragmentsReadyFor(props.groupId)) { + fragmentError.value = t("routeEditor.fragmentsNotReady"); + return; + } const problem = filterTreeError(); if (problem) { fragmentError.value = problem; @@ -342,35 +363,44 @@ async function saveAsFragment(): Promise { fragmentError.value = t("routeEditor.errAddFilter"); return; } + const groupId = props.groupId; const id = `frag-${Math.random().toString(36).slice(2, 10)}`; const next: NamedFragment[] = [ ...fragments.value.filter((f) => f.id !== id), - { id, groupId: props.groupId, name, node }, + { id, groupId, name, node }, ]; + const mine = session; try { - await saveFragments(props.groupId, next); - fragmentName.value = ""; + await saveFragments(groupId, next); + if (mine === session) fragmentName.value = ""; } catch (err) { - fragmentError.value = err instanceof Error ? err.message : String(err); + if (mine === session) fragmentError.value = err instanceof Error ? err.message : String(err); } } async function deleteFragment(frag: NamedFragment): Promise { const groupId = props.groupId; if (!groupId) return; + const mine = session; if (!(await confirm({ title: t("confirm.deleteFragment", { name: frag.name }) }))) return; + if (mine !== session) return; fragmentError.value = ""; + if (props.groupId !== groupId || !fragmentsReadyFor(groupId)) { + fragmentError.value = t("routeEditor.fragmentsNotReady"); + return; + } const next = fragments.value.filter((f) => f.id !== frag.id); try { await saveFragments(groupId, next); } catch (err) { - fragmentError.value = err instanceof Error ? err.message : String(err); + if (mine === session) fragmentError.value = err instanceof Error ? err.message : String(err); } } watch( () => props.open, (open) => { + session++; if (!open) return; const r = props.route; form.id = r?.id ?? ""; @@ -404,6 +434,7 @@ watch( testEvent.value = ""; testResult.value = null; testError.value = ""; + testing.value = false; fragmentName.value = ""; fragmentError.value = ""; if (props.groupId) loadFragments(props.groupId); @@ -562,6 +593,7 @@ watch( color="error" size="icon" class="h-8 w-8 text-muted hover:text-bad" + :disabled="!fragmentsWritable" :title="t('routeEditor.fragmentsDelete')" :aria-label="t('routeEditor.fragmentsDelete')" @click="deleteFragment(frag)" @@ -581,6 +613,7 @@ watch( type="button" variant="ghost" class="shrink-0 whitespace-nowrap" + :disabled="!fragmentsWritable" @click="saveAsFragment" > {{ t("routeEditor.fragmentsSave") }} diff --git a/app/composables/useFragments.ts b/app/composables/useFragments.ts index d02f962..662cd35 100644 --- a/app/composables/useFragments.ts +++ b/app/composables/useFragments.ts @@ -4,9 +4,37 @@ export function useFragmentsApi() { const { needLogin } = useAuthState(); const fragments = ref([]); const loading = ref(false); + const saving = ref(false); const error = ref(""); + /** Group whose fragments are shown; responses for any other group are dropped. */ + const shownGroupId = ref(null); + /** Group whose fragments were last loaded (or saved) successfully. */ + const loadedGroupId = ref(null); + // Bumped by every load/save, so only the latest request may land. + let request = 0; + + /** + * Whether a write may start for `groupId`: the shown list is that group's + * real fragments and nothing is loading or saving. Saving replaces a group's + * whole fragment list, so each write must build on the previous one. + */ + function readyFor(groupId: string): boolean { + return ( + shownGroupId.value === groupId && + loadedGroupId.value === groupId && + !error.value && + !loading.value && + !saving.value + ); + } async function load(groupId: string): Promise { + const mine = ++request; + if (shownGroupId.value !== groupId) { + fragments.value = []; + loadedGroupId.value = null; + } + shownGroupId.value = groupId; loading.value = true; error.value = ""; needLogin.value = false; @@ -14,21 +42,34 @@ export function useFragmentsApi() { const data = await apiFetch<{ fragments?: NamedFragment[] }>( `/admin/api/groups/${encodeURIComponent(groupId)}/fragments`, ); + if (mine !== request) return; fragments.value = data.fragments ?? []; + loadedGroupId.value = groupId; } catch (err) { - if (!needLogin.value) error.value = err instanceof Error ? err.message : String(err); + if (mine === request && !needLogin.value) + error.value = err instanceof Error ? err.message : String(err); } finally { - loading.value = false; + if (mine === request) loading.value = false; } } async function save(groupId: string, next: NamedFragment[]): Promise { - await apiFetch(`/admin/api/groups/${encodeURIComponent(groupId)}/fragments`, { - method: "PUT", - body: JSON.stringify({ fragments: next }), - }); + saving.value = true; + try { + await apiFetch(`/admin/api/groups/${encodeURIComponent(groupId)}/fragments`, { + method: "PUT", + body: JSON.stringify({ fragments: next }), + }); + } finally { + saving.value = false; + } + if (shownGroupId.value !== groupId) return; + request++; + loading.value = false; + error.value = ""; fragments.value = next; + loadedGroupId.value = groupId; } - return { fragments, loading, needLogin, error, load, save }; + return { fragments, loading, needLogin, error, readyFor, load, save }; } diff --git a/app/composables/useI18n.ts b/app/composables/useI18n.ts index 200d1ce..675d92e 100644 --- a/app/composables/useI18n.ts +++ b/app/composables/useI18n.ts @@ -294,6 +294,7 @@ const en: Dict = { "routeEditor.fragmentsSave": "Save as fragment", "routeEditor.fragmentsNamePlaceholder": "Fragment name", "routeEditor.fragmentsNameRequired": "Fragment name is required", + "routeEditor.fragmentsNotReady": "The group's fragments are still loading; try again in a moment", "routeEditor.errPath": "Field filters need a path", "routeEditor.errValues": "Add at least one value", "routeEditor.errGroupEmpty": "Group needs at least one condition", @@ -735,6 +736,7 @@ const zh: Dict = { "routeEditor.fragmentsSave": "存为片段", "routeEditor.fragmentsNamePlaceholder": "片段名称", "routeEditor.fragmentsNameRequired": "请填写片段名称", + "routeEditor.fragmentsNotReady": "分组的片段仍在加载,请稍后再试", "routeEditor.errPath": "字段过滤需要路径", "routeEditor.errValues": "至少需要一个值", "routeEditor.errGroupEmpty": "分组至少需要一个条件",