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