Chore: Remove Result field from datasources (#63048)

* Remove Result field from AddDataSourceCommand
* Remove DatasourcesPermissionFilterQuery Result
* Remove GetDataSourceQuery Result
* Remove GetDataSourcesByTypeQuery Result
* Remove GetDataSourcesQuery Result
* Remove GetDefaultDataSourceQuery Result
* Remove UpdateDataSourceCommand Result

pkg/api/datasources.go

@@ -45,11 +45,12 @@ var secretsPluginError datasources.ErrDatasourceSecretsPluginUserFriendly
 func (hs *HTTPServer) GetDataSources(c *contextmodel.ReqContext) response.Response {
 	query := datasources.GetDataSourcesQuery{OrgID: c.OrgID, DataSourceLimit: hs.Cfg.DataSourceLimit}
 
-	if err := hs.DataSourcesService.GetDataSources(c.Req.Context(), &query); err != nil {
+	dataSources, err := hs.DataSourcesService.GetDataSources(c.Req.Context(), &query)
+	if err != nil {
 		return response.Error(500, "Failed to query datasources", err)
 	}
 
-	filtered, err := hs.filterDatasourcesByQueryPermission(c.Req.Context(), c.SignedInUser, query.Result)
+	filtered, err := hs.filterDatasourcesByQueryPermission(c.Req.Context(), c.SignedInUser, dataSources)
 	if err != nil {
 		return response.Error(500, "Failed to query datasources", err)
 	}
@@ -116,7 +117,8 @@ func (hs *HTTPServer) GetDataSourceById(c *contextmodel.ReqContext) response.Res
 		OrgID: c.OrgID,
 	}
 
-	if err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query); err != nil {
+	dataSource, err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query)
+	if err != nil {
 		if errors.Is(err, datasources.ErrDataSourceNotFound) {
 			return response.Error(404, "Data source not found", nil)
 		}
@@ -126,7 +128,7 @@ func (hs *HTTPServer) GetDataSourceById(c *contextmodel.ReqContext) response.Res
 		return response.Error(500, "Failed to query datasources", err)
 	}
 
-	dto := hs.convertModelToDtos(c.Req.Context(), query.Result)
+	dto := hs.convertModelToDtos(c.Req.Context(), dataSource)
 
 	// Add accesscontrol metadata
 	dto.AccessControl = hs.getAccessControlMetadata(c, c.OrgID, datasources.ScopePrefix, dto.UID)
@@ -291,19 +293,20 @@ func (hs *HTTPServer) DeleteDataSourceByName(c *contextmodel.ReqContext) respons
 	}
 
 	getCmd := &datasources.GetDataSourceQuery{Name: name, OrgID: c.OrgID}
-	if err := hs.DataSourcesService.GetDataSource(c.Req.Context(), getCmd); err != nil {
+	dataSource, err := hs.DataSourcesService.GetDataSource(c.Req.Context(), getCmd)
+	if err != nil {
 		if errors.Is(err, datasources.ErrDataSourceNotFound) {
 			return response.Error(404, "Data source not found", nil)
 		}
 		return response.Error(500, "Failed to delete datasource", err)
 	}
 
-	if getCmd.Result.ReadOnly {
+	if dataSource.ReadOnly {
 		return response.Error(403, "Cannot delete read-only data source", nil)
 	}
 
 	cmd := &datasources.DeleteDataSourceCommand{Name: name, OrgID: c.OrgID}
-	err := hs.DataSourcesService.DeleteDataSource(c.Req.Context(), cmd)
+	err = hs.DataSourcesService.DeleteDataSource(c.Req.Context(), cmd)
 	if err != nil {
 		if errors.As(err, &secretsPluginError) {
 			return response.Error(500, "Failed to delete datasource: "+err.Error(), err)
@@ -311,11 +314,11 @@ func (hs *HTTPServer) DeleteDataSourceByName(c *contextmodel.ReqContext) respons
 		return response.Error(500, "Failed to delete datasource", err)
 	}
 
-	hs.Live.HandleDatasourceDelete(c.OrgID, getCmd.Result.UID)
+	hs.Live.HandleDatasourceDelete(c.OrgID, dataSource.UID)
 
 	return response.JSON(http.StatusOK, util.DynMap{
 		"message": "Data source deleted",
-		"id":      getCmd.Result.ID,
+		"id":      dataSource.ID,
 	})
 }
 
@@ -383,7 +386,8 @@ func (hs *HTTPServer) AddDataSource(c *contextmodel.ReqContext) response.Respons
 		return response.Error(http.StatusBadRequest, "Failed to add datasource", err)
 	}
 
-	if err := hs.DataSourcesService.AddDataSource(c.Req.Context(), &cmd); err != nil {
+	dataSource, err := hs.DataSourcesService.AddDataSource(c.Req.Context(), &cmd)
+	if err != nil {
 		if errors.Is(err, datasources.ErrDataSourceNameExists) || errors.Is(err, datasources.ErrDataSourceUidExists) {
 			return response.Error(409, err.Error(), err)
 		}
@@ -401,11 +405,11 @@ func (hs *HTTPServer) AddDataSource(c *contextmodel.ReqContext) response.Respons
 		hs.accesscontrolService.ClearUserPermissionCache(c.SignedInUser)
 	}
 
-	ds := hs.convertModelToDtos(c.Req.Context(), cmd.Result)
+	ds := hs.convertModelToDtos(c.Req.Context(), dataSource)
 	return response.JSON(http.StatusOK, util.DynMap{
 		"message":    "Datasource added",
-		"id":         cmd.Result.ID,
-		"name":       cmd.Result.Name,
+		"id":         dataSource.ID,
+		"name":       dataSource.Name,
 		"datasource": ds,
 	})
 }
@@ -505,7 +509,7 @@ func (hs *HTTPServer) updateDataSourceByID(c *contextmodel.ReqContext, ds *datas
 		return response.Error(403, "Cannot update read-only data source", nil)
 	}
 
-	err := hs.DataSourcesService.UpdateDataSource(c.Req.Context(), &cmd)
+	_, err := hs.DataSourcesService.UpdateDataSource(c.Req.Context(), &cmd)
 	if err != nil {
 		if errors.Is(err, datasources.ErrDataSourceUpdatingOldVersion) {
 			return response.Error(409, "Datasource has already been updated by someone else. Please reload and try again", err)
@@ -522,14 +526,15 @@ func (hs *HTTPServer) updateDataSourceByID(c *contextmodel.ReqContext, ds *datas
 		OrgID: c.OrgID,
 	}
 
-	if err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query); err != nil {
+	dataSource, err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query)
+	if err != nil {
 		if errors.Is(err, datasources.ErrDataSourceNotFound) {
 			return response.Error(404, "Data source not found", nil)
 		}
 		return response.Error(500, "Failed to query datasource", err)
 	}
 
-	datasourceDTO := hs.convertModelToDtos(c.Req.Context(), query.Result)
+	datasourceDTO := hs.convertModelToDtos(c.Req.Context(), dataSource)
 
 	hs.Live.HandleDatasourceUpdate(c.OrgID, datasourceDTO.UID)
 
@@ -547,11 +552,12 @@ func (hs *HTTPServer) getRawDataSourceById(ctx context.Context, id int64, orgID
 		OrgID: orgID,
 	}
 
-	if err := hs.DataSourcesService.GetDataSource(ctx, &query); err != nil {
+	dataSource, err := hs.DataSourcesService.GetDataSource(ctx, &query)
+	if err != nil {
 		return nil, err
 	}
 
-	return query.Result, nil
+	return dataSource, nil
 }
 
 func (hs *HTTPServer) getRawDataSourceByUID(ctx context.Context, uid string, orgID int64) (*datasources.DataSource, error) {
@@ -560,11 +566,12 @@ func (hs *HTTPServer) getRawDataSourceByUID(ctx context.Context, uid string, org
 		OrgID: orgID,
 	}
 
-	if err := hs.DataSourcesService.GetDataSource(ctx, &query); err != nil {
+	dataSource, err := hs.DataSourcesService.GetDataSource(ctx, &query)
+	if err != nil {
 		return nil, err
 	}
 
-	return query.Result, nil
+	return dataSource, nil
 }
 
 // swagger:route GET /datasources/name/{name} datasources getDataSourceByName
@@ -582,14 +589,15 @@ func (hs *HTTPServer) getRawDataSourceByUID(ctx context.Context, uid string, org
 func (hs *HTTPServer) GetDataSourceByName(c *contextmodel.ReqContext) response.Response {
 	query := datasources.GetDataSourceQuery{Name: web.Params(c.Req)[":name"], OrgID: c.OrgID}
 
-	if err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query); err != nil {
+	dataSource, err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query)
+	if err != nil {
 		if errors.Is(err, datasources.ErrDataSourceNotFound) {
 			return response.Error(404, "Data source not found", nil)
 		}
 		return response.Error(500, "Failed to query datasources", err)
 	}
 
-	dto := hs.convertModelToDtos(c.Req.Context(), query.Result)
+	dto := hs.convertModelToDtos(c.Req.Context(), dataSource)
 	return response.JSON(http.StatusOK, &dto)
 }
 
@@ -609,14 +617,14 @@ func (hs *HTTPServer) GetDataSourceByName(c *contextmodel.ReqContext) response.R
 func (hs *HTTPServer) GetDataSourceIdByName(c *contextmodel.ReqContext) response.Response {
 	query := datasources.GetDataSourceQuery{Name: web.Params(c.Req)[":name"], OrgID: c.OrgID}
 
-	if err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query); err != nil {
+	ds, err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query)
+	if err != nil {
 		if errors.Is(err, datasources.ErrDataSourceNotFound) {
 			return response.Error(404, "Data source not found", nil)
 		}
 		return response.Error(500, "Failed to query datasources", err)
 	}
 
-	ds := query.Result
 	dtos := dtos.AnyId{
 		Id: ds.ID,
 	}
@@ -861,16 +869,16 @@ func (hs *HTTPServer) filterDatasourcesByQueryPermission(ctx context.Context, us
 		User:        user,
 		Datasources: ds,
 	}
-	query.Result = ds
 
-	if err := hs.DatasourcePermissionsService.FilterDatasourcesBasedOnQueryPermissions(ctx, &query); err != nil {
+	dataSources, err := hs.DatasourcePermissionsService.FilterDatasourcesBasedOnQueryPermissions(ctx, &query)
+	if err != nil {
 		if !errors.Is(err, permissions.ErrNotImplemented) {
 			return nil, err
 		}
 		return ds, nil
 	}
 
-	return query.Result, nil
+	return dataSources, nil
 }
 
 // swagger:parameters checkDatasourceHealthByID

pkg/api/datasources_test.go

@@ -361,36 +361,32 @@ type dataSourcesServiceMock struct {
 	expectedError       error
 }
 
-func (m *dataSourcesServiceMock) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error {
-	query.Result = m.expectedDatasource
-	return m.expectedError
+func (m *dataSourcesServiceMock) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error) {
+	return m.expectedDatasource, m.expectedError
 }
 
-func (m *dataSourcesServiceMock) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) error {
-	query.Result = m.expectedDatasources
-	return m.expectedError
+func (m *dataSourcesServiceMock) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) ([]*datasources.DataSource, error) {
+	return m.expectedDatasources, m.expectedError
 }
 
-func (m *dataSourcesServiceMock) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) error {
-	return m.expectedError
+func (m *dataSourcesServiceMock) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) ([]*datasources.DataSource, error) {
+	return m.expectedDatasources, m.expectedError
 }
 
-func (m *dataSourcesServiceMock) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) error {
-	return m.expectedError
+func (m *dataSourcesServiceMock) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) (*datasources.DataSource, error) {
+	return nil, m.expectedError
 }
 
 func (m *dataSourcesServiceMock) DeleteDataSource(ctx context.Context, cmd *datasources.DeleteDataSourceCommand) error {
 	return m.expectedError
 }
 
-func (m *dataSourcesServiceMock) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) error {
-	cmd.Result = m.expectedDatasource
-	return m.expectedError
+func (m *dataSourcesServiceMock) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) (*datasources.DataSource, error) {
+	return m.expectedDatasource, m.expectedError
 }
 
-func (m *dataSourcesServiceMock) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) error {
-	cmd.Result = m.expectedDatasource
-	return m.expectedError
+func (m *dataSourcesServiceMock) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) (*datasources.DataSource, error) {
+	return m.expectedDatasource, m.expectedError
 }
 
 func (m *dataSourcesServiceMock) DecryptedValues(ctx context.Context, ds *datasources.DataSource) (map[string]string, error) {

pkg/api/frontendsettings.go

@@ -262,16 +262,16 @@ func (hs *HTTPServer) getFSDataSources(c *contextmodel.ReqContext, availablePlug
 	orgDataSources := make([]*datasources.DataSource, 0)
 	if c.OrgID != 0 {
 		query := datasources.GetDataSourcesQuery{OrgID: c.OrgID, DataSourceLimit: hs.Cfg.DataSourceLimit}
-		err := hs.DataSourcesService.GetDataSources(c.Req.Context(), &query)
+		dataSources, err := hs.DataSourcesService.GetDataSources(c.Req.Context(), &query)
 		if err != nil {
 			return nil, err
 		}
 
 		if c.IsPublicDashboardView {
 			// If RBAC is enabled, it will filter out all datasources for a public user, so we need to skip it
-			orgDataSources = query.Result
+			orgDataSources = dataSources
 		} else {
-			filtered, err := hs.filterDatasourcesByQueryPermission(c.Req.Context(), c.SignedInUser, query.Result)
+			filtered, err := hs.filterDatasourcesByQueryPermission(c.Req.Context(), c.SignedInUser, dataSources)
 			if err != nil {
 				return nil, err
 			}

pkg/infra/usagestats/statscollector/prometheus_flavor.go

@@ -38,14 +38,14 @@ func (s *Service) detectPrometheusVariants(ctx context.Context) (map[string]int6
 	}
 
 	dsProm := &datasources.GetDataSourcesByTypeQuery{Type: "prometheus"}
-	err := s.datasources.GetDataSourcesByType(ctx, dsProm)
+	dataSources, err := s.datasources.GetDataSourcesByType(ctx, dsProm)
 	if err != nil {
 		s.log.Error("Failed to read all Prometheus data sources", "error", err)
 		return nil, err
 	}
 
 	variants := map[string]int64{}
-	for _, ds := range dsProm.Result {
+	for _, ds := range dataSources {
 		variant, err := s.detectPrometheusVariant(ctx, ds)
 		if err != nil {
 			return nil, err

pkg/infra/usagestats/statscollector/service.go

@@ -239,11 +239,12 @@ func (s *Service) collectDatasourceStats(ctx context.Context) (map[string]interf
 func (s *Service) collectElasticStats(ctx context.Context) (map[string]interface{}, error) {
 	m := map[string]interface{}{}
 	esDataSourcesQuery := datasources.GetDataSourcesByTypeQuery{Type: datasources.DS_ES}
-	if err := s.datasources.GetDataSourcesByType(ctx, &esDataSourcesQuery); err != nil {
+	dataSources, err := s.datasources.GetDataSourcesByType(ctx, &esDataSourcesQuery)
+	if err != nil {
 		s.log.Error("Failed to get elasticsearch json data", "error", err)
 		return nil, err
 	}
-	for _, data := range esDataSourcesQuery.Result {
+	for _, data := range dataSources {
 		esVersion, err := data.JsonData.Get("esVersion").String()
 		if err != nil {
 			continue

pkg/infra/usagestats/statscollector/service_test.go

@@ -460,9 +460,8 @@ type mockDatasourceService struct {
 	datasources []*datasources.DataSource
 }
 
-func (s mockDatasourceService) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) error {
-	query.Result = s.datasources
-	return nil
+func (s mockDatasourceService) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) ([]*datasources.DataSource, error) {
+	return s.datasources, nil
 }
 
 func (s mockDatasourceService) GetHTTPTransport(ctx context.Context, ds *datasources.DataSource, provider httpclient.Provider, customMiddlewares ...sdkhttpclient.Middleware) (http.RoundTripper, error) {

pkg/services/accesscontrol/filter_bench_test.go

@@ -56,7 +56,7 @@ func setupFilterBenchmark(b *testing.B, numDs, numPermissions int) (db.DB, []acc
 	sqlStore := db.InitTestDB(b)
 	store := dsService.CreateStore(sqlStore, log.New("accesscontrol.test"))
 	for i := 1; i <= numDs; i++ {
-		err := store.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
+		_, err := store.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
 			Name:  fmt.Sprintf("ds:%d", i),
 			OrgID: 1,
 		})

pkg/services/accesscontrol/filter_test.go

@@ -172,7 +172,7 @@ func TestFilter_Datasources(t *testing.T) {
 				// seed 10 data sources
 				for i := 1; i <= 10; i++ {
 					dsStore := dsService.CreateStore(store, log.New("accesscontrol.test"))
-					err := dsStore.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{Name: fmt.Sprintf("ds:%d", i), UID: fmt.Sprintf("uid%d", i)})
+					_, err := dsStore.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{Name: fmt.Sprintf("ds:%d", i), UID: fmt.Sprintf("uid%d", i)})
 					require.NoError(t, err)
 				}
 

pkg/services/accesscontrol/resourcepermissions/store_bench_test.go

@@ -90,8 +90,8 @@ func GenerateDatasourcePermissions(b *testing.B, db *sqlstore.SQLStore, ac *stor
 			URL:    "http://test",
 		}
 		dsStore := datasourcesService.CreateStore(db, log.New("publicdashboards.test"))
-		_ = dsStore.AddDataSource(context.Background(), addDSCommand)
-		dataSources = append(dataSources, addDSCommand.Result.ID)
+		dataSource, _ := dsStore.AddDataSource(context.Background(), addDSCommand)
+		dataSources = append(dataSources, dataSource.ID)
 	}
 
 	userIds, teamIds := generateTeamsAndUsers(b, db, usersNum)

pkg/services/alerting/alerting_usage.go

@@ -64,13 +64,13 @@ func (e *AlertEngine) mapRulesToUsageStats(ctx context.Context, rules []*models.
 	result := map[string]int{}
 	for k, v := range typeCount {
 		query := &datasources.GetDataSourceQuery{ID: k}
-		err := e.datasourceService.GetDataSource(ctx, query)
+		dataSource, err := e.datasourceService.GetDataSource(ctx, query)
 		if err != nil {
 			return map[string]int{}, nil
 		}
 
 		// aggregate datasource usages based on datasource type
-		result[query.Result.Type] += v
+		result[dataSource.Type] += v
 	}
 
 	return result, nil

pkg/services/alerting/conditions/query.go

@@ -146,16 +146,17 @@ func (c *QueryCondition) executeQuery(context *alerting.EvalContext, timeRange l
 		OrgID: context.Rule.OrgID,
 	}
 
-	if err := context.GetDataSource(context.Ctx, getDsInfo); err != nil {
+	dataSource, err := context.GetDataSource(context.Ctx, getDsInfo)
+	if err != nil {
 		return nil, fmt.Errorf("could not find datasource: %w", err)
 	}
 
-	err := context.RequestValidator.Validate(getDsInfo.Result.URL, nil)
+	err = context.RequestValidator.Validate(dataSource.URL, nil)
 	if err != nil {
 		return nil, fmt.Errorf("access denied: %w", err)
 	}
 
-	req, err := c.getRequestForAlertRule(getDsInfo.Result, timeRange, context.IsDebug)
+	req, err := c.getRequestForAlertRule(dataSource, timeRange, context.IsDebug)
 	if err != nil {
 		return nil, fmt.Errorf("interval calculation failed: %w", err)
 	}
@@ -198,7 +199,7 @@ func (c *QueryCondition) executeQuery(context *alerting.EvalContext, timeRange l
 		})
 	}
 
-	resp, err := requestHandler.HandleRequest(context.Ctx, getDsInfo.Result, req)
+	resp, err := requestHandler.HandleRequest(context.Ctx, dataSource, req)
 	if err != nil {
 		return nil, toCustomError(err)
 	}

pkg/services/alerting/eval_context.go

@@ -228,7 +228,7 @@ func (c *EvalContext) evaluateNotificationTemplateFields() error {
 	return nil
 }
 
-func (c *EvalContext) GetDataSource(ctx context.Context, q *datasources.GetDataSourceQuery) error {
+func (c *EvalContext) GetDataSource(ctx context.Context, q *datasources.GetDataSourceQuery) (*datasources.DataSource, error) {
 	return c.DatasourceService.GetDataSource(ctx, q)
 }
 

pkg/services/alerting/extractor.go

@@ -39,32 +39,34 @@ func (e *DashAlertExtractorService) lookupQueryDataSource(ctx context.Context, p
 	dsName := ""
 	dsUid := ""
 
-	datasource, ok := panelQuery.CheckGet("datasource")
+	ds, ok := panelQuery.CheckGet("datasource")
 
 	if !ok {
-		datasource = panel.Get("datasource")
+		ds = panel.Get("datasource")
 	}
 
-	if name, err := datasource.String(); err == nil {
+	if name, err := ds.String(); err == nil {
 		dsName = name
-	} else if uid, ok := datasource.CheckGet("uid"); ok {
+	} else if uid, ok := ds.CheckGet("uid"); ok {
 		dsUid = uid.MustString()
 	}
 
 	if dsName == "" && dsUid == "" {
 		query := &datasources.GetDefaultDataSourceQuery{OrgID: orgID}
-		if err := e.datasourceService.GetDefaultDataSource(ctx, query); err != nil {
+		dataSource, err := e.datasourceService.GetDefaultDataSource(ctx, query)
+		if err != nil {
 			return nil, err
 		}
-		return query.Result, nil
+		return dataSource, nil
 	}
 
 	query := &datasources.GetDataSourceQuery{Name: dsName, UID: dsUid, OrgID: orgID}
-	if err := e.datasourceService.GetDataSource(ctx, query); err != nil {
+	dataSource, err := e.datasourceService.GetDataSource(ctx, query)
+	if err != nil {
 		return nil, err
 	}
 
-	return query.Result, nil
+	return dataSource, nil
 }
 
 func findPanelQueryByRefID(panel *simplejson.Json, refID string) *simplejson.Json {
@@ -213,11 +215,12 @@ func (e *DashAlertExtractorService) getAlertFromPanels(ctx context.Context, json
 				Datasources: []*datasources.DataSource{datasource},
 			}
 
-			if err := e.datasourcePermissionsService.FilterDatasourcesBasedOnQueryPermissions(ctx, &dsFilterQuery); err != nil {
+			dataSources, err := e.datasourcePermissionsService.FilterDatasourcesBasedOnQueryPermissions(ctx, &dsFilterQuery)
+			if err != nil {
 				if !errors.Is(err, permissions.ErrNotImplemented) {
 					return nil, err
 				}
-			} else if len(dsFilterQuery.Result) == 0 {
+			} else if len(dataSources) == 0 {
 				return nil, datasources.ErrDataSourceAccessDenied
 			}
 

pkg/services/alerting/extractor_test.go

@@ -372,12 +372,10 @@ type fakeDatasourceService struct {
 	datasources.DataSourceService
 }
 
-func (f *fakeDatasourceService) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) error {
-	query.Result = f.ExpectedDatasource
-	return nil
+func (f *fakeDatasourceService) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) (*datasources.DataSource, error) {
+	return f.ExpectedDatasource, nil
 }
 
-func (f *fakeDatasourceService) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error {
-	query.Result = f.ExpectedDatasource
-	return nil
+func (f *fakeDatasourceService) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error) {
+	return f.ExpectedDatasource, nil
 }

pkg/services/correlations/database.go

@@ -26,16 +26,17 @@ func (s CorrelationsService) createCorrelation(ctx context.Context, cmd CreateCo
 			OrgID: cmd.OrgId,
 			UID:   cmd.SourceUID,
 		}
-		if err = s.DataSourceService.GetDataSource(ctx, query); err != nil {
+		dataSource, err := s.DataSourceService.GetDataSource(ctx, query)
+		if err != nil {
 			return ErrSourceDataSourceDoesNotExists
 		}
 
-		if !cmd.SkipReadOnlyCheck && query.Result.ReadOnly {
+		if !cmd.SkipReadOnlyCheck && dataSource.ReadOnly {
 			return ErrSourceDataSourceReadOnly
 		}
 
 		if cmd.TargetUID != nil {
-			if err = s.DataSourceService.GetDataSource(ctx, &datasources.GetDataSourceQuery{
+			if _, err = s.DataSourceService.GetDataSource(ctx, &datasources.GetDataSourceQuery{
 				OrgID: cmd.OrgId,
 				UID:   *cmd.TargetUID,
 			}); err != nil {
@@ -64,11 +65,12 @@ func (s CorrelationsService) deleteCorrelation(ctx context.Context, cmd DeleteCo
 			OrgID: cmd.OrgId,
 			UID:   cmd.SourceUID,
 		}
-		if err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
+		dataSource, err := s.DataSourceService.GetDataSource(ctx, query)
+		if err != nil {
 			return ErrSourceDataSourceDoesNotExists
 		}
 
-		if query.Result.ReadOnly {
+		if dataSource.ReadOnly {
 			return ErrSourceDataSourceReadOnly
 		}
 
@@ -91,11 +93,12 @@ func (s CorrelationsService) updateCorrelation(ctx context.Context, cmd UpdateCo
 			OrgID: cmd.OrgId,
 			UID:   cmd.SourceUID,
 		}
-		if err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
+		dataSource, err := s.DataSourceService.GetDataSource(ctx, query)
+		if err != nil {
 			return ErrSourceDataSourceDoesNotExists
 		}
 
-		if query.Result.ReadOnly {
+		if dataSource.ReadOnly {
 			return ErrSourceDataSourceReadOnly
 		}
 
@@ -153,7 +156,7 @@ func (s CorrelationsService) getCorrelation(ctx context.Context, cmd GetCorrelat
 			OrgID: cmd.OrgId,
 			UID:   cmd.SourceUID,
 		}
-		if err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
+		if _, err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
 			return ErrSourceDataSourceDoesNotExists
 		}
 
@@ -179,7 +182,7 @@ func (s CorrelationsService) getCorrelationsBySourceUID(ctx context.Context, cmd
 			OrgID: cmd.OrgId,
 			UID:   cmd.SourceUID,
 		}
-		if err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
+		if _, err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
 			return ErrSourceDataSourceDoesNotExists
 		}
 

pkg/services/datasources/datasources.go

@@ -13,28 +13,28 @@ import (
 // DataSourceService interface for interacting with datasources.
 type DataSourceService interface {
 	// GetDataSource gets a datasource.
-	GetDataSource(ctx context.Context, query *GetDataSourceQuery) error
+	GetDataSource(ctx context.Context, query *GetDataSourceQuery) (*DataSource, error)
 
 	// GetDataSources gets datasources.
-	GetDataSources(ctx context.Context, query *GetDataSourcesQuery) error
+	GetDataSources(ctx context.Context, query *GetDataSourcesQuery) ([]*DataSource, error)
 
 	// GetAllDataSources gets all datasources.
 	GetAllDataSources(ctx context.Context, query *GetAllDataSourcesQuery) error
 
 	// GetDataSourcesByType gets datasources by type.
-	GetDataSourcesByType(ctx context.Context, query *GetDataSourcesByTypeQuery) error
+	GetDataSourcesByType(ctx context.Context, query *GetDataSourcesByTypeQuery) ([]*DataSource, error)
 
 	// AddDataSource adds a new datasource.
-	AddDataSource(ctx context.Context, cmd *AddDataSourceCommand) error
+	AddDataSource(ctx context.Context, cmd *AddDataSourceCommand) (*DataSource, error)
 
 	// DeleteDataSource deletes an existing datasource.
 	DeleteDataSource(ctx context.Context, cmd *DeleteDataSourceCommand) error
 
 	// UpdateDataSource updates an existing datasource.
-	UpdateDataSource(ctx context.Context, cmd *UpdateDataSourceCommand) error
+	UpdateDataSource(ctx context.Context, cmd *UpdateDataSourceCommand) (*DataSource, error)
 
 	// GetDefaultDataSource gets the default datasource.
-	GetDefaultDataSource(ctx context.Context, query *GetDefaultDataSourceQuery) error
+	GetDefaultDataSource(ctx context.Context, query *GetDefaultDataSourceQuery) (*DataSource, error)
 
 	// GetHTTPTransport gets a datasource specific HTTP transport.
 	GetHTTPTransport(ctx context.Context, ds *DataSource, provider httpclient.Provider, customMiddlewares ...sdkhttpclient.Middleware) (http.RoundTripper, error)

pkg/services/datasources/fakes/fake_datasource_service.go

@@ -18,28 +18,27 @@ type FakeDataSourceService struct {
 
 var _ datasources.DataSourceService = &FakeDataSourceService{}
 
-func (s *FakeDataSourceService) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error {
-	for _, datasource := range s.DataSources {
-		idMatch := query.ID != 0 && query.ID == datasource.ID
-		uidMatch := query.UID != "" && query.UID == datasource.UID
-		nameMatch := query.Name != "" && query.Name == datasource.Name
+func (s *FakeDataSourceService) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error) {
+	for _, dataSource := range s.DataSources {
+		idMatch := query.ID != 0 && query.ID == dataSource.ID
+		uidMatch := query.UID != "" && query.UID == dataSource.UID
+		nameMatch := query.Name != "" && query.Name == dataSource.Name
 		if idMatch || nameMatch || uidMatch {
-			query.Result = datasource
-
-			return nil
+			return dataSource, nil
 		}
 	}
-	return datasources.ErrDataSourceNotFound
+	return nil, datasources.ErrDataSourceNotFound
 }
 
-func (s *FakeDataSourceService) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) error {
+func (s *FakeDataSourceService) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) ([]*datasources.DataSource, error) {
+	var dataSources []*datasources.DataSource
 	for _, datasource := range s.DataSources {
 		orgMatch := query.OrgID != 0 && query.OrgID == datasource.OrgID
 		if orgMatch {
-			query.Result = append(query.Result, datasource)
+			dataSources = append(dataSources, datasource)
 		}
 	}
-	return nil
+	return dataSources, nil
 }
 
 func (s *FakeDataSourceService) GetAllDataSources(ctx context.Context, query *datasources.GetAllDataSourcesQuery) error {
@@ -47,32 +46,33 @@ func (s *FakeDataSourceService) GetAllDataSources(ctx context.Context, query *da
 	return nil
 }
 
-func (s *FakeDataSourceService) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) error {
+func (s *FakeDataSourceService) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) ([]*datasources.DataSource, error) {
+	var dataSources []*datasources.DataSource
 	for _, datasource := range s.DataSources {
 		if query.OrgID > 0 && datasource.OrgID != query.OrgID {
 			continue
 		}
 		typeMatch := query.Type != "" && query.Type == datasource.Type
 		if typeMatch {
-			query.Result = append(query.Result, datasource)
+			dataSources = append(dataSources, datasource)
 		}
 	}
-	return nil
+	return dataSources, nil
 }
 
-func (s *FakeDataSourceService) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) error {
+func (s *FakeDataSourceService) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) (*datasources.DataSource, error) {
 	if s.lastID == 0 {
 		s.lastID = int64(len(s.DataSources) - 1)
 	}
-	cmd.Result = &datasources.DataSource{
+	dataSource := &datasources.DataSource{
 		ID:    s.lastID + 1,
 		Name:  cmd.Name,
 		Type:  cmd.Type,
 		UID:   cmd.UID,
 		OrgID: cmd.OrgID,
 	}
-	s.DataSources = append(s.DataSources, cmd.Result)
-	return nil
+	s.DataSources = append(s.DataSources, dataSource)
+	return dataSource, nil
 }
 
 func (s *FakeDataSourceService) DeleteDataSource(ctx context.Context, cmd *datasources.DeleteDataSourceCommand) error {
@@ -88,7 +88,7 @@ func (s *FakeDataSourceService) DeleteDataSource(ctx context.Context, cmd *datas
 	return datasources.ErrDataSourceNotFound
 }
 
-func (s *FakeDataSourceService) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) error {
+func (s *FakeDataSourceService) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) (*datasources.DataSource, error) {
 	for _, datasource := range s.DataSources {
 		idMatch := cmd.ID != 0 && cmd.ID == datasource.ID
 		uidMatch := cmd.UID != "" && cmd.UID == datasource.UID
@@ -97,14 +97,14 @@ func (s *FakeDataSourceService) UpdateDataSource(ctx context.Context, cmd *datas
 			if cmd.Name != "" {
 				datasource.Name = cmd.Name
 			}
-			return nil
+			return datasource, nil
 		}
 	}
-	return datasources.ErrDataSourceNotFound
+	return nil, datasources.ErrDataSourceNotFound
 }
 
-func (s *FakeDataSourceService) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) error {
-	return nil
+func (s *FakeDataSourceService) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) (*datasources.DataSource, error) {
+	return nil, nil
 }
 
 func (s *FakeDataSourceService) GetHTTPTransport(ctx context.Context, ds *datasources.DataSource, provider httpclient.Provider, customMiddlewares ...sdkhttpclient.Middleware) (http.RoundTripper, error) {

pkg/services/datasources/models.go

@@ -105,8 +105,6 @@ type AddDataSourceCommand struct {
 	ReadOnly                bool              `json:"-"`
 	EncryptedSecureJsonData map[string][]byte `json:"-"`
 	UpdateSecretFn          UpdateSecretFn    `json:"-"`
-
-	Result *DataSource `json:"-"`
 }
 
 // Also acts as api DTO
@@ -131,8 +129,6 @@ type UpdateDataSourceCommand struct {
 	ReadOnly                bool              `json:"-"`
 	EncryptedSecureJsonData map[string][]byte `json:"-"`
 	UpdateSecretFn          UpdateSecretFn    `json:"-"`
-
-	Result *DataSource `json:"-"`
 }
 
 // DeleteDataSourceCommand will delete a DataSource based on OrgID as well as the UID (preferred), ID, or Name.
@@ -159,7 +155,6 @@ type GetDataSourcesQuery struct {
 	OrgID           int64
 	DataSourceLimit int
 	User            *user.SignedInUser
-	Result          []*DataSource
 }
 
 type GetAllDataSourcesQuery struct {
@@ -167,15 +162,13 @@ type GetAllDataSourcesQuery struct {
 }
 
 type GetDataSourcesByTypeQuery struct {
-	OrgID  int64 // optional: filter by org_id
-	Type   string
-	Result []*DataSource
+	OrgID int64 // optional: filter by org_id
+	Type  string
 }
 
 type GetDefaultDataSourceQuery struct {
-	OrgID  int64
-	User   *user.SignedInUser
-	Result *DataSource
+	OrgID int64
+	User  *user.SignedInUser
 }
 
 // GetDataSourceQuery will get a DataSource based on OrgID as well as the UID (preferred), ID, or Name.
@@ -186,14 +179,11 @@ type GetDataSourceQuery struct {
 	Name string
 
 	OrgID int64
-
-	Result *DataSource
 }
 
 type DatasourcesPermissionFilterQuery struct {
 	User        *user.SignedInUser
 	Datasources []*DataSource
-	Result      []*DataSource
 }
 
 const (

pkg/services/datasources/permissions/datasource_permissions.go

@@ -11,13 +11,13 @@ import (
 var ErrNotImplemented = errors.New("not implemented")
 
 type DatasourcePermissionsService interface {
-	FilterDatasourcesBasedOnQueryPermissions(ctx context.Context, cmd *datasources.DatasourcesPermissionFilterQuery) error
+	FilterDatasourcesBasedOnQueryPermissions(ctx context.Context, cmd *datasources.DatasourcesPermissionFilterQuery) ([]*datasources.DataSource, error)
 	FilterDatasourceUidsBasedOnQueryPermissions(ctx context.Context, user *user.SignedInUser, datasourceUids []string) ([]string, error)
 }
 
 // dummy method
-func (hs *OSSDatasourcePermissionsService) FilterDatasourcesBasedOnQueryPermissions(ctx context.Context, cmd *datasources.DatasourcesPermissionFilterQuery) error {
-	return ErrNotImplemented
+func (hs *OSSDatasourcePermissionsService) FilterDatasourcesBasedOnQueryPermissions(ctx context.Context, cmd *datasources.DatasourcesPermissionFilterQuery) ([]*datasources.DataSource, error) {
+	return nil, ErrNotImplemented
 }
 
 func (hs *OSSDatasourcePermissionsService) FilterDatasourceUidsBasedOnQueryPermissions(ctx context.Context, user *user.SignedInUser, datasourceUids []string) ([]string, error) {

pkg/services/datasources/permissions/datasource_permissions_mocks.go

@@ -17,9 +17,8 @@ func (m *mockDatasourcePermissionService) FilterDatasourceUidsBasedOnQueryPermis
 	return m.DsUidResult, m.ErrResult
 }
 
-func (m *mockDatasourcePermissionService) FilterDatasourcesBasedOnQueryPermissions(ctx context.Context, cmd *datasources.DatasourcesPermissionFilterQuery) error {
-	cmd.Result = m.DsResult
-	return m.ErrResult
+func (m *mockDatasourcePermissionService) FilterDatasourcesBasedOnQueryPermissions(ctx context.Context, cmd *datasources.DatasourcesPermissionFilterQuery) ([]*datasources.DataSource, error) {
+	return m.DsResult, m.ErrResult
 }
 
 func NewMockDatasourcePermissionService() *mockDatasourcePermissionService {

pkg/services/datasources/service/cache.go

@@ -53,13 +53,11 @@ func (dc *CacheServiceImpl) GetDatasource(
 
 	query := &datasources.GetDataSourceQuery{ID: datasourceID, OrgID: user.OrgID}
 	ss := SqlStore{db: dc.SQLStore, logger: dc.logger}
-	err := ss.GetDataSource(ctx, query)
+	ds, err := ss.GetDataSource(ctx, query)
 	if err != nil {
 		return nil, err
 	}
 
-	ds := query.Result
-
 	if ds.UID != "" {
 		dc.CacheService.Set(uidKey(ds.OrgID, ds.UID), ds, time.Second*5)
 	}
@@ -93,13 +91,11 @@ func (dc *CacheServiceImpl) GetDatasourceByUID(
 	dc.logger.FromContext(ctx).Debug("Querying for data source via SQL store", "uid", datasourceUID, "orgId", user.OrgID)
 	query := &datasources.GetDataSourceQuery{UID: datasourceUID, OrgID: user.OrgID}
 	ss := SqlStore{db: dc.SQLStore, logger: dc.logger}
-	err := ss.GetDataSource(ctx, query)
+	ds, err := ss.GetDataSource(ctx, query)
 	if err != nil {
 		return nil, err
 	}
 
-	ds := query.Result
-
 	dc.CacheService.Set(uidCacheKey, ds, dc.cacheTTL)
 	dc.CacheService.Set(idKey(ds.ID), ds, dc.cacheTTL)
 	return ds, nil

pkg/services/datasources/service/datasource.go

@@ -97,7 +97,7 @@ func (s *Service) Usage(ctx context.Context, scopeParams *quota.ScopeParameters)
 // DataSourceRetriever interface for retrieving a datasource.
 type DataSourceRetriever interface {
 	// GetDataSource gets a datasource.
-	GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error
+	GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error)
 }
 
 // NewNameScopeResolver provides an ScopeAttributeResolver able to
@@ -115,11 +115,12 @@ func NewNameScopeResolver(db DataSourceRetriever) (string, accesscontrol.ScopeAt
 		}
 
 		query := datasources.GetDataSourceQuery{Name: dsName, OrgID: orgID}
-		if err := db.GetDataSource(ctx, &query); err != nil {
+		dataSource, err := db.GetDataSource(ctx, &query)
+		if err != nil {
 			return nil, err
 		}
 
-		return []string{datasources.ScopeProvider.GetResourceScopeUID(query.Result.UID)}, nil
+		return []string{datasources.ScopeProvider.GetResourceScopeUID(dataSource.UID)}, nil
 	})
 }
 
@@ -143,19 +144,20 @@ func NewIDScopeResolver(db DataSourceRetriever) (string, accesscontrol.ScopeAttr
 		}
 
 		query := datasources.GetDataSourceQuery{ID: dsID, OrgID: orgID}
-		if err := db.GetDataSource(ctx, &query); err != nil {
+		dataSource, err := db.GetDataSource(ctx, &query)
+		if err != nil {
 			return nil, err
 		}
 
-		return []string{datasources.ScopeProvider.GetResourceScopeUID(query.Result.UID)}, nil
+		return []string{datasources.ScopeProvider.GetResourceScopeUID(dataSource.UID)}, nil
 	})
 }
 
-func (s *Service) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error {
+func (s *Service) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error) {
 	return s.SQLStore.GetDataSource(ctx, query)
 }
 
-func (s *Service) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) error {
+func (s *Service) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) ([]*datasources.DataSource, error) {
 	return s.SQLStore.GetDataSources(ctx, query)
 }
 
@@ -163,12 +165,14 @@ func (s *Service) GetAllDataSources(ctx context.Context, query *datasources.GetA
 	return s.SQLStore.GetAllDataSources(ctx, query)
 }
 
-func (s *Service) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) error {
+func (s *Service) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) ([]*datasources.DataSource, error) {
 	return s.SQLStore.GetDataSourcesByType(ctx, query)
 }
 
-func (s *Service) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) error {
-	return s.db.InTransaction(ctx, func(ctx context.Context) error {
+func (s *Service) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) (*datasources.DataSource, error) {
+	var dataSource *datasources.DataSource
+
+	return dataSource, s.db.InTransaction(ctx, func(ctx context.Context) error {
 		var err error
 
 		cmd.EncryptedSecureJsonData = make(map[string][]byte)
@@ -188,7 +192,8 @@ func (s *Service) AddDataSource(ctx context.Context, cmd *datasources.AddDataSou
 			return s.SecretsStore.Set(ctx, cmd.OrgID, cmd.Name, kvstore.DataSourceSecretType, string(secret))
 		}
 
-		if err := s.SQLStore.AddDataSource(ctx, cmd); err != nil {
+		dataSource, err = s.SQLStore.AddDataSource(ctx, cmd)
+		if err != nil {
 			return err
 		}
 
@@ -205,7 +210,7 @@ func (s *Service) AddDataSource(ctx context.Context, cmd *datasources.AddDataSou
 			if cmd.UserID != 0 {
 				permissions = append(permissions, accesscontrol.SetResourcePermissionCommand{UserID: cmd.UserID, Permission: "Edit"})
 			}
-			if _, err := s.permissionsService.SetPermissions(ctx, cmd.OrgID, cmd.Result.UID, permissions...); err != nil {
+			if _, err := s.permissionsService.SetPermissions(ctx, cmd.OrgID, dataSource.UID, permissions...); err != nil {
 				return err
 			}
 		}
@@ -224,20 +229,21 @@ func (s *Service) DeleteDataSource(ctx context.Context, cmd *datasources.DeleteD
 	})
 }
 
-func (s *Service) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) error {
-	return s.db.InTransaction(ctx, func(ctx context.Context) error {
+func (s *Service) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) (*datasources.DataSource, error) {
+	var dataSource *datasources.DataSource
+	return dataSource, s.db.InTransaction(ctx, func(ctx context.Context) error {
 		var err error
 
 		query := &datasources.GetDataSourceQuery{
 			ID:    cmd.ID,
 			OrgID: cmd.OrgID,
 		}
-		err = s.SQLStore.GetDataSource(ctx, query)
+		dataSource, err = s.SQLStore.GetDataSource(ctx, query)
 		if err != nil {
 			return err
 		}
 
-		err = s.fillWithSecureJSONData(ctx, cmd, query.Result)
+		err = s.fillWithSecureJSONData(ctx, cmd, dataSource)
 		if err != nil {
 			return err
 		}
@@ -249,8 +255,8 @@ func (s *Service) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateD
 					return err
 				}
 
-				if query.Result.Name != cmd.Name {
-					err := s.SecretsStore.Rename(ctx, cmd.OrgID, query.Result.Name, kvstore.DataSourceSecretType, cmd.Name)
+				if dataSource.Name != cmd.Name {
+					err := s.SecretsStore.Rename(ctx, cmd.OrgID, dataSource.Name, kvstore.DataSourceSecretType, cmd.Name)
 					if err != nil {
 						return err
 					}
@@ -260,11 +266,12 @@ func (s *Service) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateD
 			}
 		}
 
-		return s.SQLStore.UpdateDataSource(ctx, cmd)
+		dataSource, err = s.SQLStore.UpdateDataSource(ctx, cmd)
+		return err
 	})
 }
 
-func (s *Service) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) error {
+func (s *Service) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) (*datasources.DataSource, error) {
 	return s.SQLStore.GetDefaultDataSource(ctx, query)
 }
 

pkg/services/datasources/service/datasource_test.go

@@ -33,18 +33,16 @@ type dataSourceMockRetriever struct {
 	res []*datasources.DataSource
 }
 
-func (d *dataSourceMockRetriever) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error {
-	for _, datasource := range d.res {
-		idMatch := query.ID != 0 && query.ID == datasource.ID
-		uidMatch := query.UID != "" && query.UID == datasource.UID
-		nameMatch := query.Name != "" && query.Name == datasource.Name
+func (d *dataSourceMockRetriever) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error) {
+	for _, dataSource := range d.res {
+		idMatch := query.ID != 0 && query.ID == dataSource.ID
+		uidMatch := query.UID != "" && query.UID == dataSource.UID
+		nameMatch := query.Name != "" && query.Name == dataSource.Name
 		if idMatch || nameMatch || uidMatch {
-			query.Result = datasource
-
-			return nil
+			return dataSource, nil
 		}
 	}
-	return datasources.ErrDataSourceNotFound
+	return nil, datasources.ErrDataSourceNotFound
 }
 
 func TestService_NameScopeResolver(t *testing.T) {

pkg/services/datasources/service/store.go

@@ -23,13 +23,13 @@ import (
 
 // Store is the interface for the datasource Service's storage.
 type Store interface {
-	GetDataSource(context.Context, *datasources.GetDataSourceQuery) error
-	GetDataSources(context.Context, *datasources.GetDataSourcesQuery) error
-	GetDataSourcesByType(context.Context, *datasources.GetDataSourcesByTypeQuery) error
-	GetDefaultDataSource(context.Context, *datasources.GetDefaultDataSourceQuery) error
+	GetDataSource(context.Context, *datasources.GetDataSourceQuery) (*datasources.DataSource, error)
+	GetDataSources(context.Context, *datasources.GetDataSourcesQuery) ([]*datasources.DataSource, error)
+	GetDataSourcesByType(context.Context, *datasources.GetDataSourcesByTypeQuery) ([]*datasources.DataSource, error)
+	GetDefaultDataSource(context.Context, *datasources.GetDefaultDataSourceQuery) (*datasources.DataSource, error)
 	DeleteDataSource(context.Context, *datasources.DeleteDataSourceCommand) error
-	AddDataSource(context.Context, *datasources.AddDataSourceCommand) error
-	UpdateDataSource(context.Context, *datasources.UpdateDataSourceCommand) error
+	AddDataSource(context.Context, *datasources.AddDataSourceCommand) (*datasources.DataSource, error)
+	UpdateDataSource(context.Context, *datasources.UpdateDataSourceCommand) (*datasources.DataSource, error)
 	GetAllDataSources(ctx context.Context, query *datasources.GetAllDataSourcesQuery) error
 
 	Count(context.Context, *quota.ScopeParameters) (*quota.Map, error)
@@ -46,17 +46,22 @@ func CreateStore(db db.DB, logger log.Logger) *SqlStore {
 
 // GetDataSource adds a datasource to the query model by querying by org_id as well as
 // either uid (preferred), id, or name and is added to the bus.
-func (ss *SqlStore) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error {
+func (ss *SqlStore) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error) {
 	metrics.MDBDataSourceQueryByID.Inc()
 
-	return ss.db.WithDbSession(ctx, func(sess *db.Session) error {
-		return ss.getDataSource(ctx, query, sess)
+	var (
+		dataSource *datasources.DataSource
+		err        error
+	)
+	return dataSource, ss.db.WithDbSession(ctx, func(sess *db.Session) error {
+		dataSource, err = ss.getDataSource(ctx, query, sess)
+		return err
 	})
 }
 
-func (ss *SqlStore) getDataSource(ctx context.Context, query *datasources.GetDataSourceQuery, sess *db.Session) error {
+func (ss *SqlStore) getDataSource(ctx context.Context, query *datasources.GetDataSourceQuery, sess *db.Session) (*datasources.DataSource, error) {
 	if query.OrgID == 0 || (query.ID == 0 && len(query.Name) == 0 && len(query.UID) == 0) {
-		return datasources.ErrDataSourceIdentifierNotSet
+		return nil, datasources.ErrDataSourceIdentifierNotSet
 	}
 
 	datasource := &datasources.DataSource{Name: query.Name, OrgID: query.OrgID, ID: query.ID, UID: query.UID}
@@ -64,27 +69,27 @@ func (ss *SqlStore) getDataSource(ctx context.Context, query *datasources.GetDat
 
 	if err != nil {
 		ss.logger.Error("Failed getting data source", "err", err, "uid", query.UID, "id", query.ID, "name", query.Name, "orgId", query.OrgID)
-		return err
+		return nil, err
 	} else if !has {
-		return datasources.ErrDataSourceNotFound
+		return nil, datasources.ErrDataSourceNotFound
 	}
 
-	query.Result = datasource
-
-	return nil
+	return datasource, nil
 }
 
-func (ss *SqlStore) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) error {
-	var sess *xorm.Session
-	return ss.db.WithDbSession(ctx, func(dbSess *db.Session) error {
+func (ss *SqlStore) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) ([]*datasources.DataSource, error) {
+	var (
+		sess        *xorm.Session
+		dataSources []*datasources.DataSource
+	)
+	return dataSources, ss.db.WithDbSession(ctx, func(dbSess *db.Session) error {
 		if query.DataSourceLimit <= 0 {
 			sess = dbSess.Where("org_id=?", query.OrgID).Asc("name")
 		} else {
 			sess = dbSess.Limit(query.DataSourceLimit, 0).Where("org_id=?", query.OrgID).Asc("name")
 		}
 
-		query.Result = make([]*datasources.DataSource, 0)
-		return sess.Find(&query.Result)
+		return sess.Find(&dataSources)
 	})
 }
 
@@ -96,31 +101,30 @@ func (ss *SqlStore) GetAllDataSources(ctx context.Context, query *datasources.Ge
 }
 
 // GetDataSourcesByType returns all datasources for a given type or an error if the specified type is an empty string
-func (ss *SqlStore) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) error {
+func (ss *SqlStore) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) ([]*datasources.DataSource, error) {
 	if query.Type == "" {
-		return fmt.Errorf("datasource type cannot be empty")
+		return nil, fmt.Errorf("datasource type cannot be empty")
 	}
 
-	query.Result = make([]*datasources.DataSource, 0)
-	return ss.db.WithDbSession(ctx, func(sess *db.Session) error {
+	dataSources := make([]*datasources.DataSource, 0)
+	return dataSources, ss.db.WithDbSession(ctx, func(sess *db.Session) error {
 		if query.OrgID > 0 {
-			return sess.Where("type=? AND org_id=?", query.Type, query.OrgID).Asc("id").Find(&query.Result)
+			return sess.Where("type=? AND org_id=?", query.Type, query.OrgID).Asc("id").Find(&dataSources)
 		}
-		return sess.Where("type=?", query.Type).Asc("id").Find(&query.Result)
+		return sess.Where("type=?", query.Type).Asc("id").Find(&dataSources)
 	})
 }
 
 // GetDefaultDataSource is used to get the default datasource of organization
-func (ss *SqlStore) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) error {
-	datasource := datasources.DataSource{}
-	return ss.db.WithDbSession(ctx, func(sess *db.Session) error {
-		exists, err := sess.Where("org_id=? AND is_default=?", query.OrgID, true).Get(&datasource)
+func (ss *SqlStore) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) (*datasources.DataSource, error) {
+	dataSource := datasources.DataSource{}
+	return &dataSource, ss.db.WithDbSession(ctx, func(sess *db.Session) error {
+		exists, err := sess.Where("org_id=? AND is_default=?", query.OrgID, true).Get(&dataSource)
 
 		if !exists {
 			return datasources.ErrDataSourceNotFound
 		}
 
-		query.Result = &datasource
 		return err
 	})
 }
@@ -130,13 +134,12 @@ func (ss *SqlStore) GetDefaultDataSource(ctx context.Context, query *datasources
 func (ss *SqlStore) DeleteDataSource(ctx context.Context, cmd *datasources.DeleteDataSourceCommand) error {
 	return ss.db.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
 		dsQuery := &datasources.GetDataSourceQuery{ID: cmd.ID, UID: cmd.UID, Name: cmd.Name, OrgID: cmd.OrgID}
-		errGettingDS := ss.getDataSource(ctx, dsQuery, sess)
+		ds, errGettingDS := ss.getDataSource(ctx, dsQuery, sess)
 
 		if errGettingDS != nil && !errors.Is(errGettingDS, datasources.ErrDataSourceNotFound) {
 			return errGettingDS
 		}
 
-		ds := dsQuery.Result
 		if ds != nil {
 			// Delete the data source
 			result, err := sess.Exec("DELETE FROM data_source WHERE org_id=? AND id=?", ds.OrgID, ds.ID)
@@ -148,7 +151,7 @@ func (ss *SqlStore) DeleteDataSource(ctx context.Context, cmd *datasources.Delet
 
 			// Remove associated AccessControl permissions
 			if _, errDeletingPerms := sess.Exec("DELETE FROM permission WHERE scope=?",
-				ac.Scope(datasources.ScopeProvider.GetResourceScope(dsQuery.Result.UID))); errDeletingPerms != nil {
+				ac.Scope(datasources.ScopeProvider.GetResourceScope(ds.UID))); errDeletingPerms != nil {
 				return errDeletingPerms
 			}
 		}
@@ -219,8 +222,10 @@ func (ss *SqlStore) Count(ctx context.Context, scopeParams *quota.ScopeParameter
 	return u, nil
 }
 
-func (ss *SqlStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) error {
-	return ss.db.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
+func (ss *SqlStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) (*datasources.DataSource, error) {
+	var ds *datasources.DataSource
+
+	return ds, ss.db.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
 		existing := datasources.DataSource{OrgID: cmd.OrgID, Name: cmd.Name}
 		has, _ := sess.Get(&existing)
 
@@ -240,7 +245,7 @@ func (ss *SqlStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataS
 			cmd.UID = uid
 		}
 
-		ds := &datasources.DataSource{
+		ds = &datasources.DataSource{
 			OrgID:           cmd.OrgID,
 			Name:            cmd.Name,
 			Type:            cmd.Type,
@@ -278,8 +283,6 @@ func (ss *SqlStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataS
 			}
 		}
 
-		cmd.Result = ds
-
 		sess.PublishAfterCommit(&events.DataSourceCreated{
 			Timestamp: time.Now(),
 			Name:      cmd.Name,
@@ -302,13 +305,14 @@ func updateIsDefaultFlag(ds *datasources.DataSource, sess *db.Session) error {
 	return nil
 }
 
-func (ss *SqlStore) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) error {
-	return ss.db.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
+func (ss *SqlStore) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) (*datasources.DataSource, error) {
+	var ds *datasources.DataSource
+	return ds, ss.db.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
 		if cmd.JsonData == nil {
 			cmd.JsonData = simplejson.New()
 		}
 
-		ds := &datasources.DataSource{
+		ds = &datasources.DataSource{
 			ID:              cmd.ID,
 			OrgID:           cmd.OrgID,
 			Name:            cmd.Name,
@@ -372,7 +376,6 @@ func (ss *SqlStore) UpdateDataSource(ctx context.Context, cmd *datasources.Updat
 			}
 		}
 
-		cmd.Result = ds
 		return err
 	})
 }

pkg/services/datasources/service/store_test.go

@@ -39,22 +39,22 @@ func TestIntegrationDataAccess(t *testing.T) {
 	initDatasource := func(db db.DB) *datasources.DataSource {
 		cmd := defaultAddDatasourceCommand
 		ss := SqlStore{db: db}
-		err := ss.AddDataSource(context.Background(), &cmd)
+		_, err := ss.AddDataSource(context.Background(), &cmd)
 		require.NoError(t, err)
 
 		query := datasources.GetDataSourcesQuery{OrgID: 10}
-		err = ss.GetDataSources(context.Background(), &query)
+		dataSources, err := ss.GetDataSources(context.Background(), &query)
 		require.NoError(t, err)
-		require.Equal(t, 1, len(query.Result))
+		require.Equal(t, 1, len(dataSources))
 
-		return query.Result[0]
+		return dataSources[0]
 	}
 
 	t.Run("AddDataSource", func(t *testing.T) {
 		t.Run("Can add datasource", func(t *testing.T) {
 			db := db.InitTestDB(t)
 			ss := SqlStore{db: db}
-			err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
+			_, err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
 				OrgID:    10,
 				Name:     "laban",
 				Type:     datasources.DS_GRAPHITE,
@@ -66,11 +66,11 @@ func TestIntegrationDataAccess(t *testing.T) {
 			require.NoError(t, err)
 
 			query := datasources.GetDataSourcesQuery{OrgID: 10}
-			err = ss.GetDataSources(context.Background(), &query)
+			dataSources, err := ss.GetDataSources(context.Background(), &query)
 			require.NoError(t, err)
 
-			require.Equal(t, 1, len(query.Result))
-			ds := query.Result[0]
+			require.Equal(t, 1, len(dataSources))
+			ds := dataSources[0]
 
 			require.EqualValues(t, 10, ds.OrgID)
 			require.Equal(t, "site", ds.Database)
@@ -90,9 +90,9 @@ func TestIntegrationDataAccess(t *testing.T) {
 			cmd2 := defaultAddDatasourceCommand
 			cmd1.UID = "test"
 			cmd2.UID = "test"
-			err := ss.AddDataSource(context.Background(), &cmd1)
+			_, err := ss.AddDataSource(context.Background(), &cmd1)
 			require.NoError(t, err)
-			err = ss.AddDataSource(context.Background(), &cmd2)
+			_, err = ss.AddDataSource(context.Background(), &cmd2)
 			require.Error(t, err)
 			require.IsType(t, datasources.ErrDataSourceUidExists, err)
 		})
@@ -106,7 +106,7 @@ func TestIntegrationDataAccess(t *testing.T) {
 				return nil
 			})
 
-			err := sqlStore.AddDataSource(context.Background(), &defaultAddDatasourceCommand)
+			_, err := sqlStore.AddDataSource(context.Background(), &defaultAddDatasourceCommand)
 			require.NoError(t, err)
 
 			require.Eventually(t, func() bool {
@@ -114,12 +114,12 @@ func TestIntegrationDataAccess(t *testing.T) {
 			}, time.Second, time.Millisecond)
 
 			query := datasources.GetDataSourcesQuery{OrgID: 10}
-			err = sqlStore.GetDataSources(context.Background(), &query)
+			dataSources, err := sqlStore.GetDataSources(context.Background(), &query)
 			require.NoError(t, err)
-			require.Equal(t, 1, len(query.Result))
+			require.Equal(t, 1, len(dataSources))
 
-			require.Equal(t, query.Result[0].ID, created.ID)
-			require.Equal(t, query.Result[0].UID, created.UID)
+			require.Equal(t, dataSources[0].ID, created.ID)
+			require.Equal(t, dataSources[0].UID, created.UID)
 			require.Equal(t, int64(10), created.OrgID)
 			require.Equal(t, "nisse", created.Name)
 		})
@@ -133,7 +133,7 @@ func TestIntegrationDataAccess(t *testing.T) {
 			cmd.ID = ds.ID
 			cmd.Version = ds.Version
 			ss := SqlStore{db: db}
-			err := ss.UpdateDataSource(context.Background(), &cmd)
+			_, err := ss.UpdateDataSource(context.Background(), &cmd)
 			require.NoError(t, err)
 		})
 
@@ -145,13 +145,13 @@ func TestIntegrationDataAccess(t *testing.T) {
 
 			cmd := defaultUpdateDatasourceCommand
 			cmd.ID = ds.ID
-			err := ss.UpdateDataSource(context.Background(), &cmd)
+			_, err := ss.UpdateDataSource(context.Background(), &cmd)
 			require.NoError(t, err)
 
 			query := datasources.GetDataSourceQuery{ID: ds.ID, OrgID: 10}
-			err = ss.GetDataSource(context.Background(), &query)
+			dataSource, err := ss.GetDataSource(context.Background(), &query)
 			require.NoError(t, err)
-			require.Equal(t, ds.UID, query.Result.UID)
+			require.Equal(t, ds.UID, dataSource.UID)
 		})
 
 		t.Run("prevents update if version changed", func(t *testing.T) {
@@ -171,10 +171,10 @@ func TestIntegrationDataAccess(t *testing.T) {
 			// Make a copy as UpdateDataSource modifies it
 			cmd2 := cmd
 
-			err := ss.UpdateDataSource(context.Background(), &cmd)
+			_, err := ss.UpdateDataSource(context.Background(), &cmd)
 			require.NoError(t, err)
 
-			err = ss.UpdateDataSource(context.Background(), &cmd2)
+			_, err = ss.UpdateDataSource(context.Background(), &cmd2)
 			require.Error(t, err)
 		})
 
@@ -192,7 +192,7 @@ func TestIntegrationDataAccess(t *testing.T) {
 				URL:    "http://test",
 			}
 
-			err := ss.UpdateDataSource(context.Background(), cmd)
+			_, err := ss.UpdateDataSource(context.Background(), cmd)
 			require.NoError(t, err)
 		})
 
@@ -211,7 +211,7 @@ func TestIntegrationDataAccess(t *testing.T) {
 				Version: 90000,
 			}
 
-			err := ss.UpdateDataSource(context.Background(), cmd)
+			_, err := ss.UpdateDataSource(context.Background(), cmd)
 			require.NoError(t, err)
 		})
 	})
@@ -226,13 +226,13 @@ func TestIntegrationDataAccess(t *testing.T) {
 			require.NoError(t, err)
 
 			query := datasources.GetDataSourcesQuery{OrgID: 10}
-			err = ss.GetDataSources(context.Background(), &query)
+			dataSources, err := ss.GetDataSources(context.Background(), &query)
 			require.NoError(t, err)
 
-			require.Equal(t, 0, len(query.Result))
+			require.Equal(t, 0, len(dataSources))
 		})
 
-		t.Run("Can not delete datasource with wrong orgId", func(t *testing.T) {
+		t.Run("Can not delete datasource with wrong orgID", func(t *testing.T) {
 			db := db.InitTestDB(t)
 			ds := initDatasource(db)
 			ss := SqlStore{db: db}
@@ -242,10 +242,10 @@ func TestIntegrationDataAccess(t *testing.T) {
 			require.NoError(t, err)
 
 			query := datasources.GetDataSourcesQuery{OrgID: 10}
-			err = ss.GetDataSources(context.Background(), &query)
+			dataSources, err := ss.GetDataSources(context.Background(), &query)
 			require.NoError(t, err)
 
-			require.Equal(t, 1, len(query.Result))
+			require.Equal(t, 1, len(dataSources))
 		})
 	})
 
@@ -302,10 +302,10 @@ func TestIntegrationDataAccess(t *testing.T) {
 		err := ss.DeleteDataSource(context.Background(), &datasources.DeleteDataSourceCommand{Name: ds.Name, OrgID: ds.OrgID})
 		require.NoError(t, err)
 
-		err = ss.GetDataSources(context.Background(), &query)
+		dataSources, err := ss.GetDataSources(context.Background(), &query)
 		require.NoError(t, err)
 
-		require.Equal(t, 0, len(query.Result))
+		require.Equal(t, 0, len(dataSources))
 	})
 
 	t.Run("DeleteDataSourceAccessControlPermissions", func(t *testing.T) {
@@ -342,7 +342,10 @@ func TestIntegrationDataAccess(t *testing.T) {
 		require.NoError(t, errGetPermissions)
 		require.Zero(t, permCount, "permissions associated to the data source should have been removed")
 
-		require.Equal(t, 0, len(query.Result))
+		dataSources, err := ss.GetDataSources(context.Background(), &query)
+
+		require.NoError(t, err)
+		require.Equal(t, 0, len(dataSources))
 	})
 
 	t.Run("GetDataSources", func(t *testing.T) {
@@ -351,7 +354,7 @@ func TestIntegrationDataAccess(t *testing.T) {
 			ss := SqlStore{db: db}
 			datasourceLimit := 6
 			for i := 0; i < datasourceLimit+1; i++ {
-				err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
+				_, err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
 					OrgID:    10,
 					Name:     "laban" + strconv.Itoa(i),
 					Type:     datasources.DS_GRAPHITE,
@@ -364,10 +367,10 @@ func TestIntegrationDataAccess(t *testing.T) {
 			}
 			query := datasources.GetDataSourcesQuery{OrgID: 10, DataSourceLimit: datasourceLimit}
 
-			err := ss.GetDataSources(context.Background(), &query)
+			dataSources, err := ss.GetDataSources(context.Background(), &query)
 
 			require.NoError(t, err)
-			require.Equal(t, datasourceLimit, len(query.Result))
+			require.Equal(t, datasourceLimit, len(dataSources))
 		})
 
 		t.Run("No limit should be applied on the returned data sources if the limit is not set", func(t *testing.T) {
@@ -375,7 +378,7 @@ func TestIntegrationDataAccess(t *testing.T) {
 			ss := SqlStore{db: db}
 			numberOfDatasource := 5100
 			for i := 0; i < numberOfDatasource; i++ {
-				err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
+				_, err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
 					OrgID:    10,
 					Name:     "laban" + strconv.Itoa(i),
 					Type:     datasources.DS_GRAPHITE,
@@ -388,10 +391,10 @@ func TestIntegrationDataAccess(t *testing.T) {
 			}
 			query := datasources.GetDataSourcesQuery{OrgID: 10}
 
-			err := ss.GetDataSources(context.Background(), &query)
+			dataSources, err := ss.GetDataSources(context.Background(), &query)
 
 			require.NoError(t, err)
-			require.Equal(t, numberOfDatasource, len(query.Result))
+			require.Equal(t, numberOfDatasource, len(dataSources))
 		})
 
 		t.Run("No limit should be applied on the returned data sources if the limit is negative", func(t *testing.T) {
@@ -399,7 +402,7 @@ func TestIntegrationDataAccess(t *testing.T) {
 			ss := SqlStore{db: db}
 			numberOfDatasource := 5100
 			for i := 0; i < numberOfDatasource; i++ {
-				err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
+				_, err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
 					OrgID:    10,
 					Name:     "laban" + strconv.Itoa(i),
 					Type:     datasources.DS_GRAPHITE,
@@ -412,10 +415,10 @@ func TestIntegrationDataAccess(t *testing.T) {
 			}
 			query := datasources.GetDataSourcesQuery{OrgID: 10, DataSourceLimit: -1}
 
-			err := ss.GetDataSources(context.Background(), &query)
+			dataSources, err := ss.GetDataSources(context.Background(), &query)
 
 			require.NoError(t, err)
-			require.Equal(t, numberOfDatasource, len(query.Result))
+			require.Equal(t, numberOfDatasource, len(dataSources))
 		})
 	})
 
@@ -424,7 +427,7 @@ func TestIntegrationDataAccess(t *testing.T) {
 			db := db.InitTestDB(t)
 			ss := SqlStore{db: db}
 
-			err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
+			_, err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
 				OrgID:    10,
 				Name:     "Elasticsearch",
 				Type:     datasources.DS_ES,
@@ -435,7 +438,7 @@ func TestIntegrationDataAccess(t *testing.T) {
 			})
 			require.NoError(t, err)
 
-			err = ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
+			_, err = ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
 				OrgID:    10,
 				Name:     "Graphite",
 				Type:     datasources.DS_GRAPHITE,
@@ -448,10 +451,10 @@ func TestIntegrationDataAccess(t *testing.T) {
 
 			query := datasources.GetDataSourcesByTypeQuery{Type: datasources.DS_ES}
 
-			err = ss.GetDataSourcesByType(context.Background(), &query)
+			dataSources, err := ss.GetDataSourcesByType(context.Background(), &query)
 
 			require.NoError(t, err)
-			require.Equal(t, 1, len(query.Result))
+			require.Equal(t, 1, len(dataSources))
 		})
 
 		t.Run("Returns an error if no type specified", func(t *testing.T) {
@@ -460,7 +463,7 @@ func TestIntegrationDataAccess(t *testing.T) {
 
 			query := datasources.GetDataSourcesByTypeQuery{}
 
-			err := ss.GetDataSourcesByType(context.Background(), &query)
+			_, err := ss.GetDataSourcesByType(context.Background(), &query)
 
 			require.Error(t, err)
 		})
@@ -484,11 +487,11 @@ func TestIntegrationGetDefaultDataSource(t *testing.T) {
 			URL:    "http://test",
 		}
 
-		err := ss.AddDataSource(context.Background(), &cmd)
+		_, err := ss.AddDataSource(context.Background(), &cmd)
 		require.NoError(t, err)
 
 		query := datasources.GetDefaultDataSourceQuery{OrgID: 10}
-		err = ss.GetDefaultDataSource(context.Background(), &query)
+		_, err = ss.GetDefaultDataSource(context.Background(), &query)
 		require.Error(t, err)
 		assert.True(t, errors.Is(err, datasources.ErrDataSourceNotFound))
 	})
@@ -506,20 +509,20 @@ func TestIntegrationGetDefaultDataSource(t *testing.T) {
 			IsDefault: true,
 		}
 
-		err := ss.AddDataSource(context.Background(), &cmd)
+		_, err := ss.AddDataSource(context.Background(), &cmd)
 		require.NoError(t, err)
 
 		query := datasources.GetDefaultDataSourceQuery{OrgID: 10}
-		err = ss.GetDefaultDataSource(context.Background(), &query)
+		dataSource, err := ss.GetDefaultDataSource(context.Background(), &query)
 		require.NoError(t, err)
-		assert.Equal(t, "default datasource", query.Result.Name)
+		assert.Equal(t, "default datasource", dataSource.Name)
 	})
 
 	t.Run("should not return default datasource of other organisation", func(t *testing.T) {
 		db := db.InitTestDB(t)
 		ss := SqlStore{db: db}
 		query := datasources.GetDefaultDataSourceQuery{OrgID: 1}
-		err := ss.GetDefaultDataSource(context.Background(), &query)
+		_, err := ss.GetDefaultDataSource(context.Background(), &query)
 		require.Error(t, err)
 		assert.True(t, errors.Is(err, datasources.ErrDataSourceNotFound))
 	})

pkg/services/export/export_ds.go

@@ -12,16 +12,16 @@ func exportDataSources(helper *commitHelper, job *gitExportJob) error {
 	cmd := &datasources.GetDataSourcesQuery{
 		OrgID: helper.orgID,
 	}
-	err := job.datasourceService.GetDataSources(helper.ctx, cmd)
+	dataSources, err := job.datasourceService.GetDataSources(helper.ctx, cmd)
 	if err != nil {
 		return nil
 	}
 
-	sort.SliceStable(cmd.Result, func(i, j int) bool {
-		return cmd.Result[i].Created.After(cmd.Result[j].Created)
+	sort.SliceStable(dataSources, func(i, j int) bool {
+		return dataSources[i].Created.After(dataSources[j].Created)
 	})
 
-	for _, ds := range cmd.Result {
+	for _, ds := range dataSources {
 		ds.OrgID = 0
 		ds.Version = 0
 		ds.SecureJsonData = map[string][]byte{

pkg/services/ngalert/api/api_configuration.go

@@ -121,11 +121,11 @@ func (srv ConfigSrv) externalAlertmanagers(ctx context.Context, orgID int64) ([]
 		OrgID: orgID,
 		Type:  datasources.DS_ALERTMANAGER,
 	}
-	err := srv.datasourceService.GetDataSourcesByType(ctx, query)
+	dataSources, err := srv.datasourceService.GetDataSourcesByType(ctx, query)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch datasources for org: %w", err)
 	}
-	for _, ds := range query.Result {
+	for _, ds := range dataSources {
 		if ds.JsonData.Get(apimodels.HandleGrafanaManagedAlerts).MustBool(false) {
 			// we don't need to build the exact URL as we only need
 			// to know if any is set

pkg/services/ngalert/sender/router.go

@@ -214,11 +214,11 @@ func (d *AlertsRouter) alertmanagersFromDatasources(orgID int64) ([]string, erro
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	err := d.datasourceService.GetDataSourcesByType(ctx, query)
+	dataSources, err := d.datasourceService.GetDataSourcesByType(ctx, query)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch datasources for org: %w", err)
 	}
-	for _, ds := range query.Result {
+	for _, ds := range dataSources {
 		if !ds.JsonData.Get(definitions.HandleGrafanaManagedAlerts).MustBool(false) {
 			continue
 		}

pkg/services/provisioning/datasources/config_reader_test.go

@@ -367,14 +367,13 @@ type spyStore struct {
 	items    []*datasources.DataSource
 }
 
-func (s *spyStore) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error {
+func (s *spyStore) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error) {
 	for _, v := range s.items {
 		if query.Name == v.Name && query.OrgID == v.OrgID {
-			query.Result = v
-			return nil
+			return v, nil
 		}
 	}
-	return datasources.ErrDataSourceNotFound
+	return nil, datasources.ErrDataSourceNotFound
 }
 
 func (s *spyStore) DeleteDataSource(ctx context.Context, cmd *datasources.DeleteDataSourceCommand) error {
@@ -388,15 +387,12 @@ func (s *spyStore) DeleteDataSource(ctx context.Context, cmd *datasources.Delete
 	return nil
 }
 
-func (s *spyStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) error {
+func (s *spyStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) (*datasources.DataSource, error) {
 	s.inserted = append(s.inserted, cmd)
-	cmd.Result = &datasources.DataSource{
-		UID: cmd.UID,
-	}
-	return nil
+	return &datasources.DataSource{UID: cmd.UID}, nil
 }
 
-func (s *spyStore) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) error {
+func (s *spyStore) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) (*datasources.DataSource, error) {
 	s.updated = append(s.updated, cmd)
-	return nil
+	return nil, nil
 }

pkg/services/provisioning/datasources/datasources.go

@@ -14,9 +14,9 @@ import (
 )
 
 type Store interface {
-	GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error
-	AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) error
-	UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) error
+	GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error)
+	AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) (*datasources.DataSource, error)
+	UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) (*datasources.DataSource, error)
 	DeleteDataSource(ctx context.Context, cmd *datasources.DeleteDataSourceCommand) error
 }
 
@@ -66,7 +66,7 @@ func (dc *DatasourceProvisioner) apply(ctx context.Context, cfg *configs) error
 
 	for _, ds := range cfg.Datasources {
 		cmd := &datasources.GetDataSourceQuery{OrgID: ds.OrgID, Name: ds.Name}
-		err := dc.store.GetDataSource(ctx, cmd)
+		dataSource, err := dc.store.GetDataSource(ctx, cmd)
 		if err != nil && !errors.Is(err, datasources.ErrDataSourceNotFound) {
 			return err
 		}
@@ -74,12 +74,13 @@ func (dc *DatasourceProvisioner) apply(ctx context.Context, cfg *configs) error
 		if errors.Is(err, datasources.ErrDataSourceNotFound) {
 			insertCmd := createInsertCommand(ds)
 			dc.log.Info("inserting datasource from configuration ", "name", insertCmd.Name, "uid", insertCmd.UID)
-			if err := dc.store.AddDataSource(ctx, insertCmd); err != nil {
+			dataSource, err := dc.store.AddDataSource(ctx, insertCmd)
+			if err != nil {
 				return err
 			}
 
 			for _, correlation := range ds.Correlations {
-				if insertCorrelationCmd, err := makeCreateCorrelationCommand(correlation, insertCmd.Result.UID, insertCmd.OrgID); err == nil {
+				if insertCorrelationCmd, err := makeCreateCorrelationCommand(correlation, dataSource.UID, insertCmd.OrgID); err == nil {
 					correlationsToInsert = append(correlationsToInsert, insertCorrelationCmd)
 				} else {
 					dc.log.Error("failed to parse correlation", "correlation", correlation)
@@ -87,22 +88,22 @@ func (dc *DatasourceProvisioner) apply(ctx context.Context, cfg *configs) error
 				}
 			}
 		} else {
-			updateCmd := createUpdateCommand(ds, cmd.Result.ID)
+			updateCmd := createUpdateCommand(ds, dataSource.ID)
 			dc.log.Debug("updating datasource from configuration", "name", updateCmd.Name, "uid", updateCmd.UID)
-			if err := dc.store.UpdateDataSource(ctx, updateCmd); err != nil {
+			if _, err := dc.store.UpdateDataSource(ctx, updateCmd); err != nil {
 				return err
 			}
 
 			if len(ds.Correlations) > 0 {
 				if err := dc.correlationsStore.DeleteCorrelationsBySourceUID(ctx, correlations.DeleteCorrelationsBySourceUIDCommand{
-					SourceUID: cmd.Result.UID,
+					SourceUID: dataSource.UID,
 				}); err != nil {
 					return err
 				}
 			}
 
 			for _, correlation := range ds.Correlations {
-				if insertCorrelationCmd, err := makeCreateCorrelationCommand(correlation, cmd.Result.UID, updateCmd.OrgID); err == nil {
+				if insertCorrelationCmd, err := makeCreateCorrelationCommand(correlation, dataSource.UID, updateCmd.OrgID); err == nil {
 					correlationsToInsert = append(correlationsToInsert, insertCorrelationCmd)
 				} else {
 					dc.log.Error("failed to parse correlation", "correlation", correlation)
@@ -180,7 +181,8 @@ func (dc *DatasourceProvisioner) deleteDatasources(ctx context.Context, dsToDele
 	for _, ds := range dsToDelete {
 		cmd := &datasources.DeleteDataSourceCommand{OrgID: ds.OrgID, Name: ds.Name}
 		getDsQuery := &datasources.GetDataSourceQuery{Name: ds.Name, OrgID: ds.OrgID}
-		if err := dc.store.GetDataSource(ctx, getDsQuery); err != nil && !errors.Is(err, datasources.ErrDataSourceNotFound) {
+		dataSource, err := dc.store.GetDataSource(ctx, getDsQuery)
+		if err != nil && !errors.Is(err, datasources.ErrDataSourceNotFound) {
 			return err
 		}
 
@@ -188,15 +190,15 @@ func (dc *DatasourceProvisioner) deleteDatasources(ctx context.Context, dsToDele
 			return err
 		}
 
-		if getDsQuery.Result != nil {
+		if dataSource != nil {
 			if err := dc.correlationsStore.DeleteCorrelationsBySourceUID(ctx, correlations.DeleteCorrelationsBySourceUIDCommand{
-				SourceUID: getDsQuery.Result.UID,
+				SourceUID: dataSource.UID,
 			}); err != nil {
 				return err
 			}
 
 			if err := dc.correlationsStore.DeleteCorrelationsByTargetUID(ctx, correlations.DeleteCorrelationsByTargetUIDCommand{
-				TargetUID: getDsQuery.Result.UID,
+				TargetUID: dataSource.UID,
 			}); err != nil {
 				return err
 			}

pkg/services/publicdashboards/api/query_test.go

@@ -267,7 +267,7 @@ func TestIntegrationUnauthenticatedUserCanGetPubdashPanelQueryData(t *testing.T)
 	cacheService := datasourcesService.ProvideCacheService(localcache.ProvideService(), db)
 	qds := buildQueryDataService(t, cacheService, nil, db)
 	dsStore := datasourcesService.CreateStore(db, log.New("publicdashboards.test"))
-	_ = dsStore.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
+	_, _ = dsStore.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
 		UID:      "ds1",
 		OrgID:    1,
 		Name:     "laban",

pkg/services/secrets/kvstore/migrations/datasource_mig.go

@@ -68,7 +68,7 @@ func (s *DataSourceSecretMigrationService) Migrate(ctx context.Context) error {
 
 			// Secrets are set by the update data source function if the SecureJsonData is set in the command
 			// Secrets are deleted by the update data source function if the disableSecretsCompatibility flag is enabled
-			err = s.dataSourcesService.UpdateDataSource(ctx, &datasources.UpdateDataSourceCommand{
+			_, err = s.dataSourcesService.UpdateDataSource(ctx, &datasources.UpdateDataSourceCommand{
 				ID:             ds.ID,
 				OrgID:          ds.OrgID,
 				UID:            ds.UID,

pkg/services/secrets/kvstore/migrations/datasource_mig_test.go

@@ -46,7 +46,7 @@ func TestMigrate(t *testing.T) {
 		ds := dsservice.CreateStore(sqlStore, log.NewNopLogger())
 		dataSourceName := "Test"
 		dataSourceOrg := int64(1)
-		err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
+		_, err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
 			OrgID:  dataSourceOrg,
 			Name:   dataSourceName,
 			Type:   datasources.DS_MYSQL,
@@ -60,10 +60,10 @@ func TestMigrate(t *testing.T) {
 
 		// Check if the secret json data was added
 		query := &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
-		err = ds.GetDataSource(context.Background(), query)
+		dataSource, err := ds.GetDataSource(context.Background(), query)
 		assert.NoError(t, err)
-		assert.NotNil(t, query.Result)
-		assert.NotEmpty(t, query.Result.SecureJsonData)
+		assert.NotNil(t, dataSource)
+		assert.NotEmpty(t, dataSource.SecureJsonData)
 
 		// Check if the migration status key is empty
 		value, exist, err := kvStore.Get(context.Background(), 0, secretskvs.DataSourceSecretType, secretMigrationStatusKey)
@@ -83,10 +83,10 @@ func TestMigrate(t *testing.T) {
 
 		// Check if the secure json data was deleted
 		query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
-		err = ds.GetDataSource(context.Background(), query)
+		dataSource, err = ds.GetDataSource(context.Background(), query)
 		assert.NoError(t, err)
-		assert.NotNil(t, query.Result)
-		assert.Empty(t, query.Result.SecureJsonData)
+		assert.NotNil(t, dataSource)
+		assert.Empty(t, dataSource.SecureJsonData)
 
 		// Check if the secret was added to the secret store
 		value, exist, err = secretsStore.Get(context.Background(), dataSourceOrg, dataSourceName, secretskvs.DataSourceSecretType)
@@ -112,7 +112,7 @@ func TestMigrate(t *testing.T) {
 		dataSourceOrg := int64(1)
 
 		// Add test data source
-		err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
+		_, err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
 			OrgID:  dataSourceOrg,
 			Name:   dataSourceName,
 			Type:   datasources.DS_MYSQL,
@@ -126,10 +126,10 @@ func TestMigrate(t *testing.T) {
 
 		// Check if the secret json data was added
 		query := &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
-		err = ds.GetDataSource(context.Background(), query)
+		dataSource, err := ds.GetDataSource(context.Background(), query)
 		assert.NoError(t, err)
-		assert.NotNil(t, query.Result)
-		assert.NotEmpty(t, query.Result.SecureJsonData)
+		assert.NotNil(t, dataSource)
+		assert.NotEmpty(t, dataSource.SecureJsonData)
 
 		// Check if the migration status key is empty
 		value, exist, err := kvStore.Get(context.Background(), 0, secretskvs.DataSourceSecretType, secretMigrationStatusKey)
@@ -149,10 +149,10 @@ func TestMigrate(t *testing.T) {
 
 		// Check if the secure json data was maintained for compatibility
 		query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
-		err = ds.GetDataSource(context.Background(), query)
+		dataSource, err = ds.GetDataSource(context.Background(), query)
 		assert.NoError(t, err)
-		assert.NotNil(t, query.Result)
-		assert.NotEmpty(t, query.Result.SecureJsonData)
+		assert.NotNil(t, dataSource)
+		assert.NotEmpty(t, dataSource.SecureJsonData)
 
 		// Check if the secret was added to the secret store
 		value, exist, err = secretsStore.Get(context.Background(), dataSourceOrg, dataSourceName, secretskvs.DataSourceSecretType)
@@ -180,7 +180,7 @@ func TestMigrate(t *testing.T) {
 		dataSourceOrg := int64(1)
 
 		// Add test data source
-		err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
+		_, err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
 			OrgID:  dataSourceOrg,
 			Name:   dataSourceName,
 			Type:   datasources.DS_MYSQL,
@@ -194,10 +194,10 @@ func TestMigrate(t *testing.T) {
 
 		// Check if the secret json data was added
 		query := &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
-		err = ds.GetDataSource(context.Background(), query)
+		dataSource, err := ds.GetDataSource(context.Background(), query)
 		assert.NoError(t, err)
-		assert.NotNil(t, query.Result)
-		assert.NotEmpty(t, query.Result.SecureJsonData)
+		assert.NotNil(t, dataSource)
+		assert.NotEmpty(t, dataSource.SecureJsonData)
 
 		// Check if the migration status key is empty
 		value, exist, err := kvStore.Get(context.Background(), 0, secretskvs.DataSourceSecretType, secretMigrationStatusKey)
@@ -217,10 +217,10 @@ func TestMigrate(t *testing.T) {
 
 		// Check if the secure json data was deleted
 		query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
-		err = ds.GetDataSource(context.Background(), query)
+		dataSource, err = ds.GetDataSource(context.Background(), query)
 		assert.NoError(t, err)
-		assert.NotNil(t, query.Result)
-		assert.Empty(t, query.Result.SecureJsonData)
+		assert.NotNil(t, dataSource)
+		assert.Empty(t, dataSource.SecureJsonData)
 
 		// Check if the secret was added to the secret store
 		value, exist, err = secretsStore.Get(context.Background(), dataSourceOrg, dataSourceName, secretskvs.DataSourceSecretType)
@@ -241,10 +241,10 @@ func TestMigrate(t *testing.T) {
 
 		// Check if the secure json data was re-added for compatibility
 		query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
-		err = ds.GetDataSource(context.Background(), query)
+		dataSource, err = ds.GetDataSource(context.Background(), query)
 		assert.NoError(t, err)
-		assert.NotNil(t, query.Result)
-		assert.NotEmpty(t, query.Result.SecureJsonData)
+		assert.NotNil(t, dataSource)
+		assert.NotEmpty(t, dataSource.SecureJsonData)
 
 		// Check if the secret was added to the secret store
 		value, exist, err = secretsStore.Get(context.Background(), dataSourceOrg, dataSourceName, secretskvs.DataSourceSecretType)
@@ -271,7 +271,7 @@ func TestMigrate(t *testing.T) {
 		dataSourceOrg := int64(1)
 
 		// Add test data source
-		err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
+		_, err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
 			OrgID:  dataSourceOrg,
 			Name:   dataSourceName,
 			Type:   datasources.DS_MYSQL,
@@ -285,10 +285,10 @@ func TestMigrate(t *testing.T) {
 
 		// Check if the secret json data was added
 		query := &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
-		err = ds.GetDataSource(context.Background(), query)
+		dataSource, err := ds.GetDataSource(context.Background(), query)
 		assert.NoError(t, err)
-		assert.NotNil(t, query.Result)
-		assert.NotEmpty(t, query.Result.SecureJsonData)
+		assert.NotNil(t, dataSource)
+		assert.NotEmpty(t, dataSource.SecureJsonData)
 
 		// Check if the migration status key is empty
 		value, exist, err := kvStore.Get(context.Background(), 0, secretskvs.DataSourceSecretType, secretMigrationStatusKey)
@@ -308,10 +308,10 @@ func TestMigrate(t *testing.T) {
 
 		// Check if the secure json data was maintained for compatibility
 		query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
-		err = ds.GetDataSource(context.Background(), query)
+		dataSource, err = ds.GetDataSource(context.Background(), query)
 		assert.NoError(t, err)
-		assert.NotNil(t, query.Result)
-		assert.NotEmpty(t, query.Result.SecureJsonData)
+		assert.NotNil(t, dataSource)
+		assert.NotEmpty(t, dataSource.SecureJsonData)
 
 		// Check if the secret was added to the secret store
 		value, exist, err = secretsStore.Get(context.Background(), dataSourceOrg, dataSourceName, secretskvs.DataSourceSecretType)
@@ -332,10 +332,10 @@ func TestMigrate(t *testing.T) {
 
 		// Check if the secure json data was deleted
 		query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
-		err = ds.GetDataSource(context.Background(), query)
+		dataSource, err = ds.GetDataSource(context.Background(), query)
 		assert.NoError(t, err)
-		assert.NotNil(t, query.Result)
-		assert.Empty(t, query.Result.SecureJsonData)
+		assert.NotNil(t, dataSource)
+		assert.Empty(t, dataSource.SecureJsonData)
 
 		// Check if the secret was added to the secret store
 		value, exist, err = secretsStore.Get(context.Background(), dataSourceOrg, dataSourceName, secretskvs.DataSourceSecretType)

pkg/tests/api/alerting/api_backtesting_test.go

@@ -66,7 +66,7 @@ func TestBacktesting(t *testing.T) {
 			UserID: userId,
 			OrgID:  1,
 		}
-		err := env.Server.HTTPServer.DataSourcesService.AddDataSource(context.Background(), dsCmd)
+		_, err := env.Server.HTTPServer.DataSourcesService.AddDataSource(context.Background(), dsCmd)
 		require.NoError(t, err)
 		break
 	}

pkg/tests/api/azuremonitor/azuremonitor_test.go

@@ -64,7 +64,7 @@ func TestIntegrationAzureMonitor(t *testing.T) {
 	}
 
 	uid := "azuremonitor"
-	err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
+	_, err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
 		OrgID:          1,
 		Access:         datasources.DS_ACCESS_PROXY,
 		Name:           "Azure Monitor",

pkg/tests/api/correlations/common_test.go

@@ -149,11 +149,12 @@ func (c TestContext) createUser(cmd user.CreateUserCommand) {
 	require.NoError(c.t, err)
 }
 
-func (c TestContext) createDs(cmd *datasources.AddDataSourceCommand) {
+func (c TestContext) createDs(cmd *datasources.AddDataSourceCommand) *datasources.DataSource {
 	c.t.Helper()
 
-	err := c.env.Server.HTTPServer.DataSourcesService.AddDataSource(context.Background(), cmd)
+	dataSource, err := c.env.Server.HTTPServer.DataSourcesService.AddDataSource(context.Background(), cmd)
 	require.NoError(c.t, err)
+	return dataSource
 }
 
 func (c TestContext) createCorrelation(cmd correlations.CreateCorrelationCommand) correlations.Correlation {

pkg/tests/api/correlations/correlations_create_test.go

@@ -47,16 +47,16 @@ func TestIntegrationCreateCorrelation(t *testing.T) {
 		ReadOnly: true,
 		OrgID:    1,
 	}
-	ctx.createDs(createDsCommand)
-	readOnlyDS := createDsCommand.Result.UID
+	dataSource := ctx.createDs(createDsCommand)
+	readOnlyDS := dataSource.UID
 
 	createDsCommand = &datasources.AddDataSourceCommand{
 		Name:  "writable",
 		Type:  "loki",
 		OrgID: 1,
 	}
-	ctx.createDs(createDsCommand)
-	writableDs := createDsCommand.Result.UID
+	dataSource = ctx.createDs(createDsCommand)
+	writableDs := dataSource.UID
 
 	t.Run("Unauthenticated users shouldn't be able to create correlations", func(t *testing.T) {
 		res := ctx.Post(PostParams{

pkg/tests/api/correlations/correlations_delete_test.go

@@ -47,17 +47,17 @@ func TestIntegrationDeleteCorrelation(t *testing.T) {
 		ReadOnly: true,
 		OrgID:    1,
 	}
-	ctx.createDs(createDsCommand)
-	readOnlyDS := createDsCommand.Result.UID
+	dataSource := ctx.createDs(createDsCommand)
+	readOnlyDS := dataSource.UID
 
 	createDsCommand = &datasources.AddDataSourceCommand{
 		Name:  "writable",
 		Type:  "loki",
 		OrgID: 1,
 	}
-	ctx.createDs(createDsCommand)
-	writableDs := createDsCommand.Result.UID
-	writableDsOrgId := createDsCommand.Result.OrgID
+	dataSource = ctx.createDs(createDsCommand)
+	writableDs := dataSource.UID
+	writableDsOrgId := dataSource.OrgID
 
 	t.Run("Unauthenticated users shouldn't be able to delete correlations", func(t *testing.T) {
 		res := ctx.Delete(DeleteParams{

pkg/tests/api/correlations/correlations_read_test.go

@@ -70,8 +70,7 @@ func TestIntegrationReadCorrelation(t *testing.T) {
 		Type:  "loki",
 		OrgID: 1,
 	}
-	ctx.createDs(createDsCommand)
-	dsWithCorrelations := createDsCommand.Result
+	dsWithCorrelations := ctx.createDs(createDsCommand)
 	correlation := ctx.createCorrelation(correlations.CreateCorrelationCommand{
 		SourceUID: dsWithCorrelations.UID,
 		TargetUID: &dsWithCorrelations.UID,
@@ -88,8 +87,7 @@ func TestIntegrationReadCorrelation(t *testing.T) {
 		Type:  "loki",
 		OrgID: 1,
 	}
-	ctx.createDs(createDsCommand)
-	dsWithoutCorrelations := createDsCommand.Result
+	dsWithoutCorrelations := ctx.createDs(createDsCommand)
 
 	// This creates 2 records in the correlation table that should never be returned by the API.
 	// Given all tests in this file work on the assumption that only a single correlation exists,

pkg/tests/api/correlations/correlations_update_test.go

@@ -47,17 +47,17 @@ func TestIntegrationUpdateCorrelation(t *testing.T) {
 		ReadOnly: true,
 		OrgID:    1,
 	}
-	ctx.createDs(createDsCommand)
-	readOnlyDS := createDsCommand.Result.UID
+	dataSource := ctx.createDs(createDsCommand)
+	readOnlyDS := dataSource.UID
 
 	createDsCommand = &datasources.AddDataSourceCommand{
 		Name:  "writable",
 		Type:  "loki",
 		OrgID: 1,
 	}
-	ctx.createDs(createDsCommand)
-	writableDs := createDsCommand.Result.UID
-	writableDsOrgId := createDsCommand.Result.OrgID
+	dataSource = ctx.createDs(createDsCommand)
+	writableDs := dataSource.UID
+	writableDsOrgId := dataSource.OrgID
 
 	t.Run("Unauthenticated users shouldn't be able to update correlations", func(t *testing.T) {
 		res := ctx.Patch(PatchParams{

pkg/tests/api/elasticsearch/elasticsearch_test.go

@@ -56,7 +56,7 @@ func TestIntegrationElasticsearch(t *testing.T) {
 	}
 
 	uid := "es"
-	err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
+	_, err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
 		OrgID:          1,
 		Access:         datasources.DS_ACCESS_PROXY,
 		Name:           "Elasticsearch",

pkg/tests/api/graphite/graphite_test.go

@@ -54,7 +54,7 @@ func TestIntegrationGraphite(t *testing.T) {
 	}
 
 	uid := "graphite"
-	err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
+	_, err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
 		OrgID:          1,
 		Access:         datasources.DS_ACCESS_PROXY,
 		Name:           "graphite",

pkg/tests/api/influxdb/influxdb_test.go

@@ -54,7 +54,7 @@ func TestIntegrationInflux(t *testing.T) {
 	}
 
 	uid := "influxdb"
-	err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
+	_, err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
 		OrgID:          1,
 		Access:         datasources.DS_ACCESS_PROXY,
 		Name:           "InfluxDB",

pkg/tests/api/loki/loki_test.go

@@ -54,7 +54,7 @@ func TestIntegrationLoki(t *testing.T) {
 	}
 
 	uid := "loki"
-	err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
+	_, err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
 		OrgID:          1,
 		Access:         datasources.DS_ACCESS_PROXY,
 		Name:           "Loki",

pkg/tests/api/opentdsb/opentdsb_test.go

@@ -54,7 +54,7 @@ func TestIntegrationOpenTSDB(t *testing.T) {
 	}
 
 	uid := "influxdb"
-	err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
+	_, err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
 		OrgID:          1,
 		Access:         datasources.DS_ACCESS_PROXY,
 		Name:           "opentsdb",

pkg/tests/api/plugins/backendplugin/backendplugin_test.go

@@ -302,17 +302,17 @@ func newTestScenario(t *testing.T, name string, opts []testScenarioOption, callb
 	tsCtx.modifyIncomingRequest = in.modifyIncomingRequest
 	tsCtx.testEnv.OAuthTokenService.Token = in.token
 
-	err = testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, cmd)
+	_, err = testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, cmd)
 	require.NoError(t, err)
 
 	getDataSourceQuery := &datasources.GetDataSourceQuery{
 		OrgID: 1,
 		UID:   tsCtx.uid,
 	}
-	err = testEnv.Server.HTTPServer.DataSourcesService.GetDataSource(ctx, getDataSourceQuery)
+	dataSource, err := testEnv.Server.HTTPServer.DataSourcesService.GetDataSource(ctx, getDataSourceQuery)
 	require.NoError(t, err)
 
-	rt, err := testEnv.Server.HTTPServer.DataSourcesService.GetHTTPTransport(ctx, getDataSourceQuery.Result, testEnv.HTTPClientProvider)
+	rt, err := testEnv.Server.HTTPServer.DataSourcesService.GetHTTPTransport(ctx, dataSource, testEnv.HTTPClientProvider)
 	require.NoError(t, err)
 
 	tsCtx.rt = rt

pkg/tests/api/prometheus/prometheus_test.go

@@ -55,7 +55,7 @@ func TestIntegrationPrometheus(t *testing.T) {
 	}
 
 	uid := "prometheus"
-	err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
+	_, err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
 		OrgID:          1,
 		Access:         datasources.DS_ACCESS_PROXY,
 		Name:           "Prometheus",