Skip to content

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

feat(go-auth): bind tenant context to access tokens and API keys (#21153)

buua43651351ef7dc4f
diff --git a/internal/admin/handler.go b/internal/admin/handler.go
index 48ea881865..f169883316 100644
--- a/internal/admin/handler.go
+++ b/internal/admin/handler.go
@@ -119,7 +119,7 @@ func (h *Handler) Login(c *gin.Context) {
return
}
- authToken, err := common.DumpAccessToken(*user.AccessToken, secretKey)
+ authToken, err := common.DumpAccessToken(*user.AccessToken, "", secretKey)
if err != nil {
common.ErrorWithCode(c, common.CodeServerError, fmt.Sprintf("Failed to generate auth token: %s", err.Error()))
return
@@ -821,8 +821,7 @@ func writeSandboxError(c *gin.Context, err error) {
common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeServerError, nil, err.Error())
}
-// AuthMiddleware JWT auth middleware
-// Validates that the user is authenticated and is a superuser (admin)
+// AuthMiddleware authenticates system administrators for admin routes.
func (h *Handler) AuthMiddleware() gin.HandlerFunc {
return func(c *gin.Context) {
ctx := c.Request.Context()
@@ -834,14 +833,15 @@ func (h *Handler) AuthMiddleware() gin.HandlerFunc {
}
// Get user by access token
- user, code, err := h.userService.GetUserByToken(ctx, token)
+ identity, code, err := h.userService.ResolveAccessToken(ctx, token)
if err != nil {
common.ResponseWithHttpCodeData(c, http.StatusUnauthorized, code, nil, "Invalid access token")
c.Abort()
return
}
- if !*user.IsSuperuser {
+ user := identity.User
+ if user.IsSuperuser == nil || !*user.IsSuperuser {
common.ResponseWithHttpCodeData(c, http.StatusForbidden, common.CodeForbidden, nil, "Permission denied")
c.Abort()
return
@@ -849,6 +849,7 @@ func (h *Handler) AuthMiddleware() gin.HandlerFunc {
c.Set("user", user)
c.Set("user_id", user.ID)
+ c.Set("tenant_id", identity.TenantID)
c.Set("email", user.Email)
c.Next()
}
diff --git a/internal/admin/service.go b/internal/admin/service.go
index c6a35b8868..264c79e7c9 100644
--- a/internal/admin/service.go
+++ b/internal/admin/service.go
@@ -568,7 +568,7 @@ func (s *Service) ListUserAPITokens(ctx context.Context, username string) ([]map
}
// 2. Get user's tenants
- userTenants, err := s.userTenantDAO.GetByUserID(ctx, dao.DB, user.ID)
+ userTenants, err := s.userTenantDAO.GetByUserIDAndRole(ctx, dao.DB, user.ID, "owner")
if err != nil || len(userTenants) == 0 {
return nil, fmt.Errorf("tenant not found")
}
@@ -585,6 +585,7 @@ func (s *Service) ListUserAPITokens(ctx context.Context, username string) ([]map
result := make([]map[string]interface{}, 0, len(tokens))
for _, token := range tokens {
result = append(result, map[string]interface{}{
+ "user_id": token.UserID,
"tenant_id": token.TenantID,
"token": token.Token,
"beta": token.Beta,
@@ -609,7 +610,7 @@ func (s *Service) GenerateUserAPIToken(ctx context.Context, username string) (ma
}
// 2. Get user's tenants
- userTenants, err := s.userTenantDAO.GetByUserID(ctx, dao.DB, user.ID)
+ userTenants, err := s.userTenantDAO.GetByUserIDAndRole(ctx, dao.DB, user.ID, "owner")
if err != nil || len(userTenants) == 0 {
return nil, fmt.Errorf("tenant not found")
}
@@ -622,6 +623,7 @@ func (s *Service) GenerateUserAPIToken(ctx context.Context, username string) (ma
apiToken := &entity.APIToken{
TenantID: tenantID,
+ UserID: &user.ID,
Token: key,
Beta: &beta,
}
@@ -632,6 +634,7 @@ func (s *Service) GenerateUserAPIToken(ctx context.Context, username string) (ma
}
return map[string]interface{}{
+ "user_id": user.ID,
"tenant_id": tenantID,
"token": key,
"beta": beta,
@@ -651,7 +654,7 @@ func (s *Service) DeleteUserAPIToken(ctx context.Context, username, key string)
}
// 2. Get user's tenants
- userTenants, err := s.userTenantDAO.GetByUserID(ctx, dao.DB, user.ID)
+ userTenants, err := s.userTenantDAO.GetByUserIDAndRole(ctx, dao.DB, user.ID, "owner")
if err != nil || len(userTenants) == 0 {
return fmt.Errorf("tenant not found")
}
diff --git a/internal/common/token.go b/internal/common/token.go
index 3b1b5e5fee..dcf70e38d7 100644
--- a/internal/common/token.go
+++ b/internal/common/token.go
@@ -17,18 +17,14 @@
package common
import (
- "bytes"
- "compress/zlib"
"crypto/hmac"
"crypto/rand"
- "crypto/sha1"
+ "crypto/sha256"
"encoding/base64"
- "encoding/binary"
"encoding/hex"
- "encoding/json"
"errors"
"fmt"
- "io"
+ "strconv"
"strings"
"time"
@@ -37,159 +33,98 @@ import (
const accessTokenExpireSeconds = 86400
-// ExtractAccessToken extract access token from authorization header
-// This is equivalent to: str(jwt.loads(authorization)) in Python
-func ExtractAccessToken(authorization, secretKey string) (string, error) {
- if authorization == "" {
- return "", errors.New("empty authorization")
- }
+const accessTokenContextVersion = "v2"
- // Strip "Bearer " prefix if present
- token := strings.TrimPrefix(authorization, "Bearer ")
-
- encodedValue, err := unsignAccessToken(token, secretKey, accessTokenExpireSeconds)
- if err != nil {
- return "", fmt.Errorf("failed to decode token: %w", err)
- }
-
- jsonValue, err := decodePayload(encodedValue)
- if err != nil {
- return "", fmt.Errorf("failed to decode payload: %w", err)
- }
-
- var value string
- if err := json.Unmarshal(jsonValue, &value); err != nil {
- return "", fmt.Errorf("failed to parse payload: %w", err)
- }
-
- return value, nil
+// AccessTokenContext is the identity and tenant context carried by a signed
+// user token. TenantID is empty in Community Edition and for system admins.
+type AccessTokenContext struct {
+ AccessToken string
+ TenantID string
}
-// DumpAccessToken creates an authorization token from access token
-// This is equivalent to: jwt.dumps(access_token) in Python
-func DumpAccessToken(accessToken, secretKey string) (string, error) {
- if accessToken == "" {
- return "", errors.New("empty access token")
- }
-
- jsonValue, err := json.Marshal(accessToken)
- if err != nil {
- return "", fmt.Errorf("failed to encode payload: %w", err)
+// ExtractAccessTokenContext extracts the access token and tenant context from
+// an authorization header.
+func ExtractAccessTokenContext(authorization, secretKey string) (*AccessTokenContext, error) {
+ if authorization == "" {
+ return nil, errors.New("empty authorization")
}
- return signAccessToken(encodePayload(jsonValue), secretKey), nil
-}
-
-// urlSafeB64Decode URL-safe base64 decode
-func urlSafeB64Decode(s string) ([]byte, error) {
- return base64.RawURLEncoding.DecodeString(s)
-}
-
-// urlSafeB64Encode URL-safe base64 encode (without padding)
-func urlSafeB64Encode(data []byte) string {
- return base64.RawURLEncoding.EncodeToString(data)
-}
-
-func encodePayload(jsonValue []byte) string {
- var buf bytes.Buffer
- zw := zlib.NewWriter(&buf)
- _, _ = zw.Write(jsonValue)
- _ = zw.Close()
-
- compressed := buf.Bytes()
- if len(compressed) < len(jsonValue)-1 {
- return "." + urlSafeB64Encode(compressed)
- }
- return urlSafeB64Encode(jsonValue)
-}
+ // Strip an optional Bearer scheme.
+ token := strings.TrimSpace(authorization)
+ token = strings.TrimPrefix(token, "Bearer ")
+ token = strings.TrimSpace(token)
-func decodePayload(payload string) ([]byte, error) {
- decompress := false
- if strings.HasPrefix(payload, ".") {
- payload = payload[1:]
- decompress = true
+ parts := strings.Split(token, ".")
+ if len(parts) != 5 || parts[0] != accessTokenContextVersion {
+ return nil, errors.New("invalid access token format")
}
- jsonValue, err := urlSafeB64Decode(payload)
+ signature, err := urlSafeB64Decode(parts[4])
if err != nil {
- return nil, err
+ return nil, fmt.Errorf("malformed token signature: %w", err)
}
- if !decompress {
- return jsonValue, nil
+ value := strings.Join(parts[:4], ".")
+ mac := hmac.New(sha256.New, []byte(secretKey))
+ mac.Write([]byte(value))
+ if !hmac.Equal(signature, mac.Sum(nil)) {
+ return nil, errors.New("token signature does not match")
}
- zr, err := zlib.NewReader(bytes.NewReader(jsonValue))
+ timestamp, err := strconv.ParseInt(parts[3], 10, 64)
if err != nil {
- return nil, err
+ return nil, fmt.Errorf("malformed token timestamp: %w", err)
}
- defer zr.Close()
- return io.ReadAll(zr)
-}
-
-func signAccessToken(payload, secretKey string) string {
- value := payload + "." + urlSafeB64Encode(intToBytes(time.Now().Unix()))
- return value + "." + getAccessTokenSignature(value, secretKey)
-}
-
-func unsignAccessToken(token, secretKey string, maxAge int64) (string, error) {
- token = strings.TrimSpace(token)
-
- li := strings.LastIndex(token, ".")
- if li < 0 {
- return "", errors.New("signature missing")
+ age := time.Now().Unix() - timestamp
+ if age > accessTokenExpireSeconds {
+ return nil, fmt.Errorf("token age %d > %d seconds", age, accessTokenExpireSeconds)
}
- value := token[:li]
- sig := token[li+1:]
- if !hmac.Equal([]byte(sig), []byte(getAccessTokenSignature(value, secretKey))) {
- return "", errors.New("signature does not match")
+ if age < 0 {
+ return nil, fmt.Errorf("token age %d < 0 seconds", age)
}
- li = strings.LastIndex(value, ".")
- if li < 0 {
- return "", errors.New("timestamp missing")
+ accessTokenBytes, err := urlSafeB64Decode(parts[1])
+ if err != nil {
+ return nil, fmt.Errorf("malformed access token: %w", err)
}
- payload := value[:li]
- tsValue := value[li+1:]
- tsBytes, err := urlSafeB64Decode(tsValue)
+ tenantIDBytes, err := urlSafeB64Decode(parts[2])
if err != nil {
- return "", fmt.Errorf("malformed timestamp: %w", err)
+ return nil, fmt.Errorf("malformed tenant context: %w", err)
}
- timestamp := bytesToInt(tsBytes)
- if maxAge > 0 {
- age := time.Now().Unix() - timestamp
- if age > maxAge {
- return "", fmt.Errorf("signature age %d > %d seconds", age, maxAge)
- }
- if age < 0 {
- return "", fmt.Errorf("signature age %d < 0 seconds", age)
- }
+ if len(accessTokenBytes) == 0 {
+ return nil, errors.New("empty access token")
}
- return payload, nil
-}
-func getAccessTokenSignature(value, secretKey string) string {
- h := sha1.New()
- h.Write([]byte("itsdangerous" + "signer" + secretKey))
- key := h.Sum(nil)
+ return &AccessTokenContext{
+ AccessToken: string(accessTokenBytes),
+ TenantID: string(tenantIDBytes),
+ }, nil
+}
- mac := hmac.New(sha1.New, key)
+// DumpAccessToken creates a signed authorization token from a user access
+// token and its active tenant context.
+func DumpAccessToken(accessToken, tenantID, secretKey string) (string, error) {
+ if accessToken == "" {
+ return "", errors.New("empty access token")
+ }
+ value := strings.Join([]string{
+ accessTokenContextVersion,
+ urlSafeB64Encode([]byte(accessToken)),
+ urlSafeB64Encode([]byte(tenantID)),
+ strconv.FormatInt(time.Now().Unix(), 10),
+ }, ".")
+ mac := hmac.New(sha256.New, []byte(secretKey))
mac.Write([]byte(value))
- return urlSafeB64Encode(mac.Sum(nil))
+ return value + "." + urlSafeB64Encode(mac.Sum(nil)), nil
}
-func intToBytes(num int64) []byte {
- var buf [8]byte
- binary.BigEndian.PutUint64(buf[:], uint64(num))
- return bytes.TrimLeft(buf[:], "\x00")
+// urlSafeB64Decode decodes unpadded URL-safe base64.
+func urlSafeB64Decode(s string) ([]byte, error) {
+ return base64.RawURLEncoding.DecodeString(s)
}
-func bytesToInt(data []byte) int64 {
- if len(data) > 8 {
- data = data[len(data)-8:]
- }
- var buf [8]byte
- copy(buf[8-len(data):], data)
- return int64(binary.BigEndian.Uint64(buf[:]))
+// urlSafeB64Encode encodes unpadded URL-safe base64.
+func urlSafeB64Encode(data []byte) string {
+ return base64.RawURLEncoding.EncodeToString(data)
}
// GenerateSecretKey generates a 32-byte hex string (equivalent to Python's secrets.token_hex(32))
diff --git a/internal/common/token_test.go b/internal/common/token_test.go
new file mode 100644
index 0000000000..b58e811263
--- /dev/null
+++ b/internal/common/token_test.go
@@ -0,0 +1,77 @@
+//
+// 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 "testing"
+
+func TestAccessTokenContextRoundTrip(t *testing.T) {
+ token, err := DumpAccessToken("access-token-12345678901234567890", "tenant-123456789012345678901234567890", "secret")
+ if err != nil {
+ t.Fatalf("DumpAccessToken() error = %v", err)
+ }
+
+ got, err := ExtractAccessTokenContext(token, "secret")
+ if err != nil {
+ t.Fatalf("ExtractAccessTokenContext() error = %v", err)
+ }
+ if got.AccessToken != "access-token-12345678901234567890" {
+ t.Errorf("AccessToken = %q", got.AccessToken)
+ }
+ if got.TenantID != "tenant-123456789012345678901234567890" {
+ t.Errorf("TenantID = %q", got.TenantID)
+ }
+}
+
+func TestAccessTokenContextAllowsEmptyTenant(t *testing.T) {
+ token, err := DumpAccessToken("access-token-12345678901234567890", "", "secret")
+ if err != nil {
+ t.Fatalf("DumpAccessToken() error = %v", err)
+ }
+
+ got, err := ExtractAccessTokenContext(token, "secret")
+ if err != nil {
+ t.Fatalf("ExtractAccessTokenContext() error = %v", err)
+ }
+ if got.TenantID != "" {
+ t.Errorf("TenantID = %q, want empty", got.TenantID)
+ }
+}
+
+func TestAccessTokenContextSupportsSeparators(t *testing.T) {
+ token, err := DumpAccessToken("access|token", "tenant|id", "secret")
+ if err != nil {
+ t.Fatalf("DumpAccessToken() error = %v", err)
+ }
+
+ got, err := ExtractAccessTokenContext(token, "secret")
+ if err != nil {
+ t.Fatalf("ExtractAccessTokenContext() error = %v", err)
+ }
+ if got.AccessToken != "access|token" || got.TenantID != "tenant|id" {
+ t.Fatalf("context = %+v, want access|token in tenant|id", got)
+ }
+}
+
+func TestAccessTokenContextRejectsWrongSigningKey(t *testing.T) {
+ token, err := DumpAccessToken("access-token", "tenant-1", "secret")
+ if err != nil {
+ t.Fatalf("DumpAccessToken() error = %v", err)
+ }
+ if _, err = ExtractAccessTokenContext(token, "wrong-secret"); err == nil {
+ t.Fatal("ExtractAccessTokenContext() accepted the wrong signing key")
+ }
+}
diff --git a/internal/dao/user.go b/internal/dao/user.go
index cf1916443c..11a4bf5f67 100644
--- a/internal/dao/user.go
+++ b/internal/dao/user.go
@@ -46,6 +46,16 @@ func (dao *UserDAO) GetByID(ctx context.Context, db *gorm.DB, id uint) (*entity.
return &user, nil
}
+// GetByIDString gets a user by its string ID.
+func (dao *UserDAO) GetByIDString(ctx context.Context, db *gorm.DB, id string) (*entity.User, error) {
+ var user entity.User
+ err := db.WithContext(ctx).Where("id = ?", id).First(&user).Error
+ if err != nil {
+ return nil, err
+ }
+ return &user, nil
+}
+
func (dao *UserDAO) GetByTenantID(ctx context.Context, db *gorm.DB, tenantID string) (*entity.User, error) {
var user entity.User
err := db.WithContext(ctx).Where("id = ?", tenantID).First(&user).Error
diff --git a/internal/handler/api_token.go b/internal/handler/api_token.go
index 85514d01f2..d17cfbe639 100644
--- a/internal/handler/api_token.go
+++ b/internal/handler/api_token.go
@@ -30,31 +30,13 @@ import (
)
func (h *SystemHandler) ListAPIKeys(c *gin.Context) {
- // Get current user from context
- user, exists := c.Get("user")
- if !exists {
- common.ResponseWithHttpCodeData(c, http.StatusUnauthorized, 401, nil, "Unauthorized")
- return
- }
-
- userModel, ok := user.(*entity.User)
- if !ok {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, "Invalid user data")
- return
- }
-
- // Get user's tenant with owner role
- userTenantDAO := dao.NewUserTenantDAO()
ctx := c.Request.Context()
-
- tenants, err := userTenantDAO.GetByUserIDAndRole(ctx, dao.DB, userModel.ID, "owner")
- if err != nil || len(tenants) == 0 {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Tenant not found")
+ _, tenantID, code, err := currentAPIKeyOwner(c)
+ if err != nil {
+ respondAPIKeyContextError(c, code, err)
return
}
- tenantID := tenants[0].TenantID
-
// Get keys for the tenant
keys, err := h.systemService.ListAPIKeys(ctx, tenantID)
if err != nil {
@@ -66,31 +48,13 @@ func (h *SystemHandler) ListAPIKeys(c *gin.Context) {
}
func (h *SystemHandler) CreateKey(c *gin.Context) {
- // Get current user from context
- user, exists := c.Get("user")
- if !exists {
- common.ResponseWithHttpCodeData(c, http.StatusUnauthorized, 401, nil, "Unauthorized")
- return
- }
-
- userModel, ok := user.(*entity.User)
- if !ok {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, "Invalid user data")
- return
- }
-
- // Get user's tenant with owner role
- userTenantDAO := dao.NewUserTenantDAO()
ctx := c.Request.Context()
-
- tenants, err := userTenantDAO.GetByUserIDAndRole(ctx, dao.DB, userModel.ID, "owner")
- if err != nil || len(tenants) == 0 {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Tenant not found")
+ user, tenantID, code, err := currentAPIKeyOwner(c)
+ if err != nil {
+ respondAPIKeyContextError(c, code, err)
return
}
- tenantID := tenants[0].TenantID
-
// Parse request. An empty body is valid (all fields are optional);
// ShouldBind reports io.EOF for it.
var req service.CreateAPIKeyRequest
@@ -100,7 +64,7 @@ func (h *SystemHandler) CreateKey(c *gin.Context) {
}
// Create key
- key, err := h.systemService.CreateAPIKey(ctx, tenantID, &req)
+ key, err := h.systemService.CreateAPIKey(ctx, user.ID, tenantID, &req)
if err != nil {
common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, "Failed to create key")
return
@@ -110,31 +74,13 @@ func (h *SystemHandler) CreateKey(c *gin.Context) {
}
func (h *SystemHandler) DeleteKey(c *gin.Context) {
- // Get current user from context
- user, exists := c.Get("user")
- if !exists {
- common.ResponseWithHttpCodeData(c, http.StatusUnauthorized, 401, nil, "Unauthorized")
- return
- }
-
- userModel, ok := user.(*entity.User)
- if !ok {
- common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, 500, nil, "Invalid user data")
- return
- }
ctx := c.Request.Context()
-
- // Get user's tenant with owner role
- userTenantDAO := dao.NewUserTenantDAO()
-
- tenants, err := userTenantDAO.GetByUserIDAndRole(ctx, dao.DB, userModel.ID, "owner")
- if err != nil || len(tenants) == 0 {
- common.ResponseWithHttpCodeData(c, http.StatusBadRequest, 400, nil, "Tenant not found")
+ _, tenantID, code, err := currentAPIKeyOwner(c)
+ if err != nil {
+ respondAPIKeyContextError(c, code, err)
return
}
- tenantID := tenants[0].TenantID
-
// Get key from path parameter
key := c.Param("key")
if key == "" {
@@ -150,3 +96,35 @@ func (h *SystemHandler) DeleteKey(c *gin.Context) {
common.SuccessWithData(c, true, "success")
}
+
+func currentAPIKeyOwner(c *gin.Context) (*entity.User, string, common.ErrorCode, error) {
+ userValue, exists := c.Get("user")
+ if !exists {
+ return nil, "", common.CodeUnauthorized, errors.New("Unauthorized")
+ }
+ user, ok := userValue.(*entity.User)
+ if !ok {
+ return nil, "", common.CodeServerError, errors.New("Invalid user data")
+ }
+
+ tenantID := c.GetString("tenant_id")
+ if tenantID == "" {
+ // Community Edition keeps the single-tenant user ID as its scope.
+ tenantID = user.ID
+ }
+ membership, err := dao.NewUserTenantDAO().FilterByUserIDAndTenantID(c.Request.Context(), dao.DB, user.ID, tenantID)
+ if err != nil || membership.Role != "owner" {
+ return nil, "", common.CodeForbidden, errors.New("Only the tenant owner can manage API keys")
+ }
+ return user, tenantID, common.CodeSuccess, nil
+}
+
+func respondAPIKeyContextError(c *gin.Context, code common.ErrorCode, err error) {
+ status := http.StatusForbidden
+ if code == common.CodeUnauthorized {
+ status = http.StatusUnauthorized
+ } else if code == common.CodeServerError {
+ status = http.StatusInternalServerError
+ }
+ common.ResponseWithHttpCodeData(c, status, code, nil, err.Error())
+}
diff --git a/internal/handler/auth.go b/internal/handler/auth.go
index 836a113eb6..9ab7f70982 100644
--- a/internal/handler/auth.go
+++ b/internal/handler/auth.go
@@ -33,20 +33,20 @@ type AuthHandler struct {
userService userTokenResolver
}
-// ResolveMCPUser applies the same API-key/JWT resolution used by the public
-// MCP route, for the standalone native MCP transport.
+// ResolveMCPUser applies the same API-key and user-token resolution used by
+// the public MCP route, for the standalone native MCP transport.
func (h *AuthHandler) ResolveMCPUser(ctx context.Context, authorization string) (*entity.User, error) {
if authorization == "" {
return nil, fmt.Errorf("missing authorization header")
}
- if u, code, err := h.userService.GetUserByToken(ctx, authorization); err == nil && code == common.CodeSuccess {
- return u, nil
+ if identity, code, err := h.userService.ResolveAccessToken(ctx, authorization); err == nil && code == common.CodeSuccess {
+ return identity.User, nil
}
- if u, code, err := h.userService.GetUserByAPIToken(ctx, authorization); err == nil && code == common.CodeSuccess {
- return u, nil
+ if identity, code, err := h.userService.ResolveAPIToken(ctx, authorization); err == nil && code == common.CodeSuccess {
+ return identity.User, nil
}
- if u, code, err := h.userService.GetUserByBetaAPIToken(ctx, authorization); err == nil && code == common.CodeSuccess {
- return u, nil
+ if identity, code, err := h.userService.ResolveBetaAPIToken(ctx, authorization); err == nil && code == common.CodeSuccess {
+ return identity.User, nil
}
return nil, fmt.Errorf("invalid authorization")
}
@@ -54,12 +54,11 @@ func (h *AuthHandler) ResolveMCPUser(ctx context.Context, authorization string)
// userTokenResolver is the subset of UserService the auth
// middleware actually depends on. We keep it as a small interface
// so the test suite can swap in a stub without spinning up the
-// full UserService (which requires a live Redis + JWT secret).
+// full UserService (which requires a live Redis + token signing key).
type userTokenResolver interface {
- GetUserByToken(ctx context.Context, authorization string) (*entity.User, common.ErrorCode, error)
- GetUserByAPIToken(ctx context.Context, token string) (*entity.User, common.ErrorCode, error)
- GetUserByBetaAPIToken(ctx context.Context, token string) (*entity.User, common.ErrorCode, error)
- GetAPITokenByBeta(ctx context.Context, authorization string) (*entity.APIToken, error)
+ ResolveAccessToken(ctx context.Context, authorization string) (*service.AuthIdentity, common.ErrorCode, error)
+ ResolveAPIToken(ctx context.Context, token string) (*service.AuthIdentity, common.ErrorCode, error)
+ ResolveBetaAPIToken(ctx context.Context, token string) (*service.AuthIdentity, common.ErrorCode, error)
}
// NewAuthHandler create auth handler
@@ -69,23 +68,18 @@ func NewAuthHandler() *AuthHandler {
}
}
-// BetaAuthMiddleware resolves a user token, API token, or `beta` API token
+// BetaAuthMiddleware resolves a user token, API token, or beta API token
// from the Authorization header and sets the user on the gin.Context.
//
-// A beta token can also be a regular user JWT or API token. Order of
+// A beta endpoint also accepts user and regular API tokens. Order of
// precedence:
//
-// 1. Beta API token → GetUserByBetaAPIToken
-// 2. JWT (regular session) → existing UserService.GetUserByToken
-// 3. API token → GetUserByAPIToken
+// 1. User token → ResolveAccessToken
+// 2. API token → ResolveAPIToken
+// 3. Beta API token → ResolveBetaAPIToken
// 4. Fall through → code 102 "Authorization is not valid!"
//
-// IMPORTANT: the regular-user branch is NOT gated on a "Bearer "
-// prefix. UserService.GetUserByToken accepts the raw Authorization
-// header value and ExtractAccessToken handles Bearer stripping
-// internally. The existing AuthMiddleware() above also passes the
-// raw header to GetUserByToken without pre-filtering, so a non-Bearer
-// regular user token must keep working here too.
+// The user-token branch accepts either a raw token or a Bearer token.
func (h *AuthHandler) BetaAuthMiddleware() gin.HandlerFunc {
return func(c *gin.Context) {
ctx := c.Request.Context()
@@ -103,24 +97,24 @@ func (h *AuthHandler) BetaAuthMiddleware() gin.HandlerFunc {
c.Abort()
return
}
- // AUTH_JWT
- if u, code, err := h.userService.GetUserByToken(ctx, auth); err == nil && code == common.CodeSuccess {
- c.Set("user", u)
+ if identity, code, err := h.userService.ResolveAccessToken(ctx, auth); err == nil && code == common.CodeSuccess {
+ setAuthIdentity(c, identity)
c.Next()
return
}
// Then try a regular API token (non-beta public bot flow).
- if u, code, err := h.userService.GetUserByAPIToken(ctx, auth); err == nil && code == common.CodeSuccess {
- c.Set("user", u)
+ if identity, code, err := h.userService.ResolveAPIToken(ctx, auth); err == nil && code == common.CodeSuccess {
+ setAuthIdentity(c, identity)
c.Set("auth_via_api_token", true)
c.Next()
return
}
// Fall back to beta API token (public bot access).
- if u, code, err := h.userService.GetUserByBetaAPIToken(ctx, auth); err == nil && code == common.CodeSuccess {
- c.Set("user", u)
- if tok, terr := h.userService.GetAPITokenByBeta(ctx, auth); terr == nil && tok != nil && tok.DialogID != nil {
- c.Set("agent_id", *tok.DialogID)
+ if identity, code, err := h.userService.ResolveBetaAPIToken(ctx, auth); err == nil && code == common.CodeSuccess {
+ setAuthIdentity(c, identity)
+ c.Set("auth_via_beta_token", true)
+ if identity.APIToken != nil && identity.APIToken.DialogID != nil {
+ c.Set("agent_id", *identity.APIToken.DialogID)
}
c.Next()
return
@@ -131,8 +125,8 @@ func (h *AuthHandler) BetaAuthMiddleware() gin.HandlerFunc {
}
}
-// AuthMiddleware JWT auth middleware
-// Validates that the user is authenticated and is a superuser (admin)
+// AuthMiddleware authenticates API requests and rejects system admins from
+// using the tenant API surface.
func (h *AuthHandler) AuthMiddleware() gin.HandlerFunc {
return func(c *gin.Context) {
ctx := c.Request.Context()
@@ -145,10 +139,9 @@ func (h *AuthHandler) AuthMiddleware() gin.HandlerFunc {
authViaAPIToken := false
- // Get user by access token
- user, code, err := h.userService.GetUserByToken(ctx, token)
+ identity, code, err := h.userService.ResolveAccessToken(ctx, token)
if err != nil {
- user, code, err = h.userService.GetUserByAPIToken(ctx, token)
+ identity, code, err = h.userService.ResolveAPIToken(ctx, token)
if err != nil {
common.ResponseWithHttpCodeData(c, http.StatusUnauthorized, code, nil, "Invalid access token")
c.Abort()
@@ -157,7 +150,7 @@ func (h *AuthHandler) AuthMiddleware() gin.HandlerFunc {
authViaAPIToken = true
}
- if user.IsSuperuser != nil && *user.IsSuperuser {
+ if identity.User.IsSuperuser != nil && *identity.User.IsSuperuser {
common.ResponseWithHttpCodeData(c, http.StatusForbidden, common.CodeForbidden, nil, "Super user shouldn't access the URL")
c.Abort()
return
@@ -172,10 +165,15 @@ func (h *AuthHandler) AuthMiddleware() gin.HandlerFunc {
return
}
- c.Set("user", user)
- c.Set("user_id", user.ID)
- c.Set("email", user.Email)
+ setAuthIdentity(c, identity)
+ c.Set("email", identity.User.Email)
c.Set("auth_via_api_token", authViaAPIToken)
c.Next()
}
}
+
+func setAuthIdentity(c *gin.Context, identity *service.AuthIdentity) {
+ c.Set("user", identity.User)
+ c.Set("user_id", identity.User.ID)
+ c.Set("tenant_id", identity.TenantID)
+}
diff --git a/internal/handler/bot_test.go b/internal/handler/bot_test.go
index 943de77110..3184f2423d 100644
--- a/internal/handler/bot_test.go
+++ b/internal/handler/bot_test.go
@@ -836,17 +836,17 @@ func TestBotRoutes_RequireAuth(t *testing.T) {
// middleware must accept a regular user token sent without the
// "Bearer " prefix — same behaviour as AuthMiddleware(). We
// inject a stub userTokenResolver that returns CodeSuccess on
-// GetUserByToken, then send a non-Bearer token and assert the
+// ResolveAccessToken, then send a non-Bearer token and assert the
// middleware lets the request through (sets `user` on the
// context, calls c.Next, no abort).
func TestBotMiddleware_NonBearerRegularToken(t *testing.T) {
gin.SetMode(gin.TestMode)
stub := &stubUserTokenResolver{
- getUserByTokenFn: func(ctx context.Context, auth string) (*entity.User, common.ErrorCode, error) {
+ resolveAccessTokenFn: func(ctx context.Context, auth string) (*service.AuthIdentity, common.ErrorCode, error) {
if auth != "raw-access-token-abc" {
- t.Errorf("GetUserByToken called with %q, want raw-access-token-abc", auth)
+ t.Errorf("ResolveAccessToken called with %q, want raw-access-token-abc", auth)
}
- return &entity.User{ID: "u-regular"}, common.CodeSuccess, nil
+ return &service.AuthIdentity{User: &entity.User{ID: "u-regular"}, TenantID: "tenant-1"}, common.CodeSuccess, nil
},
}
r := gin.New()
@@ -854,10 +854,13 @@ func TestBotMiddleware_NonBearerRegularToken(t *testing.T) {
g := r.Group("/api/v1")
g.Use(ah.BetaAuthMiddleware())
var seenUser *entity.User
+ var seenTenantID string
g.GET("/x", func(c *gin.Context) {
if u, ok := c.Get("user"); ok {
seenUser, _ = u.(*entity.User)
}
+ tenantValue, _ := c.Get("tenant_id")
+ seenTenantID, _ = tenantValue.(string)
c.String(http.StatusOK, "ok")
})
req, _ := http.NewRequest(http.MethodGet, "/api/v1/x", nil)
@@ -871,23 +874,20 @@ func TestBotMiddleware_NonBearerRegularToken(t *testing.T) {
if seenUser == nil || seenUser.ID != "u-regular" {
t.Fatalf("middleware did not set user from non-Bearer token; got %+v", seenUser)
}
+ if seenTenantID != "tenant-1" {
+ t.Fatalf("tenant_id = %q, want tenant-1", seenTenantID)
+ }
}
func TestBotMiddleware_BetaTokenBindsAgentID(t *testing.T) {
gin.SetMode(gin.TestMode)
agentID := "agent-bound"
stub := &stubUserTokenResolver{
- getUserByBetaAPITokenFn: func(ctx context.Context, auth string) (*entity.User, common.ErrorCode, error) {
- if auth != "beta-token" {
- t.Errorf("GetUserByBetaAPIToken called with %q, want beta-token", auth)
- }
- return &entity.User{ID: "u-beta"}, common.CodeSuccess, nil
- },
- getAPITokenByBetaFn: func(ctx context.Context, auth string) (*entity.APIToken, error) {
+ resolveBetaAPITokenFn: func(ctx context.Context, auth string) (*service.AuthIdentity, common.ErrorCode, error) {
if auth != "beta-token" {
- t.Errorf("GetAPITokenByBeta called with %q, want beta-token", auth)
+ t.Errorf("ResolveBetaAPIToken called with %q, want beta-token", auth)
}
- return &entity.APIToken{DialogID: &agentID}, nil
+ return &service.AuthIdentity{User: &entity.User{ID: "u-beta"}, TenantID: "tenant-1", APIToken: &entity.APIToken{DialogID: &agentID}}, common.CodeSuccess, nil
},
}
r := gin.New()
@@ -895,9 +895,12 @@ func TestBotMiddleware_BetaTokenBindsAgentID(t *testing.T) {
g := r.Group("/api/v1")
g.Use(ah.BetaAuthMiddleware())
var seenAgentID string
+ var seenTenantID string
g.GET("/x", func(c *gin.Context) {
rawAgentID, _ := c.Get("agent_id")
seenAgentID, _ = rawAgentID.(string)
+ tenantValue, _ := c.Get("tenant_id")
+ seenTenantID, _ = tenantValue.(string)
c.String(http.StatusOK, "ok")
})
req, _ := http.NewRequest(http.MethodGet, "/api/v1/x", nil)
@@ -911,6 +914,9 @@ func TestBotMiddleware_BetaTokenBindsAgentID(t *testing.T) {
if seenAgentID != agentID {
t.Fatalf("agent_id = %q, want %q", seenAgentID, agentID)
}
+ if seenTenantID != "tenant-1" {
+ t.Fatalf("tenant_id = %q, want tenant-1", seenTenantID)
+ }
}
// stubUserTokenResolver implements userTokenResolver for tests.
@@ -918,40 +924,32 @@ func TestBotMiddleware_BetaTokenBindsAgentID(t *testing.T) {
// return safe defaults (CodeUnauthorized so the middleware
// short-circuits to 401).
type stubUserTokenResolver struct {
- getUserByTokenFn func(ctx context.Context, authorization string) (*entity.User, common.ErrorCode, error)
- getUserByAPITokenFn func(ctx context.Context, token string) (*entity.User, common.ErrorCode, error)
- getUserByBetaAPITokenFn func(ctx context.Context, token string) (*entity.User, common.ErrorCode, error)
- getAPITokenByBetaFn func(ctx context.Context, authorization string) (*entity.APIToken, error)
+ resolveAccessTokenFn func(ctx context.Context, authorization string) (*service.AuthIdentity, common.ErrorCode, error)
+ resolveAPITokenFn func(ctx context.Context, token string) (*service.AuthIdentity, common.ErrorCode, error)
+ resolveBetaAPITokenFn func(ctx context.Context, token string) (*service.AuthIdentity, common.ErrorCode, error)
}
-func (s *stubUserTokenResolver) GetUserByToken(ctx context.Context, authorization string) (*entity.User, common.ErrorCode, error) {
- if s.getUserByTokenFn != nil {
- return s.getUserByTokenFn(ctx, authorization)
+func (s *stubUserTokenResolver) ResolveAccessToken(ctx context.Context, authorization string) (*service.AuthIdentity, common.ErrorCode, error) {
+ if s.resolveAccessTokenFn != nil {
+ return s.resolveAccessTokenFn(ctx, authorization)
}
return nil, common.CodeUnauthorized, errors.New("not stubbed")
}
-func (s *stubUserTokenResolver) GetUserByAPIToken(ctx context.Context, token string) (*entity.User, common.ErrorCode, error) {
- if s.getUserByAPITokenFn != nil {
- return s.getUserByAPITokenFn(ctx, token)
+func (s *stubUserTokenResolver) ResolveAPIToken(ctx context.Context, token string) (*service.AuthIdentity, common.ErrorCode, error) {
+ if s.resolveAPITokenFn != nil {
+ return s.resolveAPITokenFn(ctx, token)
}
return nil, common.CodeUnauthorized, errors.New("not stubbed")
}
-func (s *stubUserTokenResolver) GetUserByBetaAPIToken(ctx context.Context, token string) (*entity.User, common.ErrorCode, error) {
- if s.getUserByBetaAPITokenFn != nil {
- return s.getUserByBetaAPITokenFn(ctx, token)
+func (s *stubUserTokenResolver) ResolveBetaAPIToken(ctx context.Context, token string) (*service.AuthIdentity, common.ErrorCode, error) {
+ if s.resolveBetaAPITokenFn != nil {
+ return s.resolveBetaAPITokenFn(ctx, token)
}
return nil, common.CodeUnauthorized, errors.New("not stubbed")
}
-func (s *stubUserTokenResolver) GetAPITokenByBeta(ctx context.Context, authorization string) (*entity.APIToken, error) {
- if s.getAPITokenByBetaFn != nil {
- return s.getAPITokenByBetaFn(ctx, authorization)
- }
- return nil, errors.New("not stubbed")
-}
-
// TestBotRoutes_NoRegularAuthRequired covers criterion 25. The
// /api/v1/chatbots/* and /api/v1/agentbots/* routes are mounted
// on apiNoAuth (NOT on the auth-protected v1 tree). This test
@@ -968,8 +966,8 @@ func (s *stubUserTokenResolver) GetAPITokenByBeta(ctx context.Context, authoriza
func TestBotRoutes_NoRegularAuthRequired(t *testing.T) {
gin.SetMode(gin.TestMode)
stub := &stubUserTokenResolver{
- getUserByTokenFn: func(ctx context.Context, auth string) (*entity.User, common.ErrorCode, error) {
- return &entity.User{ID: "u-regular"}, common.CodeSuccess, nil
+ resolveAccessTokenFn: func(ctx context.Context, auth string) (*service.AuthIdentity, common.ErrorCode, error) {
+ return &service.AuthIdentity{User: &entity.User{ID: "u-regular"}, TenantID: "tenant-1"}, common.CodeSuccess, nil
},
}
ah := &AuthHandler{userService: stub}
@@ -1053,7 +1051,7 @@ func TestBotRoutes_NoRegularAuthRequired(t *testing.T) {
func TestDownloadAttachment_Unauth(t *testing.T) {
gin.SetMode(gin.TestMode)
stub := &stubUserTokenResolver{
- getUserByTokenFn: func(ctx context.Context, auth string) (*entity.User, common.ErrorCode, error) {
+ resolveAccessTokenFn: func(ctx context.Context, auth string) (*service.AuthIdentity, common.ErrorCode, error) {
return nil, common.CodeUnauthorized, errors.New("invalid token")
},
}
@@ -1072,14 +1070,14 @@ func TestDownloadAttachment_Unauth(t *testing.T) {
c.Abort()
return
}
- u, code, err := stub.GetUserByToken(c.Request.Context(), auth)
+ identity, code, err := stub.ResolveAccessToken(c.Request.Context(), auth)
if err != nil || code != common.CodeSuccess {
common.ResponseWithCodeData(c, common.CodeUnauthorized, nil, "Invalid auth credentials")
c.Abort()
return
}
- c.Set("user", u)
+ c.Set("user", identity.User)
c.Next()
})
g.GET("/attachments/:attachment_id/download", h.DownloadAttachment)
diff --git a/internal/handler/mcp_server_test.go b/internal/handler/mcp_server_test.go
index 60d1d9b570..2edbc425f7 100644
--- a/internal/handler/mcp_server_test.go
+++ b/internal/handler/mcp_server_test.go
@@ -11,6 +11,7 @@ import (
"ragflow/internal/common"
"ragflow/internal/entity"
"ragflow/internal/server/config"
+ "ragflow/internal/service"
)
func TestStandaloneMCPIdentityAndRevocation(t *testing.T) {
@@ -19,7 +20,7 @@ func TestStandaloneMCPIdentityAndRevocation(t *testing.T) {
calls := 0
revoked := false
lastKey := ""
- auth := &AuthHandler{userService: &stubUserTokenResolver{getUserByTokenFn: func(ctx context.Context, key string) (*entity.User, common.ErrorCode, error) {
+ auth := &AuthHandler{userService: &stubUserTokenResolver{resolveAccessTokenFn: func(ctx context.Context, key string) (*service.AuthIdentity, common.ErrorCode, error) {
calls++
lastKey = key
if mode == "self-host" && calls == 1 {
@@ -30,7 +31,7 @@ func TestStandaloneMCPIdentityAndRevocation(t *testing.T) {
if revoked {
return nil, common.CodeUnauthorized, errors.New("revoked")
}
- return &entity.User{ID: key}, common.CodeSuccess, nil
+ return &service.AuthIdentity{User: &entity.User{ID: key}}, common.CodeSuccess, nil
}}}
h, err := (&MCPServerHandler{}).NewStandalone(t.Context(), auth, config.MCPConfig{LaunchMode: mode, HostAPIKey: "configured-key", SSE: true, StreamableHTTP: true, JSONResponse: true})
if err != nil {
diff --git a/internal/handler/searchbot.go b/internal/handler/searchbot.go
index a651805a47..8d8ff45eb0 100644
--- a/internal/handler/searchbot.go
+++ b/internal/handler/searchbot.go
@@ -428,16 +428,18 @@ func (h *SearchBotHandler) SearchBotDetail(c *gin.Context) {
}
userSvc := service.NewUserService()
- user, code, err := userSvc.GetUserByBetaAPIToken(ctx, c.GetHeader("Authorization"))
+ identity, code, err := userSvc.ResolveBetaAPIToken(ctx, c.GetHeader("Authorization"))
if err != nil {
common.ResponseWithCodeData(c, code, nil, "Authentication error: API key is invalid!")
return
}
+ setAuthIdentity(c, identity)
+ c.Set("auth_via_beta_token", true)
if h.searchSvc == nil {
jsonInternalError(c, fmt.Errorf("search service not configured"))
return
}
- detail, err := h.searchSvc.GetSearchShareDetail(ctx, user.ID, searchID)
+ detail, err := h.searchSvc.GetSearchShareDetail(ctx, identity.User.ID, searchID)
if err != nil {
if respondPermissionErrorIf(c, err, true) {
return
diff --git a/internal/handler/searchbot_detail_test.go b/internal/handler/searchbot_detail_test.go
index 468cc936b9..a6ec2cd930 100644
--- a/internal/handler/searchbot_detail_test.go
+++ b/internal/handler/searchbot_detail_test.go
@@ -69,6 +69,7 @@ func TestSearchbotDetailSuccess(t *testing.T) {
accessToken := "access-token"
tenantAvatar := "tenant-avatar"
beta := "beta-token"
+ userID := "tenant-1"
searchAvatar := "search-avatar"
if err := dao.DB.Create(&entity.User{
@@ -98,6 +99,7 @@ func TestSearchbotDetailSuccess(t *testing.T) {
if err := dao.DB.Create(&entity.APIToken{
TenantID: "tenant-1",
+ UserID: &userID,
Token: "token-1",
Beta: &beta,
}).Error; err != nil {
@@ -191,6 +193,7 @@ func TestSearchbotDetailRejectsUnauthorizedSearchAccess(t *testing.T) {
status := "1"
beta := "beta-token"
+ userID := "user-2"
accessToken := "access-token"
for _, u := range []entity.User{
@@ -233,6 +236,7 @@ func TestSearchbotDetailRejectsUnauthorizedSearchAccess(t *testing.T) {
if err := dao.DB.Create(&entity.APIToken{
TenantID: "user-2",
+ UserID: &userID,
Token: "token-1",
Beta: &beta,
}).Error; err != nil {
@@ -271,6 +275,7 @@ func TestSearchbotDetailDoesNotExposeInternalErrorText(t *testing.T) {
status := "1"
accessToken := "access-token"
beta := "beta-token"
+ userID := "tenant-1"
if err := dao.DB.Create(&entity.User{
ID: "tenant-1",
@@ -283,8 +288,18 @@ func TestSearchbotDetailDoesNotExposeInternalErrorText(t *testing.T) {
}).Error; err != nil {
t.Fatalf("failed to create user: %v", err)
}
+ if err := dao.DB.Create(&entity.UserTenant{
+ ID: "ut-1",
+ UserID: userID,
+ TenantID: "tenant-1",
+ Role: "owner",
+ Status: &status,
+ }).Error; err != nil {
+ t.Fatalf("failed to create user_tenant: %v", err)
+ }
if err := dao.DB.Create(&entity.APIToken{
TenantID: "tenant-1",
+ UserID: &userID,
Token: "token-1",
Beta: &beta,
}).Error; err != nil {
@@ -300,9 +315,6 @@ func TestSearchbotDetailDoesNotExposeInternalErrorText(t *testing.T) {
}).Error; err != nil {
t.Fatalf("failed to create search: %v", err)
}
- if err := dao.DB.Exec("DROP TABLE user_tenant").Error; err != nil {
- t.Fatalf("failed to drop user_tenant table: %v", err)
- }
if err := dao.DB.Exec("DROP TABLE search").Error; err != nil {
t.Fatalf("failed to drop search table: %v", err)
}
diff --git a/internal/handler/user.go b/internal/handler/user.go
index 0a5d3050af..321940a7fb 100644
--- a/internal/handler/user.go
+++ b/internal/handler/user.go
@@ -54,13 +54,13 @@ const oauthAuthCookie = "ragflow_auth"
// setOAuthAuthCookie writes the signed access token so the SPA can pick it
// up after the redirect. Not HttpOnly so the SPA can copy it into its
-// Authorization header on subsequent fetches. Lifetime mirrors the
-// access-token TTL used by the rest of the app.
+// Authorization header on subsequent fetches. The server checks the token
+// signature and expiry on each request.
func setOAuthAuthCookie(c *gin.Context, token string) {
// the SPA's bootstrap credential after the OAuth redirect. The
// SPA reads it via document.cookie and copies it into the
// Authorization header. Setting HttpOnly would break the login
- // flow. The token is short-lived (7 days) and signed with itsdangerous.
+ // flow. The API validates the token signature and expiry on each request.
// codeql[go/cookie-httponly-not-set] Intentional: this cookie is
http.SetCookie(c.Writer, &http.Cookie{
Name: oauthAuthCookie,
@@ -103,7 +103,7 @@ func (h *UserHandler) Register(c *gin.Context) {
common.ResponseWithCodeData(c, common.CodeServerError, false, err.Error())
return
}
- authToken, err := common.DumpAccessToken(*user.AccessToken, secretKey)
+ authToken, err := issueUserAccessToken(user, secretKey)
if err != nil {
common.ResponseWithCodeData(c, common.CodeServerError, false, "Failed to generate auth token")
return
@@ -167,7 +167,7 @@ func (h *UserHandler) Login(c *gin.Context) {
}
operationLog.UserID = user.ID
- // Sign the access_token using itsdangerous (compatible with Python)
+ // Sign the access token with the active tenant context.
secretKey, err := server.GetSecretKey(ctx, kvrocks.Get())
if err != nil {
errMessage := fmt.Sprintf("Failed to get secret key: %s", err.Error())
@@ -177,7 +177,7 @@ func (h *UserHandler) Login(c *gin.Context) {
operationLog.DurationMS = time.Since(startAt).Milliseconds()
return
}
- authToken, err := common.DumpAccessToken(*user.AccessToken, secretKey)
+ authToken, err := issueUserAccessToken(user, secretKey)
if err != nil {
common.ResponseWithCodeData(c, common.CodeServerError, false, "Failed to generate auth token")
operationLog.ErrorCode = uint16(common.CodeServerError)
@@ -264,7 +264,7 @@ func (h *UserHandler) LoginByEmail(c *gin.Context) {
operationLog.DurationMS = time.Since(startAt).Milliseconds()
return
}
- authToken, err := common.DumpAccessToken(*user.AccessToken, secretKey)
+ authToken, err := issueUserAccessToken(user, secretKey)
if err != nil {
common.ResponseWithCodeData(c, common.CodeServerError, false, "Failed to generate auth token")
operationLog.ErrorCode = uint16(common.CodeServerError)
@@ -357,7 +357,7 @@ func (h *UserHandler) Logout(c *gin.Context) {
}
// Get user by access token
- user, code, err := h.userService.GetUserByToken(ctx, token)
+ identity, code, err := h.userService.ResolveAccessToken(ctx, token)
if err != nil {
common.ResponseWithHttpCodeData(c, http.StatusUnauthorized, code, nil, "Invalid access token")
c.Abort()
@@ -366,6 +366,7 @@ func (h *UserHandler) Logout(c *gin.Context) {
operationLog.DurationMS = time.Since(startAt).Milliseconds()
return
}
+ user := identity.User
operationLog.UserID = user.ID
// Logout user
@@ -717,7 +718,7 @@ func (h *UserHandler) ForgotResetPassword(c *gin.Context) {
common.ResponseWithCodeData(c, common.CodeServerError, false, fmt.Sprintf("Failed to get secret key: %s", err.Error()))
return
}
- authToken, err := common.DumpAccessToken(*user.AccessToken, secretKey)
+ authToken, err := issueUserAccessToken(user, secretKey)
if err != nil {
common.ResponseWithCodeData(c, common.CodeServerError, false, "Failed to generate auth token")
return
diff --git a/internal/handler/user_auth_ee.go b/internal/handler/user_auth_ee.go
index 0657aa7f06..ff12800e6d 100644
--- a/internal/handler/user_auth_ee.go
+++ b/internal/handler/user_auth_ee.go
@@ -17,7 +17,9 @@
package handler
import (
+ "fmt"
"ragflow/internal/common"
+ "ragflow/internal/entity"
"github.com/gin-gonic/gin"
)
@@ -77,3 +79,10 @@ func (h *UserHandler) OAuthChannelCallback(c *gin.Context) {
func (h *UserHandler) GetLoginChannels(c *gin.Context) {
common.SuccessWithData(c, []interface{}{}, "success")
}
+
+func issueUserAccessToken(user *entity.User, secretKey string) (string, error) {
+ if user == nil || user.AccessToken == nil {
+ return "", fmt.Errorf("user access token is missing")
+ }
+ return common.DumpAccessToken(*user.AccessToken, "", secretKey)
+}
diff --git a/internal/router/router.go b/internal/router/router.go
index 23bb9a2f3e..17ef76f8f9 100644
--- a/internal/router/router.go
+++ b/internal/router/router.go
@@ -237,6 +237,7 @@ func (r *Router) Setup(engine *gin.Engine) {
// Protected routes
authorized := engine.Group("")
authorized.Use(r.authHandler.AuthMiddleware())
+ RegisterEEProtectedRouter(authorized, r)
{
// API v1 route group
v1 := authorized.Group("/api/v1")
diff --git a/internal/router/router_ee.go b/internal/router/router_ee.go
index be0c771017..d98ac8e468 100644
--- a/internal/router/router_ee.go
+++ b/internal/router/router_ee.go
@@ -38,3 +38,5 @@ func RegisterEENoAuthRouter(apiNoAuth *gin.RouterGroup, r *Router) {
apiNoAuth.POST("/auth/register/otp", r.userHandler.SendOTP)
apiNoAuth.POST("/auth/register/otp/verify", r.userHandler.VerifyOTP)
}
+
+func RegisterEEProtectedRouter(_ *gin.RouterGroup, _ *Router) {}
diff --git a/internal/service/api_token.go b/internal/service/api_token.go
index 8ba441e55c..691f85e938 100644
--- a/internal/service/api_token.go
+++ b/internal/service/api_token.go
@@ -18,6 +18,7 @@ package service
import (
"context"
+ "fmt"
"ragflow/internal/common"
"ragflow/internal/dao"
"ragflow/internal/entity"
@@ -26,6 +27,7 @@ import (
// APIKeyResponse key response
type APIKeyResponse struct {
+ UserID string `json:"user_id"`
TenantID string `json:"tenant_id"`
Token string `json:"token"`
DialogID *string `json:"dialog_id,omitempty"`
@@ -62,6 +64,7 @@ func (s *SystemService) ListAPIKeys(ctx context.Context, tenantID string) ([]*AP
}
responses[i] = &APIKeyResponse{
+ UserID: apiTokenUserID(key.UserID),
TenantID: key.TenantID,
Token: key.Token,
DialogID: key.DialogID,
@@ -83,7 +86,10 @@ type CreateAPIKeyRequest struct {
}
// CreateAPIKey creates a new API key for a tenant
-func (s *SystemService) CreateAPIKey(ctx context.Context, tenantID string, req *CreateAPIKeyRequest) (*APIKeyResponse, error) {
+func (s *SystemService) CreateAPIKey(ctx context.Context, userID, tenantID string, req *CreateAPIKeyRequest) (*APIKeyResponse, error) {
+ if userID == "" || tenantID == "" {
+ return nil, fmt.Errorf("user and tenant context are required")
+ }
APITokenDAO := dao.NewAPITokenDAO()
// Generate key and beta values
@@ -94,6 +100,7 @@ func (s *SystemService) CreateAPIKey(ctx context.Context, tenantID string, req *
APIKeyData := &entity.APIToken{
TenantID: tenantID,
+ UserID: &userID,
Token: APIToken,
Beta: &betaAPIKey,
}
@@ -103,6 +110,7 @@ func (s *SystemService) CreateAPIKey(ctx context.Context, tenantID string, req *
}
return &APIKeyResponse{
+ UserID: userID,
TenantID: APIKeyData.TenantID,
Token: APIKeyData.Token,
DialogID: APIKeyData.DialogID,
@@ -115,6 +123,13 @@ func (s *SystemService) CreateAPIKey(ctx context.Context, tenantID string, req *
}, nil
}
+func apiTokenUserID(value *string) string {
+ if value == nil {
+ return ""
+ }
+ return *value
+}
+
func (s *SystemService) DeleteAPIKey(ctx context.Context, tenantID, key string) error {
APITokenDAO := dao.NewAPITokenDAO()
_, err := APITokenDAO.DeleteByTenantIDAndToken(ctx, dao.DB, tenantID, key)
diff --git a/internal/service/api_token_test.go b/internal/service/api_token_test.go
new file mode 100644
index 0000000000..e5aea72e97
--- /dev/null
+++ b/internal/service/api_token_test.go
@@ -0,0 +1,49 @@
+//
+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package service
+
+import (
+ "testing"
+
+ "ragflow/internal/dao"
+ "ragflow/internal/entity"
+)
+
+func TestCreateAPIKeyStoresUserAndTenantContext(t *testing.T) {
+ ctx := t.Context()
+ db := setupServiceTestDB(t)
+ if err := db.AutoMigrate(&entity.APIToken{}); err != nil {
+ t.Fatalf("failed to migrate api_token: %v", err)
+ }
+ pushServiceDB(t, db)
+
+ key, err := (&SystemService{}).CreateAPIKey(ctx, "user-1", "tenant-1", &CreateAPIKeyRequest{})
+ if err != nil {
+ t.Fatalf("CreateAPIKey() error = %v", err)
+ }
+ if key.UserID != "user-1" || key.TenantID != "tenant-1" {
+ t.Fatalf("CreateAPIKey() context = (%q, %q), want (user-1, tenant-1)", key.UserID, key.TenantID)
+ }
+
+ stored, err := dao.NewAPITokenDAO().GetByAPIToken(ctx, dao.DB, key.Token)
+ if err != nil {
+ t.Fatalf("GetByAPIToken() error = %v", err)
+ }
+ if stored == nil || stored.UserID == nil || *stored.UserID != "user-1" || stored.TenantID != "tenant-1" {
+ t.Fatalf("stored API token context = %+v, want user-1 in tenant-1", stored)
+ }
+}
diff --git a/internal/service/user.go b/internal/service/user.go
index 54d87eb52b..9ea3fa31f3 100644
--- a/internal/service/user.go
+++ b/internal/service/user.go
@@ -50,6 +50,13 @@ type UserService struct {
userDAO *dao.UserDAO
}
+// AuthIdentity contains the identity resolved from a user token or API key.
+type AuthIdentity struct {
+ User *entity.User
+ TenantID string
+ APIToken *entity.APIToken
+}
+
// NewUserService create user service
func NewUserService() *UserService {
return &UserService{
@@ -486,35 +493,37 @@ func defaultUserLanguage() string {
return "English"
}
-// GetUserByToken gets user by authorization header
-// The token parameter is the authorization header value, which needs to be decrypted
-// using itsdangerous URLSafeTimedSerializer to get the actual access_token
-func (s *UserService) GetUserByToken(ctx context.Context, authorization string) (*entity.User, common.ErrorCode, error) {
+// ResolveAccessToken validates a signed user token and returns its identity
+// and tenant context.
+func (s *UserService) ResolveAccessToken(ctx context.Context, authorization string) (*AuthIdentity, common.ErrorCode, error) {
// Get secret key from config
secretKey, err := server.GetSecretKey(ctx, kvrocks.Get())
if err != nil {
return nil, common.CodeUnauthorized, err
}
- // Extract access token from authorization header
- // Equivalent to: access_token = str(jwt.loads(authorization)) in Python
- accessToken, err := common.ExtractAccessToken(authorization, secretKey)
+ tokenContext, err := common.ExtractAccessTokenContext(authorization, secretKey)
if err != nil {
return nil, common.CodeUnauthorized, fmt.Errorf("invalid authorization token: %w", err)
}
// Validate token format (should be at least 32 chars, UUID format)
- if len(accessToken) < 32 {
+ if len(tokenContext.AccessToken) < 32 {
return nil, common.CodeUnauthorized, fmt.Errorf("invalid access token format")
}
// Get user by access token
- user, err := s.userDAO.GetByAccessToken(ctx, dao.DB, accessToken)
+ user, err := s.userDAO.GetByAccessToken(ctx, dao.DB, tokenContext.AccessToken)
if err != nil {
return nil, common.CodeUnauthorized, err
}
- return user, common.CodeSuccess, nil
+ tenantID, err := resolveUserAuthTenant(ctx, user, tokenContext.TenantID)
+ if err != nil {
+ return nil, common.CodeUnauthorized, err
+ }
+
+ return &AuthIdentity{User: user, TenantID: tenantID}, common.CodeSuccess, nil
}
// UpdateUserAccessToken updates user's access token
@@ -822,125 +831,73 @@ func convertToUserTenantRelation(userTenant *entity.UserTenant) *UserTenantRelat
}
}
-// GetUserByAPIToken gets user by access key from Authorization header
-// This is used for API token authentication
-// The authorization parameter should be in format: "Bearer <token>" or just "<token>"
-func (s *UserService) GetUserByAPIToken(ctx context.Context, authorization string) (*entity.User, common.ErrorCode, error) {
- if authorization == "" {
- return nil, common.CodeUnauthorized, fmt.Errorf("authorization header is empty")
- }
-
- // Split authorization header to get the token
- // Expected format: "Bearer <token>" or "<token>"
- parts := strings.Split(authorization, " ")
- var token string
- if len(parts) == 2 {
- token = parts[1]
- } else if len(parts) == 1 {
- token = parts[0]
- } else {
- return nil, common.CodeUnauthorized, fmt.Errorf("invalid authorization format")
+// ResolveAPIToken validates an API key and resolves its authentication identity.
+func (s *UserService) ResolveAPIToken(ctx context.Context, authorization string) (*AuthIdentity, common.ErrorCode, error) {
+ token, err := parseAuthorizationToken(authorization)
+ if err != nil {
+ return nil, common.CodeUnauthorized, err
}
- // Query API token from database
- apiTokenDAO := dao.NewAPITokenDAO()
- userToken, err := apiTokenDAO.GetByAPIToken(ctx, dao.DB, token)
- if err != nil || userToken == nil {
- return nil, common.CodeUnauthorized, fmt.Errorf("invalid access token")
+ apiToken, err := dao.NewAPITokenDAO().GetByAPIToken(ctx, dao.DB, token)
+ if err != nil || apiToken == nil {
+ return nil, common.CodeUnauthorized, fmt.Errorf("invalid API token")
}
+ return s.resolveAPITokenIdentity(ctx, apiToken)
+}
- // Get user by tenant_id from API token
- user, err := s.userDAO.GetByTenantID(ctx, dao.DB, userToken.TenantID)
+// ResolveBetaAPIToken validates a beta key and resolves its user, tenant, and
+// associated API token metadata.
+func (s *UserService) ResolveBetaAPIToken(ctx context.Context, authorization string) (*AuthIdentity, common.ErrorCode, error) {
+ token, err := parseAuthorizationToken(authorization)
if err != nil {
- return nil, common.CodeUnauthorized, fmt.Errorf("user not found for this access token")
+ return nil, common.CodeUnauthorized, err
}
- // Check if user's access_token is empty
- if user.AccessToken == nil || *user.AccessToken == "" {
- return nil, common.CodeUnauthorized, fmt.Errorf("user has empty access_token in database")
+ apiTokens, err := dao.NewAPITokenDAO().GetByBeta(ctx, dao.DB, token)
+ if err != nil || len(apiTokens) == 0 {
+ return nil, common.CodeUnauthorized, fmt.Errorf("invalid beta API token")
}
-
- return user, common.CodeSuccess, nil
-
+ return s.resolveAPITokenIdentity(ctx, apiTokens[0])
}
-// GetAPITokenByBeta returns the APIToken row whose `beta` column
-// matches the given raw token. Used by the beta-auth middleware
-// to expose DialogID (the real agent_id) to downstream handlers
-// without re-parsing the Authorization header. Mirrors
-// `APIToken.query(beta=token)` from python bot_api.py:agent_bot_logs.
-func (s *UserService) GetAPITokenByBeta(ctx context.Context, authorization string) (*entity.APIToken, error) {
- authorization = strings.TrimSpace(authorization)
- if authorization == "" {
- return nil, fmt.Errorf("authorization header is empty")
+func (s *UserService) resolveAPITokenIdentity(ctx context.Context, apiToken *entity.APIToken) (*AuthIdentity, common.ErrorCode, error) {
+ if apiToken.UserID == nil || *apiToken.UserID == "" {
+ return nil, common.CodeUnauthorized, fmt.Errorf("API token is missing user identity")
}
- parts := strings.Fields(authorization)
- var token string
- if len(parts) == 2 {
- token = parts[1]
- } else if len(parts) == 1 {
- if strings.EqualFold(parts[0], "Bearer") {
- return nil, fmt.Errorf("invalid authorization format")
- }
- token = parts[0]
- } else {
- return nil, fmt.Errorf("invalid authorization format")
+
+ user, err := s.userDAO.GetByIDString(ctx, dao.DB, *apiToken.UserID)
+ if err != nil {
+ return nil, common.CodeUnauthorized, fmt.Errorf("user not found for API token")
}
- if token == "" {
- return nil, fmt.Errorf("invalid authorization format")
+ if user.AccessToken == nil || *user.AccessToken == "" {
+ return nil, common.CodeUnauthorized, fmt.Errorf("user has empty access_token in database")
}
- apiTokenDAO := dao.NewAPITokenDAO()
- tokens, err := apiTokenDAO.GetByBeta(ctx, dao.DB, token)
+ tenantID, err := resolveUserAuthTenant(ctx, user, apiToken.TenantID)
if err != nil {
- return nil, err
- }
- if len(tokens) == 0 {
- return nil, fmt.Errorf("invalid API token")
+ return nil, common.CodeUnauthorized, err
}
- return tokens[0], nil
-}
-// GetUserByBetaAPIToken gets user by beta access key from Authorization
-// header. This mirrors Python's AUTH_BETA flow used by public bot endpoints.
-func (s *UserService) GetUserByBetaAPIToken(ctx context.Context, authorization string) (*entity.User, common.ErrorCode, error) {
- authorization = strings.TrimSpace(authorization)
- if authorization == "" {
- return nil, common.CodeUnauthorized, fmt.Errorf("authorization header is empty")
- }
+ apiTokenMetadata := *apiToken
+ apiTokenMetadata.TenantID = tenantID
+ return &AuthIdentity{User: user, TenantID: tenantID, APIToken: &apiTokenMetadata}, common.CodeSuccess, nil
+}
+func parseAuthorizationToken(authorization string) (string, error) {
parts := strings.Fields(authorization)
- var token string
- if len(parts) == 2 {
- token = parts[1]
- } else if len(parts) == 1 {
+ switch len(parts) {
+ case 1:
if strings.EqualFold(parts[0], "Bearer") {
- return nil, common.CodeUnauthorized, fmt.Errorf("invalid authorization format")
+ return "", fmt.Errorf("invalid authorization format")
}
- token = parts[0]
- } else {
- return nil, common.CodeUnauthorized, fmt.Errorf("invalid authorization format")
- }
- if token == "" {
- return nil, common.CodeUnauthorized, fmt.Errorf("invalid authorization format")
- }
-
- apiTokenDAO := dao.NewAPITokenDAO()
- userTokens, err := apiTokenDAO.GetByBeta(ctx, dao.DB, token)
- if err != nil || len(userTokens) == 0 {
- return nil, common.CodeUnauthorized, fmt.Errorf("invalid beta access token")
- }
- userToken := userTokens[0]
-
- user, err := s.userDAO.GetByTenantID(ctx, dao.DB, userToken.TenantID)
- if err != nil {
- return nil, common.CodeUnauthorized, fmt.Errorf("user not found for this beta access token")
- }
-
- if user.AccessToken == nil || *user.AccessToken == "" {
- return nil, common.CodeUnauthorized, fmt.Errorf("user has empty access_token in database")
+ return parts[0], nil
+ case 2:
+ if !strings.EqualFold(parts[0], "Bearer") || parts[1] == "" {
+ return "", fmt.Errorf("invalid authorization format")
+ }
+ return parts[1], nil
+ default:
+ return "", fmt.Errorf("invalid authorization format")
}
-
- return user, common.CodeSuccess, nil
}
// ---- Forgot-password flow (mirrors api/apps/restful_apis/user_api.py
diff --git a/internal/service/user_auth_ee.go b/internal/service/user_auth_ee.go
new file mode 100644
index 0000000000..ecc7c1c211
--- /dev/null
+++ b/internal/service/user_auth_ee.go
@@ -0,0 +1,27 @@
+//
+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package service
+
+import (
+ "context"
+
+ "ragflow/internal/entity"
+)
+
+func resolveUserAuthTenant(_ context.Context, _ *entity.User, _ string) (string, error) {
+ return "", nil
+}
diff --git a/internal/service/user_beta_test.go b/internal/service/user_beta_test.go
index adc6dd2cf9..80013930e8 100644
--- a/internal/service/user_beta_test.go
+++ b/internal/service/user_beta_test.go
@@ -33,14 +33,14 @@ func setupUserBetaServiceDB(t *testing.T) {
pushServiceDB(t, db)
}
-func TestUserServiceGetUserByBetaAPIToken(t *testing.T) {
+func TestUserServiceResolveBetaAPIToken(t *testing.T) {
ctx := t.Context()
setupUserBetaServiceDB(t)
accessToken := "access-token"
status := "1"
if err := dao.DB.Create(&entity.User{
- ID: "tenant-1",
+ ID: "user-1",
Nickname: "Tenant",
AccessToken: &accessToken,
@@ -51,36 +51,59 @@ func TestUserServiceGetUserByBetaAPIToken(t *testing.T) {
}).Error; err != nil {
t.Fatalf("failed to create user: %v", err)
}
+ if err := dao.DB.Create(&entity.UserTenant{
+ ID: "membership-1",
+ UserID: "user-1",
+ TenantID: "tenant-1",
+ Role: "normal",
+ Status: &status,
+ }).Error; err != nil {
+ t.Fatalf("failed to create membership: %v", err)
+ }
beta := "beta-token"
+ userID := "user-1"
if err := dao.DB.Create(&entity.APIToken{
TenantID: "tenant-1",
+ UserID: &userID,
Token: "token-1",
Beta: &beta,
}).Error; err != nil {
t.Fatalf("failed to create api token: %v", err)
}
+ expectedTenantID, err := resolveUserAuthTenant(ctx, &entity.User{ID: "user-1"}, "tenant-1")
+ if err != nil {
+ t.Fatalf("resolveUserAuthTenant() failed: %v", err)
+ }
svc := NewUserService()
for _, auth := range []string{"Bearer " + beta, beta, "Bearer " + beta} {
- user, code, err := svc.GetUserByBetaAPIToken(ctx, auth)
+ identity, code, err := svc.ResolveBetaAPIToken(ctx, auth)
if err != nil {
- t.Fatalf("GetUserByBetaAPIToken(%q) failed: %v", auth, err)
+ t.Fatalf("ResolveBetaAPIToken(%q) failed: %v", auth, err)
}
if code != common.CodeSuccess {
t.Fatalf("code = %v, want %v", code, common.CodeSuccess)
}
- if user == nil || user.ID != "tenant-1" {
- t.Fatalf("user = %+v, want tenant-1", user)
+ if identity == nil || identity.User == nil || identity.User.ID != "user-1" || identity.TenantID != expectedTenantID || identity.APIToken == nil || identity.APIToken.TenantID != expectedTenantID {
+ t.Fatalf("identity = %+v, want user-1 with tenant context %q", identity, expectedTenantID)
}
}
+
+ identity, code, err := svc.ResolveAPIToken(ctx, "Bearer token-1")
+ if err != nil {
+ t.Fatalf("ResolveAPIToken() failed: %v", err)
+ }
+ if code != common.CodeSuccess || identity.User.ID != "user-1" || identity.TenantID != expectedTenantID || identity.APIToken == nil || identity.APIToken.TenantID != expectedTenantID {
+ t.Fatalf("ResolveAPIToken() = %+v, %v; want user-1 with tenant context %q", identity, code, expectedTenantID)
+ }
}
-func TestUserServiceGetUserByBetaAPITokenRejectsInvalidToken(t *testing.T) {
+func TestUserServiceResolveBetaAPITokenRejectsInvalidToken(t *testing.T) {
ctx := t.Context()
setupUserBetaServiceDB(t)
- _, code, err := NewUserService().GetUserByBetaAPIToken(ctx, "Bearer missing")
+ _, code, err := NewUserService().ResolveBetaAPIToken(ctx, "Bearer missing")
if err == nil {
t.Fatal("expected error for invalid beta token")
}
@@ -89,12 +112,12 @@ func TestUserServiceGetUserByBetaAPITokenRejectsInvalidToken(t *testing.T) {
}
}
-func TestUserServiceGetUserByBetaAPITokenRejectsEmptyOrWhitespaceToken(t *testing.T) {
+func TestUserServiceResolveBetaAPITokenRejectsEmptyOrWhitespaceToken(t *testing.T) {
ctx := t.Context()
setupUserBetaServiceDB(t)
for _, auth := range []string{"Bearer ", " ", "\t"} {
- _, code, err := NewUserService().GetUserByBetaAPIToken(ctx, auth)
+ _, code, err := NewUserService().ResolveBetaAPIToken(ctx, auth)
if err == nil {
t.Fatalf("expected error for auth %q", auth)
}
@@ -104,14 +127,14 @@ func TestUserServiceGetUserByBetaAPITokenRejectsEmptyOrWhitespaceToken(t *testin
}
}
-func TestUserServiceGetUserByBetaAPITokenRejectsUserWithEmptyAccessToken(t *testing.T) {
+func TestUserServiceResolveBetaAPITokenRejectsUserWithEmptyAccessToken(t *testing.T) {
ctx := t.Context()
setupUserBetaServiceDB(t)
status := "1"
emptyToken := ""
if err := dao.DB.Create(&entity.User{
- ID: "tenant-1",
+ ID: "user-1",
Nickname: "Tenant",
AccessToken: &emptyToken,
@@ -122,17 +145,28 @@ func TestUserServiceGetUserByBetaAPITokenRejectsUserWithEmptyAccessToken(t *test
}).Error; err != nil {
t.Fatalf("failed to create user: %v", err)
}
+ if err := dao.DB.Create(&entity.UserTenant{
+ ID: "membership-1",
+ UserID: "user-1",
+ TenantID: "tenant-1",
+ Role: "normal",
+ Status: &status,
+ }).Error; err != nil {
+ t.Fatalf("failed to create membership: %v", err)
+ }
beta := "beta-token"
+ userID := "user-1"
if err := dao.DB.Create(&entity.APIToken{
TenantID: "tenant-1",
+ UserID: &userID,
Token: "token-1",
Beta: &beta,
}).Error; err != nil {
t.Fatalf("failed to create api token: %v", err)
}
- _, code, err := NewUserService().GetUserByBetaAPIToken(ctx, "Bearer "+beta)
+ _, code, err := NewUserService().ResolveBetaAPIToken(ctx, "Bearer "+beta)
if err == nil {
t.Fatal("expected error for empty access token")
}