Skip to content

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

fix(core): enforce consistent name and alias length limits (#22020)

jay777216ece20514fbf
diff --git a/docs/references/http_api_reference.md b/docs/references/http_api_reference.md
index 01f1cecd5f..b24010e56d 100644
--- a/docs/references/http_api_reference.md
+++ b/docs/references/http_api_reference.md
@@ -8095,7 +8095,7 @@ curl --request POST \
##### Body parameters
- `"name"`: `string`, *Required*
- The name of the search app. Must be unique and no longer than 255 characters.
+ The name of the search app. Must be unique and no longer than 128 characters.
- `"description"`: `string`
A brief description of the search app.
diff --git a/internal/admin/service.go b/internal/admin/service.go
index acc2bf0522..ab7133a295 100644
--- a/internal/admin/service.go
+++ b/internal/admin/service.go
@@ -40,6 +40,7 @@ import (
"ragflow/internal/server"
servicepkg "ragflow/internal/service"
"ragflow/internal/storage"
+ "ragflow/internal/utility"
"regexp"
"strings"
"time"
@@ -216,7 +217,7 @@ func (s *Service) CreateUser(ctx context.Context, username, password, role strin
// 2. Create tenant (tenant_id = user_id)
// tenant name = nickname + "'s Kingdom" (same as Python)
- tenantName := user.Nickname + "'s Kingdom"
+ tenantName := utility.TruncateRunes(user.Nickname+"'s Kingdom", common.TenantNameLimit)
// Get default model IDs from config
cfg := server.GetConfig()
@@ -1549,7 +1550,7 @@ func (s *Service) InitDefaultAdmin() error {
func (s *Service) addTenantForAdmin(userID, nickname string) error {
status := "1"
role := "owner"
- tenantName := nickname + "'s Kingdom"
+ tenantName := utility.TruncateRunes(nickname+"'s Kingdom", common.TenantNameLimit)
tenant := &entity.Tenant{
ID: userID,
diff --git a/internal/common/app_name.go b/internal/common/app_name.go
index f90eb5f039..b33fa93baa 100644
--- a/internal/common/app_name.go
+++ b/internal/common/app_name.go
@@ -22,7 +22,6 @@ import (
"regexp"
"strconv"
"strings"
- "unicode/utf8"
)
// maxNameRetries bounds how many numbered suffixes UniqueName may try before
@@ -55,8 +54,9 @@ func splitNameCounter(stem string) (string, int, bool) {
// counter. Use UniqueFileName for file or document names that must keep their
// extension at the end.
//
-// maxLen is the maximum allowed length in bytes for the generated name;
-// maxLen <= 0 falls back to AppNameLimit.
+// maxLen is the maximum allowed length in Unicode code points for the
+// generated name; maxLen <= 0 falls back to AppNameLimit. Code points match
+// the character semantics of VARCHAR(n) on MySQL and PostgreSQL.
//
// UniqueName("topic", 0, ...) -> "topic(1)"
// UniqueName("topic(1)", 0, ...) -> "topic(2)"
@@ -65,34 +65,27 @@ func splitNameCounter(stem string) (string, int, bool) {
// exists reports whether a candidate already collides. A lookup error is
// returned to the caller instead of being treated as "free".
func UniqueName(name string, maxLen int, exists func(candidate string) (bool, error)) (string, error) {
- return uniqueName(name, maxLen, false, exists, lenBytes)
+ return uniqueName(name, maxLen, false, exists)
}
-// UniqueNameCharacters applies a Unicode character limit when choosing a name.
-func UniqueNameCharacters(name string, maxLen int, exists func(string) (bool, error)) (string, error) {
- return uniqueName(name, maxLen, false, exists, utf8.RuneCountInString)
-}
-
-func lenBytes(name string) int { return len(name) }
-
// UniqueFileName is UniqueName for file and document names: the suffix is
// inserted before the file extension instead of at the end of the name.
//
// UniqueFileName("report.pdf", 0, ...) -> "report(1).pdf"
// UniqueFileName("report(1).pdf", 0, ...) -> "report(2).pdf"
func UniqueFileName(name string, maxLen int, exists func(candidate string) (bool, error)) (string, error) {
- return uniqueName(name, maxLen, true, exists, lenBytes)
+ return uniqueName(name, maxLen, true, exists)
}
// uniqueName appends an incrementing "(N)" suffix until exists reports the
// candidate as free. keepExtension inserts the suffix before the file
// extension instead of at the end of the name.
-func uniqueName(name string, maxLen int, keepExtension bool, exists func(candidate string) (bool, error), length func(string) int) (string, error) {
+func uniqueName(name string, maxLen int, keepExtension bool, exists func(candidate string) (bool, error)) (string, error) {
if maxLen <= 0 {
maxLen = AppNameLimit
}
current := name
- if err := validateNameLength(current, maxLen, length(current)); err != nil {
+ if err := ValidateNameRunes(current, maxLen); err != nil {
return "", err
}
for i := 0; i < maxNameRetries; i++ {
@@ -115,7 +108,7 @@ func uniqueName(name string, maxLen int, keepExtension bool, exists func(candida
base = stem
}
current = fmt.Sprintf("%s(%d)%s", base, counter+1, ext)
- if err := validateNameLength(current, maxLen, length(current)); err != nil {
+ if err := ValidateNameRunes(current, maxLen); err != nil {
return "", err
}
}
@@ -142,29 +135,7 @@ func NameAvailable(currentName, newName string, exists func(candidate string) (b
return !taken, nil
}
-// AppNameLimit is the maximum allowed length of a name, in bytes.
-const AppNameLimit = 256
-
-// ValidateName rejects empty names and names longer than AppNameLimit bytes.
-func ValidateName(name string) error {
- return validateNameLimit(name, AppNameLimit)
-}
-
-// validateNameLimit rejects empty names and names longer than maxLen bytes.
-func validateNameLimit(name string, maxLen int) error {
- return validateNameLength(name, maxLen, len(name))
-}
-
-func validateNameLength(name string, maxLen, length int) error {
- // Validate name is not empty after trimming
- trimmedName := strings.TrimSpace(name)
- if trimmedName == "" {
- return fmt.Errorf("name cannot be empty or whitespace")
- }
-
- if length > maxLen {
- return fmt.Errorf("name length is %d which is large than %d", length, maxLen)
- }
-
- return nil
-}
+// AppNameLimit is the fallback maximum length of a name, in Unicode code
+// points, when a caller does not pass a column-specific limit. It matches the
+// widest user-facing name column.
+const AppNameLimit = NameLimit255
diff --git a/internal/common/app_name_test.go b/internal/common/app_name_test.go
index a8bfc7413c..30e51ee506 100644
--- a/internal/common/app_name_test.go
+++ b/internal/common/app_name_test.go
@@ -131,7 +131,7 @@ func TestUniqueName_EnforcesCallerLimit(t *testing.T) {
if _, err := UniqueName(base, 128, onlyBaseTaken); err == nil {
t.Fatal("expected length validation error for generated name at caller limit")
- } else if !strings.Contains(err.Error(), "large than") {
+ } else if !strings.Contains(err.Error(), "larger than") {
t.Fatalf("unexpected error: %v", err)
}
@@ -192,14 +192,59 @@ func TestNameAvailable_PropagatesLookupError(t *testing.T) {
}
}
-func TestValidateName(t *testing.T) {
- if err := ValidateName(" "); err == nil {
+func TestUniqueName_CountsRunesNotBytes(t *testing.T) {
+ // 128 CJK characters are 384 bytes but still fit a VARCHAR(128) column.
+ base := strings.Repeat("报", 128)
+ if _, err := UniqueName(base, 128, func(string) (bool, error) { return false, nil }); err != nil {
+ t.Fatalf("UniqueName rejected 128 CJK characters: %v", err)
+ }
+ if _, err := UniqueName(base+"告", 128, func(string) (bool, error) { return false, nil }); err == nil {
+ t.Fatal("expected 129 CJK characters to be rejected")
+ }
+}
+
+func TestUniqueFileName_CountsRunesNotBytes(t *testing.T) {
+ base := strings.Repeat("报", 251) + ".pdf" // 255 characters
+ if _, err := UniqueFileName(base, 255, func(string) (bool, error) { return false, nil }); err != nil {
+ t.Fatalf("UniqueFileName rejected 255 CJK characters: %v", err)
+ }
+ if _, err := UniqueFileName(strings.Repeat("报", 252)+".pdf", 255, func(string) (bool, error) { return false, nil }); err == nil {
+ t.Fatal("expected 256 characters to be rejected")
+ }
+}
+
+func TestValidateNameRunes(t *testing.T) {
+ if err := ValidateNameRunes(" ", 128); err == nil {
t.Fatal("expected empty name error")
}
- if err := ValidateName(strings.Repeat("a", AppNameLimit+1)); err == nil {
+ if err := ValidateNameRunes(strings.Repeat("a", 128), 128); err != nil {
+ t.Fatalf("unexpected error at limit: %v", err)
+ }
+ if err := ValidateNameRunes(strings.Repeat("a", 129), 128); err == nil {
t.Fatal("expected length error")
}
- if err := ValidateName("ok"); err != nil {
+ if err := ValidateNameRunes(" "+strings.Repeat("a", 128), 128); err == nil {
+ t.Fatal("expected whitespace to count toward the stored length")
+ }
+ if err := ValidateNameRunes(strings.Repeat("报", 128), 128); err != nil {
+ t.Fatalf("unexpected error for 128 CJK characters: %v", err)
+ }
+ if err := ValidateNameRunes("ok", 128); err != nil {
t.Fatalf("unexpected error for valid name: %v", err)
}
}
+
+func TestValidateAliasRunes(t *testing.T) {
+ if err := ValidateAliasRunes("", 255); err != nil {
+ t.Fatalf("empty alias should be valid: %v", err)
+ }
+ if err := ValidateAliasRunes(" ", 255); err != nil {
+ t.Fatalf("whitespace alias should be valid: %v", err)
+ }
+ if err := ValidateAliasRunes(strings.Repeat("a", 255), 255); err != nil {
+ t.Fatalf("alias at limit should be valid: %v", err)
+ }
+ if err := ValidateAliasRunes(strings.Repeat("a", 256), 255); err == nil {
+ t.Fatal("expected alias length error")
+ }
+}
diff --git a/internal/common/name_limit.go b/internal/common/name_limit.go
new file mode 100644
index 0000000000..afafccb8a6
--- /dev/null
+++ b/internal/common/name_limit.go
@@ -0,0 +1,64 @@
+//
+// 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 common
+
+import (
+ "errors"
+ "fmt"
+ "strings"
+ "unicode/utf8"
+)
+
+// Name limits are Unicode code points, matching VARCHAR(n) on MySQL and
+// PostgreSQL. Callers pass the width of the column they are about to write.
+const (
+ NameLimit128 = 128
+ NameLimit255 = 255
+
+ NicknameLimit = 100
+ TenantNameLimit = 128
+
+ PipelineTitleLimit = 255
+ VersionTitleLimit = 255
+
+ // VersionTitleTimeLayout is the timestamp suffix buildVersionTitle appends
+ // to a canvas title. VersionBaseTitleLimit leaves room for that suffix.
+ VersionTitleTimeLayout = "2006-01-02 15:04:05"
+ VersionBaseTitleLimit = VersionTitleLimit - (1 + len(VersionTitleTimeLayout))
+)
+
+// ValidateNameRunes rejects empty names and names longer than max Unicode
+// code points. It mirrors the character semantics of a VARCHAR(max) column.
+func ValidateNameRunes(name string, max int) error {
+ trimmed := strings.TrimSpace(name)
+ if trimmed == "" {
+ return errors.New("name cannot be empty or whitespace")
+ }
+ if length := utf8.RuneCountInString(name); length > max {
+ return fmt.Errorf("name length is %d which is larger than %d", length, max)
+ }
+ return nil
+}
+
+// ValidateAliasRunes validates an optional alias. An empty alias means "no
+// alias" and is valid; a non-empty alias must fit max Unicode code points.
+func ValidateAliasRunes(alias string, max int) error {
+ if strings.TrimSpace(alias) == "" {
+ return nil
+ }
+ return ValidateNameRunes(alias, max)
+}
diff --git a/internal/dao/migration.go b/internal/dao/migration.go
index fffb4d0448..1fb065451a 100644
--- a/internal/dao/migration.go
+++ b/internal/dao/migration.go
@@ -63,6 +63,10 @@ func RunMigrations(ctx context.Context, db *gorm.DB) error {
return fmt.Errorf("failed to modify column types: %w", err)
}
+ if err := migrateNameColumnWidths(ctx, db); err != nil {
+ return fmt.Errorf("failed to widen name columns: %w", err)
+ }
+
// Add case-insensitive unique constraint on knowledgebase (tenant_id, name)
if err := migrateKnowledgebaseNameUnique(ctx, db); err != nil {
return fmt.Errorf("failed to add unique index on knowledgebase (tenant_id, name): %w", err)
@@ -117,6 +121,59 @@ func dropModelGroupTables(ctx context.Context, db *gorm.DB) error {
return nil
}
+// migrateNameColumnWidths widens name columns whose values are copied from a
+// wider source. It is idempotent: it reads the current width and only issues
+// DDL when the column is narrower than the target.
+//
+// On MySQL, widening pipeline_title from varchar(32) to varchar(255) changes
+// the VARCHAR length prefix for utf8mb4 and can rebuild the table. Run it
+// through the standalone --migrate action during a maintenance window.
+func migrateNameColumnWidths(ctx context.Context, db *gorm.DB) error {
+ specs := []struct {
+ model any
+ field string
+ table string
+ column string
+ width int64
+ }{
+ {&entity.PipelineOperationLog{}, "PipelineTitle", "pipeline_operation_log", "pipeline_title", common.PipelineTitleLimit},
+ {&entity.Tenant{}, "Name", "tenant", "name", common.TenantNameLimit},
+ }
+
+ migrator := db.WithContext(ctx).Migrator()
+ for _, spec := range specs {
+ if !migrator.HasTable(spec.model) {
+ continue
+ }
+ types, err := migrator.ColumnTypes(spec.model)
+ if err != nil {
+ return fmt.Errorf("read %s columns: %w", spec.table, err)
+ }
+ for _, ct := range types {
+ if ct.Name() != spec.column {
+ continue
+ }
+ length, ok := ct.Length()
+ if !ok {
+ // Dialects that cannot report a width are left to AutoMigrate.
+ break
+ }
+ if length >= spec.width {
+ break
+ }
+ if err := migrator.AlterColumn(spec.model, spec.field); err != nil {
+ return fmt.Errorf("widen %s.%s to %d: %w", spec.table, spec.column, spec.width, err)
+ }
+ common.Info("Widened name column",
+ zap.String("table", spec.table),
+ zap.String("column", spec.column),
+ zap.Int64("width", spec.width))
+ break
+ }
+ }
+ return nil
+}
+
// migrateTenantLLMPrimaryKey migrates tenant_llm from its legacy composite
// primary key (tenant_id, llm_factory, llm_name) to a surrogate auto-increment
// "id" column.
diff --git a/internal/dao/migration_integration_test.go b/internal/dao/migration_integration_test.go
index d9daa936eb..683b6de7ed 100644
--- a/internal/dao/migration_integration_test.go
+++ b/internal/dao/migration_integration_test.go
@@ -369,3 +369,115 @@ func TestMigrateIngestionTaskDocumentIDUnique_Integration(t *testing.T) {
}
})
}
+
+// TestMigrateNameColumnWidths_Integration verifies that the legacy 32-character
+// pipeline_title and 100-character tenant.name columns are widened in place and
+// keep their existing values. It needs a throwaway database because it creates
+// and drops the real table names.
+func TestMigrateNameColumnWidths_Integration(t *testing.T) {
+ dsn := os.Getenv("RAGFLOW_TEST_MYSQL_DSN")
+ if dsn == "" {
+ t.Skip("RAGFLOW_TEST_MYSQL_DSN unset: this test needs a throwaway MySQL database")
+ }
+
+ db, err := gorm.Open(newMigrationAwareDialector(dsn), &gorm.Config{TranslateError: true})
+ if err != nil {
+ t.Fatalf("failed to connect: %v", err)
+ }
+ sqlDB, err := db.DB()
+ if err != nil {
+ t.Fatalf("failed to get database connection pool: %v", err)
+ }
+ t.Cleanup(func() {
+ if err := sqlDB.Close(); err != nil {
+ t.Errorf("failed to close database connection pool: %v", err)
+ }
+ })
+
+ if db.Migrator().HasTable("pipeline_operation_log") || db.Migrator().HasTable("tenant") {
+ t.Skip("test database already contains pipeline_operation_log or tenant; use a throwaway database")
+ }
+ t.Cleanup(func() {
+ db.Exec("DROP TABLE IF EXISTS pipeline_operation_log")
+ db.Exec("DROP TABLE IF EXISTS tenant")
+ })
+
+ ctx := context.Background()
+ if err := db.Exec(`CREATE TABLE pipeline_operation_log (
+ id varchar(32) PRIMARY KEY,
+ pipeline_title varchar(32) NULL,
+ KEY idx_pipeline_operation_log_pipeline_title (pipeline_title)
+ )`).Error; err != nil {
+ t.Fatalf("create pipeline_operation_log: %v", err)
+ }
+ if err := db.Exec(`CREATE TABLE tenant (
+ id varchar(32) PRIMARY KEY,
+ name varchar(100) NULL
+ )`).Error; err != nil {
+ t.Fatalf("create tenant: %v", err)
+ }
+
+ legacyTitle := strings.Repeat("a", 32)
+ legacyTenant := strings.Repeat("b", 100)
+ if err := db.Exec(`INSERT INTO pipeline_operation_log (id, pipeline_title) VALUES (?, ?)`, "log-1", legacyTitle).Error; err != nil {
+ t.Fatalf("seed pipeline_operation_log: %v", err)
+ }
+ if err := db.Exec(`INSERT INTO tenant (id, name) VALUES (?, ?)`, "tenant-1", legacyTenant).Error; err != nil {
+ t.Fatalf("seed tenant: %v", err)
+ }
+
+ if err := migrateNameColumnWidths(ctx, db); err != nil {
+ t.Fatalf("migrateNameColumnWidths failed: %v", err)
+ }
+
+ if got := columnLength(t, db, &entity.PipelineOperationLog{}, "pipeline_title"); got != common.PipelineTitleLimit {
+ t.Fatalf("pipeline_title width = %d, want %d", got, common.PipelineTitleLimit)
+ }
+ if !db.Migrator().HasIndex(&entity.PipelineOperationLog{}, "idx_pipeline_operation_log_pipeline_title") {
+ t.Fatal("pipeline_title index was dropped by the width migration")
+ }
+ if got := columnLength(t, db, &entity.Tenant{}, "name"); got != common.TenantNameLimit {
+ t.Fatalf("tenant.name width = %d, want %d", got, common.TenantNameLimit)
+ }
+
+ var title string
+ if err := db.Raw(`SELECT pipeline_title FROM pipeline_operation_log WHERE id = ?`, "log-1").Scan(&title).Error; err != nil {
+ t.Fatalf("read pipeline_title: %v", err)
+ }
+ if title != legacyTitle {
+ t.Fatalf("pipeline_title = %q, want %q", title, legacyTitle)
+ }
+ var tenantName string
+ if err := db.Raw(`SELECT name FROM tenant WHERE id = ?`, "tenant-1").Scan(&tenantName).Error; err != nil {
+ t.Fatalf("read tenant.name: %v", err)
+ }
+ if tenantName != legacyTenant {
+ t.Fatalf("tenant.name = %q, want %q", tenantName, legacyTenant)
+ }
+
+ // The widened columns must accept values that previously failed with 1406.
+ longTitle := strings.Repeat("c", common.PipelineTitleLimit)
+ if err := db.Exec(`UPDATE pipeline_operation_log SET pipeline_title = ? WHERE id = ?`, longTitle, "log-1").Error; err != nil {
+ t.Fatalf("store widened pipeline_title: %v", err)
+ }
+}
+
+func columnLength(t *testing.T, db *gorm.DB, model any, column string) int64 {
+ t.Helper()
+ types, err := db.Migrator().ColumnTypes(model)
+ if err != nil {
+ t.Fatalf("read column types: %v", err)
+ }
+ for _, ct := range types {
+ if ct.Name() != column {
+ continue
+ }
+ length, ok := ct.Length()
+ if !ok {
+ t.Fatalf("column %s does not report a length", column)
+ }
+ return length
+ }
+ t.Fatalf("column %s not found", column)
+ return 0
+}
diff --git a/internal/entity/dataset.go b/internal/entity/dataset.go
index 72b7344a2c..74c8c17a4d 100644
--- a/internal/entity/dataset.go
+++ b/internal/entity/dataset.go
@@ -19,10 +19,12 @@ package entity
import (
"strings"
"time"
+
+ "ragflow/internal/common"
)
-// DatasetNameLimit is the maximum length for dataset name
-const DatasetNameLimit = 128
+// DatasetNameLimit is the maximum length for a dataset name.
+const DatasetNameLimit = common.NameLimit128
// Status represents the status enum values
type Status string
diff --git a/internal/entity/pipeline.go b/internal/entity/pipeline.go
index 2806a10b38..ce4a2f0e3f 100644
--- a/internal/entity/pipeline.go
+++ b/internal/entity/pipeline.go
@@ -32,7 +32,7 @@ type PipelineOperationLog struct {
TenantID string `gorm:"column:tenant_id;size:32;not null;index" json:"tenant_id"`
KbID string `gorm:"column:kb_id;size:32;not null;index" json:"kb_id"`
PipelineID *string `gorm:"column:pipeline_id;size:32;index" json:"pipeline_id,omitempty"`
- PipelineTitle *string `gorm:"column:pipeline_title;size:32;index" json:"pipeline_title,omitempty"`
+ PipelineTitle *string `gorm:"column:pipeline_title;size:255;index" json:"pipeline_title,omitempty"`
PipelineVersionID *string `gorm:"column:pipeline_version_id;size:32" json:"pipeline_version_id,omitempty"`
ParserID string `gorm:"column:parser_id;size:32;not null;index" json:"parser_id"`
DocumentName string `gorm:"column:document_name;size:255;not null" json:"document_name"`
diff --git a/internal/entity/tenant.go b/internal/entity/tenant.go
index 1a5896008f..bc913705d6 100644
--- a/internal/entity/tenant.go
+++ b/internal/entity/tenant.go
@@ -19,7 +19,7 @@ package entity
// Tenant tenant model
type Tenant struct {
ID string `gorm:"column:id;primaryKey;size:32" json:"id"`
- Name *string `gorm:"column:name;size:100;index" json:"name,omitempty"`
+ Name *string `gorm:"column:name;size:128;index" json:"name,omitempty"`
PublicKey *string `gorm:"column:public_key;size:255;index" json:"public_key,omitempty"`
ParserIDs string `gorm:"column:parser_ids;size:256;not null;index" json:"parser_ids"`
Credit int `gorm:"column:credit;default:512;index" json:"credit"`
diff --git a/internal/handler/chat_channel.go b/internal/handler/chat_channel.go
index 0eed41658a..03b1557bd2 100644
--- a/internal/handler/chat_channel.go
+++ b/internal/handler/chat_channel.go
@@ -64,6 +64,11 @@ func (h *ChatChannelHandler) CreateChatChannel(c *gin.Context) {
if req.Config == nil {
req.Config = entity.JSONMap{}
}
+ req.Name = strings.TrimSpace(req.Name)
+ if err := common.ValidateNameRunes(req.Name, common.NameLimit128); err != nil {
+ common.RespondError(c, common.CodeDataError, err.Error())
+ return
+ }
ctx := c.Request.Context()
diff --git a/internal/handler/connector.go b/internal/handler/connector.go
index 29e275d240..1e045ef7b6 100644
--- a/internal/handler/connector.go
+++ b/internal/handler/connector.go
@@ -306,7 +306,7 @@ func (h *ConnectorHandler) CreateConnector(c *gin.Context) {
connector, err := h.connectorService.CreateConnector(ctx, &req)
if err != nil {
- if errors.Is(err, service.ErrConnectorInvalidFreq) {
+ if errors.Is(err, service.ErrConnectorInvalidFreq) || errors.Is(err, service.ErrConnectorInvalidName) {
common.RespondError(c, common.CodeDataError, err.Error())
return
}
diff --git a/internal/handler/document.go b/internal/handler/document.go
index 01ba0d7275..4de00178eb 100644
--- a/internal/handler/document.go
+++ b/internal/handler/document.go
@@ -1053,8 +1053,8 @@ func (h *DocumentHandler) uploadLocalDocuments(c *gin.Context, kb *entity.Knowle
common.RespondError(c, common.CodeArgumentError, "No file selected!")
return
}
- if len([]byte(fh.Filename)) > 255 {
- common.RespondError(c, common.CodeArgumentError, "File name must be 255 bytes or less.")
+ if err := common.ValidateNameRunes(fh.Filename, common.NameLimit255); err != nil {
+ common.RespondError(c, common.CodeArgumentError, "File name must be at most 255 characters.")
return
}
}
@@ -1115,8 +1115,8 @@ func (h *DocumentHandler) uploadEmptyDocument(c *gin.Context, kb *entity.Knowled
common.RespondError(c, common.CodeArgumentError, "File name can't be empty.")
return
}
- if len([]byte(name)) > 255 {
- common.RespondError(c, common.CodeArgumentError, "File name must be 255 bytes or less.")
+ if err := common.ValidateNameRunes(name, common.NameLimit255); err != nil {
+ common.RespondError(c, common.CodeArgumentError, "File name must be at most 255 characters.")
return
}
ctx := c.Request.Context()
@@ -1139,8 +1139,8 @@ func (h *DocumentHandler) uploadWebDocument(c *gin.Context, kb *entity.Knowledge
common.RespondError(c, common.CodeArgumentError, `Lack of "url"`)
return
}
- if len([]byte(name)) > 255 {
- common.RespondError(c, common.CodeArgumentError, "File name must be 255 bytes or less.")
+ if err := common.ValidateNameRunes(name, common.NameLimit255); err != nil {
+ common.RespondError(c, common.CodeArgumentError, "File name must be at most 255 characters.")
return
}
if !isValidHTTPURL(rawURL) {
diff --git a/internal/handler/file_commit.go b/internal/handler/file_commit.go
index c704e97857..b6e38bf732 100644
--- a/internal/handler/file_commit.go
+++ b/internal/handler/file_commit.go
@@ -156,7 +156,7 @@ func commitFolderID(c *gin.Context) string {
// CreateCommitRequest represents the request body for creating a commit
type CreateCommitRequest struct {
- Message string `json:"message" binding:"required"`
+ Message string `json:"message" binding:"required,max=512"`
Files []entity.FileChange `json:"files" binding:"required"`
}
@@ -195,9 +195,10 @@ func (h *FileCommitHandler) CreateCommit(c *gin.Context) {
ctx := c.Request.Context()
commit, err := h.commitService.CreateCommit(ctx, folderID, user.ID, req.Message, req.Files)
if err != nil {
- // A delete change for a file that is still in the folder is caller
- // input, not a server fault.
- if errors.Is(err, file.ErrDeleteLiveFile) {
+ // A delete change for a file that is still in the folder, or a rename
+ // with an empty or overlong target, is caller input, not a server
+ // fault.
+ if errors.Is(err, file.ErrDeleteLiveFile) || errors.Is(err, file.ErrInvalidRenameTarget) {
common.RespondError(c, common.CodeBadRequest, err.Error())
return
}
diff --git a/internal/handler/file_commit_test.go b/internal/handler/file_commit_test.go
index ae6e3033ba..30f311c8ae 100644
--- a/internal/handler/file_commit_test.go
+++ b/internal/handler/file_commit_test.go
@@ -303,6 +303,31 @@ func TestFileCommit_CreateCommit_DeleteLiveFileIsBadRequest(t *testing.T) {
}
}
+func TestFileCommit_CreateCommit_InvalidRenameIsBadRequest(t *testing.T) {
+ r, mock := setupFileCommitTest("user-1")
+ mock.createCommitFn = func(ctx context.Context, folderID, authorID, message string, changes []entity.FileChange) (*entity.FileCommit, error) {
+ return nil, fmt.Errorf("%w: f1", file.ErrInvalidRenameTarget)
+ }
+
+ body := `{"message": "rename", "files": [{"file_id": "f1", "file_name": "test.txt", "operation": "rename", "new_name": ""}]}`
+ w := httptest.NewRecorder()
+ req, _ := http.NewRequest("POST", "/api/v1/folders/folder-1/commits", strings.NewReader(body))
+ req.Header.Set("Content-Type", "application/json")
+ r.ServeHTTP(w, req)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+ }
+ var resp map[string]interface{}
+ if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
+ t.Fatal(err)
+ }
+ // An invalid rename target is caller input, not a server error.
+ if code, _ := resp["code"].(float64); code != float64(common.CodeBadRequest) {
+ t.Errorf("expected bad request, got code %v", code)
+ }
+}
+
func TestFileCommit_CreateCommit_RejectsFileOutsideFolder(t *testing.T) {
r, mock := setupFileCommitTest("user-1")
mock.createCommitFn = func(ctx context.Context, folderID, authorID, message string, changes []entity.FileChange) (*entity.FileCommit, error) {
diff --git a/internal/handler/search.go b/internal/handler/search.go
index b3f557ea67..503e9177b8 100644
--- a/internal/handler/search.go
+++ b/internal/handler/search.go
@@ -151,7 +151,7 @@ func (h *SearchHandler) ListSearches(c *gin.Context) {
// @Router /api/v1/searches [post]
type CreateSearchRequest struct {
- Name string `json:"name"` // required, validated via common.ValidateName (max 255 bytes)
+ Name string `json:"name"` // required, max 128 characters
Description *string `json:"description,omitempty"` // optional description
}
@@ -172,7 +172,7 @@ func (h *SearchHandler) CreateSearch(c *gin.Context) {
return
}
- if err = common.ValidateName(req.Name); err != nil {
+ if err = common.ValidateNameRunes(req.Name, common.NameLimit128); err != nil {
common.RespondError(c, common.CodeDataError, err.Error())
return
}
@@ -296,7 +296,7 @@ func (h *SearchHandler) UpdateSearch(c *gin.Context) {
}
// Validate name (same as Python validation)
- if err := common.ValidateName(req.Name); err != nil {
+ if err := common.ValidateNameRunes(req.Name, common.NameLimit128); err != nil {
common.RespondError(c, common.CodeDataError, err.Error())
return
}
diff --git a/internal/handler/skill_search.go b/internal/handler/skill_search.go
index 230c6fb481..8de26c59c3 100644
--- a/internal/handler/skill_search.go
+++ b/internal/handler/skill_search.go
@@ -390,11 +390,11 @@ func (h *SkillSearchHandler) GetSpace(c *gin.Context) {
// UpdateSpaceRequest represents the request to update a skill space
type UpdateSpaceRequest struct {
- Name string `json:"name"`
- Description string `json:"description"`
- EmbdID string `json:"embd_id"`
- RerankID string `json:"rerank_id"`
- TopK int `json:"top_k"`
+ Name *string `json:"name"`
+ Description string `json:"description"`
+ EmbdID string `json:"embd_id"`
+ RerankID string `json:"rerank_id"`
+ TopK int `json:"top_k"`
}
// UpdateSpace handles the update skill space request
diff --git a/internal/service/agent.go b/internal/service/agent.go
index 2a5527f58c..8bb091d673 100644
--- a/internal/service/agent.go
+++ b/internal/service/agent.go
@@ -48,6 +48,7 @@ import (
"ragflow/internal/entity"
permissionresponse "ragflow/internal/permission/response"
"ragflow/internal/tokenizer"
+ "ragflow/internal/utility"
dslpkg "ragflow/internal/agent/dsl"
)
@@ -1010,6 +1011,9 @@ func (s *AgentService) CreateAgent(ctx context.Context, req *CreateAgentRequest)
return nil, common.CodeArgumentError, errors.New("no title in request")
}
title := strings.TrimSpace(*req.Title)
+ if err := common.ValidateNameRunes(title, common.NameLimit255); err != nil {
+ return nil, common.CodeArgumentError, fmt.Errorf("create agent: %w", err)
+ }
req.Title = &title
if req.Permission == "" {
@@ -1019,7 +1023,7 @@ func (s *AgentService) CreateAgent(ctx context.Context, req *CreateAgentRequest)
req.CanvasCategory = "agent_canvas"
}
- uniqueTitle, err := common.UniqueName(title, 255, func(candidate string) (bool, error) {
+ uniqueTitle, err := common.UniqueName(title, common.NameLimit255, func(candidate string) (bool, error) {
return s.canvasDAO.TitleExists(ctx, dao.DB, userID, req.CanvasCategory, candidate, "")
})
if err != nil {
@@ -1199,9 +1203,15 @@ func (s *AgentService) UpdateAgent(ctx context.Context, canvasID string, patch m
for _, key := range []string{"title", "avatar", "description", "permission", "canvas_type", "canvas_category"} {
if value, ok := patch[key]; ok && value != nil {
if key == "title" {
- if title, ok := value.(string); ok {
- value = strings.TrimSpace(title)
+ title, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("update agent %s: title must be a string", canvasID)
+ }
+ title = strings.TrimSpace(title)
+ if err := common.ValidateNameRunes(title, common.NameLimit255); err != nil {
+ return fmt.Errorf("update agent %s: %w", canvasID, err)
}
+ value = title
}
if key == "permission" {
if permissionValue, ok := value.(string); ok {
@@ -1250,8 +1260,16 @@ func (s *AgentService) UpdateAgent(ctx context.Context, canvasID string, patch m
// Optional alias carried on a manual Save (design §4.4 carry-on path).
var aliasPtr *string
if value, ok := patch["alias"]; ok && value != nil {
- if s, ok := value.(string); ok && strings.TrimSpace(s) != "" {
- aliasPtr = &s
+ alias, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("update agent %s: alias must be a string", canvasID)
+ }
+ alias = strings.TrimSpace(alias)
+ if err := common.ValidateAliasRunes(alias, common.NameLimit255); err != nil {
+ return fmt.Errorf("update agent %s: %w", canvasID, err)
+ }
+ if alias != "" {
+ aliasPtr = &alias
}
}
// ApplyVersion restore path: restoring a version refreshes only the live
@@ -1436,13 +1454,25 @@ func (s *AgentService) PublishAgent(ctx context.Context, canvasID string, req *P
}
if req.Title != nil {
trimmed := strings.TrimSpace(*req.Title)
+ if err := common.ValidateNameRunes(trimmed, common.NameLimit255); err != nil {
+ return nil, fmt.Errorf("publish agent %s: %w", canvasID, err)
+ }
title = &trimmed
}
if req.Description != nil {
description = req.Description
}
if req.Alias != nil {
- alias = req.Alias
+ aliasValue := strings.TrimSpace(*req.Alias)
+ if err := common.ValidateAliasRunes(aliasValue, common.NameLimit255); err != nil {
+ return nil, fmt.Errorf("publish agent %s: %w", canvasID, err)
+ }
+ alias = &aliasValue
+ }
+ }
+ if title != nil {
+ if err := common.ValidateNameRunes(*title, common.NameLimit255); err != nil {
+ return nil, fmt.Errorf("publish agent %s: %w", canvasID, err)
}
}
@@ -1502,7 +1532,10 @@ func buildVersionTitle(agentTitle string, ts time.Time) string {
if title == "" {
title = "agent"
}
- return fmt.Sprintf("%s_%s", title, ts.Format("2006-01-02 15:04:05"))
+ // user_canvas_version.title is VARCHAR(255); reserve room for the timestamp
+ // suffix so a maximum-length canvas title cannot overflow the version row.
+ title = utility.TruncateRunes(title, common.VersionBaseTitleLimit)
+ return fmt.Sprintf("%s_%s", title, ts.Format(common.VersionTitleTimeLayout))
}
// ListVersions returns every version for a canvas the user can see,
@@ -1595,6 +1628,20 @@ func (s *AgentService) UpdateVersion(ctx context.Context, canvasID, versionID st
if row.UserCanvasID != canvasID {
return dao.ErrUserCanvasVersionNotFound
}
+ if patch.Alias != nil {
+ alias := strings.TrimSpace(*patch.Alias)
+ if err := common.ValidateAliasRunes(alias, common.NameLimit255); err != nil {
+ return err
+ }
+ patch.Alias = &alias
+ }
+ if patch.Title != nil {
+ title := strings.TrimSpace(*patch.Title)
+ if err := common.ValidateNameRunes(title, common.NameLimit255); err != nil {
+ return err
+ }
+ patch.Title = &title
+ }
return dao.DB.Transaction(func(tx *gorm.DB) error {
return s.versionDAO.UpdateTx(ctx, tx, versionID, patch)
})
diff --git a/internal/service/agent_sessions.go b/internal/service/agent_sessions.go
index f2f7ad768d..cd9a4a9ae7 100644
--- a/internal/service/agent_sessions.go
+++ b/internal/service/agent_sessions.go
@@ -666,6 +666,9 @@ func (s *AgentService) CreateAgentSession(ctx context.Context, req *CreateAgentS
if name == "" {
name = "session"
}
+ if err := common.ValidateNameRunes(name, common.NameLimit255); err != nil {
+ return nil, common.CodeDataError, err
+ }
var namePtr = &name
var sourcePtr *string
if req.Source != "" {
diff --git a/internal/service/agent_test.go b/internal/service/agent_test.go
index 8f05fb8324..c325c6f008 100644
--- a/internal/service/agent_test.go
+++ b/internal/service/agent_test.go
@@ -26,6 +26,7 @@ import (
"strings"
"testing"
"time"
+ "unicode/utf8"
"ragflow/internal/agent/canvas"
"ragflow/internal/common"
@@ -2142,6 +2143,71 @@ func seedAgentServiceCreateContext(t *testing.T) context.Context {
return permission.WithIdentity(t.Context(), "user-1", "tenant-agent")
}
+func TestCreateAgentRejectsOverlongTitle(t *testing.T) {
+ setupAgentSessionServiceTest(t)
+ ctx := seedAgentServiceCreateContext(t)
+
+ title := strings.Repeat("a", common.NameLimit255+1)
+ row, code, err := NewAgentService().CreateAgent(ctx, &CreateAgentRequest{
+ Title: &title,
+ DSL: entity.JSONMap{},
+ })
+ if row != nil || code != common.CodeArgumentError || err == nil {
+ t.Fatalf("CreateAgent overlong title = (%+v, %d, %v), want argument error", row, code, err)
+ }
+}
+
+func TestUpdateAgentRejectsOverlongTitle(t *testing.T) {
+ setupAgentSessionServiceTest(t)
+ ctx := serviceTestContext(t, "user-1", "user-1")
+
+ if err := dao.DB.WithContext(ctx).Create(&entity.UserCanvas{
+ ID: "canvas-overlong-title",
+ UserID: "user-1",
+ Title: sptr("Short Title"),
+ CanvasCategory: "agent_canvas",
+ DSL: entity.JSONMap{},
+ }).Error; err != nil {
+ t.Fatalf("failed to seed agent: %v", err)
+ }
+
+ err := NewAgentService().UpdateAgent(ctx, "canvas-overlong-title", map[string]interface{}{
+ "title": strings.Repeat("a", common.NameLimit255+1),
+ })
+ if err == nil || !strings.Contains(err.Error(), "larger than") {
+ t.Fatalf("UpdateAgent overlong title error = %v, want length error", err)
+ }
+}
+
+func TestUpdateAgentRejectsOverlongAlias(t *testing.T) {
+ setupAgentSessionServiceTest(t)
+ ctx := serviceTestContext(t, "user-1", "user-1")
+
+ if err := dao.DB.WithContext(ctx).Create(&entity.UserCanvas{
+ ID: "canvas-overlong-alias",
+ UserID: "user-1",
+ Title: sptr("Short Title"),
+ CanvasCategory: "agent_canvas",
+ DSL: entity.JSONMap{},
+ }).Error; err != nil {
+ t.Fatalf("failed to seed agent: %v", err)
+ }
+
+ err := NewAgentService().UpdateAgent(ctx, "canvas-overlong-alias", map[string]interface{}{
+ "alias": strings.Repeat("a", common.NameLimit255+1),
+ })
+ if err == nil || !strings.Contains(err.Error(), "larger than") {
+ t.Fatalf("UpdateAgent overlong alias error = %v, want length error", err)
+ }
+}
+
+func TestBuildVersionTitleRespectsColumnWidth(t *testing.T) {
+ got := buildVersionTitle(strings.Repeat("a", common.NameLimit255), time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC))
+ if length := utf8.RuneCountInString(got); length > common.VersionTitleLimit {
+ t.Fatalf("buildVersionTitle length = %d, want <= %d", length, common.VersionTitleLimit)
+ }
+}
+
func TestCreateAgentRequiresAuthenticatedUserID(t *testing.T) {
row, code, err := NewAgentService().CreateAgent(t.Context(), &CreateAgentRequest{
Title: sptr("Agent"),
diff --git a/internal/service/chat.go b/internal/service/chat.go
index b89160f019..6820f2eaeb 100644
--- a/internal/service/chat.go
+++ b/internal/service/chat.go
@@ -348,7 +348,7 @@ func (s *ChatService) Create(ctx context.Context, req map[string]interface{}) (m
applyCreatePromptDefaults(req)
filterCreateChatPersistedFields(req)
- name, err = common.UniqueName(name, 255, func(candidate string) (bool, error) {
+ name, err = common.UniqueName(name, common.NameLimit255, func(candidate string) (bool, error) {
return s.chatDAO.ExistsByNameTenantStatus(ctx, dao.DB, candidate, tenantID, string(entity.StatusValid))
})
if err != nil {
@@ -391,8 +391,8 @@ func validateCreateChatName(value interface{}) (string, error) {
if name == "" {
return "", errors.New("`name` is required")
}
- if len([]byte(name)) > 255 {
- return "", fmt.Errorf("chat name length is %d which is larger than 255", len([]byte(name)))
+ if err := common.ValidateNameRunes(name, common.NameLimit255); err != nil {
+ return "", err
}
return name, nil
}
@@ -1139,8 +1139,8 @@ func validateRESTChatName(value interface{}, required bool) (string, bool, error
}
return "", false, errors.New("`name` cannot be empty")
}
- if len([]byte(name)) > 255 {
- return "", false, fmt.Errorf("chat name length is %d which is larger than 255", len([]byte(name)))
+ if err := common.ValidateNameRunes(name, common.NameLimit255); err != nil {
+ return "", false, err
}
return name, true, nil
}
diff --git a/internal/service/chat_channel.go b/internal/service/chat_channel.go
index 27e51c30c8..f9ee366432 100644
--- a/internal/service/chat_channel.go
+++ b/internal/service/chat_channel.go
@@ -106,6 +106,10 @@ func (s *ChatChannelService) CreateChatChannel(ctx context.Context, name, channe
return nil, err
}
}
+ name = strings.TrimSpace(name)
+ if err := common.ValidateNameRunes(name, common.NameLimit128); err != nil {
+ return nil, err
+ }
row := &entity.ChatChannel{
ID: common.GenerateUUID(),
UserID: userID,
@@ -171,6 +175,10 @@ func (s *ChatChannelService) UpdateChatChannel(ctx context.Context, channelID st
if !ok {
return nil, common.CodeDataError, errors.New("name must be string")
}
+ name = strings.TrimSpace(name)
+ if err := common.ValidateNameRunes(name, common.NameLimit128); err != nil {
+ return nil, common.CodeDataError, err
+ }
updates["name"] = name
}
diff --git a/internal/service/chat_channel_test.go b/internal/service/chat_channel_test.go
index b9f4d81213..9bd2aa30a5 100644
--- a/internal/service/chat_channel_test.go
+++ b/internal/service/chat_channel_test.go
@@ -207,6 +207,44 @@ func TestChatChannelServiceUpdateChatChannelSuccess(t *testing.T) {
}
}
+func TestChatChannelServiceCreateRejectsOverlongName(t *testing.T) {
+ setupChatChannelServiceTestDB(t)
+ _, err := NewChatChannelService().CreateChatChannel(
+ serviceTestContext(t, "tenant-1", "tenant-1"),
+ strings.Repeat("a", common.NameLimit128+1),
+ "dingtalk",
+ entity.JSONMap{},
+ nil,
+ )
+ if err == nil || !strings.Contains(err.Error(), "larger than") {
+ t.Fatalf("CreateChatChannel overlong name error = %v, want length error", err)
+ }
+}
+
+func TestChatChannelServiceUpdateRejectsOverlongName(t *testing.T) {
+ db := setupChatChannelServiceTestDB(t)
+ createServiceTestChannel(t, db, &entity.ChatChannel{
+ ID: "cc-overlong",
+ TenantID: "tenant-1",
+ Name: "bot-a",
+ Channel: "wecom",
+ Config: entity.JSONMap{},
+ Status: 1,
+ })
+
+ _, code, err := NewChatChannelService().UpdateChatChannel(
+ serviceTestContext(t, "tenant-1", "tenant-1"),
+ "cc-overlong",
+ map[string]interface{}{"name": strings.Repeat("a", common.NameLimit128+1)},
+ )
+ if err == nil || !strings.Contains(err.Error(), "larger than") {
+ t.Fatalf("UpdateChatChannel overlong name error = %v, want length error", err)
+ }
+ if code != common.CodeDataError {
+ t.Fatalf("UpdateChatChannel code = %v, want CodeDataError", code)
+ }
+}
+
func TestChatChannelServiceUpdateChatChannelRejectsCrossTenantDialog(t *testing.T) {
db := setupChatChannelServiceTestDB(t)
createServiceTestDialog(t, db, "dialog-2", "tenant-2", "Assistant B")
diff --git a/internal/service/chat_rest_update_test.go b/internal/service/chat_rest_update_test.go
index 2bcdff506f..4088df6d44 100644
--- a/internal/service/chat_rest_update_test.go
+++ b/internal/service/chat_rest_update_test.go
@@ -561,7 +561,7 @@ func TestChatServicePatchChatRejectsTooLongName(t *testing.T) {
if err == nil {
t.Fatal("expected too long name error")
}
- if err.Error() != "chat name length is 256 which is larger than 255" {
+ if err.Error() != "name length is 256 which is larger than 255" {
t.Fatalf("unexpected error: %v", err)
}
}
diff --git a/internal/service/compilation_template_group_service.go b/internal/service/compilation_template_group_service.go
index 1e71e02361..2699a2ca36 100644
--- a/internal/service/compilation_template_group_service.go
+++ b/internal/service/compilation_template_group_service.go
@@ -41,10 +41,6 @@ func timeStr(ms *int64) string {
const (
groupScopeFile = "file"
groupScopeDataset = "dataset"
- // maxGroupNameLen is the DB column size for compilation_template_group.name.
- maxGroupNameLen = 128
- // maxTemplateNameLen is the DB column size for compilation_template.name.
- maxTemplateNameLen = 128
)
// GroupTemplate is a child-template entry in a group create/update payload.
@@ -137,7 +133,7 @@ func (s *CompilationTemplateGroupService) CreateGroup(ctx context.Context, req *
return nil, err
}
// Fall back to a numbered name when the requested one is already taken.
- groupName, err := common.UniqueName(strings.TrimSpace(req.Name), maxGroupNameLen, func(candidate string) (bool, error) {
+ groupName, err := common.UniqueName(strings.TrimSpace(req.Name), common.NameLimit128, func(candidate string) (bool, error) {
return s.groupDAO.NameExists(ctx, dao.DB, tenantID, candidate, "")
})
if err != nil {
@@ -381,7 +377,7 @@ func validateGroupPayload(req *GroupRequest, requireAll bool) error {
}
}
if strings.TrimSpace(req.Name) != "" {
- if len([]byte(req.Name)) > maxGroupNameLen {
+ if err := common.ValidateNameRunes(req.Name, common.NameLimit128); err != nil {
return groupValidationErrorf("template group name is too long.")
}
}
@@ -426,7 +422,7 @@ func (s *CompilationTemplateGroupService) insertChildren(ctx context.Context, db
name := groupName
if len(templates) != 1 {
var err error
- name, err = common.UniqueName(strings.TrimSpace(child.Name), maxTemplateNameLen, func(candidate string) (bool, error) {
+ name, err = common.UniqueName(strings.TrimSpace(child.Name), common.NameLimit128, func(candidate string) (bool, error) {
return s.templateDAO.NameExistsInGroup(ctx, db, tenantID, groupID, candidate, "")
})
if err != nil {
@@ -560,7 +556,7 @@ func (s *CompilationTemplateGroupService) reconcileChildren(ctx context.Context,
}
continue
}
- newName, err := common.UniqueName(item.name, maxTemplateNameLen, func(candidate string) (bool, error) {
+ newName, err := common.UniqueName(item.name, common.NameLimit128, func(candidate string) (bool, error) {
return s.templateDAO.NameExistsInGroup(ctx, db, tenantID, groupID, candidate, "")
})
if err != nil {
diff --git a/internal/service/compilation_template_service.go b/internal/service/compilation_template_service.go
index 45b0dfce66..01b965137b 100644
--- a/internal/service/compilation_template_service.go
+++ b/internal/service/compilation_template_service.go
@@ -27,6 +27,7 @@ import (
"unicode"
"unicode/utf8"
+ "ragflow/internal/common"
"ragflow/internal/dao"
"ragflow/internal/entity"
"ragflow/internal/permission"
@@ -181,7 +182,7 @@ func ValidateTemplatePayload(req map[string]interface{}, requireAll bool) error
}
if name, ok := req["name"]; ok {
nameStr, ok2 := name.(string)
- if !ok2 || strings.TrimSpace(nameStr) == "" || len([]byte(nameStr)) > 128 {
+ if !ok2 || common.ValidateNameRunes(nameStr, common.NameLimit128) != nil {
return errors.New("invalid template name")
}
}
diff --git a/internal/service/connector.go b/internal/service/connector.go
index 15ed71ecc4..1ba666f76e 100644
--- a/internal/service/connector.go
+++ b/internal/service/connector.go
@@ -89,6 +89,9 @@ var (
// ErrConnectorInvalidFreq is returned when a connector frequency is not
// positive. Handlers map it to a client error; callers match with errors.Is.
ErrConnectorInvalidFreq = errors.New("connector frequency must be positive")
+ // ErrConnectorInvalidName is returned when a connector name is empty or
+ // wider than the connector.name column. Handlers map it to a client error.
+ ErrConnectorInvalidName = errors.New("connector name is invalid")
)
// ConnectorService connector service
@@ -289,6 +292,11 @@ func (s *ConnectorService) CreateConnector(ctx context.Context, req *CreateConne
if err := permission.NewDatabaseChecker(dao.DB).CheckFeature(ctx, "file", permission.ActionWrite); err != nil {
return nil, err
}
+ name := strings.TrimSpace(req.Name)
+ if err := common.ValidateNameRunes(name, common.NameLimit128); err != nil {
+ return nil, fmt.Errorf("%w: %v", ErrConnectorInvalidName, err)
+ }
+ req.Name = name
if req.RefreshFreq != nil && *req.RefreshFreq <= 0 {
return nil, fmt.Errorf("%w: refresh_freq got %d", ErrConnectorInvalidFreq, *req.RefreshFreq)
}
diff --git a/internal/service/connector_freq_test.go b/internal/service/connector_freq_test.go
index e7108e32b1..356f066b81 100644
--- a/internal/service/connector_freq_test.go
+++ b/internal/service/connector_freq_test.go
@@ -2,6 +2,7 @@ package service
import (
"errors"
+ "strings"
"testing"
"ragflow/internal/common"
@@ -49,6 +50,20 @@ func TestCreateConnectorRejectsNonPositiveFreq(t *testing.T) {
}
}
+func TestCreateConnectorRejectsOverlongName(t *testing.T) {
+ setupFreqValidationConnector(t)
+ svc := NewConnectorService()
+
+ _, err := svc.CreateConnector(serviceTestContext(t, "user-1", "user-1"), &CreateConnectorRequest{
+ Name: strings.Repeat("a", common.NameLimit128+1),
+ Source: "rss",
+ Config: entity.JSONMap{},
+ })
+ if err == nil || !errors.Is(err, ErrConnectorInvalidName) {
+ t.Fatalf("CreateConnector overlong name error = %v, want ErrConnectorInvalidName", err)
+ }
+}
+
func TestUpdateConnectorRejectsNonPositiveFreq(t *testing.T) {
setupFreqValidationConnector(t)
svc := NewConnectorService()
diff --git a/internal/service/dataset/crud.go b/internal/service/dataset/crud.go
index 08f25b920d..40b51c2967 100644
--- a/internal/service/dataset/crud.go
+++ b/internal/service/dataset/crud.go
@@ -68,7 +68,7 @@ func (d *DatasetService) CreateDataset(ctx context.Context, req *service.CreateD
return nil, common.CodeDataError, errors.New("dataset name can't be empty")
}
if utf8.RuneCountInString(name) > entity.DatasetNameLimit {
- return nil, common.CodeDataError, fmt.Errorf("Dataset name length is %d which is large than %d", utf8.RuneCountInString(name), entity.DatasetNameLimit)
+ return nil, common.CodeDataError, fmt.Errorf("dataset name length is %d which is larger than %d", utf8.RuneCountInString(name), entity.DatasetNameLimit)
}
tenant, err := d.tenantDAO.GetByID(ctx, dao.DB, tenantID)
@@ -323,7 +323,7 @@ func (d *DatasetService) CreateDataset(ctx context.Context, req *service.CreateD
// dedupeDatasetName returns a non-colliding dataset name within the tenant,
// appending (1), (2), ... when the requested name is already taken.
func (d *DatasetService) dedupeDatasetName(ctx context.Context, name, tenantID string) (string, error) {
- return common.UniqueNameCharacters(name, entity.DatasetNameLimit, func(candidate string) (bool, error) {
+ return common.UniqueName(name, entity.DatasetNameLimit, func(candidate string) (bool, error) {
return d.kbDAO.NameExists(ctx, dao.DB, tenantID, candidate)
})
}
diff --git a/internal/service/dataset/sdk_contract_test.go b/internal/service/dataset/sdk_contract_test.go
index f81ed66f5d..af42772d3a 100644
--- a/internal/service/dataset/sdk_contract_test.go
+++ b/internal/service/dataset/sdk_contract_test.go
@@ -59,7 +59,7 @@ func TestSDKDatasetNegativePagerankDiagnostic(t *testing.T) {
func TestSDKDatasetUnicodeDeduplicationLimit(t *testing.T) {
for _, n := range []int{125, 128} {
name := strings.Repeat("数", n)
- got, err := common.UniqueNameCharacters(name, 128, func(candidate string) (bool, error) { return candidate == name, nil })
+ got, err := common.UniqueName(name, common.NameLimit128, func(candidate string) (bool, error) { return candidate == name, nil })
if n == 125 {
if err != nil || got != name+"(1)" {
t.Fatalf("name=%q err=%v", got, err)
diff --git a/internal/service/dataset/update.go b/internal/service/dataset/update.go
index 13285b5766..4219919aa4 100644
--- a/internal/service/dataset/update.go
+++ b/internal/service/dataset/update.go
@@ -69,8 +69,8 @@ func (d *DatasetService) UpdateDataset(ctx context.Context, datasetID string, re
if name == "" {
return nil, common.CodeDataError, errors.New("String should have at least 1 character")
}
- if utf8.RuneCountInString(name) > 128 {
- return nil, common.CodeDataError, errors.New("String should have at most 128 characters")
+ if utf8.RuneCountInString(name) > entity.DatasetNameLimit {
+ return nil, common.CodeDataError, fmt.Errorf("String should have at most %d characters", entity.DatasetNameLimit)
}
simpleUpdates["name"] = name
}
diff --git a/internal/service/document/document_crud.go b/internal/service/document/document_crud.go
index 49248a3b35..dc81fa56bd 100644
--- a/internal/service/document/document_crud.go
+++ b/internal/service/document/document_crud.go
@@ -132,6 +132,9 @@ func (s *DocumentService) UpdateDocument(ctx context.Context, id string, req *Up
if req.Name == nil {
return common.CodeSuccess, nil
}
+ if code, err := s.validateDocumentName(ctx, document, *req.Name); err != nil {
+ return code, err
+ }
kb, err := s.kbDAO.GetByID(ctx, dao.DB, document.KbID)
if err != nil {
return common.CodeServerError, err
@@ -392,7 +395,7 @@ func (s *DocumentService) InsertDocument(ctx context.Context, doc *entity.Docume
// Returns an error when the existing-name lookup fails so callers never write
// blind and risk duplicated document names.
func (s *DocumentService) UniqueDocumentName(ctx context.Context, kbID, name string) (string, error) {
- return common.UniqueFileName(name, 255, func(candidate string) (bool, error) {
+ return common.UniqueFileName(name, common.NameLimit255, func(candidate string) (bool, error) {
return s.documentDAO.NameExistsInKB(ctx, dao.DB, kbID, candidate)
})
}
diff --git a/internal/service/document/document_dataset_update.go b/internal/service/document/document_dataset_update.go
index bcf3cf3389..1add74b108 100644
--- a/internal/service/document/document_dataset_update.go
+++ b/internal/service/document/document_dataset_update.go
@@ -502,8 +502,8 @@ func requestField[T any](value *T, present bool) *T {
// validateDocumentName mirrors Python's validate_document_name: length check
// (101), then extension check (101), then duplicate check (102).
func (s *DocumentService) validateDocumentName(ctx context.Context, doc *entity.Document, newName string) (common.ErrorCode, error) {
- if len([]byte(newName)) > 255 {
- return common.CodeArgumentError, errors.New("File name must be 255 bytes or less.")
+ if err := common.ValidateNameRunes(newName, common.NameLimit255); err != nil {
+ return common.CodeArgumentError, err
}
oldName := ""
diff --git a/internal/service/document/document_test.go b/internal/service/document/document_test.go
index cc8c968164..225c3e97e8 100644
--- a/internal/service/document/document_test.go
+++ b/internal/service/document/document_test.go
@@ -1441,6 +1441,65 @@ func TestUploadLocalDocuments_MirrorsPythonCoreFields(t *testing.T) {
assertKBDocNum(t, kb.ID, 2)
}
+func TestUploadLocalDocumentsKeepsStorageKeyWithinByteLimit(t *testing.T) {
+ db := setupServiceTestDB(t)
+ pushServiceDB(t, db)
+
+ mockStorage := newFakeUploadStorage()
+ factory := storage.GetStorageFactory()
+ origStorage := factory.GetStorage()
+ factory.SetStorage(mockStorage)
+ t.Cleanup(func() { factory.SetStorage(origStorage) })
+
+ pipelineID := "pipe-long-name"
+ ensureTestTenantOwner(t, "user-1", "tenant-1")
+ valid := string(entity.StatusValid)
+ kb := &entity.Knowledgebase{
+ ID: "kb-long-name",
+ TenantID: "tenant-1",
+ CreatedBy: "user-1",
+ Name: "kb-long-name",
+ ParserID: "naive",
+ PipelineID: &pipelineID,
+ ParserConfig: entity.JSONMap{},
+ Status: &valid,
+ }
+ if err := dao.DB.Create(kb).Error; err != nil {
+ t.Fatalf("insert kb: %v", err)
+ }
+
+ ctx := permission.WithIdentity(t.Context(), "user-1", "")
+ svc := testDocumentService(t)
+ filename := strings.Repeat("界", 100) + ".pdf"
+ fh := makeTestFileHeader(t, "file", filename, []byte("%PDF-1.7"))
+ got, errs := svc.UploadLocalDocuments(ctx, kb, []*multipart.FileHeader{fh}, "", nil)
+ if len(errs) != 0 {
+ t.Fatalf("unexpected errs: %v", errs)
+ }
+ if len(got) != 1 {
+ t.Fatalf("expected 1 uploaded doc, got %d", len(got))
+ }
+
+ location, _ := got[0]["location"].(string)
+ if location == "" {
+ t.Fatal("location is empty")
+ }
+ for _, segment := range strings.Split(location, "/") {
+ if len(segment) > utility.StorageKeyMaxBytes {
+ t.Fatalf("storage key segment %q is %d bytes, want <= %d", segment, len(segment), utility.StorageKeyMaxBytes)
+ }
+ }
+ if !strings.HasSuffix(location, ".pdf") {
+ t.Fatalf("location = %q, want .pdf suffix", location)
+ }
+ if got[0]["name"] != filename {
+ t.Fatalf("name = %v, want the full display name %q", got[0]["name"], filename)
+ }
+ if _, err := mockStorage.Get(ctx, kb.ID, location); err != nil {
+ t.Fatalf("blob not stored at %q: %v", location, err)
+ }
+}
+
func TestUploadEmptyDocument_CreatesVirtualDocumentAndFileLink(t *testing.T) {
db := setupServiceTestDB(t)
pushServiceDB(t, db)
@@ -3263,6 +3322,19 @@ func TestUpdateDocumentUsesSharedRenamePath(t *testing.T) {
}
}
+func TestUpdateDocumentRejectsOverlongName(t *testing.T) {
+ db := setupServiceTestDB(t)
+ pushServiceDB(t, db)
+ insertTestKB(t, "kb-1", "tenant-1", 1, 10, 5)
+ insertNamedTestDoc(t, "doc-1", "kb-1", "old.pdf", 10, 5)
+
+ name := strings.Repeat("a", 252) + ".pdf"
+ code, err := testDocumentService(t).UpdateDocument(t.Context(), "doc-1", &UpdateDocumentRequest{Name: &name})
+ if err == nil || code != common.CodeArgumentError {
+ t.Fatalf("UpdateDocument overlong name = (%v, %v), want argument error", code, err)
+ }
+}
+
func float64Ptr(value float64) *float64 { return &value }
func int64Ptr(value int64) *int64 { return &value }
diff --git a/internal/service/document/document_upload.go b/internal/service/document/document_upload.go
index 2ac63d4950..2beda0a4bf 100644
--- a/internal/service/document/document_upload.go
+++ b/internal/service/document/document_upload.go
@@ -68,7 +68,7 @@ func (s *DocumentService) UploadLocalDocuments(ctx context.Context, kb *entity.K
continue
}
- filename, err := common.UniqueFileName(fh.Filename, 255, func(candidate string) (bool, error) {
+ filename, err := common.UniqueFileName(fh.Filename, common.NameLimit255, func(candidate string) (bool, error) {
return s.documentDAO.NameExistsInKB(ctx, dao.DB, kb.ID, candidate)
})
if err != nil {
@@ -82,12 +82,12 @@ func (s *DocumentService) UploadLocalDocuments(ctx context.Context, kb *entity.K
continue
}
- location := filename
- if safeParent != "" {
- location = safeParent + "/" + filename
- }
- for storageImpl.ObjExist(ctx, kb.ID, location) {
- location += "_"
+ var location string
+ for attempt := 0; ; attempt++ {
+ location = storageObjectPath(safeParent, filename, attempt)
+ if !storageImpl.ObjExist(ctx, kb.ID, location) {
+ break
+ }
}
if err = storageImpl.Put(ctx, kb.ID, location, blob); err != nil {
errMsgs = append(errMsgs, fh.Filename+": "+err.Error())
@@ -122,6 +122,17 @@ func (s *DocumentService) UploadLocalDocuments(ctx context.Context, kb *entity.K
return results, errMsgs
}
+// storageObjectPath builds the persisted object key for an upload. Display
+// names are limited by Unicode code points, while filesystem-backed storage
+// limits each path segment by bytes.
+func storageObjectPath(parent, filename string, attempt int) string {
+ key := utility.StorageObjectName(filename, attempt, utility.StorageKeyMaxBytes)
+ if parent == "" {
+ return key
+ }
+ return parent + "/" + key
+}
+
// UploadEmptyDocument inserts a zero-byte "virtual" document into the dataset.
func (s *DocumentService) UploadEmptyDocument(ctx context.Context, kb *entity.Knowledgebase, name string) (map[string]interface{}, common.ErrorCode, error) {
userID := permission.UserIDFromContext(ctx)
@@ -129,7 +140,7 @@ func (s *DocumentService) UploadEmptyDocument(ctx context.Context, kb *entity.Kn
return nil, common.CodeUnauthorized, permission.ErrUnauthenticated
}
// Fall back to a numbered name when the requested one is already taken.
- name, err := common.UniqueFileName(name, 255, func(candidate string) (bool, error) {
+ name, err := common.UniqueFileName(name, common.NameLimit255, func(candidate string) (bool, error) {
return s.documentDAO.NameExistsInKB(ctx, dao.DB, kb.ID, candidate)
})
if err != nil {
@@ -265,9 +276,12 @@ func (s *DocumentService) UploadWebDocument(ctx context.Context, kb *entity.Know
if headers != nil {
contentType = headers.Get("Content-Type")
}
- filename := normalizeWebDocumentName(name, contentType, blob)
+ filename, ok := normalizeWebDocumentName(name, contentType, blob)
+ if !ok {
+ return nil, common.CodeArgumentError, fmt.Errorf("file name cannot be empty")
+ }
filename, _, blob = utility.NormalizeUploadInfoContent(filename, contentType, blob)
- filename, err = common.UniqueFileName(filename, 255, func(candidate string) (bool, error) {
+ filename, err = common.UniqueFileName(filename, common.NameLimit255, func(candidate string) (bool, error) {
return s.documentDAO.NameExistsInKB(ctx, dao.DB, kb.ID, candidate)
})
if err != nil {
@@ -279,9 +293,12 @@ func (s *DocumentService) UploadWebDocument(ctx context.Context, kb *entity.Know
return nil, common.CodeDataError, fmt.Errorf("this type of file has not been supported yet")
}
- location := filename
- for storageImpl.ObjExist(ctx, kb.ID, location) {
- location += "_"
+ location := ""
+ for attempt := 0; ; attempt++ {
+ location = storageObjectPath("", filename, attempt)
+ if !storageImpl.ObjExist(ctx, kb.ID, location) {
+ break
+ }
}
if err = storageImpl.Put(ctx, kb.ID, location, blob); err != nil {
return nil, common.CodeServerError, err
@@ -307,19 +324,22 @@ func (s *DocumentService) UploadWebDocument(ctx context.Context, kb *entity.Know
return docToRawMap(doc), common.CodeSuccess, nil
}
-func normalizeWebDocumentName(name, contentType string, blob []byte) string {
+func normalizeWebDocumentName(name, contentType string, blob []byte) (string, bool) {
filename := utility.SanitizeFilename(name)
+ if filename == "" {
+ return "", false
+ }
if filepath.Ext(filename) != "" {
- return filename
+ return filename, true
}
lowerCT := strings.ToLower(strings.TrimSpace(strings.Split(contentType, ";")[0]))
switch {
case lowerCT == "application/pdf" || http.DetectContentType(blob) == "application/pdf" || utility.BytesLooksLikePDF(blob):
- return filename + ".pdf"
+ return filename + ".pdf", true
case lowerCT == "text/html" || lowerCT == "application/xhtml+xml" || utility.LooksLikeHTML(blob):
- return filename + ".html"
+ return filename + ".html", true
default:
- return filename
+ return filename, true
}
}
diff --git a/internal/service/document/document_upload_test.go b/internal/service/document/document_upload_test.go
index bf676f0141..6d4b5fa875 100644
--- a/internal/service/document/document_upload_test.go
+++ b/internal/service/document/document_upload_test.go
@@ -51,14 +51,21 @@ func TestNormalizeWebDocumentName(t *testing.T) {
name, filename, ct string
blob []byte
want string
+ wantOK bool
}{
- {"pdf detected by blob", "report", "application/octet-stream", pdfBlob, "report.pdf"},
- {"html detected by blob", "page", "application/octet-stream", htmlBlob, "page.html"},
- {"dot stripped by utility, no type hint", "image.png", "application/octet-stream", []byte("plain"), "imagepng"},
- {"no hint, no extension", "doc", "application/json", []byte("{}"), "doc"},
+ {"pdf detected by blob", "report", "application/octet-stream", pdfBlob, "report.pdf", true},
+ {"html detected by blob", "page", "application/octet-stream", htmlBlob, "page.html", true},
+ {"dot stripped by utility, no type hint", "image.png", "application/octet-stream", []byte("plain"), "imagepng", true},
+ {"no hint, no extension", "doc", "application/json", []byte("{}"), "doc", true},
+ {"cjk-only name with pdf content", "界界", "application/pdf", pdfBlob, "", false},
+ {"cjk-only name without type hint", "界界", "application/json", []byte("{}"), "", false},
}
for _, c := range cases {
- if got := normalizeWebDocumentName(c.filename, c.ct, c.blob); got != c.want {
+ got, ok := normalizeWebDocumentName(c.filename, c.ct, c.blob)
+ if ok != c.wantOK {
+ t.Errorf("%s: normalizeWebDocumentName ok = %v, want %v", c.name, ok, c.wantOK)
+ }
+ if got != c.want {
t.Errorf("%s: normalizeWebDocumentName = %q, want %q", c.name, got, c.want)
}
}
diff --git a/internal/service/file/file_commit.go b/internal/service/file/file_commit.go
index 03d5e1fe53..de0f829cbb 100644
--- a/internal/service/file/file_commit.go
+++ b/internal/service/file/file_commit.go
@@ -30,11 +30,13 @@ import (
"ragflow/internal/entity"
"ragflow/internal/permission"
"ragflow/internal/storage"
+ "ragflow/internal/utility"
"sort"
"strings"
"sync"
"sync/atomic"
"time"
+ "unicode/utf8"
"go.uber.org/zap"
"gorm.io/gorm"
@@ -70,6 +72,11 @@ const maxCommitFolderDepth = 64
// entry as processed, so later edits would never be reported.
var ErrDeleteLiveFile = errors.New("cannot commit the deletion of a file that is still in the folder")
+// ErrInvalidRenameTarget rejects a rename change whose target is empty or
+// exceeds the stored name limit. The handler maps it to a client error instead
+// of a server fault.
+var ErrInvalidRenameTarget = errors.New("invalid file rename target")
+
// fileTreeContains reports whether fileID, or one of its ancestors, is folderID.
// It walks from the file upwards rather than scanning the folder, and treats an
// unknown ID as outside: a deletion is only valid for a file that is already
@@ -95,8 +102,39 @@ func (s *FileCommitService) fileTreeContains(ctx context.Context, tx *gorm.DB, f
return false, nil
}
+// normalizeCommitRenames trims and validates every rename target before the
+// transaction writes objects or rows. Object storage has no transaction, so a
+// later invalid rename would otherwise leave objects written by earlier
+// add/modify changes behind.
+func normalizeCommitRenames(changes []entity.FileChange) ([]entity.FileChange, error) {
+ normalized := make([]entity.FileChange, len(changes))
+ copy(normalized, changes)
+ for i := range normalized {
+ if normalized[i].Operation != "rename" {
+ continue
+ }
+ normalized[i].NewName = strings.TrimSpace(normalized[i].NewName)
+ if err := common.ValidateNameRunes(normalized[i].NewName, common.NameLimit255); err != nil {
+ return nil, fmt.Errorf("%w for file %s: %v", ErrInvalidRenameTarget, normalized[i].FileID, err)
+ }
+ }
+ return normalized, nil
+}
+
// CreateCommit creates a new commit for a workspace folder
func (s *FileCommitService) CreateCommit(ctx context.Context, folderID, authorID, message string, changes []entity.FileChange) (*entity.FileCommit, error) {
+ message = strings.TrimSpace(message)
+ if message == "" {
+ return nil, errors.New("commit message is required")
+ }
+ if utf8.RuneCountInString(message) > 512 {
+ return nil, errors.New("commit message must be at most 512 characters")
+ }
+ normalizedChanges, err := normalizeCommitRenames(changes)
+ if err != nil {
+ return nil, err
+ }
+ changes = normalizedChanges
// 1. Get the latest commit for this folder
latestCommit, _ := s.commitDAO.GetLatestByFolderID(ctx, dao.DB, folderID)
@@ -250,20 +288,21 @@ func (s *FileCommitService) CreateCommit(ctx context.Context, folderID, authorID
}
case "rename":
+ newName := change.NewName
item.OldName = &change.OldName
- item.NewName = &change.NewName
+ item.NewName = &newName
- if err := tx.Model(&entity.File{}).Where("id = ?", change.FileID).Update("name", change.NewName).Error; err != nil {
+ if err := tx.Model(&entity.File{}).Where("id = ?", change.FileID).Update("name", newName).Error; err != nil {
return fmt.Errorf("failed to rename file: %w", err)
}
if entry, ok := treeState[change.FileID]; ok {
if entryMap, ok := entry.(map[string]interface{}); ok {
- entryMap["name"] = change.NewName
+ entryMap["name"] = newName
}
} else {
treeState[change.FileID] = map[string]interface{}{
- "name": change.NewName,
+ "name": newName,
"status": "1",
}
}
@@ -543,12 +582,13 @@ func (s *FileCommitService) RecordPageEdit(ctx context.Context, in PageEditCommi
return nil, fmt.Errorf("failed to resolve page commit parent: %w", perr)
}
+ title := utility.TruncateRunes(strings.TrimSpace(in.Title), common.NameLimit255)
commit = &entity.FileCommit{
ID: commitID,
FolderID: in.DatasetID,
- Message: in.Title,
+ Message: title,
AuthorID: in.AuthorID,
- Title: &in.Title,
+ Title: &title,
Comments: &in.Comments,
FileCount: 1,
}
diff --git a/internal/service/file/file_commit_authorization_test.go b/internal/service/file/file_commit_authorization_test.go
index cd63af6320..e30571bcbd 100644
--- a/internal/service/file/file_commit_authorization_test.go
+++ b/internal/service/file/file_commit_authorization_test.go
@@ -2,6 +2,7 @@ package file
import (
"context"
+ "strings"
"testing"
"ragflow/internal/entity"
@@ -165,6 +166,30 @@ func TestCreateCommitAcceptsFilesInsideFolderTree(t *testing.T) {
}
}
+func TestCreateCommitRejectsInvalidRenameTarget(t *testing.T) {
+ f := newCommitAuthFixture(t)
+ svc := NewFileCommitService()
+
+ for _, name := range []string{"", " ", strings.Repeat("a", 256)} {
+ t.Run(name, func(t *testing.T) {
+ _, err := svc.CreateCommit(context.Background(), "folder-a", "user-a", "rename", []entity.FileChange{
+ {FileID: "file-a", Operation: "rename", OldName: "a.txt", NewName: name},
+ })
+ if err == nil {
+ t.Fatal("expected CreateCommit to reject an invalid rename target")
+ }
+ })
+ }
+
+ var row entity.File
+ if err := f.db.Where("id = ?", "file-a").First(&row).Error; err != nil {
+ t.Fatalf("reload file-a: %v", err)
+ }
+ if row.Name != "a.txt" {
+ t.Fatalf("file-a name = %q, want a.txt", row.Name)
+ }
+}
+
func TestCreateCommitRejectsMissingFolder(t *testing.T) {
f := newCommitAuthFixture(t)
svc := NewFileCommitService()
diff --git a/internal/service/file/file_commit_delete_test.go b/internal/service/file/file_commit_delete_test.go
index cc18c9a156..96fcc8a074 100644
--- a/internal/service/file/file_commit_delete_test.go
+++ b/internal/service/file/file_commit_delete_test.go
@@ -8,6 +8,7 @@ import (
"ragflow/internal/dao"
"ragflow/internal/entity"
"ragflow/internal/permission"
+ "ragflow/internal/storage"
"github.com/glebarez/sqlite"
"gorm.io/gorm"
@@ -204,3 +205,28 @@ func TestCreateCommit_RejectsDeleteOfOutOfFolderFileAbsentFromTree(t *testing.T)
t.Fatalf("expected no tombstone for alien file, found %d commit items", commits)
}
}
+
+// A later invalid rename must not leave the objects written by earlier
+// add/modify changes behind, because object storage has no transaction.
+func TestCreateCommitRejectsInvalidRenameBeforeWritingObjects(t *testing.T) {
+ db := newCommitDeleteTestDB(t)
+ seedFolder(t, db, "folder-1", "")
+ seedLiveFile(t, db, "f1", "folder-1")
+
+ store := &fakeStorage{}
+ factory := storage.GetStorageFactory()
+ original := factory.GetStorage()
+ factory.SetStorage(store)
+ t.Cleanup(func() { factory.SetStorage(original) })
+
+ _, err := NewFileCommitService().CreateCommit(t.Context(), "folder-1", "u1", "rename", []entity.FileChange{
+ {FileID: "f1", FileName: "a.txt", Operation: "add", Content: "data"},
+ {FileID: "f1", Operation: "rename", NewName: " "},
+ })
+ if !errors.Is(err, ErrInvalidRenameTarget) {
+ t.Fatalf("err = %v, want ErrInvalidRenameTarget", err)
+ }
+ if store.lastFnm != "" {
+ t.Fatalf("object %q was written before rename validation", store.lastFnm)
+ }
+}
diff --git a/internal/service/file/file_folder.go b/internal/service/file/file_folder.go
index 48e14ea947..8e300e17ff 100644
--- a/internal/service/file/file_folder.go
+++ b/internal/service/file/file_folder.go
@@ -439,7 +439,7 @@ func (s *FileService) createFolderRecursive(ctx context.Context, parentFolder *e
// getUniqueFilename returns a non-colliding file name within the folder,
// appending (1), (2), ... when the requested name is already taken.
func (s *FileService) getUniqueFilename(ctx context.Context, name, parentID, tenantID string) (string, error) {
- return common.UniqueFileName(name, 255, func(candidate string) (bool, error) {
+ return common.UniqueFileName(name, common.NameLimit255, func(candidate string) (bool, error) {
return s.fileDAO.NameExists(ctx, dao.DB, candidate, parentID, tenantID, "")
})
}
@@ -497,9 +497,9 @@ func (s *FileService) CreateFolder(ctx context.Context, name, parentID, fileType
var uniqueName string
if fileType == FileTypeFolder {
// A folder is not a file: append the counter to the whole name.
- uniqueName, err = common.UniqueName(name, 255, existsInParent)
+ uniqueName, err = common.UniqueName(name, common.NameLimit255, existsInParent)
} else {
- uniqueName, err = common.UniqueFileName(name, 255, existsInParent)
+ uniqueName, err = common.UniqueFileName(name, common.NameLimit255, existsInParent)
}
if err != nil {
return nil, err
@@ -596,7 +596,15 @@ func (s *FileService) MoveFiles(ctx context.Context, srcFileIDs []string, destFi
}
}
+ trimmedName := strings.TrimSpace(newName)
+ if newName != "" && trimmedName == "" {
+ return errors.New("new_name must not be blank")
+ }
+ newName = trimmedName
if newName != "" {
+ if err := common.ValidateNameRunes(newName, common.NameLimit255); err != nil {
+ return err
+ }
if len(srcFileIDs) > 1 {
return errors.New("new name can only be used with a single file")
}
diff --git a/internal/service/file/file_folder_test.go b/internal/service/file/file_folder_test.go
index bd056f369a..e34173b289 100644
--- a/internal/service/file/file_folder_test.go
+++ b/internal/service/file/file_folder_test.go
@@ -3,6 +3,7 @@ package file
import (
"context"
"errors"
+ "mime/multipart"
"strings"
"testing"
@@ -11,6 +12,7 @@ import (
"ragflow/internal/entity"
"ragflow/internal/permission"
"ragflow/internal/permission/testsupport"
+ "ragflow/internal/storage"
"github.com/glebarez/sqlite"
"gorm.io/gorm"
@@ -426,6 +428,30 @@ func TestFileService_UploadRejectsInaccessibleParent(t *testing.T) {
}
}
+func TestFileService_UploadRejectsOverlongNameBeforePut(t *testing.T) {
+ db := setupFolderTestDB(t)
+ parent := &entity.File{ID: "folder-1", ParentID: "root-1", TenantID: "tenant-1", CreatedBy: "tenant-1", Name: "root", Type: FileTypeFolder}
+ if err := db.Create(parent).Error; err != nil {
+ t.Fatalf("seed parent folder: %v", err)
+ }
+
+ store := &fakeStorage{}
+ factory := storage.GetStorageFactory()
+ original := factory.GetStorage()
+ factory.SetStorage(store)
+ t.Cleanup(func() { factory.SetStorage(original) })
+
+ filename := strings.Repeat("a", 256) + ".txt"
+ fh := makeUploadInfoHeader(t, filename, []byte("x"))
+ _, err := testFileService().UploadFile(fileTestContext(t, "tenant-1", "tenant-1"), parent.ID, []*multipart.FileHeader{fh}, 1024)
+ if err == nil || !strings.Contains(err.Error(), "name length") {
+ t.Fatalf("UploadFile err = %v, want name length error", err)
+ }
+ if store.lastFnm != "" {
+ t.Fatalf("object %q was written before the name was validated", store.lastFnm)
+ }
+}
+
func insertFolderTestDocument(t *testing.T, id, kbID, name string) {
t.Helper()
doc := &entity.Document{
@@ -492,6 +518,40 @@ func TestMoveFilesRenameUpdatesAllLinkedDocuments(t *testing.T) {
}
}
+func TestMoveFilesRejectsBlankRenameTarget(t *testing.T) {
+ setupFolderTestDB(t)
+ folder := &entity.File{
+ ID: "folder-1",
+ ParentID: "folder-1",
+ TenantID: "tenant-1",
+ Name: "root",
+ Type: FileTypeFolder,
+ }
+ if err := dao.DB.Create(folder).Error; err != nil {
+ t.Fatalf("seed folder: %v", err)
+ }
+ insertFolderTestFile(t, "file-1", "folder-1", "old.pdf")
+
+ svc := testFileService()
+ ctx := fileTestContext(t, "tenant-1", "tenant-1")
+ err := svc.MoveFiles(ctx, []string{"file-1"}, "folder-1", " ")
+ if err == nil || !strings.Contains(err.Error(), "must not be blank") {
+ t.Fatalf("MoveFiles blank rename error = %v, want blank-name error", err)
+ }
+}
+
+func TestMoveFilesRenameRejectsOverlongName(t *testing.T) {
+ setupFolderTestDB(t)
+ insertFolderTestFile(t, "file-1", "folder-1", "old.pdf")
+
+ svc := testFileService()
+ ctx := fileTestContext(t, "tenant-1", "tenant-1")
+ err := svc.MoveFiles(ctx, []string{"file-1"}, "", strings.Repeat("a", common.NameLimit255+1)+".pdf")
+ if err == nil || !strings.Contains(err.Error(), "larger than") {
+ t.Fatalf("MoveFiles overlong name error = %v, want length error", err)
+ }
+}
+
// A failing file2document lookup must surface as an error instead of being
// silently treated as "no links", so a rename never reports success while
// linked documents keep stale names.
diff --git a/internal/service/file/file_test.go b/internal/service/file/file_test.go
index 17015a615f..9478c5be24 100644
--- a/internal/service/file/file_test.go
+++ b/internal/service/file/file_test.go
@@ -6,6 +6,7 @@ import (
"encoding/base64"
"errors"
"io"
+ "mime/multipart"
"net/http"
"net/http/httptest"
"net/url"
@@ -617,6 +618,48 @@ func TestReadUploadInfoData_RejectsOversizedInput(t *testing.T) {
}
}
+func TestUploadInfosRejectsNameOverLimitAfterNormalization(t *testing.T) {
+ t.Setenv(common.EnvMaxFileNumPerUser, "")
+ store := &fakeStorage{}
+ factory := storage.GetStorageFactory()
+ original := factory.GetStorage()
+ factory.SetStorage(store)
+ t.Cleanup(func() { factory.SetStorage(original) })
+
+ ctx := permission.WithIdentity(t.Context(), "user-1", "")
+ filename := strings.Repeat("a", common.NameLimit255)
+ fh := makeUploadInfoHeader(t, filename, []byte("%PDF-1.7"))
+ if _, err := testFileService().UploadInfos(ctx, []*multipart.FileHeader{fh}); err == nil || !strings.Contains(err.Error(), "maximum length") {
+ t.Fatalf("UploadInfos err = %v, want maximum length error", err)
+ }
+}
+
+func makeUploadInfoHeader(t *testing.T, filename string, content []byte) *multipart.FileHeader {
+ t.Helper()
+ var body bytes.Buffer
+ writer := multipart.NewWriter(&body)
+ part, err := writer.CreateFormFile("file", filename)
+ if err != nil {
+ t.Fatalf("create form file: %v", err)
+ }
+ if _, err := part.Write(content); err != nil {
+ t.Fatalf("write form file: %v", err)
+ }
+ if err := writer.Close(); err != nil {
+ t.Fatalf("close multipart writer: %v", err)
+ }
+ req := httptest.NewRequest(http.MethodPost, "/", &body)
+ req.Header.Set("Content-Type", writer.FormDataContentType())
+ if err := req.ParseMultipartForm(int64(len(content) + 1024)); err != nil {
+ t.Fatalf("parse multipart form: %v", err)
+ }
+ headers := req.MultipartForm.File["file"]
+ if len(headers) != 1 {
+ t.Fatalf("multipart file headers = %d, want 1", len(headers))
+ }
+ return headers[0]
+}
+
// zeroReader is an io.Reader that returns an infinite stream of zero bytes.
type zeroReader struct{}
diff --git a/internal/service/file/file_upload.go b/internal/service/file/file_upload.go
index 3a9c090bc9..93971117e6 100644
--- a/internal/service/file/file_upload.go
+++ b/internal/service/file/file_upload.go
@@ -119,9 +119,18 @@ func (s *FileService) UploadFile(ctx context.Context, parentID string, files []*
}
}
- location := fileObjNames[len(fileObjNames)-1]
- for storageImpl.ObjExist(ctx, lastFolder.ID, location) {
- location += "_"
+ baseName := fileObjNames[len(fileObjNames)-1]
+ uniqueName, err := s.getUniqueFilename(ctx, baseName, lastFolder.ID, tenantID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get unique filename: %w", err)
+ }
+
+ var location string
+ for attempt := 0; ; attempt++ {
+ location = utility.StorageObjectName(uniqueName, attempt, utility.StorageKeyMaxBytes)
+ if !storageImpl.ObjExist(ctx, lastFolder.ID, location) {
+ break
+ }
}
var src multipart.File
@@ -141,12 +150,6 @@ func (s *FileService) UploadFile(ctx context.Context, parentID string, files []*
return nil, fmt.Errorf("failed to store file: %w", err)
}
- var uniqueName string
- uniqueName, err = s.getUniqueFilename(ctx, fileObjNames[len(fileObjNames)-1], lastFolder.ID, tenantID)
- if err != nil {
- return nil, fmt.Errorf("failed to get unique filename: %w", err)
- }
-
fileRecord := &entity.File{
ID: common.GenerateToken(),
ParentID: lastFolder.ID,
@@ -221,6 +224,9 @@ func (s *FileService) UploadInfos(ctx context.Context, files []*multipart.FileHe
contentType = http.DetectContentType(data)
}
filename, contentType, data = utility.NormalizeUploadInfoContent(filename, contentType, data)
+ if err := validateUploadInfoFilename(filename); err != nil {
+ return nil, err
+ }
resp, err := s.storeUploadInfoBlob(ctx, storageImpl, filename, contentType, data)
if err != nil {
return nil, err
@@ -292,7 +298,16 @@ func (s *FileService) checkUploadInfoHealth(ctx context.Context, filename string
}
}
}
- if len([]byte(filename)) > 255 {
+ if err := validateUploadInfoFilename(filename); err != nil {
+ return err
+ }
+ return nil
+}
+
+// validateUploadInfoFilename enforces the stored name limit after any
+// content-derived extension has been added.
+func validateUploadInfoFilename(filename string) error {
+ if err := common.ValidateNameRunes(filename, common.NameLimit255); err != nil {
return fmt.Errorf("exceed the maximum length of file name")
}
return nil
diff --git a/internal/service/ingestion_task_service.go b/internal/service/ingestion_task_service.go
index 40f8502c17..371b5d54b7 100644
--- a/internal/service/ingestion_task_service.go
+++ b/internal/service/ingestion_task_service.go
@@ -15,6 +15,7 @@ import (
ingestionpipeline "ragflow/internal/ingestion/pipeline"
"ragflow/internal/observability"
"ragflow/internal/permission"
+ "ragflow/internal/utility"
"go.uber.org/zap"
"gorm.io/gorm"
@@ -1166,6 +1167,7 @@ func (s *IngestionTaskService) buildOpenLogInput(ctx context.Context, task *enti
}
}
}
+ input.PipelineTitle = utility.TruncateRunes(input.PipelineTitle, common.PipelineTitleLimit)
return input, nil
}
diff --git a/internal/service/mcp.go b/internal/service/mcp.go
index 8a9f5e5972..ce6f41474a 100644
--- a/internal/service/mcp.go
+++ b/internal/service/mcp.go
@@ -40,7 +40,6 @@ import (
const (
mcpServerTypeSSE = "sse"
mcpServerTypeStreamableHTTP = "streamable-http"
- mcpServerNameLimit = 255
mcpServerPreviewID = "preview"
defaultMCPFetchTimeoutSec = 10
mcpPermissionBatchSize = 256
@@ -121,8 +120,8 @@ func (s *MCPService) CreateMCPServer(ctx context.Context, req CreateMCPServerReq
return nil, common.CodeDataError, errors.New("unsupported MCP server type")
}
- if req.Name == "" || len([]byte(req.Name)) > mcpServerNameLimit {
- return nil, common.CodeDataError, fmt.Errorf("Invalid MCP name or length is %d which is large than 255.", len([]byte(req.Name)))
+ if err := common.ValidateNameRunes(req.Name, common.NameLimit255); err != nil {
+ return nil, common.CodeDataError, err
}
if req.URL == "" {
return nil, common.CodeDataError, errors.New("invalid url")
@@ -138,7 +137,7 @@ func (s *MCPService) CreateMCPServer(ctx context.Context, req CreateMCPServerReq
return nil, code, normalized
}
- name, err := common.UniqueName(req.Name, mcpServerNameLimit, func(candidate string) (bool, error) {
+ name, err := common.UniqueName(req.Name, common.NameLimit255, func(candidate string) (bool, error) {
return s.mcpServerDAO.ExistsByNameAndTenant(ctx, dao.DB, candidate, tenantID)
})
if err != nil {
@@ -433,8 +432,10 @@ func (s *MCPService) UpdateMCPServer(ctx context.Context, mcpID string, req Upda
serverName = value
serverNameProvided = true
}
- if serverName != "" && len([]byte(serverName)) > mcpServerNameLimit {
- return nil, common.CodeDataError, fmt.Errorf("Invalid MCP name or length is %d which is large than 255.", len([]byte(serverName)))
+ if serverName != "" {
+ if err := common.ValidateNameRunes(serverName, common.NameLimit255); err != nil {
+ return nil, common.CodeDataError, err
+ }
}
if serverNameProvided {
available, err := common.NameAvailable(server.Name, serverName, func(candidate string) (bool, error) {
@@ -759,8 +760,8 @@ func (s *MCPService) ImportServers(ctx context.Context, servers map[string]map[s
results = append(results, ImportResult{Server: serverName, Success: false, Message: "Missing required fields (type or url)"})
continue
}
- if serverName == "" || len([]byte(serverName)) > mcpServerNameLimit {
- results = append(results, ImportResult{Server: serverName, Success: false, Message: fmt.Sprintf("Invalid MCP name or length is %d which is large than 255.", len(serverName))})
+ if err := common.ValidateNameRunes(serverName, common.NameLimit255); err != nil {
+ results = append(results, ImportResult{Server: serverName, Success: false, Message: err.Error()})
continue
}
if !isValidMCPServerType(stype) {
@@ -864,7 +865,7 @@ func (s *MCPService) ImportServers(ctx context.Context, servers map[string]map[s
}
func (s *MCPService) nextAvailableMCPName(ctx context.Context, base, tenantID string) (string, error) {
- return common.UniqueName(base, mcpServerNameLimit, func(candidate string) (bool, error) {
+ return common.UniqueName(base, common.NameLimit255, func(candidate string) (bool, error) {
return s.mcpServerDAO.ExistsByNameAndTenant(ctx, dao.DB, candidate, tenantID)
})
}
diff --git a/internal/service/memory.go b/internal/service/memory.go
index c90af1d0c4..7b6e7352b9 100644
--- a/internal/service/memory.go
+++ b/internal/service/memory.go
@@ -45,8 +45,8 @@ import (
)
const (
- // MemoryNameLimit is the maximum length allowed for memory names
- MemoryNameLimit = 128
+ // MemoryNameLimit is the maximum length allowed for memory names.
+ MemoryNameLimit = common.NameLimit128
// MemorySizeLimit is the maximum memory size in bytes (5MB)
MemorySizeLimit = 5242880
)
@@ -535,7 +535,7 @@ func (s *MemoryService) CreateMemory(ctx context.Context, req *CreateMemoryReque
}
}
- if err := common.ValidateName(req.Name); err != nil {
+ if err := common.ValidateNameRunes(req.Name, MemoryNameLimit); err != nil {
return nil, err
}
@@ -643,7 +643,7 @@ func (s *MemoryService) UpdateMemory(ctx context.Context, memoryID string, req *
if req.Name != nil {
memoryName := strings.TrimSpace(*req.Name)
- if err = common.ValidateName(memoryName); err != nil {
+ if err = common.ValidateNameRunes(memoryName, MemoryNameLimit); err != nil {
return nil, err
}
available, nameErr := common.NameAvailable(strings.TrimSpace(currentMemory.Name), memoryName, func(candidate string) (bool, error) {
diff --git a/internal/service/search.go b/internal/service/search.go
index 408150324e..8f5362068c 100644
--- a/internal/service/search.go
+++ b/internal/service/search.go
@@ -147,7 +147,7 @@ type CreateSearchResponse struct {
// Reference: api/apps/restful_apis/search_api.py::create
// Python implementation steps:
// 1. Get JSON request body with name (required) and description (optional)
-// 2. Validate name is string, non-empty, and max 255 bytes
+// 2. Validate name is a string, non-empty, and at most 128 characters
// 3. Generate unique name using duplicate_name(SearchService.query, name, tenant_id)
// 4. Generate UUID for search ID
// 5. Set fields: id, name, description, tenant_id, created_by
@@ -162,7 +162,7 @@ func (s *SearchService) CreateSearch(ctx context.Context, name string, descripti
if err := permission.NewDatabaseChecker(dao.DB).CheckFeature(ctx, "search", permission.ActionWrite); err != nil {
return nil, err
}
- if err := common.ValidateName(name); err != nil {
+ if err := common.ValidateNameRunes(name, common.NameLimit128); err != nil {
return nil, err
}
@@ -170,8 +170,8 @@ func (s *SearchService) CreateSearch(ctx context.Context, name string, descripti
searchID := common.GenerateUUID()
// Generate unique name (same as Python duplicate_name)
- // search.name is a 128-byte column; keep generated names within it.
- uniqueName, err := common.UniqueName(name, 128, func(candidate string) (bool, error) {
+ // search.name is a 128-character column; keep generated names within it.
+ uniqueName, err := common.UniqueName(name, common.NameLimit128, func(candidate string) (bool, error) {
existing, err := s.searchDAO.GetByNameAndTenant(ctx, dao.DB, candidate, tenantID)
if err != nil {
return false, err
@@ -538,7 +538,10 @@ func (s *SearchService) UpdateSearch(ctx context.Context, searchID string, req *
}
// Check for duplicate names within the Search App's tenant.
- trimmedName := req.Name
+ trimmedName := strings.TrimSpace(req.Name)
+ if err := common.ValidateNameRunes(trimmedName, common.NameLimit128); err != nil {
+ return nil, err
+ }
available, err := common.NameAvailable(search.Name, trimmedName, func(candidate string) (bool, error) {
existing, err := s.searchDAO.GetByNameAndTenant(ctx, dao.DB, candidate, search.TenantID)
if err != nil {
diff --git a/internal/service/search_test.go b/internal/service/search_test.go
index 065fba752e..a0d2399fc6 100644
--- a/internal/service/search_test.go
+++ b/internal/service/search_test.go
@@ -23,6 +23,7 @@ import (
"strings"
"testing"
+ "ragflow/internal/common"
"ragflow/internal/dao"
"ragflow/internal/entity"
"ragflow/internal/permission"
@@ -66,6 +67,23 @@ func TestSearchServiceCreateRejectsEmptyName(t *testing.T) {
}
}
+func TestSearchServiceUpdateRejectsOverlongName(t *testing.T) {
+ setupSearchServiceTestDB(t)
+ ctx := serviceTestContext(t, "tenant-1", "tenant-1")
+ created, err := NewSearchService().CreateSearch(ctx, "Search", nil)
+ if err != nil {
+ t.Fatalf("CreateSearch failed: %v", err)
+ }
+
+ _, err = NewSearchService().UpdateSearch(ctx, created.SearchID, &UpdateSearchRequest{
+ Name: strings.Repeat("a", common.NameLimit128+1),
+ SearchConfig: map[string]interface{}{},
+ })
+ if err == nil || !strings.Contains(err.Error(), "larger than") {
+ t.Fatalf("UpdateSearch overlong name error = %v, want length error", err)
+ }
+}
+
func TestSearchServiceUpdateRejectsUnauthorizedSearchID(t *testing.T) {
setupSearchServiceTestDB(t)
diff --git a/internal/service/skill_space.go b/internal/service/skill_space.go
index 0a8dab9eef..812a79d2a1 100644
--- a/internal/service/skill_space.go
+++ b/internal/service/skill_space.go
@@ -27,6 +27,7 @@ import (
"ragflow/internal/entity"
"ragflow/internal/permission"
"ragflow/internal/service/file"
+ "strings"
"sync"
"time"
@@ -90,11 +91,11 @@ type CreateSpaceRequest struct {
// UpdateSpaceRequest represents the request to update a skills space
type UpdateSpaceRequest struct {
- Name string `json:"name"`
- Description string `json:"description"`
- EmbdID string `json:"embd_id"`
- RerankID string `json:"rerank_id"`
- TopK int `json:"top_k"`
+ Name *string `json:"name"`
+ Description string `json:"description"`
+ EmbdID string `json:"embd_id"`
+ RerankID string `json:"rerank_id"`
+ TopK int `json:"top_k"`
}
// getSkillsFolderID gets or creates the skills folder for a tenant
@@ -210,8 +211,8 @@ func (s *SkillSpaceService) CreateSpace(ctx context.Context, req *CreateSpaceReq
// Fall back to a numbered name when an active space already uses the
// requested one, mirroring the dataset create rule.
- // skill_space.name is a 128-byte column; keep generated names within it.
- spaceName, err := common.UniqueName(req.Name, 128, func(candidate string) (bool, error) {
+ // skill_space.name is a 128-character column; keep generated names within it.
+ spaceName, err := common.UniqueName(req.Name, common.NameLimit128, func(candidate string) (bool, error) {
existing, lookupErr := s.spaceDAO.GetByTenantAndName(ctx, dao.DB, tenantID, candidate)
if lookupErr != nil {
if dao.IsNotFoundErr(lookupErr) {
@@ -396,10 +397,21 @@ func (s *SkillSpaceService) UpdateSpace(ctx context.Context, spaceID string, req
// Build updates
updates := make(map[string]interface{})
- if req.Name != "" && req.Name != space.Name {
+ newName := ""
+ if req.Name != nil {
+ newName = strings.TrimSpace(*req.Name)
+ if newName == "" {
+ return nil, common.CodeDataError, errors.New("name cannot be empty or whitespace")
+ }
+ if err := common.ValidateNameRunes(newName, common.NameLimit128); err != nil {
+ return nil, common.CodeDataError, err
+ }
+ }
+
+ if newName != "" && newName != space.Name {
// Reject a rename onto another space's name; case-only changes are
// allowed, matching the dataset rename rule.
- available, err := common.NameAvailable(space.Name, req.Name, func(candidate string) (bool, error) {
+ available, err := common.NameAvailable(space.Name, newName, func(candidate string) (bool, error) {
existing, lookupErr := s.spaceDAO.GetByTenantAndName(ctx, dao.DB, tenantID, candidate)
if lookupErr != nil {
if dao.IsNotFoundErr(lookupErr) {
@@ -413,11 +425,11 @@ func (s *SkillSpaceService) UpdateSpace(ctx context.Context, spaceID string, req
return nil, common.CodeOperatingError, err
}
if !available {
- return nil, common.CodeDataError, fmt.Errorf("space with name '%s' already exists", req.Name)
+ return nil, common.CodeDataError, fmt.Errorf("space with name '%s' already exists", newName)
}
originalName := space.Name
- updates["name"] = req.Name
+ updates["name"] = newName
// Update space first, then folder (atomic-like behavior with rollback on failure)
if err = s.spaceDAO.UpdateByID(ctx, dao.DB, spaceID, updates); err != nil {
@@ -425,7 +437,7 @@ func (s *SkillSpaceService) UpdateSpace(ctx context.Context, spaceID string, req
}
// Update folder name as well - if this fails, rollback space name
- if err = s.fileDAO.UpdateByID(ctx, dao.DB, space.FolderID, map[string]interface{}{"name": req.Name}); err != nil {
+ if err = s.fileDAO.UpdateByID(ctx, dao.DB, space.FolderID, map[string]interface{}{"name": newName}); err != nil {
common.Error("Failed to update folder name, rolling back space name", err)
// Rollback space name
if rollbackErr := s.spaceDAO.UpdateByID(ctx, dao.DB, spaceID, map[string]interface{}{"name": originalName}); rollbackErr != nil {
diff --git a/internal/service/skill_space_test.go b/internal/service/skill_space_test.go
index 1abf9c786d..4e4451c6cc 100644
--- a/internal/service/skill_space_test.go
+++ b/internal/service/skill_space_test.go
@@ -38,6 +38,62 @@ import (
// the handler returns, so inheriting it left the space at status "2" forever:
// the delete endpoint answers with the idempotent "already deleting" success on
// every retry and space creation refuses the same name.
+// UpdateSpace must reject a supplied name that becomes empty after trimming,
+// while an omitted name remains a no-op for the other fields.
+func TestUpdateSpaceRejectsWhitespaceOnlyName(t *testing.T) {
+ db := setupServiceTestDB(t)
+ models := append([]interface{}{&entity.SkillSpace{}}, permissionChangeLogTestModels()...)
+ if err := db.AutoMigrate(models...); err != nil {
+ t.Fatalf("failed to migrate skill space: %v", err)
+ }
+ pushServiceDB(t, db)
+
+ valid := string(entity.StatusValid)
+ if err := db.Create(&entity.UserTenant{
+ ID: "owner-membership",
+ UserID: "owner-1",
+ TenantID: "tenant-1",
+ Role: string(permission.RoleOwner),
+ Status: &valid,
+ }).Error; err != nil {
+ t.Fatalf("create membership: %v", err)
+ }
+ if err := testsupport.PrepareEnterprisePermissionFixture(db, "tenant-1", "owner-1"); err != nil {
+ t.Fatalf("prepare skill space permission fixture: %v", err)
+ }
+ if err := db.Create(&entity.File{
+ ID: "folder-1",
+ ParentID: "skills-root",
+ TenantID: "tenant-1",
+ CreatedBy: "owner-1",
+ Name: "skills",
+ Type: "folder",
+ }).Error; err != nil {
+ t.Fatalf("create space folder: %v", err)
+ }
+
+ space := &entity.SkillSpace{
+ ID: "space-1",
+ UserID: "owner-1",
+ TenantID: "tenant-1",
+ Name: "skills",
+ FolderID: "folder-1",
+ Status: entity.SpaceStatusActive,
+ }
+ if err := db.Create(space).Error; err != nil {
+ t.Fatalf("create space: %v", err)
+ }
+
+ ctx := permission.WithIdentity(context.Background(), "owner-1", "tenant-1")
+ name := " "
+ if _, code, err := NewSkillSpaceService(nil).UpdateSpace(ctx, space.ID, &UpdateSpaceRequest{Name: &name}); err == nil || code != common.CodeDataError {
+ t.Fatalf("UpdateSpace = (%v, %v), want CodeDataError", code, err)
+ }
+ if _, code, err := NewSkillSpaceService(nil).UpdateSpace(ctx, space.ID, &UpdateSpaceRequest{Description: "updated"}); err != nil || code != common.CodeSuccess {
+ t.Fatalf("UpdateSpace with omitted name = (%v, %v), want success", code, err)
+ }
+}
+
func TestAsyncDeleteSpaceOutlivesTheRequestContext(t *testing.T) {
db := setupServiceTestDB(t)
models := append([]interface{}{&entity.SkillSpace{}}, permissionChangeLogTestModels()...)
diff --git a/internal/service/user.go b/internal/service/user.go
index 0276391429..14d93c9a47 100644
--- a/internal/service/user.go
+++ b/internal/service/user.go
@@ -119,6 +119,10 @@ func (s *UserService) Register(ctx context.Context, req *RegisterRequest) (*enti
if !emailRegex.MatchString(req.Email) {
return nil, common.CodeOperatingError, fmt.Errorf("invalid email address: %s", req.Email)
}
+ req.Nickname = strings.TrimSpace(req.Nickname)
+ if err := common.ValidateNameRunes(req.Nickname, common.NicknameLimit); err != nil {
+ return nil, common.CodeDataError, err
+ }
existUser, err := s.userDAO.GetByEmail(ctx, dao.DB, req.Email)
if existUser != nil {
@@ -690,7 +694,11 @@ func (s *UserService) UpdateUserSettings(ctx context.Context, user *entity.User,
}
}
if req.Nickname != nil {
- user.Nickname = *req.Nickname
+ nickname := strings.TrimSpace(*req.Nickname)
+ if err := common.ValidateNameRunes(nickname, common.NicknameLimit); err != nil {
+ return common.CodeDataError, err
+ }
+ user.Nickname = nickname
}
if req.Avatar != nil {
// In Go version, avatar might be stored differently
diff --git a/internal/utility/file.go b/internal/utility/file.go
index 9ebafdb09b..a87f8c0ba2 100644
--- a/internal/utility/file.go
+++ b/internal/utility/file.go
@@ -88,7 +88,7 @@ func normalizeFilename(filename string) (string, bool) {
}
base := filepath.Base(filename)
base = strings.TrimSpace(base)
- if base == "" || len(base) > filenameLenLimit {
+ if base == "" || utf8.RuneCountInString(base) > filenameLenLimit {
return "", false
}
return strings.ToLower(base), true
@@ -265,6 +265,44 @@ func TruncateFilename(name string, maxBytes int) string {
return name[:end] + ext
}
+// StorageKeyMaxBytes is the maximum size of one object-store path segment.
+// Filesystem-backed backends such as Silo and MinIO store each segment as a
+// file name and reject anything longer.
+const StorageKeyMaxBytes = 255
+
+// StorageObjectName returns a storage key segment for filename that fits
+// within maxBytes. Display names use Unicode code points, but object keys must
+// stay within the byte limit of the storage backend. attempt > 0 adds a
+// collision suffix before the extension without exceeding the budget.
+func StorageObjectName(filename string, attempt, maxBytes int) string {
+ if maxBytes <= 0 {
+ return ""
+ }
+ suffix := ""
+ if attempt > 0 {
+ suffix = fmt.Sprintf("(%d)", attempt)
+ }
+ if len(suffix) >= maxBytes {
+ return suffix[:maxBytes]
+ }
+ ext := filepath.Ext(filename)
+ if len(ext)+len(suffix) >= maxBytes {
+ ext = ""
+ }
+ budget := maxBytes - len(ext) - len(suffix)
+ base := strings.TrimSuffix(filename, ext)
+ if budget <= 0 {
+ base = ""
+ } else if len(base) > budget {
+ end := budget
+ for end > 0 && !utf8.RuneStart(base[end]) {
+ end--
+ }
+ base = base[:end]
+ }
+ return base + suffix + ext
+}
+
// CONTENT_TYPE_MAP maps file extensions to MIME content types
var CONTENT_TYPE_MAP = map[string]string{
// Office
diff --git a/internal/utility/storage_key_test.go b/internal/utility/storage_key_test.go
new file mode 100644
index 0000000000..27729c4e06
--- /dev/null
+++ b/internal/utility/storage_key_test.go
@@ -0,0 +1,68 @@
+//
+// 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 utility
+
+import (
+ "strings"
+ "testing"
+ "unicode/utf8"
+)
+
+func TestStorageObjectName(t *testing.T) {
+ longCJK := strings.Repeat("界", 100) + ".pdf"
+ longASCII := strings.Repeat("a", 300) + ".txt"
+
+ cases := []struct {
+ name string
+ filename string
+ attempt int
+ maxBytes int
+ want string
+ checkWant bool
+ wantSuffix string
+ wantPart string
+ }{
+ {name: "short ascii unchanged", filename: "deck.pptx", maxBytes: 255, want: "deck.pptx", checkWant: true},
+ {name: "long ascii keeps extension", filename: longASCII, maxBytes: 255, wantSuffix: ".txt"},
+ {name: "long cjk keeps extension", filename: longCJK, maxBytes: 255, wantSuffix: ".pdf"},
+ {name: "collision suffix stays in budget", filename: longCJK, attempt: 1, maxBytes: 255, wantSuffix: ".pdf", wantPart: "(1).pdf"},
+ {name: "no extension", filename: strings.Repeat("界", 100), maxBytes: 255},
+ {name: "extension larger than budget", filename: "file.pdf", maxBytes: 4, want: "file", checkWant: true},
+ {name: "zero budget", filename: "file.pdf", maxBytes: 0, want: "", checkWant: true},
+ }
+
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ got := StorageObjectName(tc.filename, tc.attempt, tc.maxBytes)
+ if tc.checkWant && got != tc.want {
+ t.Fatalf("StorageObjectName(%q, %d, %d) = %q, want %q", tc.filename, tc.attempt, tc.maxBytes, got, tc.want)
+ }
+ if tc.maxBytes > 0 && len(got) > tc.maxBytes {
+ t.Fatalf("StorageObjectName(%q, %d, %d) = %q (%d bytes), want <= %d bytes", tc.filename, tc.attempt, tc.maxBytes, got, len(got), tc.maxBytes)
+ }
+ if !utf8.ValidString(got) {
+ t.Fatalf("StorageObjectName(%q, %d, %d) = %q, want valid UTF-8", tc.filename, tc.attempt, tc.maxBytes, got)
+ }
+ if tc.wantSuffix != "" && !strings.HasSuffix(got, tc.wantSuffix) {
+ t.Fatalf("StorageObjectName(%q, %d, %d) = %q, want suffix %q", tc.filename, tc.attempt, tc.maxBytes, got, tc.wantSuffix)
+ }
+ if tc.wantPart != "" && !strings.Contains(got, tc.wantPart) {
+ t.Fatalf("StorageObjectName(%q, %d, %d) = %q, want %q", tc.filename, tc.attempt, tc.maxBytes, got, tc.wantPart)
+ }
+ })
+ }
+}
diff --git a/test/api/chat_api_test.go b/test/api/chat_api_test.go
index 6574bd0a00..f8ef18c1bd 100644
--- a/test/api/chat_api_test.go
+++ b/test/api/chat_api_test.go
@@ -12,6 +12,7 @@ import (
"slices"
"strings"
"testing"
+ "unicode/utf8"
)
func createRESTChat(t *testing.T, extra apiObject) apiObject {
@@ -130,19 +131,18 @@ func TestRESTChatNameValidation(t *testing.T) {
value any
}{
{"missing", nil}, {"empty", ""}, {"whitespace", " \t\n"}, {"number", 1},
- {"ascii_overflow", strings.Repeat("a", 256)}, {"utf8_overflow", strings.Repeat("界", 86)},
+ {"ascii_overflow", strings.Repeat("a", 256)}, {"utf8_overflow", strings.Repeat("界", 256)},
} {
t.Run("create/"+tc.name, func(t *testing.T) {
restCode(t, restCall(t, TestConfig, http.MethodPost, "/chats", apiObject{"name": tc.value, "dataset_ids": []string{}}, nil), 200, 102)
})
}
asciiPrefix := uniqueName("boundary_ascii")
- boundaryNames := []string{asciiPrefix + strings.Repeat("a", 255-len(asciiPrefix))}
+ boundaryNames := []string{asciiPrefix + strings.Repeat("a", 255-utf8.RuneCountInString(asciiPrefix))}
utf8Prefix := uniqueName("boundary_utf8")
- utf8Padding := 255 - len(utf8Prefix)
- boundaryNames = append(boundaryNames, utf8Prefix+strings.Repeat("界", utf8Padding/len("界"))+strings.Repeat("a", utf8Padding%len("界")))
+ boundaryNames = append(boundaryNames, utf8Prefix+strings.Repeat("界", 255-utf8.RuneCountInString(utf8Prefix)))
for _, name := range boundaryNames {
- t.Run(fmt.Sprintf("boundary/%d_bytes", len(name)), func(t *testing.T) {
+ t.Run(fmt.Sprintf("boundary/%d_chars", utf8.RuneCountInString(name)), func(t *testing.T) {
chat := createRESTChat(t, apiObject{"name": name})
assertChatValue(t, chat["name"], name)
assertChatValue(t, getRESTChat(t, chatID(t, chat))["name"], name)
diff --git a/test/api/document_api_test.go b/test/api/document_api_test.go
index 4781639b09..f42bd5e94a 100644
--- a/test/api/document_api_test.go
+++ b/test/api/document_api_test.go
@@ -151,8 +151,8 @@ func TestRESTDocumentUploadValidation(t *testing.T) {
}{
{"missing_file", nil, 101, "No file part!"},
{"empty_filename", []documentUpload{{Name: "", Content: []byte("x")}}, 101, "No file part!"},
- {"overlong_filename", []documentUpload{{Name: strings.Repeat("a", 252) + ".txt"}}, 101, "255 bytes"},
- {"multibyte_overlong_filename", []documentUpload{{Name: strings.Repeat("界", 84) + ".txt"}}, 101, "255 bytes"},
+ {"overlong_filename", []documentUpload{{Name: strings.Repeat("a", 252) + ".txt"}}, 101, "255 characters"},
+ {"multibyte_overlong_filename", []documentUpload{{Name: strings.Repeat("界", 252) + ".txt"}}, 101, "255 characters"},
{"unsupported_format", []documentUpload{{Name: "executable.exe", Content: []byte("not executable")}}, 500, "not been supported"},
} {
t.Run(tc.name, func(t *testing.T) {
diff --git a/test/api/search_api_test.go b/test/api/search_api_test.go
index b0d312c521..ed7ee6102b 100644
--- a/test/api/search_api_test.go
+++ b/test/api/search_api_test.go
@@ -173,7 +173,7 @@ func TestRESTSearchNameRules(t *testing.T) {
for _, tc := range []struct{ name, value, want string }{
{"empty", "", "empty"},
{"whitespace", " \t ", "empty"},
- {"oversized", strings.Repeat("s", 257), "large than"},
+ {"oversized", strings.Repeat("s", 257), "larger than"},
} {
t.Run(tc.name, func(t *testing.T) {
result := restCall(t, TestConfig, http.MethodPost, "/searches", apiObject{"name": tc.value}, nil)
diff --git a/test/testcases/test_sdk_api/test_chat_assistant_management/test_update_chat_assistant.py b/test/testcases/test_sdk_api/test_chat_assistant_management/test_update_chat_assistant.py
index 226a3f27a7..794c95cb2d 100644
--- a/test/testcases/test_sdk_api/test_chat_assistant_management/test_update_chat_assistant.py
+++ b/test/testcases/test_sdk_api/test_chat_assistant_management/test_update_chat_assistant.py
@@ -21,7 +21,7 @@ import pytest
from PIL import Image
pytestmark = pytest.mark.integration
-CHAT_NAME_MAX_BYTES = 255
+CHAT_NAME_MAX_CHARS = 255
@pytest.mark.p3
@@ -42,8 +42,8 @@ def test_name(client, chat_factory, name_case, expected_message):
original_name = chat.name
name = {
"unique": f"renamed-{uuid4().hex}",
- "max_length": "a" * CHAT_NAME_MAX_BYTES,
- "too_long": "a" * (CHAT_NAME_MAX_BYTES + 1),
+ "max_length": "a" * CHAT_NAME_MAX_CHARS,
+ "too_long": "a" * (CHAT_NAME_MAX_CHARS + 1),
"non_string": 1,
"empty": "",
}.get(name_case)
diff --git a/test/testcases/test_sdk_api/test_file_management_within_dataset/test_update_document.py b/test/testcases/test_sdk_api/test_file_management_within_dataset/test_update_document.py
index c0d3a6b3b8..0de586a0c5 100644
--- a/test/testcases/test_sdk_api/test_file_management_within_dataset/test_update_document.py
+++ b/test/testcases/test_sdk_api/test_file_management_within_dataset/test_update_document.py
@@ -30,7 +30,8 @@ class TestDocumentsUpdated:
pytest.param(f"{'a' * 251}.txt", ""),
(0, "Field: <name> - Message: <Input should be a valid string> - Value: <0>"),
(None, "Field: <name> - Message: <Input should be a valid string> - Value: <None>"),
- ("", "the extension of file can't be changed"),
+ ("", "name cannot be empty or whitespace"),
+ (" ", "name cannot be empty or whitespace"),
("ragflow_test_upload_0", "the extension of file can't be changed"),
("ragflow_test_upload_1.txt", "duplicated document name in the same dataset"),
("RAGFLOW_TEST_UPLOAD_1.TXT", "duplicated document name in the same dataset"),
diff --git a/test/testcases/test_sdk_api/test_file_management_within_dataset/test_upload_documents.py b/test/testcases/test_sdk_api/test_file_management_within_dataset/test_upload_documents.py
index 7aef4f5ed3..ca42e8abda 100644
--- a/test/testcases/test_sdk_api/test_file_management_within_dataset/test_upload_documents.py
+++ b/test/testcases/test_sdk_api/test_file_management_within_dataset/test_upload_documents.py
@@ -19,7 +19,7 @@ from pathlib import Path
import pytest
-DOCUMENT_NAME_MAX_BYTES = 255
+DOCUMENT_NAME_MAX_CHARS = 255
TEXT_FILE_CONTENT = "This is the content of a test TXT file."
@@ -128,7 +128,7 @@ class TestDocumentsUpload:
@pytest.mark.p2
def test_filename_max_length(self, add_dataset_func, tmp_path):
dataset = add_dataset_func
- fp = _create_text_file(tmp_path / f"{'a' * (DOCUMENT_NAME_MAX_BYTES - len('.txt'))}.txt")
+ fp = _create_text_file(tmp_path / f"{'a' * (DOCUMENT_NAME_MAX_CHARS - len('.txt'))}.txt")
with fp.open("rb") as f:
blob = f.read()
@@ -144,15 +144,23 @@ class TestDocumentsUpload:
"display_name",
[
"a" * 252 + ".txt",
- "界" * 84 + ".txt",
+ "界" * 252 + ".txt",
],
)
def test_filename_over_limit(self, add_dataset_func, display_name):
- assert len(display_name.encode("utf-8")) == DOCUMENT_NAME_MAX_BYTES + 1
+ assert len(display_name) == DOCUMENT_NAME_MAX_CHARS + 1
- with pytest.raises(Exception, match="File name must be 255 bytes or less\\."):
+ with pytest.raises(Exception, match="File name must be at most 255 characters\\."):
add_dataset_func.upload_documents([{"display_name": display_name, "blob": b"content"}])
+ @pytest.mark.p2
+ def test_multibyte_filename_within_character_limit(self, add_dataset_func):
+ dataset = add_dataset_func
+ display_name = "界" * (DOCUMENT_NAME_MAX_CHARS - len(".txt")) + ".txt"
+ documents = dataset.upload_documents([{"display_name": display_name, "blob": b"content"}])
+ assert len(documents) == 1, str(documents)
+ assert documents[0].name == display_name, str(documents[0])
+
@pytest.mark.p2
def test_partial_upload_persists_successful_file(self, add_dataset_func):
dataset = add_dataset_func