Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

Go: add context for DB access (#17861)

Jin Hai583ba3cb9755
diff --git a/internal/dao/chat.go b/internal/dao/chat.go
index 8f7cf8ae70..14787663e8 100644
--- a/internal/dao/chat.go
+++ b/internal/dao/chat.go
@@ -206,7 +206,7 @@ func (dao *ChatDAO) UpdateByID(ctx context.Context, db *gorm.DB, id string, upda
}
if result.RowsAffected == 0 {
var count int64
- if err := DB.Model(&entity.Chat{}).Where("id = ?", id).Count(&count).Error; err != nil {
+ if err := db.WithContext(ctx).Model(&entity.Chat{}).Where("id = ?", id).Count(&count).Error; err != nil {
return err
}
if count == 0 {
diff --git a/internal/dao/compilation_template.go b/internal/dao/compilation_template.go
index 634e1eeb2e..929d44a5dc 100644
--- a/internal/dao/compilation_template.go
+++ b/internal/dao/compilation_template.go
@@ -44,13 +44,11 @@ func NewCompilationTemplateDAO() *CompilationTemplateDAO {
// one valid template (group missing, wrong tenant, or empty). This surfaces the
// misconfiguration instead of silently dropping the compilation_template_ids
// stamp — the data-loss path the caller is guarding against.
-func (dao *CompilationTemplateDAO) ResolveGroupTemplateIDs(ctx context.Context, tenantID string, groupIDs []string) ([]string, error) {
+func (dao *CompilationTemplateDAO) ResolveGroupTemplateIDs(ctx context.Context, db *gorm.DB, tenantID string, groupIDs []string) ([]string, error) {
if len(groupIDs) == 0 {
return nil, nil
}
- db := DB.WithContext(ctx)
-
// Verify the requested groups exist and are valid. The built-in group
// (compiler.json's default) is a global, tenant-agnostic catalogue, so it
// resolves for every tenant; other groups are scoped to the caller's
@@ -62,7 +60,7 @@ func (dao *CompilationTemplateDAO) ResolveGroupTemplateIDs(ctx context.Context,
}
}
var validGroups []entity.CompilationTemplateGroup
- if err := db.
+ if err := db.WithContext(ctx).
Where("id IN ? AND status = ?", groupIDs, string(entity.StatusValid)).
Find(&validGroups).Error; err != nil {
return nil, fmt.Errorf("resolve compilation template groups: %w", err)
@@ -86,7 +84,7 @@ func (dao *CompilationTemplateDAO) ResolveGroupTemplateIDs(ctx context.Context,
}
var templates []entity.CompilationTemplate
- if err := db.Model(&entity.CompilationTemplate{}).
+ if err := db.WithContext(ctx).Model(&entity.CompilationTemplate{}).
Where("group_id IN ? AND status = ?", groupIDs, string(entity.StatusValid)).
Order("create_time asc").
Find(&templates).Error; err != nil {
@@ -116,9 +114,9 @@ func (dao *CompilationTemplateDAO) ResolveGroupTemplateIDs(ctx context.Context,
// It backs the KnowledgeCompiler TemplateResolver: the template's kind selects
// the Go compile variant (see common.KindToVariant) and its config is the
// template "content" plumbed to the variant.
-func (dao *CompilationTemplateDAO) GetTemplate(ctx context.Context, tenantID, templateID string) (*entity.CompilationTemplate, error) {
+func (dao *CompilationTemplateDAO) GetTemplate(ctx context.Context, db *gorm.DB, tenantID, templateID string) (*entity.CompilationTemplate, error) {
var t entity.CompilationTemplate
- if err := DB.WithContext(ctx).
+ if err := db.WithContext(ctx).
Where("id = ? AND tenant_id = ? AND status = ?", templateID, tenantID, string(entity.StatusValid)).
First(&t).Error; err != nil {
return nil, fmt.Errorf("load compilation template %q: %w", templateID, err)
@@ -142,9 +140,9 @@ func (dao *CompilationTemplateDAO) ListByGroup(ctx context.Context, db *gorm.DB,
// ListBuiltins returns the valid, built-in (is_builtin) compilation templates,
// ordered by create_time then name. Mirrors Python list_builtins().
-func (dao *CompilationTemplateDAO) ListBuiltins(ctx context.Context) ([]*entity.CompilationTemplate, error) {
+func (dao *CompilationTemplateDAO) ListBuiltins(ctx context.Context, db *gorm.DB) ([]*entity.CompilationTemplate, error) {
var templates []*entity.CompilationTemplate
- if err := DB.WithContext(ctx).
+ if err := db.WithContext(ctx).
Where("is_builtin = ? AND status = ?", true, string(entity.StatusValid)).
Order("create_time asc, name asc").
Find(&templates).Error; err != nil {
@@ -156,8 +154,8 @@ func (dao *CompilationTemplateDAO) ListBuiltins(ctx context.Context) ([]*entity.
// NameExistsInGroup reports whether a valid, non-built-in template with the
// given name already exists inside the group, excluding excludeID. Mirrors the
// Python duplicate-child guard.
-func (dao *CompilationTemplateDAO) NameExistsInGroup(ctx context.Context, tenantID, groupID, name, excludeID string) (bool, error) {
- q := DB.WithContext(ctx).Model(&entity.CompilationTemplate{}).
+func (dao *CompilationTemplateDAO) NameExistsInGroup(ctx context.Context, db *gorm.DB, tenantID, groupID, name, excludeID string) (bool, error) {
+ q := db.WithContext(ctx).Model(&entity.CompilationTemplate{}).
Where("tenant_id = ? AND group_id = ? AND name = ? AND is_builtin = ? AND status = ?",
tenantID, groupID, name, false, string(entity.StatusValid))
if excludeID != "" {
@@ -172,9 +170,9 @@ func (dao *CompilationTemplateDAO) NameExistsInGroup(ctx context.Context, tenant
// GetByID returns a single template row by id regardless of tenant scope
// (used for reconciling group children).
-func (dao *CompilationTemplateDAO) GetByID(ctx context.Context, id string) (*entity.CompilationTemplate, error) {
+func (dao *CompilationTemplateDAO) GetByID(ctx context.Context, db *gorm.DB, id string) (*entity.CompilationTemplate, error) {
var t entity.CompilationTemplate
- if err := DB.WithContext(ctx).Where("id = ?", id).First(&t).Error; err != nil {
+ if err := db.WithContext(ctx).Where("id = ?", id).First(&t).Error; err != nil {
return nil, err
}
return &t, nil
diff --git a/internal/dao/compilation_template_group.go b/internal/dao/compilation_template_group.go
index 8524527525..9366920085 100644
--- a/internal/dao/compilation_template_group.go
+++ b/internal/dao/compilation_template_group.go
@@ -36,8 +36,8 @@ func NewCompilationTemplateGroupDAO() *CompilationTemplateGroupDAO {
// ListSaved returns the tenant's valid groups with optional keyword/scope
// filtering and ordering, mirroring Python list_saved(). Built-in groups
// (empty tenant) are included so every tenant sees the catalogue.
-func (dao *CompilationTemplateGroupDAO) ListSaved(ctx context.Context, tenantID, keywords, scope, orderby string, desc bool) ([]*entity.CompilationTemplateGroup, error) {
- q := DB.WithContext(ctx).
+func (dao *CompilationTemplateGroupDAO) ListSaved(ctx context.Context, db *gorm.DB, tenantID, keywords, scope, orderby string, desc bool) ([]*entity.CompilationTemplateGroup, error) {
+ q := db.WithContext(ctx).
Where("(tenant_id = ? OR tenant_id = '') AND status = ?", tenantID, string(entity.StatusValid))
if keywords != "" {
q = q.Where("name LIKE ?", "%"+keywords+"%")
@@ -60,9 +60,9 @@ func (dao *CompilationTemplateGroupDAO) ListSaved(ctx context.Context, tenantID,
}
// GetSaved returns a single valid group for the tenant (or built-in), or nil.
-func (dao *CompilationTemplateGroupDAO) GetSaved(ctx context.Context, tenantID, groupID string) (*entity.CompilationTemplateGroup, error) {
+func (dao *CompilationTemplateGroupDAO) GetSaved(ctx context.Context, db *gorm.DB, tenantID, groupID string) (*entity.CompilationTemplateGroup, error) {
var g entity.CompilationTemplateGroup
- err := DB.WithContext(ctx).
+ err := db.WithContext(ctx).
Where("(tenant_id = ? OR tenant_id = '') AND id = ? AND status = ?",
tenantID, groupID, string(entity.StatusValid)).
First(&g).Error
@@ -77,8 +77,8 @@ func (dao *CompilationTemplateGroupDAO) GetSaved(ctx context.Context, tenantID,
// NameExists reports whether a valid group with the given name exists for the
// tenant, excluding excludeID. Mirrors Python name_exists().
-func (dao *CompilationTemplateGroupDAO) NameExists(ctx context.Context, tenantID, name, excludeID string) (bool, error) {
- q := DB.WithContext(ctx).Model(&entity.CompilationTemplateGroup{}).
+func (dao *CompilationTemplateGroupDAO) NameExists(ctx context.Context, db *gorm.DB, tenantID, name, excludeID string) (bool, error) {
+ q := db.WithContext(ctx).Model(&entity.CompilationTemplateGroup{}).
Where("tenant_id = ? AND name = ? AND status = ?", tenantID, name, string(entity.StatusValid))
if excludeID != "" {
q = q.Where("id <> ?", excludeID)
diff --git a/internal/dao/compilation_template_seed_test.go b/internal/dao/compilation_template_seed_test.go
index 9b852d7e40..d9c52bc77c 100644
--- a/internal/dao/compilation_template_seed_test.go
+++ b/internal/dao/compilation_template_seed_test.go
@@ -134,7 +134,7 @@ func TestSeedBuiltinCompilationTemplatesForTenant(t *testing.T) {
}
// ResolveGroupTemplateIDs resolves the built-in group for any tenant.
- resolved, err := NewCompilationTemplateDAO().ResolveGroupTemplateIDs(ctx, "some-other-tenant", []string{BuiltinCompilationTemplateGroupID})
+ resolved, err := NewCompilationTemplateDAO().ResolveGroupTemplateIDs(ctx, db, "some-other-tenant", []string{BuiltinCompilationTemplateGroupID})
if err != nil {
t.Fatalf("resolve built-in group: %v", err)
}
diff --git a/internal/dao/kb.go b/internal/dao/kb.go
index e10ac12002..bd265e2c96 100644
--- a/internal/dao/kb.go
+++ b/internal/dao/kb.go
@@ -234,10 +234,10 @@ func (dao *KnowledgebaseDAO) GetByTenantIDs(ctx context.Context, db *gorm.DB, te
}
// GetOwnerFilter returns owner counts for datasets visible to a user.
-func (dao *KnowledgebaseDAO) GetOwnerFilter(tenantIDs []string, userID string) ([]*entity.DatasetOwnerFilter, error) {
+func (dao *KnowledgebaseDAO) GetOwnerFilter(ctx context.Context, db *gorm.DB, tenantIDs []string, userID string) ([]*entity.DatasetOwnerFilter, error) {
owners := make([]*entity.DatasetOwnerFilter, 0)
- err := DB.Model(&entity.Knowledgebase{}).
+ err := db.WithContext(ctx).Model(&entity.Knowledgebase{}).
Select("knowledgebase.tenant_id as id, user.nickname as label, COUNT(knowledgebase.id) as count").
Joins("LEFT JOIN user ON knowledgebase.tenant_id = user.id").
Where("((knowledgebase.tenant_id IN ? AND knowledgebase.permission = ?) OR knowledgebase.tenant_id = ?) AND knowledgebase.status = ?",
diff --git a/internal/dao/task.go b/internal/dao/task.go
index bf52b8efe1..18624897e6 100644
--- a/internal/dao/task.go
+++ b/internal/dao/task.go
@@ -55,8 +55,8 @@ func (dao *TaskDAO) GetByID(ctx context.Context, db *gorm.DB, id string) (*entit
}
// UpdateProgress sets the progress and progress message of a task
-func (dao *TaskDAO) UpdateProgress(id string, progress float64, progressMsg string) error {
- return DB.Model(&entity.Task{}).Where("id = ?", id).Updates(map[string]any{
+func (dao *TaskDAO) UpdateProgress(ctx context.Context, db *gorm.DB, id string, progress float64, progressMsg string) error {
+ return db.WithContext(ctx).Model(&entity.Task{}).Where("id = ?", id).Updates(map[string]any{
"progress": progress,
"progress_msg": progressMsg,
}).Error
diff --git a/internal/dao/user_canvas_version.go b/internal/dao/user_canvas_version.go
index 491b330b88..679c751452 100644
--- a/internal/dao/user_canvas_version.go
+++ b/internal/dao/user_canvas_version.go
@@ -103,9 +103,9 @@ func (dao *UserCanvasVersionDAO) GetLatest(ctx context.Context, db *gorm.DB, can
// GetLatestReleased returns the most recently updated released version of
// canvasID, or ErrUserCanvasVersionNotFound when nothing was ever published.
// Mirrors the released-version lookup in Python's get_agent handler.
-func (dao *UserCanvasVersionDAO) GetLatestReleased(canvasID string) (*entity.UserCanvasVersion, error) {
+func (dao *UserCanvasVersionDAO) GetLatestReleased(ctx context.Context, db *gorm.DB, canvasID string) (*entity.UserCanvasVersion, error) {
var v entity.UserCanvasVersion
- err := DB.Where("user_canvas_id = ? AND `release` = ?", canvasID, true).
+ err := db.WithContext(ctx).Where("user_canvas_id = ? AND `release` = ?", canvasID, true).
Order("update_time DESC").
First(&v).Error
if err != nil {
@@ -120,7 +120,7 @@ func (dao *UserCanvasVersionDAO) GetLatestReleased(canvasID string) (*entity.Use
// GetLatestReleaseTimes returns MAX(create_time) of released versions per
// canvas for the given canvas IDs. Mirrors the release_time aggregation in
// Python's UserCanvasService.get_list.
-func (dao *UserCanvasVersionDAO) GetLatestReleaseTimes(canvasIDs []string) (map[string]int64, error) {
+func (dao *UserCanvasVersionDAO) GetLatestReleaseTimes(ctx context.Context, db *gorm.DB, canvasIDs []string) (map[string]int64, error) {
result := make(map[string]int64, len(canvasIDs))
if len(canvasIDs) == 0 {
return result, nil
@@ -130,7 +130,7 @@ func (dao *UserCanvasVersionDAO) GetLatestReleaseTimes(canvasIDs []string) (map[
ReleaseTime int64
}
var rows []row
- err := DB.Model(&entity.UserCanvasVersion{}).
+ err := db.WithContext(ctx).Model(&entity.UserCanvasVersion{}).
Select("user_canvas_id, MAX(create_time) AS release_time").
Where("user_canvas_id IN ? AND `release` = ?", canvasIDs, true).
Group("user_canvas_id").
diff --git a/internal/ingestion/component/knowledge_compiler/common/deps.go b/internal/ingestion/component/knowledge_compiler/common/deps.go
index de39b473ad..0f37d2c4be 100644
--- a/internal/ingestion/component/knowledge_compiler/common/deps.go
+++ b/internal/ingestion/component/knowledge_compiler/common/deps.go
@@ -4,6 +4,8 @@ import (
"context"
"fmt"
"sync"
+
+ "gorm.io/gorm"
)
// DefaultLLMContextLength is the fallback chat-model context window (tokens)
@@ -151,7 +153,7 @@ func ResolveDeps(tenantID, llmID, embeddingModel string) (Deps, error) {
// compilation_template_group_id but no GroupResolver is installed, the
// component fails loudly instead of silently emitting rows that miss
// compilation_template_ids (a data-loss path).
-type GroupResolver func(ctx context.Context, tenantID string, groupIDs []string) ([]string, error)
+type GroupResolver func(ctx context.Context, db *gorm.DB, tenantID string, groupIDs []string) ([]string, error)
var (
groupResolverMu sync.RWMutex
@@ -172,7 +174,7 @@ func SetGroupResolver(r GroupResolver) {
// resolve. Returns an error if group ids are requested but no resolver is
// installed, surfacing the misconfiguration instead of silently dropping the
// compilation_template_ids stamp.
-func ResolveGroupTemplateIDs(ctx context.Context, tenantID string, groupIDs []string) ([]string, error) {
+func ResolveGroupTemplateIDs(ctx context.Context, db *gorm.DB, tenantID string, groupIDs []string) ([]string, error) {
if len(groupIDs) == 0 {
return nil, nil
}
@@ -182,11 +184,11 @@ func ResolveGroupTemplateIDs(ctx context.Context, tenantID string, groupIDs []st
if r == nil {
return nil, fmt.Errorf("knowledge_compiler: compilation_template_group_id provided but no GroupResolver installed (production wiring must call common.SetGroupResolver)")
}
- return r(ctx, tenantID, groupIDs)
+ return r(ctx, db, tenantID, groupIDs)
}
// TemplateResolver loads a single compilation template by id for the tenant.
-type TemplateResolver func(ctx context.Context, tenantID, templateID string) (TemplateInfo, error)
+type TemplateResolver func(ctx context.Context, db *gorm.DB, tenantID, templateID string) (TemplateInfo, error)
// TemplateInfo is a resolved compilation template: its id, the kind that
// selects the Go compiler variant (see KindToVariant), and its config blob (the
@@ -216,12 +218,12 @@ func SetTemplateResolver(r TemplateResolver) {
// ResolveTemplate loads a single compilation template by id via the installed
// resolver. Returns an error when no resolver is installed (compilation_template_id
// provided but unwired) rather than silently compiling with no template config.
-func ResolveTemplate(ctx context.Context, tenantID, templateID string) (TemplateInfo, error) {
+func ResolveTemplate(ctx context.Context, db *gorm.DB, tenantID, templateID string) (TemplateInfo, error) {
templateResolverMu.RLock()
r := templateResolver
templateResolverMu.RUnlock()
if r == nil {
return TemplateInfo{}, fmt.Errorf("knowledge_compiler: compilation_template_id provided but no TemplateResolver installed (production wiring must call common.SetTemplateResolver)")
}
- return r(ctx, tenantID, templateID)
+ return r(ctx, db, tenantID, templateID)
}
diff --git a/internal/ingestion/component/knowledge_compiler/component.go b/internal/ingestion/component/knowledge_compiler/component.go
index bb870f4b93..b88f762b93 100644
--- a/internal/ingestion/component/knowledge_compiler/component.go
+++ b/internal/ingestion/component/knowledge_compiler/component.go
@@ -98,7 +98,7 @@ func (c *KnowledgeCompilerComponent) Invoke(ctx context.Context, db *gorm.DB, in
// compilation_template_id > compilation_template_group_id. The variant is
// derived from each template's kind (see common.KindToVariant), not from
// the DSL.
- specs, err := resolveTemplateSpecs(ctx, tenantID, param)
+ specs, err := resolveTemplateSpecs(ctx, db, tenantID, param)
if err != nil {
return nil, err
}
@@ -343,22 +343,22 @@ func pageIndexSummary(graphJSON string) string {
// their TemplateInfo rows. Priority: compilation_template_id >
// compilation_template_group_id. The group path resolves the group to its
// child template ids and then loads each template.
-func resolveTemplateSpecs(ctx context.Context, tenantID string, param common.Param) ([]common.TemplateInfo, error) {
+func resolveTemplateSpecs(ctx context.Context, db *gorm.DB, tenantID string, param common.Param) ([]common.TemplateInfo, error) {
if param.CompilationTemplateID != "" {
- info, err := common.ResolveTemplate(ctx, tenantID, param.CompilationTemplateID)
+ info, err := common.ResolveTemplate(ctx, db, tenantID, param.CompilationTemplateID)
if err != nil {
return nil, err
}
return []common.TemplateInfo{info}, nil
}
if param.CompilationTemplateGroupID != "" {
- ids, err := common.ResolveGroupTemplateIDs(ctx, tenantID, []string{param.CompilationTemplateGroupID})
+ ids, err := common.ResolveGroupTemplateIDs(ctx, db, tenantID, []string{param.CompilationTemplateGroupID})
if err != nil {
return nil, err
}
specs := make([]common.TemplateInfo, 0, len(ids))
for _, id := range ids {
- info, err := common.ResolveTemplate(ctx, tenantID, id)
+ info, err := common.ResolveTemplate(ctx, db, tenantID, id)
if err != nil {
return nil, err
}
diff --git a/internal/ingestion/component/knowledge_compiler/component_test.go b/internal/ingestion/component/knowledge_compiler/component_test.go
index 074d3a1e47..c46a8847af 100644
--- a/internal/ingestion/component/knowledge_compiler/component_test.go
+++ b/internal/ingestion/component/knowledge_compiler/component_test.go
@@ -14,6 +14,8 @@ import (
"ragflow/internal/ingestion/component/knowledge_compiler/common"
"ragflow/internal/service/nav"
+
+ "gorm.io/gorm"
)
// mockChat answers the structure variant's three LLM call shapes under the
@@ -1082,7 +1084,7 @@ func TestKnowledgeCompiler_PassThroughEnvelope(t *testing.T) {
// groupResolverStub maps every requested group id to a fixed pair of template
// ids, standing in for the production DB-backed group service.
-func groupResolverStub(_ context.Context, _ string, groupIDs []string) ([]string, error) {
+func groupResolverStub(_ context.Context, _ *gorm.DB, _ string, groupIDs []string) ([]string, error) {
var out []string
for _, g := range groupIDs {
out = append(out, "tpl-"+g+"-a", "tpl-"+g+"-b")
@@ -1099,8 +1101,8 @@ func TestKnowledgeCompiler_GroupIDsResolvedToTemplateIDs(t *testing.T) {
installMockDeps(t)
// The group resolves to two concrete template ids; each is compiled as its
// own spec, so the TemplateResolver must return a valid kind for them.
- // Override the package stub and restore it afterwards.
- common.SetTemplateResolver(func(ctx context.Context, tenantID, templateID string) (common.TemplateInfo, error) {
+ // Override the package stub and restore it afterward.
+ common.SetTemplateResolver(func(ctx context.Context, db *gorm.DB, tenantID, templateID string) (common.TemplateInfo, error) {
kind := templateID
if strings.HasPrefix(templateID, "tpl-grp1") {
kind = "structure"
@@ -1204,7 +1206,7 @@ func TestKnowledgeCompiler_GroupIDsWithoutResolverFailsLoud(t *testing.T) {
// register a synthetic "tpl-<variant>" id that maps to the desired kind.
// Production wiring installs the real DB-backed resolvers (see
// internal/ingestion/task/knowledge_compiler_wiring.go).
-var testTemplateResolver common.TemplateResolver = func(ctx context.Context, tenantID, templateID string) (common.TemplateInfo, error) {
+var testTemplateResolver common.TemplateResolver = func(ctx context.Context, db *gorm.DB, tenantID, templateID string) (common.TemplateInfo, error) {
return common.TemplateInfo{ID: templateID, Kind: templateID, Config: map[string]any{}}, nil
}
@@ -1217,16 +1219,16 @@ var testTemplateResolver common.TemplateResolver = func(ctx context.Context, ten
func installVariantTemplateResolver(t *testing.T, variant string) {
t.Helper()
prev := testTemplateResolver
- common.SetTemplateResolver(func(ctx context.Context, tenantID, templateID string) (common.TemplateInfo, error) {
+ common.SetTemplateResolver(func(ctx context.Context, db *gorm.DB, tenantID, templateID string) (common.TemplateInfo, error) {
if templateID == "tpl-"+variant {
return common.TemplateInfo{ID: templateID, Kind: variant, Config: map[string]any{}}, nil
}
- return prev(ctx, tenantID, templateID)
+ return prev(ctx, db, tenantID, templateID)
})
t.Cleanup(func() { common.SetTemplateResolver(testTemplateResolver) })
}
-var testGroupResolver common.GroupResolver = func(ctx context.Context, tenantID string, groupIDs []string) ([]string, error) {
+var testGroupResolver common.GroupResolver = func(ctx context.Context, db *gorm.DB, tenantID string, groupIDs []string) ([]string, error) {
return groupIDs, nil
}
diff --git a/internal/ingestion/pipeline/pipeline_knowledge_compiler_dsl_test.go b/internal/ingestion/pipeline/pipeline_knowledge_compiler_dsl_test.go
index 8a73819b54..66b76f356d 100644
--- a/internal/ingestion/pipeline/pipeline_knowledge_compiler_dsl_test.go
+++ b/internal/ingestion/pipeline/pipeline_knowledge_compiler_dsl_test.go
@@ -19,6 +19,7 @@ import (
"fmt"
"os"
"path/filepath"
+ "ragflow/internal/dao"
"testing"
// Named import so this file can drive the runtime factory directly.
@@ -30,20 +31,22 @@ import (
_ "ragflow/internal/ingestion/component/knowledge_compiler"
kc "ragflow/internal/ingestion/component/knowledge_compiler/common"
+
+ "gorm.io/gorm"
)
// installStubResolvers wires in-memory GroupResolver / TemplateResolver stubs so
// the DSL tests can exercise the template-resolution path without MySQL.
func installStubResolvers(t *testing.T, groupToTemplates map[string][]string, templates map[string]kc.TemplateInfo) {
t.Helper()
- kc.SetGroupResolver(func(ctx context.Context, tenantID string, groupIDs []string) ([]string, error) {
+ kc.SetGroupResolver(func(ctx context.Context, db *gorm.DB, tenantID string, groupIDs []string) ([]string, error) {
var out []string
for _, g := range groupIDs {
out = append(out, groupToTemplates[g]...)
}
return out, nil
})
- kc.SetTemplateResolver(func(ctx context.Context, tenantID, templateID string) (kc.TemplateInfo, error) {
+ kc.SetTemplateResolver(func(ctx context.Context, db *gorm.DB, tenantID, templateID string) (kc.TemplateInfo, error) {
info, ok := templates[templateID]
if !ok {
return kc.TemplateInfo{}, fmt.Errorf("no stub template %q", templateID)
@@ -107,6 +110,7 @@ func TestKnowledgeCompilerDSL_FixtureDecodesAndBindsParams(t *testing.T) {
// TemplateResolver seam — without it, resolving the template fails loudly
// rather than compiling with no template config.
func TestKnowledgeCompilerDSL_FrontendDSLDecodesAndConstructs(t *testing.T) {
+ ctx := t.Context()
raw, err := os.ReadFile(filepath.Join(repoRootFromPipelineTest(t), "agent", "templates", "compiler.json"))
if err != nil {
t.Fatalf("read fixture: %v", err)
@@ -144,7 +148,7 @@ func TestKnowledgeCompilerDSL_FrontendDSLDecodesAndConstructs(t *testing.T) {
// Without an installed TemplateResolver, the resolution seam fails loud.
kc.SetTemplateResolver(nil)
- if _, err := kc.ResolveTemplate(context.Background(), "tenant", "t1"); err == nil {
+ if _, err = kc.ResolveTemplate(ctx, dao.DB, "tenant", "t1"); err == nil {
t.Fatal("ResolveTemplate without resolver: expected error")
}
}
@@ -295,7 +299,9 @@ func TestKnowledgeCompilerDSL_ResolveTemplateSeam(t *testing.T) {
"t2": {ID: "t2", Kind: "tree", Config: map[string]any{}},
})
- ids, err := kc.ResolveGroupTemplateIDs(context.Background(), "tenant", []string{"g1"})
+ ctx := t.Context()
+
+ ids, err := kc.ResolveGroupTemplateIDs(ctx, dao.DB, "tenant", []string{"g1"})
if err != nil {
t.Fatalf("ResolveGroupTemplateIDs: %v", err)
}
@@ -303,7 +309,7 @@ func TestKnowledgeCompilerDSL_ResolveTemplateSeam(t *testing.T) {
t.Fatalf("group resolved to %v, want [t1 t2]", ids)
}
- info, err := kc.ResolveTemplate(context.Background(), "tenant", "t1")
+ info, err := kc.ResolveTemplate(ctx, dao.DB, "tenant", "t1")
if err != nil {
t.Fatalf("ResolveTemplate t1: %v", err)
}
diff --git a/internal/ingestion/task/knowledge_compiler_wiring.go b/internal/ingestion/task/knowledge_compiler_wiring.go
index 44ba0ef41a..311e4e1970 100644
--- a/internal/ingestion/task/knowledge_compiler_wiring.go
+++ b/internal/ingestion/task/knowledge_compiler_wiring.go
@@ -30,6 +30,8 @@ import (
"ragflow/internal/entity/models"
kc "ragflow/internal/ingestion/component/knowledge_compiler/common"
"ragflow/internal/service"
+
+ "gorm.io/gorm"
)
// This file is the composition-root wiring for the KnowledgeCompiler ingestion
@@ -58,8 +60,8 @@ func init() {
// on every compiled unit.
func newKnowledgeCompilerGroupResolver() kc.GroupResolver {
tmplDAO := dao.NewCompilationTemplateDAO()
- return func(ctx context.Context, tenantID string, groupIDs []string) ([]string, error) {
- return tmplDAO.ResolveGroupTemplateIDs(ctx, tenantID, groupIDs)
+ return func(ctx context.Context, db *gorm.DB, tenantID string, groupIDs []string) ([]string, error) {
+ return tmplDAO.ResolveGroupTemplateIDs(ctx, db, tenantID, groupIDs)
}
}
@@ -70,8 +72,8 @@ func newKnowledgeCompilerGroupResolver() kc.GroupResolver {
// compilation_template_id would fail loudly at runtime.
func newKnowledgeCompilerTemplateResolver() kc.TemplateResolver {
tmplDAO := dao.NewCompilationTemplateDAO()
- return func(ctx context.Context, tenantID, templateID string) (kc.TemplateInfo, error) {
- t, err := tmplDAO.GetTemplate(ctx, tenantID, templateID)
+ return func(ctx context.Context, db *gorm.DB, tenantID, templateID string) (kc.TemplateInfo, error) {
+ t, err := tmplDAO.GetTemplate(ctx, db, tenantID, templateID)
if err != nil {
return kc.TemplateInfo{}, err
}
diff --git a/internal/service/agent.go b/internal/service/agent.go
index 1e58692119..0c57769f5d 100644
--- a/internal/service/agent.go
+++ b/internal/service/agent.go
@@ -512,7 +512,8 @@ func (s *AgentService) ListAgents(ctx context.Context, userID string, keywords s
for _, item := range items {
canvasIDs = append(canvasIDs, item.ID)
}
- releaseTimes, err := s.versionDAO.GetLatestReleaseTimes(canvasIDs)
+ var releaseTimes map[string]int64
+ releaseTimes, err = s.versionDAO.GetLatestReleaseTimes(ctx, dao.DB, canvasIDs)
if err != nil {
return nil, common.CodeServerError, fmt.Errorf("failed to get release times: %w", err)
}
@@ -675,7 +676,7 @@ func (s *AgentService) GetAgent(ctx context.Context, userID, canvasID string) (*
// released version, or nil when the canvas has never been published.
// Mirrors the last_publish_time computation in Python's get_agent handler.
func (s *AgentService) GetLastPublishTime(ctx context.Context, canvasID string) (*int64, error) {
- version, err := s.versionDAO.GetLatestReleased(canvasID)
+ version, err := s.versionDAO.GetLatestReleased(ctx, dao.DB, canvasID)
if err != nil {
if errors.Is(err, dao.ErrUserCanvasVersionNotFound) {
return nil, nil
diff --git a/internal/service/compilation_template_group_service.go b/internal/service/compilation_template_group_service.go
index 5e06b009ff..2d6bc4bdd6 100644
--- a/internal/service/compilation_template_group_service.go
+++ b/internal/service/compilation_template_group_service.go
@@ -92,7 +92,7 @@ type GroupListItem struct {
// ListSaved returns the tenant's groups with nested templates. Mirrors Python
// list_saved(). total is derived from the full (unpaginated) result set.
func (s *CompilationTemplateGroupService) ListSaved(ctx context.Context, tenantID, keywords, scope, orderby string, desc bool) ([]*GroupListItem, error) {
- groups, err := s.groupDAO.ListSaved(ctx, tenantID, keywords, scope, orderby, desc)
+ groups, err := s.groupDAO.ListSaved(ctx, dao.DB, tenantID, keywords, scope, orderby, desc)
if err != nil {
return nil, err
}
@@ -102,7 +102,7 @@ func (s *CompilationTemplateGroupService) ListSaved(ctx context.Context, tenantI
// GetSaved returns a single group with its nested templates, or nil. Mirrors
// Python get_saved().
func (s *CompilationTemplateGroupService) GetSaved(ctx context.Context, tenantID, groupID string) (*GroupListItem, error) {
- group, err := s.groupDAO.GetSaved(ctx, tenantID, groupID)
+ group, err := s.groupDAO.GetSaved(ctx, dao.DB, tenantID, groupID)
if err != nil || group == nil {
return nil, err
}
@@ -146,7 +146,7 @@ func (s *CompilationTemplateGroupService) CreateGroup(ctx context.Context, tenan
// templates. Mirrors Python update_group(). The field update and child
// reconciliation are committed atomically.
func (s *CompilationTemplateGroupService) UpdateGroup(ctx context.Context, tenantID, groupID string, req *GroupRequest) (*GroupListItem, error) {
- existing, err := s.groupDAO.GetSaved(ctx, tenantID, groupID)
+ existing, err := s.groupDAO.GetSaved(ctx, dao.DB, tenantID, groupID)
if err != nil {
return nil, err
}
@@ -154,11 +154,11 @@ func (s *CompilationTemplateGroupService) UpdateGroup(ctx context.Context, tenan
return nil, nil
}
- if err := validateGroupPayload(req, false); err != nil {
+ if err = validateGroupPayload(req, false); err != nil {
return nil, err
}
- if err := dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err = dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
updates := map[string]interface{}{}
if strings.TrimSpace(req.Name) != "" {
updates["name"] = strings.TrimSpace(req.Name)
@@ -191,17 +191,17 @@ func (s *CompilationTemplateGroupService) UpdateGroup(ctx context.Context, tenan
// DeleteGroup soft-deletes a group and its valid child templates. Mirrors
// Python delete_group(). Returns (false, nil) when the group is missing.
func (s *CompilationTemplateGroupService) DeleteGroup(ctx context.Context, tenantID, groupID string) (bool, error) {
- existing, err := s.groupDAO.GetSaved(ctx, tenantID, groupID)
+ existing, err := s.groupDAO.GetSaved(ctx, dao.DB, tenantID, groupID)
if err != nil {
return false, err
}
if existing == nil {
return false, nil
}
- if err := s.templateDAO.UpdateStatusByGroup(ctx, dao.DB, groupID, string(entity.StatusInvalid)); err != nil {
+ if err = s.templateDAO.UpdateStatusByGroup(ctx, dao.DB, groupID, string(entity.StatusInvalid)); err != nil {
return false, err
}
- if err := s.groupDAO.Delete(ctx, dao.DB, tenantID, groupID); err != nil {
+ if err = s.groupDAO.Delete(ctx, dao.DB, tenantID, groupID); err != nil {
return false, err
}
return true, nil
@@ -224,7 +224,7 @@ func (s *CompilationTemplateGroupService) NameExists(ctx context.Context, tenant
if len(excludeIDs) > 0 {
excludeID = excludeIDs[0]
}
- return s.groupDAO.NameExists(ctx, tenantID, name, excludeID)
+ return s.groupDAO.NameExists(ctx, dao.DB, tenantID, name, excludeID)
}
// ValidateGroupRequest validates the fields present in a group create/update
@@ -368,7 +368,7 @@ func validateGroupPayload(req *GroupRequest, requireAll bool) error {
func (s *CompilationTemplateGroupService) insertChildren(ctx context.Context, db *gorm.DB, tenantID, groupID string, templates []*GroupTemplate, seen map[string]struct{}) error {
for _, child := range templates {
name := strings.TrimSpace(child.Name)
- if exists, err := s.templateDAO.NameExistsInGroup(ctx, tenantID, groupID, name, ""); err != nil {
+ if exists, err := s.templateDAO.NameExistsInGroup(ctx, dao.DB, tenantID, groupID, name, ""); err != nil {
return err
} else if exists {
return groupValidationErrorf("template name '%s' already exists in this group.", name)
diff --git a/internal/service/compilation_template_service.go b/internal/service/compilation_template_service.go
index 81e3805e5e..8b55809c09 100644
--- a/internal/service/compilation_template_service.go
+++ b/internal/service/compilation_template_service.go
@@ -118,15 +118,15 @@ func NewCompilationTemplateService() *CompilationTemplateService {
// LLM id lazily filled in, mirroring the Python list_builtins blueprint flow
// (list from DB; if empty, seed from files and retry; then fill default LLM).
func (s *CompilationTemplateService) ListBuiltins(ctx context.Context, tenantID string) ([]*BuiltinTemplate, error) {
- templates, err := s.templateDAO.ListBuiltins(ctx)
+ templates, err := s.templateDAO.ListBuiltins(ctx, dao.DB)
if err != nil {
return nil, err
}
if len(templates) == 0 {
- if err := s.seedBuiltins(ctx); err != nil {
+ if err = s.seedBuiltins(ctx); err != nil {
return nil, err
}
- templates, err = s.templateDAO.ListBuiltins(ctx)
+ templates, err = s.templateDAO.ListBuiltins(ctx, dao.DB)
if err != nil {
return nil, err
}
@@ -347,7 +347,7 @@ func (s *CompilationTemplateService) seedBuiltins(ctx context.Context) error {
}
func (s *CompilationTemplateService) upsertBuiltin(ctx context.Context, t *entity.CompilationTemplate) error {
- existing, err := s.templateDAO.GetByID(ctx, t.ID)
+ existing, err := s.templateDAO.GetByID(ctx, dao.DB, t.ID)
if errors.Is(err, gorm.ErrRecordNotFound) {
return s.templateDAO.Save(ctx, dao.DB, t)
}
diff --git a/internal/service/dataset/crud.go b/internal/service/dataset/crud.go
index a2889a3203..af10883cac 100644
--- a/internal/service/dataset/crud.go
+++ b/internal/service/dataset/crud.go
@@ -484,7 +484,7 @@ func (d *DatasetService) ListDatasetFilters(ctx context.Context, userID string)
tenantIDs = append(tenantIDs, joinedTenant.TenantID)
}
- owners, err := d.kbDAO.GetOwnerFilter(tenantIDs, userID)
+ owners, err := d.kbDAO.GetOwnerFilter(ctx, dao.DB, tenantIDs, userID)
if err != nil {
return nil, common.CodeServerError, errors.New("database operation failed")
}
diff --git a/internal/service/memory_extractor.go b/internal/service/memory_extractor.go
index d2afc0b85d..9a4250e39a 100644
--- a/internal/service/memory_extractor.go
+++ b/internal/service/memory_extractor.go
@@ -112,8 +112,8 @@ func (s *MemoryMessageService) HandleSaveToMemoryTask(ctx context.Context, paylo
return fmt.Errorf("%w: memory: task %s is already failed", ErrMemoryTaskTerminal, taskID)
}
- if err := s.saveExtractedToMemory(ctx, memoryID, msg, sourceID, taskID); err != nil {
- s.updateTaskProgress(taskID, -1, err.Error())
+ if err = s.saveExtractedToMemory(ctx, memoryID, msg, sourceID, taskID); err != nil {
+ s.updateTaskProgress(ctx, taskID, -1, err.Error())
return fmt.Errorf("%w: %v", ErrMemoryTaskTerminal, err)
}
return nil
@@ -133,7 +133,7 @@ func (s *MemoryMessageService) saveExtractedToMemory(ctx context.Context, memory
}
extractTypes := getTypesToExtract(memoryTypes)
if len(extractTypes) == 0 {
- s.updateTaskProgress(taskID, 1.0, fmt.Sprintf("Memory '%s' don't need to extract.", memoryID))
+ s.updateTaskProgress(ctx, taskID, 1.0, fmt.Sprintf("Memory '%s' don't need to extract.", memoryID))
return nil
}
@@ -142,20 +142,20 @@ func (s *MemoryMessageService) saveExtractedToMemory(ctx context.Context, memory
return err
}
if len(extracted) == 0 {
- s.updateTaskProgress(taskID, 1.0, "No memory extracted from raw message.")
+ s.updateTaskProgress(ctx, taskID, 1.0, "No memory extracted from raw message.")
return nil
}
- s.updateTaskProgress(taskID, 0.5, fmt.Sprintf("Extracted %d messages from raw dialogue.", len(extracted)))
+ s.updateTaskProgress(ctx, taskID, 0.5, fmt.Sprintf("Extracted %d messages from raw dialogue.", len(extracted)))
now := time.Now().UTC()
messages := make([]map[string]any, 0, len(extracted))
for _, item := range extracted {
messages = append(messages, buildExtractedMessage(generateRawMessageID(ctx), sourceID, memoryID, msg, item, now))
}
- if err := s.embedAndSaveMessages(ctx, mem, messages); err != nil {
+ if err = s.embedAndSaveMessages(ctx, mem, messages); err != nil {
return err
}
- s.updateTaskProgress(taskID, 1.0, "Message saved successfully.")
+ s.updateTaskProgress(ctx, taskID, 1.0, "Message saved successfully.")
return nil
}
@@ -195,7 +195,7 @@ func (s *MemoryMessageService) extractByLLM(ctx context.Context, mem *CreateMemo
}
chatModel := models.NewChatModel(driver, &modelName, apiConfig)
- s.updateTaskProgress(taskID, 0.15, "Prepared prompts and LLM.")
+ s.updateTaskProgress(ctx, taskID, 0.15, "Prepared prompts and LLM.")
temperature := mem.Temperature
resp, err := chatModel.ModelDriver.ChatWithMessages(ctx, modelName, messages, apiConfig, &models.ChatConfig{Temperature: &temperature}, nil)
if err != nil {
@@ -204,7 +204,7 @@ func (s *MemoryMessageService) extractByLLM(ctx context.Context, mem *CreateMemo
if resp == nil || resp.Answer == nil {
return nil, errors.New("empty response from chat model")
}
- s.updateTaskProgress(taskID, 0.35, "Get extracted result from LLM.")
+ s.updateTaskProgress(ctx, taskID, 0.35, "Get extracted result from LLM.")
return parseMemoryExtraction(*resp.Answer, extractTypes), nil
}
@@ -294,12 +294,12 @@ func formatMemoryTime(value string, fallback time.Time) string {
// updateTaskProgress stamps and persists task progress, mirroring
// Python TaskService.update_progress call sites. Failures are logged
// and swallowed so progress reporting never breaks extraction.
-func (s *MemoryMessageService) updateTaskProgress(taskID string, progress float64, msg string) {
+func (s *MemoryMessageService) updateTaskProgress(ctx context.Context, taskID string, progress float64, msg string) {
if s == nil || s.taskDAO == nil || taskID == "" {
return
}
stamped := time.Now().Format(memoryTimeLayout) + " " + msg
- if err := s.taskDAO.UpdateProgress(taskID, progress, stamped); err != nil {
+ if err := s.taskDAO.UpdateProgress(ctx, dao.DB, taskID, progress, stamped); err != nil {
common.Warn("memory: update task progress failed", zap.Error(err))
}
}