From f4cb56a89117b93a5d8987cd069af1b3b795dfff Mon Sep 17 00:00:00 2001 From: Antonio Navarro Perez Date: Wed, 18 Sep 2024 16:31:24 +0200 Subject: [PATCH] Add new filters Signed-off-by: Antonio Navarro Perez --- go.mod | 2 +- go.sum | 4 +- serve/graph/all.resolvers.go | 5 +- serve/graph/generated.go | 2960 +++++++++++++++++++++-- serve/graph/model/filter_methods_gen.go | 172 +- 5 files changed, 2816 insertions(+), 327 deletions(-) diff --git a/go.mod b/go.mod index f7cde78..9efec0a 100644 --- a/go.mod +++ b/go.mod @@ -4,7 +4,7 @@ go 1.22.7 require ( github.com/99designs/gqlgen v0.17.51 - github.com/ajnavarro/gqlfiltergen v0.0.0-20240917141952-a5827c0f0dd7 + github.com/ajnavarro/gqlfiltergen v0.0.0-20240918141943-b05d2c9a83f1 github.com/cockroachdb/pebble v1.1.2 github.com/gnolang/gno v0.1.1 github.com/go-chi/chi/v5 v5.1.0 diff --git a/go.sum b/go.sum index 7b0dfd0..1590e67 100644 --- a/go.sum +++ b/go.sum @@ -11,8 +11,8 @@ github.com/agnivade/levenshtein v1.1.1 h1:QY8M92nrzkmr798gCo3kmMyqXFzdQVpxLlGPRB github.com/agnivade/levenshtein v1.1.1/go.mod h1:veldBMzWxcCG2ZvUTKD2kJNRdCk5hVbJomOvKkmgYbo= github.com/ajg/form v1.5.1 h1:t9c7v8JUKu/XxOGBU0yjNpaMloxGEJhUkqFRq0ibGeU= github.com/ajg/form v1.5.1/go.mod h1:uL1WgH+h2mgNtvBq0339dVnzXdBETtL2LeUXaIv25UY= -github.com/ajnavarro/gqlfiltergen v0.0.0-20240917141952-a5827c0f0dd7 h1:+IWeSygkYmvIfhi5YWL0nnG+/1ynL6ANvTcsYPIYwoo= -github.com/ajnavarro/gqlfiltergen v0.0.0-20240917141952-a5827c0f0dd7/go.mod h1:uHvKxvSISkr7QFZnYlrXfpnEDI/UPpodVM/a/XkOjtU= +github.com/ajnavarro/gqlfiltergen v0.0.0-20240918141943-b05d2c9a83f1 h1:VGStydpETwBG3RUUcb030XVWAd8z7CB8GzRO6CEoHXw= +github.com/ajnavarro/gqlfiltergen v0.0.0-20240918141943-b05d2c9a83f1/go.mod h1:uHvKxvSISkr7QFZnYlrXfpnEDI/UPpodVM/a/XkOjtU= github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883 h1:bvNMNQO63//z+xNgfBlViaCIJKLlCJ6/fmUseuG0wVQ= github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8= github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss= diff --git a/serve/graph/all.resolvers.go b/serve/graph/all.resolvers.go index b47954b..bd8f971 100644 --- a/serve/graph/all.resolvers.go +++ b/serve/graph/all.resolvers.go @@ -2,7 +2,7 @@ package graph // This file will be automatically regenerated based on the schema, any resolver implementations // will be copied through when generating and any unknown code will be moved to the end. -// Code generated by github.com/99designs/gqlgen version v0.17.49 +// Code generated by github.com/99designs/gqlgen version v0.17.51 import ( "context" @@ -177,7 +177,8 @@ func (r *queryResolver) GetBlocks(ctx context.Context, where model.FilterBlock) // GetTransactions is the resolver for the getTransactions field. func (r *queryResolver) GetTransactions(ctx context.Context, where model.FilterTransaction) ([]*model.Transaction, error) { // corner case - if where.Hash.Eq != nil && + if where.Hash != nil && + where.Hash.Eq != nil && len(where.Or) == 0 { tx, err := r.store.GetTxByHash(*where.Hash.Eq) if err != nil { diff --git a/serve/graph/generated.go b/serve/graph/generated.go index 4f87d55..0513d16 100644 --- a/serve/graph/generated.go +++ b/serve/graph/generated.go @@ -2831,12 +2831,12 @@ input TransactionFilter { """ hash: String """ - Transaction's message to filter Transactions. - ` + "`" + `messages` + "`" + ` can be configured as a filter with a transaction message's ` + "`" + `router` + "`" + ` and ` + "`" + `type` + "`" + ` and ` + "`" + `parameters(bank / vm)` + "`" + `. - ` + "`" + `messages` + "`" + ` is entered as an array and works exclusively. - ex) ` + "`" + `messages[0] || messages[1] || messages[2]` + "`" + ` + Transaction's messages to filter Transactions. + ` + "`" + `message` + "`" + ` can be configured as a filter with a transaction message's ` + "`" + `router` + "`" + ` and ` + "`" + `type` + "`" + ` and ` + "`" + `parameters(bank / vm)` + "`" + `. + ` + "`" + `message` + "`" + ` is entered as an array and works exclusively. + ex) ` + "`" + `message[0] || message[1] || message[2]` + "`" + ` """ - messages: [TransactionMessageInput!] + message: [TransactionMessageInput!] """ ` + "`" + `memo` + "`" + ` are string information stored within a transaction. ` + "`" + `memo` + "`" + ` can be utilized to find or distinguish transactions. @@ -2980,182 +2980,386 @@ var parsedSchema = gqlparser.MustLoadSchema(sources...) func (ec *executionContext) dir_filterable_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - var arg0 []model.FilterableExtra - if tmp, ok := rawArgs["extras"]; ok { - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("extras")) - arg0, err = ec.unmarshalOFilterableExtra2ᚕgithubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐFilterableExtraᚄ(ctx, tmp) - if err != nil { - return nil, err - } + arg0, err := ec.dir_filterable_argsExtras(ctx, rawArgs) + if err != nil { + return nil, err } args["extras"] = arg0 return args, nil } +func (ec *executionContext) dir_filterable_argsExtras( + ctx context.Context, + rawArgs map[string]interface{}, +) ([]model.FilterableExtra, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["extras"] + if !ok { + var zeroVal []model.FilterableExtra + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("extras")) + if tmp, ok := rawArgs["extras"]; ok { + return ec.unmarshalOFilterableExtra2ᚕgithubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐFilterableExtraᚄ(ctx, tmp) + } + + var zeroVal []model.FilterableExtra + return zeroVal, nil +} func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - var arg0 string - if tmp, ok := rawArgs["name"]; ok { - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) - arg0, err = ec.unmarshalNString2string(ctx, tmp) - if err != nil { - return nil, err - } + arg0, err := ec.field_Query___type_argsName(ctx, rawArgs) + if err != nil { + return nil, err } args["name"] = arg0 return args, nil } +func (ec *executionContext) field_Query___type_argsName( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["name"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) + if tmp, ok := rawArgs["name"]; ok { + return ec.unmarshalNString2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} func (ec *executionContext) field_Query_blocks_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - var arg0 model.BlockFilter - if tmp, ok := rawArgs["filter"]; ok { - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter")) - arg0, err = ec.unmarshalNBlockFilter2githubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐBlockFilter(ctx, tmp) - if err != nil { - return nil, err - } + arg0, err := ec.field_Query_blocks_argsFilter(ctx, rawArgs) + if err != nil { + return nil, err } args["filter"] = arg0 return args, nil } +func (ec *executionContext) field_Query_blocks_argsFilter( + ctx context.Context, + rawArgs map[string]interface{}, +) (model.BlockFilter, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["filter"] + if !ok { + var zeroVal model.BlockFilter + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("filter")) + if tmp, ok := rawArgs["filter"]; ok { + return ec.unmarshalNBlockFilter2githubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐBlockFilter(ctx, tmp) + } + + var zeroVal model.BlockFilter + return zeroVal, nil +} func (ec *executionContext) field_Query_getBlocks_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - var arg0 model.FilterBlock - if tmp, ok := rawArgs["where"]; ok { - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) - arg0, err = ec.unmarshalNFilterBlock2githubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐFilterBlock(ctx, tmp) - if err != nil { - return nil, err - } + arg0, err := ec.field_Query_getBlocks_argsWhere(ctx, rawArgs) + if err != nil { + return nil, err } args["where"] = arg0 return args, nil } +func (ec *executionContext) field_Query_getBlocks_argsWhere( + ctx context.Context, + rawArgs map[string]interface{}, +) (model.FilterBlock, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["where"] + if !ok { + var zeroVal model.FilterBlock + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) + if tmp, ok := rawArgs["where"]; ok { + return ec.unmarshalNFilterBlock2githubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐFilterBlock(ctx, tmp) + } + + var zeroVal model.FilterBlock + return zeroVal, nil +} func (ec *executionContext) field_Query_getTransactions_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - var arg0 model.FilterTransaction - if tmp, ok := rawArgs["where"]; ok { - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) - arg0, err = ec.unmarshalNFilterTransaction2githubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐFilterTransaction(ctx, tmp) - if err != nil { - return nil, err - } + arg0, err := ec.field_Query_getTransactions_argsWhere(ctx, rawArgs) + if err != nil { + return nil, err } args["where"] = arg0 return args, nil } +func (ec *executionContext) field_Query_getTransactions_argsWhere( + ctx context.Context, + rawArgs map[string]interface{}, +) (model.FilterTransaction, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["where"] + if !ok { + var zeroVal model.FilterTransaction + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) + if tmp, ok := rawArgs["where"]; ok { + return ec.unmarshalNFilterTransaction2githubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐFilterTransaction(ctx, tmp) + } + + var zeroVal model.FilterTransaction + return zeroVal, nil +} func (ec *executionContext) field_Query_transactions_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - var arg0 model.TransactionFilter - if tmp, ok := rawArgs["filter"]; ok { - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter")) - arg0, err = ec.unmarshalNTransactionFilter2githubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐTransactionFilter(ctx, tmp) - if err != nil { - return nil, err - } + arg0, err := ec.field_Query_transactions_argsFilter(ctx, rawArgs) + if err != nil { + return nil, err } args["filter"] = arg0 return args, nil } +func (ec *executionContext) field_Query_transactions_argsFilter( + ctx context.Context, + rawArgs map[string]interface{}, +) (model.TransactionFilter, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["filter"] + if !ok { + var zeroVal model.TransactionFilter + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("filter")) + if tmp, ok := rawArgs["filter"]; ok { + return ec.unmarshalNTransactionFilter2githubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐTransactionFilter(ctx, tmp) + } + + var zeroVal model.TransactionFilter + return zeroVal, nil +} func (ec *executionContext) field_Subscription_blocks_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - var arg0 model.BlockFilter - if tmp, ok := rawArgs["filter"]; ok { - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter")) - arg0, err = ec.unmarshalNBlockFilter2githubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐBlockFilter(ctx, tmp) - if err != nil { - return nil, err - } + arg0, err := ec.field_Subscription_blocks_argsFilter(ctx, rawArgs) + if err != nil { + return nil, err } args["filter"] = arg0 return args, nil } +func (ec *executionContext) field_Subscription_blocks_argsFilter( + ctx context.Context, + rawArgs map[string]interface{}, +) (model.BlockFilter, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["filter"] + if !ok { + var zeroVal model.BlockFilter + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("filter")) + if tmp, ok := rawArgs["filter"]; ok { + return ec.unmarshalNBlockFilter2githubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐBlockFilter(ctx, tmp) + } + + var zeroVal model.BlockFilter + return zeroVal, nil +} func (ec *executionContext) field_Subscription_getBlocks_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - var arg0 model.FilterBlock - if tmp, ok := rawArgs["filter"]; ok { - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter")) - arg0, err = ec.unmarshalNFilterBlock2githubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐFilterBlock(ctx, tmp) - if err != nil { - return nil, err - } + arg0, err := ec.field_Subscription_getBlocks_argsFilter(ctx, rawArgs) + if err != nil { + return nil, err } args["filter"] = arg0 return args, nil } +func (ec *executionContext) field_Subscription_getBlocks_argsFilter( + ctx context.Context, + rawArgs map[string]interface{}, +) (model.FilterBlock, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["filter"] + if !ok { + var zeroVal model.FilterBlock + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("filter")) + if tmp, ok := rawArgs["filter"]; ok { + return ec.unmarshalNFilterBlock2githubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐFilterBlock(ctx, tmp) + } + + var zeroVal model.FilterBlock + return zeroVal, nil +} func (ec *executionContext) field_Subscription_getTransactions_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - var arg0 model.FilterTransaction - if tmp, ok := rawArgs["filter"]; ok { - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter")) - arg0, err = ec.unmarshalNFilterTransaction2githubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐFilterTransaction(ctx, tmp) - if err != nil { - return nil, err - } + arg0, err := ec.field_Subscription_getTransactions_argsFilter(ctx, rawArgs) + if err != nil { + return nil, err } args["filter"] = arg0 return args, nil } +func (ec *executionContext) field_Subscription_getTransactions_argsFilter( + ctx context.Context, + rawArgs map[string]interface{}, +) (model.FilterTransaction, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["filter"] + if !ok { + var zeroVal model.FilterTransaction + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("filter")) + if tmp, ok := rawArgs["filter"]; ok { + return ec.unmarshalNFilterTransaction2githubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐFilterTransaction(ctx, tmp) + } + + var zeroVal model.FilterTransaction + return zeroVal, nil +} func (ec *executionContext) field_Subscription_transactions_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - var arg0 model.TransactionFilter - if tmp, ok := rawArgs["filter"]; ok { - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter")) - arg0, err = ec.unmarshalNTransactionFilter2githubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐTransactionFilter(ctx, tmp) - if err != nil { - return nil, err - } + arg0, err := ec.field_Subscription_transactions_argsFilter(ctx, rawArgs) + if err != nil { + return nil, err } args["filter"] = arg0 return args, nil } +func (ec *executionContext) field_Subscription_transactions_argsFilter( + ctx context.Context, + rawArgs map[string]interface{}, +) (model.TransactionFilter, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["filter"] + if !ok { + var zeroVal model.TransactionFilter + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("filter")) + if tmp, ok := rawArgs["filter"]; ok { + return ec.unmarshalNTransactionFilter2githubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐTransactionFilter(ctx, tmp) + } + + var zeroVal model.TransactionFilter + return zeroVal, nil +} func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - var arg0 bool - if tmp, ok := rawArgs["includeDeprecated"]; ok { - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated")) - arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp) - if err != nil { - return nil, err - } + arg0, err := ec.field___Type_enumValues_argsIncludeDeprecated(ctx, rawArgs) + if err != nil { + return nil, err } args["includeDeprecated"] = arg0 return args, nil } +func (ec *executionContext) field___Type_enumValues_argsIncludeDeprecated( + ctx context.Context, + rawArgs map[string]interface{}, +) (bool, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["includeDeprecated"] + if !ok { + var zeroVal bool + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated")) + if tmp, ok := rawArgs["includeDeprecated"]; ok { + return ec.unmarshalOBoolean2bool(ctx, tmp) + } + + var zeroVal bool + return zeroVal, nil +} func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - var arg0 bool - if tmp, ok := rawArgs["includeDeprecated"]; ok { - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated")) - arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp) - if err != nil { - return nil, err - } + arg0, err := ec.field___Type_fields_argsIncludeDeprecated(ctx, rawArgs) + if err != nil { + return nil, err } args["includeDeprecated"] = arg0 return args, nil } +func (ec *executionContext) field___Type_fields_argsIncludeDeprecated( + ctx context.Context, + rawArgs map[string]interface{}, +) (bool, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["includeDeprecated"] + if !ok { + var zeroVal bool + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated")) + if tmp, ok := rawArgs["includeDeprecated"]; ok { + return ec.unmarshalOBoolean2bool(ctx, tmp) + } + + var zeroVal bool + return zeroVal, nil +} // endregion ***************************** args.gotpl ***************************** @@ -3182,9 +3386,11 @@ func (ec *executionContext) _BankMsgSend_from_address(ctx context.Context, field ctx = rctx // use context from middleware stack in children return obj.FromAddress, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -3246,9 +3452,11 @@ func (ec *executionContext) _BankMsgSend_to_address(ctx context.Context, field g ctx = rctx // use context from middleware stack in children return obj.ToAddress, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -3310,9 +3518,11 @@ func (ec *executionContext) _BankMsgSend_amount(ctx context.Context, field graph ctx = rctx // use context from middleware stack in children return obj.Amount, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -3374,9 +3584,11 @@ func (ec *executionContext) _Block_hash(ctx context.Context, field graphql.Colle ctx = rctx // use context from middleware stack in children return obj.Hash(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -3438,13 +3650,16 @@ func (ec *executionContext) _Block_height(ctx context.Context, field graphql.Col ctx = rctx // use context from middleware stack in children return obj.Height(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { extras, err := ec.unmarshalOFilterableExtra2ᚕgithubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐFilterableExtraᚄ(ctx, []interface{}{"MINMAX"}) if err != nil { - return nil, err + var zeroVal int64 + return zeroVal, err } if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal int64 + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, extras) } @@ -3506,9 +3721,11 @@ func (ec *executionContext) _Block_version(ctx context.Context, field graphql.Co ctx = rctx // use context from middleware stack in children return obj.Version(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -3570,9 +3787,11 @@ func (ec *executionContext) _Block_chain_id(ctx context.Context, field graphql.C ctx = rctx // use context from middleware stack in children return obj.ChainID(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -3634,9 +3853,11 @@ func (ec *executionContext) _Block_time(ctx context.Context, field graphql.Colle ctx = rctx // use context from middleware stack in children return obj.Time(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal time.Time + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -3698,9 +3919,11 @@ func (ec *executionContext) _Block_num_txs(ctx context.Context, field graphql.Co ctx = rctx // use context from middleware stack in children return obj.NumTxs(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal int64 + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -3762,9 +3985,11 @@ func (ec *executionContext) _Block_total_txs(ctx context.Context, field graphql. ctx = rctx // use context from middleware stack in children return obj.TotalTxs(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal int64 + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -3826,9 +4051,11 @@ func (ec *executionContext) _Block_app_version(ctx context.Context, field graphq ctx = rctx // use context from middleware stack in children return obj.AppVersion(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -3890,9 +4117,11 @@ func (ec *executionContext) _Block_last_block_hash(ctx context.Context, field gr ctx = rctx // use context from middleware stack in children return obj.LastBlockHash(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -3954,9 +4183,11 @@ func (ec *executionContext) _Block_last_commit_hash(ctx context.Context, field g ctx = rctx // use context from middleware stack in children return obj.LastCommitHash(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -4018,9 +4249,11 @@ func (ec *executionContext) _Block_validators_hash(ctx context.Context, field gr ctx = rctx // use context from middleware stack in children return obj.ValidatorsHash(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -4082,9 +4315,11 @@ func (ec *executionContext) _Block_next_validators_hash(ctx context.Context, fie ctx = rctx // use context from middleware stack in children return obj.NextValidatorsHash(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -4146,9 +4381,11 @@ func (ec *executionContext) _Block_consensus_hash(ctx context.Context, field gra ctx = rctx // use context from middleware stack in children return obj.ConsensusHash(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -4210,9 +4447,11 @@ func (ec *executionContext) _Block_app_hash(ctx context.Context, field graphql.C ctx = rctx // use context from middleware stack in children return obj.AppHash(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -4274,9 +4513,11 @@ func (ec *executionContext) _Block_last_results_hash(ctx context.Context, field ctx = rctx // use context from middleware stack in children return obj.LastResultsHash(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -4338,9 +4579,11 @@ func (ec *executionContext) _Block_proposer_address_raw(ctx context.Context, fie ctx = rctx // use context from middleware stack in children return obj.ProposerAddressRaw(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -4402,9 +4645,11 @@ func (ec *executionContext) _Block_txs(ctx context.Context, field graphql.Collec ctx = rctx // use context from middleware stack in children return obj.Txs(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal []*model.BlockTransaction + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -4476,9 +4721,11 @@ func (ec *executionContext) _BlockTransaction_hash(ctx context.Context, field gr ctx = rctx // use context from middleware stack in children return obj.Hash, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -4540,9 +4787,11 @@ func (ec *executionContext) _BlockTransaction_fee(ctx context.Context, field gra ctx = rctx // use context from middleware stack in children return obj.Fee, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal *model.TxFee + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -4610,9 +4859,11 @@ func (ec *executionContext) _BlockTransaction_memo(ctx context.Context, field gr ctx = rctx // use context from middleware stack in children return obj.Memo, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -4718,9 +4969,11 @@ func (ec *executionContext) _Coin_amount(ctx context.Context, field graphql.Coll ctx = rctx // use context from middleware stack in children return obj.Amount, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal int + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -4782,9 +5035,11 @@ func (ec *executionContext) _Coin_denom(ctx context.Context, field graphql.Colle ctx = rctx // use context from middleware stack in children return obj.Denom, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -4846,9 +5101,11 @@ func (ec *executionContext) _GnoEvent_type(ctx context.Context, field graphql.Co ctx = rctx // use context from middleware stack in children return obj.Type, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -4910,9 +5167,11 @@ func (ec *executionContext) _GnoEvent_pkg_path(ctx context.Context, field graphq ctx = rctx // use context from middleware stack in children return obj.PkgPath, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -4974,9 +5233,11 @@ func (ec *executionContext) _GnoEvent_func(ctx context.Context, field graphql.Co ctx = rctx // use context from middleware stack in children return obj.Func, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -5038,9 +5299,11 @@ func (ec *executionContext) _GnoEvent_attrs(ctx context.Context, field graphql.C ctx = rctx // use context from middleware stack in children return obj.Attrs, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal []*model.GnoEventAttribute + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -5105,9 +5368,11 @@ func (ec *executionContext) _GnoEventAttribute_key(ctx context.Context, field gr ctx = rctx // use context from middleware stack in children return obj.Key, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -5169,9 +5434,11 @@ func (ec *executionContext) _GnoEventAttribute_value(ctx context.Context, field ctx = rctx // use context from middleware stack in children return obj.Value, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -5233,9 +5500,11 @@ func (ec *executionContext) _MemFile_name(ctx context.Context, field graphql.Col ctx = rctx // use context from middleware stack in children return obj.Name, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -5297,9 +5566,11 @@ func (ec *executionContext) _MemFile_body(ctx context.Context, field graphql.Col ctx = rctx // use context from middleware stack in children return obj.Body, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -5361,9 +5632,11 @@ func (ec *executionContext) _MemPackage_name(ctx context.Context, field graphql. ctx = rctx // use context from middleware stack in children return obj.Name, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -5425,9 +5698,11 @@ func (ec *executionContext) _MemPackage_path(ctx context.Context, field graphql. ctx = rctx // use context from middleware stack in children return obj.Path, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -5489,9 +5764,11 @@ func (ec *executionContext) _MemPackage_files(ctx context.Context, field graphql ctx = rctx // use context from middleware stack in children return obj.Files, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal []*model.MemFile + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -5556,9 +5833,11 @@ func (ec *executionContext) _MsgAddPackage_creator(ctx context.Context, field gr ctx = rctx // use context from middleware stack in children return obj.Creator, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -5620,9 +5899,11 @@ func (ec *executionContext) _MsgAddPackage_package(ctx context.Context, field gr ctx = rctx // use context from middleware stack in children return obj.Package, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal *model.MemPackage + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -5692,9 +5973,11 @@ func (ec *executionContext) _MsgAddPackage_deposit(ctx context.Context, field gr ctx = rctx // use context from middleware stack in children return obj.Deposit, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -5756,9 +6039,11 @@ func (ec *executionContext) _MsgCall_caller(ctx context.Context, field graphql.C ctx = rctx // use context from middleware stack in children return obj.Caller, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -5820,9 +6105,11 @@ func (ec *executionContext) _MsgCall_send(ctx context.Context, field graphql.Col ctx = rctx // use context from middleware stack in children return obj.Send, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -5884,9 +6171,11 @@ func (ec *executionContext) _MsgCall_pkg_path(ctx context.Context, field graphql ctx = rctx // use context from middleware stack in children return obj.PkgPath, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -5948,9 +6237,11 @@ func (ec *executionContext) _MsgCall_func(ctx context.Context, field graphql.Col ctx = rctx // use context from middleware stack in children return obj.Func, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -6012,9 +6303,11 @@ func (ec *executionContext) _MsgCall_args(ctx context.Context, field graphql.Col ctx = rctx // use context from middleware stack in children return obj.Args, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal []string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -6073,9 +6366,11 @@ func (ec *executionContext) _MsgRun_caller(ctx context.Context, field graphql.Co ctx = rctx // use context from middleware stack in children return obj.Caller, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -6137,9 +6432,11 @@ func (ec *executionContext) _MsgRun_send(ctx context.Context, field graphql.Coll ctx = rctx // use context from middleware stack in children return obj.Send, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -6201,9 +6498,11 @@ func (ec *executionContext) _MsgRun_package(ctx context.Context, field graphql.C ctx = rctx // use context from middleware stack in children return obj.Package, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal *model.MemPackage + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -7170,13 +7469,16 @@ func (ec *executionContext) _Transaction_index(ctx context.Context, field graphq ctx = rctx // use context from middleware stack in children return obj.Index(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { extras, err := ec.unmarshalOFilterableExtra2ᚕgithubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐFilterableExtraᚄ(ctx, []interface{}{"MINMAX"}) if err != nil { - return nil, err + var zeroVal int + return zeroVal, err } if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal int + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, extras) } @@ -7238,9 +7540,11 @@ func (ec *executionContext) _Transaction_hash(ctx context.Context, field graphql ctx = rctx // use context from middleware stack in children return obj.Hash(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -7302,9 +7606,11 @@ func (ec *executionContext) _Transaction_success(ctx context.Context, field grap ctx = rctx // use context from middleware stack in children return obj.Success(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal bool + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -7366,13 +7672,16 @@ func (ec *executionContext) _Transaction_block_height(ctx context.Context, field ctx = rctx // use context from middleware stack in children return obj.BlockHeight(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { extras, err := ec.unmarshalOFilterableExtra2ᚕgithubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐFilterableExtraᚄ(ctx, []interface{}{"MINMAX"}) if err != nil { - return nil, err + var zeroVal int + return zeroVal, err } if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal int + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, extras) } @@ -7434,9 +7743,11 @@ func (ec *executionContext) _Transaction_gas_wanted(ctx context.Context, field g ctx = rctx // use context from middleware stack in children return obj.GasWanted(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal int + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -7498,9 +7809,11 @@ func (ec *executionContext) _Transaction_gas_used(ctx context.Context, field gra ctx = rctx // use context from middleware stack in children return obj.GasUsed(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal int + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -7562,9 +7875,11 @@ func (ec *executionContext) _Transaction_gas_fee(ctx context.Context, field grap ctx = rctx // use context from middleware stack in children return obj.GasFee(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal *model.Coin + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -7673,9 +7988,11 @@ func (ec *executionContext) _Transaction_messages(ctx context.Context, field gra ctx = rctx // use context from middleware stack in children return obj.Messages(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal []*model.TransactionMessage + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -7745,9 +8062,11 @@ func (ec *executionContext) _Transaction_memo(ctx context.Context, field graphql ctx = rctx // use context from middleware stack in children return obj.Memo(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -7809,9 +8128,11 @@ func (ec *executionContext) _Transaction_response(ctx context.Context, field gra ctx = rctx // use context from middleware stack in children return obj.Response(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal *model.TransactionResponse + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -7885,9 +8206,11 @@ func (ec *executionContext) _TransactionMessage_typeUrl(ctx context.Context, fie ctx = rctx // use context from middleware stack in children return obj.TypeURL, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -7949,9 +8272,11 @@ func (ec *executionContext) _TransactionMessage_route(ctx context.Context, field ctx = rctx // use context from middleware stack in children return obj.Route, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -8013,9 +8338,11 @@ func (ec *executionContext) _TransactionMessage_value(ctx context.Context, field ctx = rctx // use context from middleware stack in children return obj.Value, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal model.MessageValue + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -8077,9 +8404,11 @@ func (ec *executionContext) _TransactionResponse_log(ctx context.Context, field ctx = rctx // use context from middleware stack in children return obj.Log(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -8141,9 +8470,11 @@ func (ec *executionContext) _TransactionResponse_info(ctx context.Context, field ctx = rctx // use context from middleware stack in children return obj.Info(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -8205,9 +8536,11 @@ func (ec *executionContext) _TransactionResponse_error(ctx context.Context, fiel ctx = rctx // use context from middleware stack in children return obj.Error(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -8269,9 +8602,11 @@ func (ec *executionContext) _TransactionResponse_data(ctx context.Context, field ctx = rctx // use context from middleware stack in children return obj.Data(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -8333,9 +8668,11 @@ func (ec *executionContext) _TransactionResponse_events(ctx context.Context, fie ctx = rctx // use context from middleware stack in children return obj.Events(), nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal []model.Event + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -8394,9 +8731,11 @@ func (ec *executionContext) _TxFee_gas_wanted(ctx context.Context, field graphql ctx = rctx // use context from middleware stack in children return obj.GasWanted, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal int + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -8458,9 +8797,11 @@ func (ec *executionContext) _TxFee_gas_fee(ctx context.Context, field graphql.Co ctx = rctx // use context from middleware stack in children return obj.GasFee, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal *model.Coin + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -8572,9 +8913,11 @@ func (ec *executionContext) _UnknownEvent_value(ctx context.Context, field graph ctx = rctx // use context from middleware stack in children return obj.Value, nil } + directive1 := func(ctx context.Context) (interface{}, error) { if ec.directives.Filterable == nil { - return nil, errors.New("directive filterable is not implemented") + var zeroVal string + return zeroVal, errors.New("directive filterable is not implemented") } return ec.directives.Filterable(ctx, obj, directive0, nil) } @@ -13492,15 +13835,27 @@ func (ec *executionContext) _Event(ctx context.Context, sel ast.SelectionSet, ob case nil: return graphql.Null case model.GnoEvent: + if len(graphql.CollectFields(ec.OperationContext, sel, []string{"Event", "GnoEvent"})) == 0 { + return graphql.Empty{} + } return ec._GnoEvent(ctx, sel, &obj) case *model.GnoEvent: + if len(graphql.CollectFields(ec.OperationContext, sel, []string{"Event", "GnoEvent"})) == 0 { + return graphql.Empty{} + } if obj == nil { return graphql.Null } return ec._GnoEvent(ctx, sel, obj) case model.UnknownEvent: + if len(graphql.CollectFields(ec.OperationContext, sel, []string{"Event", "UnknownEvent"})) == 0 { + return graphql.Empty{} + } return ec._UnknownEvent(ctx, sel, &obj) case *model.UnknownEvent: + if len(graphql.CollectFields(ec.OperationContext, sel, []string{"Event", "UnknownEvent"})) == 0 { + return graphql.Empty{} + } if obj == nil { return graphql.Null } @@ -13515,36 +13870,66 @@ func (ec *executionContext) _MessageValue(ctx context.Context, sel ast.Selection case nil: return graphql.Null case model.BankMsgSend: + if len(graphql.CollectFields(ec.OperationContext, sel, []string{"MessageValue", "BankMsgSend"})) == 0 { + return graphql.Empty{} + } return ec._BankMsgSend(ctx, sel, &obj) case *model.BankMsgSend: + if len(graphql.CollectFields(ec.OperationContext, sel, []string{"MessageValue", "BankMsgSend"})) == 0 { + return graphql.Empty{} + } if obj == nil { return graphql.Null } return ec._BankMsgSend(ctx, sel, obj) case model.MsgCall: + if len(graphql.CollectFields(ec.OperationContext, sel, []string{"MessageValue", "MsgCall"})) == 0 { + return graphql.Empty{} + } return ec._MsgCall(ctx, sel, &obj) case *model.MsgCall: + if len(graphql.CollectFields(ec.OperationContext, sel, []string{"MessageValue", "MsgCall"})) == 0 { + return graphql.Empty{} + } if obj == nil { return graphql.Null } return ec._MsgCall(ctx, sel, obj) case model.MsgAddPackage: + if len(graphql.CollectFields(ec.OperationContext, sel, []string{"MessageValue", "MsgAddPackage"})) == 0 { + return graphql.Empty{} + } return ec._MsgAddPackage(ctx, sel, &obj) case *model.MsgAddPackage: + if len(graphql.CollectFields(ec.OperationContext, sel, []string{"MessageValue", "MsgAddPackage"})) == 0 { + return graphql.Empty{} + } if obj == nil { return graphql.Null } return ec._MsgAddPackage(ctx, sel, obj) case model.MsgRun: + if len(graphql.CollectFields(ec.OperationContext, sel, []string{"MessageValue", "MsgRun"})) == 0 { + return graphql.Empty{} + } return ec._MsgRun(ctx, sel, &obj) case *model.MsgRun: + if len(graphql.CollectFields(ec.OperationContext, sel, []string{"MessageValue", "MsgRun"})) == 0 { + return graphql.Empty{} + } if obj == nil { return graphql.Null } return ec._MsgRun(ctx, sel, obj) case model.UnexpectedMessage: + if len(graphql.CollectFields(ec.OperationContext, sel, []string{"MessageValue", "UnexpectedMessage"})) == 0 { + return graphql.Empty{} + } return ec._UnexpectedMessage(ctx, sel, &obj) case *model.UnexpectedMessage: + if len(graphql.CollectFields(ec.OperationContext, sel, []string{"MessageValue", "UnexpectedMessage"})) == 0 { + return graphql.Empty{} + } if obj == nil { return graphql.Null } @@ -13570,16 +13955,76 @@ func (ec *executionContext) _BankMsgSend(ctx context.Context, sel ast.SelectionS case "__typename": out.Values[i] = graphql.MarshalString("BankMsgSend") case "from_address": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._BankMsgSend_from_address(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._BankMsgSend_from_address(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "to_address": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._BankMsgSend_to_address(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._BankMsgSend_to_address(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "amount": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._BankMsgSend_amount(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._BankMsgSend_amount(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ @@ -13619,86 +14064,426 @@ func (ec *executionContext) _Block(ctx context.Context, sel ast.SelectionSet, ob case "__typename": out.Values[i] = graphql.MarshalString("Block") case "hash": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_hash(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_hash(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "height": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_height(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_height(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "version": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_version(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_version(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "chain_id": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_chain_id(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_chain_id(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "time": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_time(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_time(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "num_txs": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_num_txs(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_num_txs(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "total_txs": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_total_txs(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_total_txs(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "app_version": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_app_version(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_app_version(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "last_block_hash": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_last_block_hash(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_last_block_hash(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "last_commit_hash": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_last_commit_hash(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_last_commit_hash(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "validators_hash": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_validators_hash(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_validators_hash(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "next_validators_hash": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_next_validators_hash(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_next_validators_hash(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "consensus_hash": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_consensus_hash(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_consensus_hash(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "app_hash": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_app_hash(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_app_hash(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "last_results_hash": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_last_results_hash(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_last_results_hash(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "proposer_address_raw": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_proposer_address_raw(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_proposer_address_raw(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "txs": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Block_txs(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Block_txs(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ @@ -13738,21 +14523,101 @@ func (ec *executionContext) _BlockTransaction(ctx context.Context, sel ast.Selec case "__typename": out.Values[i] = graphql.MarshalString("BlockTransaction") case "hash": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._BlockTransaction_hash(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._BlockTransaction_hash(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "fee": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._BlockTransaction_fee(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._BlockTransaction_fee(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "memo": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._BlockTransaction_memo(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._BlockTransaction_memo(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "content_raw": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._BlockTransaction_content_raw(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._BlockTransaction_content_raw(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ @@ -13792,11 +14657,51 @@ func (ec *executionContext) _Coin(ctx context.Context, sel ast.SelectionSet, obj case "__typename": out.Values[i] = graphql.MarshalString("Coin") case "amount": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Coin_amount(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Coin_amount(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "denom": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Coin_denom(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Coin_denom(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ @@ -13836,21 +14741,101 @@ func (ec *executionContext) _GnoEvent(ctx context.Context, sel ast.SelectionSet, case "__typename": out.Values[i] = graphql.MarshalString("GnoEvent") case "type": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._GnoEvent_type(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._GnoEvent_type(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "pkg_path": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._GnoEvent_pkg_path(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._GnoEvent_pkg_path(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "func": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._GnoEvent_func(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._GnoEvent_func(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "attrs": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._GnoEvent_attrs(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._GnoEvent_attrs(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) @@ -13887,11 +14872,51 @@ func (ec *executionContext) _GnoEventAttribute(ctx context.Context, sel ast.Sele case "__typename": out.Values[i] = graphql.MarshalString("GnoEventAttribute") case "key": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._GnoEventAttribute_key(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._GnoEventAttribute_key(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "value": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._GnoEventAttribute_value(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._GnoEventAttribute_value(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ @@ -13931,11 +14956,51 @@ func (ec *executionContext) _MemFile(ctx context.Context, sel ast.SelectionSet, case "__typename": out.Values[i] = graphql.MarshalString("MemFile") case "name": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._MemFile_name(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._MemFile_name(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "body": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._MemFile_body(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._MemFile_body(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ @@ -13975,16 +15040,76 @@ func (ec *executionContext) _MemPackage(ctx context.Context, sel ast.SelectionSe case "__typename": out.Values[i] = graphql.MarshalString("MemPackage") case "name": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._MemPackage_name(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._MemPackage_name(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "path": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._MemPackage_path(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._MemPackage_path(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "files": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._MemPackage_files(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._MemPackage_files(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) @@ -14021,16 +15146,76 @@ func (ec *executionContext) _MsgAddPackage(ctx context.Context, sel ast.Selectio case "__typename": out.Values[i] = graphql.MarshalString("MsgAddPackage") case "creator": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._MsgAddPackage_creator(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._MsgAddPackage_creator(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "package": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._MsgAddPackage_package(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._MsgAddPackage_package(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "deposit": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._MsgAddPackage_deposit(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._MsgAddPackage_deposit(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ @@ -14070,26 +15255,126 @@ func (ec *executionContext) _MsgCall(ctx context.Context, sel ast.SelectionSet, case "__typename": out.Values[i] = graphql.MarshalString("MsgCall") case "caller": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._MsgCall_caller(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._MsgCall_caller(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "send": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._MsgCall_send(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._MsgCall_send(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "pkg_path": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._MsgCall_pkg_path(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._MsgCall_pkg_path(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "func": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._MsgCall_func(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._MsgCall_func(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "args": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._MsgCall_args(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._MsgCall_args(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) @@ -14126,16 +15411,76 @@ func (ec *executionContext) _MsgRun(ctx context.Context, sel ast.SelectionSet, o case "__typename": out.Values[i] = graphql.MarshalString("MsgRun") case "caller": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._MsgRun_caller(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._MsgRun_caller(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "send": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._MsgRun_send(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._MsgRun_send(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "package": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._MsgRun_package(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._MsgRun_package(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ @@ -14185,106 +15530,45 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr case "transactions": field := field - innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { - defer func() { - if r := recover(); r != nil { - ec.Error(ctx, ec.Recover(ctx, r)) - } - }() - res = ec._Query_transactions(ctx, field) - 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) }) + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { + return ec._Query_transactions(ctx, field) + }) case "blocks": field := field - innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { - defer func() { - if r := recover(); r != nil { - ec.Error(ctx, ec.Recover(ctx, r)) - } - }() - res = ec._Query_blocks(ctx, field) - 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) }) + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { + return ec._Query_blocks(ctx, field) + }) case "latestBlockHeight": 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_latestBlockHeight(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.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { + return ec._Query_latestBlockHeight(ctx, field) + }) + if out.Values[i] == graphql.Null { + out.Invalids++ } - - out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) case "getBlocks": field := field - innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { - defer func() { - if r := recover(); r != nil { - ec.Error(ctx, ec.Recover(ctx, r)) - } - }() - res = ec._Query_getBlocks(ctx, field) - 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) }) + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { + return ec._Query_getBlocks(ctx, field) + }) case "getTransactions": field := field - innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { - defer func() { - if r := recover(); r != nil { - ec.Error(ctx, ec.Recover(ctx, r)) - } - }() - res = ec._Query_getTransactions(ctx, field) - 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) }) + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { + return ec._Query_getTransactions(ctx, field) + }) case "__type": + field := field + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { return ec._Query___type(ctx, field) }) case "__schema": + field := field + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { return ec._Query___schema(ctx, field) }) @@ -14349,53 +15633,273 @@ func (ec *executionContext) _Transaction(ctx context.Context, sel ast.SelectionS case "__typename": out.Values[i] = graphql.MarshalString("Transaction") case "index": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Transaction_index(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Transaction_index(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "hash": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Transaction_hash(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Transaction_hash(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "success": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Transaction_success(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Transaction_success(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "block_height": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Transaction_block_height(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Transaction_block_height(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "gas_wanted": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Transaction_gas_wanted(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Transaction_gas_wanted(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "gas_used": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Transaction_gas_used(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Transaction_gas_used(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "gas_fee": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Transaction_gas_fee(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Transaction_gas_fee(ctx, field, obj) case "content_raw": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Transaction_content_raw(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Transaction_content_raw(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "messages": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Transaction_messages(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Transaction_messages(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "memo": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Transaction_memo(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Transaction_memo(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "response": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._Transaction_response(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._Transaction_response(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ @@ -14435,16 +15939,76 @@ func (ec *executionContext) _TransactionMessage(ctx context.Context, sel ast.Sel case "__typename": out.Values[i] = graphql.MarshalString("TransactionMessage") case "typeUrl": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._TransactionMessage_typeUrl(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._TransactionMessage_typeUrl(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "route": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._TransactionMessage_route(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._TransactionMessage_route(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "value": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._TransactionMessage_value(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._TransactionMessage_value(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ @@ -14484,26 +16048,126 @@ func (ec *executionContext) _TransactionResponse(ctx context.Context, sel ast.Se case "__typename": out.Values[i] = graphql.MarshalString("TransactionResponse") case "log": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._TransactionResponse_log(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._TransactionResponse_log(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "info": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._TransactionResponse_info(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._TransactionResponse_info(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "error": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._TransactionResponse_error(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._TransactionResponse_error(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "data": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._TransactionResponse_data(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._TransactionResponse_data(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "events": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._TransactionResponse_events(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._TransactionResponse_events(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) @@ -14540,11 +16204,51 @@ func (ec *executionContext) _TxFee(ctx context.Context, sel ast.SelectionSet, ob case "__typename": out.Values[i] = graphql.MarshalString("TxFee") case "gas_wanted": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._TxFee_gas_wanted(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._TxFee_gas_wanted(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "gas_fee": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._TxFee_gas_fee(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._TxFee_gas_fee(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ @@ -14584,6 +16288,26 @@ func (ec *executionContext) _UnexpectedMessage(ctx context.Context, sel ast.Sele case "__typename": out.Values[i] = graphql.MarshalString("UnexpectedMessage") case "raw": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._UnexpectedMessage_raw(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._UnexpectedMessage_raw(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ @@ -14623,6 +16347,26 @@ func (ec *executionContext) _UnknownEvent(ctx context.Context, sel ast.Selection case "__typename": out.Values[i] = graphql.MarshalString("UnknownEvent") case "value": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec._UnknownEvent_value(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec._UnknownEvent_value(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ @@ -14662,23 +16406,123 @@ func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionS case "__typename": out.Values[i] = graphql.MarshalString("__Directive") case "name": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Directive_name(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Directive_name(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "description": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Directive_description(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Directive_description(ctx, field, obj) case "locations": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Directive_locations(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Directive_locations(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "args": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Directive_args(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Directive_args(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "isRepeatable": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Directive_isRepeatable(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Directive_isRepeatable(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ @@ -14718,18 +16562,98 @@ func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionS case "__typename": out.Values[i] = graphql.MarshalString("__EnumValue") case "name": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___EnumValue_name(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___EnumValue_name(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "description": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___EnumValue_description(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___EnumValue_description(ctx, field, obj) case "isDeprecated": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___EnumValue_isDeprecated(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "deprecationReason": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___EnumValue_deprecationReason(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) @@ -14766,28 +16690,148 @@ func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, case "__typename": out.Values[i] = graphql.MarshalString("__Field") case "name": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Field_name(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Field_name(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "description": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Field_description(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Field_description(ctx, field, obj) case "args": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Field_args(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Field_args(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "type": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Field_type(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Field_type(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "isDeprecated": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Field_isDeprecated(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "deprecationReason": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Field_deprecationReason(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) @@ -14824,18 +16868,98 @@ func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.Selection case "__typename": out.Values[i] = graphql.MarshalString("__InputValue") case "name": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___InputValue_name(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___InputValue_name(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "description": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___InputValue_description(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___InputValue_description(ctx, field, obj) case "type": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___InputValue_type(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___InputValue_type(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "defaultValue": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___InputValue_defaultValue(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) @@ -14872,22 +16996,142 @@ func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, case "__typename": out.Values[i] = graphql.MarshalString("__Schema") case "description": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Schema_description(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Schema_description(ctx, field, obj) case "types": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Schema_types(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Schema_types(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "queryType": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Schema_queryType(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Schema_queryType(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "mutationType": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Schema_mutationType(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Schema_mutationType(ctx, field, obj) case "subscriptionType": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Schema_subscriptionType(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj) case "directives": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Schema_directives(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Schema_directives(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ @@ -14927,27 +17171,227 @@ func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, o case "__typename": out.Values[i] = graphql.MarshalString("__Type") case "kind": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Type_kind(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Type_kind(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "name": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Type_name(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Type_name(ctx, field, obj) case "description": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Type_description(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Type_description(ctx, field, obj) case "fields": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Type_fields(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Type_fields(ctx, field, obj) case "interfaces": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Type_interfaces(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Type_interfaces(ctx, field, obj) case "possibleTypes": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Type_possibleTypes(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj) case "enumValues": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Type_enumValues(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Type_enumValues(ctx, field, obj) case "inputFields": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Type_inputFields(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Type_inputFields(ctx, field, obj) case "ofType": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Type_ofType(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Type_ofType(ctx, field, obj) case "specifiedByURL": + field := field + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return ec.___Type_specifiedByURL(ctx, field, obj) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } out.Values[i] = ec.___Type_specifiedByURL(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) @@ -14998,7 +17442,7 @@ func (ec *executionContext) unmarshalNBlockFilter2githubᚗcomᚋgnolangᚋtxᚑ func (ec *executionContext) marshalNBlockTransaction2ᚕᚖgithubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐBlockTransaction(ctx context.Context, sel ast.SelectionSet, v []*model.BlockTransaction) graphql.Marshaler { ret := make(graphql.Array, len(v)) var wg sync.WaitGroup - isLen1 := len(v) == 1 + isLen1 := true if !isLen1 { wg.Add(len(v)) } @@ -15210,7 +17654,7 @@ func (ec *executionContext) unmarshalNTransactionFilter2githubᚗcomᚋgnolang func (ec *executionContext) marshalNTransactionMessage2ᚕᚖgithubᚗcomᚋgnolangᚋtxᚑindexerᚋserveᚋgraphᚋmodelᚐTransactionMessage(ctx context.Context, sel ast.SelectionSet, v []*model.TransactionMessage) graphql.Marshaler { ret := make(graphql.Array, len(v)) var wg sync.WaitGroup - isLen1 := len(v) == 1 + isLen1 := true if !isLen1 { wg.Add(len(v)) } @@ -15277,7 +17721,7 @@ func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlge func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler { ret := make(graphql.Array, len(v)) var wg sync.WaitGroup - isLen1 := len(v) == 1 + isLen1 := true if !isLen1 { wg.Add(len(v)) } @@ -15353,7 +17797,7 @@ func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx conte func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler { ret := make(graphql.Array, len(v)) var wg sync.WaitGroup - isLen1 := len(v) == 1 + isLen1 := true if !isLen1 { wg.Add(len(v)) } @@ -15409,7 +17853,7 @@ func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlg func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler { ret := make(graphql.Array, len(v)) var wg sync.WaitGroup - isLen1 := len(v) == 1 + isLen1 := true if !isLen1 { wg.Add(len(v)) } @@ -15457,7 +17901,7 @@ func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋg func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler { ret := make(graphql.Array, len(v)) var wg sync.WaitGroup - isLen1 := len(v) == 1 + isLen1 := true if !isLen1 { wg.Add(len(v)) } @@ -15545,7 +17989,7 @@ func (ec *executionContext) marshalOBlock2ᚕᚖgithubᚗcomᚋgnolangᚋtxᚑin } ret := make(graphql.Array, len(v)) var wg sync.WaitGroup - isLen1 := len(v) == 1 + isLen1 := true if !isLen1 { wg.Add(len(v)) } @@ -15639,7 +18083,7 @@ func (ec *executionContext) marshalOEvent2ᚕgithubᚗcomᚋgnolangᚋtxᚑindex } ret := make(graphql.Array, len(v)) var wg sync.WaitGroup - isLen1 := len(v) == 1 + isLen1 := true if !isLen1 { wg.Add(len(v)) } @@ -16276,7 +18720,7 @@ func (ec *executionContext) marshalOFilterableExtra2ᚕgithubᚗcomᚋgnolangᚋ } ret := make(graphql.Array, len(v)) var wg sync.WaitGroup - isLen1 := len(v) == 1 + isLen1 := true if !isLen1 { wg.Add(len(v)) } @@ -16323,7 +18767,7 @@ func (ec *executionContext) marshalOGnoEventAttribute2ᚕᚖgithubᚗcomᚋgnola } ret := make(graphql.Array, len(v)) var wg sync.WaitGroup - isLen1 := len(v) == 1 + isLen1 := true if !isLen1 { wg.Add(len(v)) } @@ -16386,7 +18830,7 @@ func (ec *executionContext) marshalOMemFile2ᚕᚖgithubᚗcomᚋgnolangᚋtxᚑ } ret := make(graphql.Array, len(v)) var wg sync.WaitGroup - isLen1 := len(v) == 1 + isLen1 := true if !isLen1 { wg.Add(len(v)) } @@ -17043,7 +19487,7 @@ func (ec *executionContext) marshalOTransaction2ᚕᚖgithubᚗcomᚋgnolangᚋt } ret := make(graphql.Array, len(v)) var wg sync.WaitGroup - isLen1 := len(v) == 1 + isLen1 := true if !isLen1 { wg.Add(len(v)) } @@ -17133,7 +19577,7 @@ func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgq } ret := make(graphql.Array, len(v)) var wg sync.WaitGroup - isLen1 := len(v) == 1 + isLen1 := true if !isLen1 { wg.Add(len(v)) } @@ -17180,7 +19624,7 @@ func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgen } ret := make(graphql.Array, len(v)) var wg sync.WaitGroup - isLen1 := len(v) == 1 + isLen1 := true if !isLen1 { wg.Add(len(v)) } @@ -17227,7 +19671,7 @@ func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋg } ret := make(graphql.Array, len(v)) var wg sync.WaitGroup - isLen1 := len(v) == 1 + isLen1 := true if !isLen1 { wg.Add(len(v)) } @@ -17281,7 +19725,7 @@ func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgen } ret := make(graphql.Array, len(v)) var wg sync.WaitGroup - isLen1 := len(v) == 1 + isLen1 := true if !isLen1 { wg.Add(len(v)) } diff --git a/serve/graph/model/filter_methods_gen.go b/serve/graph/model/filter_methods_gen.go index 4d586c9..80e94a2 100644 --- a/serve/graph/model/filter_methods_gen.go +++ b/serve/graph/model/filter_methods_gen.go @@ -415,40 +415,50 @@ func (f *NestedFilterMessageValue) Eval(obj *MessageValue) bool { } // Handle union objects depending of the type - tobj := *obj - switch objv := tobj.(type) { - case BankMsgSend: - // Handle BankMsgSend field - toEvalBankMsgSend := objv - if f.BankMsgSend != nil && !f.BankMsgSend.Eval(&toEvalBankMsgSend) { - return false - } + // Check if any filters are specified + filtersSpecified := f.BankMsgSend != nil || f.MsgCall != nil || f.MsgAddPackage != nil || f.MsgRun != nil || false - case MsgCall: + // If no filters are specified for any types, accept all objects + if !filtersSpecified { + return true + } + + // Evaluate specified type filters + matchedType := false - // Handle MsgCall field - toEvalMsgCall := objv - if f.MsgCall != nil && !f.MsgCall.Eval(&toEvalMsgCall) { + tobj := *obj + if uObj, ok := tobj.(BankMsgSend); ok { + matchedType = true + if f.BankMsgSend != nil && !f.BankMsgSend.Eval(&uObj) { return false } + } - case MsgAddPackage: - - // Handle MsgAddPackage field - toEvalMsgAddPackage := objv - if f.MsgAddPackage != nil && !f.MsgAddPackage.Eval(&toEvalMsgAddPackage) { + if uObj, ok := tobj.(MsgCall); ok { + matchedType = true + if f.MsgCall != nil && !f.MsgCall.Eval(&uObj) { return false } + } - case MsgRun: + if uObj, ok := tobj.(MsgAddPackage); ok { + matchedType = true + if f.MsgAddPackage != nil && !f.MsgAddPackage.Eval(&uObj) { + return false + } + } - // Handle MsgRun field - toEvalMsgRun := objv - if f.MsgRun != nil && !f.MsgRun.Eval(&toEvalMsgRun) { + if uObj, ok := tobj.(MsgRun); ok { + matchedType = true + if f.MsgRun != nil && !f.MsgRun.Eval(&uObj) { return false } + } + // If the object is of a type not specified in filters and filters are specified, ignore this element + if !matchedType { + return true } return true @@ -692,24 +702,36 @@ func (f *NestedFilterEvent) Eval(obj *Event) bool { } // Handle union objects depending of the type - tobj := *obj - switch objv := tobj.(type) { - case GnoEvent: - // Handle GnoEvent field - toEvalGnoEvent := objv - if f.GnoEvent != nil && !f.GnoEvent.Eval(&toEvalGnoEvent) { + // Check if any filters are specified + filtersSpecified := f.GnoEvent != nil || f.UnknownEvent != nil || false + + // If no filters are specified for any types, accept all objects + if !filtersSpecified { + return true + } + + // Evaluate specified type filters + matchedType := false + + tobj := *obj + if uObj, ok := tobj.(GnoEvent); ok { + matchedType = true + if f.GnoEvent != nil && !f.GnoEvent.Eval(&uObj) { return false } + } - case UnknownEvent: - - // Handle UnknownEvent field - toEvalUnknownEvent := objv - if f.UnknownEvent != nil && !f.UnknownEvent.Eval(&toEvalUnknownEvent) { + if uObj, ok := tobj.(UnknownEvent); ok { + matchedType = true + if f.UnknownEvent != nil && !f.UnknownEvent.Eval(&uObj) { return false } + } + // If the object is of a type not specified in filters and filters are specified, ignore this element + if !matchedType { + return true } return true @@ -1488,40 +1510,50 @@ func (f *FilterMessageValue) Eval(obj *MessageValue) bool { } // Handle union objects depending of the type - tobj := *obj - switch objv := tobj.(type) { - case BankMsgSend: - // Handle BankMsgSend field - toEvalBankMsgSend := objv - if f.BankMsgSend != nil && !f.BankMsgSend.Eval(&toEvalBankMsgSend) { - return false - } + // Check if any filters are specified + filtersSpecified := f.BankMsgSend != nil || f.MsgCall != nil || f.MsgAddPackage != nil || f.MsgRun != nil || false - case MsgCall: + // If no filters are specified for any types, accept all objects + if !filtersSpecified { + return true + } + + // Evaluate specified type filters + matchedType := false - // Handle MsgCall field - toEvalMsgCall := objv - if f.MsgCall != nil && !f.MsgCall.Eval(&toEvalMsgCall) { + tobj := *obj + if uObj, ok := tobj.(BankMsgSend); ok { + matchedType = true + if f.BankMsgSend != nil && !f.BankMsgSend.Eval(&uObj) { return false } + } - case MsgAddPackage: - - // Handle MsgAddPackage field - toEvalMsgAddPackage := objv - if f.MsgAddPackage != nil && !f.MsgAddPackage.Eval(&toEvalMsgAddPackage) { + if uObj, ok := tobj.(MsgCall); ok { + matchedType = true + if f.MsgCall != nil && !f.MsgCall.Eval(&uObj) { return false } + } - case MsgRun: + if uObj, ok := tobj.(MsgAddPackage); ok { + matchedType = true + if f.MsgAddPackage != nil && !f.MsgAddPackage.Eval(&uObj) { + return false + } + } - // Handle MsgRun field - toEvalMsgRun := objv - if f.MsgRun != nil && !f.MsgRun.Eval(&toEvalMsgRun) { + if uObj, ok := tobj.(MsgRun); ok { + matchedType = true + if f.MsgRun != nil && !f.MsgRun.Eval(&uObj) { return false } + } + // If the object is of a type not specified in filters and filters are specified, ignore this element + if !matchedType { + return true } return true @@ -1765,24 +1797,36 @@ func (f *FilterEvent) Eval(obj *Event) bool { } // Handle union objects depending of the type - tobj := *obj - switch objv := tobj.(type) { - case GnoEvent: - // Handle GnoEvent field - toEvalGnoEvent := objv - if f.GnoEvent != nil && !f.GnoEvent.Eval(&toEvalGnoEvent) { + // Check if any filters are specified + filtersSpecified := f.GnoEvent != nil || f.UnknownEvent != nil || false + + // If no filters are specified for any types, accept all objects + if !filtersSpecified { + return true + } + + // Evaluate specified type filters + matchedType := false + + tobj := *obj + if uObj, ok := tobj.(GnoEvent); ok { + matchedType = true + if f.GnoEvent != nil && !f.GnoEvent.Eval(&uObj) { return false } + } - case UnknownEvent: - - // Handle UnknownEvent field - toEvalUnknownEvent := objv - if f.UnknownEvent != nil && !f.UnknownEvent.Eval(&toEvalUnknownEvent) { + if uObj, ok := tobj.(UnknownEvent); ok { + matchedType = true + if f.UnknownEvent != nil && !f.UnknownEvent.Eval(&uObj) { return false } + } + // If the object is of a type not specified in filters and filters are specified, ignore this element + if !matchedType { + return true } return true