RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
feat(go): port knowledge compilation template/group + wiki artifact/nav/skill REST APIs from Python (#17656)
Zhichang Yub811dce1b05c
diff --git a/cmd/ragflow_server.go b/cmd/ragflow_server.goindex 1594dd5748..8407707673 100644--- a/cmd/ragflow_server.go+++ b/cmd/ragflow_server.go@@ -833,6 +833,9 @@ func startServer(ctx context.Context) {componentsSvc := service.NewComponentsService()componentsHandler := handler.NewComponentsHandler(componentsSvc)pipelineHandler := handler.NewPipelineHandler()+ compilationTemplateHandler := handler.NewCompilationTemplateHandler(service.NewCompilationTemplateService())+ compilationTemplateGroupHandler := handler.NewCompilationTemplateGroupHandler(service.NewCompilationTemplateGroupService())+ datasetArtifactHandler := handler.NewDatasetArtifactHandler(service.NewDatasetArtifactService(), datasetsService, file.NewFileCommitService())// Initialize routerr := router.NewRouter(authHandler,@@ -865,7 +868,10 @@ func startServer(ctx context.Context) {openaiChatHandler,botHandler,componentsHandler,- pipelineHandler)+ pipelineHandler,+ compilationTemplateHandler,+ compilationTemplateGroupHandler,+ datasetArtifactHandler)// Create Gin engineginEngine := gin.New()diff --git a/internal/dao/compilation_template.go b/internal/dao/compilation_template.goindex 6db5c3613f..634e1eeb2e 100644--- a/internal/dao/compilation_template.go+++ b/internal/dao/compilation_template.go@@ -20,6 +20,8 @@ import ("context""fmt""ragflow/internal/entity"++ "gorm.io/gorm")// CompilationTemplateDAO is the data-access object for compilation templates and@@ -123,3 +125,97 @@ func (dao *CompilationTemplateDAO) GetTemplate(ctx context.Context, tenantID, te}return &t, nil}++// ListByGroup returns the valid compilation templates belonging to a group,+// ordered by create_time asc, mirroring Python+// CompilationTemplateGroupService child loading.+func (dao *CompilationTemplateDAO) ListByGroup(ctx context.Context, db *gorm.DB, groupID string) ([]*entity.CompilationTemplate, error) {+ var templates []*entity.CompilationTemplate+ if err := db.WithContext(ctx).+ Where("group_id = ? AND status = ?", groupID, string(entity.StatusValid)).+ Order("create_time asc").+ Find(&templates).Error; err != nil {+ return nil, err+ }+ return templates, nil+}++// 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) {+ var templates []*entity.CompilationTemplate+ 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 {+ return nil, err+ }+ return templates, nil+}++// 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{}).+ Where("tenant_id = ? AND group_id = ? AND name = ? AND is_builtin = ? AND status = ?",+ tenantID, groupID, name, false, string(entity.StatusValid))+ if excludeID != "" {+ q = q.Where("id <> ?", excludeID)+ }+ var count int64+ if err := q.Count(&count).Error; err != nil {+ return false, err+ }+ return count > 0, nil+}++// 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) {+ var t entity.CompilationTemplate+ if err := DB.WithContext(ctx).Where("id = ?", id).First(&t).Error; err != nil {+ return nil, err+ }+ return &t, nil+}++// Save inserts a new template row.+func (dao *CompilationTemplateDAO) Save(ctx context.Context, db *gorm.DB, t *entity.CompilationTemplate) error {+ return db.WithContext(ctx).Create(t).Error+}++// UpdateFields persists the supplied columns for the template with the given id.+func (dao *CompilationTemplateDAO) UpdateFields(ctx context.Context, db *gorm.DB, id string, m map[string]interface{}) error {+ return db.WithContext(ctx).Model(&entity.CompilationTemplate{}).+ Where("id = ?", id).Updates(m).Error+}++// UpdateStatusByGroup flips the status of every valid template in a group,+// mirroring Python group delete's child cascade.+func (dao *CompilationTemplateDAO) UpdateStatusByGroup(ctx context.Context, db *gorm.DB, groupID, status string) error {+ return db.WithContext(ctx).Model(&entity.CompilationTemplate{}).+ Where("group_id = ? AND status = ?", groupID, string(entity.StatusValid)).+ Update("status", status).Error+}++// UpdateStatusByID flips a single template's status.+func (dao *CompilationTemplateDAO) UpdateStatusByID(ctx context.Context, db *gorm.DB, id, status string) error {+ return db.WithContext(ctx).Model(&entity.CompilationTemplate{}).+ Where("id = ?", id).+ Update("status", status).Error+}++// HardDeleteOrphansByName physically removes stale, invalid, non-built-in+// templates of the given name within the group, mirroring Python+// _purge_stale_invalid_children (which DELETEs orphaned duplicate names after a+// group child is soft-deleted). The deletion is scoped to the group so a+// same-named template in another group is never affected. These rows were+// soft-deleted in a prior operation but must be permanently purged to keep the+// table clean.+func (dao *CompilationTemplateDAO) HardDeleteOrphansByName(ctx context.Context, db *gorm.DB, tenantID, groupID, name string) error {+ return db.WithContext(ctx).Where(+ "tenant_id = ? AND group_id = ? AND name = ? AND is_builtin = ? AND status = ?",+ tenantID, groupID, name, false, string(entity.StatusInvalid),+ ).Delete(&entity.CompilationTemplate{}).Error+}diff --git a/internal/dao/compilation_template_group.go b/internal/dao/compilation_template_group.gonew file mode 100644index 0000000000..8524527525--- /dev/null+++ b/internal/dao/compilation_template_group.go@@ -0,0 +1,109 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package dao++import (+ "context"+ "errors"+ "ragflow/internal/entity"++ "gorm.io/gorm"+)++// CompilationTemplateGroupDAO is the data-access object for compilation template+// groups.+type CompilationTemplateGroupDAO struct{}++// NewCompilationTemplateGroupDAO creates a compilation template group DAO.+func NewCompilationTemplateGroupDAO() *CompilationTemplateGroupDAO {+ return &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).+ Where("(tenant_id = ? OR tenant_id = '') AND status = ?", tenantID, string(entity.StatusValid))+ if keywords != "" {+ q = q.Where("name LIKE ?", "%"+keywords+"%")+ }+ if scope != "" {+ q = q.Where("scope = ?", scope)+ }+ if orderby != "name" && orderby != "scope" && orderby != "create_time" && orderby != "update_time" {+ orderby = "create_time"+ }+ dir := "asc"+ if desc {+ dir = "desc"+ }+ var groups []*entity.CompilationTemplateGroup+ if err := q.Order(orderby + " " + dir).Find(&groups).Error; err != nil {+ return nil, err+ }+ return groups, nil+}++// 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) {+ var g entity.CompilationTemplateGroup+ err := DB.WithContext(ctx).+ Where("(tenant_id = ? OR tenant_id = '') AND id = ? AND status = ?",+ tenantID, groupID, string(entity.StatusValid)).+ First(&g).Error+ if errors.Is(err, gorm.ErrRecordNotFound) {+ return nil, nil+ }+ if err != nil {+ return nil, err+ }+ return &g, nil+}++// 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{}).+ Where("tenant_id = ? AND name = ? AND status = ?", tenantID, name, string(entity.StatusValid))+ if excludeID != "" {+ q = q.Where("id <> ?", excludeID)+ }+ var count int64+ if err := q.Count(&count).Error; err != nil {+ return false, err+ }+ return count > 0, nil+}++// Create inserts a new group row.+func (dao *CompilationTemplateGroupDAO) Create(ctx context.Context, db *gorm.DB, g *entity.CompilationTemplateGroup) error {+ return db.WithContext(ctx).Create(g).Error+}++// UpdateFields persists the supplied columns for the group with the given id.+func (dao *CompilationTemplateGroupDAO) UpdateFields(ctx context.Context, db *gorm.DB, id string, m map[string]interface{}) error {+ return db.WithContext(ctx).Model(&entity.CompilationTemplateGroup{}).+ Where("id = ?", id).Updates(m).Error+}++// Delete soft-deletes a valid group, mirroring Python delete_group().+func (dao *CompilationTemplateGroupDAO) Delete(ctx context.Context, db *gorm.DB, tenantID, groupID string) error {+ return db.WithContext(ctx).Model(&entity.CompilationTemplateGroup{}).+ Where("id = ? AND tenant_id = ? AND status = ?", groupID, tenantID, string(entity.StatusValid)).+ Update("status", string(entity.StatusInvalid)).Error+}diff --git a/internal/dao/file_commit.go b/internal/dao/file_commit.goindex a47c2f8a78..62fc6e15c9 100644--- a/internal/dao/file_commit.go+++ b/internal/dao/file_commit.go@@ -18,11 +18,24 @@ package daoimport ("context"+ "errors""ragflow/internal/entity"+ "strconv""gorm.io/gorm"+ "gorm.io/gorm/clause")+// toInterfaceSlice converts a string slice into an []interface{} for use as+// parameterized query variables.+func toInterfaceSlice(ss []string) []interface{} {+ out := make([]interface{}, len(ss))+ for i := range ss {+ out[i] = ss[i]+ }+ return out+}+// FileCommitDAO file commit data access objecttype FileCommitDAO struct{}@@ -110,6 +123,41 @@ func (dao *FileCommitDAO) ListByFolderID(ctx context.Context, db *gorm.DB, foldereturn commits, total, nil}+// ListByIDs lists commits whose IDs are in the given set, preserving the+// order of commitIDs (most-recent-first for page-edit history). Returns the+// total matched count for pagination.+func (dao *FileCommitDAO) ListByIDs(ctx context.Context, db *gorm.DB, commitIDs []string, page, pageSize int) ([]*entity.FileCommit, int64, error) {+ if len(commitIDs) == 0 {+ return []*entity.FileCommit{}, 0, nil+ }+ var commits []*entity.FileCommit+ var total int64+ query := db.WithContext(ctx).Model(&entity.FileCommit{}).Where("id IN ?", commitIDs)+ if err := query.Count(&total).Error; err != nil {+ return nil, 0, err+ }+ // Preserve the incoming (most-recent-first) order with a parameterized+ // CASE expression rather than a MySQL-specific FIELD() interpolation.+ orderExpr := "CASE id"+ for i := range commitIDs {+ orderExpr += " WHEN ? THEN " + strconv.Itoa(i)+ }+ orderExpr += " END"+ ordered := query.Clauses(clause.OrderBy{Expression: clause.Expr{+ SQL: orderExpr,+ Vars: toInterfaceSlice(commitIDs),+ }})+ // Apply pagination in the query itself so long histories never load the+ // full set into memory before slicing.+ if page > 0 && pageSize > 0 {+ ordered = ordered.Offset((page - 1) * pageSize).Limit(pageSize)+ }+ if err := ordered.Find(&commits).Error; err != nil {+ return nil, 0, err+ }+ return commits, total, nil+}+// FileCommitItemDAO file commit item data access objecttype FileCommitItemDAO struct{}@@ -146,3 +194,24 @@ func (dao *FileCommitItemDAO) GetByCommitIDAndFileID(ctx context.Context, db *go}return &item, nil}++// GetLatestCommitIDByFileID returns the most recent commit_id that modified the+// given wiki page file key, or "" if none. Used to build the parent chain for+// page-edit commits.+func (dao *FileCommitItemDAO) GetLatestCommitIDByFileID(ctx context.Context, db *gorm.DB, fileID string) (string, error) {+ var item entity.FileCommitItem+ err := db.WithContext(ctx).+ Where("file_id = ?", fileID).+ // Order by the monotonic auto-increment sequence so the most recently+ // inserted item is always selected even when multiple edits share the+ // same create_time millisecond.+ Order("seq DESC").+ First(&item).Error+ if err != nil {+ if errors.Is(err, gorm.ErrRecordNotFound) {+ return "", nil+ }+ return "", err+ }+ return item.CommitID, nil+}diff --git a/internal/entity/file_commit.go b/internal/entity/file_commit.goindex 9e98b1c645..9684218d99 100644--- a/internal/entity/file_commit.go+++ b/internal/entity/file_commit.go@@ -38,8 +38,9 @@ func (FileCommit) TableName() string {// FileCommitItem represents a single file change within a commit.type FileCommitItem struct {ID string `gorm:"column:id;primaryKey;size:32" json:"id"`+ Seq uint `gorm:"column:seq;autoIncrement;index" json:"seq,omitempty"`CommitID string `gorm:"column:commit_id;size:32;not null;uniqueIndex:idx_commit_file" json:"commit_id"`- FileID string `gorm:"column:file_id;size:32;not null;uniqueIndex:idx_commit_file" json:"file_id"`+ FileID string `gorm:"column:file_id;size:255;not null;uniqueIndex:idx_commit_file" json:"file_id"`Operation string `gorm:"column:operation;size:16;not null;index" json:"operation"`OldHash *string `gorm:"column:old_hash;size:64;index" json:"old_hash,omitempty"`NewHash *string `gorm:"column:new_hash;size:64;index" json:"new_hash,omitempty"`diff --git a/internal/handler/compilation_template.go b/internal/handler/compilation_template.gonew file mode 100644index 0000000000..ee4f8adb46--- /dev/null+++ b/internal/handler/compilation_template.go@@ -0,0 +1,78 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package handler++import (+ "ragflow/internal/common"+ "ragflow/internal/service"++ "github.com/gin-gonic/gin"+)++// CompilationTemplateHandler serves the knowledge-compilation template REST+// APIs. It mirrors the Python compilation_template_api blueprint.+type CompilationTemplateHandler struct {+ compilationTemplateService *service.CompilationTemplateService+}++// NewCompilationTemplateHandler creates a CompilationTemplateHandler.+func NewCompilationTemplateHandler(svc *service.CompilationTemplateService) *CompilationTemplateHandler {+ return &CompilationTemplateHandler{compilationTemplateService: svc}+}++// ListBuiltins returns the built-in template palette used by the frontend+// "Add template group" panel.+//+// @Summary List built-in compilation templates+// @Tags compilation template+// @Security ApiKeyAuth+// @Success 200 {object} map[string]interface{}+// @Router /v1/compilation-templates/builtins [get]+func (h *CompilationTemplateHandler) ListBuiltins(c *gin.Context) {+ user, code, msg := GetUser(c)+ if code != common.CodeSuccess {+ common.ErrorWithCode(c, code, msg)+ return+ }+ templates, err := h.compilationTemplateService.ListBuiltins(c.Request.Context(), user.ID)+ if err != nil {+ common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())+ return+ }+ common.SuccessWithData(c, templates, "success")+}++// ListWikiPresets returns the wiki page-structure presets loaded from YAML.+//+// @Summary List wiki presets+// @Tags compilation template+// @Security ApiKeyAuth+// @Success 200 {object} map[string]interface{}+// @Router /v1/compilation-templates/wiki-presets [get]+func (h *CompilationTemplateHandler) ListWikiPresets(c *gin.Context) {+ _, code, msg := GetUser(c)+ if code != common.CodeSuccess {+ common.ErrorWithCode(c, code, msg)+ return+ }+ presets, err := h.compilationTemplateService.LoadWikiPresets()+ if err != nil {+ common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())+ return+ }+ common.SuccessWithData(c, presets, "success")+}diff --git a/internal/handler/compilation_template_group.go b/internal/handler/compilation_template_group.gonew file mode 100644index 0000000000..fed392925a--- /dev/null+++ b/internal/handler/compilation_template_group.go@@ -0,0 +1,233 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package handler++import (+ "strconv"++ "ragflow/internal/common"+ "ragflow/internal/service"++ "github.com/gin-gonic/gin"+)++// CompilationTemplateGroupHandler serves the knowledge-compilation template+// group REST APIs. It mirrors the Python compilation_template_group_api blueprint.+type CompilationTemplateGroupHandler struct {+ compilationTemplateGroupService *service.CompilationTemplateGroupService+}++// NewCompilationTemplateGroupHandler creates a CompilationTemplateGroupHandler.+func NewCompilationTemplateGroupHandler(svc *service.CompilationTemplateGroupService) *CompilationTemplateGroupHandler {+ return &CompilationTemplateGroupHandler{compilationTemplateGroupService: svc}+}++// List returns the tenant's compilation template groups with their nested+// templates and pagination.+//+// @Summary List compilation template groups+// @Tags compilation template group+// @Security ApiKeyAuth+// @Param keywords query string false "name keyword filter"+// @Param scope query string false "scope filter (file|dataset)"+// @Param page query int false "page number" default(1)+// @Param page_size query int false "items per page" default(30)+// @Param orderby query string false "order field" default(create_time)+// @Param desc query bool false "descending" default(true)+// @Success 200 {object} map[string]interface{}+// @Router /v1/compilation-template-groups [get]+func (h *CompilationTemplateGroupHandler) List(c *gin.Context) {+ user, code, msg := GetUser(c)+ if code != common.CodeSuccess {+ common.ErrorWithCode(c, code, msg)+ return+ }+ page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))+ pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "30"))+ if page < 1 {+ page = 1+ }+ if pageSize < 1 {+ pageSize = 30+ }+ keywords := c.Query("keywords")+ scope := c.Query("scope")+ orderby := c.DefaultQuery("orderby", "create_time")+ desc := c.DefaultQuery("desc", "true") != "false"++ groups, err := h.compilationTemplateGroupService.ListSaved(c.Request.Context(), user.ID, keywords, scope, orderby, desc)+ if err != nil {+ common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())+ return+ }+ total := len(groups)+ if page > 0 && pageSize > 0 {+ start := (page - 1) * pageSize+ if start >= total {+ groups = []*service.GroupListItem{}+ } else {+ end := start + pageSize+ if end > total {+ end = total+ }+ groups = groups[start:end]+ }+ }+ common.SuccessWithData(c, gin.H{"groups": groups, "total": total}, "success")+}++// Get returns a single compilation template group.+//+// @Summary Get compilation template group+// @Tags compilation template group+// @Security ApiKeyAuth+// @Param group_id path string true "group id"+// @Success 200 {object} map[string]interface{}+// @Router /v1/compilation-template-groups/{group_id} [get]+func (h *CompilationTemplateGroupHandler) Get(c *gin.Context) {+ user, code, msg := GetUser(c)+ if code != common.CodeSuccess {+ common.ErrorWithCode(c, code, msg)+ return+ }+ id := c.Param("group_id")+ group, err := h.compilationTemplateGroupService.GetSaved(c.Request.Context(), user.ID, id)+ if err != nil {+ common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())+ return+ }+ if group == nil {+ common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Cannot find compilation template group "+id+".")+ return+ }+ common.SuccessWithData(c, group, "success")+}++// Save creates a new compilation template group with its child templates.+//+// @Summary Save compilation template group+// @Tags compilation template group+// @Security ApiKeyAuth+// @Param request body service.GroupRequest true "group payload"+// @Success 200 {object} map[string]interface{}+// @Router /v1/compilation-template-groups [post]+func (h *CompilationTemplateGroupHandler) Save(c *gin.Context) {+ user, code, msg := GetUser(c)+ if code != common.CodeSuccess {+ common.ErrorWithCode(c, code, msg)+ return+ }+ var req service.GroupRequest+ if err := c.ShouldBindJSON(&req); err != nil {+ common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Invalid request: "+err.Error())+ return+ }+ if err := service.ValidateGroupRequest(&req); err != nil {+ common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())+ return+ }+ nameExists, err := h.compilationTemplateGroupService.NameExists(c.Request.Context(), user.ID, req.Name)+ if err != nil {+ common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())+ return+ }+ if nameExists {+ common.ResponseWithCodeData(c, common.CodeDataError, nil, "Duplicated compilation template group name.")+ return+ }+ group, err := h.compilationTemplateGroupService.CreateGroup(c.Request.Context(), user.ID, &req)+ if err != nil {+ common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())+ return+ }+ common.SuccessWithData(c, group, "success")+}++// Update applies a partial update to a compilation template group.+//+// @Summary Update compilation template group+// @Tags compilation template group+// @Security ApiKeyAuth+// @Param group_id path string true "group id"+// @Param request body service.GroupRequest true "group payload"+// @Success 200 {object} map[string]interface{}+// @Router /v1/compilation-template-groups/{group_id} [put]+func (h *CompilationTemplateGroupHandler) Update(c *gin.Context) {+ user, code, msg := GetUser(c)+ if code != common.CodeSuccess {+ common.ErrorWithCode(c, code, msg)+ return+ }+ id := c.Param("group_id")+ var req service.GroupRequest+ if err := c.ShouldBindJSON(&req); err != nil {+ common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Invalid request: "+err.Error())+ return+ }+ if err := service.ValidateGroupRequest(&req); err != nil {+ common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())+ return+ }+ if req.Name != "" {+ nameExists, nerr := h.compilationTemplateGroupService.NameExists(c.Request.Context(), user.ID, req.Name, id)+ if nerr != nil {+ common.ResponseWithCodeData(c, common.CodeExceptionError, nil, nerr.Error())+ return+ }+ if nameExists {+ common.ResponseWithCodeData(c, common.CodeDataError, nil, "Duplicated compilation template group name.")+ return+ }+ }+ group, err := h.compilationTemplateGroupService.UpdateGroup(c.Request.Context(), user.ID, id, &req)+ if err != nil {+ common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())+ return+ }+ if group == nil {+ common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Cannot find compilation template group "+id+".")+ return+ }+ common.SuccessWithData(c, group, "success")+}++// Delete soft-deletes a compilation template group and its children.+//+// @Summary Delete compilation template group+// @Tags compilation template group+// @Security ApiKeyAuth+// @Param group_id path string true "group id"+// @Success 200 {object} map[string]interface{}+// @Router /v1/compilation-template-groups/{group_id} [delete]+func (h *CompilationTemplateGroupHandler) Delete(c *gin.Context) {+ user, code, msg := GetUser(c)+ if code != common.CodeSuccess {+ common.ErrorWithCode(c, code, msg)+ return+ }+ id := c.Param("group_id")+ ok, err := h.compilationTemplateGroupService.DeleteGroup(c.Request.Context(), user.ID, id)+ if err != nil {+ common.ResponseWithCodeData(c, common.CodeExceptionError, nil, err.Error())+ return+ }+ if !ok {+ common.ResponseWithCodeData(c, common.CodeNotFound, nil, "Cannot find compilation template group "+id+".")+ return+ }+ common.SuccessWithData(c, true, "success")+}diff --git a/internal/handler/dataset_artifact.go b/internal/handler/dataset_artifact.gonew file mode 100644index 0000000000..5f65d4f3fa--- /dev/null+++ b/internal/handler/dataset_artifact.go@@ -0,0 +1,475 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package handler++import (+ "net/http"+ "strconv"++ "ragflow/internal/common"+ "ragflow/internal/dao"+ "ragflow/internal/entity"+ "ragflow/internal/service"+ dataset "ragflow/internal/service/dataset"+ "ragflow/internal/service/file"++ "github.com/gin-gonic/gin"+ "go.uber.org/zap"+)++// maxArtifactPageSize caps the page_size query parameter for artifact list+// endpoints so a client cannot force an unbounded document-engine search.+const maxArtifactPageSize = 100++// DatasetArtifactHandler exposes the knowledge-compilation artifact REST APIs+// backed by DatasetArtifactService.+type DatasetArtifactHandler struct {+ svc *service.DatasetArtifactService+ datasetSvc *dataset.DatasetService+ fileCommitSvc *file.FileCommitService+}++// NewDatasetArtifactHandler creates a DatasetArtifactHandler.+func NewDatasetArtifactHandler(svc *service.DatasetArtifactService, datasetSvc *dataset.DatasetService, fileCommitSvc *file.FileCommitService) *DatasetArtifactHandler {+ return &DatasetArtifactHandler{svc: svc, datasetSvc: datasetSvc, fileCommitSvc: fileCommitSvc}+}++// datasetOwner resolves the dataset and returns its tenant id. It also enforces+// dataset access permission for the requesting user. When the request is+// unauthenticated, the dataset is missing, or the user is not allowed to access+// it, an error response is written and (nil, "", "") is returned so callers can+// abort without sending a second response.+func (h *DatasetArtifactHandler) datasetOwner(c *gin.Context, datasetID string) (*entity.User, string, string) {+ user, code, msg := GetUser(c)+ if code != common.CodeSuccess {+ common.ErrorWithCode(c, code, msg)+ return nil, "", ""+ }+ kb, err := h.datasetSvc.GetKnowledgebaseByID(c.Request.Context(), datasetID)+ if err != nil {+ if dao.IsNotFoundErr(err) {+ common.ErrorWithCode(c, common.CodeNotFound, "dataset not found")+ } else {+ common.ErrorWithCode(c, common.CodeServerError, "failed to resolve dataset")+ }+ return nil, "", ""+ }+ if kb == nil {+ common.ErrorWithCode(c, common.CodeNotFound, "dataset not found")+ return nil, "", ""+ }+ if !h.datasetSvc.Accessible(c.Request.Context(), datasetID, user.ID) {+ common.ErrorWithCode(c, common.CodeForbidden, "no permission to access this dataset")+ return nil, "", ""+ }+ return user, kb.TenantID, msg+}++// HEAD /artifacts — any wiki artifact present?+func (h *DatasetArtifactHandler) AnyArtifact(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ has, err := h.svc.HasWiki(c.Request.Context(), tenantID, c.Param("dataset_id"))+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ if has {+ c.Status(http.StatusOK)+ } else {+ c.Status(http.StatusNotFound)+ }+}++// GET /artifacts — list wiki pages.+func (h *DatasetArtifactHandler) ListArtifacts(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ datasetID := c.Param("dataset_id")+ pageType := c.Query("page_type")+ topic := c.Query("topic")+ page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))+ pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "30"))+ if page < 1 {+ page = 1+ }+ if pageSize < 1 {+ pageSize = 30+ }+ if pageSize > maxArtifactPageSize {+ pageSize = maxArtifactPageSize+ }+ items, total, err := h.svc.ListWikiPages(c.Request.Context(), tenantID, datasetID, pageType, topic, page, pageSize)+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ common.SuccessWithData(c, gin.H{"total": total, "pages": items}, "success")+}++// PUT /artifacts/<page_type>/<slug> — edit a wiki page.+func (h *DatasetArtifactHandler) UpdateArtifact(c *gin.Context) {+ user, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ datasetID := c.Param("dataset_id")+ pageType := c.Param("page_type")+ slug := c.Param("slug")+ var req struct {+ ContentMd string `json:"content_md"`+ Title string `json:"title"`+ Outlinks []string `json:"outlinks"`+ }+ if err := c.ShouldBindJSON(&req); err != nil {+ common.ErrorWithCode(c, common.CodeArgumentError, err.Error())+ return+ }++ // Read the current page before mutating so an audit commit can record an+ // accurate old-to-new diff. Only record when the prior state was read+ // successfully; a failed read must not produce a diff against an unknown+ // old value.+ var oldContent string+ canRecordAudit := false+ if req.ContentMd != "" {+ before, gerr := h.svc.GetWikiPage(c.Request.Context(), tenantID, datasetID, pageType, slug)+ if gerr != nil {+ common.Warn("failed to read wiki page before recording edit commit", zap.Error(gerr))+ } else if before != nil {+ oldContent = before.ContentMd+ canRecordAudit = true+ }+ }++ detail, err := h.svc.UpdateWikiPage(c.Request.Context(), tenantID, datasetID, pageType, slug, req.ContentMd, req.Title, req.Outlinks)+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ if detail == nil {+ common.ErrorWithCode(c, common.CodeNotFound, "page not found")+ return+ }++ // Record a wiki-page edit audit commit (git-style parent chain) when the+ // content actually changed. Best-effort: a commit write failure must not+ // roll back the page edit already persisted above.+ if canRecordAudit && req.ContentMd != oldContent && h.fileCommitSvc != nil {+ title := req.Title+ if title == "" {+ title = detail.Title+ }+ if _, cerr := h.fileCommitSvc.RecordPageEdit(c.Request.Context(), file.PageEditCommitInput{+ DatasetID: datasetID,+ DocID: pageType + "/" + slug,+ Slug: slug,+ PageType: pageType,+ Title: title,+ AuthorID: user.ID,+ OldContent: oldContent,+ NewContent: req.ContentMd,+ }); cerr != nil {+ common.Warn("failed to record wiki page edit commit", zap.Error(cerr))+ }+ }++ common.SuccessWithData(c, detail, "success")+}++// GET /artifacts/<page_type>/<slug> — single wiki page.+func (h *DatasetArtifactHandler) GetArtifact(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ datasetID := c.Param("dataset_id")+ pageType := c.Param("page_type")+ slug := c.Param("slug")+ detail, err := h.svc.GetWikiPage(c.Request.Context(), tenantID, datasetID, pageType, slug)+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ if detail == nil {+ common.ErrorWithCode(c, common.CodeNotFound, "page not found")+ return+ }+ common.SuccessWithData(c, detail, "success")+}++// DELETE /artifacts — clear all wiki artifacts.+func (h *DatasetArtifactHandler) DeleteArtifacts(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ deleted, err := h.svc.ClearWiki(c.Request.Context(), tenantID, c.Param("dataset_id"))+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ common.SuccessWithData(c, deleted, "success")+}++// GET /artifacts/topics — list wiki topics.+func (h *DatasetArtifactHandler) ListArtifactTopics(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ datasetID := c.Param("dataset_id")+ items, total, err := h.svc.ListWikiTopics(c.Request.Context(), tenantID, datasetID)+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ common.SuccessWithData(c, gin.H{"total": total, "topics": items}, "success")+}++// GET /artifacts/alteration — wiki alteration summary.+func (h *DatasetArtifactHandler) GetArtifactAlteration(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ datasetID := c.Param("dataset_id")+ alt, err := h.svc.GetWikiAlteration(c.Request.Context(), tenantID, datasetID)+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ common.SuccessWithData(c, alt, "success")+}++// GET /artifacts/graph — wiki entity/relation graph.+func (h *DatasetArtifactHandler) GetArtifactGraph(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ datasetID := c.Param("dataset_id")+ graph, err := h.svc.GetWikiGraph(c.Request.Context(), tenantID, datasetID)+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ common.SuccessWithData(c, graph, "success")+}++// GET /artifacts/structure — list compiled structures of a dataset.+func (h *DatasetArtifactHandler) ListStructures(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ datasetID := c.Param("dataset_id")+ structureKind := c.Query("structure_kind")+ structureIndexType := c.Query("structure_index_type")+ items, total, err := h.svc.ListStructures(c.Request.Context(), tenantID, datasetID, structureKind, structureIndexType)+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ common.SuccessWithData(c, gin.H{"total": total, "structures": items}, "success")+}++// DELETE /artifacts/structure — delete compiled structures of a dataset.+func (h *DatasetArtifactHandler) DeleteStructures(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ datasetID := c.Param("dataset_id")+ structureKind := c.Query("structure_kind")+ structureIndexType := c.Query("structure_index_type")+ n, err := h.svc.DeleteStructures(c.Request.Context(), tenantID, datasetID, structureKind, structureIndexType)+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ common.SuccessWithData(c, gin.H{"deleted": n}, "success")+}++// HEAD /skills — any skill artifact present?+func (h *DatasetArtifactHandler) AnySkill(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ has, err := h.svc.HasSkill(c.Request.Context(), tenantID, c.Param("dataset_id"))+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ if has {+ c.Status(http.StatusOK)+ } else {+ c.Status(http.StatusNotFound)+ }+}++// GET /navigation — list navigation clusters.+func (h *DatasetArtifactHandler) ListNavigation(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ items, total, err := h.svc.ListNavClusters(c.Request.Context(), tenantID, c.Param("dataset_id"))+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ common.SuccessWithData(c, gin.H{"total": total, "nav": items}, "success")+}++// DELETE /navigation — delete all navigation clusters.+func (h *DatasetArtifactHandler) DeleteNavigation(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ n, err := h.svc.DeleteNav(c.Request.Context(), tenantID, c.Param("dataset_id"))+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ common.SuccessWithData(c, gin.H{"deleted": n}, "success")+}++// DELETE /navigation/<name> — delete a single navigation cluster.+func (h *DatasetArtifactHandler) DeleteNavigationNode(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ n, err := h.svc.DeleteNavNode(c.Request.Context(), tenantID, c.Param("dataset_id"), c.Param("name"))+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ common.SuccessWithData(c, gin.H{"deleted": n}, "success")+}++// GET /navigation/<name>/children — list children of a navigation cluster.+func (h *DatasetArtifactHandler) ListNavigationChildren(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ items, total, err := h.svc.ListNavChildren(c.Request.Context(), tenantID, c.Param("dataset_id"), c.Param("name"))+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ common.SuccessWithData(c, gin.H{"total": total, "children": items}, "success")+}++// GET /skills — skill tree.+func (h *DatasetArtifactHandler) GetSkillTree(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ kwd := c.Query("kwd")+ items, total, err := h.svc.GetSkillTree(c.Request.Context(), tenantID, c.Param("dataset_id"), kwd)+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ common.SuccessWithData(c, gin.H{"total": total, "tree": items}, "success")+}++// DELETE /skills — delete all skills.+func (h *DatasetArtifactHandler) DeleteSkills(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ n, err := h.svc.DeleteSkills(c.Request.Context(), tenantID, c.Param("dataset_id"), "")+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ common.SuccessWithData(c, gin.H{"deleted": n}, "success")+}++// GET /skills/<skill_kwd> — single skill page.+func (h *DatasetArtifactHandler) GetSkillPage(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ detail, err := h.svc.GetSkillPage(c.Request.Context(), tenantID, c.Param("dataset_id"), c.Param("skill_kwd"))+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ if detail == nil {+ common.ErrorWithCode(c, common.CodeNotFound, "skill not found")+ return+ }+ common.SuccessWithData(c, detail, "success")+}++// DELETE /skills/<skill_kwd> — delete a single skill.+func (h *DatasetArtifactHandler) DeleteSkill(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ n, err := h.svc.DeleteSkills(c.Request.Context(), tenantID, c.Param("dataset_id"), c.Param("skill_kwd"))+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ common.SuccessWithData(c, gin.H{"deleted": n}, "success")+}++// GET /documents/<document_id>/structure/graph — document structure graph.+func (h *DatasetArtifactHandler) GetDocumentGraph(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ datasetID := c.Param("dataset_id")+ documentID := c.Param("document_id")+ graphType := c.Query("graph_type")+ items, total, err := h.svc.GetDocumentGraph(c.Request.Context(), tenantID, datasetID, documentID, graphType)+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ common.SuccessWithData(c, gin.H{"total": total, "graph": items}, "success")+}++// DELETE /documents/<document_id>/structure/graph — delete document structure graph.+func (h *DatasetArtifactHandler) DeleteDocumentGraph(c *gin.Context) {+ _, tenantID, _ := h.datasetOwner(c, c.Param("dataset_id"))+ if tenantID == "" {+ return+ }+ datasetID := c.Param("dataset_id")+ documentID := c.Param("document_id")+ n, err := h.svc.DeleteDocumentGraph(c.Request.Context(), tenantID, datasetID, documentID)+ if err != nil {+ common.ErrorWithCode(c, common.CodeDataError, err.Error())+ return+ }+ common.SuccessWithData(c, gin.H{"deleted": n}, "success")+}diff --git a/internal/handler/file_commit.go b/internal/handler/file_commit.goindex 2da5aef295..2a20bd4a03 100644--- a/internal/handler/file_commit.go+++ b/internal/handler/file_commit.go@@ -38,6 +38,7 @@ type fileCommitService interface {GetCommitTree(ctx context.Context, commitID string) (map[string]interface{}, error)GetCommitFileContent(ctx context.Context, folderID, commitID, fileID string) ([]byte, error)GetFileVersionHistory(ctx context.Context, fileID string) ([]entity.VersionEntry, error)+ ListPageCommits(ctx context.Context, datasetID, pageType, slug string, page, pageSize int) ([]*entity.FileCommit, int64, error)}// FileCommitHandler file commit handler@@ -217,6 +218,49 @@ func (h *FileCommitHandler) ListCommits(c *gin.Context) {}ctx := c.Request.Context()++ // Python's list_commits supports ?slug=<page_slug> to filter audit commits+ // for a specific wiki/skill page (written by record_page_edit). These page+ // commits are scoped to the dataset and page file key, so route them through+ // the page-commit path instead of the folder-based ListCommits. This only+ // applies to the /datasets/{dataset_id}/commits route.+ if slug := c.Query("slug"); slug != "" {+ datasetID := c.Param("dataset_id")+ if datasetID == "" {+ common.ErrorWithCode(c, common.CodeArgumentError, "slug requires a dataset scope")+ return+ }+ pageType := c.Query("page_type")+ commits, total, err := h.commitService.ListPageCommits(ctx, datasetID, pageType, slug, page, pageSize)+ if err != nil {+ jsonInternalError(c, err)+ return+ }+ var commitList []entity.CommitResponse+ for _, commit := range commits {+ var ct int64+ if commit.CreateTime != nil {+ ct = *commit.CreateTime+ }+ commitList = append(commitList, entity.CommitResponse{+ ID: commit.ID,+ FolderID: commit.FolderID,+ ParentID: commit.ParentID,+ Message: commit.Message,+ AuthorID: commit.AuthorID,+ FileCount: commit.FileCount,+ CreateTime: &ct,+ })+ }+ common.SuccessWithData(c, gin.H{+ "total": total,+ "page": page,+ "page_size": pageSize,+ "commits": commitList,+ }, common.CodeSuccess.Message())+ return+ }+commits, total, err := h.commitService.ListCommits(ctx, folderID, page, pageSize, orderBy, desc)if err != nil {jsonInternalError(c, err)diff --git a/internal/handler/file_commit_test.go b/internal/handler/file_commit_test.goindex 76987096f5..a8ecb07e3b 100644--- a/internal/handler/file_commit_test.go+++ b/internal/handler/file_commit_test.go@@ -41,6 +41,7 @@ type mockFileCommitSvc struct {getCommitTreeFn func(ctx context.Context, commitID string) (map[string]interface{}, error)getCommitFileContentFn func(ctx context.Context, folderID, commitID, fileID string) ([]byte, error)getFileVersionHistoryFn func(ctx context.Context, fileID string) ([]entity.VersionEntry, error)+ listPageCommitsFn func(ctx context.Context, datasetID, pageType, slug string, page, pageSize int) ([]*entity.FileCommit, int64, error)}func (m *mockFileCommitSvc) CreateCommit(ctx context.Context, folderID, authorID, message string, changes []entity.FileChange) (*entity.FileCommit, error) {@@ -128,6 +129,13 @@ func (m *mockFileCommitSvc) GetFileVersionHistory(ctx context.Context, fileID st}, nil}+func (m *mockFileCommitSvc) ListPageCommits(ctx context.Context, datasetID, pageType, slug string, page, pageSize int) ([]*entity.FileCommit, int64, error) {+ if m.listPageCommitsFn != nil {+ return m.listPageCommitsFn(ctx, datasetID, pageType, slug, page, pageSize)+ }+ return []*entity.FileCommit{}, 0, nil+}+func setupFileCommitTest(userID string) (*gin.Engine, *mockFileCommitSvc) {mock := &mockFileCommitSvc{}h := &FileCommitHandler{commitService: mock}diff --git a/internal/handler/providers.go b/internal/handler/providers.goindex 9fb4225231..47d479cd43 100644--- a/internal/handler/providers.go+++ b/internal/handler/providers.go@@ -112,7 +112,7 @@ func (h *ProviderHandler) AddProvider(c *gin.Context) {}func (h *ProviderHandler) DeleteProvider(c *gin.Context) {- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return@@ -131,7 +131,7 @@ func (h *ProviderHandler) DeleteProvider(c *gin.Context) {}func (h *ProviderHandler) ShowProvider(c *gin.Context) {- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return@@ -146,7 +146,7 @@ func (h *ProviderHandler) ShowProvider(c *gin.Context) {}func (h *ProviderHandler) ListModels(c *gin.Context) {- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return@@ -221,7 +221,7 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {}func (h *ProviderHandler) ShowModel(c *gin.Context) {- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return@@ -249,7 +249,7 @@ type CreateProviderInstanceRequest struct {}func (h *ProviderHandler) CreateProviderInstance(c *gin.Context) {- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return@@ -287,7 +287,7 @@ func (h *ProviderHandler) CreateProviderInstance(c *gin.Context) {}func (h *ProviderHandler) ListProviderInstances(c *gin.Context) {- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return@@ -306,13 +306,13 @@ func (h *ProviderHandler) ListProviderInstances(c *gin.Context) {}func (h *ProviderHandler) ShowProviderInstance(c *gin.Context) {- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return}- instanceIDOrName := c.Param("instance_name")+ instanceIDOrName := c.Param("instance_id_or_name")if instanceIDOrName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")return@@ -331,13 +331,13 @@ func (h *ProviderHandler) ShowProviderInstance(c *gin.Context) {}func (h *ProviderHandler) ShowInstanceBalance(c *gin.Context) {- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return}- instanceName := c.Param("instance_name")+ instanceName := c.Param("instance_id_or_name")if instanceName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")return@@ -357,7 +357,7 @@ func (h *ProviderHandler) ShowInstanceBalance(c *gin.Context) {}func (h *ProviderHandler) CheckConnection(c *gin.Context) {- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return@@ -382,13 +382,13 @@ func (h *ProviderHandler) CheckConnection(c *gin.Context) {func (h *ProviderHandler) CheckInstanceConnection(c *gin.Context) {ctx := c.Request.Context()- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return}- instanceName := c.Param("instance_name")+ instanceName := c.Param("instance_id_or_name")if instanceName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")return@@ -417,13 +417,13 @@ func (h *ProviderHandler) CheckInstanceConnection(c *gin.Context) {func (h *ProviderHandler) ListTasks(c *gin.Context) {ctx := c.Request.Context()- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return}- instanceName := c.Param("instance_name")+ instanceName := c.Param("instance_id_or_name")if instanceName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")return@@ -443,13 +443,13 @@ func (h *ProviderHandler) ListTasks(c *gin.Context) {func (h *ProviderHandler) ShowTask(c *gin.Context) {ctx := c.Request.Context()- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return}- instanceName := c.Param("instance_name")+ instanceName := c.Param("instance_id_or_name")if instanceName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")return@@ -484,13 +484,13 @@ type AlterProviderInstanceRequest struct {func (h *ProviderHandler) AlterProviderInstance(c *gin.Context) {ctx := c.Request.Context()- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return}- instanceName := c.Param("instance_name")+ instanceName := c.Param("instance_id_or_name")if instanceName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")return@@ -527,7 +527,7 @@ type DropProviderInstanceRequest struct {}func (h *ProviderHandler) DropProviderInstance(c *gin.Context) {- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return@@ -552,12 +552,12 @@ func (h *ProviderHandler) DropProviderInstance(c *gin.Context) {func (h *ProviderHandler) ListInstanceModels(c *gin.Context) {ctx := c.Request.Context()- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return}- instanceName := c.Param("instance_name")+ instanceName := c.Param("instance_id_or_name")if instanceName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")return@@ -600,13 +600,13 @@ type AlterModelRequest struct {}func (h *ProviderHandler) AlterModel(c *gin.Context) {- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return}- instanceName := c.Param("instance_name")+ instanceName := c.Param("instance_id_or_name")if instanceName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")return@@ -691,8 +691,8 @@ func (h *ProviderHandler) AddModel(c *gin.Context) {return}- req.ProviderName = c.Param("provider_name")- req.InstanceName = c.Param("instance_name")+ req.ProviderName = c.Param("provider_id_or_name")+ req.InstanceName = c.Param("instance_id_or_name")if req.ProviderName == "" || req.InstanceName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, common.CodeBadRequest, nil, "provider_name and instance_name are required")@@ -726,12 +726,12 @@ type DropInstanceModelRequest struct {}func (h *ProviderHandler) DropInstanceModels(c *gin.Context) {- providerName := c.Param("provider_name")+ providerName := c.Param("provider_id_or_name")if providerName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Provider name is required")return}- instanceName := c.Param("instance_name")+ instanceName := c.Param("instance_id_or_name")if instanceName == "" {common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Instance name is required")returndiff --git a/internal/handler/providers_test.go b/internal/handler/providers_test.goindex c19f14c61d..77dfda7e72 100644--- a/internal/handler/providers_test.go+++ b/internal/handler/providers_test.go@@ -88,8 +88,8 @@ func TestProviderHandlerAlterModelRejectsMissingModelSelector(t *testing.T) {ctx, recorder := newProviderHandlerRequest(t,map[string]interface{}{"status": "active"},- gin.Param{Key: "provider_name", Value: "OpenAI"},- gin.Param{Key: "instance_name", Value: "default"},+ gin.Param{Key: "provider_id_or_name", Value: "OpenAI"},+ gin.Param{Key: "instance_id_or_name", Value: "default"},)NewProviderHandler(nil, service.NewModelProviderService()).AlterModel(ctx)@@ -107,8 +107,8 @@ func TestProviderHandlerAlterModelRejectsInvalidStatus(t *testing.T) {ctx, recorder := newProviderHandlerRequest(t,map[string]interface{}{"status": "disabled"},- gin.Param{Key: "provider_name", Value: "OpenAI"},- gin.Param{Key: "instance_name", Value: "default"},+ gin.Param{Key: "provider_id_or_name", Value: "OpenAI"},+ gin.Param{Key: "instance_id_or_name", Value: "default"},gin.Param{Key: "model_name", Value: "gpt-test"},)@@ -131,8 +131,8 @@ func TestProviderHandlerAlterModelUpdatesStatus(t *testing.T) {ctx, recorder := newProviderHandlerRequest(t,map[string]interface{}{"status": "inactive"},- gin.Param{Key: "provider_name", Value: "OpenAI"},- gin.Param{Key: "instance_name", Value: "default"},+ gin.Param{Key: "provider_id_or_name", Value: "OpenAI"},+ gin.Param{Key: "instance_id_or_name", Value: "default"},gin.Param{Key: "model_name", Value: "gpt-test"},)diff --git a/internal/router/router.go b/internal/router/router.goindex 5b6115fa19..cc2218d05a 100644--- a/internal/router/router.go+++ b/internal/router/router.go@@ -55,6 +55,10 @@ type Router struct {botHandler *handler.BotHandlercomponentsHandler *handler.ComponentsHandlerpipelineHandler *handler.PipelineHandler++ compilationTemplateHandler *handler.CompilationTemplateHandler+ compilationTemplateGroupHandler *handler.CompilationTemplateGroupHandler+ datasetArtifactHandler *handler.DatasetArtifactHandler}// NewRouter create router@@ -90,6 +94,9 @@ func NewRouter(botHandler *handler.BotHandler,componentsHandler *handler.ComponentsHandler,pipelineHandler *handler.PipelineHandler,+ compilationTemplateHandler *handler.CompilationTemplateHandler,+ compilationTemplateGroupHandler *handler.CompilationTemplateGroupHandler,+ datasetArtifactHandler *handler.DatasetArtifactHandler,) *Router {return &Router{authHandler: authHandler,@@ -123,6 +130,10 @@ func NewRouter(botHandler: botHandler,componentsHandler: componentsHandler,pipelineHandler: pipelineHandler,++ compilationTemplateHandler: compilationTemplateHandler,+ compilationTemplateGroupHandler: compilationTemplateGroupHandler,+ datasetArtifactHandler: datasetArtifactHandler,}}@@ -350,6 +361,32 @@ func (r *Router) Setup(engine *gin.Engine) {datasets.GET("/:dataset_id/index", r.datasetsHandler.TraceIndex)datasets.POST("/:dataset_id/index", r.datasetsHandler.RunIndex)datasets.DELETE("/:dataset_id/index", r.datasetsHandler.DeleteIndex)++ // Knowledge-compilation wiki artifacts+ datasets.HEAD("/:dataset_id/artifacts", r.datasetArtifactHandler.AnyArtifact)+ datasets.GET("/:dataset_id/artifacts", r.datasetArtifactHandler.ListArtifacts)+ datasets.DELETE("/:dataset_id/artifacts", r.datasetArtifactHandler.DeleteArtifacts)+ datasets.GET("/:dataset_id/artifacts/topics", r.datasetArtifactHandler.ListArtifactTopics)+ datasets.GET("/:dataset_id/artifacts/alteration", r.datasetArtifactHandler.GetArtifactAlteration)+ datasets.GET("/:dataset_id/artifacts/graph", r.datasetArtifactHandler.GetArtifactGraph)+ datasets.GET("/:dataset_id/artifacts/:page_type/:slug", r.datasetArtifactHandler.GetArtifact)+ datasets.PUT("/:dataset_id/artifacts/:page_type/:slug", r.datasetArtifactHandler.UpdateArtifact)+ datasets.GET("/:dataset_id/artifacts/structure", r.datasetArtifactHandler.ListStructures)+ datasets.DELETE("/:dataset_id/artifacts/structure", r.datasetArtifactHandler.DeleteStructures)++ // Knowledge-compilation navigation+ datasets.GET("/:dataset_id/navigation", r.datasetArtifactHandler.ListNavigation)+ datasets.DELETE("/:dataset_id/navigation", r.datasetArtifactHandler.DeleteNavigation)+ datasets.DELETE("/:dataset_id/navigation/:name", r.datasetArtifactHandler.DeleteNavigationNode)+ datasets.GET("/:dataset_id/navigation/:name/children", r.datasetArtifactHandler.ListNavigationChildren)++ // Knowledge-compilation skills+ datasets.HEAD("/:dataset_id/skills", r.datasetArtifactHandler.AnySkill)+ datasets.GET("/:dataset_id/skills", r.datasetArtifactHandler.GetSkillTree)+ datasets.DELETE("/:dataset_id/skills", r.datasetArtifactHandler.DeleteSkills)+ datasets.GET("/:dataset_id/skills/:skill_kwd", r.datasetArtifactHandler.GetSkillPage)+ datasets.DELETE("/:dataset_id/skills/:skill_kwd", r.datasetArtifactHandler.DeleteSkill)+datasets.DELETE("/:dataset_id/:index_type", r.datasetsHandler.DeleteIndex)//datasets.DELETE("/:dataset_id/graph", r.datasetsHandler.DeleteKnowledgeGraph)datasets.POST("", r.datasetsHandler.CreateDataset)@@ -391,6 +428,8 @@ func (r *Router) Setup(engine *gin.Engine) {datasets.DELETE("/:dataset_id/chunks", r.chunkHandler.StopParsing)datasets.DELETE("/:dataset_id/documents/:document_id/chunks", r.chunkHandler.RemoveChunks)datasets.PUT("/:dataset_id/documents/:document_id/metadata/config", r.datasetsHandler.UpdateDocumentMetadataConfig)+ datasets.GET("/:dataset_id/documents/:document_id/structure/graph", r.datasetArtifactHandler.GetDocumentGraph)+ datasets.DELETE("/:dataset_id/documents/:document_id/structure/graph", r.datasetArtifactHandler.DeleteDocumentGraph)datasets.POST("/:dataset_id/metadata/update", r.documentHandler.MetadataBatchUpdate)datasets.PATCH("/:dataset_id/documents/metadatas", r.documentHandler.UpdateDocumentMetadatas)}@@ -517,24 +556,24 @@ func (r *Router) Setup(engine *gin.Engine) {{provider.GET("", r.providerHandler.ListProviders)provider.PUT("", r.providerHandler.AddProvider)- provider.GET("/:provider_name", r.providerHandler.ShowProvider)- provider.DELETE("/:provider_name", r.providerHandler.DeleteProvider)- provider.GET("/:provider_name/models", r.providerHandler.ListModels)- provider.GET("/:provider_name/models/:model_name", r.providerHandler.ShowModel)- provider.POST("/:provider_name/instances", r.providerHandler.CreateProviderInstance)- provider.GET("/:provider_name/instances", r.providerHandler.ListProviderInstances)- provider.GET("/:provider_name/instances/:instance_name", r.providerHandler.ShowProviderInstance)- provider.GET("/:provider_name/instances/:instance_name/balance", r.providerHandler.ShowInstanceBalance)- provider.GET("/:provider_name/instances/:instance_name/connection", r.providerHandler.CheckInstanceConnection)- provider.POST("/:provider_name/connection", r.providerHandler.CheckConnection)- provider.GET("/:provider_name/instances/:instance_name/tasks", r.providerHandler.ListTasks)- provider.GET("/:provider_name/instances/:instance_name/tasks/:task_id", r.providerHandler.ShowTask)- provider.PUT("/:provider_name/instances/:instance_name", r.providerHandler.AlterProviderInstance)- provider.DELETE("/:provider_name/instances", r.providerHandler.DropProviderInstance)- provider.GET("/:provider_name/instances/:instance_name/models", r.providerHandler.ListInstanceModels)- provider.PATCH("/:provider_name/instances/:instance_name/models/*model_name", r.providerHandler.AlterModel)- provider.POST("/:provider_name/instances/:instance_name/models", r.providerHandler.AddModel)- provider.DELETE("/:provider_name/instances/:instance_name/models", r.providerHandler.DropInstanceModels)+ provider.GET("/:provider_id_or_name", r.providerHandler.ShowProvider)+ provider.DELETE("/:provider_id_or_name", r.providerHandler.DeleteProvider)+ provider.GET("/:provider_id_or_name/models", r.providerHandler.ListModels)+ provider.GET("/:provider_id_or_name/models/:model_name", r.providerHandler.ShowModel)+ provider.POST("/:provider_id_or_name/instances", r.providerHandler.CreateProviderInstance)+ provider.GET("/:provider_id_or_name/instances", r.providerHandler.ListProviderInstances)+ provider.GET("/:provider_id_or_name/instances/:instance_id_or_name", r.providerHandler.ShowProviderInstance)+ provider.GET("/:provider_id_or_name/instances/:instance_id_or_name/balance", r.providerHandler.ShowInstanceBalance)+ provider.GET("/:provider_id_or_name/instances/:instance_id_or_name/connection", r.providerHandler.CheckInstanceConnection)+ provider.POST("/:provider_id_or_name/connection", r.providerHandler.CheckConnection)+ provider.GET("/:provider_id_or_name/instances/:instance_id_or_name/tasks", r.providerHandler.ListTasks)+ provider.GET("/:provider_id_or_name/instances/:instance_id_or_name/tasks/:task_id", r.providerHandler.ShowTask)+ provider.PUT("/:provider_id_or_name/instances/:instance_id_or_name", r.providerHandler.AlterProviderInstance)+ provider.DELETE("/:provider_id_or_name/instances", r.providerHandler.DropProviderInstance)+ provider.GET("/:provider_id_or_name/instances/:instance_id_or_name/models", r.providerHandler.ListInstanceModels)+ provider.PATCH("/:provider_id_or_name/instances/:instance_id_or_name/models/*model_name", r.providerHandler.AlterModel)+ provider.POST("/:provider_id_or_name/instances/:instance_id_or_name/models", r.providerHandler.AddModel)+ provider.DELETE("/:provider_id_or_name/instances/:instance_id_or_name/models", r.providerHandler.DropInstanceModels)v1.POST("/chat/to_model", r.providerHandler.ChatToModel)v1.POST("/embeddings", r.providerHandler.EmbedText)v1.POST("/rerank", r.providerHandler.RerankDocument)@@ -581,6 +620,17 @@ func (r *Router) Setup(engine *gin.Engine) {// runtime.DefaultRegistry.v1.GET("/components", r.componentsHandler.Get)+ // Compilation template routes+ v1.GET("/compilation-templates/builtins", r.compilationTemplateHandler.ListBuiltins)+ v1.GET("/compilation-templates/wiki-presets", r.compilationTemplateHandler.ListWikiPresets)++ // Compilation template group routes+ v1.GET("/compilation-template-groups", r.compilationTemplateGroupHandler.List)+ v1.POST("/compilation-template-groups", r.compilationTemplateGroupHandler.Save)+ v1.GET("/compilation-template-groups/:group_id", r.compilationTemplateGroupHandler.Get)+ v1.PUT("/compilation-template-groups/:group_id", r.compilationTemplateGroupHandler.Update)+ v1.DELETE("/compilation-template-groups/:group_id", r.compilationTemplateGroupHandler.Delete)+connectors := v1.Group("/connectors"){connectors.GET("", r.connectorHandler.ListConnectors)diff --git a/internal/service/compilation_template_group_service.go b/internal/service/compilation_template_group_service.gonew file mode 100644index 0000000000..5e06b009ff--- /dev/null+++ b/internal/service/compilation_template_group_service.go@@ -0,0 +1,494 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package service++import (+ "context"+ "fmt"+ "strings"+ "time"++ "ragflow/internal/dao"+ "ragflow/internal/entity"+ "ragflow/internal/utility"++ "gorm.io/gorm"+)++// timeStr formats a Unix-millisecond timestamp for the read-side JSON payloads.+func timeStr(ms *int64) string {+ if ms == nil {+ return ""+ }+ return time.UnixMilli(*ms).UTC().Format("2006-01-02 15:04:05")+}++const (+ groupScopeFile = "file"+ groupScopeDataset = "dataset"+ // maxGroupNameLen is the DB column size for compilation_template_group.name.+ maxGroupNameLen = 128+)++// GroupTemplate is a child-template entry in a group create/update payload.+type GroupTemplate struct {+ ID string `json:"id,omitempty"`+ Name string `json:"name,omitempty"`+ Description string `json:"description,omitempty"`+ Kind string `json:"kind,omitempty"`+ Config entity.JSONMap `json:"config,omitempty"`+}++// GroupRequest is the create/update payload for a compilation template group.+type GroupRequest struct {+ Name string `json:"name,omitempty"`+ Description string `json:"description,omitempty"`+ Templates []*GroupTemplate `json:"templates,omitempty"`+}++// CompilationTemplateGroupService implements the knowledge-compilation template+// group REST operations, mirroring the Python CompilationTemplateGroupService.+type CompilationTemplateGroupService struct {+ groupDAO *dao.CompilationTemplateGroupDAO+ templateDAO *dao.CompilationTemplateDAO+ tenantDAO *dao.TenantDAO+}++// NewCompilationTemplateGroupService creates a CompilationTemplateGroupService.+func NewCompilationTemplateGroupService() *CompilationTemplateGroupService {+ return &CompilationTemplateGroupService{+ groupDAO: dao.NewCompilationTemplateGroupDAO(),+ templateDAO: dao.NewCompilationTemplateDAO(),+ tenantDAO: dao.NewTenantDAO(),+ }+}++// GroupListItem is the read-side representation of a group with its nested+// templates, mirroring Python _group_to_dict.+type GroupListItem struct {+ ID string `json:"id"`+ Name string `json:"name"`+ Description string `json:"description"`+ Scope string `json:"scope"`+ CreateTime string `json:"create_time,omitempty"`+ UpdateTime string `json:"update_time,omitempty"`+ Templates []*TemplateListItem `json:"templates"`+}++// 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)+ if err != nil {+ return nil, err+ }+ return s.buildGroupItems(ctx, tenantID, groups)+}++// 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)+ if err != nil || group == nil {+ return nil, err+ }+ return s.buildGroupItem(ctx, tenantID, group)+}++// CreateGroup creates a group plus its child templates. Mirrors Python+// create_group(). It returns a GroupValidationError for payload/scope problems.+// The group and all child writes are committed atomically so a mid-way failure+// cannot leave a partially-populated group behind.+func (s *CompilationTemplateGroupService) CreateGroup(ctx context.Context, tenantID string, req *GroupRequest) (*GroupListItem, error) {+ if err := validateGroupPayload(req, true); err != nil {+ return nil, err+ }+ scope, err := s.deriveScope(req.Templates)+ if err != nil {+ return nil, err+ }++ groupID := utility.GenerateUUID()+ if err := dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ group := &entity.CompilationTemplateGroup{+ ID: groupID,+ TenantID: tenantID,+ Name: strings.TrimSpace(req.Name),+ Description: strptr(req.Description),+ Scope: scope,+ Status: strptr(string(entity.StatusValid)),+ }+ if cerr := s.groupDAO.Create(ctx, tx, group); cerr != nil {+ return cerr+ }+ return s.insertChildren(ctx, tx, tenantID, groupID, req.Templates, nil)+ }); err != nil {+ return nil, err+ }+ return s.GetSaved(ctx, tenantID, groupID)+}++// UpdateGroup applies a partial update to a group and reconciles its child+// 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)+ if err != nil {+ return nil, err+ }+ if existing == nil {+ return nil, nil+ }++ if err := validateGroupPayload(req, false); err != nil {+ return nil, err+ }++ 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)+ }+ if req.Description != "" {+ updates["description"] = req.Description+ }+ if req.Templates != nil {+ scope, serr := s.deriveScope(req.Templates)+ if serr != nil {+ return serr+ }+ updates["scope"] = scope+ }+ if len(updates) > 0 {+ if uerr := s.groupDAO.UpdateFields(ctx, tx, groupID, updates); uerr != nil {+ return uerr+ }+ }+ if req.Templates != nil {+ return s.reconcileChildren(ctx, tx, tenantID, groupID, req.Templates)+ }+ return nil+ }); err != nil {+ return nil, err+ }+ return s.GetSaved(ctx, tenantID, groupID)+}++// 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)+ 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 {+ return false, err+ }+ if err := s.groupDAO.Delete(ctx, dao.DB, tenantID, groupID); err != nil {+ return false, err+ }+ return true, nil+}++// GroupValidationError is returned for group payload/scope problems so handlers+// can map it to a 400 without an HTTP 500.+type GroupValidationError struct{ msg string }++func (e *GroupValidationError) Error() string { return e.msg }++func groupValidationErrorf(format string, a ...interface{}) error {+ return &GroupValidationError{msg: fmt.Sprintf(format, a...)}+}++// NameExists reports whether a valid group with the given name exists for the+// tenant (optionally excluding excludeID), mirroring Python name_exists().+func (s *CompilationTemplateGroupService) NameExists(ctx context.Context, tenantID, name string, excludeIDs ...string) (bool, error) {+ excludeID := ""+ if len(excludeIDs) > 0 {+ excludeID = excludeIDs[0]+ }+ return s.groupDAO.NameExists(ctx, tenantID, name, excludeID)+}++// ValidateGroupRequest validates the fields present in a group create/update+// payload before any DB write, mirroring the Python blueprint+// _validate_group_payload. Required-field enforcement for create happens inside+// CreateGroup (require_all=True).+func ValidateGroupRequest(req *GroupRequest) error {+ return validateGroupPayload(req, false)+}++// buildGroupItems loads child templates for many groups at once.+func (s *CompilationTemplateGroupService) buildGroupItems(ctx context.Context, tenantID string, groups []*entity.CompilationTemplateGroup) ([]*GroupListItem, error) {+ items := make([]*GroupListItem, 0, len(groups))+ for _, g := range groups {+ item, err := s.buildGroupItem(ctx, tenantID, g)+ if err != nil {+ return nil, err+ }+ items = append(items, item)+ }+ return items, nil+}++func (s *CompilationTemplateGroupService) buildGroupItem(ctx context.Context, tenantID string, group *entity.CompilationTemplateGroup) (*GroupListItem, error) {+ children, err := s.templateDAO.ListByGroup(ctx, dao.DB, group.ID)+ if err != nil {+ return nil, err+ }+ items := make([]*TemplateListItem, 0, len(children))+ for _, c := range children {+ items = append(items, &TemplateListItem{+ ID: c.ID,+ Name: c.Name,+ Description: derefString(c.Description),+ Kind: c.Kind,+ Config: fillConfigDefaultLLM(ctx, s.tenantDAO, c.Config, c.TenantID),+ CreateTime: timeStr(c.CreateTime),+ UpdateTime: timeStr(c.UpdateTime),+ })+ }+ return &GroupListItem{+ ID: group.ID,+ Name: group.Name,+ Description: derefString(group.Description),+ Scope: group.Scope,+ CreateTime: timeStr(group.CreateTime),+ UpdateTime: timeStr(group.UpdateTime),+ Templates: items,+ }, nil+}++// deriveScope mirrors Python _derive_scope: one wiki child => dataset scope,+// otherwise file scope (with a wiki-combination guard and re-chunk tree guard).+func (s *CompilationTemplateGroupService) deriveScope(templates []*GroupTemplate) (string, error) {+ if len(templates) == 0 {+ return "", groupValidationErrorf("a template group must contain at least one template.")+ }+ artifactCount := 0+ for _, t := range templates {+ if strings.TrimSpace(t.Kind) == "wiki" {+ artifactCount+++ }+ }+ if artifactCount > 0 {+ if artifactCount != 1 || len(templates) != 1 {+ return "", groupValidationErrorf("a wiki template cannot be combined with other templates in the same group.")+ }+ return groupScopeDataset, nil+ }+ if err := s.enforceSingleRechunkTree(templates); err != nil {+ return "", err+ }+ return groupScopeFile, nil+}++// enforceSingleRechunkTree mirrors Python _enforce_single_rechunk_tree.+func (s *CompilationTemplateGroupService) enforceSingleRechunkTree(templates []*GroupTemplate) error {+ rechunkTrees := 0+ for _, t := range templates {+ if strings.TrimSpace(t.Kind) != "tree" {+ continue+ }+ raptor, _ := t.Config["raptor"].(map[string]interface{})+ if b, ok := raptor["rechunk"].(bool); ok && b {+ rechunkTrees+++ }+ }+ if rechunkTrees > 1 {+ return groupValidationErrorf("only one tree template in a group may enable re-chunking.")+ }+ return nil+}++// validateGroupPayload mirrors Python _validate_group_payload in the group+// blueprint.+func validateGroupPayload(req *GroupRequest, requireAll bool) error {+ if requireAll {+ if strings.TrimSpace(req.Name) == "" {+ return groupValidationErrorf("missing required field: name.")+ }+ if len(req.Templates) == 0 {+ return groupValidationErrorf("missing required field: templates.")+ }+ }+ if strings.TrimSpace(req.Name) != "" {+ if len([]byte(req.Name)) > maxGroupNameLen {+ return groupValidationErrorf("template group name is too long.")+ }+ }+ if len(req.Description) > 1024 {+ return groupValidationErrorf("invalid template group description.")+ }+ if req.Templates != nil {+ if len(req.Templates) == 0 {+ return groupValidationErrorf("a template group must contain at least one template.")+ }+ seen := map[string]struct{}{}+ for _, child := range req.Templates {+ if child == nil {+ return groupValidationErrorf("invalid template entry in group.")+ }+ payload := map[string]interface{}{+ "name": child.Name, "description": child.Description,+ "kind": child.Kind, "config": child.Config,+ }+ if err := ValidateTemplatePayload(payload, true); err != nil {+ return err+ }+ name := strings.TrimSpace(child.Name)+ if _, dup := seen[name]; dup {+ return groupValidationErrorf("template name '%s' is duplicated in this group.", name)+ }+ seen[name] = struct{}{}+ }+ }+ return nil+}++// insertChildren inserts new child templates. usedForReconcile controls whether+// the duplicate-name guard applies (create always; reconcile passes seen set).+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 {+ return err+ } else if exists {+ return groupValidationErrorf("template name '%s' already exists in this group.", name)+ }+ desc := child.Description+ config := fillConfigDefaultLLM(ctx, s.tenantDAO, child.Config, &tenantID)+ if config == nil {+ config = entity.JSONMap{}+ }+ valid := string(entity.StatusValid)+ tmpl := &entity.CompilationTemplate{+ ID: utility.GenerateUUID(),+ TenantID: &tenantID,+ GroupID: &groupID,+ Name: name,+ Kind: strings.TrimSpace(child.Kind),+ Config: config,+ Status: &valid,+ }+ if desc != "" {+ tmpl.Description = &desc+ }+ if err := s.templateDAO.Save(ctx, db, tmpl); err != nil {+ return err+ }+ }+ return nil+}++// reconcileChildren mirrors the Python update_group child reconciliation:+// existing children (matched by id, or by submitted order for legacy clients)+// are updated in place, new ones inserted, and removed ones soft-deleted.+func (s *CompilationTemplateGroupService) reconcileChildren(ctx context.Context, db *gorm.DB, tenantID, groupID string, templates []*GroupTemplate) error {+ current, err := s.templateDAO.ListByGroup(ctx, db, groupID)+ if err != nil {+ return err+ }+ currentByID := map[string]*entity.CompilationTemplate{}+ for _, c := range current {+ currentByID[c.ID] = c+ }+ seenNames := map[string]struct{}{}+ retained := map[string]struct{}{}++ for index, child := range templates {+ name := strings.TrimSpace(child.Name)+ if _, dup := seenNames[name]; dup {+ return groupValidationErrorf("template name '%s' is duplicated in this group.", name)+ }+ seenNames[name] = struct{}{}++ var target *entity.CompilationTemplate+ if child.ID != "" {+ target = currentByID[child.ID]+ if target == nil {+ return groupValidationErrorf("template %s does not belong to this group.", child.ID)+ }+ } else if index < len(current) {+ // Positional fallback for legacy clients that omit IDs. Skip rows+ // already retained by an explicit ID above so a mixed payload cannot+ // bind two submitted entries to one existing row.+ if _, taken := retained[current[index].ID]; !taken {+ target = current[index]+ }+ }++ config := fillConfigDefaultLLM(ctx, s.tenantDAO, child.Config, &tenantID)+ if config == nil {+ config = entity.JSONMap{}+ }+ desc := child.Description+ if target != nil {+ updates := map[string]interface{}{+ "name": name, "kind": strings.TrimSpace(child.Kind), "config": config,+ }+ if desc != "" {+ updates["description"] = desc+ }+ if err := s.templateDAO.UpdateFields(ctx, db, target.ID, updates); err != nil {+ return err+ }+ retained[target.ID] = struct{}{}+ continue+ }+ newID := utility.GenerateUUID()+ valid := string(entity.StatusValid)+ tmpl := &entity.CompilationTemplate{+ ID: newID,+ TenantID: &tenantID,+ GroupID: &groupID,+ Name: name,+ Kind: strings.TrimSpace(child.Kind),+ Config: config,+ Status: &valid,+ }+ if desc != "" {+ tmpl.Description = &desc+ }+ if err := s.templateDAO.Save(ctx, db, tmpl); err != nil {+ return err+ }+ retained[newID] = struct{}{}+ }++ for _, c := range current {+ if _, keep := retained[c.ID]; !keep {+ if err := s.templateDAO.UpdateStatusByID(ctx, db, c.ID, string(entity.StatusInvalid)); err != nil {+ return err+ }+ // Mirror Python _purge_stale_invalid_children: permanently drop+ // any stale invalid non-builtin template of the same name, scoped to+ // this group so a same-named template in another group is untouched.+ if c.Name != "" && !c.IsBuiltin {+ if err := s.templateDAO.HardDeleteOrphansByName(ctx, db, tenantID, groupID, c.Name); err != nil {+ return err+ }+ }+ }+ }+ return nil+}++func strptr(s string) *string { return &s }diff --git a/internal/service/compilation_template_service.go b/internal/service/compilation_template_service.gonew file mode 100644index 0000000000..bbe04fe04b--- /dev/null+++ b/internal/service/compilation_template_service.go@@ -0,0 +1,379 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package service++import (+ "context"+ "errors"+ "fmt"+ "os"+ "path/filepath"+ "sort"+ "strings"+ "unicode"++ "ragflow/internal/dao"+ "ragflow/internal/entity"+ "ragflow/internal/utility"++ "gopkg.in/yaml.v3"+ "gorm.io/gorm"+)++// fillConfigDefaultLLM mirrors Python CompilationTemplateService.+// fill_config_default_llm: when the config has no explicit llm_id it lazily+// fills the tenant's default chat model id (read-side only; the DB row is left+// untouched).+func fillConfigDefaultLLM(ctx context.Context, tenantDAO *dao.TenantDAO, config entity.JSONMap, tenantID *string) entity.JSONMap {+ if len(config) == 0 || tenantID == nil || *tenantID == "" {+ return config+ }+ if _, ok := config["llm_id"]; ok {+ return config+ }+ tenant, err := tenantDAO.GetByID(ctx, dao.DB, *tenantID)+ if err != nil || tenant == nil || tenant.TenantLLMID == nil {+ return config+ }+ out := make(entity.JSONMap, len(config)+1)+ for k, v := range config {+ out[k] = v+ }+ out["llm_id"] = *tenant.TenantLLMID+ return out+}++// capitalizeTitle capitalizes the first letter of a lowercase section name for+// error messages (replaces deprecated strings.Title).+func capitalizeTitle(s string) string {+ if s == "" {+ return s+ }+ r := []rune(s)+ r[0] = unicode.ToUpper(r[0])+ return string(r)+}++// TemplateListItem is the read-side representation of a compilation template,+// mirroring Python CompilationTemplateService._to_saved_dict.+type TemplateListItem struct {+ ID string `json:"id"`+ Name string `json:"name"`+ Description string `json:"description"`+ Kind string `json:"kind"`+ Config entity.JSONMap `json:"config"`+ CreateTime string `json:"create_time,omitempty"`+ UpdateTime string `json:"update_time,omitempty"`+}++// BuiltinTemplate is the palette representation of a built-in template,+// mirroring Python CompilationTemplateService._to_builtin_dict.+type BuiltinTemplate struct {+ ID string `json:"id"`+ Kind string `json:"kind"`+ DisplayName string `json:"display_name"`+ Description string `json:"description"`+ Config entity.JSONMap `json:"config"`+}++// WikiPreset is a wiki page-structure preset loaded from YAML, mirroring+// Python load_wiki_presets_from_files.+type WikiPreset struct {+ ID string `json:"id"`+ Topic string `json:"topic"`+ Instruction string `json:"instruction"`+ PageExample string `json:"page_example"`+}++// CompilationTemplateService implements the read-side compilation template+// operations (builtins palette + wiki presets) used by the REST APIs.+type CompilationTemplateService struct {+ templateDAO *dao.CompilationTemplateDAO+ tenantDAO *dao.TenantDAO+}++// NewCompilationTemplateService creates a CompilationTemplateService.+func NewCompilationTemplateService() *CompilationTemplateService {+ return &CompilationTemplateService{+ templateDAO: dao.NewCompilationTemplateDAO(),+ tenantDAO: dao.NewTenantDAO(),+ }+}++// ListBuiltins returns the built-in template palette with the tenant's default+// 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)+ if err != nil {+ return nil, err+ }+ if len(templates) == 0 {+ if err := s.seedBuiltins(ctx); err != nil {+ return nil, err+ }+ templates, err = s.templateDAO.ListBuiltins(ctx)+ if err != nil {+ return nil, err+ }+ }+ out := make([]*BuiltinTemplate, 0, len(templates))+ for _, t := range templates {+ config := fillConfigDefaultLLM(ctx, s.tenantDAO, t.Config, t.TenantID)+ out = append(out, &BuiltinTemplate{+ ID: t.ID,+ Kind: t.Kind,+ DisplayName: t.Name,+ Description: derefString(t.Description),+ Config: config,+ })+ }+ return s.sortBuiltins(out), nil+}++// LoadWikiPresets loads the wiki page-structure presets from the+// init_data/compilation_templates/wiki/*.yaml files, filesystem-fresh per call.+func (s *CompilationTemplateService) LoadWikiPresets() ([]*WikiPreset, error) {+ wikiDir := filepath.Join(utility.GetProjectBaseDirectory(),+ "api", "db", "init_data", "compilation_templates", "wiki")+ entries, err := os.ReadDir(wikiDir)+ if err != nil {+ if os.IsNotExist(err) {+ return []*WikiPreset{}, nil+ }+ return nil, err+ }+ var presets []*WikiPreset+ for _, entry := range entries {+ if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".yaml") && !strings.HasSuffix(entry.Name(), ".yml") {+ continue+ }+ path := filepath.Join(wikiDir, entry.Name())+ data, rerr := os.ReadFile(path)+ if rerr != nil {+ continue+ }+ var doc map[string]interface{}+ if yerr := yaml.Unmarshal(data, &doc); yerr != nil || doc == nil {+ continue+ }+ presets = append(presets, &WikiPreset{+ ID: strings.TrimSuffix(entry.Name(), filepath.Ext(entry.Name())),+ Topic: strings.TrimSpace(yamlStr(doc["topic"])),+ Instruction: yamlStr(doc["instruction"]),+ PageExample: yamlStr(doc["page_example"]),+ })+ }+ return presets, nil+}++// ValidateTemplatePayload validates a single template payload, mirroring the+// Python compilation_template_validation module. It returns an error describing+// the first problem found.+func ValidateTemplatePayload(req map[string]interface{}, requireAll bool) error {+ if requireAll {+ for _, key := range []string{"name", "kind", "config"} {+ if _, ok := req[key]; !ok {+ return fmt.Errorf("missing required field: %s.", key)+ }+ }+ }+ if name, ok := req["name"]; ok {+ nameStr, ok2 := name.(string)+ if !ok2 || strings.TrimSpace(nameStr) == "" || len([]byte(nameStr)) > 128 {+ return errors.New("invalid template name.")+ }+ }+ if desc, ok := req["description"]; ok {+ if descStr, ok2 := desc.(string); !ok2 || len(descStr) > 1024 {+ return errors.New("invalid template description.")+ }+ }+ if kind, ok := req["kind"]; ok {+ if kindStr, ok2 := kind.(string); !ok2 || kindStr == "" {+ return errors.New("invalid template kind.")+ }+ }+ config, hasConfig := req["config"]+ if hasConfig {+ configMap, ok := config.(map[string]interface{})+ if !ok {+ return errors.New("invalid template config.")+ }+ if len(fmt.Sprint(configMap["global_rules"])) > 4096 {+ return errors.New("global compilation rules is too long.")+ }+ for _, section := range []string{"entity", "relation"} {+ sec, _ := configMap[section].(map[string]interface{})+ fields, _ := sec["fields"].([]interface{})+ seen := map[string]struct{}{}+ for _, f := range fields {+ fm, _ := f.(map[string]interface{})+ fieldType := strings.TrimSpace(yamlStr(fm["type"]))+ if fieldType == "" {+ return fmt.Errorf("%s type is required.", capitalizeTitle(section))+ }+ if _, dup := seen[fieldType]; dup {+ return fmt.Errorf("%s type can not be duplicated.", capitalizeTitle(section))+ }+ seen[fieldType] = struct{}{}+ if strings.TrimSpace(yamlStr(fm["description"])) == "" {+ return fmt.Errorf("%s field description is required.", capitalizeTitle(section))+ }+ if len(yamlStr(fm["description"])) > 1024 {+ return fmt.Errorf("%s field description is too long.", capitalizeTitle(section))+ }+ if len(yamlStr(fm["rule"])) > 1024 {+ return fmt.Errorf("%s field rule is too long.", capitalizeTitle(section))+ }+ }+ }+ if configMap["kind"] == "wiki" || req["kind"] == "wiki" {+ for _, group := range []string{"claim", "concept"} {+ sec, _ := configMap[group].(map[string]interface{})+ fields, _ := sec["fields"].([]interface{})+ for _, f := range fields {+ fm, _ := f.(map[string]interface{})+ switch group {+ case "claim":+ if strings.TrimSpace(yamlStr(fm["statement"])) == "" {+ return errors.New("claim statement is required.")+ }+ if strings.TrimSpace(yamlStr(fm["subject"])) == "" {+ return errors.New("claim subject is required.")+ }+ if len(yamlStr(fm["statement"])) > 1024 {+ return errors.New("claim statement is too long.")+ }+ if len(yamlStr(fm["subject"])) > 1024 {+ return errors.New("claim subject is too long.")+ }+ case "concept":+ if strings.TrimSpace(yamlStr(fm["term"])) == "" {+ return errors.New("concept term is required.")+ }+ if strings.TrimSpace(yamlStr(fm["definition_excerpt"])) == "" {+ return errors.New("concept definition excerpt is required.")+ }+ if len(yamlStr(fm["term"])) > 1024 {+ return errors.New("concept term is too long.")+ }+ if len(yamlStr(fm["definition_excerpt"])) > 1024 {+ return errors.New("concept definition excerpt is too long.")+ }+ }+ }+ }+ }+ }+ return nil+}++// sortBuiltins mirrors Python _sort_builtins: empty-kind entries first, then by+// display name.+func (s *CompilationTemplateService) sortBuiltins(templates []*BuiltinTemplate) []*BuiltinTemplate {+ sort.SliceStable(templates, func(i, j int) bool {+ emptyI := templates[i].Kind == "empty" || templates[i].ID == "empty"+ emptyJ := templates[j].Kind == "empty" || templates[j].ID == "empty"+ if emptyI != emptyJ {+ return emptyI+ }+ return strings.ToLower(templates[i].DisplayName) < strings.ToLower(templates[j].DisplayName)+ })+ return templates+}++// seedBuiltins loads the built-in templates from the init_data YAML files and+// upserts them (as a safety net when the DB has no built-ins yet), mirroring+// Python seed_builtins_from_files.+func (s *CompilationTemplateService) seedBuiltins(ctx context.Context) error {+ dir := filepath.Join(utility.GetProjectBaseDirectory(),+ "api", "db", "init_data", "compilation_templates")+ entries, err := os.ReadDir(dir)+ if err != nil {+ return nil // directory absent is acceptable; nothing to seed+ }+ for _, entry := range entries {+ if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".yaml") && !strings.HasSuffix(entry.Name(), ".yml") {+ continue+ }+ data, rerr := os.ReadFile(filepath.Join(dir, entry.Name()))+ if rerr != nil {+ continue+ }+ var doc struct {+ Kind string `yaml:"kind"`+ DisplayName string `yaml:"display_name"`+ Description string `yaml:"description"`+ Config map[string]interface{} `yaml:"config"`+ }+ if yerr := yaml.Unmarshal(data, &doc); yerr != nil {+ continue+ }+ if doc.Kind == "" || doc.DisplayName == "" || doc.Config == nil {+ continue+ }+ id := strings.TrimSuffix(entry.Name(), filepath.Ext(entry.Name()))+ desc := doc.Description+ valid := string(entity.StatusValid)+ tmpl := &entity.CompilationTemplate{+ ID: id,+ Name: doc.DisplayName,+ Kind: doc.Kind,+ Config: entity.JSONMap(doc.Config),+ IsBuiltin: true,+ Status: &valid,+ }+ if doc.Description != "" {+ tmpl.Description = &desc+ }+ _ = s.upsertBuiltin(ctx, tmpl)+ }+ return nil+}++func (s *CompilationTemplateService) upsertBuiltin(ctx context.Context, t *entity.CompilationTemplate) error {+ existing, err := s.templateDAO.GetByID(ctx, t.ID)+ if errors.Is(err, gorm.ErrRecordNotFound) {+ return s.templateDAO.Save(ctx, dao.DB, t)+ }+ if err != nil {+ return err+ }+ m := map[string]interface{}{+ "name": t.Name, "kind": t.Kind, "config": t.Config,+ "description": t.Description, "is_builtin": true,+ "status": t.Status,+ }+ return s.templateDAO.UpdateFields(ctx, dao.DB, existing.ID, m)+}++func derefString(p *string) string {+ if p == nil {+ return ""+ }+ return *p+}++// yamlStr safely stringifies a YAML value, returning "" when the key is absent+// (instead of fmt.Sprint(nil) which yields "<nil>").+func yamlStr(v interface{}) string {+ if v == nil {+ return ""+ }+ return fmt.Sprint(v)+}diff --git a/internal/service/dataset_artifact_service.go b/internal/service/dataset_artifact_service.gonew file mode 100644index 0000000000..38a524fcf0--- /dev/null+++ b/internal/service/dataset_artifact_service.go@@ -0,0 +1,846 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package service++import (+ "context"+ "encoding/json"+ "fmt"+ "sort"++ "ragflow/internal/engine"+ "ragflow/internal/engine/types"+)++// Compile keyword constants used by the knowledge-compilation artifacts stored+// in the document engine.+const (+ CompileKwdWikiPage = "wiki_page"+ CompileKwdWikiEntity = "wiki_entity"+ CompileKwdWikiRelation = "wiki_relation"+ CompileKwdWikiAlter = "wiki_alter"+ CompileKwdSkill = "skill"+ CompileKwdSkillAll = "skill_all"+ CompileKwdDatasetNav = "dataset_nav"+ CompileKwdRaptorGraph = "raptor_graph"++ // Structure / graph compilation keywords.+ CompileKwdStructure = "structure"+ CompileKwdStructureIndex = "structureIndex"+ CompileKwdStructureEntity = "structureEntity"+ CompileKwdStructureRelation = "structureRelation"+ CompileKwdStructureCommunity = "structureCommunity"++ // Field name for the structure index type discriminator.+ FieldStructureIndexType = "structure_index_type"+ FieldStructureKind = "structure_kind"+ FieldPageID = "page_id"+ FieldGraphType = "graph_type"+)++// DatasetArtifactService reads knowledge-compilation artifacts (wiki pages,+// graphs, structures, navigation, skills) from the document engine.+type DatasetArtifactService struct{}++// NewDatasetArtifactService creates a DatasetArtifactService.+func NewDatasetArtifactService() *DatasetArtifactService {+ return &DatasetArtifactService{}+}++// wikiIndexName returns the tenant document index name.+func wikiIndexName(tenantID string) string {+ return fmt.Sprintf("ragflow_%s", tenantID)+}++// searchCompiled runs a filtered search over the tenant's document index for+// the given dataset, returning the matching chunks.+func (s *DatasetArtifactService) searchCompiled(ctx context.Context, tenantID, datasetID string, filter map[string]interface{}, selectFields []string, offset, limit int, orderBy *types.OrderByExpr) ([]map[string]interface{}, int64, error) {+ docEngine := engine.Get()+ if docEngine == nil {+ return nil, 0, fmt.Errorf("document engine is not initialized")+ }+ // Copy caller filters first, then pin the dataset scope so kb_id always wins+ // even if a caller passes its own kb_id.+ merged := make(map[string]interface{}, len(filter)+1)+ for k, v := range filter {+ merged[k] = v+ }+ merged["kb_id"] = []string{datasetID}+ res, err := docEngine.Search(ctx, &types.SearchRequest{+ IndexNames: []string{wikiIndexName(tenantID)},+ KbIDs: []string{datasetID},+ Offset: offset,+ Limit: limit,+ SelectFields: selectFields,+ Filter: merged,+ OrderBy: orderBy,+ })+ if err != nil {+ return nil, 0, err+ }+ if res == nil {+ return nil, 0, nil+ }+ return res.Chunks, res.Total, nil+}++// intValue coerces an engine field value into an int, tolerating the numeric+// types a document engine may decode a number as (float64, int, int64,+// json.Number) as well as a string form and a list-valued form (first element+// wins). It returns 0 for anything else.+func intValue(v interface{}) int {+ if v == nil {+ return 0+ }+ switch n := v.(type) {+ case int:+ return n+ case int64:+ return int(n)+ case int32:+ return int(n)+ case float64:+ return int(n)+ case float32:+ return int(n)+ case json.Number:+ if iv, err := n.Int64(); err == nil {+ return int(iv)+ }+ if fv, err := n.Float64(); err == nil {+ return int(fv)+ }+ case string:+ var iv int+ if _, err := fmt.Sscanf(n, "%d", &iv); err == nil {+ return iv+ }+ case []interface{}:+ if len(n) > 0 {+ return intValue(n[0])+ }+ }+ return 0+}++// HasWiki reports whether the dataset has any compiled wiki artifact.+func (s *DatasetArtifactService) HasWiki(ctx context.Context, tenantID, datasetID string) (bool, error) {+ _, total, err := s.searchCompiled(ctx, tenantID, datasetID,+ map[string]interface{}{"compile_kwd": []string{CompileKwdWikiPage}}, nil, 0, 1, nil)+ if err != nil {+ return false, err+ }+ return total > 0, nil+}++// HasSkill reports whether the dataset has any compiled skill artifact.+func (s *DatasetArtifactService) HasSkill(ctx context.Context, tenantID, datasetID string) (bool, error) {+ _, total, err := s.searchCompiled(ctx, tenantID, datasetID,+ map[string]interface{}{"compile_kwd": []string{CompileKwdSkillAll}}, nil, 0, 1, nil)+ if err != nil {+ return false, err+ }+ return total > 0, nil+}++// WikiPageItem is a single wiki page summary returned by ListWikiPages.+type WikiPageItem struct {+ Slug string `json:"slug"`+ Title string `json:"title"`+ PageType string `json:"page_type"`+ Topic string `json:"topic"`+ Summary string `json:"summary"`+}++// ListWikiPages lists wiki pages for a dataset with optional page_type/topic+// filters and pagination.+func (s *DatasetArtifactService) ListWikiPages(ctx context.Context, tenantID, datasetID, pageType, topic string, page, pageSize int) ([]WikiPageItem, int64, error) {+ filter := map[string]interface{}{"compile_kwd": []string{CompileKwdWikiPage}}+ if pageType != "" {+ filter["page_type_kwd"] = []string{pageType}+ }+ if topic != "" {+ filter["topic_kwd"] = []string{topic}+ }+ offset := (page - 1) * pageSize+ chunks, total, err := s.searchCompiled(ctx, tenantID, datasetID, filter,+ []string{"slug_kwd", "title_kwd", "page_type_kwd", "topic_kwd", "outlinks_int", "summary_with_weight"},+ offset, pageSize, (&types.OrderByExpr{}).Desc("outlinks_int").Asc("title_kwd"))+ if err != nil {+ return nil, 0, err+ }+ items := make([]WikiPageItem, 0, len(chunks))+ for _, c := range chunks {+ items = append(items, WikiPageItem{+ Slug: firstStringValue(c["slug_kwd"]),+ Title: firstStringValue(c["title_kwd"]),+ PageType: firstStringValue(c["page_type_kwd"]),+ Topic: firstStringValue(c["topic_kwd"]),+ Summary: firstStringValue(c["summary_with_weight"]),+ })+ }+ return items, total, nil+}++// WikiPageDetail is the full wiki page payload.+type WikiPageDetail struct {+ Slug string `json:"slug"`+ Title string `json:"title"`+ PageType string `json:"page_type"`+ Topic string `json:"topic"`+ ContentMd string `json:"content_md"`+ Summary string `json:"summary"`+ EntityNames []string `json:"entity_names"`+ Outlinks []string `json:"outlinks"`+ RelatedKbPages []string `json:"related_kb_pages"`+ SourceChunkIDs []string `json:"source_chunk_ids"`+ SourceDocIDs []string `json:"source_doc_ids"`+}++// GetWikiPage returns a single wiki page by page_type and slug.+func (s *DatasetArtifactService) GetWikiPage(ctx context.Context, tenantID, datasetID, pageType, slug string) (*WikiPageDetail, error) {+ slugKwd := pageType + "/" + slug+ filter := map[string]interface{}{+ "compile_kwd": []string{CompileKwdWikiPage},+ "page_type_kwd": []string{pageType},+ "slug_kwd": []string{slugKwd},+ }+ chunks, _, err := s.searchCompiled(ctx, tenantID, datasetID, filter,+ []string{"slug_kwd", "title_kwd", "page_type_kwd", "topic_kwd", "content_with_weight",+ "summary_with_weight", "entity_names_kwd", "outlinks_kwd", "related_kb_pages_kwd",+ "source_chunk_ids", "source_doc_ids"},+ 0, 1, nil)+ if err != nil {+ return nil, err+ }+ if len(chunks) == 0 {+ return nil, nil+ }+ c := chunks[0]+ detail := &WikiPageDetail{+ Slug: firstStringValue(c["slug_kwd"]),+ Title: firstStringValue(c["title_kwd"]),+ PageType: firstStringValue(c["page_type_kwd"]),+ Topic: firstStringValue(c["topic_kwd"]),+ ContentMd: firstStringValue(c["content_with_weight"]),+ Summary: firstStringValue(c["summary_with_weight"]),+ EntityNames: toStringSlice(c["entity_names_kwd"]),+ Outlinks: toStringSlice(c["outlinks_kwd"]),+ RelatedKbPages: toStringSlice(c["related_kb_pages_kwd"]),+ SourceChunkIDs: toStringSlice(c["source_chunk_ids"]),+ SourceDocIDs: toStringSlice(c["source_doc_ids"]),+ }+ return detail, nil+}++// UpdateWikiPage performs a partial field update of a wiki page's content,+// title and outlinks through the document engine, then returns the refreshed+// page.+func (s *DatasetArtifactService) UpdateWikiPage(ctx context.Context, tenantID, datasetID, pageType, slug, contentMd, title string, outlinks []string) (*WikiPageDetail, error) {+ docEngine := engine.Get()+ if docEngine == nil {+ return nil, fmt.Errorf("document engine is not initialized")+ }+ slugKwd := pageType + "/" + slug+ filter := map[string]interface{}{+ "compile_kwd": []string{CompileKwdWikiPage},+ "page_type_kwd": []string{pageType},+ "slug_kwd": []string{slugKwd},+ }+ chunks, _, err := s.searchCompiled(ctx, tenantID, datasetID, filter, []string{"id"}, 0, 1, nil)+ if err != nil {+ return nil, err+ }+ if len(chunks) == 0 {+ return nil, nil+ }+ id, ok := chunks[0]["id"].(string)+ if !ok || id == "" {+ return nil, fmt.Errorf("wiki page chunk has no id")+ }+ update := map[string]interface{}{}+ if contentMd != "" {+ update["content_with_weight"] = contentMd+ }+ if title != "" {+ update["title_kwd"] = title+ }+ if len(outlinks) > 0 {+ update["outlinks_kwd"] = outlinks+ }+ if len(update) > 0 {+ cond := map[string]interface{}{"id": id, "kb_id": datasetID}+ if err := docEngine.UpdateChunks(ctx, cond, update, wikiIndexName(tenantID), datasetID); err != nil {+ return nil, err+ }+ }+ return s.GetWikiPage(ctx, tenantID, datasetID, pageType, slug)+}++// WikiTopicItem is a single topic entry returned by ListWikiTopics.+type WikiTopicItem struct {+ Topic string `json:"topic"`+ Title string `json:"title"`+ Slug string `json:"slug"`+ PageCount int `json:"page_count"`+}++// ListWikiTopics aggregates wiki topics for a dataset.+func (s *DatasetArtifactService) ListWikiTopics(ctx context.Context, tenantID, datasetID string) ([]WikiTopicItem, int64, error) {+ filter := map[string]interface{}{+ "compile_kwd": []string{CompileKwdWikiPage},+ "page_type_kwd": []string{"concept", "entity"},+ }+ chunks, _, err := s.searchCompiled(ctx, tenantID, datasetID, filter,+ []string{"topic_kwd", "title_kwd", "slug_kwd"}, 0, 1000, nil)+ if err != nil {+ return nil, 0, err+ }+ counts := map[string]int{}+ metas := map[string]WikiTopicItem{}+ for _, c := range chunks {+ t := firstStringValue(c["topic_kwd"])+ if t == "" {+ continue+ }+ counts[t]+++ if _, ok := metas[t]; !ok {+ metas[t] = WikiTopicItem{+ Topic: t,+ Title: firstStringValue(c["title_kwd"]),+ Slug: firstStringValue(c["slug_kwd"]),+ }+ }+ }+ items := make([]WikiTopicItem, 0, len(metas))+ for t, it := range metas {+ it.PageCount = counts[t]+ items = append(items, it)+ }+ sort.Slice(items, func(i, j int) bool { return items[i].Topic < items[j].Topic })+ return items, int64(len(items)), nil+}++// WikiGraph is the entity/relation graph for a dataset's wiki artifacts.+type WikiGraph struct {+ Entities []WikiGraphEntity `json:"entities"`+ Relations []WikiGraphRelation `json:"relations"`+}++// WikiGraphEntity is a single wiki graph entity.+type WikiGraphEntity struct {+ Slug string `json:"slug"`+ Name string `json:"name"`+ Aliases []string `json:"aliases"`+ Description string `json:"description"`+ Type string `json:"type"`+ Weight int `json:"weight"`+ SourceChunkIDs []string `json:"source_chunk_ids"`+}++// WikiGraphRelation is a single wiki graph relation.+type WikiGraphRelation struct {+ From string `json:"from"`+ To string `json:"to"`+}++// GetWikiGraph returns the wiki entity/relation graph for a dataset.+func (s *DatasetArtifactService) GetWikiGraph(ctx context.Context, tenantID, datasetID string) (*WikiGraph, error) {+ entityChunks, _, err := s.searchCompiled(ctx, tenantID, datasetID,+ map[string]interface{}{"compile_kwd": []string{CompileKwdWikiEntity}},+ []string{"slug_kwd", "title_kwd", "aliases_kwd", "description_with_weight", "entity_type_kwd", "weight_int", "source_chunk_ids"},+ 0, 1000, (&types.OrderByExpr{}).Desc("weight_int"))+ if err != nil {+ return nil, err+ }+ fromKwds := make([]string, 0, len(entityChunks))+ for _, c := range entityChunks {+ fromKwds = append(fromKwds, firstStringValue(c["slug_kwd"]))+ }+ graph := &WikiGraph{Entities: []WikiGraphEntity{}, Relations: []WikiGraphRelation{}}+ for _, c := range entityChunks {+ w := intValue(c["weight_int"])+ graph.Entities = append(graph.Entities, WikiGraphEntity{+ Slug: firstStringValue(c["slug_kwd"]),+ Name: firstStringValue(c["title_kwd"]),+ Aliases: toStringSlice(c["aliases_kwd"]),+ Description: firstStringValue(c["description_with_weight"]),+ Type: firstStringValue(c["entity_type_kwd"]),+ Weight: w,+ SourceChunkIDs: toStringSlice(c["source_chunk_ids"]),+ })+ }+ if len(fromKwds) > 0 {+ relChunks, _, err := s.searchCompiled(ctx, tenantID, datasetID,+ map[string]interface{}{"compile_kwd": []string{CompileKwdWikiRelation}, "from_kwd": fromKwds},+ []string{"from_kwd", "to_kwd"}, 0, 10000, nil)+ if err != nil {+ return nil, err+ }+ for _, c := range relChunks {+ graph.Relations = append(graph.Relations, WikiGraphRelation{+ From: firstStringValue(c["from_kwd"]),+ To: firstStringValue(c["to_kwd"]),+ })+ }+ }+ return graph, nil+}++// WikiAlteration is the alteration summary for a dataset's wiki artifacts.+type WikiAlteration struct {+ Removed int `json:"removed"`+ NewlyUploaded int `json:"newly_uploaded"`+ RemovedDocIDs []string `json:"removed_doc_ids"`+ NewlyUploadedDocIDs []string `json:"newly_uploaded_doc_ids"`+ InvolvedDocIDs []string `json:"involved_doc_ids"`+ EligibleDocIDs []string `json:"eligible_doc_ids"`+}++// GetWikiAlteration returns the wiki alteration summary for a dataset.+func (s *DatasetArtifactService) GetWikiAlteration(ctx context.Context, tenantID, datasetID string) (*WikiAlteration, error) {+ chunks, _, err := s.searchCompiled(ctx, tenantID, datasetID,+ map[string]interface{}{"compile_kwd": []string{CompileKwdWikiPage}},+ []string{"source_doc_ids"}, 0, 10000, nil)+ if err != nil {+ return nil, err+ }+ involved := map[string]struct{}{}+ for _, c := range chunks {+ for _, d := range toStringSlice(c["source_doc_ids"]) {+ involved[d] = struct{}{}+ }+ }+ ids := make([]string, 0, len(involved))+ for d := range involved {+ ids = append(ids, d)+ }+ sort.Strings(ids)+ return &WikiAlteration{+ Removed: 0,+ NewlyUploaded: 0,+ RemovedDocIDs: []string{},+ NewlyUploadedDocIDs: []string{},+ InvolvedDocIDs: ids,+ EligibleDocIDs: ids,+ }, nil+}++// ClearWiki deletes all wiki artifacts for a dataset.+func (s *DatasetArtifactService) ClearWiki(ctx context.Context, tenantID, datasetID string) (map[string]int, error) {+ docEngine := engine.Get()+ if docEngine == nil {+ return nil, fmt.Errorf("document engine is not initialized")+ }+ kwds := []string{CompileKwdWikiPage, CompileKwdWikiEntity, CompileKwdWikiRelation, CompileKwdWikiAlter}+ deleted := map[string]int{}+ for _, kwd := range kwds {+ chunks, _, err := s.searchCompiled(ctx, tenantID, datasetID,+ map[string]interface{}{"compile_kwd": []string{kwd}}, []string{"id"}, 0, 10000, nil)+ if err != nil {+ return nil, err+ }+ if len(chunks) == 0 {+ deleted[kwd] = 0+ continue+ }+ ids := make([]string, 0, len(chunks))+ for _, c := range chunks {+ if id, ok := c["id"].(string); ok {+ ids = append(ids, id)+ }+ }+ cond := map[string]interface{}{"id": ids, "kb_id": datasetID}+ if _, err := docEngine.DeleteChunks(ctx, cond, wikiIndexName(tenantID), datasetID); err != nil {+ return nil, err+ }+ deleted[kwd] = len(ids)+ }+ return deleted, nil+}++// StructureItem is a single compiled structure entry for a dataset.+type StructureItem struct {+ PageID string `json:"page_id"`+ StructureKind string `json:"structure_kind"`+ StructureIndexType string `json:"structure_index_type"`+ Data string `json:"data"`+}++// ListStructures returns the compiled structures of a dataset, filtered by+// optional structure_kind and structure_index_type.+func (s *DatasetArtifactService) ListStructures(ctx context.Context, tenantID, datasetID, structureKind, structureIndexType string) ([]StructureItem, int64, error) {+ filter := map[string]interface{}{"compile_kwd": []string{CompileKwdStructure}}+ if structureKind != "" {+ filter[FieldStructureKind] = []string{structureKind}+ }+ if structureIndexType != "" {+ filter[FieldStructureIndexType] = []string{structureIndexType}+ }+ chunks, total, err := s.searchCompiled(ctx, tenantID, datasetID, filter,+ []string{FieldPageID, FieldStructureKind, FieldStructureIndexType, "content_with_weight"}, 0, 10000, nil)+ if err != nil {+ return nil, 0, err+ }+ items := make([]StructureItem, 0, len(chunks))+ for _, c := range chunks {+ items = append(items, StructureItem{+ PageID: firstStringValue(c[FieldPageID]),+ StructureKind: firstStringValue(c[FieldStructureKind]),+ StructureIndexType: firstStringValue(c[FieldStructureIndexType]),+ Data: firstStringValue(c["content_with_weight"]),+ })+ }+ return items, total, nil+}++// DeleteStructures deletes the compiled structures of a dataset, optionally+// scoped by structure_kind and structure_index_type.+func (s *DatasetArtifactService) DeleteStructures(ctx context.Context, tenantID, datasetID, structureKind, structureIndexType string) (int, error) {+ docEngine := engine.Get()+ if docEngine == nil {+ return 0, fmt.Errorf("document engine is not initialized")+ }+ filter := map[string]interface{}{"compile_kwd": []string{CompileKwdStructure}}+ if structureKind != "" {+ filter[FieldStructureKind] = []string{structureKind}+ }+ if structureIndexType != "" {+ filter[FieldStructureIndexType] = []string{structureIndexType}+ }+ chunks, _, err := s.searchCompiled(ctx, tenantID, datasetID, filter, []string{"id"}, 0, 10000, nil)+ if err != nil {+ return 0, err+ }+ if len(chunks) == 0 {+ return 0, nil+ }+ ids := make([]string, 0, len(chunks))+ for _, c := range chunks {+ if id, ok := c["id"].(string); ok {+ ids = append(ids, id)+ }+ }+ cond := map[string]interface{}{"id": ids, "kb_id": datasetID}+ if _, err := docEngine.DeleteChunks(ctx, cond, wikiIndexName(tenantID), datasetID); err != nil {+ return 0, err+ }+ return len(ids), nil+}++// DocGraphItem is a single node/edge entry in a document's structure graph.+type DocGraphItem struct {+ ID string `json:"id"`+ Content string `json:"content"`+ SourceID string `json:"source_id"`+}++// GetDocumentGraph returns the structure graph of a single document.+func (s *DatasetArtifactService) GetDocumentGraph(ctx context.Context, tenantID, datasetID, documentID, graphType string) ([]DocGraphItem, int64, error) {+ filter := map[string]interface{}{+ "doc_id": []string{documentID},+ "compiled_graph_kwd": []string{"graph"},+ }+ if graphType != "" {+ filter[FieldGraphType] = []string{graphType}+ }+ chunks, total, err := s.searchCompiled(ctx, tenantID, datasetID, filter,+ []string{"id", "content_with_weight", "source_id"}, 0, 10000, nil)+ if err != nil {+ return nil, 0, err+ }+ items := make([]DocGraphItem, 0, len(chunks))+ for _, c := range chunks {+ items = append(items, DocGraphItem{+ ID: firstStringValue(c["id"]),+ Content: firstStringValue(c["content_with_weight"]),+ SourceID: firstStringValue(c["source_id"]),+ })+ }+ return items, total, nil+}++// DeleteDocumentGraph deletes the structure graph of a single document.+func (s *DatasetArtifactService) DeleteDocumentGraph(ctx context.Context, tenantID, datasetID, documentID string) (int, error) {+ docEngine := engine.Get()+ if docEngine == nil {+ return 0, fmt.Errorf("document engine is not initialized")+ }+ filter := map[string]interface{}{+ "doc_id": []string{documentID},+ "compiled_graph_kwd": []string{"graph"},+ }+ chunks, _, err := s.searchCompiled(ctx, tenantID, datasetID, filter, []string{"id"}, 0, 10000, nil)+ if err != nil {+ return 0, err+ }+ if len(chunks) == 0 {+ return 0, nil+ }+ ids := make([]string, 0, len(chunks))+ for _, c := range chunks {+ if id, ok := c["id"].(string); ok {+ ids = append(ids, id)+ }+ }+ cond := map[string]interface{}{"id": ids, "kb_id": datasetID}+ if _, err := docEngine.DeleteChunks(ctx, cond, wikiIndexName(tenantID), datasetID); err != nil {+ return 0, err+ }+ return len(ids), nil+}++// NavigationItem is a single navigation cluster.+type NavigationItem struct {+ Name string `json:"name"`+ Title string `json:"title"`+ Count int `json:"count"`+}++// ListNavClusters returns the navigation clusters of a dataset.+func (s *DatasetArtifactService) ListNavClusters(ctx context.Context, tenantID, datasetID string) ([]NavigationItem, int64, error) {+ chunks, total, err := s.searchCompiled(ctx, tenantID, datasetID,+ map[string]interface{}{"compile_kwd": []string{CompileKwdDatasetNav}},+ []string{"nav_cluster_kwd", "title_kwd", "count_int"}, 0, 10000, nil)+ if err != nil {+ return nil, 0, err+ }+ items := make([]NavigationItem, 0, len(chunks))+ for _, c := range chunks {+ count := intValue(c["count_int"])+ items = append(items, NavigationItem{+ Name: firstStringValue(c["nav_cluster_kwd"]),+ Title: firstStringValue(c["title_kwd"]),+ Count: count,+ })+ }+ return items, total, nil+}++// DeleteNav deletes all navigation clusters of a dataset.+func (s *DatasetArtifactService) DeleteNav(ctx context.Context, tenantID, datasetID string) (int, error) {+ docEngine := engine.Get()+ if docEngine == nil {+ return 0, fmt.Errorf("document engine is not initialized")+ }+ chunks, _, err := s.searchCompiled(ctx, tenantID, datasetID,+ map[string]interface{}{"compile_kwd": []string{CompileKwdDatasetNav}}, []string{"id"}, 0, 10000, nil)+ if err != nil {+ return 0, err+ }+ if len(chunks) == 0 {+ return 0, nil+ }+ ids := make([]string, 0, len(chunks))+ for _, c := range chunks {+ if id, ok := c["id"].(string); ok {+ ids = append(ids, id)+ }+ }+ cond := map[string]interface{}{"id": ids, "kb_id": datasetID}+ if _, err := docEngine.DeleteChunks(ctx, cond, wikiIndexName(tenantID), datasetID); err != nil {+ return 0, err+ }+ return len(ids), nil+}++// DeleteNavNode deletes a single navigation cluster by name.+func (s *DatasetArtifactService) DeleteNavNode(ctx context.Context, tenantID, datasetID, name string) (int, error) {+ docEngine := engine.Get()+ if docEngine == nil {+ return 0, fmt.Errorf("document engine is not initialized")+ }+ chunks, _, err := s.searchCompiled(ctx, tenantID, datasetID,+ map[string]interface{}{"compile_kwd": []string{CompileKwdDatasetNav}, "nav_cluster_kwd": []string{name}},+ []string{"id"}, 0, 10000, nil)+ if err != nil {+ return 0, err+ }+ if len(chunks) == 0 {+ return 0, nil+ }+ ids := make([]string, 0, len(chunks))+ for _, c := range chunks {+ if id, ok := c["id"].(string); ok {+ ids = append(ids, id)+ }+ }+ cond := map[string]interface{}{"id": ids, "kb_id": datasetID}+ if _, err := docEngine.DeleteChunks(ctx, cond, wikiIndexName(tenantID), datasetID); err != nil {+ return 0, err+ }+ return len(ids), nil+}++// NavChildItem is a single child entry under a navigation cluster.+type NavChildItem struct {+ Name string `json:"name"`+ Title string `json:"title"`+ Count int `json:"count"`+}++// ListNavChildren returns the children of a navigation cluster.+func (s *DatasetArtifactService) ListNavChildren(ctx context.Context, tenantID, datasetID, name string) ([]NavChildItem, int64, error) {+ chunks, total, err := s.searchCompiled(ctx, tenantID, datasetID,+ map[string]interface{}{"compile_kwd": []string{CompileKwdDatasetNav}, "nav_cluster_kwd": []string{name}},+ []string{"nav_child_kwd", "title_kwd", "count_int"}, 0, 10000, nil)+ if err != nil {+ return nil, 0, err+ }+ items := make([]NavChildItem, 0, len(chunks))+ for _, c := range chunks {+ count := intValue(c["count_int"])+ items = append(items, NavChildItem{+ Name: firstStringValue(c["nav_child_kwd"]),+ Title: firstStringValue(c["title_kwd"]),+ Count: count,+ })+ }+ return items, total, nil+}++// SkillTreeItem is a single skill-tree page summary.+type SkillTreeItem struct {+ Kwd string `json:"kwd"`+ Title string `json:"title"`+ PageType string `json:"page_type"`+ Outlinks int `json:"outlinks"`+ Inlinks int `json:"inlinks"`+}++// GetSkillTree returns the skill tree of a dataset.+func (s *DatasetArtifactService) GetSkillTree(ctx context.Context, tenantID, datasetID, kwd string) ([]SkillTreeItem, int64, error) {+ filter := map[string]interface{}{"compile_kwd": []string{CompileKwdSkillAll}}+ if kwd != "" {+ filter["kwd"] = []string{kwd}+ }+ chunks, total, err := s.searchCompiled(ctx, tenantID, datasetID, filter,+ []string{"kwd", "title_kwd", "page_type_kwd", "outlinks_int", "inlinks_int"}, 0, 10000, nil)+ if err != nil {+ return nil, 0, err+ }+ items := make([]SkillTreeItem, 0, len(chunks))+ for _, c := range chunks {+ outlinks, inlinks := intValue(c["outlinks_int"]), intValue(c["inlinks_int"])+ items = append(items, SkillTreeItem{+ Kwd: firstStringValue(c["kwd"]),+ Title: firstStringValue(c["title_kwd"]),+ PageType: firstStringValue(c["page_type_kwd"]),+ Outlinks: outlinks,+ Inlinks: inlinks,+ })+ }+ return items, total, nil+}++// SkillPageDetail is the full skill page payload.+type SkillPageDetail struct {+ Kwd string `json:"kwd"`+ Title string `json:"title"`+ ContentMd string `json:"content_md"`+ Outlinks []string `json:"outlinks"`+ Inlinks []string `json:"inlinks"`+}++// GetSkillPage returns a single skill page by keyword.+func (s *DatasetArtifactService) GetSkillPage(ctx context.Context, tenantID, datasetID, kwd string) (*SkillPageDetail, error) {+ chunks, _, err := s.searchCompiled(ctx, tenantID, datasetID,+ map[string]interface{}{"compile_kwd": []string{CompileKwdSkillAll}, "kwd": []string{kwd}},+ []string{"kwd", "title_kwd", "content_with_weight", "outlinks_kwd", "inlinks_kwd"}, 0, 1, nil)+ if err != nil {+ return nil, err+ }+ if len(chunks) == 0 {+ return nil, nil+ }+ c := chunks[0]+ return &SkillPageDetail{+ Kwd: firstStringValue(c["kwd"]),+ Title: firstStringValue(c["title_kwd"]),+ ContentMd: firstStringValue(c["content_with_weight"]),+ Outlinks: toStringSlice(c["outlinks_kwd"]),+ Inlinks: toStringSlice(c["inlinks_kwd"]),+ }, nil+}++// DeleteSkills deletes skills of a dataset, optionally scoped by keyword.+func (s *DatasetArtifactService) DeleteSkills(ctx context.Context, tenantID, datasetID, kwd string) (int, error) {+ docEngine := engine.Get()+ if docEngine == nil {+ return 0, fmt.Errorf("document engine is not initialized")+ }+ filter := map[string]interface{}{"compile_kwd": []string{CompileKwdSkillAll}}+ if kwd != "" {+ filter["kwd"] = []string{kwd}+ }+ chunks, _, err := s.searchCompiled(ctx, tenantID, datasetID, filter, []string{"id"}, 0, 10000, nil)+ if err != nil {+ return 0, err+ }+ if len(chunks) == 0 {+ return 0, nil+ }+ ids := make([]string, 0, len(chunks))+ for _, c := range chunks {+ if id, ok := c["id"].(string); ok {+ ids = append(ids, id)+ }+ }+ cond := map[string]interface{}{"id": ids, "kb_id": datasetID}+ if _, err := docEngine.DeleteChunks(ctx, cond, wikiIndexName(tenantID), datasetID); err != nil {+ return 0, err+ }+ return len(ids), nil+}++// firstStringValue returns the first string in a possibly-list ES field value.+func firstStringValue(v interface{}) string {+ switch t := v.(type) {+ case string:+ return t+ case []interface{}:+ if len(t) > 0 {+ if s, ok := t[0].(string); ok {+ return s+ }+ }+ case []string:+ if len(t) > 0 {+ return t[0]+ }+ }+ return ""+}++// toStringSlice normalizes an ES field value (string or list) to []string.+func toStringSlice(v interface{}) []string {+ switch t := v.(type) {+ case string:+ if t == "" {+ return []string{}+ }+ return []string{t}+ case []interface{}:+ out := make([]string, 0, len(t))+ for _, e := range t {+ if s, ok := e.(string); ok {+ out = append(out, s)+ }+ }+ return out+ case []string:+ return t+ }+ return []string{}+}diff --git a/internal/service/file/file_commit.go b/internal/service/file/file_commit.goindex 2ac6b2514e..fc6c205a65 100644--- a/internal/service/file/file_commit.go+++ b/internal/service/file/file_commit.go@@ -28,6 +28,8 @@ import ("ragflow/internal/storage""ragflow/internal/utility""sort"+ "strings"+ "sync""time""go.uber.org/zap"@@ -233,6 +235,209 @@ func (s *FileCommitService) CreateCommit(ctx context.Context, folderID, authorIDreturn commit, nil}+// PageEditCommitInput carries the data needed to record a single wiki/skill+// page edit as an audit commit.+type PageEditCommitInput struct {+ DatasetID string // knowledgebase scope, stored on the commit for isolation+ DocID string // ES doc id of the page content+ Slug string+ PageType string+ Title string+ AuthorID string+ OldContent string+ NewContent string+}++// wikiFileID derives the stable file key used to scope page-edit commits to a+// specific knowledgebase and page, so identical slugs in different+// knowledgebases never share a commit parent or history.+func wikiFileID(datasetID, pageType, slug string) string {+ return datasetID + "/" + pageType + "/" + slug+}++// RecordPageEdit records a wiki/skill page edit as an audit commit with a+// git-style parent chain (each edit points at the previous commit for the same+// page). The new content_after is referenced in ES by doc_id; a unified diff of+// old vs new content is stored on the commit item. The commit is scoped to the+// dataset via FolderID and a derived page file key so page histories never cross+// knowledgebase boundaries.+//+// This path is independent of the workspace File tree (it does not require a+// File record or a tree_state snapshot).+func (s *FileCommitService) RecordPageEdit(ctx context.Context, in PageEditCommitInput) (*entity.FileCommit, error) {+ // Parent chain: previous commit that touched the same page file key.+ fileID := wikiFileID(in.DatasetID, in.PageType, in.Slug)++ commitID := utility.GenerateUUID()++ diffText := unifiedDiff(in.OldContent, in.NewContent)+ contentAfterStorage := "es"+ contentAfterLocation := in.DocID+ slugKwd := in.Slug+ pageTypeKwd := in.PageType++ item := &entity.FileCommitItem{+ ID: utility.GenerateUUID(),+ CommitID: commitID,+ FileID: fileID,+ Operation: "modify",+ Diff: &diffText,+ ContentAfterStorage: &contentAfterStorage,+ ContentAfterLocation: &contentAfterLocation,+ SlugKwd: &slugKwd,+ PageTypeKwd: &pageTypeKwd,+ }++ var commit *entity.FileCommit+ // Serialize parent selection with insertion in process so two concurrent+ // edits on the same page cannot both read the same parent and fork the+ // chain. This is backend-agnostic (works identically on MySQL and SQLite)+ // and cheaper than row-level DB locks.+ mu := pageCommitLock(fileID)+ mu.Lock()+ defer mu.Unlock()++ // Read the parent inside the lock, on the shared connection, so it always+ // reflects the previously committed edit for this page.+ parentID, perr := s.commitItemDAO.GetLatestCommitIDByFileID(ctx, dao.DB, fileID)+ if perr != nil {+ return nil, fmt.Errorf("failed to resolve page commit parent: %w", perr)+ }++ commit = &entity.FileCommit{+ ID: commitID,+ FolderID: in.DatasetID,+ Message: in.Title,+ AuthorID: in.AuthorID,+ Title: &in.Title,+ FileCount: 1,+ }+ if parentID != "" {+ commit.ParentID = &parentID+ }++ if err := dao.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ if cerr := tx.Create(commit).Error; cerr != nil {+ return fmt.Errorf("failed to create page commit: %w", cerr)+ }+ if ierr := tx.Create(item).Error; ierr != nil {+ return fmt.Errorf("failed to create page commit item: %w", ierr)+ }+ return nil+ }); err != nil {+ return nil, err+ }++ return commit, nil+}++// pageCommitLocks is a per-page-file-key mutex registry that serializes+// RecordPageEdit calls for the same page. Entries are retained for the process+// lifetime (bounded by the number of distinct pages edited).+var pageCommitLocks sync.Map // fileID -> *sync.Mutex++func pageCommitLock(fileID string) *sync.Mutex {+ v, _ := pageCommitLocks.LoadOrStore(fileID, &sync.Mutex{})+ return v.(*sync.Mutex)+}++// ListPageCommits lists audit commits for a specific wiki/skill page.+func (s *FileCommitService) ListPageCommits(ctx context.Context, datasetID, pageType, slug string, page, pageSize int) ([]*entity.FileCommit, int64, error) {+ items, err := s.commitItemDAO.ListByFileID(ctx, dao.DB, wikiFileID(datasetID, pageType, slug))+ if err != nil {+ return nil, 0, err+ }+ commitIDs := make([]string, 0, len(items))+ for _, it := range items {+ commitIDs = append(commitIDs, it.CommitID)+ }+ if len(commitIDs) == 0 {+ return []*entity.FileCommit{}, 0, nil+ }++ commits, total, err := s.commitDAO.ListByIDs(ctx, dao.DB, commitIDs, page, pageSize)+ if err != nil {+ return nil, 0, err+ }+ return commits, total, nil+}++// unifiedDiff produces a simple line-based unified diff between two texts.+func unifiedDiff(oldText, newText string) string {+ oldLines := strings.Split(oldText, "\n")+ newLines := strings.Split(newText, "\n")++ const maxCtx = 3+ type hunkLine struct {+ prefix string+ text string+ }+ var hunks []hunkLine++ // Longest common subsequence over lines, then render the diff.+ cur := make([][]int, len(oldLines)+1)+ for i := range cur {+ cur[i] = make([]int, len(newLines)+1)+ }+ for i := len(oldLines) - 1; i >= 0; i-- {+ for j := len(newLines) - 1; j >= 0; j-- {+ if oldLines[i] == newLines[j] {+ cur[i][j] = cur[i+1][j+1] + 1+ } else if cur[i+1][j] >= cur[i][j+1] {+ cur[i][j] = cur[i+1][j]+ } else {+ cur[i][j] = cur[i][j+1]+ }+ }+ }++ i, j := 0, 0+ for i < len(oldLines) && j < len(newLines) {+ if oldLines[i] == newLines[j] {+ i+++ j+++ } else if cur[i+1][j] >= cur[i][j+1] {+ hunks = append(hunks, hunkLine{"-", oldLines[i]})+ i+++ } else {+ hunks = append(hunks, hunkLine{"+", newLines[j]})+ j+++ }+ }+ for ; i < len(oldLines); i++ {+ hunks = append(hunks, hunkLine{"-", oldLines[i]})+ }+ for ; j < len(newLines); j++ {+ hunks = append(hunks, hunkLine{"+", newLines[j]})+ }++ if len(hunks) == 0 {+ return ""+ }+ if len(hunks) > maxCtx*2 {+ var b strings.Builder+ for k := 0; k < maxCtx; k++ {+ b.WriteString(hunks[k].prefix)+ b.WriteString(hunks[k].text)+ b.WriteString("\n")+ }+ b.WriteString("... (" + fmt.Sprintf("%d", len(hunks)-maxCtx*2) + " lines omitted) ...\n")+ for k := len(hunks) - maxCtx; k < len(hunks); k++ {+ b.WriteString(hunks[k].prefix)+ b.WriteString(hunks[k].text)+ b.WriteString("\n")+ }+ return b.String()+ }+ var b strings.Builder+ for _, h := range hunks {+ b.WriteString(h.prefix)+ b.WriteString(h.text)+ b.WriteString("\n")+ }+ return b.String()+}+// ListCommits lists commits for a workspace folder with paginationfunc (s *FileCommitService) ListCommits(ctx context.Context, folderID string, page, pageSize int, orderBy string, desc bool) ([]*entity.FileCommit, int64, error) {return s.commitDAO.ListByFolderID(ctx, dao.DB, folderID, page, pageSize, orderBy, desc)diff --git a/internal/service/file/file_commit_page_test.go b/internal/service/file/file_commit_page_test.gonew file mode 100644index 0000000000..5f63e66c6d--- /dev/null+++ b/internal/service/file/file_commit_page_test.go@@ -0,0 +1,281 @@+package file++import (+ "context"+ "strconv"+ "strings"+ "sync"+ "testing"++ "ragflow/internal/dao"+ "ragflow/internal/entity"++ "github.com/glebarez/sqlite"+ "gorm.io/gorm"+)++func newPageCommitTestDB(t *testing.T) *gorm.DB {+ t.Helper()+ db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{TranslateError: true})+ if err != nil {+ t.Fatalf("open sqlite: %v", err)+ }+ // Keep a single connection so the :memory: database is shared across all+ // goroutines (sqlite :memory: is otherwise per-connection); this also+ // serializes the concurrent page-commit test through one connection.+ if sqlDB, serr := db.DB(); serr == nil {+ sqlDB.SetMaxOpenConns(1)+ sqlDB.SetMaxIdleConns(1)+ }+ if err := db.AutoMigrate(&entity.FileCommit{}, &entity.FileCommitItem{}); err != nil {+ t.Fatalf("auto migrate: %v", err)+ }+ old := dao.DB+ dao.DB = db+ t.Cleanup(func() { dao.DB = old })+ return db+}++func TestRecordPageEdit_CreatesCommitAndItem(t *testing.T) {+ newPageCommitTestDB(t)+ svc := NewFileCommitService()+ ctx := context.Background()++ in := PageEditCommitInput{+ DatasetID: "kb1",+ DocID: "wiki/page-a",+ Slug: "page-a",+ PageType: "wiki",+ Title: "First edit",+ AuthorID: "u1",+ OldContent: "hello world",+ NewContent: "hello world, edited",+ }+ commit, err := svc.RecordPageEdit(ctx, in)+ if err != nil {+ t.Fatalf("RecordPageEdit: %v", err)+ }+ if commit.ID == "" {+ t.Fatal("expected a generated commit id")+ }+ if commit.AuthorID != "u1" || commit.Message != "First edit" || commit.FileCount != 1 {+ t.Fatalf("unexpected commit: %+v", commit)+ }+ if commit.FolderID != "kb1" {+ t.Fatalf("expected folder_id kb1 for dataset scope, got %s", commit.FolderID)+ }+ if commit.ParentID != nil {+ t.Fatalf("first edit should have no parent, got %v", *commit.ParentID)+ }++ var items []entity.FileCommitItem+ if err := dao.DB.Where("commit_id = ?", commit.ID).Find(&items).Error; err != nil {+ t.Fatalf("load items: %v", err)+ }+ if len(items) != 1 {+ t.Fatalf("expected 1 item, got %d", len(items))+ }+ it := items[0]+ if it.Operation != "modify" {+ t.Fatalf("expected operation modify, got %s", it.Operation)+ }+ if it.FileID != "kb1/wiki/page-a" {+ t.Fatalf("expected file_id kb1/wiki/page-a (dataset-scoped), got %s", it.FileID)+ }+ if it.SlugKwd == nil || *it.SlugKwd != "page-a" {+ t.Fatalf("expected slug_kwd page-a, got %v", it.SlugKwd)+ }+ if it.PageTypeKwd == nil || *it.PageTypeKwd != "wiki" {+ t.Fatalf("expected page_type_kwd wiki, got %v", it.PageTypeKwd)+ }+ if it.Diff == nil || !strings.Contains(*it.Diff, "hello world, edited") {+ t.Fatalf("expected diff containing new content, got %v", it.Diff)+ }+ if it.ContentAfterStorage == nil || *it.ContentAfterStorage != "es" {+ t.Fatalf("expected content_after_storage es, got %v", it.ContentAfterStorage)+ }+ if it.ContentAfterLocation == nil || *it.ContentAfterLocation != "wiki/page-a" {+ t.Fatalf("expected content_after_location wiki/page-a, got %v", it.ContentAfterLocation)+ }+}++func TestRecordPageEdit_SecondEditLinksParent(t *testing.T) {+ newPageCommitTestDB(t)+ svc := NewFileCommitService()+ ctx := context.Background()++ base := PageEditCommitInput{+ DatasetID: "kb1",+ DocID: "wiki/page-a",+ Slug: "page-a",+ PageType: "wiki",+ Title: "first",+ AuthorID: "u1",+ }+ if _, err := svc.RecordPageEdit(ctx, base); err != nil {+ t.Fatalf("first RecordPageEdit: %v", err)+ }++ second := base+ second.Title = "second"+ second.OldContent = "hello"+ second.NewContent = "hello world"+ commit2, err := svc.RecordPageEdit(ctx, second)+ if err != nil {+ t.Fatalf("second RecordPageEdit: %v", err)+ }+ if commit2.ParentID == nil {+ t.Fatal("second edit should link to the first commit as parent")+ }+ var first entity.FileCommit+ if err := dao.DB.Where("title = ?", "first").First(&first).Error; err != nil {+ t.Fatalf("load first commit: %v", err)+ }+ if *commit2.ParentID != first.ID {+ t.Fatalf("parent id mismatch: got %s want %s", *commit2.ParentID, first.ID)+ }+}++func TestRecordPageEdit_IsolatesDatasets(t *testing.T) {+ newPageCommitTestDB(t)+ svc := NewFileCommitService()+ ctx := context.Background()++ mk := func(datasetID string) PageEditCommitInput {+ return PageEditCommitInput{+ DatasetID: datasetID,+ DocID: datasetID + "/wiki/page-a",+ Slug: "page-a",+ PageType: "wiki",+ Title: datasetID + "-edit",+ AuthorID: "u1",+ OldContent: "old",+ NewContent: "new",+ }+ }+ if _, err := svc.RecordPageEdit(ctx, mk("kb1")); err != nil {+ t.Fatalf("kb1 RecordPageEdit: %v", err)+ }+ if _, err := svc.RecordPageEdit(ctx, mk("kb2")); err != nil {+ t.Fatalf("kb2 RecordPageEdit: %v", err)+ }++ // A second edit in kb1 must parent to kb1's own first commit, not kb2's.+ kb1Again := mk("kb1")+ kb1Again.Title = "kb1-edit-2"+ kb1Again.OldContent = "old"+ kb1Again.NewContent = "newer"+ kb1Commit2, err := svc.RecordPageEdit(ctx, kb1Again)+ if err != nil {+ t.Fatalf("kb1 second RecordPageEdit: %v", err)+ }+ if kb1Commit2.ParentID == nil {+ t.Fatal("kb1 second edit should have a parent")+ }++ var kb1First, kb2First entity.FileCommit+ if err := dao.DB.Where("title = ?", "kb1-edit").First(&kb1First).Error; err != nil {+ t.Fatalf("load kb1 first commit: %v", err)+ }+ if err := dao.DB.Where("title = ?", "kb2-edit").First(&kb2First).Error; err != nil {+ t.Fatalf("load kb2 first commit: %v", err)+ }+ if *kb1Commit2.ParentID != kb1First.ID {+ t.Fatalf("kb1 parent mismatch: got %s want %s", *kb1Commit2.ParentID, kb1First.ID)+ }+ if *kb1Commit2.ParentID == kb2First.ID {+ t.Fatal("kb1 parent must not cross into kb2 history")+ }+}++func TestRecordPageEdit_ConcurrentEditsFormLinearChain(t *testing.T) {+ newPageCommitTestDB(t)+ svc := NewFileCommitService()+ ctx := context.Background()++ const edits = 8+ var wg sync.WaitGroup+ errs := make([]error, edits)+ for i := 0; i < edits; i++ {+ wg.Add(1)+ go func(idx int) {+ defer wg.Done()+ in := PageEditCommitInput{+ DatasetID: "kb1",+ DocID: "wiki/page-a",+ Slug: "page-a",+ PageType: "wiki",+ Title: "edit-" + strconv.Itoa(idx),+ AuthorID: "u1",+ OldContent: "old",+ NewContent: "new-" + strconv.Itoa(idx),+ }+ _, errs[idx] = svc.RecordPageEdit(ctx, in)+ }(i)+ }+ wg.Wait()+ for i, e := range errs {+ if e != nil {+ t.Fatalf("edit %d failed: %v", i, e)+ }+ }++ var commits []entity.FileCommit+ if err := dao.DB.Where("folder_id = ?", "kb1").Order("create_time ASC").Find(&commits).Error; err != nil {+ t.Fatalf("load commits: %v", err)+ }+ if len(commits) != edits {+ t.Fatalf("expected %d commits, got %d", edits, len(commits))+ }+ // Every commit except the first must have a parent, and the parents must+ // form a linear chain (no two commits share the same parent).+ seenParents := map[string]bool{}+ for i, c := range commits {+ if i == 0 {+ if c.ParentID != nil {+ t.Fatalf("first commit should have no parent")+ }+ continue+ }+ if c.ParentID == nil {+ t.Fatalf("commit %s should have a parent", c.ID)+ }+ if seenParents[*c.ParentID] {+ t.Fatalf("two commits share parent %s -> forked chain", *c.ParentID)+ }+ seenParents[*c.ParentID] = true+ }+}++func TestUnifiedDiff_EmptyWhenNoChange(t *testing.T) {+ if d := unifiedDiff("same", "same"); d != "" {+ t.Fatalf("expected empty diff for identical text, got %q", d)+ }+}++func TestUnifiedDiff_DetectsAddition(t *testing.T) {+ d := unifiedDiff("a\nb\nc\n", "a\nb\nc\nd\n")+ if !strings.Contains(d, "+d") {+ t.Fatalf("expected diff to contain added line, got %q", d)+ }+}++func TestUnifiedDiff_DetectsRemoval(t *testing.T) {+ d := unifiedDiff("a\nb\nc\n", "a\nc\n")+ if !strings.Contains(d, "-b") {+ t.Fatalf("expected diff to contain removed line, got %q", d)+ }+}++func TestUnifiedDiff_TruncatesLongDiff(t *testing.T) {+ oldLines := make([]string, 50)+ newLines := make([]string, 50)+ for i := range oldLines {+ oldLines[i] = "old-line"+ newLines[i] = "new-line"+ }+ d := unifiedDiff(strings.Join(oldLines, "\n"), strings.Join(newLines, "\n"))+ if !strings.Contains(d, "... ") || !strings.Contains(d, "lines omitted") {+ t.Fatalf("expected long diff to be truncated, got %q", d)+ }+}