From 48615a5356ad9ab72530cb3e45153e27ee0e2ea1 Mon Sep 17 00:00:00 2001 From: vijeyash Date: Mon, 12 Feb 2024 13:32:54 +0530 Subject: [PATCH] added count handlers in graphql --- graphqlserver/graph/generated.go | 734 +++++++++++++++++++++++- graphqlserver/graph/model/models_gen.go | 11 + graphqlserver/graph/schema.graphqls | 13 + graphqlserver/graph/schema.resolvers.go | 100 ++++ 4 files changed, 847 insertions(+), 11 deletions(-) diff --git a/graphqlserver/graph/generated.go b/graphqlserver/graph/generated.go index ba3f13df..a0419d01 100644 --- a/graphqlserver/graph/generated.go +++ b/graphqlserver/graph/generated.go @@ -46,12 +46,23 @@ type DirectiveRoot struct { } type ComplexityRoot struct { + ClusterAPIsCount struct { + ClusterName func(childComplexity int) int + Count func(childComplexity int) int + } + ClusterNamespaceOutdatedCount struct { ClusterName func(childComplexity int) int Namespace func(childComplexity int) int OutdatedCount func(childComplexity int) int } + ClusterNamespaceResourceCount struct { + ClusterName func(childComplexity int) int + Namespace func(childComplexity int) int + ResourceCount func(childComplexity int) int + } + DeletedAPI struct { ClusterName func(childComplexity int) int Deleted func(childComplexity int) int @@ -157,7 +168,10 @@ type ComplexityRoot struct { } Query struct { + AllClusterDeletedAPIsCounts func(childComplexity int) int + AllClusterDeprecatedAPIsCounts func(childComplexity int) int AllClusterNamespaceOutdatedCounts func(childComplexity int) int + AllClusterNamespaceResourceCounts func(childComplexity int) int AllDeletedAPIs func(childComplexity int) int AllDeprecatedAPIs func(childComplexity int) int AllEvents func(childComplexity int) int @@ -282,6 +296,9 @@ type QueryResolver interface { OutdatedImagesByClusterAndNamespace(ctx context.Context, clusterName string, namespace string) ([]*model.OutdatedImage, error) OutdatedImagesCount(ctx context.Context, clusterName string, namespace string) (int, error) AllClusterNamespaceOutdatedCounts(ctx context.Context) ([]*model.ClusterNamespaceOutdatedCount, error) + AllClusterDeprecatedAPIsCounts(ctx context.Context) ([]*model.ClusterAPIsCount, error) + AllClusterDeletedAPIsCounts(ctx context.Context) ([]*model.ClusterAPIsCount, error) + AllClusterNamespaceResourceCounts(ctx context.Context) ([]*model.ClusterNamespaceResourceCount, error) } type executableSchema struct { @@ -303,6 +320,20 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in _ = ec switch typeName + "." + field { + case "ClusterAPIsCount.clusterName": + if e.complexity.ClusterAPIsCount.ClusterName == nil { + break + } + + return e.complexity.ClusterAPIsCount.ClusterName(childComplexity), true + + case "ClusterAPIsCount.count": + if e.complexity.ClusterAPIsCount.Count == nil { + break + } + + return e.complexity.ClusterAPIsCount.Count(childComplexity), true + case "ClusterNamespaceOutdatedCount.clusterName": if e.complexity.ClusterNamespaceOutdatedCount.ClusterName == nil { break @@ -324,6 +355,27 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.ClusterNamespaceOutdatedCount.OutdatedCount(childComplexity), true + case "ClusterNamespaceResourceCount.clusterName": + if e.complexity.ClusterNamespaceResourceCount.ClusterName == nil { + break + } + + return e.complexity.ClusterNamespaceResourceCount.ClusterName(childComplexity), true + + case "ClusterNamespaceResourceCount.namespace": + if e.complexity.ClusterNamespaceResourceCount.Namespace == nil { + break + } + + return e.complexity.ClusterNamespaceResourceCount.Namespace(childComplexity), true + + case "ClusterNamespaceResourceCount.resourceCount": + if e.complexity.ClusterNamespaceResourceCount.ResourceCount == nil { + break + } + + return e.complexity.ClusterNamespaceResourceCount.ResourceCount(childComplexity), true + case "DeletedAPI.ClusterName": if e.complexity.DeletedAPI.ClusterName == nil { break @@ -884,6 +936,20 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.OutdatedImage.VersionsBehind(childComplexity), true + case "Query.allClusterDeletedAPIsCounts": + if e.complexity.Query.AllClusterDeletedAPIsCounts == nil { + break + } + + return e.complexity.Query.AllClusterDeletedAPIsCounts(childComplexity), true + + case "Query.allClusterDeprecatedAPIsCounts": + if e.complexity.Query.AllClusterDeprecatedAPIsCounts == nil { + break + } + + return e.complexity.Query.AllClusterDeprecatedAPIsCounts(childComplexity), true + case "Query.allClusterNamespaceOutdatedCounts": if e.complexity.Query.AllClusterNamespaceOutdatedCounts == nil { break @@ -891,6 +957,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Query.AllClusterNamespaceOutdatedCounts(childComplexity), true + case "Query.allClusterNamespaceResourceCounts": + if e.complexity.Query.AllClusterNamespaceResourceCounts == nil { + break + } + + return e.complexity.Query.AllClusterNamespaceResourceCounts(childComplexity), true + case "Query.allDeletedAPIs": if e.complexity.Query.AllDeletedAPIs == nil { break @@ -1712,6 +1785,94 @@ func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArg // region **************************** field.gotpl ***************************** +func (ec *executionContext) _ClusterAPIsCount_clusterName(ctx context.Context, field graphql.CollectedField, obj *model.ClusterAPIsCount) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ClusterAPIsCount_clusterName(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.ClusterName, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalNString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ClusterAPIsCount_clusterName(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ClusterAPIsCount", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ClusterAPIsCount_count(ctx context.Context, field graphql.CollectedField, obj *model.ClusterAPIsCount) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ClusterAPIsCount_count(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Count, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(int) + fc.Result = res + return ec.marshalNInt2int(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ClusterAPIsCount_count(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ClusterAPIsCount", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Int does not have child fields") + }, + } + return fc, nil +} + func (ec *executionContext) _ClusterNamespaceOutdatedCount_clusterName(ctx context.Context, field graphql.CollectedField, obj *model.ClusterNamespaceOutdatedCount) (ret graphql.Marshaler) { fc, err := ec.fieldContext_ClusterNamespaceOutdatedCount_clusterName(ctx, field) if err != nil { @@ -1844,6 +2005,138 @@ func (ec *executionContext) fieldContext_ClusterNamespaceOutdatedCount_outdatedC return fc, nil } +func (ec *executionContext) _ClusterNamespaceResourceCount_clusterName(ctx context.Context, field graphql.CollectedField, obj *model.ClusterNamespaceResourceCount) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ClusterNamespaceResourceCount_clusterName(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.ClusterName, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalNString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ClusterNamespaceResourceCount_clusterName(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ClusterNamespaceResourceCount", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ClusterNamespaceResourceCount_namespace(ctx context.Context, field graphql.CollectedField, obj *model.ClusterNamespaceResourceCount) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ClusterNamespaceResourceCount_namespace(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Namespace, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalNString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ClusterNamespaceResourceCount_namespace(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ClusterNamespaceResourceCount", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ClusterNamespaceResourceCount_resourceCount(ctx context.Context, field graphql.CollectedField, obj *model.ClusterNamespaceResourceCount) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ClusterNamespaceResourceCount_resourceCount(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.ResourceCount, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(int) + fc.Result = res + return ec.marshalNInt2int(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ClusterNamespaceResourceCount_resourceCount(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ClusterNamespaceResourceCount", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Int does not have child fields") + }, + } + return fc, nil +} + func (ec *executionContext) _DeletedAPI_ClusterName(ctx context.Context, field graphql.CollectedField, obj *model.DeletedAPI) (ret graphql.Marshaler) { fc, err := ec.fieldContext_DeletedAPI_ClusterName(ctx, field) if err != nil { @@ -6235,8 +6528,160 @@ func (ec *executionContext) fieldContext_Query_outdatedImagesCount(ctx context.C return fc, nil } -func (ec *executionContext) _Query_allClusterNamespaceOutdatedCounts(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Query_allClusterNamespaceOutdatedCounts(ctx, field) +func (ec *executionContext) _Query_allClusterNamespaceOutdatedCounts(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Query_allClusterNamespaceOutdatedCounts(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Query().AllClusterNamespaceOutdatedCounts(rctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.([]*model.ClusterNamespaceOutdatedCount) + fc.Result = res + return ec.marshalNClusterNamespaceOutdatedCount2ᚕᚖgithubᚗcomᚋintelopsᚋkubvizᚋgraphqlserverᚋgraphᚋmodelᚐClusterNamespaceOutdatedCountᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Query_allClusterNamespaceOutdatedCounts(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Query", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "clusterName": + return ec.fieldContext_ClusterNamespaceOutdatedCount_clusterName(ctx, field) + case "namespace": + return ec.fieldContext_ClusterNamespaceOutdatedCount_namespace(ctx, field) + case "outdatedCount": + return ec.fieldContext_ClusterNamespaceOutdatedCount_outdatedCount(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ClusterNamespaceOutdatedCount", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Query_allClusterDeprecatedAPIsCounts(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Query_allClusterDeprecatedAPIsCounts(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Query().AllClusterDeprecatedAPIsCounts(rctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.([]*model.ClusterAPIsCount) + fc.Result = res + return ec.marshalNClusterAPIsCount2ᚕᚖgithubᚗcomᚋintelopsᚋkubvizᚋgraphqlserverᚋgraphᚋmodelᚐClusterAPIsCountᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Query_allClusterDeprecatedAPIsCounts(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Query", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "clusterName": + return ec.fieldContext_ClusterAPIsCount_clusterName(ctx, field) + case "count": + return ec.fieldContext_ClusterAPIsCount_count(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ClusterAPIsCount", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Query_allClusterDeletedAPIsCounts(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Query_allClusterDeletedAPIsCounts(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Query().AllClusterDeletedAPIsCounts(rctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.([]*model.ClusterAPIsCount) + fc.Result = res + return ec.marshalNClusterAPIsCount2ᚕᚖgithubᚗcomᚋintelopsᚋkubvizᚋgraphqlserverᚋgraphᚋmodelᚐClusterAPIsCountᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Query_allClusterDeletedAPIsCounts(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Query", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "clusterName": + return ec.fieldContext_ClusterAPIsCount_clusterName(ctx, field) + case "count": + return ec.fieldContext_ClusterAPIsCount_count(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ClusterAPIsCount", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Query_allClusterNamespaceResourceCounts(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Query_allClusterNamespaceResourceCounts(ctx, field) if err != nil { return graphql.Null } @@ -6249,7 +6694,7 @@ func (ec *executionContext) _Query_allClusterNamespaceOutdatedCounts(ctx context }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return ec.resolvers.Query().AllClusterNamespaceOutdatedCounts(rctx) + return ec.resolvers.Query().AllClusterNamespaceResourceCounts(rctx) }) if err != nil { ec.Error(ctx, err) @@ -6261,12 +6706,12 @@ func (ec *executionContext) _Query_allClusterNamespaceOutdatedCounts(ctx context } return graphql.Null } - res := resTmp.([]*model.ClusterNamespaceOutdatedCount) + res := resTmp.([]*model.ClusterNamespaceResourceCount) fc.Result = res - return ec.marshalNClusterNamespaceOutdatedCount2ᚕᚖgithubᚗcomᚋintelopsᚋkubvizᚋgraphqlserverᚋgraphᚋmodelᚐClusterNamespaceOutdatedCountᚄ(ctx, field.Selections, res) + return ec.marshalNClusterNamespaceResourceCount2ᚕᚖgithubᚗcomᚋintelopsᚋkubvizᚋgraphqlserverᚋgraphᚋmodelᚐClusterNamespaceResourceCountᚄ(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Query_allClusterNamespaceOutdatedCounts(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_allClusterNamespaceResourceCounts(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ Object: "Query", Field: field, @@ -6275,13 +6720,13 @@ func (ec *executionContext) fieldContext_Query_allClusterNamespaceOutdatedCounts Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "clusterName": - return ec.fieldContext_ClusterNamespaceOutdatedCount_clusterName(ctx, field) + return ec.fieldContext_ClusterNamespaceResourceCount_clusterName(ctx, field) case "namespace": - return ec.fieldContext_ClusterNamespaceOutdatedCount_namespace(ctx, field) - case "outdatedCount": - return ec.fieldContext_ClusterNamespaceOutdatedCount_outdatedCount(ctx, field) + return ec.fieldContext_ClusterNamespaceResourceCount_namespace(ctx, field) + case "resourceCount": + return ec.fieldContext_ClusterNamespaceResourceCount_resourceCount(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type ClusterNamespaceOutdatedCount", field.Name) + return nil, fmt.Errorf("no field named %q was found under type ClusterNamespaceResourceCount", field.Name) }, } return fc, nil @@ -11138,6 +11583,50 @@ func (ec *executionContext) fieldContext___Type_specifiedByURL(ctx context.Conte // region **************************** object.gotpl **************************** +var clusterAPIsCountImplementors = []string{"ClusterAPIsCount"} + +func (ec *executionContext) _ClusterAPIsCount(ctx context.Context, sel ast.SelectionSet, obj *model.ClusterAPIsCount) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, clusterAPIsCountImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ClusterAPIsCount") + case "clusterName": + out.Values[i] = ec._ClusterAPIsCount_clusterName(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "count": + out.Values[i] = ec._ClusterAPIsCount_count(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + var clusterNamespaceOutdatedCountImplementors = []string{"ClusterNamespaceOutdatedCount"} func (ec *executionContext) _ClusterNamespaceOutdatedCount(ctx context.Context, sel ast.SelectionSet, obj *model.ClusterNamespaceOutdatedCount) graphql.Marshaler { @@ -11187,6 +11676,55 @@ func (ec *executionContext) _ClusterNamespaceOutdatedCount(ctx context.Context, return out } +var clusterNamespaceResourceCountImplementors = []string{"ClusterNamespaceResourceCount"} + +func (ec *executionContext) _ClusterNamespaceResourceCount(ctx context.Context, sel ast.SelectionSet, obj *model.ClusterNamespaceResourceCount) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, clusterNamespaceResourceCountImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ClusterNamespaceResourceCount") + case "clusterName": + out.Values[i] = ec._ClusterNamespaceResourceCount_clusterName(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "namespace": + out.Values[i] = ec._ClusterNamespaceResourceCount_namespace(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceCount": + out.Values[i] = ec._ClusterNamespaceResourceCount_resourceCount(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + var deletedAPIImplementors = []string{"DeletedAPI"} func (ec *executionContext) _DeletedAPI(ctx context.Context, sel ast.SelectionSet, obj *model.DeletedAPI) graphql.Marshaler { @@ -12070,6 +12608,72 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) + case "allClusterDeprecatedAPIsCounts": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Query_allClusterDeprecatedAPIsCounts(ctx, field) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + rrm := func(ctx context.Context) graphql.Marshaler { + return ec.OperationContext.RootResolverMiddleware(ctx, + func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) + case "allClusterDeletedAPIsCounts": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Query_allClusterDeletedAPIsCounts(ctx, field) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + rrm := func(ctx context.Context) graphql.Marshaler { + return ec.OperationContext.RootResolverMiddleware(ctx, + func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) + case "allClusterNamespaceResourceCounts": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Query_allClusterNamespaceResourceCounts(ctx, field) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + rrm := func(ctx context.Context) graphql.Marshaler { + return ec.OperationContext.RootResolverMiddleware(ctx, + func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) case "__type": out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { @@ -12819,6 +13423,60 @@ func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.Se return res } +func (ec *executionContext) marshalNClusterAPIsCount2ᚕᚖgithubᚗcomᚋintelopsᚋkubvizᚋgraphqlserverᚋgraphᚋmodelᚐClusterAPIsCountᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.ClusterAPIsCount) graphql.Marshaler { + ret := make(graphql.Array, len(v)) + var wg sync.WaitGroup + isLen1 := len(v) == 1 + if !isLen1 { + wg.Add(len(v)) + } + for i := range v { + i := i + fc := &graphql.FieldContext{ + Index: &i, + Result: &v[i], + } + ctx := graphql.WithFieldContext(ctx, fc) + f := func(i int) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = nil + } + }() + if !isLen1 { + defer wg.Done() + } + ret[i] = ec.marshalNClusterAPIsCount2ᚖgithubᚗcomᚋintelopsᚋkubvizᚋgraphqlserverᚋgraphᚋmodelᚐClusterAPIsCount(ctx, sel, v[i]) + } + if isLen1 { + f(i) + } else { + go f(i) + } + + } + wg.Wait() + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + +func (ec *executionContext) marshalNClusterAPIsCount2ᚖgithubᚗcomᚋintelopsᚋkubvizᚋgraphqlserverᚋgraphᚋmodelᚐClusterAPIsCount(ctx context.Context, sel ast.SelectionSet, v *model.ClusterAPIsCount) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + ec.Errorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._ClusterAPIsCount(ctx, sel, v) +} + func (ec *executionContext) marshalNClusterNamespaceOutdatedCount2ᚕᚖgithubᚗcomᚋintelopsᚋkubvizᚋgraphqlserverᚋgraphᚋmodelᚐClusterNamespaceOutdatedCountᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.ClusterNamespaceOutdatedCount) graphql.Marshaler { ret := make(graphql.Array, len(v)) var wg sync.WaitGroup @@ -12873,6 +13531,60 @@ func (ec *executionContext) marshalNClusterNamespaceOutdatedCount2ᚖgithubᚗco return ec._ClusterNamespaceOutdatedCount(ctx, sel, v) } +func (ec *executionContext) marshalNClusterNamespaceResourceCount2ᚕᚖgithubᚗcomᚋintelopsᚋkubvizᚋgraphqlserverᚋgraphᚋmodelᚐClusterNamespaceResourceCountᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.ClusterNamespaceResourceCount) graphql.Marshaler { + ret := make(graphql.Array, len(v)) + var wg sync.WaitGroup + isLen1 := len(v) == 1 + if !isLen1 { + wg.Add(len(v)) + } + for i := range v { + i := i + fc := &graphql.FieldContext{ + Index: &i, + Result: &v[i], + } + ctx := graphql.WithFieldContext(ctx, fc) + f := func(i int) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = nil + } + }() + if !isLen1 { + defer wg.Done() + } + ret[i] = ec.marshalNClusterNamespaceResourceCount2ᚖgithubᚗcomᚋintelopsᚋkubvizᚋgraphqlserverᚋgraphᚋmodelᚐClusterNamespaceResourceCount(ctx, sel, v[i]) + } + if isLen1 { + f(i) + } else { + go f(i) + } + + } + wg.Wait() + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + +func (ec *executionContext) marshalNClusterNamespaceResourceCount2ᚖgithubᚗcomᚋintelopsᚋkubvizᚋgraphqlserverᚋgraphᚋmodelᚐClusterNamespaceResourceCount(ctx context.Context, sel ast.SelectionSet, v *model.ClusterNamespaceResourceCount) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + ec.Errorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._ClusterNamespaceResourceCount(ctx, sel, v) +} + func (ec *executionContext) marshalNDeletedAPI2ᚕᚖgithubᚗcomᚋintelopsᚋkubvizᚋgraphqlserverᚋgraphᚋmodelᚐDeletedAPIᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.DeletedAPI) graphql.Marshaler { ret := make(graphql.Array, len(v)) var wg sync.WaitGroup diff --git a/graphqlserver/graph/model/models_gen.go b/graphqlserver/graph/model/models_gen.go index 3f28f8bc..397b571e 100644 --- a/graphqlserver/graph/model/models_gen.go +++ b/graphqlserver/graph/model/models_gen.go @@ -2,12 +2,23 @@ package model +type ClusterAPIsCount struct { + ClusterName string `json:"clusterName"` + Count int `json:"count"` +} + type ClusterNamespaceOutdatedCount struct { ClusterName string `json:"clusterName"` Namespace string `json:"namespace"` OutdatedCount int `json:"outdatedCount"` } +type ClusterNamespaceResourceCount struct { + ClusterName string `json:"clusterName"` + Namespace string `json:"namespace"` + ResourceCount int `json:"resourceCount"` +} + type DeletedAPI struct { ClusterName *string `json:"ClusterName,omitempty"` ObjectName *string `json:"ObjectName,omitempty"` diff --git a/graphqlserver/graph/schema.graphqls b/graphqlserver/graph/schema.graphqls index dc755361..72ef18ef 100644 --- a/graphqlserver/graph/schema.graphqls +++ b/graphqlserver/graph/schema.graphqls @@ -15,7 +15,20 @@ type Query { outdatedImagesByClusterAndNamespace(clusterName: String!, namespace: String!): [OutdatedImage!]! outdatedImagesCount(clusterName: String!, namespace: String!): Int! allClusterNamespaceOutdatedCounts: [ClusterNamespaceOutdatedCount!]! + allClusterDeprecatedAPIsCounts: [ClusterAPIsCount!]! + allClusterDeletedAPIsCounts: [ClusterAPIsCount!]! + allClusterNamespaceResourceCounts: [ClusterNamespaceResourceCount!]! } +type ClusterNamespaceResourceCount { + clusterName: String! + namespace: String! + resourceCount: Int! +} +type ClusterAPIsCount { + clusterName: String! + count: Int! +} + type ClusterNamespaceOutdatedCount { clusterName: String! diff --git a/graphqlserver/graph/schema.resolvers.go b/graphqlserver/graph/schema.resolvers.go index e58892de..296b70e4 100644 --- a/graphqlserver/graph/schema.resolvers.go +++ b/graphqlserver/graph/schema.resolvers.go @@ -524,6 +524,106 @@ func (r *queryResolver) AllClusterNamespaceOutdatedCounts(ctx context.Context) ( return results, nil } +// AllClusterDeprecatedAPIsCounts is the resolver for the allClusterDeprecatedAPIsCounts field. +func (r *queryResolver) AllClusterDeprecatedAPIsCounts(ctx context.Context) ([]*model.ClusterAPIsCount, error) { + if r.DB == nil { + return nil, fmt.Errorf("database connection is not initialized") + } + query := ` + SELECT ClusterName, COUNT(*) as count + FROM DeprecatedAPIs + GROUP BY ClusterName +` + + rows, err := r.DB.QueryContext(ctx, query) + if err != nil { + return nil, fmt.Errorf("error executing query: %v", err) + } + defer rows.Close() + var results []*model.ClusterAPIsCount + for rows.Next() { + var result model.ClusterAPIsCount + if err := rows.Scan(&result.ClusterName, &result.Count); err != nil { + return nil, fmt.Errorf("error scanning row: %v", err) + } + results = append(results, &result) + } + + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("error iterating rows: %v", err) + } + + return results, nil +} + +// AllClusterDeletedAPIsCounts is the resolver for the allClusterDeletedAPIsCounts field. +func (r *queryResolver) AllClusterDeletedAPIsCounts(ctx context.Context) ([]*model.ClusterAPIsCount, error) { + if r.DB == nil { + return nil, fmt.Errorf("database connection is not initialized") + } + + query := ` + SELECT ClusterName, COUNT(*) as count + FROM DeletedAPIs + GROUP BY ClusterName + ` + + rows, err := r.DB.QueryContext(ctx, query) + if err != nil { + return nil, fmt.Errorf("error executing query: %v", err) + } + defer rows.Close() + + var results []*model.ClusterAPIsCount + for rows.Next() { + var result model.ClusterAPIsCount + if err := rows.Scan(&result.ClusterName, &result.Count); err != nil { + return nil, fmt.Errorf("error scanning row: %v", err) + } + results = append(results, &result) + } + + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("error iterating rows: %v", err) + } + + return results, nil +} + +// AllClusterNamespaceResourceCounts is the resolver for the allClusterNamespaceResourceCounts field. +func (r *queryResolver) AllClusterNamespaceResourceCounts(ctx context.Context) ([]*model.ClusterNamespaceResourceCount, error) { + if r.DB == nil { + return nil, fmt.Errorf("database connection is not initialized") + } + + query := ` + SELECT ClusterName, Namespace, COUNT(*) as resourceCount + FROM getall_resources + GROUP BY ClusterName, Namespace + ` + + rows, err := r.DB.QueryContext(ctx, query) + if err != nil { + return nil, fmt.Errorf("error executing query: %v", err) + } + defer rows.Close() + + var results []*model.ClusterNamespaceResourceCount + for rows.Next() { + var result model.ClusterNamespaceResourceCount + if err := rows.Scan(&result.ClusterName, &result.Namespace, &result.ResourceCount); err != nil { + return nil, fmt.Errorf("error scanning row: %v", err) + } + results = append(results, &result) + } + + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("error iterating rows: %v", err) + } + + return results, nil +} + // Query returns QueryResolver implementation. func (r *Resolver) Query() QueryResolver { return &queryResolver{r} }