From 01a4e6705ac0ee9315a481cbcc20a21515d0d342 Mon Sep 17 00:00:00 2001 From: rot1024 Date: Wed, 2 Feb 2022 13:30:49 +0900 Subject: [PATCH] refactor: graphql resolvers (#105) * refactor gql * refactor context * rename --- internal/adapter/context.go | 84 +++++++ internal/adapter/gql/context.go | 65 +++--- internal/adapter/gql/loader.go | 29 +-- internal/adapter/gql/resolver.go | 12 +- internal/adapter/gql/resolver_asset.go | 5 +- internal/adapter/gql/resolver_dataset.go | 25 +- .../adapter/gql/resolver_dataset_schema.go | 23 +- internal/adapter/gql/resolver_layer.go | 218 ++++-------------- .../adapter/gql/resolver_mutation_asset.go | 10 +- .../adapter/gql/resolver_mutation_dataset.go | 40 +--- .../adapter/gql/resolver_mutation_layer.go | 65 ++---- .../adapter/gql/resolver_mutation_project.go | 20 +- .../adapter/gql/resolver_mutation_property.go | 45 +--- .../adapter/gql/resolver_mutation_scene.go | 59 ++--- internal/adapter/gql/resolver_mutation_tag.go | 30 +-- .../adapter/gql/resolver_mutation_team.go | 30 +-- .../adapter/gql/resolver_mutation_user.go | 20 +- internal/adapter/gql/resolver_plugin.go | 36 +-- internal/adapter/gql/resolver_project.go | 10 +- internal/adapter/gql/resolver_property.go | 153 +++--------- .../adapter/gql/resolver_property_schema.go | 26 +-- internal/adapter/gql/resolver_query.go | 88 ++----- internal/adapter/gql/resolver_scene.go | 65 ++---- internal/adapter/gql/resolver_tag.go | 46 +--- internal/adapter/gql/resolver_team.go | 15 +- internal/adapter/gql/resolver_user.go | 10 +- internal/adapter/gql/tracer.go | 151 ------------ internal/app/auth.go | 36 +-- internal/app/graphql.go | 46 ++-- internal/app/private.go | 12 +- internal/app/public.go | 8 +- 31 files changed, 372 insertions(+), 1110 deletions(-) create mode 100644 internal/adapter/context.go delete mode 100644 internal/adapter/gql/tracer.go diff --git a/internal/adapter/context.go b/internal/adapter/context.go new file mode 100644 index 00000000..e8598033 --- /dev/null +++ b/internal/adapter/context.go @@ -0,0 +1,84 @@ +package adapter + +import ( + "context" + + "github.com/reearth/reearth-backend/internal/usecase" + "github.com/reearth/reearth-backend/internal/usecase/interfaces" + "github.com/reearth/reearth-backend/pkg/user" +) + +type ContextKey string + +const ( + contextUser ContextKey = "user" + contextOperator ContextKey = "operator" + contextSub ContextKey = "sub" + contextUsecases ContextKey = "usecases" +) + +func AttachUser(ctx context.Context, u *user.User) context.Context { + return context.WithValue(ctx, contextUser, u) +} + +func AttachOperator(ctx context.Context, o *usecase.Operator) context.Context { + return context.WithValue(ctx, contextOperator, o) +} + +func AttachSub(ctx context.Context, sub string) context.Context { + return context.WithValue(ctx, contextSub, sub) +} + +func AttachUsecases(ctx context.Context, u *interfaces.Container) context.Context { + ctx = context.WithValue(ctx, contextUsecases, u) + return ctx +} + +func User(ctx context.Context) *user.User { + if v := ctx.Value(contextUser); v != nil { + if u, ok := v.(*user.User); ok { + return u + } + } + return nil +} + +func Lang(ctx context.Context, lang *string) string { + if lang != nil && *lang != "" { + return *lang + } + + u := User(ctx) + if u == nil { + return "en" // default language + } + + l := u.Lang() + if l.IsRoot() { + return "en" // default language + } + + return l.String() +} + +func Operator(ctx context.Context) *usecase.Operator { + if v := ctx.Value(contextOperator); v != nil { + if v2, ok := v.(*usecase.Operator); ok { + return v2 + } + } + return nil +} + +func Sub(ctx context.Context) string { + if v := ctx.Value(contextSub); v != nil { + if v2, ok := v.(string); ok { + return v2 + } + } + return "" +} + +func Usecases(ctx context.Context) *interfaces.Container { + return ctx.Value(contextUsecases).(*interfaces.Container) +} diff --git a/internal/adapter/gql/context.go b/internal/adapter/gql/context.go index df46435b..fd9a6390 100644 --- a/internal/adapter/gql/context.go +++ b/internal/adapter/gql/context.go @@ -3,59 +3,54 @@ package gql import ( "context" + "github.com/reearth/reearth-backend/internal/adapter" "github.com/reearth/reearth-backend/internal/usecase" + "github.com/reearth/reearth-backend/internal/usecase/interfaces" "github.com/reearth/reearth-backend/pkg/user" ) type ContextKey string const ( - ContextUser ContextKey = "user" - ContextOperator ContextKey = "operator" - ContextSub ContextKey = "sub" + contextLoaders ContextKey = "loaders" + contextDataloaders ContextKey = "dataloaders" ) +func AttachUsecases(ctx context.Context, u *interfaces.Container, enableDataLoaders bool) context.Context { + loaders := NewLoaders(u) + dataloaders := loaders.DataLoadersWith(ctx, enableDataLoaders) + + ctx = adapter.AttachUsecases(ctx, u) + ctx = context.WithValue(ctx, contextLoaders, loaders) + ctx = context.WithValue(ctx, contextDataloaders, dataloaders) + + return ctx +} + func getUser(ctx context.Context) *user.User { - if v := ctx.Value(ContextUser); v != nil { - if u, ok := v.(*user.User); ok { - return u - } - } - return nil + return adapter.User(ctx) } func getLang(ctx context.Context, lang *string) string { - if lang != nil && *lang != "" { - return *lang - } + return adapter.Lang(ctx, lang) +} - u := getUser(ctx) - if u == nil { - return "en" // default language - } +func getOperator(ctx context.Context) *usecase.Operator { + return adapter.Operator(ctx) +} - l := u.Lang() - if l.IsRoot() { - return "en" // default language - } +func getSub(ctx context.Context) string { + return adapter.Sub(ctx) +} - return l.String() +func usecases(ctx context.Context) *interfaces.Container { + return adapter.Usecases(ctx) } -func getOperator(ctx context.Context) *usecase.Operator { - if v := ctx.Value(ContextOperator); v != nil { - if v2, ok := v.(*usecase.Operator); ok { - return v2 - } - } - return nil +func loaders(ctx context.Context) *Loaders { + return ctx.Value(contextLoaders).(*Loaders) } -func getSub(ctx context.Context) string { - if v := ctx.Value(ContextSub); v != nil { - if v2, ok := v.(string); ok { - return v2 - } - } - return "" +func dataloaders(ctx context.Context) *DataLoaders { + return ctx.Value(contextDataloaders).(*DataLoaders) } diff --git a/internal/adapter/gql/loader.go b/internal/adapter/gql/loader.go index c2df08e3..78c50ef9 100644 --- a/internal/adapter/gql/loader.go +++ b/internal/adapter/gql/loader.go @@ -45,9 +45,12 @@ type DataLoaders struct { TagGroup TagGroupDataLoader } -func NewLoaders(usecases interfaces.Container) Loaders { - return Loaders{ - usecases: usecases, +func NewLoaders(usecases *interfaces.Container) *Loaders { + if usecases == nil { + return nil + } + return &Loaders{ + usecases: *usecases, Asset: NewAssetLoader(usecases.Asset), Dataset: NewDatasetLoader(usecases.Dataset), Layer: NewLayerLoader(usecases.Layer), @@ -61,15 +64,15 @@ func NewLoaders(usecases interfaces.Container) Loaders { } } -func (l Loaders) DataLoadersWith(ctx context.Context, enabled bool) DataLoaders { +func (l Loaders) DataLoadersWith(ctx context.Context, enabled bool) *DataLoaders { if enabled { return l.DataLoaders(ctx) } return l.OrdinaryDataLoaders(ctx) } -func (l Loaders) DataLoaders(ctx context.Context) DataLoaders { - return DataLoaders{ +func (l Loaders) DataLoaders(ctx context.Context) *DataLoaders { + return &DataLoaders{ Asset: l.Asset.DataLoader(ctx), Dataset: l.Dataset.DataLoader(ctx), DatasetSchema: l.Dataset.SchemaDataLoader(ctx), @@ -89,8 +92,8 @@ func (l Loaders) DataLoaders(ctx context.Context) DataLoaders { } } -func (l Loaders) OrdinaryDataLoaders(ctx context.Context) DataLoaders { - return DataLoaders{ +func (l Loaders) OrdinaryDataLoaders(ctx context.Context) *DataLoaders { + return &DataLoaders{ Asset: l.Asset.OrdinaryDataLoader(ctx), Dataset: l.Dataset.OrdinaryDataLoader(ctx), DatasetSchema: l.Dataset.SchemaOrdinaryDataLoader(ctx), @@ -109,13 +112,3 @@ func (l Loaders) OrdinaryDataLoaders(ctx context.Context) DataLoaders { TagGroup: l.Tag.GroupDataLoader(ctx), } } - -type dataLoadersKey struct{} - -func DataLoadersFromContext(ctx context.Context) DataLoaders { - return ctx.Value(dataLoadersKey{}).(DataLoaders) -} - -func DataLoadersKey() interface{} { - return dataLoadersKey{} -} diff --git a/internal/adapter/gql/resolver.go b/internal/adapter/gql/resolver.go index e708250a..ac987de3 100644 --- a/internal/adapter/gql/resolver.go +++ b/internal/adapter/gql/resolver.go @@ -4,8 +4,6 @@ package gql import ( "errors" - - "github.com/reearth/reearth-backend/internal/usecase/interfaces" ) // THIS CODE IS A STARTING POINT ONLY. IT WILL NOT BE UPDATED WITH SCHEMA CHANGES. @@ -14,15 +12,11 @@ var ErrNotImplemented = errors.New("not impleneted yet") var ErrUnauthorized = errors.New("unauthorized") type Resolver struct { - usecases interfaces.Container - loaders Loaders - debug bool + debug bool } -func NewResolver(loaders Loaders, debug bool) ResolverRoot { +func NewResolver(debug bool) ResolverRoot { return &Resolver{ - usecases: loaders.usecases, - loaders: loaders, - debug: debug, + debug: debug, } } diff --git a/internal/adapter/gql/resolver_asset.go b/internal/adapter/gql/resolver_asset.go index b10cd1c4..a3938eaf 100644 --- a/internal/adapter/gql/resolver_asset.go +++ b/internal/adapter/gql/resolver_asset.go @@ -14,8 +14,5 @@ func (r *Resolver) Asset() AssetResolver { type assetResolver struct{ *Resolver } func (r *assetResolver) Team(ctx context.Context, obj *gqlmodel.Asset) (*gqlmodel.Team, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Team.Load(id.TeamID(obj.TeamID)) + return dataloaders(ctx).Team.Load(id.TeamID(obj.TeamID)) } diff --git a/internal/adapter/gql/resolver_dataset.go b/internal/adapter/gql/resolver_dataset.go index 511a71d6..1002d1b4 100644 --- a/internal/adapter/gql/resolver_dataset.go +++ b/internal/adapter/gql/resolver_dataset.go @@ -18,17 +18,11 @@ func (r *Resolver) DatasetField() DatasetFieldResolver { type datasetResolver struct{ *Resolver } func (r *datasetResolver) Schema(ctx context.Context, obj *gqlmodel.Dataset) (*gqlmodel.DatasetSchema, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).DatasetSchema.Load(id.DatasetSchemaID(obj.SchemaID)) + return dataloaders(ctx).DatasetSchema.Load(id.DatasetSchemaID(obj.SchemaID)) } func (r *datasetResolver) Name(ctx context.Context, obj *gqlmodel.Dataset) (*string, error) { - exit := trace(ctx) - defer exit() - - ds, err := DataLoadersFromContext(ctx).DatasetSchema.Load(id.DatasetSchemaID(obj.SchemaID)) + ds, err := dataloaders(ctx).DatasetSchema.Load(id.DatasetSchemaID(obj.SchemaID)) if err != nil || ds == nil || ds.RepresentativeFieldID == nil { return nil, err } @@ -46,24 +40,15 @@ func (r *datasetResolver) Name(ctx context.Context, obj *gqlmodel.Dataset) (*str type datasetFieldResolver struct{ *Resolver } func (r *datasetFieldResolver) Field(ctx context.Context, obj *gqlmodel.DatasetField) (*gqlmodel.DatasetSchemaField, error) { - exit := trace(ctx) - defer exit() - - ds, err := DataLoadersFromContext(ctx).DatasetSchema.Load(id.DatasetSchemaID(obj.SchemaID)) + ds, err := dataloaders(ctx).DatasetSchema.Load(id.DatasetSchemaID(obj.SchemaID)) return ds.Field(obj.FieldID), err } func (r *datasetFieldResolver) Schema(ctx context.Context, obj *gqlmodel.DatasetField) (*gqlmodel.DatasetSchema, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).DatasetSchema.Load(id.DatasetSchemaID(obj.SchemaID)) + return dataloaders(ctx).DatasetSchema.Load(id.DatasetSchemaID(obj.SchemaID)) } func (r *datasetFieldResolver) ValueRef(ctx context.Context, obj *gqlmodel.DatasetField) (*gqlmodel.Dataset, error) { - exit := trace(ctx) - defer exit() - if obj.Value == nil { return nil, nil } @@ -71,5 +56,5 @@ func (r *datasetFieldResolver) ValueRef(ctx context.Context, obj *gqlmodel.Datas if !ok { return nil, nil } - return DataLoadersFromContext(ctx).Dataset.Load(id.DatasetID(idstr)) + return dataloaders(ctx).Dataset.Load(id.DatasetID(idstr)) } diff --git a/internal/adapter/gql/resolver_dataset_schema.go b/internal/adapter/gql/resolver_dataset_schema.go index 4b4e7792..d72cd953 100644 --- a/internal/adapter/gql/resolver_dataset_schema.go +++ b/internal/adapter/gql/resolver_dataset_schema.go @@ -19,16 +19,10 @@ func (r *Resolver) DatasetSchemaField() DatasetSchemaFieldResolver { type datasetSchemaResolver struct{ *Resolver } func (r *datasetSchemaResolver) Scene(ctx context.Context, obj *gqlmodel.DatasetSchema) (*gqlmodel.Scene, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Scene.Load(id.SceneID(obj.SceneID)) + return dataloaders(ctx).Scene.Load(id.SceneID(obj.SceneID)) } func (r *datasetSchemaResolver) RepresentativeField(ctx context.Context, obj *gqlmodel.DatasetSchema) (*gqlmodel.DatasetSchemaField, error) { - exit := trace(ctx) - defer exit() - if obj.RepresentativeFieldID == nil { return nil, nil } @@ -42,27 +36,18 @@ func (r *datasetSchemaResolver) RepresentativeField(ctx context.Context, obj *gq } func (r *datasetSchemaResolver) Datasets(ctx context.Context, obj *gqlmodel.DatasetSchema, first *int, last *int, after *usecase.Cursor, before *usecase.Cursor) (*gqlmodel.DatasetConnection, error) { - exit := trace(ctx) - defer exit() - - return r.loaders.Dataset.FindBySchema(ctx, obj.ID, first, last, before, after) + return loaders(ctx).Dataset.FindBySchema(ctx, obj.ID, first, last, before, after) } type datasetSchemaFieldResolver struct{ *Resolver } func (r *datasetSchemaFieldResolver) Schema(ctx context.Context, obj *gqlmodel.DatasetSchemaField) (*gqlmodel.DatasetSchema, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).DatasetSchema.Load(id.DatasetSchemaID(obj.SchemaID)) + return dataloaders(ctx).DatasetSchema.Load(id.DatasetSchemaID(obj.SchemaID)) } func (r *datasetSchemaFieldResolver) Ref(ctx context.Context, obj *gqlmodel.DatasetSchemaField) (*gqlmodel.DatasetSchema, error) { - exit := trace(ctx) - defer exit() - if obj.RefID == nil { return nil, nil } - return DataLoadersFromContext(ctx).DatasetSchema.Load(id.DatasetSchemaID(*obj.RefID)) + return dataloaders(ctx).DatasetSchema.Load(id.DatasetSchemaID(*obj.RefID)) } diff --git a/internal/adapter/gql/resolver_layer.go b/internal/adapter/gql/resolver_layer.go index 1e6ca028..adbe737a 100644 --- a/internal/adapter/gql/resolver_layer.go +++ b/internal/adapter/gql/resolver_layer.go @@ -46,17 +46,11 @@ func (r *Resolver) LayerTagGroup() LayerTagGroupResolver { type infoboxResolver struct{ *Resolver } func (r *infoboxResolver) Property(ctx context.Context, obj *gqlmodel.Infobox) (*gqlmodel.Property, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Property.Load(id.PropertyID(obj.PropertyID)) + return dataloaders(ctx).Property.Load(id.PropertyID(obj.PropertyID)) } func (r *infoboxResolver) Layer(ctx context.Context, obj *gqlmodel.Infobox) (gqlmodel.Layer, error) { - exit := trace(ctx) - defer exit() - - layer, err := DataLoadersFromContext(ctx).Layer.Load(id.LayerID(obj.LayerID)) + layer, err := dataloaders(ctx).Layer.Load(id.LayerID(obj.LayerID)) if err != nil || layer == nil { return nil, err } @@ -64,20 +58,14 @@ func (r *infoboxResolver) Layer(ctx context.Context, obj *gqlmodel.Infobox) (gql } func (r *infoboxResolver) LinkedDataset(ctx context.Context, obj *gqlmodel.Infobox) (*gqlmodel.Dataset, error) { - exit := trace(ctx) - defer exit() - if obj.LinkedDatasetID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Dataset.Load(id.DatasetID(*obj.LinkedDatasetID)) + return dataloaders(ctx).Dataset.Load(id.DatasetID(*obj.LinkedDatasetID)) } func (r *infoboxResolver) Merged(ctx context.Context, obj *gqlmodel.Infobox) (*gqlmodel.MergedInfobox, error) { - exit := trace(ctx) - defer exit() - - ml, err := r.loaders.Layer.FetchParentAndMerged(ctx, id.LayerID(obj.LayerID)) + ml, err := loaders(ctx).Layer.FetchParentAndMerged(ctx, id.LayerID(obj.LayerID)) if err != nil || ml == nil { return nil, err } @@ -85,17 +73,11 @@ func (r *infoboxResolver) Merged(ctx context.Context, obj *gqlmodel.Infobox) (*g } func (r *infoboxResolver) Scene(ctx context.Context, obj *gqlmodel.Infobox) (*gqlmodel.Scene, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Scene.Load(id.SceneID(obj.SceneID)) + return dataloaders(ctx).Scene.Load(id.SceneID(obj.SceneID)) } func (r *infoboxResolver) ScenePlugin(ctx context.Context, obj *gqlmodel.Infobox) (*gqlmodel.ScenePlugin, error) { - exit := trace(ctx) - defer exit() - - layer, err := DataLoadersFromContext(ctx).Layer.Load(id.LayerID(obj.LayerID)) + layer, err := dataloaders(ctx).Layer.Load(id.LayerID(obj.LayerID)) if err != nil || layer == nil { return nil, err } @@ -109,7 +91,7 @@ func (r *infoboxResolver) ScenePlugin(ctx context.Context, obj *gqlmodel.Infobox return nil, nil } - s, err := DataLoadersFromContext(ctx).Scene.Load(id.SceneID(obj.SceneID)) + s, err := dataloaders(ctx).Scene.Load(id.SceneID(obj.SceneID)) if err != nil { return nil, err } @@ -119,10 +101,7 @@ func (r *infoboxResolver) ScenePlugin(ctx context.Context, obj *gqlmodel.Infobox type infoboxFieldResolver struct{ *Resolver } func (r *infoboxFieldResolver) Layer(ctx context.Context, obj *gqlmodel.InfoboxField) (gqlmodel.Layer, error) { - exit := trace(ctx) - defer exit() - - layer, err := DataLoadersFromContext(ctx).Layer.Load(id.LayerID(obj.LayerID)) + layer, err := dataloaders(ctx).Layer.Load(id.LayerID(obj.LayerID)) if err != nil { return nil, err } @@ -130,10 +109,7 @@ func (r *infoboxFieldResolver) Layer(ctx context.Context, obj *gqlmodel.InfoboxF } func (r *infoboxFieldResolver) Infobox(ctx context.Context, obj *gqlmodel.InfoboxField) (*gqlmodel.Infobox, error) { - exit := trace(ctx) - defer exit() - - layer, err := DataLoadersFromContext(ctx).Layer.Load(id.LayerID(obj.LayerID)) + layer, err := dataloaders(ctx).Layer.Load(id.LayerID(obj.LayerID)) if err != nil || layer == nil { return nil, err } @@ -145,24 +121,15 @@ func (r *infoboxFieldResolver) Infobox(ctx context.Context, obj *gqlmodel.Infobo } func (r *infoboxFieldResolver) Property(ctx context.Context, obj *gqlmodel.InfoboxField) (*gqlmodel.Property, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Property.Load(id.PropertyID(obj.PropertyID)) + return dataloaders(ctx).Property.Load(id.PropertyID(obj.PropertyID)) } func (r *infoboxFieldResolver) Plugin(ctx context.Context, obj *gqlmodel.InfoboxField) (*gqlmodel.Plugin, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Plugin.Load(obj.PluginID) + return dataloaders(ctx).Plugin.Load(obj.PluginID) } func (r *infoboxFieldResolver) Extension(ctx context.Context, obj *gqlmodel.InfoboxField) (*gqlmodel.PluginExtension, error) { - exit := trace(ctx) - defer exit() - - plugin, err := DataLoadersFromContext(ctx).Plugin.Load(obj.PluginID) + plugin, err := dataloaders(ctx).Plugin.Load(obj.PluginID) if err != nil { return nil, err } @@ -170,20 +137,14 @@ func (r *infoboxFieldResolver) Extension(ctx context.Context, obj *gqlmodel.Info } func (r *infoboxFieldResolver) LinkedDataset(ctx context.Context, obj *gqlmodel.InfoboxField) (*gqlmodel.Dataset, error) { - exit := trace(ctx) - defer exit() - if obj.LinkedDatasetID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Dataset.Load(id.DatasetID(*obj.LinkedDatasetID)) + return dataloaders(ctx).Dataset.Load(id.DatasetID(*obj.LinkedDatasetID)) } func (r *infoboxFieldResolver) Merged(ctx context.Context, obj *gqlmodel.InfoboxField) (*gqlmodel.MergedInfoboxField, error) { - exit := trace(ctx) - defer exit() - - ml, err := r.loaders.Layer.FetchParentAndMerged(ctx, id.LayerID(obj.LayerID)) + ml, err := loaders(ctx).Layer.FetchParentAndMerged(ctx, id.LayerID(obj.LayerID)) if err != nil || ml == nil || ml.Infobox == nil { return nil, err } @@ -191,17 +152,11 @@ func (r *infoboxFieldResolver) Merged(ctx context.Context, obj *gqlmodel.Infobox } func (r *infoboxFieldResolver) Scene(ctx context.Context, obj *gqlmodel.InfoboxField) (*gqlmodel.Scene, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Scene.Load(id.SceneID(obj.SceneID)) + return dataloaders(ctx).Scene.Load(id.SceneID(obj.SceneID)) } func (r *infoboxFieldResolver) ScenePlugin(ctx context.Context, obj *gqlmodel.InfoboxField) (*gqlmodel.ScenePlugin, error) { - exit := trace(ctx) - defer exit() - - s, err := DataLoadersFromContext(ctx).Scene.Load(id.SceneID(obj.SceneID)) + s, err := dataloaders(ctx).Scene.Load(id.SceneID(obj.SceneID)) if err != nil { return nil, err } @@ -211,43 +166,31 @@ func (r *infoboxFieldResolver) ScenePlugin(ctx context.Context, obj *gqlmodel.In type layerGroupResolver struct{ *Resolver } func (r *layerGroupResolver) Parent(ctx context.Context, obj *gqlmodel.LayerGroup) (*gqlmodel.LayerGroup, error) { - exit := trace(ctx) - defer exit() - if obj.ParentID != nil { - return DataLoadersFromContext(ctx).LayerGroup.Load(id.LayerID(*obj.ParentID)) + return dataloaders(ctx).LayerGroup.Load(id.LayerID(*obj.ParentID)) } - return r.loaders.Layer.FetchParent(ctx, id.LayerID(obj.ID)) + return loaders(ctx).Layer.FetchParent(ctx, id.LayerID(obj.ID)) } func (r *layerGroupResolver) Property(ctx context.Context, obj *gqlmodel.LayerGroup) (*gqlmodel.Property, error) { - exit := trace(ctx) - defer exit() - if obj.PropertyID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Property.Load(id.PropertyID(*obj.PropertyID)) + return dataloaders(ctx).Property.Load(id.PropertyID(*obj.PropertyID)) } func (r *layerGroupResolver) Plugin(ctx context.Context, obj *gqlmodel.LayerGroup) (*gqlmodel.Plugin, error) { - exit := trace(ctx) - defer exit() - if obj.PluginID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Plugin.Load(*obj.PluginID) + return dataloaders(ctx).Plugin.Load(*obj.PluginID) } func (r *layerGroupResolver) Extension(ctx context.Context, obj *gqlmodel.LayerGroup) (*gqlmodel.PluginExtension, error) { - exit := trace(ctx) - defer exit() - if obj.PluginID == nil || obj.ExtensionID == nil { return nil, nil } - plugin, err := DataLoadersFromContext(ctx).Plugin.Load(*obj.PluginID) + plugin, err := dataloaders(ctx).Plugin.Load(*obj.PluginID) if err != nil { return nil, err } @@ -255,27 +198,18 @@ func (r *layerGroupResolver) Extension(ctx context.Context, obj *gqlmodel.LayerG } func (r *layerGroupResolver) ParentLayer(ctx context.Context, obj *gqlmodel.LayerItem) (*gqlmodel.LayerGroup, error) { - exit := trace(ctx) - defer exit() - - return r.loaders.Layer.FetchParent(ctx, id.LayerID(obj.ID)) + return loaders(ctx).Layer.FetchParent(ctx, id.LayerID(obj.ID)) } func (r *layerGroupResolver) LinkedDatasetSchema(ctx context.Context, obj *gqlmodel.LayerGroup) (*gqlmodel.DatasetSchema, error) { - exit := trace(ctx) - defer exit() - if obj.LinkedDatasetSchemaID == nil { return nil, nil } - return DataLoadersFromContext(ctx).DatasetSchema.Load(id.DatasetSchemaID(*obj.LinkedDatasetSchemaID)) + return dataloaders(ctx).DatasetSchema.Load(id.DatasetSchemaID(*obj.LinkedDatasetSchemaID)) } func (r *layerGroupResolver) Layers(ctx context.Context, obj *gqlmodel.LayerGroup) ([]gqlmodel.Layer, error) { - exit := trace(ctx) - defer exit() - - layers, err := DataLoadersFromContext(ctx).Layer.LoadAll(id.LayerIDsFromIDRef(obj.LayerIds)) + layers, err := dataloaders(ctx).Layer.LoadAll(id.LayerIDsFromIDRef(obj.LayerIds)) if len(err) > 0 && err[0] != nil { return nil, err[0] } @@ -283,20 +217,14 @@ func (r *layerGroupResolver) Layers(ctx context.Context, obj *gqlmodel.LayerGrou } func (r *layerGroupResolver) Scene(ctx context.Context, obj *gqlmodel.LayerGroup) (*gqlmodel.Scene, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Scene.Load(id.SceneID(obj.SceneID)) + return dataloaders(ctx).Scene.Load(id.SceneID(obj.SceneID)) } func (r *layerGroupResolver) ScenePlugin(ctx context.Context, obj *gqlmodel.LayerGroup) (*gqlmodel.ScenePlugin, error) { - exit := trace(ctx) - defer exit() - if obj.PluginID == nil { return nil, nil } - s, err := DataLoadersFromContext(ctx).Scene.Load(id.SceneID(obj.SceneID)) + s, err := dataloaders(ctx).Scene.Load(id.SceneID(obj.SceneID)) if err != nil { return nil, err } @@ -306,43 +234,31 @@ func (r *layerGroupResolver) ScenePlugin(ctx context.Context, obj *gqlmodel.Laye type layerItemResolver struct{ *Resolver } func (r *layerItemResolver) Parent(ctx context.Context, obj *gqlmodel.LayerItem) (*gqlmodel.LayerGroup, error) { - exit := trace(ctx) - defer exit() - if obj.ParentID != nil { - return DataLoadersFromContext(ctx).LayerGroup.Load(id.LayerID(*obj.ParentID)) + return dataloaders(ctx).LayerGroup.Load(id.LayerID(*obj.ParentID)) } - return r.loaders.Layer.FetchParent(ctx, id.LayerID(obj.ID)) + return loaders(ctx).Layer.FetchParent(ctx, id.LayerID(obj.ID)) } func (r *layerItemResolver) Property(ctx context.Context, obj *gqlmodel.LayerItem) (*gqlmodel.Property, error) { - exit := trace(ctx) - defer exit() - if obj.PropertyID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Property.Load(id.PropertyID(*obj.PropertyID)) + return dataloaders(ctx).Property.Load(id.PropertyID(*obj.PropertyID)) } func (r *layerItemResolver) Plugin(ctx context.Context, obj *gqlmodel.LayerItem) (*gqlmodel.Plugin, error) { - exit := trace(ctx) - defer exit() - if obj.PluginID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Plugin.Load(*obj.PluginID) + return dataloaders(ctx).Plugin.Load(*obj.PluginID) } func (r *layerItemResolver) Extension(ctx context.Context, obj *gqlmodel.LayerItem) (*gqlmodel.PluginExtension, error) { - exit := trace(ctx) - defer exit() - if obj.PluginID == nil || obj.ExtensionID == nil { return nil, nil } - plugin, err := DataLoadersFromContext(ctx).Plugin.Load(*obj.PluginID) + plugin, err := dataloaders(ctx).Plugin.Load(*obj.PluginID) if err != nil { return nil, err } @@ -350,40 +266,28 @@ func (r *layerItemResolver) Extension(ctx context.Context, obj *gqlmodel.LayerIt } func (r *layerItemResolver) LinkedDataset(ctx context.Context, obj *gqlmodel.LayerItem) (*gqlmodel.Dataset, error) { - exit := trace(ctx) - defer exit() - if obj.LinkedDatasetID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Dataset.Load(id.DatasetID(*obj.LinkedDatasetID)) + return dataloaders(ctx).Dataset.Load(id.DatasetID(*obj.LinkedDatasetID)) } func (r *layerItemResolver) Merged(ctx context.Context, obj *gqlmodel.LayerItem) (*gqlmodel.MergedLayer, error) { - exit := trace(ctx) - defer exit() - if obj.ParentID == nil { - return r.loaders.Layer.FetchParentAndMerged(ctx, id.LayerID(obj.ID)) + return loaders(ctx).Layer.FetchParentAndMerged(ctx, id.LayerID(obj.ID)) } - return r.loaders.Layer.FetchMerged(ctx, id.LayerID(obj.ID), id.LayerIDFromRefID(obj.ParentID)) + return loaders(ctx).Layer.FetchMerged(ctx, id.LayerID(obj.ID), id.LayerIDFromRefID(obj.ParentID)) } func (r *layerItemResolver) Scene(ctx context.Context, obj *gqlmodel.LayerItem) (*gqlmodel.Scene, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Scene.Load(id.SceneID(obj.SceneID)) + return dataloaders(ctx).Scene.Load(id.SceneID(obj.SceneID)) } func (r *layerItemResolver) ScenePlugin(ctx context.Context, obj *gqlmodel.LayerItem) (*gqlmodel.ScenePlugin, error) { - exit := trace(ctx) - defer exit() - if obj.PluginID == nil { return nil, nil } - s, err := DataLoadersFromContext(ctx).Scene.Load(id.SceneID(obj.SceneID)) + s, err := dataloaders(ctx).Scene.Load(id.SceneID(obj.SceneID)) if err != nil { return nil, err } @@ -393,55 +297,37 @@ func (r *layerItemResolver) ScenePlugin(ctx context.Context, obj *gqlmodel.Layer type mergedLayerResolver struct{ *Resolver } func (r *mergedLayerResolver) Original(ctx context.Context, obj *gqlmodel.MergedLayer) (*gqlmodel.LayerItem, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).LayerItem.Load(id.LayerID(obj.OriginalID)) + return dataloaders(ctx).LayerItem.Load(id.LayerID(obj.OriginalID)) } func (r *mergedLayerResolver) Parent(ctx context.Context, obj *gqlmodel.MergedLayer) (*gqlmodel.LayerGroup, error) { - exit := trace(ctx) - defer exit() - if obj.ParentID == nil { return nil, nil } - return DataLoadersFromContext(ctx).LayerGroup.Load(id.LayerID(*obj.ParentID)) + return dataloaders(ctx).LayerGroup.Load(id.LayerID(*obj.ParentID)) } func (r *mergedLayerResolver) Scene(ctx context.Context, obj *gqlmodel.MergedLayer) (*gqlmodel.Scene, error) { - exit := trace(ctx) - defer exit() - if obj.ParentID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Scene.Load(id.SceneID(obj.SceneID)) + return dataloaders(ctx).Scene.Load(id.SceneID(obj.SceneID)) } type mergedInfoboxResolver struct{ *Resolver } func (r *mergedInfoboxResolver) Scene(ctx context.Context, obj *gqlmodel.MergedInfobox) (*gqlmodel.Scene, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Scene.Load(id.SceneID(obj.SceneID)) + return dataloaders(ctx).Scene.Load(id.SceneID(obj.SceneID)) } type mergedInfoboxFieldResolver struct{ *Resolver } func (r *mergedInfoboxFieldResolver) Plugin(ctx context.Context, obj *gqlmodel.MergedInfoboxField) (*gqlmodel.Plugin, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Plugin.Load(obj.PluginID) + return dataloaders(ctx).Plugin.Load(obj.PluginID) } func (r *mergedInfoboxFieldResolver) Extension(ctx context.Context, obj *gqlmodel.MergedInfoboxField) (*gqlmodel.PluginExtension, error) { - exit := trace(ctx) - defer exit() - - plugin, err := DataLoadersFromContext(ctx).Plugin.Load(obj.PluginID) + plugin, err := dataloaders(ctx).Plugin.Load(obj.PluginID) if err != nil { return nil, err } @@ -449,17 +335,11 @@ func (r *mergedInfoboxFieldResolver) Extension(ctx context.Context, obj *gqlmode } func (r *mergedInfoboxFieldResolver) Scene(ctx context.Context, obj *gqlmodel.MergedInfoboxField) (*gqlmodel.Scene, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Scene.Load(id.SceneID(obj.SceneID)) + return dataloaders(ctx).Scene.Load(id.SceneID(obj.SceneID)) } func (r *mergedInfoboxFieldResolver) ScenePlugin(ctx context.Context, obj *gqlmodel.MergedInfoboxField) (*gqlmodel.ScenePlugin, error) { - exit := trace(ctx) - defer exit() - - s, err := DataLoadersFromContext(ctx).Scene.Load(id.SceneID(obj.SceneID)) + s, err := dataloaders(ctx).Scene.Load(id.SceneID(obj.SceneID)) if err != nil { return nil, err } @@ -469,10 +349,7 @@ func (r *mergedInfoboxFieldResolver) ScenePlugin(ctx context.Context, obj *gqlmo type layerTagItemResolver struct{ *Resolver } func (r *layerTagItemResolver) Tag(ctx context.Context, obj *gqlmodel.LayerTagItem) (gqlmodel.Tag, error) { - exit := trace(ctx) - defer exit() - - t, err := DataLoadersFromContext(ctx).Tag.Load(id.TagID(obj.TagID)) + t, err := dataloaders(ctx).Tag.Load(id.TagID(obj.TagID)) if err != nil { return nil, err } @@ -482,10 +359,7 @@ func (r *layerTagItemResolver) Tag(ctx context.Context, obj *gqlmodel.LayerTagIt type layerTagGroupResolver struct{ *Resolver } func (r *layerTagGroupResolver) Tag(ctx context.Context, obj *gqlmodel.LayerTagGroup) (gqlmodel.Tag, error) { - exit := trace(ctx) - defer exit() - - t, err := DataLoadersFromContext(ctx).Tag.Load(id.TagID(obj.TagID)) + t, err := dataloaders(ctx).Tag.Load(id.TagID(obj.TagID)) if err != nil { return nil, err } diff --git a/internal/adapter/gql/resolver_mutation_asset.go b/internal/adapter/gql/resolver_mutation_asset.go index a22e5dc8..482d7208 100644 --- a/internal/adapter/gql/resolver_mutation_asset.go +++ b/internal/adapter/gql/resolver_mutation_asset.go @@ -9,10 +9,7 @@ import ( ) func (r *mutationResolver) CreateAsset(ctx context.Context, input gqlmodel.CreateAssetInput) (*gqlmodel.CreateAssetPayload, error) { - exit := trace(ctx) - defer exit() - - res, err := r.usecases.Asset.Create(ctx, interfaces.CreateAssetParam{ + res, err := usecases(ctx).Asset.Create(ctx, interfaces.CreateAssetParam{ TeamID: id.TeamID(input.TeamID), File: gqlmodel.FromFile(&input.File), }, getOperator(ctx)) @@ -24,10 +21,7 @@ func (r *mutationResolver) CreateAsset(ctx context.Context, input gqlmodel.Creat } func (r *mutationResolver) RemoveAsset(ctx context.Context, input gqlmodel.RemoveAssetInput) (*gqlmodel.RemoveAssetPayload, error) { - exit := trace(ctx) - defer exit() - - res, err2 := r.usecases.Asset.Remove(ctx, id.AssetID(input.AssetID), getOperator(ctx)) + res, err2 := usecases(ctx).Asset.Remove(ctx, id.AssetID(input.AssetID), getOperator(ctx)) if err2 != nil { return nil, err2 } diff --git a/internal/adapter/gql/resolver_mutation_dataset.go b/internal/adapter/gql/resolver_mutation_dataset.go index 51a2d652..dcdcbf39 100644 --- a/internal/adapter/gql/resolver_mutation_dataset.go +++ b/internal/adapter/gql/resolver_mutation_dataset.go @@ -9,10 +9,7 @@ import ( ) func (r *mutationResolver) UpdateDatasetSchema(ctx context.Context, input gqlmodel.UpdateDatasetSchemaInput) (*gqlmodel.UpdateDatasetSchemaPayload, error) { - exit := trace(ctx) - defer exit() - - res, err := r.usecases.Dataset.UpdateDatasetSchema(ctx, interfaces.UpdateDatasetSchemaParam{ + res, err := usecases(ctx).Dataset.UpdateDatasetSchema(ctx, interfaces.UpdateDatasetSchemaParam{ SchemaId: id.DatasetSchemaID(input.SchemaID), Name: input.Name, }, getOperator(ctx)) @@ -24,10 +21,7 @@ func (r *mutationResolver) UpdateDatasetSchema(ctx context.Context, input gqlmod } func (r *mutationResolver) AddDynamicDatasetSchema(ctx context.Context, input gqlmodel.AddDynamicDatasetSchemaInput) (*gqlmodel.AddDynamicDatasetSchemaPayload, error) { - exit := trace(ctx) - defer exit() - - res, err := r.usecases.Dataset.AddDynamicDatasetSchema(ctx, interfaces.AddDynamicDatasetSchemaParam{ + res, err := usecases(ctx).Dataset.AddDynamicDatasetSchema(ctx, interfaces.AddDynamicDatasetSchemaParam{ SceneId: id.SceneID(input.SceneID), }) if err != nil { @@ -38,10 +32,7 @@ func (r *mutationResolver) AddDynamicDatasetSchema(ctx context.Context, input gq } func (r *mutationResolver) AddDynamicDataset(ctx context.Context, input gqlmodel.AddDynamicDatasetInput) (*gqlmodel.AddDynamicDatasetPayload, error) { - exit := trace(ctx) - defer exit() - - dss, ds, err := r.usecases.Dataset.AddDynamicDataset(ctx, interfaces.AddDynamicDatasetParam{ + dss, ds, err := usecases(ctx).Dataset.AddDynamicDataset(ctx, interfaces.AddDynamicDatasetParam{ SchemaId: id.DatasetSchemaID(input.DatasetSchemaID), Author: input.Author, Content: input.Content, @@ -57,10 +48,7 @@ func (r *mutationResolver) AddDynamicDataset(ctx context.Context, input gqlmodel } func (r *mutationResolver) SyncDataset(ctx context.Context, input gqlmodel.SyncDatasetInput) (*gqlmodel.SyncDatasetPayload, error) { - exit := trace(ctx) - defer exit() - - dss, ds, err := r.usecases.Dataset.Sync(ctx, id.SceneID(input.SceneID), input.URL, getOperator(ctx)) + dss, ds, err := usecases(ctx).Dataset.Sync(ctx, id.SceneID(input.SceneID), input.URL, getOperator(ctx)) if err != nil { return nil, err } @@ -83,10 +71,7 @@ func (r *mutationResolver) SyncDataset(ctx context.Context, input gqlmodel.SyncD } func (r *mutationResolver) RemoveDatasetSchema(ctx context.Context, input gqlmodel.RemoveDatasetSchemaInput) (*gqlmodel.RemoveDatasetSchemaPayload, error) { - exit := trace(ctx) - defer exit() - - res, err := r.usecases.Dataset.RemoveDatasetSchema(ctx, interfaces.RemoveDatasetSchemaParam{ + res, err := usecases(ctx).Dataset.RemoveDatasetSchema(ctx, interfaces.RemoveDatasetSchemaParam{ SchemaId: id.DatasetSchemaID(input.SchemaID), Force: input.Force, }, getOperator(ctx)) @@ -98,10 +83,7 @@ func (r *mutationResolver) RemoveDatasetSchema(ctx context.Context, input gqlmod } func (r *mutationResolver) AddDatasetSchema(ctx context.Context, input gqlmodel.AddDatasetSchemaInput) (*gqlmodel.AddDatasetSchemaPayload, error) { - exit := trace(ctx) - defer exit() - - res, err2 := r.usecases.Dataset.AddDatasetSchema(ctx, interfaces.AddDatasetSchemaParam{ + res, err2 := usecases(ctx).Dataset.AddDatasetSchema(ctx, interfaces.AddDatasetSchemaParam{ SceneId: id.SceneID(input.SceneID), Name: input.Name, RepresentativeField: id.DatasetSchemaFieldIDFromRefID(input.Representativefield), @@ -114,10 +96,7 @@ func (r *mutationResolver) AddDatasetSchema(ctx context.Context, input gqlmodel. } func (r *mutationResolver) ImportDataset(ctx context.Context, input gqlmodel.ImportDatasetInput) (*gqlmodel.ImportDatasetPayload, error) { - exit := trace(ctx) - defer exit() - - res, err := r.usecases.Dataset.ImportDataset(ctx, interfaces.ImportDatasetParam{ + res, err := usecases(ctx).Dataset.ImportDataset(ctx, interfaces.ImportDatasetParam{ SceneId: id.SceneID(input.SceneID), SchemaId: id.DatasetSchemaIDFromRefID(input.DatasetSchemaID), File: gqlmodel.FromFile(&input.File), @@ -130,10 +109,7 @@ func (r *mutationResolver) ImportDataset(ctx context.Context, input gqlmodel.Imp } func (r *mutationResolver) ImportDatasetFromGoogleSheet(ctx context.Context, input gqlmodel.ImportDatasetFromGoogleSheetInput) (*gqlmodel.ImportDatasetPayload, error) { - exit := trace(ctx) - defer exit() - - res, err := r.usecases.Dataset.ImportDatasetFromGoogleSheet(ctx, interfaces.ImportDatasetFromGoogleSheetParam{ + res, err := usecases(ctx).Dataset.ImportDatasetFromGoogleSheet(ctx, interfaces.ImportDatasetFromGoogleSheetParam{ Token: input.AccessToken, FileID: input.FileID, SheetName: input.SheetName, diff --git a/internal/adapter/gql/resolver_mutation_layer.go b/internal/adapter/gql/resolver_mutation_layer.go index e745793b..843af6a2 100644 --- a/internal/adapter/gql/resolver_mutation_layer.go +++ b/internal/adapter/gql/resolver_mutation_layer.go @@ -9,10 +9,7 @@ import ( ) func (r *mutationResolver) AddLayerItem(ctx context.Context, input gqlmodel.AddLayerItemInput) (*gqlmodel.AddLayerItemPayload, error) { - exit := trace(ctx) - defer exit() - - layer, parent, err := r.usecases.Layer.AddItem(ctx, interfaces.AddLayerItemInput{ + layer, parent, err := usecases(ctx).Layer.AddItem(ctx, interfaces.AddLayerItemInput{ ParentLayerID: id.LayerID(input.ParentLayerID), PluginID: &input.PluginID, ExtensionID: &input.ExtensionID, @@ -33,10 +30,7 @@ func (r *mutationResolver) AddLayerItem(ctx context.Context, input gqlmodel.AddL } func (r *mutationResolver) AddLayerGroup(ctx context.Context, input gqlmodel.AddLayerGroupInput) (*gqlmodel.AddLayerGroupPayload, error) { - exit := trace(ctx) - defer exit() - - layer, parent, err := r.usecases.Layer.AddGroup(ctx, interfaces.AddLayerGroupInput{ + layer, parent, err := usecases(ctx).Layer.AddGroup(ctx, interfaces.AddLayerGroupInput{ ParentLayerID: id.LayerID(input.ParentLayerID), PluginID: input.PluginID, ExtensionID: input.ExtensionID, @@ -57,10 +51,7 @@ func (r *mutationResolver) AddLayerGroup(ctx context.Context, input gqlmodel.Add } func (r *mutationResolver) RemoveLayer(ctx context.Context, input gqlmodel.RemoveLayerInput) (*gqlmodel.RemoveLayerPayload, error) { - exit := trace(ctx) - defer exit() - - id, layer, err := r.usecases.Layer.Remove(ctx, id.LayerID(input.LayerID), getOperator(ctx)) + id, layer, err := usecases(ctx).Layer.Remove(ctx, id.LayerID(input.LayerID), getOperator(ctx)) if err != nil { return nil, err } @@ -72,10 +63,7 @@ func (r *mutationResolver) RemoveLayer(ctx context.Context, input gqlmodel.Remov } func (r *mutationResolver) UpdateLayer(ctx context.Context, input gqlmodel.UpdateLayerInput) (*gqlmodel.UpdateLayerPayload, error) { - exit := trace(ctx) - defer exit() - - layer, err := r.usecases.Layer.Update(ctx, interfaces.UpdateLayerInput{ + layer, err := usecases(ctx).Layer.Update(ctx, interfaces.UpdateLayerInput{ LayerID: id.LayerID(input.LayerID), Name: input.Name, Visible: input.Visible, @@ -90,10 +78,7 @@ func (r *mutationResolver) UpdateLayer(ctx context.Context, input gqlmodel.Updat } func (r *mutationResolver) MoveLayer(ctx context.Context, input gqlmodel.MoveLayerInput) (*gqlmodel.MoveLayerPayload, error) { - exit := trace(ctx) - defer exit() - - targetLayerID, layerGroupFrom, layerGroupTo, index, err := r.usecases.Layer.Move(ctx, interfaces.MoveLayerInput{ + targetLayerID, layerGroupFrom, layerGroupTo, index, err := usecases(ctx).Layer.Move(ctx, interfaces.MoveLayerInput{ LayerID: id.LayerID(input.LayerID), DestLayerID: id.LayerIDFromRefID(input.DestLayerID), Index: gqlmodel.RefToIndex(input.Index), @@ -111,10 +96,7 @@ func (r *mutationResolver) MoveLayer(ctx context.Context, input gqlmodel.MoveLay } func (r *mutationResolver) CreateInfobox(ctx context.Context, input gqlmodel.CreateInfoboxInput) (*gqlmodel.CreateInfoboxPayload, error) { - exit := trace(ctx) - defer exit() - - layer, err := r.usecases.Layer.CreateInfobox(ctx, id.LayerID(input.LayerID), getOperator(ctx)) + layer, err := usecases(ctx).Layer.CreateInfobox(ctx, id.LayerID(input.LayerID), getOperator(ctx)) if err != nil { return nil, err } @@ -125,10 +107,7 @@ func (r *mutationResolver) CreateInfobox(ctx context.Context, input gqlmodel.Cre } func (r *mutationResolver) RemoveInfobox(ctx context.Context, input gqlmodel.RemoveInfoboxInput) (*gqlmodel.RemoveInfoboxPayload, error) { - exit := trace(ctx) - defer exit() - - layer, err := r.usecases.Layer.RemoveInfobox(ctx, id.LayerID(input.LayerID), getOperator(ctx)) + layer, err := usecases(ctx).Layer.RemoveInfobox(ctx, id.LayerID(input.LayerID), getOperator(ctx)) if err != nil { return nil, err } @@ -139,10 +118,7 @@ func (r *mutationResolver) RemoveInfobox(ctx context.Context, input gqlmodel.Rem } func (r *mutationResolver) AddInfoboxField(ctx context.Context, input gqlmodel.AddInfoboxFieldInput) (*gqlmodel.AddInfoboxFieldPayload, error) { - exit := trace(ctx) - defer exit() - - infoboxField, layer, err := r.usecases.Layer.AddInfoboxField(ctx, interfaces.AddInfoboxFieldParam{ + infoboxField, layer, err := usecases(ctx).Layer.AddInfoboxField(ctx, interfaces.AddInfoboxFieldParam{ LayerID: id.LayerID(input.LayerID), PluginID: input.PluginID, ExtensionID: input.ExtensionID, @@ -159,10 +135,7 @@ func (r *mutationResolver) AddInfoboxField(ctx context.Context, input gqlmodel.A } func (r *mutationResolver) MoveInfoboxField(ctx context.Context, input gqlmodel.MoveInfoboxFieldInput) (*gqlmodel.MoveInfoboxFieldPayload, error) { - exit := trace(ctx) - defer exit() - - infoboxField, layer, index, err := r.usecases.Layer.MoveInfoboxField(ctx, interfaces.MoveInfoboxFieldParam{ + infoboxField, layer, index, err := usecases(ctx).Layer.MoveInfoboxField(ctx, interfaces.MoveInfoboxFieldParam{ LayerID: id.LayerID(input.LayerID), InfoboxFieldID: id.InfoboxFieldID(input.InfoboxFieldID), Index: input.Index, @@ -179,10 +152,7 @@ func (r *mutationResolver) MoveInfoboxField(ctx context.Context, input gqlmodel. } func (r *mutationResolver) RemoveInfoboxField(ctx context.Context, input gqlmodel.RemoveInfoboxFieldInput) (*gqlmodel.RemoveInfoboxFieldPayload, error) { - exit := trace(ctx) - defer exit() - - infoboxField, layer, err := r.usecases.Layer.RemoveInfoboxField(ctx, interfaces.RemoveInfoboxFieldParam{ + infoboxField, layer, err := usecases(ctx).Layer.RemoveInfoboxField(ctx, interfaces.RemoveInfoboxFieldParam{ LayerID: id.LayerID(input.LayerID), InfoboxFieldID: id.InfoboxFieldID(input.InfoboxFieldID), }, getOperator(ctx)) @@ -197,10 +167,7 @@ func (r *mutationResolver) RemoveInfoboxField(ctx context.Context, input gqlmode } func (r *mutationResolver) ImportLayer(ctx context.Context, input gqlmodel.ImportLayerInput) (*gqlmodel.ImportLayerPayload, error) { - exit := trace(ctx) - defer exit() - - l, l2, err := r.usecases.Layer.ImportLayer(ctx, interfaces.ImportLayerParam{ + l, l2, err := usecases(ctx).Layer.ImportLayer(ctx, interfaces.ImportLayerParam{ LayerID: id.LayerID(input.LayerID), File: gqlmodel.FromFile(&input.File), Format: gqlmodel.FromLayerEncodingFormat(input.Format), @@ -216,10 +183,7 @@ func (r *mutationResolver) ImportLayer(ctx context.Context, input gqlmodel.Impor } func (r *mutationResolver) AttachTagToLayer(ctx context.Context, input gqlmodel.AttachTagToLayerInput) (*gqlmodel.AttachTagToLayerPayload, error) { - exit := trace(ctx) - defer exit() - - layer, err := r.usecases.Layer.AttachTag(ctx, id.LayerID(input.LayerID), id.TagID(input.TagID), getOperator(ctx)) + layer, err := usecases(ctx).Layer.AttachTag(ctx, id.LayerID(input.LayerID), id.TagID(input.TagID), getOperator(ctx)) if err != nil { return nil, err } @@ -229,10 +193,7 @@ func (r *mutationResolver) AttachTagToLayer(ctx context.Context, input gqlmodel. } func (r *mutationResolver) DetachTagFromLayer(ctx context.Context, input gqlmodel.DetachTagFromLayerInput) (*gqlmodel.DetachTagFromLayerPayload, error) { - exit := trace(ctx) - defer exit() - - layer, err := r.usecases.Layer.DetachTag(ctx, id.LayerID(input.LayerID), id.TagID(input.TagID), getOperator(ctx)) + layer, err := usecases(ctx).Layer.DetachTag(ctx, id.LayerID(input.LayerID), id.TagID(input.TagID), getOperator(ctx)) if err != nil { return nil, err } diff --git a/internal/adapter/gql/resolver_mutation_project.go b/internal/adapter/gql/resolver_mutation_project.go index 1cc52255..60d05479 100644 --- a/internal/adapter/gql/resolver_mutation_project.go +++ b/internal/adapter/gql/resolver_mutation_project.go @@ -10,10 +10,7 @@ import ( ) func (r *mutationResolver) CreateProject(ctx context.Context, input gqlmodel.CreateProjectInput) (*gqlmodel.ProjectPayload, error) { - exit := trace(ctx) - defer exit() - - res, err := r.usecases.Project.Create(ctx, interfaces.CreateProjectParam{ + res, err := usecases(ctx).Project.Create(ctx, interfaces.CreateProjectParam{ TeamID: id.TeamID(input.TeamID), Visualizer: visualizer.Visualizer(input.Visualizer), Name: input.Name, @@ -30,9 +27,6 @@ func (r *mutationResolver) CreateProject(ctx context.Context, input gqlmodel.Cre } func (r *mutationResolver) UpdateProject(ctx context.Context, input gqlmodel.UpdateProjectInput) (*gqlmodel.ProjectPayload, error) { - exit := trace(ctx) - defer exit() - deletePublicImage := false if input.DeletePublicImage != nil { deletePublicImage = *input.DeletePublicImage @@ -43,7 +37,7 @@ func (r *mutationResolver) UpdateProject(ctx context.Context, input gqlmodel.Upd deleteImageURL = *input.DeleteImageURL } - res, err := r.usecases.Project.Update(ctx, interfaces.UpdateProjectParam{ + res, err := usecases(ctx).Project.Update(ctx, interfaces.UpdateProjectParam{ ID: id.ProjectID(input.ProjectID), Name: input.Name, Description: input.Description, @@ -68,10 +62,7 @@ func (r *mutationResolver) UpdateProject(ctx context.Context, input gqlmodel.Upd } func (r *mutationResolver) PublishProject(ctx context.Context, input gqlmodel.PublishProjectInput) (*gqlmodel.ProjectPayload, error) { - exit := trace(ctx) - defer exit() - - res, err := r.usecases.Project.Publish(ctx, interfaces.PublishProjectParam{ + res, err := usecases(ctx).Project.Publish(ctx, interfaces.PublishProjectParam{ ID: id.ProjectID(input.ProjectID), Alias: input.Alias, Status: gqlmodel.FromPublishmentStatus(input.Status), @@ -84,10 +75,7 @@ func (r *mutationResolver) PublishProject(ctx context.Context, input gqlmodel.Pu } func (r *mutationResolver) DeleteProject(ctx context.Context, input gqlmodel.DeleteProjectInput) (*gqlmodel.DeleteProjectPayload, error) { - exit := trace(ctx) - defer exit() - - err := r.usecases.Project.Delete(ctx, id.ProjectID(input.ProjectID), getOperator(ctx)) + err := usecases(ctx).Project.Delete(ctx, id.ProjectID(input.ProjectID), getOperator(ctx)) if err != nil { return nil, err } diff --git a/internal/adapter/gql/resolver_mutation_property.go b/internal/adapter/gql/resolver_mutation_property.go index 88d7bbee..c117fda9 100644 --- a/internal/adapter/gql/resolver_mutation_property.go +++ b/internal/adapter/gql/resolver_mutation_property.go @@ -11,9 +11,6 @@ import ( ) func (r *mutationResolver) UpdatePropertyValue(ctx context.Context, input gqlmodel.UpdatePropertyValueInput) (*gqlmodel.PropertyFieldPayload, error) { - exit := trace(ctx) - defer exit() - var v *property.Value if input.Value != nil { v = gqlmodel.FromPropertyValueAndType(input.Value, input.Type) @@ -22,7 +19,7 @@ func (r *mutationResolver) UpdatePropertyValue(ctx context.Context, input gqlmod } } - pp, pgl, pg, pf, err := r.usecases.Property.UpdateValue(ctx, interfaces.UpdatePropertyValueParam{ + pp, pgl, pg, pf, err := usecases(ctx).Property.UpdateValue(ctx, interfaces.UpdatePropertyValueParam{ PropertyID: id.PropertyID(input.PropertyID), Pointer: gqlmodel.FromPointer(input.SchemaGroupID, input.ItemID, &input.FieldID), Value: v, @@ -38,10 +35,7 @@ func (r *mutationResolver) UpdatePropertyValue(ctx context.Context, input gqlmod } func (r *mutationResolver) RemovePropertyField(ctx context.Context, input gqlmodel.RemovePropertyFieldInput) (*gqlmodel.PropertyFieldPayload, error) { - exit := trace(ctx) - defer exit() - - p, err := r.usecases.Property.RemoveField(ctx, interfaces.RemovePropertyFieldParam{ + p, err := usecases(ctx).Property.RemoveField(ctx, interfaces.RemovePropertyFieldParam{ PropertyID: id.PropertyID(input.PropertyID), Pointer: gqlmodel.FromPointer(input.SchemaGroupID, input.ItemID, &input.FieldID), }, getOperator(ctx)) @@ -55,10 +49,7 @@ func (r *mutationResolver) RemovePropertyField(ctx context.Context, input gqlmod } func (r *mutationResolver) UploadFileToProperty(ctx context.Context, input gqlmodel.UploadFileToPropertyInput) (*gqlmodel.PropertyFieldPayload, error) { - exit := trace(ctx) - defer exit() - - p, pgl, pg, pf, err := r.usecases.Property.UploadFile(ctx, interfaces.UploadFileParam{ + p, pgl, pg, pf, err := usecases(ctx).Property.UploadFile(ctx, interfaces.UploadFileParam{ PropertyID: id.PropertyID(input.PropertyID), Pointer: gqlmodel.FromPointer(input.SchemaGroupID, input.ItemID, &input.FieldID), File: gqlmodel.FromFile(&input.File), @@ -74,10 +65,7 @@ func (r *mutationResolver) UploadFileToProperty(ctx context.Context, input gqlmo } func (r *mutationResolver) LinkDatasetToPropertyValue(ctx context.Context, input gqlmodel.LinkDatasetToPropertyValueInput) (*gqlmodel.PropertyFieldPayload, error) { - exit := trace(ctx) - defer exit() - - p, pgl, pg, pf, err := r.usecases.Property.LinkValue(ctx, interfaces.LinkPropertyValueParam{ + p, pgl, pg, pf, err := usecases(ctx).Property.LinkValue(ctx, interfaces.LinkPropertyValueParam{ PropertyID: id.PropertyID(input.PropertyID), Pointer: gqlmodel.FromPointer(input.SchemaGroupID, input.ItemID, &input.FieldID), Links: gqlmodel.FromPropertyFieldLink( @@ -97,10 +85,7 @@ func (r *mutationResolver) LinkDatasetToPropertyValue(ctx context.Context, input } func (r *mutationResolver) UnlinkPropertyValue(ctx context.Context, input gqlmodel.UnlinkPropertyValueInput) (*gqlmodel.PropertyFieldPayload, error) { - exit := trace(ctx) - defer exit() - - p, pgl, pg, pf, err := r.usecases.Property.UnlinkValue(ctx, interfaces.UnlinkPropertyValueParam{ + p, pgl, pg, pf, err := usecases(ctx).Property.UnlinkValue(ctx, interfaces.UnlinkPropertyValueParam{ PropertyID: id.PropertyID(input.PropertyID), Pointer: gqlmodel.FromPointer(input.SchemaGroupID, input.ItemID, &input.FieldID), }, getOperator(ctx)) @@ -115,9 +100,6 @@ func (r *mutationResolver) UnlinkPropertyValue(ctx context.Context, input gqlmod } func (r *mutationResolver) AddPropertyItem(ctx context.Context, input gqlmodel.AddPropertyItemInput) (*gqlmodel.PropertyItemPayload, error) { - exit := trace(ctx) - defer exit() - var v *property.Value if input.NameFieldType != nil { v = gqlmodel.FromPropertyValueAndType(input.NameFieldValue, *input.NameFieldType) @@ -126,7 +108,7 @@ func (r *mutationResolver) AddPropertyItem(ctx context.Context, input gqlmodel.A } } - p, pgl, pi, err := r.usecases.Property.AddItem(ctx, interfaces.AddPropertyItemParam{ + p, pgl, pi, err := usecases(ctx).Property.AddItem(ctx, interfaces.AddPropertyItemParam{ PropertyID: id.PropertyID(input.PropertyID), Pointer: gqlmodel.FromPointer(&input.SchemaGroupID, nil, nil), Index: input.Index, @@ -144,10 +126,7 @@ func (r *mutationResolver) AddPropertyItem(ctx context.Context, input gqlmodel.A } func (r *mutationResolver) MovePropertyItem(ctx context.Context, input gqlmodel.MovePropertyItemInput) (*gqlmodel.PropertyItemPayload, error) { - exit := trace(ctx) - defer exit() - - p, pgl, pi, err := r.usecases.Property.MoveItem(ctx, interfaces.MovePropertyItemParam{ + p, pgl, pi, err := usecases(ctx).Property.MoveItem(ctx, interfaces.MovePropertyItemParam{ PropertyID: id.PropertyID(input.PropertyID), Pointer: gqlmodel.FromPointer(&input.SchemaGroupID, &input.ItemID, nil), Index: input.Index, @@ -163,10 +142,7 @@ func (r *mutationResolver) MovePropertyItem(ctx context.Context, input gqlmodel. } func (r *mutationResolver) RemovePropertyItem(ctx context.Context, input gqlmodel.RemovePropertyItemInput) (*gqlmodel.PropertyItemPayload, error) { - exit := trace(ctx) - defer exit() - - p, err := r.usecases.Property.RemoveItem(ctx, interfaces.RemovePropertyItemParam{ + p, err := usecases(ctx).Property.RemoveItem(ctx, interfaces.RemovePropertyItemParam{ PropertyID: id.PropertyID(input.PropertyID), Pointer: gqlmodel.FromPointer(&input.SchemaGroupID, &input.ItemID, nil), }, getOperator(ctx)) @@ -180,9 +156,6 @@ func (r *mutationResolver) RemovePropertyItem(ctx context.Context, input gqlmode } func (r *mutationResolver) UpdatePropertyItems(ctx context.Context, input gqlmodel.UpdatePropertyItemInput) (*gqlmodel.PropertyItemPayload, error) { - exit := trace(ctx) - defer exit() - op := make([]interfaces.UpdatePropertyItemsOperationParam, 0, len(input.Operations)) for _, o := range input.Operations { var v *property.Value @@ -201,7 +174,7 @@ func (r *mutationResolver) UpdatePropertyItems(ctx context.Context, input gqlmod }) } - p, err2 := r.usecases.Property.UpdateItems(ctx, interfaces.UpdatePropertyItemsParam{ + p, err2 := usecases(ctx).Property.UpdateItems(ctx, interfaces.UpdatePropertyItemsParam{ PropertyID: id.PropertyID(input.PropertyID), Pointer: gqlmodel.FromPointer(&input.SchemaGroupID, nil, nil), Operations: op, diff --git a/internal/adapter/gql/resolver_mutation_scene.go b/internal/adapter/gql/resolver_mutation_scene.go index 8379a7a8..26377eee 100644 --- a/internal/adapter/gql/resolver_mutation_scene.go +++ b/internal/adapter/gql/resolver_mutation_scene.go @@ -12,10 +12,7 @@ import ( ) func (r *mutationResolver) CreateScene(ctx context.Context, input gqlmodel.CreateSceneInput) (*gqlmodel.CreateScenePayload, error) { - exit := trace(ctx) - defer exit() - - res, err := r.usecases.Scene.Create( + res, err := usecases(ctx).Scene.Create( ctx, id.ProjectID(input.ProjectID), getOperator(ctx), @@ -30,10 +27,7 @@ func (r *mutationResolver) CreateScene(ctx context.Context, input gqlmodel.Creat } func (r *mutationResolver) AddWidget(ctx context.Context, input gqlmodel.AddWidgetInput) (*gqlmodel.AddWidgetPayload, error) { - exit := trace(ctx) - defer exit() - - scene, widget, err := r.usecases.Scene.AddWidget( + scene, widget, err := usecases(ctx).Scene.AddWidget( ctx, id.SceneID(input.SceneID), input.PluginID, @@ -51,10 +45,7 @@ func (r *mutationResolver) AddWidget(ctx context.Context, input gqlmodel.AddWidg } func (r *mutationResolver) UpdateWidget(ctx context.Context, input gqlmodel.UpdateWidgetInput) (*gqlmodel.UpdateWidgetPayload, error) { - exit := trace(ctx) - defer exit() - - scene, widget, err := r.usecases.Scene.UpdateWidget(ctx, interfaces.UpdateWidgetParam{ + scene, widget, err := usecases(ctx).Scene.UpdateWidget(ctx, interfaces.UpdateWidgetParam{ SceneID: id.SceneID(input.SceneID), WidgetID: id.WidgetID(input.WidgetID), Enabled: input.Enabled, @@ -73,10 +64,7 @@ func (r *mutationResolver) UpdateWidget(ctx context.Context, input gqlmodel.Upda } func (r *mutationResolver) RemoveWidget(ctx context.Context, input gqlmodel.RemoveWidgetInput) (*gqlmodel.RemoveWidgetPayload, error) { - exit := trace(ctx) - defer exit() - - scene, err := r.usecases.Scene.RemoveWidget(ctx, + scene, err := usecases(ctx).Scene.RemoveWidget(ctx, id.SceneID(input.SceneID), id.WidgetID(input.WidgetID), getOperator(ctx), @@ -92,10 +80,7 @@ func (r *mutationResolver) RemoveWidget(ctx context.Context, input gqlmodel.Remo } func (r *mutationResolver) UpdateWidgetAlignSystem(ctx context.Context, input gqlmodel.UpdateWidgetAlignSystemInput) (*gqlmodel.UpdateWidgetAlignSystemPayload, error) { - exit := trace(ctx) - defer exit() - - scene, err := r.usecases.Scene.UpdateWidgetAlignSystem(ctx, interfaces.UpdateWidgetAlignSystemParam{ + scene, err := usecases(ctx).Scene.UpdateWidgetAlignSystem(ctx, interfaces.UpdateWidgetAlignSystemParam{ SceneID: id.SceneID(input.SceneID), Location: *gqlmodel.FromSceneWidgetLocation(input.Location), Align: gqlmodel.FromWidgetAlignType(input.Align), @@ -110,10 +95,7 @@ func (r *mutationResolver) UpdateWidgetAlignSystem(ctx context.Context, input gq } func (r *mutationResolver) InstallPlugin(ctx context.Context, input gqlmodel.InstallPluginInput) (*gqlmodel.InstallPluginPayload, error) { - exit := trace(ctx) - defer exit() - - scene, pl, pr, err := r.usecases.Scene.InstallPlugin(ctx, + scene, pl, pr, err := usecases(ctx).Scene.InstallPlugin(ctx, id.SceneID(input.SceneID), input.PluginID, getOperator(ctx), @@ -131,18 +113,15 @@ func (r *mutationResolver) InstallPlugin(ctx context.Context, input gqlmodel.Ins } func (r *mutationResolver) UploadPlugin(ctx context.Context, input gqlmodel.UploadPluginInput) (*gqlmodel.UploadPluginPayload, error) { - exit := trace(ctx) - defer exit() - operator := getOperator(ctx) var p *plugin.Plugin var s *scene.Scene var err error if input.File != nil { - p, s, err = r.usecases.Plugin.Upload(ctx, input.File.File, id.SceneID(input.SceneID), operator) + p, s, err = usecases(ctx).Plugin.Upload(ctx, input.File.File, id.SceneID(input.SceneID), operator) } else if input.URL != nil { - p, s, err = r.usecases.Plugin.UploadFromRemote(ctx, input.URL, id.SceneID(input.SceneID), operator) + p, s, err = usecases(ctx).Plugin.UploadFromRemote(ctx, input.URL, id.SceneID(input.SceneID), operator) } else { return nil, errors.New("either file or url is required") } @@ -158,10 +137,7 @@ func (r *mutationResolver) UploadPlugin(ctx context.Context, input gqlmodel.Uplo } func (r *mutationResolver) UninstallPlugin(ctx context.Context, input gqlmodel.UninstallPluginInput) (*gqlmodel.UninstallPluginPayload, error) { - exit := trace(ctx) - defer exit() - - scene, err := r.usecases.Scene.UninstallPlugin(ctx, + scene, err := usecases(ctx).Scene.UninstallPlugin(ctx, id.SceneID(input.SceneID), id.PluginID(input.PluginID), getOperator(ctx), @@ -177,10 +153,7 @@ func (r *mutationResolver) UninstallPlugin(ctx context.Context, input gqlmodel.U } func (r *mutationResolver) UpgradePlugin(ctx context.Context, input gqlmodel.UpgradePluginInput) (*gqlmodel.UpgradePluginPayload, error) { - exit := trace(ctx) - defer exit() - - s, err := r.usecases.Scene.UpgradePlugin(ctx, + s, err := usecases(ctx).Scene.UpgradePlugin(ctx, id.SceneID(input.SceneID), input.PluginID, input.ToPluginID, @@ -197,9 +170,7 @@ func (r *mutationResolver) UpgradePlugin(ctx context.Context, input gqlmodel.Upg } func (r *mutationResolver) AddCluster(ctx context.Context, input gqlmodel.AddClusterInput) (*gqlmodel.AddClusterPayload, error) { - exit := trace(ctx) - defer exit() - s, c, err := r.usecases.Scene.AddCluster(ctx, id.SceneID(input.SceneID), input.Name, getOperator(ctx)) + s, c, err := usecases(ctx).Scene.AddCluster(ctx, id.SceneID(input.SceneID), input.Name, getOperator(ctx)) if err != nil { return nil, err } @@ -211,9 +182,7 @@ func (r *mutationResolver) AddCluster(ctx context.Context, input gqlmodel.AddClu } func (r *mutationResolver) UpdateCluster(ctx context.Context, input gqlmodel.UpdateClusterInput) (*gqlmodel.UpdateClusterPayload, error) { - exit := trace(ctx) - defer exit() - s, c, err := r.usecases.Scene.UpdateCluster(ctx, interfaces.UpdateClusterParam{ + s, c, err := usecases(ctx).Scene.UpdateCluster(ctx, interfaces.UpdateClusterParam{ ClusterID: id.ClusterID(input.ClusterID), SceneID: id.SceneID(input.SceneID), Name: input.Name, @@ -230,9 +199,7 @@ func (r *mutationResolver) UpdateCluster(ctx context.Context, input gqlmodel.Upd } func (r *mutationResolver) RemoveCluster(ctx context.Context, input gqlmodel.RemoveClusterInput) (*gqlmodel.RemoveClusterPayload, error) { - exit := trace(ctx) - defer exit() - s, err := r.usecases.Scene.RemoveCluster(ctx, id.SceneID(input.SceneID), id.ClusterID(input.ClusterID), getOperator(ctx)) + s, err := usecases(ctx).Scene.RemoveCluster(ctx, id.SceneID(input.SceneID), id.ClusterID(input.ClusterID), getOperator(ctx)) if err != nil { return nil, err } diff --git a/internal/adapter/gql/resolver_mutation_tag.go b/internal/adapter/gql/resolver_mutation_tag.go index ceffc845..99bd76ca 100644 --- a/internal/adapter/gql/resolver_mutation_tag.go +++ b/internal/adapter/gql/resolver_mutation_tag.go @@ -9,10 +9,7 @@ import ( ) func (r *mutationResolver) CreateTagItem(ctx context.Context, input gqlmodel.CreateTagItemInput) (*gqlmodel.CreateTagItemPayload, error) { - exit := trace(ctx) - defer exit() - - tag, parent, err := r.usecases.Tag.CreateItem(ctx, interfaces.CreateTagItemParam{ + tag, parent, err := usecases(ctx).Tag.CreateItem(ctx, interfaces.CreateTagItemParam{ Label: input.Label, SceneID: id.SceneID(input.SceneID), Parent: id.TagIDFromRefID(input.Parent), @@ -31,10 +28,7 @@ func (r *mutationResolver) CreateTagItem(ctx context.Context, input gqlmodel.Cre } func (r *mutationResolver) CreateTagGroup(ctx context.Context, input gqlmodel.CreateTagGroupInput) (*gqlmodel.CreateTagGroupPayload, error) { - exit := trace(ctx) - defer exit() - - tag, err := r.usecases.Tag.CreateGroup(ctx, interfaces.CreateTagGroupParam{ + tag, err := usecases(ctx).Tag.CreateGroup(ctx, interfaces.CreateTagGroupParam{ Label: input.Label, SceneID: id.SceneID(input.SceneID), Tags: id.TagIDsFromIDRef(input.Tags), @@ -48,10 +42,7 @@ func (r *mutationResolver) CreateTagGroup(ctx context.Context, input gqlmodel.Cr } func (r *mutationResolver) UpdateTag(ctx context.Context, input gqlmodel.UpdateTagInput) (*gqlmodel.UpdateTagPayload, error) { - exit := trace(ctx) - defer exit() - - tag, err := r.usecases.Tag.UpdateTag(ctx, interfaces.UpdateTagParam{ + tag, err := usecases(ctx).Tag.UpdateTag(ctx, interfaces.UpdateTagParam{ Label: input.Label, SceneID: id.SceneID(input.SceneID), TagID: id.TagID(input.TagID), @@ -65,10 +56,7 @@ func (r *mutationResolver) UpdateTag(ctx context.Context, input gqlmodel.UpdateT } func (r *mutationResolver) AttachTagItemToGroup(ctx context.Context, input gqlmodel.AttachTagItemToGroupInput) (*gqlmodel.AttachTagItemToGroupPayload, error) { - exit := trace(ctx) - defer exit() - - tag, err := r.usecases.Tag.AttachItemToGroup(ctx, interfaces.AttachItemToGroupParam{ + tag, err := usecases(ctx).Tag.AttachItemToGroup(ctx, interfaces.AttachItemToGroupParam{ ItemID: id.TagID(input.ItemID), GroupID: id.TagID(input.GroupID), }, getOperator(ctx)) @@ -81,10 +69,7 @@ func (r *mutationResolver) AttachTagItemToGroup(ctx context.Context, input gqlmo } func (r *mutationResolver) DetachTagItemFromGroup(ctx context.Context, input gqlmodel.DetachTagItemFromGroupInput) (*gqlmodel.DetachTagItemFromGroupPayload, error) { - exit := trace(ctx) - defer exit() - - tag, err := r.usecases.Tag.DetachItemFromGroup(ctx, interfaces.DetachItemToGroupParam{ + tag, err := usecases(ctx).Tag.DetachItemFromGroup(ctx, interfaces.DetachItemToGroupParam{ ItemID: id.TagID(input.ItemID), GroupID: id.TagID(input.GroupID), }, getOperator(ctx)) @@ -97,10 +82,7 @@ func (r *mutationResolver) DetachTagItemFromGroup(ctx context.Context, input gql } func (r *mutationResolver) RemoveTag(ctx context.Context, input gqlmodel.RemoveTagInput) (*gqlmodel.RemoveTagPayload, error) { - exit := trace(ctx) - defer exit() - - tagID, layers, err := r.usecases.Tag.Remove(ctx, id.TagID(input.TagID), getOperator(ctx)) + tagID, layers, err := usecases(ctx).Tag.Remove(ctx, id.TagID(input.TagID), getOperator(ctx)) if err != nil { return nil, err } diff --git a/internal/adapter/gql/resolver_mutation_team.go b/internal/adapter/gql/resolver_mutation_team.go index f40d87c1..4595933a 100644 --- a/internal/adapter/gql/resolver_mutation_team.go +++ b/internal/adapter/gql/resolver_mutation_team.go @@ -8,10 +8,7 @@ import ( ) func (r *mutationResolver) CreateTeam(ctx context.Context, input gqlmodel.CreateTeamInput) (*gqlmodel.CreateTeamPayload, error) { - exit := trace(ctx) - defer exit() - - res, err := r.usecases.Team.Create(ctx, input.Name, getUser(ctx).ID()) + res, err := usecases(ctx).Team.Create(ctx, input.Name, getUser(ctx).ID()) if err != nil { return nil, err } @@ -20,10 +17,7 @@ func (r *mutationResolver) CreateTeam(ctx context.Context, input gqlmodel.Create } func (r *mutationResolver) DeleteTeam(ctx context.Context, input gqlmodel.DeleteTeamInput) (*gqlmodel.DeleteTeamPayload, error) { - exit := trace(ctx) - defer exit() - - if err := r.usecases.Team.Remove(ctx, id.TeamID(input.TeamID), getOperator(ctx)); err != nil { + if err := usecases(ctx).Team.Remove(ctx, id.TeamID(input.TeamID), getOperator(ctx)); err != nil { return nil, err } @@ -31,10 +25,7 @@ func (r *mutationResolver) DeleteTeam(ctx context.Context, input gqlmodel.Delete } func (r *mutationResolver) UpdateTeam(ctx context.Context, input gqlmodel.UpdateTeamInput) (*gqlmodel.UpdateTeamPayload, error) { - exit := trace(ctx) - defer exit() - - res, err := r.usecases.Team.Update(ctx, id.TeamID(input.TeamID), input.Name, getOperator(ctx)) + res, err := usecases(ctx).Team.Update(ctx, id.TeamID(input.TeamID), input.Name, getOperator(ctx)) if err != nil { return nil, err } @@ -43,10 +34,7 @@ func (r *mutationResolver) UpdateTeam(ctx context.Context, input gqlmodel.Update } func (r *mutationResolver) AddMemberToTeam(ctx context.Context, input gqlmodel.AddMemberToTeamInput) (*gqlmodel.AddMemberToTeamPayload, error) { - exit := trace(ctx) - defer exit() - - res, err := r.usecases.Team.AddMember(ctx, id.TeamID(input.TeamID), id.UserID(input.UserID), gqlmodel.FromRole(input.Role), getOperator(ctx)) + res, err := usecases(ctx).Team.AddMember(ctx, id.TeamID(input.TeamID), id.UserID(input.UserID), gqlmodel.FromRole(input.Role), getOperator(ctx)) if err != nil { return nil, err } @@ -55,10 +43,7 @@ func (r *mutationResolver) AddMemberToTeam(ctx context.Context, input gqlmodel.A } func (r *mutationResolver) RemoveMemberFromTeam(ctx context.Context, input gqlmodel.RemoveMemberFromTeamInput) (*gqlmodel.RemoveMemberFromTeamPayload, error) { - exit := trace(ctx) - defer exit() - - res, err := r.usecases.Team.RemoveMember(ctx, id.TeamID(input.TeamID), id.UserID(input.UserID), getOperator(ctx)) + res, err := usecases(ctx).Team.RemoveMember(ctx, id.TeamID(input.TeamID), id.UserID(input.UserID), getOperator(ctx)) if err != nil { return nil, err } @@ -67,10 +52,7 @@ func (r *mutationResolver) RemoveMemberFromTeam(ctx context.Context, input gqlmo } func (r *mutationResolver) UpdateMemberOfTeam(ctx context.Context, input gqlmodel.UpdateMemberOfTeamInput) (*gqlmodel.UpdateMemberOfTeamPayload, error) { - exit := trace(ctx) - defer exit() - - res, err := r.usecases.Team.UpdateMember(ctx, id.TeamID(input.TeamID), id.UserID(input.UserID), gqlmodel.FromRole(input.Role), getOperator(ctx)) + res, err := usecases(ctx).Team.UpdateMember(ctx, id.TeamID(input.TeamID), id.UserID(input.UserID), gqlmodel.FromRole(input.Role), getOperator(ctx)) if err != nil { return nil, err } diff --git a/internal/adapter/gql/resolver_mutation_user.go b/internal/adapter/gql/resolver_mutation_user.go index 7f1930a1..e6236235 100644 --- a/internal/adapter/gql/resolver_mutation_user.go +++ b/internal/adapter/gql/resolver_mutation_user.go @@ -9,15 +9,12 @@ import ( ) func (r *mutationResolver) Signup(ctx context.Context, input gqlmodel.SignupInput) (*gqlmodel.SignupPayload, error) { - exit := trace(ctx) - defer exit() - secret := "" if input.Secret != nil { secret = *input.Secret } - u, team, err := r.usecases.User.Signup(ctx, interfaces.SignupParam{ + u, team, err := usecases(ctx).User.Signup(ctx, interfaces.SignupParam{ Sub: getSub(ctx), Lang: input.Lang, Theme: gqlmodel.ToTheme(input.Theme), @@ -33,10 +30,7 @@ func (r *mutationResolver) Signup(ctx context.Context, input gqlmodel.SignupInpu } func (r *mutationResolver) UpdateMe(ctx context.Context, input gqlmodel.UpdateMeInput) (*gqlmodel.UpdateMePayload, error) { - exit := trace(ctx) - defer exit() - - res, err := r.usecases.User.UpdateMe(ctx, interfaces.UpdateMeParam{ + res, err := usecases(ctx).User.UpdateMe(ctx, interfaces.UpdateMeParam{ Name: input.Name, Email: input.Email, Lang: input.Lang, @@ -52,10 +46,7 @@ func (r *mutationResolver) UpdateMe(ctx context.Context, input gqlmodel.UpdateMe } func (r *mutationResolver) RemoveMyAuth(ctx context.Context, input gqlmodel.RemoveMyAuthInput) (*gqlmodel.UpdateMePayload, error) { - exit := trace(ctx) - defer exit() - - res, err := r.usecases.User.RemoveMyAuth(ctx, input.Auth, getOperator(ctx)) + res, err := usecases(ctx).User.RemoveMyAuth(ctx, input.Auth, getOperator(ctx)) if err != nil { return nil, err } @@ -64,10 +55,7 @@ func (r *mutationResolver) RemoveMyAuth(ctx context.Context, input gqlmodel.Remo } func (r *mutationResolver) DeleteMe(ctx context.Context, input gqlmodel.DeleteMeInput) (*gqlmodel.DeleteMePayload, error) { - exit := trace(ctx) - defer exit() - - if err := r.usecases.User.DeleteMe(ctx, id.UserID(input.UserID), getOperator(ctx)); err != nil { + if err := usecases(ctx).User.DeleteMe(ctx, id.UserID(input.UserID), getOperator(ctx)); err != nil { return nil, err } diff --git a/internal/adapter/gql/resolver_plugin.go b/internal/adapter/gql/resolver_plugin.go index 2648729e..7440fb18 100644 --- a/internal/adapter/gql/resolver_plugin.go +++ b/internal/adapter/gql/resolver_plugin.go @@ -18,36 +18,27 @@ func (r *Resolver) PluginExtension() PluginExtensionResolver { type pluginResolver struct{ *Resolver } func (r *pluginResolver) PropertySchema(ctx context.Context, obj *gqlmodel.Plugin) (*gqlmodel.PropertySchema, error) { - exit := trace(ctx) - defer exit() - if obj.PropertySchemaID == nil { return nil, nil } - return DataLoadersFromContext(ctx).PropertySchema.Load(*obj.PropertySchemaID) + return dataloaders(ctx).PropertySchema.Load(*obj.PropertySchemaID) } func (r *pluginResolver) Scene(ctx context.Context, obj *gqlmodel.Plugin) (*gqlmodel.Scene, error) { - exit := trace(ctx) - defer exit() - if obj.SceneID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Scene.Load(id.SceneID(*obj.SceneID)) + return dataloaders(ctx).Scene.Load(id.SceneID(*obj.SceneID)) } func (r *pluginResolver) ScenePlugin(ctx context.Context, obj *gqlmodel.Plugin, sceneID *id.ID) (*gqlmodel.ScenePlugin, error) { - exit := trace(ctx) - defer exit() - if sceneID == nil && obj.SceneID != nil { sceneID = obj.SceneID } if sceneID == nil { return nil, nil } - s, err := DataLoadersFromContext(ctx).Scene.Load(id.SceneID(*sceneID)) + s, err := dataloaders(ctx).Scene.Load(id.SceneID(*sceneID)) return s.Plugin(obj.ID), err } @@ -68,31 +59,19 @@ func (r *pluginResolver) TranslatedDescription(ctx context.Context, obj *gqlmode type pluginExtensionResolver struct{ *Resolver } func (r *pluginExtensionResolver) Plugin(ctx context.Context, obj *gqlmodel.PluginExtension) (*gqlmodel.Plugin, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Plugin.Load(obj.PluginID) + return dataloaders(ctx).Plugin.Load(obj.PluginID) } func (r *pluginExtensionResolver) PropertySchema(ctx context.Context, obj *gqlmodel.PluginExtension) (*gqlmodel.PropertySchema, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).PropertySchema.Load(obj.PropertySchemaID) + return dataloaders(ctx).PropertySchema.Load(obj.PropertySchemaID) } func (r *pluginExtensionResolver) SceneWidget(ctx context.Context, obj *gqlmodel.PluginExtension, sceneID id.ID) (*gqlmodel.SceneWidget, error) { - exit := trace(ctx) - defer exit() - - s, err := DataLoadersFromContext(ctx).Scene.Load(id.SceneID(sceneID)) + s, err := dataloaders(ctx).Scene.Load(id.SceneID(sceneID)) return s.Widget(obj.PluginID, obj.ExtensionID), err } func (r *pluginExtensionResolver) TranslatedName(ctx context.Context, obj *gqlmodel.PluginExtension, lang *string) (string, error) { - exit := trace(ctx) - defer exit() - if s, ok := obj.AllTranslatedName[getLang(ctx, lang)]; ok { return s, nil } @@ -100,9 +79,6 @@ func (r *pluginExtensionResolver) TranslatedName(ctx context.Context, obj *gqlmo } func (r *pluginExtensionResolver) TranslatedDescription(ctx context.Context, obj *gqlmodel.PluginExtension, lang *string) (string, error) { - exit := trace(ctx) - defer exit() - if s, ok := obj.AllTranslatedDescription[getLang(ctx, lang)]; ok { return s, nil } diff --git a/internal/adapter/gql/resolver_project.go b/internal/adapter/gql/resolver_project.go index c3a0b961..fe8cb010 100644 --- a/internal/adapter/gql/resolver_project.go +++ b/internal/adapter/gql/resolver_project.go @@ -15,17 +15,11 @@ func (r *Resolver) Project() ProjectResolver { type projectResolver struct{ *Resolver } func (r *projectResolver) Team(ctx context.Context, obj *gqlmodel.Project) (*gqlmodel.Team, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Team.Load(id.TeamID(obj.TeamID)) + return dataloaders(ctx).Team.Load(id.TeamID(obj.TeamID)) } func (r *projectResolver) Scene(ctx context.Context, obj *gqlmodel.Project) (*gqlmodel.Scene, error) { - exit := trace(ctx) - defer exit() - - s, err := r.loaders.Scene.FindByProject(ctx, id.ProjectID(obj.ID)) + s, err := loaders(ctx).Scene.FindByProject(ctx, id.ProjectID(obj.ID)) if err != nil && err != rerror.ErrNotFound { return nil, err } diff --git a/internal/adapter/gql/resolver_property.go b/internal/adapter/gql/resolver_property.go index f0885bfd..8ccd73b9 100644 --- a/internal/adapter/gql/resolver_property.go +++ b/internal/adapter/gql/resolver_property.go @@ -44,17 +44,11 @@ func (r *Resolver) PropertyGroup() PropertyGroupResolver { type propertyResolver struct{ *Resolver } func (r *propertyResolver) Schema(ctx context.Context, obj *gqlmodel.Property) (*gqlmodel.PropertySchema, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).PropertySchema.Load(obj.SchemaID) + return dataloaders(ctx).PropertySchema.Load(obj.SchemaID) } func (r *propertyResolver) Layer(ctx context.Context, obj *gqlmodel.Property) (gqlmodel.Layer, error) { - exit := trace(ctx) - defer exit() - - l, err := r.loaders.Layer.FetchByProperty(ctx, id.PropertyID(obj.ID)) + l, err := loaders(ctx).Layer.FetchByProperty(ctx, id.PropertyID(obj.ID)) if err != nil || errors.Is(err, rerror.ErrNotFound) { return nil, nil } @@ -62,10 +56,7 @@ func (r *propertyResolver) Layer(ctx context.Context, obj *gqlmodel.Property) (g } func (r *propertyResolver) Merged(ctx context.Context, obj *gqlmodel.Property) (*gqlmodel.MergedProperty, error) { - exit := trace(ctx) - defer exit() - - l, err := r.loaders.Layer.FetchByProperty(ctx, id.PropertyID(obj.ID)) + l, err := loaders(ctx).Layer.FetchByProperty(ctx, id.PropertyID(obj.ID)) if err != nil { if errors.Is(err, rerror.ErrNotFound) { return nil, nil @@ -94,24 +85,15 @@ func (r *propertyResolver) Merged(ctx context.Context, obj *gqlmodel.Property) ( type propertyFieldResolver struct{ *Resolver } func (r *propertyFieldResolver) Parent(ctx context.Context, obj *gqlmodel.PropertyField) (*gqlmodel.Property, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Property.Load(id.PropertyID(obj.ParentID)) + return dataloaders(ctx).Property.Load(id.PropertyID(obj.ParentID)) } func (r *propertyFieldResolver) Schema(ctx context.Context, obj *gqlmodel.PropertyField) (*gqlmodel.PropertySchema, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).PropertySchema.Load(obj.SchemaID) + return dataloaders(ctx).PropertySchema.Load(obj.SchemaID) } func (r *propertyFieldResolver) Field(ctx context.Context, obj *gqlmodel.PropertyField) (*gqlmodel.PropertySchemaField, error) { - exit := trace(ctx) - defer exit() - - schema, err := DataLoadersFromContext(ctx).PropertySchema.Load(obj.SchemaID) + schema, err := dataloaders(ctx).PropertySchema.Load(obj.SchemaID) if err != nil { return nil, err } @@ -119,33 +101,24 @@ func (r *propertyFieldResolver) Field(ctx context.Context, obj *gqlmodel.Propert } func (r *propertyFieldResolver) ActualValue(ctx context.Context, obj *gqlmodel.PropertyField) (interface{}, error) { - exit := trace(ctx) - defer exit() - - datasetLoader := DataLoadersFromContext(ctx).Dataset + datasetLoader := dataloaders(ctx).Dataset return actualValue(datasetLoader, obj.Value, obj.Links, false) } type propertyFieldLinkResolver struct{ *Resolver } func (r *propertyFieldLinkResolver) Dataset(ctx context.Context, obj *gqlmodel.PropertyFieldLink) (*gqlmodel.Dataset, error) { - exit := trace(ctx) - defer exit() - if obj.DatasetID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Dataset.Load(id.DatasetID(*obj.DatasetID)) + return dataloaders(ctx).Dataset.Load(id.DatasetID(*obj.DatasetID)) } func (r *propertyFieldLinkResolver) DatasetField(ctx context.Context, obj *gqlmodel.PropertyFieldLink) (*gqlmodel.DatasetField, error) { - exit := trace(ctx) - defer exit() - if obj.DatasetID == nil { return nil, nil } - d, err := DataLoadersFromContext(ctx).Dataset.Load(id.DatasetID(*obj.DatasetID)) + d, err := dataloaders(ctx).Dataset.Load(id.DatasetID(*obj.DatasetID)) if err != nil { return nil, err } @@ -153,80 +126,59 @@ func (r *propertyFieldLinkResolver) DatasetField(ctx context.Context, obj *gqlmo } func (r *propertyFieldLinkResolver) DatasetSchema(ctx context.Context, obj *gqlmodel.PropertyFieldLink) (*gqlmodel.DatasetSchema, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).DatasetSchema.Load(id.DatasetSchemaID(obj.DatasetSchemaID)) + return dataloaders(ctx).DatasetSchema.Load(id.DatasetSchemaID(obj.DatasetSchemaID)) } func (r *propertyFieldLinkResolver) DatasetSchemaField(ctx context.Context, obj *gqlmodel.PropertyFieldLink) (*gqlmodel.DatasetSchemaField, error) { - exit := trace(ctx) - defer exit() - - ds, err := DataLoadersFromContext(ctx).DatasetSchema.Load(id.DatasetSchemaID(obj.DatasetSchemaID)) + ds, err := dataloaders(ctx).DatasetSchema.Load(id.DatasetSchemaID(obj.DatasetSchemaID)) return ds.Field(obj.DatasetSchemaFieldID), err } type mergedPropertyResolver struct{ *Resolver } func (r *mergedPropertyResolver) Original(ctx context.Context, obj *gqlmodel.MergedProperty) (*gqlmodel.Property, error) { - exit := trace(ctx) - defer exit() - if obj.OriginalID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Property.Load(id.PropertyID(*obj.OriginalID)) + return dataloaders(ctx).Property.Load(id.PropertyID(*obj.OriginalID)) } func (r *mergedPropertyResolver) Parent(ctx context.Context, obj *gqlmodel.MergedProperty) (*gqlmodel.Property, error) { - exit := trace(ctx) - defer exit() - if obj.ParentID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Property.Load(id.PropertyID(*obj.ParentID)) + return dataloaders(ctx).Property.Load(id.PropertyID(*obj.ParentID)) } func (r *mergedPropertyResolver) Schema(ctx context.Context, obj *gqlmodel.MergedProperty) (*gqlmodel.PropertySchema, error) { - exit := trace(ctx) - defer exit() - if obj.SchemaID == nil { if propertyID := obj.PropertyID(); propertyID != nil { - property, err := DataLoadersFromContext(ctx).Property.Load(id.PropertyID(*propertyID)) + property, err := dataloaders(ctx).Property.Load(id.PropertyID(*propertyID)) if err != nil { return nil, err } if property == nil { return nil, nil } - return DataLoadersFromContext(ctx).PropertySchema.Load(property.SchemaID) + return dataloaders(ctx).PropertySchema.Load(property.SchemaID) } return nil, nil } - return DataLoadersFromContext(ctx).PropertySchema.Load(*obj.SchemaID) + return dataloaders(ctx).PropertySchema.Load(*obj.SchemaID) } func (r *mergedPropertyResolver) LinkedDataset(ctx context.Context, obj *gqlmodel.MergedProperty) (*gqlmodel.Dataset, error) { - exit := trace(ctx) - defer exit() - if obj.LinkedDatasetID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Dataset.Load(id.DatasetID(*obj.LinkedDatasetID)) + return dataloaders(ctx).Dataset.Load(id.DatasetID(*obj.LinkedDatasetID)) } func (r *mergedPropertyResolver) Groups(ctx context.Context, obj *gqlmodel.MergedProperty) ([]*gqlmodel.MergedPropertyGroup, error) { - exit := trace(ctx) - defer exit() - if obj.Groups != nil { return obj.Groups, nil } - m, err := r.loaders.Property.FetchMerged(ctx, obj.OriginalID, obj.ParentID, obj.LinkedDatasetID) + m, err := loaders(ctx).Property.FetchMerged(ctx, obj.OriginalID, obj.ParentID, obj.LinkedDatasetID) if err != nil || m == nil { return nil, err } @@ -236,13 +188,10 @@ func (r *mergedPropertyResolver) Groups(ctx context.Context, obj *gqlmodel.Merge type mergedPropertyGroupResolver struct{ *Resolver } func (r *mergedPropertyGroupResolver) Original(ctx context.Context, obj *gqlmodel.MergedPropertyGroup) (*gqlmodel.PropertyGroup, error) { - exit := trace(ctx) - defer exit() - if obj.OriginalID == nil || obj.OriginalPropertyID == nil { return nil, nil } - p, err := DataLoadersFromContext(ctx).Property.Load(id.PropertyID(*obj.OriginalID)) + p, err := dataloaders(ctx).Property.Load(id.PropertyID(*obj.OriginalID)) if err != nil { return nil, err } @@ -253,13 +202,10 @@ func (r *mergedPropertyGroupResolver) Original(ctx context.Context, obj *gqlmode } func (r *mergedPropertyGroupResolver) Parent(ctx context.Context, obj *gqlmodel.MergedPropertyGroup) (*gqlmodel.PropertyGroup, error) { - exit := trace(ctx) - defer exit() - if obj.ParentID == nil || obj.ParentPropertyID == nil { return nil, nil } - p, err := DataLoadersFromContext(ctx).Property.Load(id.PropertyID(*obj.ParentID)) + p, err := dataloaders(ctx).Property.Load(id.PropertyID(*obj.ParentID)) if err != nil { return nil, err } @@ -270,94 +216,67 @@ func (r *mergedPropertyGroupResolver) Parent(ctx context.Context, obj *gqlmodel. } func (r *mergedPropertyGroupResolver) OriginalProperty(ctx context.Context, obj *gqlmodel.MergedPropertyGroup) (*gqlmodel.Property, error) { - exit := trace(ctx) - defer exit() - if obj.OriginalID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Property.Load(id.PropertyID(*obj.OriginalID)) + return dataloaders(ctx).Property.Load(id.PropertyID(*obj.OriginalID)) } func (r *mergedPropertyGroupResolver) ParentProperty(ctx context.Context, obj *gqlmodel.MergedPropertyGroup) (*gqlmodel.Property, error) { - exit := trace(ctx) - defer exit() - if obj.ParentID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Property.Load(id.PropertyID(*obj.ParentID)) + return dataloaders(ctx).Property.Load(id.PropertyID(*obj.ParentID)) } func (r *mergedPropertyGroupResolver) Schema(ctx context.Context, obj *gqlmodel.MergedPropertyGroup) (*gqlmodel.PropertySchema, error) { - exit := trace(ctx) - defer exit() - if obj.SchemaID == nil { if propertyID := obj.PropertyID(); propertyID != nil { - property, err := DataLoadersFromContext(ctx).Property.Load(id.PropertyID(*propertyID)) + property, err := dataloaders(ctx).Property.Load(id.PropertyID(*propertyID)) if err != nil { return nil, err } if property == nil { return nil, nil } - return DataLoadersFromContext(ctx).PropertySchema.Load(property.SchemaID) + return dataloaders(ctx).PropertySchema.Load(property.SchemaID) } return nil, nil } - return DataLoadersFromContext(ctx).PropertySchema.Load(*obj.SchemaID) + return dataloaders(ctx).PropertySchema.Load(*obj.SchemaID) } func (r *mergedPropertyGroupResolver) LinkedDataset(ctx context.Context, obj *gqlmodel.MergedPropertyGroup) (*gqlmodel.Dataset, error) { - exit := trace(ctx) - defer exit() - if obj.LinkedDatasetID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Dataset.Load(id.DatasetID(*obj.LinkedDatasetID)) + return dataloaders(ctx).Dataset.Load(id.DatasetID(*obj.LinkedDatasetID)) } type mergedPropertyFieldResolver struct{ *Resolver } func (r *mergedPropertyFieldResolver) Schema(ctx context.Context, obj *gqlmodel.MergedPropertyField) (*gqlmodel.PropertySchema, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).PropertySchema.Load(obj.SchemaID) + return dataloaders(ctx).PropertySchema.Load(obj.SchemaID) } func (r *mergedPropertyFieldResolver) Field(ctx context.Context, obj *gqlmodel.MergedPropertyField) (*gqlmodel.PropertySchemaField, error) { - exit := trace(ctx) - defer exit() - - s, err := DataLoadersFromContext(ctx).PropertySchema.Load(obj.SchemaID) + s, err := dataloaders(ctx).PropertySchema.Load(obj.SchemaID) return s.Field(obj.FieldID), err } func (r *mergedPropertyFieldResolver) ActualValue(ctx context.Context, obj *gqlmodel.MergedPropertyField) (interface{}, error) { - exit := trace(ctx) - defer exit() - - datasetLoader := DataLoadersFromContext(ctx).Dataset + datasetLoader := dataloaders(ctx).Dataset return actualValue(datasetLoader, obj.Value, obj.Links, obj.Overridden) } type propertyGroupListResolver struct{ *Resolver } func (*propertyGroupListResolver) Schema(ctx context.Context, obj *gqlmodel.PropertyGroupList) (*gqlmodel.PropertySchema, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).PropertySchema.Load(obj.SchemaID) + return dataloaders(ctx).PropertySchema.Load(obj.SchemaID) } func (*propertyGroupListResolver) SchemaGroup(ctx context.Context, obj *gqlmodel.PropertyGroupList) (*gqlmodel.PropertySchemaGroup, error) { - exit := trace(ctx) - defer exit() - - s, err := DataLoadersFromContext(ctx).PropertySchema.Load(obj.SchemaID) + s, err := dataloaders(ctx).PropertySchema.Load(obj.SchemaID) if err != nil { return nil, err } @@ -367,17 +286,11 @@ func (*propertyGroupListResolver) SchemaGroup(ctx context.Context, obj *gqlmodel type propertyGroupResolver struct{ *Resolver } func (*propertyGroupResolver) Schema(ctx context.Context, obj *gqlmodel.PropertyGroup) (*gqlmodel.PropertySchema, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).PropertySchema.Load(obj.SchemaID) + return dataloaders(ctx).PropertySchema.Load(obj.SchemaID) } func (*propertyGroupResolver) SchemaGroup(ctx context.Context, obj *gqlmodel.PropertyGroup) (*gqlmodel.PropertySchemaGroup, error) { - exit := trace(ctx) - defer exit() - - s, err := DataLoadersFromContext(ctx).PropertySchema.Load(obj.SchemaID) + s, err := dataloaders(ctx).PropertySchema.Load(obj.SchemaID) if err != nil { return nil, err } diff --git a/internal/adapter/gql/resolver_property_schema.go b/internal/adapter/gql/resolver_property_schema.go index 5efe5196..433c6022 100644 --- a/internal/adapter/gql/resolver_property_schema.go +++ b/internal/adapter/gql/resolver_property_schema.go @@ -25,9 +25,6 @@ func (r *Resolver) PropertySchemaGroup() PropertySchemaGroupResolver { type propertySchemaFieldResolver struct{ *Resolver } func (r *propertySchemaFieldResolver) TranslatedTitle(ctx context.Context, obj *gqlmodel.PropertySchemaField, lang *string) (string, error) { - exit := trace(ctx) - defer exit() - if s, ok := obj.AllTranslatedTitle[getLang(ctx, lang)]; ok { return s, nil } @@ -35,9 +32,6 @@ func (r *propertySchemaFieldResolver) TranslatedTitle(ctx context.Context, obj * } func (r *propertySchemaFieldResolver) TranslatedDescription(ctx context.Context, obj *gqlmodel.PropertySchemaField, lang *string) (string, error) { - exit := trace(ctx) - defer exit() - if s, ok := obj.AllTranslatedDescription[getLang(ctx, lang)]; ok { return s, nil } @@ -47,41 +41,29 @@ func (r *propertySchemaFieldResolver) TranslatedDescription(ctx context.Context, type propertyLinkableFieldsResolver struct{ *Resolver } func (r *propertyLinkableFieldsResolver) Schema(ctx context.Context, obj *gqlmodel.PropertyLinkableFields) (*gqlmodel.PropertySchema, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).PropertySchema.Load(obj.SchemaID) + return dataloaders(ctx).PropertySchema.Load(obj.SchemaID) } func (r *propertyLinkableFieldsResolver) LatlngField(ctx context.Context, obj *gqlmodel.PropertyLinkableFields) (*gqlmodel.PropertySchemaField, error) { - exit := trace(ctx) - defer exit() - if obj.Latlng == nil { return nil, nil } - ps, err := DataLoadersFromContext(ctx).PropertySchema.Load(obj.SchemaID) + ps, err := dataloaders(ctx).PropertySchema.Load(obj.SchemaID) return ps.Field(*obj.Latlng), err } func (r *propertyLinkableFieldsResolver) URLField(ctx context.Context, obj *gqlmodel.PropertyLinkableFields) (*gqlmodel.PropertySchemaField, error) { - exit := trace(ctx) - defer exit() - if obj.URL == nil { return nil, nil } - ps, err := DataLoadersFromContext(ctx).PropertySchema.Load(obj.SchemaID) + ps, err := dataloaders(ctx).PropertySchema.Load(obj.SchemaID) return ps.Field(*obj.URL), err } type propertySchemaGroupResolver struct{ *Resolver } func (r *propertySchemaGroupResolver) Schema(ctx context.Context, obj *gqlmodel.PropertySchemaGroup) (*gqlmodel.PropertySchema, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).PropertySchema.Load(obj.SchemaID) + return dataloaders(ctx).PropertySchema.Load(obj.SchemaID) } func (r *propertySchemaGroupResolver) TranslatedTitle(ctx context.Context, obj *gqlmodel.PropertySchemaGroup, lang *string) (string, error) { diff --git a/internal/adapter/gql/resolver_query.go b/internal/adapter/gql/resolver_query.go index 5d8775c7..946dfb74 100644 --- a/internal/adapter/gql/resolver_query.go +++ b/internal/adapter/gql/resolver_query.go @@ -15,16 +15,10 @@ func (r *Resolver) Query() QueryResolver { type queryResolver struct{ *Resolver } func (r *queryResolver) Assets(ctx context.Context, teamID id.ID, first *int, last *int, after *usecase.Cursor, before *usecase.Cursor) (*gqlmodel.AssetConnection, error) { - exit := trace(ctx) - defer exit() - - return r.loaders.Asset.FindByTeam(ctx, teamID, first, last, before, after) + return loaders(ctx).Asset.FindByTeam(ctx, teamID, first, last, before, after) } func (r *queryResolver) Me(ctx context.Context) (*gqlmodel.User, error) { - exit := trace(ctx) - defer exit() - u := getUser(ctx) if u == nil { return nil, nil @@ -33,10 +27,7 @@ func (r *queryResolver) Me(ctx context.Context) (*gqlmodel.User, error) { } func (r *queryResolver) Node(ctx context.Context, i id.ID, typeArg gqlmodel.NodeType) (gqlmodel.Node, error) { - exit := trace(ctx) - defer exit() - - dataloaders := DataLoadersFromContext(ctx) + dataloaders := dataloaders(ctx) switch typeArg { case gqlmodel.NodeTypeAsset: result, err := dataloaders.Asset.Load(id.AssetID(i)) @@ -103,10 +94,7 @@ func (r *queryResolver) Node(ctx context.Context, i id.ID, typeArg gqlmodel.Node } func (r *queryResolver) Nodes(ctx context.Context, ids []*id.ID, typeArg gqlmodel.NodeType) ([]gqlmodel.Node, error) { - exit := trace(ctx) - defer exit() - - dataloaders := DataLoadersFromContext(ctx) + dataloaders := dataloaders(ctx) switch typeArg { case gqlmodel.NodeTypeAsset: data, err := dataloaders.Asset.LoadAll(id.AssetIDsFromIDRef(ids)) @@ -214,16 +202,10 @@ func (r *queryResolver) Nodes(ctx context.Context, ids []*id.ID, typeArg gqlmode } func (r *queryResolver) PropertySchema(ctx context.Context, i id.PropertySchemaID) (*gqlmodel.PropertySchema, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).PropertySchema.Load(i) + return dataloaders(ctx).PropertySchema.Load(i) } func (r *queryResolver) PropertySchemas(ctx context.Context, ids []*id.PropertySchemaID) ([]*gqlmodel.PropertySchema, error) { - exit := trace(ctx) - defer exit() - ids2 := make([]id.PropertySchemaID, 0, len(ids)) for _, i := range ids { if i != nil { @@ -231,7 +213,7 @@ func (r *queryResolver) PropertySchemas(ctx context.Context, ids []*id.PropertyS } } - data, err := DataLoadersFromContext(ctx).PropertySchema.LoadAll(ids2) + data, err := dataloaders(ctx).PropertySchema.LoadAll(ids2) if len(err) > 0 && err[0] != nil { return nil, err[0] } @@ -240,16 +222,10 @@ func (r *queryResolver) PropertySchemas(ctx context.Context, ids []*id.PropertyS } func (r *queryResolver) Plugin(ctx context.Context, id id.PluginID) (*gqlmodel.Plugin, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Plugin.Load(id) + return dataloaders(ctx).Plugin.Load(id) } func (r *queryResolver) Plugins(ctx context.Context, ids []*id.PluginID) ([]*gqlmodel.Plugin, error) { - exit := trace(ctx) - defer exit() - ids2 := make([]id.PluginID, 0, len(ids)) for _, i := range ids { if i != nil { @@ -257,7 +233,7 @@ func (r *queryResolver) Plugins(ctx context.Context, ids []*id.PluginID) ([]*gql } } - data, err := DataLoadersFromContext(ctx).Plugin.LoadAll(ids2) + data, err := dataloaders(ctx).Plugin.LoadAll(ids2) if len(err) > 0 && err[0] != nil { return nil, err[0] } @@ -266,10 +242,7 @@ func (r *queryResolver) Plugins(ctx context.Context, ids []*id.PluginID) ([]*gql } func (r *queryResolver) Layer(ctx context.Context, layerID id.ID) (gqlmodel.Layer, error) { - exit := trace(ctx) - defer exit() - - dataloaders := DataLoadersFromContext(ctx) + dataloaders := dataloaders(ctx) result, err := dataloaders.Layer.Load(id.LayerID(layerID)) if result == nil || *result == nil { return nil, nil @@ -278,64 +251,37 @@ func (r *queryResolver) Layer(ctx context.Context, layerID id.ID) (gqlmodel.Laye } func (r *queryResolver) Scene(ctx context.Context, projectID id.ID) (*gqlmodel.Scene, error) { - exit := trace(ctx) - defer exit() - - return r.loaders.Scene.FindByProject(ctx, id.ProjectID(projectID)) + return loaders(ctx).Scene.FindByProject(ctx, id.ProjectID(projectID)) } func (r *queryResolver) Projects(ctx context.Context, teamID id.ID, includeArchived *bool, first *int, last *int, after *usecase.Cursor, before *usecase.Cursor) (*gqlmodel.ProjectConnection, error) { - exit := trace(ctx) - defer exit() - - return r.loaders.Project.FindByTeam(ctx, id.TeamID(teamID), first, last, before, after) + return loaders(ctx).Project.FindByTeam(ctx, id.TeamID(teamID), first, last, before, after) } func (r *queryResolver) DatasetSchemas(ctx context.Context, sceneID id.ID, first *int, last *int, after *usecase.Cursor, before *usecase.Cursor) (*gqlmodel.DatasetSchemaConnection, error) { - exit := trace(ctx) - defer exit() - - return r.loaders.Dataset.FindSchemaByScene(ctx, sceneID, first, last, before, after) + return loaders(ctx).Dataset.FindSchemaByScene(ctx, sceneID, first, last, before, after) } func (r *queryResolver) DynamicDatasetSchemas(ctx context.Context, sceneID id.ID) ([]*gqlmodel.DatasetSchema, error) { - exit := trace(ctx) - defer exit() - - return r.loaders.Dataset.FindDynamicSchemasByScene(ctx, sceneID) + return loaders(ctx).Dataset.FindDynamicSchemasByScene(ctx, sceneID) } func (r *queryResolver) Datasets(ctx context.Context, datasetSchemaID id.ID, first *int, last *int, after *usecase.Cursor, before *usecase.Cursor) (*gqlmodel.DatasetConnection, error) { - exit := trace(ctx) - defer exit() - - return r.loaders.Dataset.FindBySchema(ctx, datasetSchemaID, first, last, before, after) + return loaders(ctx).Dataset.FindBySchema(ctx, datasetSchemaID, first, last, before, after) } func (r *queryResolver) SceneLock(ctx context.Context, sceneID id.ID) (*gqlmodel.SceneLockMode, error) { - exit := trace(ctx) - defer exit() - - return r.loaders.Scene.FetchLock(ctx, id.SceneID(sceneID)) + return loaders(ctx).Scene.FetchLock(ctx, id.SceneID(sceneID)) } func (r *queryResolver) SearchUser(ctx context.Context, nameOrEmail string) (*gqlmodel.SearchedUser, error) { - exit := trace(ctx) - defer exit() - - return r.loaders.User.SearchUser(ctx, nameOrEmail) + return loaders(ctx).User.SearchUser(ctx, nameOrEmail) } func (r *queryResolver) CheckProjectAlias(ctx context.Context, alias string) (*gqlmodel.ProjectAliasAvailability, error) { - exit := trace(ctx) - defer exit() - - return r.loaders.Project.CheckAlias(ctx, alias) + return loaders(ctx).Project.CheckAlias(ctx, alias) } func (r *queryResolver) InstallablePlugins(ctx context.Context) ([]*gqlmodel.PluginMetadata, error) { - exit := trace(ctx) - defer exit() - - return r.loaders.Plugin.FetchPluginMetadata(ctx) + return loaders(ctx).Plugin.FetchPluginMetadata(ctx) } diff --git a/internal/adapter/gql/resolver_scene.go b/internal/adapter/gql/resolver_scene.go index fa9dd710..94624741 100644 --- a/internal/adapter/gql/resolver_scene.go +++ b/internal/adapter/gql/resolver_scene.go @@ -27,31 +27,19 @@ func (r *Resolver) Cluster() ClusterResolver { type sceneResolver struct{ *Resolver } func (r *sceneResolver) Project(ctx context.Context, obj *gqlmodel.Scene) (*gqlmodel.Project, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Project.Load(id.ProjectID(obj.ProjectID)) + return dataloaders(ctx).Project.Load(id.ProjectID(obj.ProjectID)) } func (r *sceneResolver) Team(ctx context.Context, obj *gqlmodel.Scene) (*gqlmodel.Team, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Team.Load(id.TeamID(obj.TeamID)) + return dataloaders(ctx).Team.Load(id.TeamID(obj.TeamID)) } func (r *sceneResolver) Property(ctx context.Context, obj *gqlmodel.Scene) (*gqlmodel.Property, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Property.Load(id.PropertyID(obj.PropertyID)) + return dataloaders(ctx).Property.Load(id.PropertyID(obj.PropertyID)) } func (r *sceneResolver) RootLayer(ctx context.Context, obj *gqlmodel.Scene) (*gqlmodel.LayerGroup, error) { - exit := trace(ctx) - defer exit() - - layer, err := DataLoadersFromContext(ctx).Layer.Load(id.LayerID(obj.RootLayerID)) + layer, err := dataloaders(ctx).Layer.Load(id.LayerID(obj.RootLayerID)) if err != nil { return nil, err } @@ -66,17 +54,11 @@ func (r *sceneResolver) RootLayer(ctx context.Context, obj *gqlmodel.Scene) (*gq } func (r *sceneResolver) DatasetSchemas(ctx context.Context, obj *gqlmodel.Scene, first *int, last *int, after *usecase.Cursor, before *usecase.Cursor) (*gqlmodel.DatasetSchemaConnection, error) { - exit := trace(ctx) - defer exit() - - return r.loaders.Dataset.FindSchemaByScene(ctx, obj.ID, first, last, before, after) + return loaders(ctx).Dataset.FindSchemaByScene(ctx, obj.ID, first, last, before, after) } func (r *sceneResolver) LockMode(ctx context.Context, obj *gqlmodel.Scene) (gqlmodel.SceneLockMode, error) { - exit := trace(ctx) - defer exit() - - sl, err := r.loaders.Scene.FetchLock(ctx, id.SceneID(obj.ID)) + sl, err := loaders(ctx).Scene.FetchLock(ctx, id.SceneID(obj.ID)) if err != nil { return gqlmodel.SceneLockModeFree, err } @@ -84,10 +66,7 @@ func (r *sceneResolver) LockMode(ctx context.Context, obj *gqlmodel.Scene) (gqlm } func (r *sceneResolver) Tags(ctx context.Context, obj *gqlmodel.Scene) ([]gqlmodel.Tag, error) { - exit := trace(ctx) - defer exit() - - tags, err := r.usecases.Tag.FetchByScene(ctx, id.SceneID(obj.ID), getOperator(ctx)) + tags, err := usecases(ctx).Tag.FetchByScene(ctx, id.SceneID(obj.ID), getOperator(ctx)) if err != nil { return nil, err } @@ -102,35 +81,23 @@ func (r *sceneResolver) Tags(ctx context.Context, obj *gqlmodel.Scene) ([]gqlmod type scenePluginResolver struct{ *Resolver } func (r *scenePluginResolver) Plugin(ctx context.Context, obj *gqlmodel.ScenePlugin) (*gqlmodel.Plugin, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Plugin.Load(obj.PluginID) + return dataloaders(ctx).Plugin.Load(obj.PluginID) } func (r *scenePluginResolver) Property(ctx context.Context, obj *gqlmodel.ScenePlugin) (*gqlmodel.Property, error) { - exit := trace(ctx) - defer exit() - if obj.PropertyID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Property.Load(id.PropertyID(*obj.PropertyID)) + return dataloaders(ctx).Property.Load(id.PropertyID(*obj.PropertyID)) } type sceneWidgetResolver struct{ *Resolver } func (r *sceneWidgetResolver) Plugin(ctx context.Context, obj *gqlmodel.SceneWidget) (*gqlmodel.Plugin, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Plugin.Load(obj.PluginID) + return dataloaders(ctx).Plugin.Load(obj.PluginID) } func (r *sceneWidgetResolver) Extension(ctx context.Context, obj *gqlmodel.SceneWidget) (*gqlmodel.PluginExtension, error) { - exit := trace(ctx) - defer exit() - - plugin, err := DataLoadersFromContext(ctx).Plugin.Load(obj.PluginID) + plugin, err := dataloaders(ctx).Plugin.Load(obj.PluginID) if err != nil { return nil, err } @@ -143,17 +110,11 @@ func (r *sceneWidgetResolver) Extension(ctx context.Context, obj *gqlmodel.Scene } func (r *sceneWidgetResolver) Property(ctx context.Context, obj *gqlmodel.SceneWidget) (*gqlmodel.Property, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Property.Load(id.PropertyID(obj.PropertyID)) + return dataloaders(ctx).Property.Load(id.PropertyID(obj.PropertyID)) } type clusterResolver struct{ *Resolver } func (r *clusterResolver) Property(ctx context.Context, obj *gqlmodel.Cluster) (*gqlmodel.Property, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Property.Load(id.PropertyID(obj.PropertyID)) + return dataloaders(ctx).Property.Load(id.PropertyID(obj.PropertyID)) } diff --git a/internal/adapter/gql/resolver_tag.go b/internal/adapter/gql/resolver_tag.go index 5a378e54..7eb57243 100644 --- a/internal/adapter/gql/resolver_tag.go +++ b/internal/adapter/gql/resolver_tag.go @@ -14,51 +14,36 @@ func (r *Resolver) TagItem() TagItemResolver { } func (t tagItemResolver) LinkedDatasetSchema(ctx context.Context, obj *gqlmodel.TagItem) (*gqlmodel.DatasetSchema, error) { - exit := trace(ctx) - defer exit() - if obj.LinkedDatasetID == nil { return nil, nil } - return DataLoadersFromContext(ctx).DatasetSchema.Load(id.DatasetSchemaID(*obj.LinkedDatasetSchemaID)) + return dataloaders(ctx).DatasetSchema.Load(id.DatasetSchemaID(*obj.LinkedDatasetSchemaID)) } func (t tagItemResolver) LinkedDataset(ctx context.Context, obj *gqlmodel.TagItem) (*gqlmodel.Dataset, error) { - exit := trace(ctx) - defer exit() - if obj.LinkedDatasetID == nil { return nil, nil } - return DataLoadersFromContext(ctx).Dataset.Load(id.DatasetID(*obj.LinkedDatasetID)) + return dataloaders(ctx).Dataset.Load(id.DatasetID(*obj.LinkedDatasetID)) } func (t tagItemResolver) LinkedDatasetField(ctx context.Context, obj *gqlmodel.TagItem) (*gqlmodel.DatasetField, error) { - exit := trace(ctx) - defer exit() - if obj.LinkedDatasetID == nil { return nil, nil } - ds, err := DataLoadersFromContext(ctx).Dataset.Load(id.DatasetID(*obj.LinkedDatasetID)) + ds, err := dataloaders(ctx).Dataset.Load(id.DatasetID(*obj.LinkedDatasetID)) return ds.Field(*obj.LinkedDatasetFieldID), err } func (t tagItemResolver) Parent(ctx context.Context, obj *gqlmodel.TagItem) (*gqlmodel.TagGroup, error) { - exit := trace(ctx) - defer exit() - if obj.ParentID == nil { return nil, nil } - return DataLoadersFromContext(ctx).TagGroup.Load(id.TagID(*obj.ParentID)) + return dataloaders(ctx).TagGroup.Load(id.TagID(*obj.ParentID)) } func (tg tagItemResolver) Layers(ctx context.Context, obj *gqlmodel.TagItem) ([]gqlmodel.Layer, error) { - exit := trace(ctx) - defer exit() - - return tg.loaders.Layer.FetchByTag(ctx, id.TagID(obj.ID)) + return loaders(ctx).Layer.FetchByTag(ctx, id.TagID(obj.ID)) } type tagGroupResolver struct{ *Resolver } @@ -67,10 +52,7 @@ func (r *Resolver) TagGroup() TagGroupResolver { return &tagGroupResolver{r} } -func (tg tagGroupResolver) Tags(ctx context.Context, obj *gqlmodel.TagGroup) ([]*gqlmodel.TagItem, error) { - exit := trace(ctx) - defer exit() - +func (r tagGroupResolver) Tags(ctx context.Context, obj *gqlmodel.TagGroup) ([]*gqlmodel.TagItem, error) { tagIds := make([]id.TagID, 0, len(obj.TagIds)) for _, i := range obj.TagIds { if i == nil { @@ -78,23 +60,17 @@ func (tg tagGroupResolver) Tags(ctx context.Context, obj *gqlmodel.TagGroup) ([] } tagIds = append(tagIds, id.TagID(*i)) } - tagItems, err := DataLoadersFromContext(ctx).TagItem.LoadAll(tagIds) + tagItems, err := dataloaders(ctx).TagItem.LoadAll(tagIds) if len(err) > 0 && err[0] != nil { return nil, err[0] } return tagItems, nil } -func (tg tagGroupResolver) Scene(ctx context.Context, obj *gqlmodel.TagGroup) (*gqlmodel.Scene, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Scene.Load(id.SceneID(obj.SceneID)) +func (r tagGroupResolver) Scene(ctx context.Context, obj *gqlmodel.TagGroup) (*gqlmodel.Scene, error) { + return dataloaders(ctx).Scene.Load(id.SceneID(obj.SceneID)) } -func (tg tagGroupResolver) Layers(ctx context.Context, obj *gqlmodel.TagGroup) ([]gqlmodel.Layer, error) { - exit := trace(ctx) - defer exit() - - return tg.loaders.Layer.FetchByTag(ctx, id.TagID(obj.ID)) +func (r tagGroupResolver) Layers(ctx context.Context, obj *gqlmodel.TagGroup) ([]gqlmodel.Layer, error) { + return loaders(ctx).Layer.FetchByTag(ctx, id.TagID(obj.ID)) } diff --git a/internal/adapter/gql/resolver_team.go b/internal/adapter/gql/resolver_team.go index 3501bb73..c7a1c49c 100644 --- a/internal/adapter/gql/resolver_team.go +++ b/internal/adapter/gql/resolver_team.go @@ -19,24 +19,15 @@ func (r *Resolver) TeamMember() TeamMemberResolver { type teamResolver struct{ *Resolver } func (r *teamResolver) Assets(ctx context.Context, obj *gqlmodel.Team, first *int, last *int, after *usecase.Cursor, before *usecase.Cursor) (*gqlmodel.AssetConnection, error) { - exit := trace(ctx) - defer exit() - - return r.loaders.Asset.FindByTeam(ctx, obj.ID, first, last, before, after) + return loaders(ctx).Asset.FindByTeam(ctx, obj.ID, first, last, before, after) } func (r *teamResolver) Projects(ctx context.Context, obj *gqlmodel.Team, includeArchived *bool, first *int, last *int, after *usecase.Cursor, before *usecase.Cursor) (*gqlmodel.ProjectConnection, error) { - exit := trace(ctx) - defer exit() - - return r.loaders.Project.FindByTeam(ctx, id.TeamID(obj.ID), first, last, before, after) + return loaders(ctx).Project.FindByTeam(ctx, id.TeamID(obj.ID), first, last, before, after) } type teamMemberResolver struct{ *Resolver } func (r *teamMemberResolver) User(ctx context.Context, obj *gqlmodel.TeamMember) (*gqlmodel.User, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).User.Load(id.UserID(obj.UserID)) + return dataloaders(ctx).User.Load(id.UserID(obj.UserID)) } diff --git a/internal/adapter/gql/resolver_user.go b/internal/adapter/gql/resolver_user.go index 3caba5b5..ad443f5d 100644 --- a/internal/adapter/gql/resolver_user.go +++ b/internal/adapter/gql/resolver_user.go @@ -14,15 +14,9 @@ func (r *Resolver) User() UserResolver { type userResolver struct{ *Resolver } func (r *userResolver) MyTeam(ctx context.Context, obj *gqlmodel.User) (*gqlmodel.Team, error) { - exit := trace(ctx) - defer exit() - - return DataLoadersFromContext(ctx).Team.Load(id.TeamID(obj.MyTeamID)) + return dataloaders(ctx).Team.Load(id.TeamID(obj.MyTeamID)) } func (r *userResolver) Teams(ctx context.Context, obj *gqlmodel.User) ([]*gqlmodel.Team, error) { - exit := trace(ctx) - defer exit() - - return r.loaders.Team.FindByUser(ctx, id.UserID(obj.ID)) + return loaders(ctx).Team.FindByUser(ctx, id.UserID(obj.ID)) } diff --git a/internal/adapter/gql/tracer.go b/internal/adapter/gql/tracer.go deleted file mode 100644 index 2fa9c8ef..00000000 --- a/internal/adapter/gql/tracer.go +++ /dev/null @@ -1,151 +0,0 @@ -package gql - -import ( - "context" - "fmt" - "sort" - "sync" - "time" - - "github.com/99designs/gqlgen/graphql" -) - -type tracerKeyStruct struct{} - -var tracerKey = tracerKeyStruct{} - -type Tracer struct { - Spans sync.Map -} - -type span struct { - Name string - StartedAt int64 - EndedAt int64 -} - -func (t *Tracer) AddSpan(s *span) { - if t == nil { - return - } - - var spans []*span - if ss, ok := t.Spans.Load(s.Name); ok { - if ss, ok := ss.([]*span); ok { - spans = append(ss, s) - } else { - spans = []*span{s} - } - } else { - spans = []*span{s} - } - - t.Spans.Store(s.Name, spans) -} - -func (t *Tracer) Print() { - if t == nil { - return - } - - type result struct { - Name string - Max int64 - Min int64 - Avr float64 - Count int - } - var results []result - - t.Spans.Range(func(key, value interface{}) bool { - name := key.(string) - ss := value.([]*span) - - var max, min, sum int64 - for i, s := range ss { - d := s.Duration() - sum += d - if i == 0 { - max = d - min = d - } else { - if max < d { - max = d - } - if min > d { - min = d - } - } - } - - results = append(results, result{ - Name: name, - Max: max, - Min: min, - Avr: float64(sum) / float64(len(ss)), - Count: len(ss), - }) - return true - }) - - sort.Slice(results, func(i, j int) bool { - return results[i].Avr > results[j].Avr - }) - - println("\nGraphQL tracing --------------------------------") - for _, r := range results { - if r.Count == 1 { - fmt.Printf("%s: %.2fms\n", r.Name, float64(r.Min)/1000000.0) - } else { - fmt.Printf("%s: %.2f~%.2fms (avr:%.2fms) (%d)\n", r.Name, float64(r.Min)/1000000.0, float64(r.Max)/1000000.0, r.Avr/1000000.0, r.Count) - } - } - println("------------------------------------------------\n") -} - -func (s *span) Start() { - s.StartedAt = time.Now().UnixNano() -} - -func (s *span) End() { - s.EndedAt = time.Now().UnixNano() -} - -func (s *span) Duration() int64 { - return s.EndedAt - s.StartedAt -} - -func AttachTracer(ctx context.Context, t *Tracer) context.Context { - return context.WithValue(ctx, tracerKey, t) -} - -func ExitTracer(ctx context.Context) { - getTracer(ctx).Print() -} - -func getTracer(ctx context.Context) *Tracer { - if t, ok := ctx.Value(tracerKey).(*Tracer); ok { - return t - } - return nil -} - -func trace(ctx context.Context) func() { - t := getTracer(ctx) - fc := graphql.GetFieldContext(ctx) - - name := fc.Field.Name - if object := fc.Field.ObjectDefinition; object != nil { - name = object.Name + "." + name - } - - s := &span{ - Name: name, - } - s.Start() - t.AddSpan(s) - - return func() { - s.End() - } -} diff --git a/internal/app/auth.go b/internal/app/auth.go index 4743aea1..73aeaf6a 100644 --- a/internal/app/auth.go +++ b/internal/app/auth.go @@ -4,7 +4,7 @@ import ( "context" "github.com/labstack/echo/v4" - "github.com/reearth/reearth-backend/internal/adapter/gql" + "github.com/reearth/reearth-backend/internal/adapter" "github.com/reearth/reearth-backend/internal/usecase" "github.com/reearth/reearth-backend/pkg/id" "github.com/reearth/reearth-backend/pkg/rerror" @@ -28,9 +28,6 @@ func authMiddleware(cfg *ServerConfig) echo.MiddlewareFunc { userID = u } - // attach sub - ctx = context.WithValue(ctx, gql.ContextSub, sub) - // debug mode if cfg.Debug { if userID := c.Request().Header.Get(debugUserHeader); userID != "" { @@ -61,30 +58,6 @@ func authMiddleware(cfg *ServerConfig) echo.MiddlewareFunc { if err != nil && err != rerror.ErrNotFound { return err } - - // Auth0 accounts are already merged into one so it doesn't need to fetch more info from Auth0 - // - // if u == nil && token != "" { - // // user not found by sub - - // // fetch user profile from Auth0 - // data, err := cfg.Gateways.Authenticator.FetchUser(token) - // if err != nil { - // return err - // } - - // // if !data.EmailVerified { - // // return errors.New("email is not verified") - // // } - - // u, err = cfg.Repos.User.FindByEmail(ctx, data.Email) - // if err != nil && err != rerror.ErrNotFound { - // return err - // } - // if u == nil { - // return rerror.ErrUserNotFound - // } - // } } // save a new sub @@ -94,15 +67,14 @@ func authMiddleware(cfg *ServerConfig) echo.MiddlewareFunc { } } - // attach operator op, err := generateOperator(ctx, cfg, u) if err != nil { return err } - ctx = context.WithValue(ctx, gql.ContextOperator, op) - // attach user - ctx = context.WithValue(ctx, gql.ContextUser, u) + ctx = adapter.AttachSub(ctx, sub) + ctx = adapter.AttachOperator(ctx, op) + ctx = adapter.AttachUser(ctx, u) c.SetRequest(req.WithContext(ctx)) return next(c) diff --git a/internal/app/graphql.go b/internal/app/graphql.go index 811aa331..4faf675b 100644 --- a/internal/app/graphql.go +++ b/internal/app/graphql.go @@ -10,6 +10,7 @@ import ( "github.com/99designs/gqlgen/graphql/playground" "github.com/labstack/echo/v4" "github.com/ravilushqa/otelgqlgen" + "github.com/reearth/reearth-backend/internal/adapter" "github.com/reearth/reearth-backend/internal/adapter/gql" "github.com/reearth/reearth-backend/internal/usecase/interfaces" "github.com/vektah/gqlparser/v2/gqlerror" @@ -17,35 +18,6 @@ import ( const enableDataLoaders = true -func dataLoaderMiddleware(container gql.Loaders) echo.MiddlewareFunc { - return func(next echo.HandlerFunc) echo.HandlerFunc { - return func(echoCtx echo.Context) error { - req := echoCtx.Request() - ctx := req.Context() - - ctx = context.WithValue(ctx, gql.DataLoadersKey(), container.DataLoadersWith(ctx, enableDataLoaders)) - echoCtx.SetRequest(req.WithContext(ctx)) - return next(echoCtx) - } - } -} - -func tracerMiddleware(enabled bool) echo.MiddlewareFunc { - return func(next echo.HandlerFunc) echo.HandlerFunc { - return func(echoCtx echo.Context) error { - if !enabled { - return next(echoCtx) - } - req := echoCtx.Request() - ctx := req.Context() - t := &gql.Tracer{} - echoCtx.SetRequest(req.WithContext(gql.AttachTracer(ctx, t))) - defer t.Print() - return next(echoCtx) - } - } -} - func graphqlAPI( ec *echo.Echo, r *echo.Group, @@ -53,7 +25,6 @@ func graphqlAPI( usecases interfaces.Container, ) { playgroundEnabled := conf.Debug || conf.Config.Dev - controllers := gql.NewLoaders(usecases) if playgroundEnabled { r.GET("/graphql", echo.WrapHandler( @@ -62,20 +33,24 @@ func graphqlAPI( } schema := gql.NewExecutableSchema(gql.Config{ - Resolvers: gql.NewResolver(controllers, conf.Debug), + Resolvers: gql.NewResolver(conf.Debug), }) srv := handler.NewDefaultServer(schema) srv.Use(otelgqlgen.Middleware()) + if conf.Config.GraphQL.ComplexityLimit > 0 { srv.Use(extension.FixedComplexityLimit(conf.Config.GraphQL.ComplexityLimit)) } + if playgroundEnabled { srv.Use(extension.Introspection{}) } + srv.Use(extension.AutomaticPersistedQuery{ Cache: lru.New(30), }) + srv.SetErrorPresenter( // show more detailed error messgage in debug mode func(ctx context.Context, e error) *gqlerror.Error { @@ -87,7 +62,14 @@ func graphqlAPI( ) r.POST("/graphql", func(c echo.Context) error { + req := c.Request() + ctx := req.Context() + + ctx = adapter.AttachUsecases(ctx, &usecases) + ctx = gql.AttachUsecases(ctx, &usecases, enableDataLoaders) + c.SetRequest(req.WithContext(ctx)) + srv.ServeHTTP(c.Response(), c.Request()) return nil - }, dataLoaderMiddleware(controllers), tracerMiddleware(false)) + }) } diff --git a/internal/app/private.go b/internal/app/private.go index 4ee108cd..af351557 100644 --- a/internal/app/private.go +++ b/internal/app/private.go @@ -8,14 +8,13 @@ import ( "strings" "github.com/labstack/echo/v4" - "github.com/reearth/reearth-backend/internal/adapter/gql" + "github.com/reearth/reearth-backend/internal/adapter" "github.com/reearth/reearth-backend/internal/usecase" "github.com/reearth/reearth-backend/internal/usecase/repo" "github.com/reearth/reearth-backend/pkg/id" "github.com/reearth/reearth-backend/pkg/layer/encoding" "github.com/reearth/reearth-backend/pkg/layer/merging" "github.com/reearth/reearth-backend/pkg/rerror" - "github.com/reearth/reearth-backend/pkg/user" ) // TODO: move to adapter and usecase layer @@ -60,14 +59,16 @@ func privateAPI( ) { r.GET("/layers/:param", func(c echo.Context) error { ctx := c.Request().Context() - user := c.Request().Context().Value(gql.ContextUser).(*user.User) + user := adapter.User(c.Request().Context()) if user == nil { return &echo.HTTPError{Code: http.StatusUnauthorized, Message: ErrUnauthorized} } - op := c.Request().Context().Value(gql.ContextOperator).(*usecase.Operator) + + op := adapter.Operator(c.Request().Context()) if op == nil { return &echo.HTTPError{Code: http.StatusUnauthorized, Message: ErrOpDenied} } + param := c.Param("param") params := strings.Split(param, ".") if len(params) != 2 { @@ -78,6 +79,7 @@ func privateAPI( if err != nil { return &echo.HTTPError{Code: http.StatusBadRequest, Message: ErrBadID} } + scenes, err := repos.Scene.FindIDsByTeam(ctx, op.ReadableTeams) if err != nil { if errors.Is(rerror.ErrNotFound, err) { @@ -85,6 +87,7 @@ func privateAPI( } return &echo.HTTPError{Code: http.StatusInternalServerError, Message: err} } + layer, err := repos.Layer.FindByID(ctx, lid, scenes) if err != nil { if errors.Is(rerror.ErrNotFound, err) { @@ -92,6 +95,7 @@ func privateAPI( } return &echo.HTTPError{Code: http.StatusInternalServerError, Message: err} } + err = checkScene(ctx, layer.Scene(), op, repos.Scene) if err != nil { if errors.Is(ErrOpDenied, err) { diff --git a/internal/app/public.go b/internal/app/public.go index c536605a..bcc3d5de 100644 --- a/internal/app/public.go +++ b/internal/app/public.go @@ -18,8 +18,12 @@ func publicAPI( repos *repo.Container, gateways *gateway.Container, ) { - controller := http1.NewUserController(interactor.NewUser(repos, gateways, conf.SignupSecret)) - publishedController := http1.NewPublishedController(interactor.NewPublished(repos.Project, gateways.File, "")) + controller := http1.NewUserController( + interactor.NewUser(repos, gateways, conf.SignupSecret), + ) + publishedController := http1.NewPublishedController( + interactor.NewPublished(repos.Project, gateways.File, ""), + ) r.GET("/ping", func(c echo.Context) error { return c.JSON(http.StatusOK, "pong")