Skip to content

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

refactor(go-syncer): route GetConnector access errors through helper (#19146)

mkaaada36865c09bf1
diff --git a/internal/handler/connector.go b/internal/handler/connector.go
index ad52ce18f4..e86f650680 100644
--- a/internal/handler/connector.go
+++ b/internal/handler/connector.go
@@ -36,7 +36,7 @@ import (
type connectorServiceIface interface {
ListConnectors(ctx context.Context, userID string) (*service.ListConnectorsResponse, error)
CreateConnector(ctx context.Context, userID string, req *service.CreateConnectorRequest) (*entity.Connector, error)
- GetConnector(ctx context.Context, connectorID, userID string) (*entity.Connector, common.ErrorCode, error)
+ GetConnector(ctx context.Context, connectorID, userID string) (*entity.Connector, error)
ListLog(ctx context.Context, connectorID, userID string, page, pageSize int) ([]*entity.ConnectorSyncLog, int64, common.ErrorCode, error)
ListLogs(ctx context.Context, userID, datasetID string, page, pageSize int) ([]*entity.ConnectorSyncLog, int64, common.ErrorCode, error)
DeleteConnector(ctx context.Context, connectorID, userID string) (bool, common.ErrorCode, error)
@@ -100,6 +100,8 @@ func connectorErrorResponse(c *gin.Context, err error) bool {
switch {
case err == nil:
return false
+ case errors.Is(err, service.ErrConnectorIDRequired):
+ common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
case errors.Is(err, service.ErrConnectorNoAuth):
common.ResponseWithCodeData(c, common.CodeAuthenticationError, false, "no authorization")
case errors.Is(err, service.ErrConnectorNotFound):
@@ -130,9 +132,8 @@ func (h *ConnectorHandler) GetConnector(c *gin.Context) {
}
ctx := c.Request.Context()
- connector, code, err := h.connectorService.GetConnector(ctx, c.Param("connector_id"), user.ID)
- if err != nil {
- common.ErrorWithCode(c, code, err.Error())
+ connector, err := h.connectorService.GetConnector(ctx, c.Param("connector_id"), user.ID)
+ if connectorErrorResponse(c, err) {
return
}
diff --git a/internal/handler/connector_test.go b/internal/handler/connector_test.go
index cc65a93780..b87de823d0 100644
--- a/internal/handler/connector_test.go
+++ b/internal/handler/connector_test.go
@@ -48,11 +48,11 @@ func (s fakeConnectorService) CreateConnector(context.Context, string, *service.
return s.connector, nil
}
-func (s fakeConnectorService) GetConnector(context.Context, string, string) (*entity.Connector, common.ErrorCode, error) {
+func (s fakeConnectorService) GetConnector(context.Context, string, string) (*entity.Connector, error) {
if s.err != nil {
- return nil, s.code, s.err
+ return nil, s.err
}
- return s.connector, common.CodeSuccess, nil
+ return s.connector, nil
}
func (s fakeConnectorService) UpdateConnector(context.Context, string, string, *service.UpdateConnectorRequest) (*entity.Connector, common.ErrorCode, error) {
@@ -144,6 +144,91 @@ func (s fakeConnectorService) ResumeFailedSync(context.Context, string, string,
return true, common.CodeSuccess, nil
}
+func TestConnectorHandlerGetConnector(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+
+ tests := []struct {
+ name string
+ connectorID string
+ service fakeConnectorService
+ wantCode common.ErrorCode
+ wantData interface{}
+ wantMsg string
+ }{
+ {
+ name: "success",
+ connectorID: "connector-1",
+ service: fakeConnectorService{
+ connector: &entity.Connector{ID: "connector-1", TenantID: "tenant-1", Name: "REST source"},
+ },
+ wantCode: common.CodeSuccess,
+ wantData: map[string]interface{}{
+ "id": "connector-1",
+ },
+ wantMsg: "success",
+ },
+ {
+ name: "unauthorized",
+ connectorID: "connector-1",
+ service: fakeConnectorService{err: service.ErrConnectorNoAuth},
+ wantCode: common.CodeAuthenticationError,
+ wantData: false,
+ wantMsg: "no authorization",
+ },
+ {
+ name: "not found",
+ connectorID: "connector-missing",
+ service: fakeConnectorService{err: service.ErrConnectorNotFound},
+ wantCode: common.CodeDataError,
+ wantData: nil,
+ wantMsg: "Can't find this Connector!",
+ },
+ {
+ name: "missing id",
+ connectorID: "",
+ service: fakeConnectorService{err: service.ErrConnectorIDRequired},
+ wantCode: common.CodeDataError,
+ wantData: nil,
+ wantMsg: "connector_id is required",
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ h := &ConnectorHandler{connectorService: tt.service}
+ resp := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(resp)
+ c.Request = httptest.NewRequest(http.MethodGet, "/api/v1/connectors/"+tt.connectorID, nil)
+ c.Params = gin.Params{{Key: "connector_id", Value: tt.connectorID}}
+ c.Set("user", &entity.User{ID: "user-1"})
+
+ h.GetConnector(c)
+
+ var body map[string]interface{}
+ if err := json.Unmarshal(resp.Body.Bytes(), &body); err != nil {
+ t.Fatalf("unmarshal response: %v", err)
+ }
+ if body["code"] != float64(tt.wantCode) {
+ t.Fatalf("code=%v want=%v body=%v", body["code"], tt.wantCode, body)
+ }
+ if tt.wantMsg != "" && body["message"] != tt.wantMsg {
+ t.Fatalf("message=%v want=%v body=%v", body["message"], tt.wantMsg, body)
+ }
+ if wantData, ok := tt.wantData.(map[string]interface{}); ok {
+ data, ok := body["data"].(map[string]interface{})
+ if !ok {
+ t.Fatalf("data=%v body=%v", body["data"], body)
+ }
+ if data["id"] != wantData["id"] {
+ t.Fatalf("data id=%v want=%v body=%v", data["id"], wantData, body)
+ }
+ } else if body["data"] != tt.wantData {
+ t.Fatalf("data=%v want=%v body=%v", body["data"], tt.wantData, body)
+ }
+ })
+ }
+}
+
func TestConnectorHandlerStartBoxWebOAuth(t *testing.T) {
gin.SetMode(gin.TestMode)
diff --git a/internal/service/connector.go b/internal/service/connector.go
index b320ec7de4..ee330cb1d2 100644
--- a/internal/service/connector.go
+++ b/internal/service/connector.go
@@ -78,10 +78,14 @@ var (
ErrConnectorNotFound = errors.New("can't find this Connector")
// ErrConnectorNoAuth mirrors Python's "no authorization" denial.
ErrConnectorNoAuth = errors.New("no authorization")
+ // ErrConnectorIDRequired is returned when a connector ID is missing.
+ ErrConnectorIDRequired = errors.New("connector_id is required")
// ErrConnectorTestUnsupported is returned for connector sources without a settings validator.
ErrConnectorTestUnsupported = errors.New("connector test is not supported for this source")
// ErrConnectorSourceNotImplemented is returned for connector sources not registered in the Go syncer.
ErrConnectorSourceNotImplemented = errors.New("connector source is not implemented")
+ // ErrConnectorInternal is a generic, safe-to-expose internal failure.
+ ErrConnectorInternal = errors.New("Internal server error")
)
// ConnectorService connector service
@@ -325,34 +329,28 @@ func (s *ConnectorService) CreateConnector(ctx context.Context, userID string, r
}
// GetConnector returns one connector when the user can access its tenant.
-func (s *ConnectorService) GetConnector(ctx context.Context, connectorID, userID string) (*entity.Connector, common.ErrorCode, error) {
- if connectorID == "" {
- return nil, common.CodeDataError, fmt.Errorf("connector_id is required")
+func (s *ConnectorService) GetConnector(ctx context.Context, connectorID, userID string) (*entity.Connector, error) {
+ if strings.TrimSpace(connectorID) == "" {
+ return nil, ErrConnectorIDRequired
}
connector, err := s.connectorDAO.GetByID(ctx, dao.DB, connectorID)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, common.CodeDataError, fmt.Errorf("can't find this Connector")
+ return nil, ErrConnectorNotFound
}
- return nil, common.CodeServerError, err
- }
-
- if connector.TenantID == userID {
- return connector, common.CodeSuccess, nil
+ common.Error("get connector failed", err, zap.String("connector_id", connectorID))
+ return nil, ErrConnectorInternal
}
- tenantIDs, err := s.userTenantDAO.GetTenantIDsByUserID(ctx, dao.DB, userID)
+ canAccess, err := s.canAccessConnector(ctx, connector, userID)
if err != nil {
- return nil, common.CodeServerError, err
+ return nil, err
}
- for _, tenantID := range tenantIDs {
- if tenantID == connector.TenantID {
- return connector, common.CodeSuccess, nil
- }
+ if !canAccess {
+ return nil, ErrConnectorNoAuth
}
-
- return nil, common.CodeAuthenticationError, fmt.Errorf("no authorization")
+ return connector, nil
}
// ListConnectors list connectors for a user
@@ -375,25 +373,14 @@ func (s *ConnectorService) ListConnectors(ctx context.Context, userID string) (*
// accessible reports whether the user can access the connector's tenant.
func (s *ConnectorService) accessible(ctx context.Context, connectorID, userID string) (bool, error) {
- conn, err := s.connectorDAO.GetByID(ctx, dao.DB, connectorID)
- if err != nil {
- return false, ErrConnectorNotFound
- }
-
- if conn.TenantID == userID {
- return true, nil
- }
-
- tenantIDs, err := s.userTenantDAO.GetTenantIDsByUserID(ctx, dao.DB, userID)
+ connector, err := s.connectorDAO.GetByID(ctx, dao.DB, connectorID)
if err != nil {
- return false, err
- }
- for _, tid := range tenantIDs {
- if tid == conn.TenantID {
- return true, nil
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return false, ErrConnectorNotFound
}
+ return false, err
}
- return false, nil
+ return s.canAccessConnector(ctx, connector, userID)
}
// TestConnector validates connector settings without persisting or syncing.