Add knowledge base duplicate flow

This commit is contained in:
wizardchen
2026-07-08 20:43:12 +08:00
committed by lyingbug
parent e93f8d3c21
commit 58b79876ae
16 changed files with 488 additions and 122 deletions
+85
View File
@@ -936,6 +936,17 @@ type CopyKnowledgeBaseResponse struct {
Message string `json:"message"`
}
type DuplicateKnowledgeBaseRequest struct {
TargetID string `json:"target_id"`
}
type DuplicateKnowledgeBaseResponse struct {
SourceID string `json:"source_id"`
TargetID string `json:"target_id"`
Message string `json:"message"`
KnowledgeBase interface{} `json:"knowledge_base"`
}
// CopyKnowledgeBase godoc
// @Summary 复制知识库
// @Description 将一个知识库的内容复制到另一个知识库(异步任务)
@@ -1114,6 +1125,80 @@ func (h *KnowledgeBaseHandler) CopyKnowledgeBase(c *gin.Context) {
})
}
// DuplicateKnowledgeBase godoc
// @Summary 创建知识库副本
// @Description 创建一个只包含设置的新知识库副本,不复制知识、FAQ 内容、分块、索引、Wiki 页面、分享或置顶状态
// @Tags 知识库
// @Accept json
// @Produce json
// @Param id path string true "源知识库 ID"
// @Param request body DuplicateKnowledgeBaseRequest false "创建副本请求"
// @Success 201 {object} map[string]interface{} "创建后的知识库副本"
// @Failure 400 {object} errors.AppError "请求参数错误"
// @Security Bearer
// @Router /knowledge-bases/{id}/duplicate [post]
func (h *KnowledgeBaseHandler) DuplicateKnowledgeBase(c *gin.Context) {
ctx := c.Request.Context()
sourceID := c.Param("id")
if sourceID == "" {
c.Error(apperrors.NewBadRequestError("Knowledge base ID cannot be empty"))
return
}
var req DuplicateKnowledgeBaseRequest
if c.Request.Body != nil && c.Request.ContentLength != 0 {
if err := c.ShouldBindJSON(&req); err != nil {
c.Error(apperrors.NewBadRequestError("Invalid request parameters").WithDetails(err.Error()))
return
}
}
callerTenantID := c.GetUint64(types.TenantIDContextKey.String())
sourceKB, err := h.service.GetKnowledgeBaseByID(ctx, sourceID)
if err != nil {
if stderrors.Is(err, repository.ErrKnowledgeBaseNotFound) {
c.Error(errors.NewNotFoundError("Source knowledge base not found"))
return
}
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
if sourceKB.TenantID != callerTenantID {
logger.Warnf(ctx,
"Knowledge base duplicate rejected: source belongs to another tenant, source_id: %s, caller_tenant: %d, kb_tenant: %d",
secutils.SanitizeForLog(sourceID), callerTenantID, sourceKB.TenantID)
c.Error(errors.NewForbiddenError("No permission to duplicate this knowledge base"))
return
}
targetKB, err := h.service.DuplicateKnowledgeBase(ctx, sourceID, req.TargetID)
if err != nil {
if appErr, ok := apperrors.IsAppError(err); ok {
c.Error(appErr)
return
}
if stderrors.Is(err, repository.ErrKnowledgeBaseNotFound) {
c.Error(errors.NewNotFoundError("Source knowledge base not found"))
return
}
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(err.Error()))
return
}
logger.Infof(ctx, "Knowledge base duplicate created, source: %s, target: %s",
secutils.SanitizeForLog(sourceID), secutils.SanitizeForLog(targetKB.ID))
c.JSON(http.StatusCreated, gin.H{
"success": true,
"data": DuplicateKnowledgeBaseResponse{
SourceID: sourceID,
TargetID: targetKB.ID,
Message: "Knowledge base duplicate created",
KnowledgeBase: buildKBResponse(targetKB, h.resolveKBStoreView(ctx, targetKB, callerTenantID), nil),
},
})
}
// GetKBCloneProgress godoc
// @Summary 获取知识库复制进度
// @Description 获取知识库复制任务的进度
@@ -9,50 +9,32 @@ import (
"github.com/gin-gonic/gin"
apperrors "github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/middleware"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
)
// handler.CopyKnowledgeBase pre-flight tests.
//
// The async clone worker (service.CopyKnowledgeBase) re-applies the same
// embedding-model and store-binding defenses as defense in depth, but the
// handler-level pre-flight is the one that surfaces 400 to the API caller
// synchronously instead of inside Asynq progress polling. These tests pin
// the synchronous behavior so a future refactor that drops the pre-flight
// fails loudly here rather than silently degrading UX.
// stubKBCopyService provides only the two methods the Copy handler reaches
// for (GetKnowledgeBaseByID twice). Other interface methods stay nil so any
// accidental new call panics rather than silently succeeding.
// stubKBCopyService provides only the methods the duplicate handler reaches.
// Other interface methods stay embedded so accidental new calls panic in tests.
type stubKBCopyService struct {
interfaces.KnowledgeBaseService
byID func(ctx context.Context, id string) (*types.KnowledgeBase, error)
byID func(ctx context.Context, id string) (*types.KnowledgeBase, error)
duplicate func(ctx context.Context, sourceID, targetID string) (*types.KnowledgeBase, error)
}
func (s *stubKBCopyService) GetKnowledgeBaseByID(ctx context.Context, id string) (*types.KnowledgeBase, error) {
return s.byID(ctx, id)
}
// stubEnqueuer records whether Enqueue was invoked. The whole point of the
// pre-flight is to short-circuit *before* enqueue, so the test fails if
// enqueue ran for a mismatched clone.
type stubEnqueuer struct {
calls int
func (s *stubKBCopyService) DuplicateKnowledgeBase(
ctx context.Context,
sourceID string,
targetID string,
) (*types.KnowledgeBase, error) {
return s.duplicate(ctx, sourceID, targetID)
}
func (s *stubEnqueuer) Enqueue(_ interface{}, _ ...interface{}) (*stubEnqueueInfo, error) {
s.calls++
return &stubEnqueueInfo{ID: "x"}, nil
}
// stubEnqueueInfo is a stand-in for asynq.TaskInfo so the test does not need
// to construct one.
type stubEnqueueInfo struct{ ID string }
func newCopyPreflightRouter(svc interfaces.KnowledgeBaseService) (*gin.Engine, *stubEnqueuer) {
func newDuplicateRouter(svc interfaces.KnowledgeBaseService) *gin.Engine {
gin.SetMode(gin.TestMode)
r := gin.New()
r.Use(middleware.ErrorHandler())
@@ -61,120 +43,75 @@ func newCopyPreflightRouter(svc interfaces.KnowledgeBaseService) (*gin.Engine, *
c.Set(types.UserIDContextKey.String(), "u-test")
c.Next()
})
enq := &stubEnqueuer{}
// The real handler reaches into h.asynqClient.Enqueue with the asynq
// task type. We do not exercise the enqueue path in these tests — every
// case here either short-circuits at pre-flight or returns 4xx earlier.
// Leaving asynqClient nil would panic if enqueue ran, which is exactly
// the regression we want to catch.
h := &KnowledgeBaseHandler{service: svc}
r.POST("/knowledge-bases/copy", h.CopyKnowledgeBase)
return r, enq
r.POST("/knowledge-bases/:id/duplicate", h.DuplicateKnowledgeBase)
return r
}
func storeIDPtr(s string) *string { return &s }
func TestCopyHandlerPreflight_DifferentEmbeddingModel(t *testing.T) {
func TestDuplicateHandler_ReturnsCreatedKnowledgeBase(t *testing.T) {
var gotSourceID, gotTargetID string
svc := &stubKBCopyService{
byID: func(_ context.Context, id string) (*types.KnowledgeBase, error) {
switch id {
case "src":
return &types.KnowledgeBase{
ID: "src", TenantID: 1, EmbeddingModelID: "embed-A",
}, nil
case "dst":
return &types.KnowledgeBase{
ID: "dst", TenantID: 1, EmbeddingModelID: "embed-B",
}, nil
if id != "src" {
t.Fatalf("handler should only load the source KB, got id=%s", id)
}
return nil, nil
return &types.KnowledgeBase{ID: "src", TenantID: 1, Name: "Source"}, nil
},
duplicate: func(_ context.Context, sourceID, targetID string) (*types.KnowledgeBase, error) {
gotSourceID, gotTargetID = sourceID, targetID
return &types.KnowledgeBase{
ID: "copy-id",
TenantID: 1,
Name: "Source",
CreatorID: "u-test",
}, nil
},
}
r, _ := newCopyPreflightRouter(svc)
r := newDuplicateRouter(svc)
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodPost, "/knowledge-bases/copy",
strings.NewReader(`{"source_id":"src","target_id":"dst"}`))
req := httptest.NewRequest(http.MethodPost, "/knowledge-bases/src/duplicate",
strings.NewReader(`{"target_id":"copy-id"}`))
req.Header.Set("Content-Type", "application/json")
r.ServeHTTP(w, req)
if w.Code != http.StatusBadRequest {
t.Fatalf("expected 400 for embedding-model mismatch, got %d body=%s", w.Code, w.Body.String())
if w.Code != http.StatusCreated {
t.Fatalf("expected 201 for duplicate, got %d body=%s", w.Code, w.Body.String())
}
if !strings.Contains(w.Body.String(), "different embedding models") {
t.Fatalf("expected embedding-model error message, got %s", w.Body.String())
if gotSourceID != "src" || gotTargetID != "copy-id" {
t.Fatalf("duplicate service called with source=%q target=%q", gotSourceID, gotTargetID)
}
body := w.Body.String()
for _, want := range []string{`"source_id":"src"`, `"target_id":"copy-id"`, `"knowledge_base"`} {
if !strings.Contains(body, want) {
t.Fatalf("response missing %s: %s", want, body)
}
}
}
func TestCopyHandlerPreflight_DifferentVectorStore(t *testing.T) {
func TestDuplicateHandler_RejectsCrossTenantSource(t *testing.T) {
calledDuplicate := false
svc := &stubKBCopyService{
byID: func(_ context.Context, id string) (*types.KnowledgeBase, error) {
switch id {
case "src":
return &types.KnowledgeBase{
ID: "src", TenantID: 1, EmbeddingModelID: "embed-A",
VectorStoreID: storeIDPtr("store-A"),
}, nil
case "dst":
return &types.KnowledgeBase{
ID: "dst", TenantID: 1, EmbeddingModelID: "embed-A",
VectorStoreID: storeIDPtr("store-B"),
}, nil
}
return &types.KnowledgeBase{ID: id, TenantID: 2, Name: "Shared"}, nil
},
duplicate: func(_ context.Context, _, _ string) (*types.KnowledgeBase, error) {
calledDuplicate = true
return nil, nil
},
}
r, _ := newCopyPreflightRouter(svc)
r := newDuplicateRouter(svc)
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodPost, "/knowledge-bases/copy",
strings.NewReader(`{"source_id":"src","target_id":"dst"}`))
req := httptest.NewRequest(http.MethodPost, "/knowledge-bases/src/duplicate",
strings.NewReader(`{}`))
req.Header.Set("Content-Type", "application/json")
r.ServeHTTP(w, req)
if w.Code != http.StatusBadRequest {
t.Fatalf("expected 400 for store mismatch, got %d body=%s", w.Code, w.Body.String())
if w.Code != http.StatusForbidden {
t.Fatalf("expected 403 for cross-tenant source, got %d body=%s", w.Code, w.Body.String())
}
if !strings.Contains(w.Body.String(), "different vector stores") {
t.Fatalf("expected store-mismatch error message, got %s", w.Body.String())
}
if strings.Contains(w.Body.String(), "Phase 4") {
t.Fatalf("error message must not leak internal roadmap labels: %s", w.Body.String())
if calledDuplicate {
t.Fatal("duplicate service must not be called when source KB is outside the caller tenant")
}
}
func TestCopyHandlerPreflight_OneSideNilStore(t *testing.T) {
svc := &stubKBCopyService{
byID: func(_ context.Context, id string) (*types.KnowledgeBase, error) {
switch id {
case "src":
return &types.KnowledgeBase{
ID: "src", TenantID: 1, EmbeddingModelID: "embed-A",
VectorStoreID: nil,
}, nil
case "dst":
return &types.KnowledgeBase{
ID: "dst", TenantID: 1, EmbeddingModelID: "embed-A",
VectorStoreID: storeIDPtr("store-A"),
}, nil
}
return nil, nil
},
}
r, _ := newCopyPreflightRouter(svc)
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodPost, "/knowledge-bases/copy",
strings.NewReader(`{"source_id":"src","target_id":"dst"}`))
req.Header.Set("Content-Type", "application/json")
r.ServeHTTP(w, req)
if w.Code != http.StatusBadRequest {
t.Fatalf("expected 400 when one side is env-store and the other is DB-store, got %d body=%s",
w.Code, w.Body.String())
}
}
// compile-time guard against accidentally dropping the apperrors import
// from the file — if the pre-flight refactor goes away, this fails too.
var _ = apperrors.NewBadRequestError