Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.
Go agentagenticaichatbotdsh-pluginembeddingsevaluationgenerative-aigolangknowledge-basellmmulti-tenantollamaopenaiquestion-answeringragrerankingsemantic-searchvector-searchwiki
fix: clean up wiki data when deleting knowledge base (#3109)
chenrui9d67a0eb4d83
diff --git a/internal/application/repository/wiki_page.go b/internal/application/repository/wiki_page.goindex 2e3eedb43..50212603d 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.goindex 19bc8f621..f21502334 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_versionON 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.goindex 76189da6b..18638d80f 100644--- a/internal/application/service/knowledgebase.go+++ b/internal/application/service/knowledgebase.go@@ -51,6 +51,7 @@ type knowledgeBaseService struct {dsScheduler *datasource.Scheduleraudit interfaces.AuditLogServiceresourceCatalog 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 servicesctx = 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 thediff --git a/internal/application/service/knowledgebase_wiki_cleanup_test.go b/internal/application/service/knowledgebase_wiki_cleanup_test.gonew file mode 100644index 000000000..75c4636e2--- /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.goindex 13517c1f3..b8aaa4122 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