From 02c1759044fbc906914dfdaf63d26ed94aaadf0c Mon Sep 17 00:00:00 2001 From: wizardchen Date: Mon, 7 Sep 2026 15:12:04 +0800 Subject: [PATCH] fix(knowledge): confirm document deletion before reporting success --- frontend/src/hooks/useKnowledgeBase.ts | 34 ------ frontend/src/i18n/locales/en-US.ts | 4 + frontend/src/i18n/locales/ko-KR.ts | 4 + frontend/src/i18n/locales/ru-RU.ts | 4 + frontend/src/i18n/locales/zh-CN.ts | 4 + frontend/src/utils/knowledgeDeletion.test.ts | 103 +++++++++++++++++ frontend/src/utils/knowledgeDeletion.ts | 55 +++++++++ .../src/views/knowledge/KnowledgeBase.vue | 109 ++++++++++++------ .../repository/knowledge_list_filter_test.go | 32 +++++ 9 files changed, 278 insertions(+), 71 deletions(-) create mode 100644 frontend/src/utils/knowledgeDeletion.test.ts create mode 100644 frontend/src/utils/knowledgeDeletion.ts diff --git a/frontend/src/hooks/useKnowledgeBase.ts b/frontend/src/hooks/useKnowledgeBase.ts index 1e379917..ec5dba67 100644 --- a/frontend/src/hooks/useKnowledgeBase.ts +++ b/frontend/src/hooks/useKnowledgeBase.ts @@ -6,7 +6,6 @@ import { uploadKnowledgeFile, listKnowledgeFiles, getKnowledgeDetails, - delKnowledgeDetails, getKnowledgeDetailsCon, } from "@/api/knowledge-base/index"; import { knowledgeStore } from "@/stores/knowledge"; @@ -96,38 +95,6 @@ export default function (knowledgeBaseId?: string) { }) .catch(() => {}); }; - const delKnowledge = (index: number, item: any, onSuccess?: () => void) => { - cardList.value[index].isMore = false; - moreIndex.value = -1; - return delKnowledgeDetails(item.id) - .then(async (result: any) => { - if (result.success) { - MessagePlugin.info(t('knowledgeBase.deleteSuccess')); - if (onSuccess) { - onSuccess(); - } else { - // 后端已将单条删除放入异步队列,立即拉列表仍可能包含待删项; - // 短轮询直到列表与后端一致或超时。 - const maxPolls = 30; - const delayMs = 400; - for (let i = 0; i < maxPolls; i++) { - await getKnowled(); - const stillPresent = (cardList.value || []).some((c: any) => c.id === item.id); - if (!stillPresent) break; - await new Promise((r) => setTimeout(r, delayMs)); - } - } - return true; - } else { - MessagePlugin.error(t('knowledgeBase.deleteFailed')); - return false; - } - }) - .catch(() => { - MessagePlugin.error(t('knowledgeBase.deleteFailed')); - return false; - }); - }; const openMore = (index: number) => { moreIndex.value = index; }; @@ -261,7 +228,6 @@ export default function (knowledgeBaseId?: string) { moreIndex, getKnowled, details, - delKnowledge, openMore, onVisibleChange, requestMethod, diff --git a/frontend/src/i18n/locales/en-US.ts b/frontend/src/i18n/locales/en-US.ts index ef6c89fb..6aea42d6 100755 --- a/frontend/src/i18n/locales/en-US.ts +++ b/frontend/src/i18n/locales/en-US.ts @@ -593,6 +593,10 @@ export default { clearSelection: 'Deselect all', batchDelete: 'Delete selected', confirmBatchDeleteDocument: 'Delete {count} selected documents? This action cannot be undone.', + deleteSubmitted: 'Delete request submitted. Waiting for completion.', + deletePending: 'Deletion is still pending. Refresh later to check the result.', + deleteTaskFailed: 'Deletion failed. Check the document error details and try again.', + deleteStatusUnavailable: 'Could not confirm the deletion result. Refresh later to check the document status.', batchDeleteSuccess: 'Deleted {count} documents', batchDeleteFailed: 'Batch delete failed', batchTag: 'Batch Tag', diff --git a/frontend/src/i18n/locales/ko-KR.ts b/frontend/src/i18n/locales/ko-KR.ts index 9f1b1091..892888e5 100755 --- a/frontend/src/i18n/locales/ko-KR.ts +++ b/frontend/src/i18n/locales/ko-KR.ts @@ -6396,6 +6396,10 @@ export default { clearSelection: '선택 해제', batchDelete: '선택 삭제', confirmBatchDeleteDocument: '선택한 {count}개 문서를 삭제하시겠습니까? 삭제 후 복구할 수 없습니다.', + deleteSubmitted: '삭제 요청이 제출되었습니다. 완료를 기다리는 중입니다.', + deletePending: '삭제가 아직 완료되지 않았습니다. 잠시 후 새로고침하여 결과를 확인하세요.', + deleteTaskFailed: '삭제에 실패했습니다. 문서의 오류 세부 정보를 확인한 후 다시 시도하세요.', + deleteStatusUnavailable: '삭제 결과를 확인할 수 없습니다. 잠시 후 새로고침하여 문서 상태를 확인하세요.', batchDeleteSuccess: '{count}개 문서가 삭제되었습니다', batchDeleteFailed: '일괄 삭제 실패', batchTag: '일괄 태그', diff --git a/frontend/src/i18n/locales/ru-RU.ts b/frontend/src/i18n/locales/ru-RU.ts index 4f96f893..286ccb52 100755 --- a/frontend/src/i18n/locales/ru-RU.ts +++ b/frontend/src/i18n/locales/ru-RU.ts @@ -6396,6 +6396,10 @@ export default { clearSelection: 'Снять выделение', batchDelete: 'Удалить выбранные', confirmBatchDeleteDocument: 'Удалить {count} выбранных документов? Это действие нельзя отменить.', + deleteSubmitted: 'Запрос на удаление отправлен. Ожидание завершения.', + deletePending: 'Удаление ещё не завершено. Обновите страницу позже, чтобы проверить результат.', + deleteTaskFailed: 'Не удалось удалить документы. Проверьте сведения об ошибке и повторите попытку.', + deleteStatusUnavailable: 'Не удалось подтвердить результат удаления. Обновите страницу позже, чтобы проверить состояние документов.', batchDeleteSuccess: 'Удалено документов: {count}', batchDeleteFailed: 'Ошибка пакетного удаления', batchTag: 'Пакетная метка', diff --git a/frontend/src/i18n/locales/zh-CN.ts b/frontend/src/i18n/locales/zh-CN.ts index ea656b08..5e10e795 100755 --- a/frontend/src/i18n/locales/zh-CN.ts +++ b/frontend/src/i18n/locales/zh-CN.ts @@ -6398,6 +6398,10 @@ export default { clearSelection: '取消选择', batchDelete: '批量删除', confirmBatchDeleteDocument: '确认删除选中的 {count} 个文档?删除后将无法恢复。', + deleteSubmitted: '删除任务已提交,正在等待完成。', + deletePending: '删除尚未完成,请稍后刷新查看结果。', + deleteTaskFailed: '删除任务失败,请查看文档错误详情后重试。', + deleteStatusUnavailable: '暂时无法确认删除结果,请稍后刷新查看文档状态。', batchDeleteSuccess: '成功删除 {count} 个文档', batchDeleteFailed: '批量删除失败', batchTag: '批量打标签', diff --git a/frontend/src/utils/knowledgeDeletion.test.ts b/frontend/src/utils/knowledgeDeletion.test.ts new file mode 100644 index 00000000..e37d6d80 --- /dev/null +++ b/frontend/src/utils/knowledgeDeletion.test.ts @@ -0,0 +1,103 @@ +import assert from 'node:assert/strict'; +import test from 'node:test'; +import { waitForKnowledgeDeletion } from './knowledgeDeletion.ts'; + +const noDelay = async () => {}; +const row = (id: string, parse_status: string) => ({ id, parse_status }); + +test('waits through queued and hidden deleting rows until every requested ID is gone', async () => { + const snapshots = [ + [row('a', 'completed'), row('b', 'completed')], + [row('a', 'deleting'), row('b', 'deleting')], + [row('b', 'deleting')], + [], + ]; + let calls = 0; + const result = await waitForKnowledgeDeletion(['a', 'b'], async () => ({ + success: true, data: snapshots[calls++], + }), { delay: noDelay }); + assert.equal(result, 'completed'); + assert.equal(calls, 4); +}); + +test('accepts the empty Go slice encoded as null', async () => { + assert.equal(await waitForKnowledgeDeletion(['a'], async () => ({ success: true, data: null })), 'completed'); +}); + +test('does not mistake polling timeout for successful deletion', async () => { + let calls = 0; + assert.equal(await waitForKnowledgeDeletion(['a'], async () => { + calls++; + return { success: true, data: [row('a', 'deleting')] }; + }, { attempts: 3, delay: noDelay }), 'pending'); + assert.equal(calls, 3); +}); + +test('reports a delete that exhausts retries and becomes visible again', async () => { + const snapshots = [[row('a', 'deleting')], [row('a', 'failed')]]; + assert.equal(await waitForKnowledgeDeletion(['a'], async () => ({ + success: true, data: snapshots.shift(), + }), { delay: noDelay }), 'failed'); +}); + +test('does not treat a previous parse or delete failure as failure of the newly queued request', async () => { + const snapshots = [[row('a', 'failed')], [row('a', 'deleting')], []]; + assert.equal(await waitForKnowledgeDeletion(['a'], async () => ({ + success: true, data: snapshots.shift(), + }), { delay: noDelay }), 'completed'); +}); + +test('checks requested IDs even when other documents are returned', async () => { + assert.equal(await waitForKnowledgeDeletion(['a'], async () => ({ + success: true, data: [row('unrelated', 'completed')], + })), 'completed'); +}); + +test('missing or unsuccessful responses cannot confirm deletion', async () => { + for (const response of [{ success: true }, { success: false, data: [] }, { data: [] }]) { + await assert.rejects(waitForKnowledgeDeletion(['a'], async () => response), /Invalid/); + } +}); + +test('query failures propagate instead of being interpreted as missing files', async () => { + await assert.rejects(waitForKnowledgeDeletion(['a'], async () => { + throw new Error('network unavailable'); + }), /network unavailable/); +}); + +test('navigation during an in-flight query suppresses completion', async () => { + let active = true; + assert.equal(await waitForKnowledgeDeletion(['a'], async () => { + active = false; + return { success: true, data: [] }; + }, { isActive: () => active }), 'cancelled'); +}); + +test('navigation during a polling delay stops further queries', async () => { + let active = true; + let calls = 0; + assert.equal(await waitForKnowledgeDeletion(['a'], async () => { + calls++; + return { success: true, data: [row('a', 'deleting')] }; + }, { isActive: () => active, delay: async () => { active = false; } }), 'cancelled'); + assert.equal(calls, 1); +}); + +test('checks all 200 IDs in bounded queries before deciding deletion is complete', async () => { + const ids = Array.from({ length: 200 }, (_, i) => `document-${i}`); + const queried: string[][] = []; + assert.equal(await waitForKnowledgeDeletion(ids, async (batch) => { + queried.push(batch); + return { success: true, data: batch.includes(ids[199]) ? [row(ids[199], 'deleting')] : [] }; + }, { attempts: 1 }), 'pending'); + assert.deepEqual(queried.map(batch => batch.length), [50, 50, 50, 50]); + assert.deepEqual(queried.flat(), ids); +}); + +test('a later chunk query failure cannot report a partially checked batch as deleted', async () => { + const ids = Array.from({ length: 51 }, (_, i) => `document-${i}`); + await assert.rejects(waitForKnowledgeDeletion(ids, async (batch) => { + if (batch.includes(ids[50])) throw new Error('query failed'); + return { success: true, data: [] }; + }), /query failed/); +}); diff --git a/frontend/src/utils/knowledgeDeletion.ts b/frontend/src/utils/knowledgeDeletion.ts new file mode 100644 index 00000000..a3ef5539 --- /dev/null +++ b/frontend/src/utils/knowledgeDeletion.ts @@ -0,0 +1,55 @@ +interface KnowledgeDeletionRow { + id: string; + parse_status?: string; +} + +interface KnowledgeDeletionResponse { + success?: boolean; + data?: KnowledgeDeletionRow[] | null; +} + +type DeletionResult = 'completed' | 'pending' | 'failed' | 'cancelled'; + +/** Query exact IDs, including deleting rows, instead of the filtered document list. */ +export async function waitForKnowledgeDeletion( + ids: string[], + fetchRows: (ids: string[]) => Promise, + options: { + isActive?: () => boolean; + attempts?: number; + delay?: () => Promise; + } = {}, +): Promise { + const isActive = options.isActive ?? (() => true); + const delay = options.delay ?? (() => new Promise(resolve => setTimeout(resolve, 1000))); + const requested = new Set(ids); + const deleting = new Set(); + const attempts = options.attempts ?? 30; + for (let i = 0; i < attempts; i++) { + if (!isActive()) return 'cancelled'; + const rows: KnowledgeDeletionRow[] = []; + // A supported 200-document delete exceeds common proxy request-line + // limits if all UUIDs are put into a single GET query string. + for (let start = 0; start < ids.length; start += 50) { + if (!isActive()) return 'cancelled'; + const response = await fetchRows(ids.slice(start, start + 50)); + if (!isActive()) return 'cancelled'; + // A missing/invalid payload is not evidence of deletion. The Go batch + // endpoint can encode an empty slice as either [] or null. + if (response.success !== true || (response.data !== null && !Array.isArray(response.data))) { + throw new Error('Invalid knowledge deletion status response'); + } + rows.push(...(response.data ?? [])); + } + const remaining = rows.filter(row => requested.has(row.id)); + if (remaining.length === 0) return 'completed'; + for (const row of remaining) { + if (row.parse_status === 'deleting') deleting.add(row.id); + // A document may already have a failed parse/delete before this request + // starts. Only a failure after observing deletion belongs to this run. + if (deleting.has(row.id) && row.parse_status === 'failed') return 'failed'; + } + if (i + 1 < attempts) await delay(); + } + return isActive() ? 'pending' : 'cancelled'; +} diff --git a/frontend/src/views/knowledge/KnowledgeBase.vue b/frontend/src/views/knowledge/KnowledgeBase.vue index dfa0e411..86eda162 100644 --- a/frontend/src/views/knowledge/KnowledgeBase.vue +++ b/frontend/src/views/knowledge/KnowledgeBase.vue @@ -32,6 +32,7 @@ import { reparseKnowledge, cancelKnowledgeParse, batchDeleteKnowledge, + delKnowledgeDetails, batchReparseKnowledge, getKnowledgeSpans, getKnowledgeDetails, @@ -41,6 +42,7 @@ import { downKnowledgeDetails, type KnowledgeFolderTree, } from "@/api/knowledge-base/index"; +import { waitForKnowledgeDeletion } from '@/utils/knowledgeDeletion'; import { knowledgeSpansPayloadHasTrace } from '@/utils/knowledgeTrace'; import FAQEntryManager from './components/FAQEntryManager.vue'; import DocumentListView from './components/DocumentListView.vue'; @@ -332,7 +334,7 @@ const canDownloadKnowledge = computed(() => { }); const knowledgeList = ref>([]); -let { cardList, total, moreIndex, details, getKnowled, delKnowledge, openMore, onVisibleChange: _onVisibleChange, getCardDetails, getfDetails } = useKnowledgeBase(kbId.value) +let { cardList, total, moreIndex, details, getKnowled, openMore, onVisibleChange: _onVisibleChange, getCardDetails, getfDetails } = useKnowledgeBase(kbId.value) const showKbDetailContextualGuide = computed(() => { return Boolean(kbId.value) @@ -1440,20 +1442,7 @@ const closeCardMoreMenu = (index: number) => { const confirmDeleteKnowledge = (index: number, item: KnowledgeCard) => { closeCardMoreMenu(index); - const deletedId = item?.id; - delKnowledge(index, item, async () => { - resetPage(); - const maxPolls = 30; - const delayMs = 400; - for (let i = 0; i < maxPolls; i++) { - await loadKnowledgeFiles(kbId.value); - const stillPresent = (cardList.value || []).some((c: KnowledgeCard) => c.id === deletedId); - if (!stillPresent) break; - await new Promise((r) => setTimeout(r, delayMs)); - } - loadTags(kbId.value, true); - void loadFolderTree(kbId.value); - }); + void deleteKnowledgeDocuments([item.id], () => delKnowledgeDetails(item.id), false); }; const onReparseMenuClick = (index: number, item: KnowledgeCard) => { @@ -2093,39 +2082,85 @@ const openKnowledgeItem = (item: KnowledgeCard) => { openCardDetails(item); }; -const confirmBatchDelete = async () => { - if (batchDeleting.value || batchReparsing.value || selectedIds.value.size === 0) return; - const ids = Array.from(selectedIds.value); - const deletedIdSet = new Set(ids); +// Stop observing a previous KB when navigating, including away and back. +let deleteGeneration = 0; +watch(kbId, () => { + deleteGeneration++; + batchDeleting.value = false; +}); +onUnmounted(() => { deleteGeneration++; }); + +const deleteKnowledgeDocuments = async ( + ids: string[], + submit: () => Promise, + batch: boolean, +) => { + if (batchDeleting.value || batchReparsing.value || ids.length === 0) return; + const targetKbId = kbId.value; + const generation = ++deleteGeneration; + const isActive = () => generation === deleteGeneration && isCurrentKb(targetKbId); batchDeleting.value = true; + let submitted = false; try { - const res: any = await batchDeleteKnowledge(kbId.value, ids); - if (res?.success) { - MessagePlugin.success(t('knowledgeBase.batchDeleteSuccess', { count: ids.length })); + const res = await submit(); + if (!isActive()) return; + if (!res?.success) { + MessagePlugin.error(res?.message || t('knowledgeBase.batchDeleteFailed')); + return; + } + submitted = true; + MessagePlugin.info(t('knowledgeBase.deleteSubmitted')); + if (batch) { clearSelection(); batchMode.value = false; - resetPage(); - // 后端将批量删除放入异步队列,立刻拉列表仍可能包含待删项;短轮询直到列表与后端一致或超时 - const maxPolls = 30; - const delayMs = 400; - for (let i = 0; i < maxPolls; i++) { - await loadKnowledgeFiles(kbId.value); - const stillPresent = (cardList.value || []).some((c: KnowledgeCard) => deletedIdSet.has(c.id)); - if (!stillPresent) break; - await new Promise((r) => setTimeout(r, delayMs)); - } - loadTags(kbId.value, true); - void loadFolderTree(kbId.value); + } + const result = await waitForKnowledgeDeletion( + ids, + async (queryIds) => { + const query = new URLSearchParams(); + queryIds.forEach(id => query.append('ids', id)); + return await batchQueryKnowledge(query.toString(), targetKbId) as any; + }, + { isActive }, + ); + if (!isActive() || result === 'cancelled') return; + if (result === 'completed') { + MessagePlugin.success(batch + ? t('knowledgeBase.batchDeleteSuccess', { count: ids.length }) + : t('knowledgeBase.deleteSuccess')); + } else if (result === 'failed') { + MessagePlugin.error(t('knowledgeBase.deleteTaskFailed')); } else { - MessagePlugin.error(res?.message || t('knowledgeBase.batchDeleteFailed')); + MessagePlugin.info(t('knowledgeBase.deletePending')); } } catch (e: any) { - MessagePlugin.error(e?.message || t('knowledgeBase.batchDeleteFailed')); + if (!isActive()) return; + if (submitted) { + MessagePlugin.warning(t('knowledgeBase.deleteStatusUnavailable')); + } else { + MessagePlugin.error(e?.message || t('knowledgeBase.batchDeleteFailed')); + } } finally { - batchDeleting.value = false; + if (isActive()) { + batchDeleting.value = false; + if (submitted) { + resetPage(); + await loadKnowledgeFiles(targetKbId); + if (isActive()) { + void loadTags(targetKbId, true); + void loadFolderTree(targetKbId); + } + } + } } }; +const confirmBatchDelete = () => { + const targetKbId = kbId.value; + const ids = Array.from(selectedIds.value); + return deleteKnowledgeDocuments(ids, () => batchDeleteKnowledge(targetKbId, ids), true); +}; + const handleBatchTag = () => { if (batchDeleting.value || batchReparsing.value || batchTagging.value || selectedIds.value.size === 0) return; batchTagDialogVisible.value = true; diff --git a/internal/application/repository/knowledge_list_filter_test.go b/internal/application/repository/knowledge_list_filter_test.go index ad970c47..a3283622 100644 --- a/internal/application/repository/knowledge_list_filter_test.go +++ b/internal/application/repository/knowledge_list_filter_test.go @@ -67,3 +67,35 @@ func TestListPaged_ExcludesDeletingByDefault(t *testing.T) { assert.Equal(t, deletingID, rows[0].ID) assert.Equal(t, int64(1), total) } + +// The deletion UI must use the exact-ID batch endpoint: a row missing from +// the default list may only be hidden while cleanup is still in progress. +func TestGetKnowledgeBatch_TracksDeletionUntilSoftDelete(t *testing.T) { + db := setupKnowledgeTestDB(t) + repo := NewKnowledgeRepository(db).(*knowledgeRepository) + ctx := context.Background() + kbID := uuid.New().String() + id := insertKnowledgeInKB(t, db, 1, kbID, types.ParseStatusDeleting) + otherTenantID := insertKnowledgeInKB(t, db, 2, kbID, types.ParseStatusDeleting) + + rows, err := repo.GetKnowledgeBatch(ctx, 1, []string{id, otherTenantID}) + require.NoError(t, err) + require.Len(t, rows, 1) + assert.Equal(t, id, rows[0].ID) + assert.Equal(t, types.ParseStatusDeleting, rows[0].ParseStatus) + + updated, err := repo.UpdateActiveDeletingKnowledgeColumns(ctx, id, map[string]interface{}{ + "parse_status": types.ParseStatusFailed, + }) + require.NoError(t, err) + require.True(t, updated) + rows, err = repo.GetKnowledgeBatch(ctx, 1, []string{id}) + require.NoError(t, err) + require.Len(t, rows, 1) + assert.Equal(t, types.ParseStatusFailed, rows[0].ParseStatus) + + require.NoError(t, repo.DeleteKnowledgeList(ctx, 1, []string{id})) + rows, err = repo.GetKnowledgeBatch(ctx, 1, []string{id}) + require.NoError(t, err) + assert.Empty(t, rows) +}