Skip to content

Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.

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.go
index 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.go
index 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_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 76189da6b..18638d80f 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 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.go
index 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