fix: reject cross-store reuse_vectors knowledge move

Moving knowledge with mode=reuse_vectors copies vector index entries
directly between knowledge bases, which only works when both KBs are
bound to the same vector store (CopyIndices is routed through the source
store). Nothing rejected a cross-store reuse_vectors move, so it would
copy target-KB rows into the source store and then delete the source
indices — corrupting vector data. The move endpoint validated only the
embedding model, and ListMoveTargets surfaces same-model KBs regardless
of their store binding, so a cross-store target is reachable.

Reject reuse_vectors moves whose source and target KBs are bound to
different vector stores:

- MoveKnowledge handler: synchronous 400 before enqueueing, with a
  message pointing the caller at reparse mode.
- moveOneKnowledge: re-check before marking the knowledge as processing,
  so a rejected move leaves it untouched rather than stranded.
- moveKnowledgeReuseVectors: a top-of-function guard as defense in depth
  for any directly enqueued task, satisfying the pre-existing contract
  noted in the comment ("callers must reject cross-store moves").

reparse mode is unaffected: it re-indexes into the target store from
scratch and is the supported way to move across stores.
This commit is contained in:
ochan.kwon
2026-06-05 10:13:45 +09:00
committed by lyingbug
parent e76210a695
commit db7baad84c
4 changed files with 238 additions and 4 deletions
@@ -995,6 +995,18 @@ func (s *knowledgeService) moveOneKnowledge(
return fmt.Errorf("knowledge %s is not in completed status (current: %s)", knowledgeID, knowledge.ParseStatus)
}
// Reject a cross-store reuse_vectors move BEFORE mutating status, so a
// rejected move leaves the knowledge untouched (Completed) rather than
// stranded in Processing. reuse_vectors copies indices through the source
// store only; a cross-store copy would corrupt vector data. The handler
// rejects this synchronously — this is defense-in-depth for directly
// enqueued tasks. Cross-store moves must use reparse mode.
if mode == "reuse_vectors" && !sourceKB.SharesStoreWith(targetKB) {
return fmt.Errorf(
"reuse_vectors move across different vector stores is not supported "+
"(source KB %s, target KB %s); use reparse mode", sourceKB.ID, targetKB.ID)
}
// Mark as processing during move
knowledge.ParseStatus = types.ParseStatusProcessing
if err := s.repo.UpdateKnowledge(ctx, knowledge); err != nil {
@@ -1019,6 +1031,19 @@ func (s *knowledgeService) moveKnowledgeReuseVectors(
) error {
tenantID := ctx.Value(types.TenantIDContextKey).(uint64)
// reuse_vectors copies index entries directly between KBs, which only works
// inside the same VectorStore backend (CopyIndices is routed through the
// source store). A cross-store reuse_vectors move would write target-KB rows
// into the source store and then delete the source indices, corrupting data.
// The MoveKnowledge handler rejects this up front; this is defense-in-depth
// for any path that enqueues a move task directly. Cross-store moves must use
// reparse mode (moveKnowledgeReparse), which re-indexes into the target store.
if !sourceKB.SharesStoreWith(targetKB) {
return fmt.Errorf(
"reuse_vectors move across different vector stores is not supported "+
"(source KB %s, target KB %s); use reparse mode", sourceKB.ID, targetKB.ID)
}
// 1. Get old chunk IDs for vector index copy mapping
oldChunks, err := s.chunkRepo.ListChunksByKnowledgeID(ctx, tenantID, knowledge.ID)
if err != nil {
@@ -1033,10 +1058,9 @@ func (s *knowledgeService) moveKnowledgeReuseVectors(
// 2. Copy vector indices from source KB to target KB
if len(chunkIDMapping) > 0 && knowledge.EmbeddingModelID != "" {
// reuse_vectors mode copies index entries directly between KBs, which
// only works inside the same VectorStore backend. Route through the
// source KB's binding; callers must reject cross-store moves before
// landing here.
// Same VectorStore backend is guaranteed by the SharesStoreWith guard at
// the top of this function, so routing CopyIndices through the source
// KB's binding also resolves the target's store.
var sourceStoreID *string
if sourceKB != nil {
sourceStoreID = sourceKB.VectorStoreID
@@ -0,0 +1,62 @@
package service
import (
"context"
"testing"
"github.com/Tencent/WeKnora/internal/types"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// TestMoveKnowledgeReuseVectors_CrossStoreRejected verifies the defense-in-depth
// guard: a reuse_vectors move whose source and target KBs are bound to different
// vector stores must be rejected before any index copy runs. The guard fires at
// the top of moveKnowledgeReuseVectors, so an empty knowledgeService (no repos)
// is sufficient — the function returns before touching any dependency.
func TestMoveKnowledgeReuseVectors_CrossStoreRejected(t *testing.T) {
s := &knowledgeService{}
ctx := context.WithValue(context.Background(), types.TenantIDContextKey, uint64(1))
storeA, storeB := "store-a", "store-b"
tests := []struct {
name string
srcStore *string
dstStore *string
}{
{"both bound, different stores", &storeA, &storeB},
{"source bound, target env-store", &storeA, nil},
{"source env-store, target bound", nil, &storeB},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
src := &types.KnowledgeBase{ID: "kb-src", VectorStoreID: tt.srcStore}
dst := &types.KnowledgeBase{ID: "kb-dst", VectorStoreID: tt.dstStore}
kn := &types.Knowledge{ID: "k1", EmbeddingModelID: "m1"}
err := s.moveKnowledgeReuseVectors(ctx, kn, src, dst)
require.Error(t, err)
assert.Contains(t, err.Error(), "different vector stores")
})
}
}
// TestSharesStoreWith_GuardSemantics pins the same/cross-store classification the
// move gate relies on, including the env-store (nil) normalization, so a change
// to SharesStoreWith that would silently re-open the cross-store reuse_vectors
// hole fails here.
func TestSharesStoreWith_GuardSemantics(t *testing.T) {
storeA, storeB, empty := "store-a", "store-b", ""
same := func(a, b *string) bool {
return (&types.KnowledgeBase{VectorStoreID: a}).
SharesStoreWith(&types.KnowledgeBase{VectorStoreID: b})
}
assert.True(t, same(nil, nil), "both env-store → same")
assert.True(t, same(&empty, nil), "empty string normalizes to env-store")
assert.True(t, same(&storeA, &storeA), "same UUID → same")
assert.False(t, same(&storeA, &storeB), "different UUID → cross-store")
assert.False(t, same(&storeA, nil), "bound vs env-store → cross-store")
}