From 9d67a0eb4d8375e32cd7b936f479cfc09d2394db Mon Sep 17 00:00:00 2001 From: chenrui <792608290@qq.com> Date: Mon, 14 Sep 2026 21:02:31 +0800 Subject: [PATCH] fix: clean up wiki data when deleting knowledge base (#3109) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix: clean up wiki data when deleting knowledge base ProcessKBDelete async task cleaned up vector indices, chunks, files, graph data and knowledge rows, but left wiki data untouched because knowledgeBaseService had no wiki repository dependency. Add four KB-scoped delete methods to WikiPageRepository and invoke them at the end of ProcessKBDelete: soft-delete wiki_pages/wiki_folders/ wiki_page_issues (they carry DeletedAt), hard-delete wiki_page_revisions (no DeletedAt column — immutable snapshots). * fix: scope wiki KB cleanup by tenant and run it on every delete path Wiki rows do not depend on the vector engine, so ProcessKBDelete now cleans them in a defer (including SkipRetry). Deletes are keyed by tenant_id plus knowledge_base_id so a tampered queue payload cannot wipe another tenant's wiki. --------- Co-authored-by: wizardchen --- internal/application/repository/wiki_page.go | 51 ++++ .../application/repository/wiki_page_test.go | 117 ++++++++ internal/application/service/knowledgebase.go | 65 ++++- .../knowledgebase_wiki_cleanup_test.go | 256 ++++++++++++++++++ internal/types/interfaces/wiki_page.go | 25 ++ 5 files changed, 509 insertions(+), 5 deletions(-) create mode 100644 internal/application/service/knowledgebase_wiki_cleanup_test.go diff --git a/internal/application/repository/wiki_page.go b/internal/application/repository/wiki_page.go index 2e3eedb4..50212603 100644 --- a/internal/application/repository/wiki_page.go +++ b/internal/application/repository/wiki_page.go @@ -1252,6 +1252,57 @@ func (r *wikiPageRepository) DeleteByID(ctx context.Context, id string) error { return nil } +// deleteByTenantAndKnowledgeBase deletes model rows for one tenant+KB. +// The empty-kbID guard prevents a missing predicate from matching every row. +func (r *wikiPageRepository) deleteByTenantAndKnowledgeBase( + ctx context.Context, tenantID uint64, kbID string, model any, +) error { + if kbID == "" { + return nil + } + return r.db.WithContext(ctx). + Where("tenant_id = ? AND knowledge_base_id = ?", tenantID, kbID). + Delete(model).Error +} + +// DeleteByKnowledgeBaseID soft-deletes all wiki pages in a knowledge base. +// GORM's Delete on a model with DeletedAt sets deleted_at and subsequent +// queries auto-filter deleted_at IS NULL, so this is a one-shot UPDATE. +func (r *wikiPageRepository) DeleteByKnowledgeBaseID( + ctx context.Context, tenantID uint64, kbID string, +) error { + return r.deleteByTenantAndKnowledgeBase(ctx, tenantID, kbID, &types.WikiPage{}) +} + +// DeleteFoldersByKnowledgeBaseID soft-deletes all wiki folders in a knowledge +// base, bypassing the emptiness guard that DeleteFolder enforces. The whole +// KB is being torn down, so non-empty folders must go. +func (r *wikiPageRepository) DeleteFoldersByKnowledgeBaseID( + ctx context.Context, tenantID uint64, kbID string, +) error { + return r.deleteByTenantAndKnowledgeBase(ctx, tenantID, kbID, &types.WikiFolder{}) +} + +// DeleteRevisionsByKnowledgeBaseID hard-deletes all wiki page revisions in a +// knowledge base. wiki_page_revisions has no deleted_at column — it stores +// immutable snapshots, not soft-deletable rows — so GORM's Delete falls back +// to a physical DELETE, same as DeleteRevisionsByPage but scoped to the KB +// via the indexed knowledge_base_id column. +func (r *wikiPageRepository) DeleteRevisionsByKnowledgeBaseID( + ctx context.Context, tenantID uint64, kbID string, +) error { + return r.deleteByTenantAndKnowledgeBase(ctx, tenantID, kbID, &types.WikiPageRevision{}) +} + +// DeleteIssuesByKnowledgeBaseID soft-deletes all wiki page issues in a +// knowledge base. Issues carry DeletedAt, so GORM sets deleted_at and +// subsequent queries auto-filter them out. +func (r *wikiPageRepository) DeleteIssuesByKnowledgeBaseID( + ctx context.Context, tenantID uint64, kbID string, +) error { + return r.deleteByTenantAndKnowledgeBase(ctx, tenantID, kbID, &types.WikiPageIssue{}) +} + // escapeLikePattern escapes LIKE / ILIKE metacharacters so the returned string // can be safely concatenated with % wildcards without unintended matches. // Order matters: escape the backslash first, then the wildcards. diff --git a/internal/application/repository/wiki_page_test.go b/internal/application/repository/wiki_page_test.go index 19bc8f62..f2150233 100644 --- a/internal/application/repository/wiki_page_test.go +++ b/internal/application/repository/wiki_page_test.go @@ -76,6 +76,24 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_wiki_page_revisions_page_version ON wiki_page_revisions (page_id, version); ` +// wikiPageIssuesTestDDL mirrors the production wiki_page_issues DDL for SQLite. +const wikiPageIssuesTestDDL = ` +CREATE TABLE IF NOT EXISTS wiki_page_issues ( + id VARCHAR(36) PRIMARY KEY, + tenant_id INTEGER NOT NULL, + knowledge_base_id VARCHAR(36) NOT NULL, + slug VARCHAR(255) NOT NULL, + issue_type VARCHAR(50) NOT NULL, + description TEXT NOT NULL, + suspected_knowledge_ids TEXT, + status VARCHAR(20) NOT NULL DEFAULT 'pending', + reported_by VARCHAR(100) NOT NULL, + created_at DATETIME DEFAULT CURRENT_TIMESTAMP, + updated_at DATETIME DEFAULT CURRENT_TIMESTAMP, + deleted_at DATETIME +); +` + // wikiFoldersTestDDL mirrors the production wiki_folders DDL for SQLite. const wikiFoldersTestDDL = ` CREATE TABLE IF NOT EXISTS wiki_folders ( @@ -99,6 +117,7 @@ func setupWikiPagesTestDB(t *testing.T) *gorm.DB { require.NoError(t, err) require.NoError(t, db.Exec(wikiPagesTestDDL).Error) require.NoError(t, db.Exec(wikiFoldersTestDDL).Error) + require.NoError(t, db.Exec(wikiPageIssuesTestDDL).Error) for _, stmt := range strings.Split(strings.TrimSpace(wikiPageRevisionsTestDDL), ";") { if strings.TrimSpace(stmt) == "" { continue @@ -641,3 +660,101 @@ func TestDeleteRevisionsByPageOnlyTouchesThatPage(t *testing.T) { require.NoError(t, repo.DeleteRevisionsByPage(ctx, "")) assert.Equal(t, int64(1), countWikiRevisions(t, db, bystander.ID)) } + +func TestDeleteByKnowledgeBaseIDScopesSoftAndHardDeletes(t *testing.T) { + db := setupWikiPagesTestDB(t) + repo := NewWikiPageRepository(db) + ctx := context.Background() + + victim := makeWikiPage("kb-victim", "concept/victim", types.WikiPageTypeConcept, types.WikiPageStatusPublished) + otherKB := makeWikiPage("kb-other", "concept/other", types.WikiPageTypeConcept, types.WikiPageStatusPublished) + otherTenant := makeWikiPage( + "kb-victim", "concept/other-tenant", types.WikiPageTypeConcept, types.WikiPageStatusPublished, + ) + otherTenant.TenantID = 2 + for _, p := range []*types.WikiPage{victim, otherKB, otherTenant} { + require.NoError(t, repo.Create(ctx, p)) + } + require.NoError(t, db.Create(makeWikiRevision(victim, 1, types.WikiEditSourceUser)).Error) + require.NoError(t, db.Create(makeWikiRevision(otherKB, 1, types.WikiEditSourceUser)).Error) + require.NoError(t, db.Create(makeWikiRevision(otherTenant, 1, types.WikiEditSourceUser)).Error) + + victimFolder := &types.WikiFolder{ + ID: "f-victim", TenantID: 1, KnowledgeBaseID: "kb-victim", + Name: "victim", Path: "victim", CreatedAt: time.Now(), UpdatedAt: time.Now(), + } + otherFolder := &types.WikiFolder{ + ID: "f-other", TenantID: 1, KnowledgeBaseID: "kb-other", + Name: "other", Path: "other", CreatedAt: time.Now(), UpdatedAt: time.Now(), + } + require.NoError(t, repo.CreateFolder(ctx, victimFolder)) + require.NoError(t, repo.CreateFolder(ctx, otherFolder)) + + victimIssue := &types.WikiPageIssue{ + ID: "i-victim", TenantID: 1, KnowledgeBaseID: "kb-victim", + Slug: victim.Slug, IssueType: "lint", Description: "victim", + ReportedBy: "test", CreatedAt: time.Now(), UpdatedAt: time.Now(), + } + otherIssue := &types.WikiPageIssue{ + ID: "i-other", TenantID: 1, KnowledgeBaseID: "kb-other", + Slug: otherKB.Slug, IssueType: "lint", Description: "other", + ReportedBy: "test", CreatedAt: time.Now(), UpdatedAt: time.Now(), + } + require.NoError(t, repo.CreateIssue(ctx, victimIssue)) + require.NoError(t, repo.CreateIssue(ctx, otherIssue)) + + // Empty kbID must not become a table-wide delete. + require.NoError(t, repo.DeleteByKnowledgeBaseID(ctx, 1, "")) + require.NoError(t, repo.DeleteFoldersByKnowledgeBaseID(ctx, 1, "")) + require.NoError(t, repo.DeleteRevisionsByKnowledgeBaseID(ctx, 1, "")) + require.NoError(t, repo.DeleteIssuesByKnowledgeBaseID(ctx, 1, "")) + _, err := repo.GetBySlug(ctx, "kb-victim", victim.Slug) + require.NoError(t, err) + + // Wrong tenant must not touch the victim tenant's rows. + require.NoError(t, repo.DeleteByKnowledgeBaseID(ctx, 99, "kb-victim")) + require.NoError(t, repo.DeleteFoldersByKnowledgeBaseID(ctx, 99, "kb-victim")) + require.NoError(t, repo.DeleteRevisionsByKnowledgeBaseID(ctx, 99, "kb-victim")) + require.NoError(t, repo.DeleteIssuesByKnowledgeBaseID(ctx, 99, "kb-victim")) + _, err = repo.GetBySlug(ctx, "kb-victim", victim.Slug) + require.NoError(t, err) + + require.NoError(t, repo.DeleteByKnowledgeBaseID(ctx, 1, "kb-victim")) + require.NoError(t, repo.DeleteFoldersByKnowledgeBaseID(ctx, 1, "kb-victim")) + require.NoError(t, repo.DeleteRevisionsByKnowledgeBaseID(ctx, 1, "kb-victim")) + require.NoError(t, repo.DeleteIssuesByKnowledgeBaseID(ctx, 1, "kb-victim")) + + _, err = repo.GetBySlug(ctx, "kb-victim", victim.Slug) + require.ErrorIs(t, err, ErrWikiPageNotFound) + _, err = repo.GetFolderByID(ctx, "kb-victim", "f-victim") + require.ErrorIs(t, err, ErrWikiFolderNotFound) + issues, err := repo.ListIssues(ctx, "kb-victim", "", "") + require.NoError(t, err) + assert.Empty(t, issues) + assert.Zero(t, countWikiRevisions(t, db, victim.ID)) + + // Soft-deleted rows remain when queried without the GORM deleted_at filter. + var pageCount, folderCount, issueCount int64 + require.NoError(t, db.Unscoped().Model(&types.WikiPage{}). + Where("id = ?", victim.ID).Count(&pageCount).Error) + require.NoError(t, db.Unscoped().Model(&types.WikiFolder{}). + Where("id = ?", "f-victim").Count(&folderCount).Error) + require.NoError(t, db.Unscoped().Model(&types.WikiPageIssue{}). + Where("id = ?", "i-victim").Count(&issueCount).Error) + assert.Equal(t, int64(1), pageCount) + assert.Equal(t, int64(1), folderCount) + assert.Equal(t, int64(1), issueCount) + + // Other KB and other tenant are untouched. + _, err = repo.GetBySlug(ctx, "kb-other", otherKB.Slug) + require.NoError(t, err) + _, err = repo.GetBySlug(ctx, "kb-victim", otherTenant.Slug) + require.NoError(t, err) + _, err = repo.GetFolderByID(ctx, "kb-other", "f-other") + require.NoError(t, err) + assert.Equal(t, int64(1), countWikiRevisions(t, db, otherKB.ID)) + assert.Equal(t, int64(1), countWikiRevisions(t, db, otherTenant.ID)) + otherIssues, err := repo.ListIssues(ctx, "kb-other", "", "") + require.NoError(t, err) + require.Len(t, otherIssues, 1) +} diff --git a/internal/application/service/knowledgebase.go b/internal/application/service/knowledgebase.go index 76189da6..18638d80 100644 --- a/internal/application/service/knowledgebase.go +++ b/internal/application/service/knowledgebase.go @@ -51,6 +51,7 @@ type knowledgeBaseService struct { dsScheduler *datasource.Scheduler audit interfaces.AuditLogService resourceCatalog interfaces.ResourceCatalog + wikiRepo interfaces.WikiPageRepository } // NewKnowledgeBaseService creates a new knowledge base service @@ -74,6 +75,7 @@ func NewKnowledgeBaseService(repo interfaces.KnowledgeBaseRepository, dsScheduler *datasource.Scheduler, audit interfaces.AuditLogService, resourceCatalog interfaces.ResourceCatalog, + wikiRepo interfaces.WikiPageRepository, ) interfaces.KnowledgeBaseService { return &knowledgeBaseService{ repo: repo, @@ -96,6 +98,7 @@ func NewKnowledgeBaseService(repo interfaces.KnowledgeBaseRepository, dsScheduler: dsScheduler, audit: audit, resourceCatalog: resourceCatalog, + wikiRepo: wikiRepo, } } @@ -808,11 +811,11 @@ func (s *knowledgeBaseService) DeleteKnowledgeBase(ctx context.Context, id strin // ProcessKBDelete handles async knowledge base deletion task // This method performs heavy cleanup operations: deleting embeddings, chunks, files, and graph data -func (s *knowledgeBaseService) ProcessKBDelete(ctx context.Context, t *asynq.Task) error { +func (s *knowledgeBaseService) ProcessKBDelete(ctx context.Context, t *asynq.Task) (err error) { var payload types.KBDeletePayload - if err := json.Unmarshal(t.Payload(), &payload); err != nil { - logger.Errorf(ctx, "Failed to unmarshal KB delete payload: %v", err) - return err + if unmarshalErr := json.Unmarshal(t.Payload(), &payload); unmarshalErr != nil { + logger.Errorf(ctx, "Failed to unmarshal KB delete payload: %v", unmarshalErr) + return unmarshalErr } tenantID := payload.TenantID @@ -822,6 +825,24 @@ func (s *knowledgeBaseService) ProcessKBDelete(ctx context.Context, t *asynq.Tas // Set tenant context for downstream services ctx = context.WithValue(ctx, types.TenantIDContextKey, tenantID) defer func() { + // Wiki rows are independent of the vector engine. Run this on every + // return path — including SkipRetry — with its own timeout so a slow + // Redis queue scan cannot starve the SQL deletes. + wikiCtx, cancelWiki := context.WithTimeout(context.WithoutCancel(ctx), kbTaskCleanupTimeout) + wikiErr := s.cleanupWikiForKnowledgeBase(wikiCtx, tenantID, kbID) + cancelWiki() + if wikiErr != nil { + logger.Warnf(ctx, "Failed to clean wiki data for KB %s: %v", kbID, wikiErr) + // SkipRetry would otherwise drop the task while wiki orphans + // remain. Promote the wiki error so asynq retries; a later + // attempt that succeeds at wiki cleanup can still SkipRetry. + if err == nil || errors.Is(err, asynq.SkipRetry) { + err = wikiErr + } + } else if err == nil { + logger.Infof(ctx, "KB delete task completed successfully, knowledge base ID: %s", kbID) + } + // Workers may enqueue downstream work while the delete task performs // heavy storage cleanup. A detached, bounded final scrub runs on every // return path, including retryable failures and cancellation. @@ -969,10 +990,44 @@ func (s *knowledgeBaseService) ProcessKBDelete(ctx context.Context, t *asynq.Tas } } - logger.Infof(ctx, "KB delete task completed successfully, knowledge base ID: %s", kbID) + logger.Infof(ctx, "KB resource cleanup finished, knowledge base ID: %s", kbID) return nil } +// cleanupWikiForKnowledgeBase removes wiki pages, folders, revisions, and +// issues for a deleted knowledge base. Pages, folders, and issues are +// soft-deleted (they carry DeletedAt); revisions are hard-deleted (no +// deleted_at column — they are immutable snapshots). +// +// nil-safe for tests that construct knowledgeBaseService without wikiRepo. +// Failures are returned so the KB delete task can retry; the caller logs. +func (s *knowledgeBaseService) cleanupWikiForKnowledgeBase( + ctx context.Context, tenantID uint64, kbID string, +) error { + if s.wikiRepo == nil || kbID == "" { + return nil + } + logger.Infof(ctx, "Cleaning up wiki data for knowledge base") + var errs error + if err := s.wikiRepo.DeleteByKnowledgeBaseID(ctx, tenantID, kbID); err != nil { + logger.Warnf(ctx, "Failed to delete wiki pages for KB %s: %v", kbID, err) + errs = errors.Join(errs, err) + } + if err := s.wikiRepo.DeleteFoldersByKnowledgeBaseID(ctx, tenantID, kbID); err != nil { + logger.Warnf(ctx, "Failed to delete wiki folders for KB %s: %v", kbID, err) + errs = errors.Join(errs, err) + } + if err := s.wikiRepo.DeleteRevisionsByKnowledgeBaseID(ctx, tenantID, kbID); err != nil { + logger.Warnf(ctx, "Failed to delete wiki revisions for KB %s: %v", kbID, err) + errs = errors.Join(errs, err) + } + if err := s.wikiRepo.DeleteIssuesByKnowledgeBaseID(ctx, tenantID, kbID); err != nil { + logger.Warnf(ctx, "Failed to delete wiki issues for KB %s: %v", kbID, err) + errs = errors.Join(errs, err) + } + return errs +} + // cancelTasksForKnowledgeBase removes queue work for a deleted KB when the // configured task backend supports knowledge-base-wide inspection. Queue // cleanup is an optimization: the soft-deleted database row remains the diff --git a/internal/application/service/knowledgebase_wiki_cleanup_test.go b/internal/application/service/knowledgebase_wiki_cleanup_test.go new file mode 100644 index 00000000..75c4636e --- /dev/null +++ b/internal/application/service/knowledgebase_wiki_cleanup_test.go @@ -0,0 +1,256 @@ +package service + +import ( + "context" + "encoding/json" + "errors" + "testing" + + "github.com/Tencent/WeKnora/internal/application/service/retriever" + "github.com/Tencent/WeKnora/internal/types" + "github.com/Tencent/WeKnora/internal/types/interfaces" + "github.com/hibiken/asynq" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +type wikiKBDeleteCall struct { + tenantID uint64 + kbID string +} + +// recordingWikiRepo records calls to the four KB-scoped delete methods. +// Embedding interfaces.WikiPageRepository satisfies the interface; only the +// methods under test are overridden, the rest panic if accidentally invoked. +type recordingWikiRepo struct { + interfaces.WikiPageRepository + + pagesErr error + foldersErr error + revisionsErr error + issuesErr error + + pagesCalls []wikiKBDeleteCall + foldersCalls []wikiKBDeleteCall + revisionsCalls []wikiKBDeleteCall + issuesCalls []wikiKBDeleteCall +} + +func (r *recordingWikiRepo) DeleteByKnowledgeBaseID(_ context.Context, tenantID uint64, kbID string) error { + r.pagesCalls = append(r.pagesCalls, wikiKBDeleteCall{tenantID, kbID}) + return r.pagesErr +} + +func (r *recordingWikiRepo) DeleteFoldersByKnowledgeBaseID(_ context.Context, tenantID uint64, kbID string) error { + r.foldersCalls = append(r.foldersCalls, wikiKBDeleteCall{tenantID, kbID}) + return r.foldersErr +} + +func (r *recordingWikiRepo) DeleteRevisionsByKnowledgeBaseID(_ context.Context, tenantID uint64, kbID string) error { + r.revisionsCalls = append(r.revisionsCalls, wikiKBDeleteCall{tenantID, kbID}) + return r.revisionsErr +} + +func (r *recordingWikiRepo) DeleteIssuesByKnowledgeBaseID(_ context.Context, tenantID uint64, kbID string) error { + r.issuesCalls = append(r.issuesCalls, wikiKBDeleteCall{tenantID, kbID}) + return r.issuesErr +} + +func assertWikiCleanup(t *testing.T, wikiRepo *recordingWikiRepo, tenantID uint64, kbID string) { + t.Helper() + want := []wikiKBDeleteCall{{tenantID, kbID}} + assert.Equal(t, want, wikiRepo.pagesCalls) + assert.Equal(t, want, wikiRepo.foldersCalls) + assert.Equal(t, want, wikiRepo.revisionsCalls) + assert.Equal(t, want, wikiRepo.issuesCalls) +} + +// kbDeletePayload builds the asynq task payload used by ProcessKBDelete. +func kbDeletePayload(t *testing.T, kbID string, tenantID uint64) *asynq.Task { + t.Helper() + payload, err := json.Marshal(types.KBDeletePayload{TenantID: tenantID, KnowledgeBaseID: kbID}) + require.NoError(t, err) + return asynq.NewTask(types.TypeKBDelete, payload) +} + +// TestProcessKBDeleteCleansWikiData verifies the four wiki tables are cleaned +// up when ProcessKBDelete runs against a KB with documents. +func TestProcessKBDeleteCleansWikiData(t *testing.T) { + const kbID = "kb-with-docs" + const tenantID uint64 = 1 + wikiRepo := &recordingWikiRepo{} + svc := &knowledgeBaseService{ + kgRepo: populatedKBKnowledgeRepo{items: []*types.Knowledge{ + {ID: "k1", KnowledgeBaseID: kbID, EmbeddingModelID: "m1"}, + }}, + chunkRepo: kbCleanupChunkRepo{}, + modelService: kbCleanupModelService{}, + taskInspector: &recordingKBTaskInspector{}, + wikiRepo: wikiRepo, + } + + err := svc.ProcessKBDelete(context.Background(), kbDeletePayload(t, kbID, tenantID)) + + require.NoError(t, err) + assertWikiCleanup(t, wikiRepo, tenantID, kbID) +} + +// TestProcessKBDeleteWikiCleanupFailureRetries verifies a wiki cleanup +// failure fails the task so asynq retries, while still attempting every table. +func TestProcessKBDeleteWikiCleanupFailureRetries(t *testing.T) { + const kbID = "kb-wiki-fail" + const tenantID uint64 = 1 + wikiRepo := &recordingWikiRepo{ + pagesErr: errors.New("pages boom"), + foldersErr: errors.New("folders boom"), + revisionsErr: errors.New("revisions boom"), + issuesErr: errors.New("issues boom"), + } + svc := &knowledgeBaseService{ + kgRepo: populatedKBKnowledgeRepo{items: []*types.Knowledge{ + {ID: "k1", KnowledgeBaseID: kbID, EmbeddingModelID: "m1"}, + }}, + chunkRepo: kbCleanupChunkRepo{}, + modelService: kbCleanupModelService{}, + taskInspector: &recordingKBTaskInspector{}, + wikiRepo: wikiRepo, + } + + err := svc.ProcessKBDelete(context.Background(), kbDeletePayload(t, kbID, tenantID)) + + require.Error(t, err) + assert.ErrorContains(t, err, "pages boom") + assert.ErrorContains(t, err, "folders boom") + assert.ErrorContains(t, err, "revisions boom") + assert.ErrorContains(t, err, "issues boom") + assertWikiCleanup(t, wikiRepo, tenantID, kbID) +} + +// TestProcessKBDeleteWikiCleanupNilRepoSafe guards backward compatibility: +// tests (and any other callers) that construct knowledgeBaseService without +// wikiRepo must not panic on the cleanup path. +func TestProcessKBDeleteWikiCleanupNilRepoSafe(t *testing.T) { + svc := &knowledgeBaseService{ + kgRepo: populatedKBKnowledgeRepo{items: []*types.Knowledge{ + {ID: "k1", KnowledgeBaseID: "kb-nil", EmbeddingModelID: "m1"}, + }}, + chunkRepo: kbCleanupChunkRepo{}, + modelService: kbCleanupModelService{}, + taskInspector: &recordingKBTaskInspector{}, + // wikiRepo intentionally left nil + } + + err := svc.ProcessKBDelete(context.Background(), kbDeletePayload(t, "kb-nil", 1)) + + require.NoError(t, err) +} + +// TestProcessKBDeleteEmptyKBStillCleansWiki verifies wiki cleanup runs even +// when the KB has no knowledge entries. A KB can have wiki data without any +// documents (pure wiki KB, or documents already deleted individually). +func TestProcessKBDeleteEmptyKBStillCleansWiki(t *testing.T) { + const kbID = "kb-no-docs" + const tenantID uint64 = 1 + wikiRepo := &recordingWikiRepo{} + svc := &knowledgeBaseService{ + kgRepo: emptyKBKnowledgeRepo{}, + taskInspector: &recordingKBTaskInspector{}, + taskPendingRepo: &recordingKBPendingRepo{}, + wikiRepo: wikiRepo, + } + + err := svc.ProcessKBDelete(context.Background(), kbDeletePayload(t, kbID, tenantID)) + + require.NoError(t, err) + assertWikiCleanup(t, wikiRepo, tenantID, kbID) +} + +// TestProcessKBDeleteWikiCleanupIdempotent verifies calling the cleanup path +// twice doesn't error out. Each attempt still issues the four scoped deletes. +func TestProcessKBDeleteWikiCleanupIdempotent(t *testing.T) { + const kbID = "kb-idempotent" + const tenantID uint64 = 1 + wikiRepo := &recordingWikiRepo{} + svc := &knowledgeBaseService{ + kgRepo: emptyKBKnowledgeRepo{}, + taskInspector: &recordingKBTaskInspector{}, + taskPendingRepo: &recordingKBPendingRepo{}, + wikiRepo: wikiRepo, + } + task := kbDeletePayload(t, kbID, tenantID) + + require.NoError(t, svc.ProcessKBDelete(context.Background(), task)) + require.NoError(t, svc.ProcessKBDelete(context.Background(), task)) + + want := []wikiKBDeleteCall{{tenantID, kbID}, {tenantID, kbID}} + assert.Equal(t, want, wikiRepo.pagesCalls) + assert.Equal(t, want, wikiRepo.foldersCalls) + assert.Equal(t, want, wikiRepo.revisionsCalls) + assert.Equal(t, want, wikiRepo.issuesCalls) +} + +// TestProcessKBDeleteCleansWikiWhenVectorStoreForbidden verifies wiki cleanup +// still runs when engine resolution returns SkipRetry. Wiki rows do not +// depend on the vector store and must not be left behind. +func TestProcessKBDeleteCleansWikiWhenVectorStoreForbidden(t *testing.T) { + const kbID = "kb-skip" + const tenantID uint64 = 1 + const storeID = "00000000-0000-0000-0000-0000000000ff" + storeIDPtr := storeID + wikiRepo := &recordingWikiRepo{} + repo := &kbDeleteTrackingKnowledgeRepo{populatedKBKnowledgeRepo: populatedKBKnowledgeRepo{items: []*types.Knowledge{ + {ID: "k1", KnowledgeBaseID: kbID, EmbeddingModelID: "m1"}, + }}} + svc := &knowledgeBaseService{ + kgRepo: repo, + chunkRepo: kbCleanupChunkRepo{}, + modelService: kbCleanupModelService{}, + taskInspector: &recordingKBTaskInspector{}, + ownership: &kbDeleteOwnership{owned: map[string]uint64{}}, + wikiRepo: wikiRepo, + } + + payload, err := json.Marshal(types.KBDeletePayload{ + TenantID: tenantID, + KnowledgeBaseID: kbID, + VectorStoreID: &storeIDPtr, + }) + require.NoError(t, err) + + err = svc.ProcessKBDelete(context.Background(), asynq.NewTask(types.TypeKBDelete, payload)) + + require.ErrorIs(t, err, asynq.SkipRetry) + assert.Equal(t, 0, repo.deleteCalls) + assertWikiCleanup(t, wikiRepo, tenantID, kbID) +} + +func TestProcessKBDeleteCleansWikiWhenVectorStoreUnavailable(t *testing.T) { + const kbID = "kb-unavailable" + const tenantID uint64 = 1 + const storeID = "00000000-0000-0000-0000-0000000000aa" + storeIDPtr := storeID + wikiRepo := &recordingWikiRepo{} + svc := &knowledgeBaseService{ + kgRepo: populatedKBKnowledgeRepo{items: []*types.Knowledge{ + {ID: "k1", KnowledgeBaseID: kbID, EmbeddingModelID: "m1"}, + }}, + chunkRepo: kbCleanupChunkRepo{}, + modelService: kbCleanupModelService{}, + taskInspector: &recordingKBTaskInspector{}, + retrieveEngine: kbDeleteDeferredRegistry{err: retriever.ErrVectorStoreUnavailable}, + ownership: &kbDeleteOwnership{owned: map[string]uint64{storeID: tenantID}}, + wikiRepo: wikiRepo, + } + + payload, err := json.Marshal(types.KBDeletePayload{ + TenantID: tenantID, + KnowledgeBaseID: kbID, + VectorStoreID: &storeIDPtr, + }) + require.NoError(t, err) + + err = svc.ProcessKBDelete(context.Background(), asynq.NewTask(types.TypeKBDelete, payload)) + + require.ErrorIs(t, err, retriever.ErrVectorStoreUnavailable) + assertWikiCleanup(t, wikiRepo, tenantID, kbID) +} diff --git a/internal/types/interfaces/wiki_page.go b/internal/types/interfaces/wiki_page.go index 13517c1f..b8aaa412 100644 --- a/internal/types/interfaces/wiki_page.go +++ b/internal/types/interfaces/wiki_page.go @@ -418,6 +418,31 @@ type WikiPageRepository interface { // DeleteRevisionsByPage hard-deletes a page's entire snapshot history. DeleteRevisionsByPage(ctx context.Context, pageID string) error + // DeleteByKnowledgeBaseID soft-deletes all wiki pages for tenantID+kbID. + // Used by KB delete cleanup to batch-soft-delete every page without walking + // the folder tree. Bypasses the per-page chunk/link reconciliation that + // DeletePage does — the whole KB is going away, so cross-link cleanup is + // the KB delete flow's responsibility. tenantID is required so a tampered + // delete payload cannot wipe another tenant's wiki by kbID alone. + DeleteByKnowledgeBaseID(ctx context.Context, tenantID uint64, kbID string) error + + // DeleteFoldersByKnowledgeBaseID soft-deletes all wiki folders for + // tenantID+kbID. Unlike DeleteFolder this does NOT enforce the emptiness + // guard — the KB is being deleted, so non-empty folders must go too. + DeleteFoldersByKnowledgeBaseID(ctx context.Context, tenantID uint64, kbID string) error + + // DeleteRevisionsByKnowledgeBaseID hard-deletes all wiki page revisions + // for tenantID+kbID. Revisions have no deleted_at column (they are + // immutable snapshots, not soft-deletable rows), so this is a physical + // DELETE — same semantics as DeleteRevisionsByPage but scoped to the + // whole KB. + DeleteRevisionsByKnowledgeBaseID(ctx context.Context, tenantID uint64, kbID string) error + + // DeleteIssuesByKnowledgeBaseID soft-deletes all wiki page issues for + // tenantID+kbID. Issues reference the KB and must be cleaned up + // alongside pages to avoid orphans. + DeleteIssuesByKnowledgeBaseID(ctx context.Context, tenantID uint64, kbID string) error + // CreateIssue inserts a new wiki page issue record. CreateIssue(ctx context.Context, issue *types.WikiPageIssue) error