diff --git a/v2/go.mod b/v2/go.mod index ad5d096fc1..b0d959d69e 100644 --- a/v2/go.mod +++ b/v2/go.mod @@ -3,6 +3,7 @@ module github.com/wundergraph/graphql-go-tools/v2 go 1.25 require ( + connectrpc.com/connect v1.19.2 github.com/99designs/gqlgen v0.17.76 github.com/bufbuild/protocompile v0.14.1 github.com/buger/jsonparser v1.1.1 diff --git a/v2/go.sum b/v2/go.sum index 13adfeb881..2dfb181e23 100644 --- a/v2/go.sum +++ b/v2/go.sum @@ -1,3 +1,5 @@ +connectrpc.com/connect v1.19.2 h1:McQ83FGdzL+t60peksi0gXC7MQ/iLKgLduAnThbM0mo= +connectrpc.com/connect v1.19.2/go.mod h1:tN20fjdGlewnSFeZxLKb0xwIZ6ozc3OQs2hTXy4du9w= github.com/99designs/gqlgen v0.17.76 h1:YsJBcfACWmXWU2t1yCjoGdOmqcTfOFpjbLAE443fmYI= github.com/99designs/gqlgen v0.17.76/go.mod h1:miiU+PkAnTIDKMQ1BseUOIVeQHoiwYDZGCswoxl7xec= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= diff --git a/v2/pkg/engine/datasource/graphql_datasource/configuration.go b/v2/pkg/engine/datasource/graphql_datasource/configuration.go index ec398c0e05..508807b419 100644 --- a/v2/pkg/engine/datasource/graphql_datasource/configuration.go +++ b/v2/pkg/engine/datasource/graphql_datasource/configuration.go @@ -20,7 +20,18 @@ type ConfigurationInput struct { SchemaConfiguration *SchemaConfiguration CustomScalarTypeFields []SingleTypeField - GRPC *grpcdatasource.GRPCConfiguration + GRPC *grpcdatasource.GRPCConfiguration + Connect *ConnectConfiguration +} + +// ConnectConfiguration holds Connect protocol-specific configuration. +// The GRPC field in ConfigurationInput is still used for Mapping and Compiler, +// as Connect shares the same protobuf schema definitions. +type ConnectConfiguration struct { + // BaseURL is the base URL of the Connect service (e.g., "http://localhost:8080"). + BaseURL string + // Encoding specifies the serialization format (Protobuf or JSON). + Encoding grpcdatasource.ConnectEncoding } type Configuration struct { @@ -29,7 +40,8 @@ type Configuration struct { schemaConfiguration SchemaConfiguration customScalarTypeFields []SingleTypeField - grpc *grpcdatasource.GRPCConfiguration + grpc *grpcdatasource.GRPCConfiguration + connect *ConnectConfiguration } func NewConfiguration(input ConfigurationInput) (Configuration, error) { @@ -46,8 +58,8 @@ func NewConfiguration(input ConfigurationInput) (Configuration, error) { cfg.schemaConfiguration = *input.SchemaConfiguration - if input.Fetch == nil && input.Subscription == nil && input.GRPC == nil { - return Configuration{}, errors.New("fetch or subscription or grpc configuration is required") + if input.Fetch == nil && input.Subscription == nil && input.GRPC == nil && input.Connect == nil { + return Configuration{}, errors.New("fetch or subscription or grpc or connect configuration is required") } if input.Fetch != nil { @@ -76,6 +88,15 @@ func NewConfiguration(input ConfigurationInput) (Configuration, error) { cfg.grpc = input.GRPC } + if input.Connect != nil { + cfg.connect = input.Connect + // Connect uses the same GRPC mapping/compiler for proto schema definitions. + // Ensure GRPC config is also provided when using Connect. + if input.GRPC == nil { + return Configuration{}, errors.New("GRPC configuration (mapping/compiler) is required when using Connect") + } + } + return cfg, nil } @@ -99,6 +120,10 @@ func (c *Configuration) IsGRPC() bool { return c.grpc != nil } +func (c *Configuration) IsConnect() bool { + return c.connect != nil +} + type SingleTypeField struct { TypeName string FieldName string diff --git a/v2/pkg/engine/datasource/graphql_datasource/graphql_datasource.go b/v2/pkg/engine/datasource/graphql_datasource/graphql_datasource.go index f4268d1f6a..292412d0c4 100644 --- a/v2/pkg/engine/datasource/graphql_datasource/graphql_datasource.go +++ b/v2/pkg/engine/datasource/graphql_datasource/graphql_datasource.go @@ -90,8 +90,9 @@ type Planner[T Configuration] struct { minifier *astminify.Minifier - // gRPC - grpcClient grpc.ClientConnInterface + // gRPC / Connect + grpcClient grpc.ClientConnInterface + connectTransport grpcdatasource.RPCTransport printKitPool *sync.Pool } @@ -360,7 +361,15 @@ func (p *Planner[T]) ConfigureFetch() resolve.FetchConfiguration { return resolve.FetchConfiguration{} } - dataSource, err = grpcdatasource.NewDataSource(p.grpcClient, grpcdatasource.DataSourceConfig{ + // Determine which transport to use: Connect or gRPC. + var transport grpcdatasource.RPCTransport + if p.connectTransport != nil { + transport = p.connectTransport + } else { + transport = grpcdatasource.NewGRPCTransport(p.grpcClient) + } + + dataSource, err = grpcdatasource.NewDataSource(transport, grpcdatasource.DataSourceConfig{ Operation: &opDocument, Definition: p.config.schemaConfiguration.upstreamSchemaAst, Mapping: p.config.grpc.Mapping, @@ -372,7 +381,7 @@ func (p *Planner[T]) ConfigureFetch() resolve.FetchConfiguration { SubgraphName: p.dataSourceConfig.Name(), }) if err != nil { - p.stopWithError(errors.WithStack(fmt.Errorf("failed to create gRPC datasource: %w", err))) + p.stopWithError(errors.WithStack(fmt.Errorf("failed to create datasource: %w", err))) return resolve.FetchConfiguration{} } } @@ -1728,10 +1737,11 @@ func getRelaxedPrintKitPool() *sync.Pool { } type Factory[T Configuration] struct { - executionContext context.Context + executionContext context.Context httpClient *http.Client grpcClient grpc.ClientConnInterface grpcClientProvider func() grpc.ClientConnInterface + connectTransport grpcdatasource.RPCTransport subscriptionClient GraphQLSubscriptionClient printKitPool *sync.Pool } @@ -1795,6 +1805,23 @@ func NewFactoryGRPCClientProvider(executionContext context.Context, clientProvid }, nil } +// NewFactoryConnect creates a Connect protocol factory for the GraphQL datasource planner. +// It uses the Connect protocol (HTTP-native RPC) instead of gRPC for transport. +func NewFactoryConnect(executionContext context.Context, connectTransport grpcdatasource.RPCTransport) (*Factory[Configuration], error) { + if executionContext == nil { + return nil, fmt.Errorf("execution context is required") + } + + if connectTransport == nil { + return nil, fmt.Errorf("connect transport is required") + } + + return &Factory[Configuration]{ + executionContext: executionContext, + connectTransport: connectTransport, + }, nil +} + func (p *Planner[T]) getKit() *printKit { pool := p.printKitPool if pool == nil { @@ -1837,6 +1864,7 @@ func (f *Factory[T]) Planner(logger abstractlogger.Logger) plan.DataSourcePlanne return &Planner[T]{ fetchClient: f.httpClient, grpcClient: grpcClient, + connectTransport: f.connectTransport, subscriptionClient: f.subscriptionClient, printKitPool: f.getPrintKitPool(), } @@ -1862,7 +1890,7 @@ func (f *Factory[T]) PlanningBehavior() plan.DataSourcePlanningBehavior { MergeAliasedRootNodes: true, OverrideFieldPathFromAlias: true, AllowPlanningTypeName: true, - AlwaysFlattenFragments: f.grpcClient != nil || f.grpcClientProvider != nil, + AlwaysFlattenFragments: f.grpcClient != nil || f.grpcClientProvider != nil || f.connectTransport != nil, } return b } diff --git a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource.go b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource.go index 527b3e2448..e68d9fc1b6 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource.go +++ b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource.go @@ -44,7 +44,7 @@ var _ resolve.DataSource = (*DataSource)(nil) // transforms the responses back to GraphQL format. type DataSource struct { plan *RPCExecutionPlan - cc grpc.ClientConnInterface + transport RPCTransport rc *RPCCompiler mapping *GRPCMapping federationConfigs plan.FederationFieldConfigurations @@ -68,8 +68,8 @@ type DataSourceConfig struct { Disabled bool } -// NewDataSource creates a new gRPC datasource -func NewDataSource(client grpc.ClientConnInterface, config DataSourceConfig) (*DataSource, error) { +// NewDataSource creates a new datasource with the given RPCTransport. +func NewDataSource(transport RPCTransport, config DataSourceConfig) (*DataSource, error) { planner, err := NewPlanner(config.SubgraphName, config.Mapping, config.FederationConfigs) if err != nil { return nil, err @@ -81,7 +81,7 @@ func NewDataSource(client grpc.ClientConnInterface, config DataSourceConfig) (*D return &DataSource{ plan: plan, - cc: client, + transport: transport, rc: config.Compiler, mapping: config.Mapping, definition: config.Definition, @@ -91,6 +91,12 @@ func NewDataSource(client grpc.ClientConnInterface, config DataSourceConfig) (*D }, nil } +// NewDataSourceGRPC creates a new gRPC datasource using a gRPC ClientConnInterface. +// This is a convenience function that wraps the connection in a grpcTransport. +func NewDataSourceGRPC(client grpc.ClientConnInterface, config DataSourceConfig) (*DataSource, error) { + return NewDataSource(NewGRPCTransport(client), config) +} + // Load implements resolve.DataSource interface. // It processes the input JSON data to make gRPC calls and returns // the response data. @@ -152,7 +158,7 @@ func (d *DataSource) Load(ctx context.Context, headers http.Header, input []byte builder := newJSONBuilder(item.Arena, d.mapping, variables) errGrp.Go(func() error { // Invoke the gRPC method - this will populate serviceCall.Output - err := d.cc.Invoke(errGrpCtx, serviceCall.MethodFullName(), serviceCall.Input, serviceCall.Output) + err := d.transport.Invoke(errGrpCtx, serviceCall.MethodFullName(), serviceCall.Input, serviceCall.Output) if err != nil { return err } diff --git a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_connect_test.go b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_connect_test.go new file mode 100644 index 0000000000..329ca1cade --- /dev/null +++ b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_connect_test.go @@ -0,0 +1,184 @@ +package grpcdatasource + +import ( + "context" + "encoding/json" + "fmt" + "net/http" + "net/http/httptest" + "testing" + + "github.com/stretchr/testify/require" + "golang.org/x/net/http2" + "golang.org/x/net/http2/h2c" + + "github.com/wundergraph/graphql-go-tools/v2/pkg/astparser" + "github.com/wundergraph/graphql-go-tools/v2/pkg/grpctest" + "github.com/wundergraph/graphql-go-tools/v2/pkg/grpctest/productv1/productv1connect" +) + +// setupTestConnectServer starts an httptest server backed by the +// MockServiceConnect adapter (the gRPC MockService wrapped onto the +// ConnectRPC handler interface). The server speaks Connect, gRPC, and +// gRPC-Web on the same H2C endpoint, but for these tests we drive it via +// the Connect transport. +// +// Returns a base URL that can be passed to NewConnectTransport. +func setupTestConnectServer(t testing.TB) (baseURL string, cleanup func()) { + t.Helper() + + mock := &grpctest.MockService{} + connectImpl := grpctest.NewMockServiceConnect(mock) + + mux := http.NewServeMux() + mux.Handle(productv1connect.NewProductServiceHandler(connectImpl)) + + srv := httptest.NewUnstartedServer(h2c.NewHandler(mux, &http2.Server{})) + srv.EnableHTTP2 = true + srv.Start() + + cleanup = srv.Close + return srv.URL, cleanup +} + +// Test_DataSource_Load_WithMockServiceConnect mirrors the gRPC end-to-end +// happy path (Test_DataSource_Load_WithMockService) but routes the call +// through the Connect transport instead of the gRPC client connection. +// It proves that the data source pipeline (compiler -> JSON builder -> +// transport -> response unmarshal) works for the Connect protocol against +// the same MockService implementation. +func Test_DataSource_Load_WithMockServiceConnect(t *testing.T) { + baseURL, cleanup := setupTestConnectServer(t) + t.Cleanup(cleanup) + + query := `query ComplexFilterTypeQuery($filter: ComplexFilterTypeInput!) { complexFilterType(filter: $filter) { id name } }` + variables := `{"variables":{"filter":{"filter":{"name":"Test Product","filterField1":"filterField1","filterField2":"filterField2"}}}}` + + schemaDoc := grpctest.MustGraphQLSchema(t) + queryDoc, report := astparser.ParseGraphqlDocumentString(query) + if report.HasErrors() { + t.Fatalf("failed to parse query: %s", report.Error()) + } + + compiler, err := NewProtoCompiler(grpctest.MustProtoSchema(t), nil) + require.NoError(t, err) + + transport := NewConnectTransport(ConnectTransportConfig{ + BaseURL: baseURL, + Encoding: ConnectEncodingProtobuf, + }) + + ds, err := NewDataSource(transport, DataSourceConfig{ + Operation: &queryDoc, + Definition: &schemaDoc, + SubgraphName: "Products", + Compiler: compiler, + Mapping: &GRPCMapping{ + Service: "Products", + QueryRPCs: RPCConfigMap[RPCConfig]{ + "complexFilterType": { + RPC: "QueryComplexFilterType", + Request: "QueryComplexFilterTypeRequest", + Response: "QueryComplexFilterTypeResponse", + }, + }, + Fields: map[string]FieldMap{ + "Query": { + "complexFilterType": { + TargetName: "complex_filter_type", + ArgumentMappings: map[string]string{ + "filter": "filter", + }, + }, + }, + "FilterType": { + "name": {TargetName: "name"}, + "filterField1": {TargetName: "filter_field_1"}, + "filterField2": {TargetName: "filter_field_2"}, + }, + }, + }, + }) + require.NoError(t, err) + + output, err := ds.Load(context.Background(), nil, []byte(`{"query":"`+query+`","body":`+variables+`}`)) + require.NoError(t, err) + + type response struct { + Data struct { + ComplexFilterType []struct { + Id string `json:"id"` + Name string `json:"name"` + } `json:"complexFilterType"` + } `json:"data"` + } + var resp response + require.NoError(t, json.Unmarshal(output, &resp)) + require.Equal(t, "test-id-123", resp.Data.ComplexFilterType[0].Id) + require.Equal(t, "Test Product", resp.Data.ComplexFilterType[0].Name) +} + +// Test_DataSource_Load_WithMockServiceConnect_JSON re-runs the same +// happy-path query with JSON encoding instead of Protobuf. Both wire +// formats must yield identical decoded responses. +func Test_DataSource_Load_WithMockServiceConnect_JSON(t *testing.T) { + baseURL, cleanup := setupTestConnectServer(t) + t.Cleanup(cleanup) + + query := `query ComplexFilterTypeQuery($filter: ComplexFilterTypeInput!) { complexFilterType(filter: $filter) { id name } }` + variables := `{"variables":{"filter":{"filter":{"name":"Test Product","filterField1":"a","filterField2":"b"}}}}` + + schemaDoc := grpctest.MustGraphQLSchema(t) + queryDoc, report := astparser.ParseGraphqlDocumentString(query) + if report.HasErrors() { + t.Fatalf("failed to parse query: %s", report.Error()) + } + + compiler, err := NewProtoCompiler(grpctest.MustProtoSchema(t), nil) + require.NoError(t, err) + + transport := NewConnectTransport(ConnectTransportConfig{ + BaseURL: baseURL, + Encoding: ConnectEncodingJSON, + }) + + ds, err := NewDataSource(transport, DataSourceConfig{ + Operation: &queryDoc, + Definition: &schemaDoc, + SubgraphName: "Products", + Compiler: compiler, + Mapping: &GRPCMapping{ + Service: "Products", + QueryRPCs: RPCConfigMap[RPCConfig]{ + "complexFilterType": { + RPC: "QueryComplexFilterType", + Request: "QueryComplexFilterTypeRequest", + Response: "QueryComplexFilterTypeResponse", + }, + }, + Fields: map[string]FieldMap{ + "Query": { + "complexFilterType": { + TargetName: "complex_filter_type", + ArgumentMappings: map[string]string{ + "filter": "filter", + }, + }, + }, + "FilterType": { + "name": {TargetName: "name"}, + "filterField1": {TargetName: "filter_field_1"}, + "filterField2": {TargetName: "filter_field_2"}, + }, + }, + }, + }) + require.NoError(t, err) + + output, err := ds.Load(context.Background(), nil, []byte(`{"query":"`+query+`","body":`+variables+`}`)) + require.NoError(t, err) + + require.Contains(t, string(output), `"id":"test-id-123"`) + require.Contains(t, string(output), `"name":"Test Product"`) + fmt.Println(string(output)) // helpful when debugging encoding regressions +} diff --git a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_federation_test.go b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_federation_test.go index 786fe338cf..823ed5fb0e 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_federation_test.go +++ b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_federation_test.go @@ -317,7 +317,7 @@ func Test_DataSource_Load_WithEntity_Calls(t *testing.T) { } // Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -617,7 +617,7 @@ func Test_DataSource_Load_WithEntity_Calls_WithCompositeTypes(t *testing.T) { } // Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -1406,7 +1406,7 @@ func Test_DataSource_Load_WithEntity_Calls_And_Requires(t *testing.T) { } // Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -1821,7 +1821,7 @@ func Test_DataSource_Load_WithEntity_Calls_And_Requires_And_FieldResolvers(t *te } // Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -1965,7 +1965,7 @@ func Test_DataSource_Load_WithEntity_Calls_And_Requires_AbstractTypes(t *testing } // Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", diff --git a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_spy_test.go b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_spy_test.go index 2ad9172916..1c3b358bd4 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_spy_test.go +++ b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_spy_test.go @@ -150,7 +150,7 @@ func Test_DataSource_Load_NullMetrics_NestedResolversNotInvoked(t *testing.T) { compiler, err := NewProtoCompiler(grpctest.MustProtoSchema(t), testMapping()) require.NoError(t, err) - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -191,7 +191,7 @@ func Test_DataSource_Load_NullCategory_FieldResolversNotInvoked(t *testing.T) { compiler, err := NewProtoCompiler(grpctest.MustProtoSchema(t), testMapping()) require.NoError(t, err) - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -226,7 +226,7 @@ func Test_DataSource_Load_ArgumentLessFieldResolversCalled(t *testing.T) { compiler, err := NewProtoCompiler(grpctest.MustProtoSchema(t), testMapping()) require.NoError(t, err) - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSource(NewGRPCTransport(conn), DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -267,7 +267,7 @@ func Test_DataSource_Load_NullCategory_ArgumentLessFieldResolversNotInvoked(t *t compiler, err := NewProtoCompiler(grpctest.MustProtoSchema(t), testMapping()) require.NoError(t, err) - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSource(NewGRPCTransport(conn), DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", diff --git a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_test.go b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_test.go index 112ce26d62..e723d6e37f 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_test.go +++ b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_test.go @@ -44,7 +44,7 @@ func Benchmark_DataSource_Load(b *testing.B) { compiler, err := NewProtoCompiler(grpctest.MustProtoSchema(b), testMapping()) require.NoError(b, err) - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -81,7 +81,7 @@ func Benchmark_DataSource_Load_WithFieldArguments(b *testing.B) { const subgraphName = "Products" - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: subgraphName, @@ -192,7 +192,7 @@ func Test_DataSource_Load(t *testing.T) { } mi := mockInterface{} - ds, err := NewDataSource(mi, DataSourceConfig{ + ds, err := NewDataSourceGRPC(mi, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -247,7 +247,7 @@ func Test_DataSource_Load_WithMockService(t *testing.T) { } // 2. Create a datasource with the real gRPC client connection - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -337,7 +337,7 @@ func Test_DataSource_Load_WithRecursiveInputType(t *testing.T) { t.Fatalf("failed to compile proto: %v", err) } - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -388,7 +388,7 @@ func Test_DataSource_Load_WithMockService_WithResponseMapping(t *testing.T) { } // 2. Create a datasource with the real gRPC client connection - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -489,7 +489,7 @@ func Test_DataSource_Load_WithGrpcError(t *testing.T) { } // 3. Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -837,7 +837,7 @@ func Test_DataSource_Load_WithAnimalInterface(t *testing.T) { } // Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -1107,7 +1107,7 @@ func Test_Datasource_Load_WithUnionTypes(t *testing.T) { } // Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -1243,7 +1243,7 @@ func Test_DataSource_Load_WithCategoryQueries(t *testing.T) { } // Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -1323,7 +1323,7 @@ func Test_DataSource_Load_WithTotalCalculation(t *testing.T) { } // Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -1413,7 +1413,7 @@ func Test_DataSource_Load_WithTypename(t *testing.T) { } // Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -1882,7 +1882,7 @@ func Test_DataSource_Load_WithAliases(t *testing.T) { } // Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -2260,7 +2260,7 @@ func Test_DataSource_Load_WithNullableFieldsType(t *testing.T) { } // Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -3561,7 +3561,7 @@ func Test_DataSource_Load_WithNestedLists(t *testing.T) { } // Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -4795,7 +4795,7 @@ func Test_Datasource_Load_WithFieldResolvers(t *testing.T) { } // Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -5004,7 +5004,7 @@ func Test_Datasource_Load_WithHeaders(t *testing.T) { require.NoError(t, err) // Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", @@ -5055,7 +5055,7 @@ func Test_Datasource_Load_PreservesExistingContextMetadata(t *testing.T) { require.NoError(t, err) // Create the datasource - ds, err := NewDataSource(conn, DataSourceConfig{ + ds, err := NewDataSourceGRPC(conn, DataSourceConfig{ Operation: &queryDoc, Definition: &schemaDoc, SubgraphName: "Products", diff --git a/v2/pkg/engine/datasource/grpc_datasource/transport.go b/v2/pkg/engine/datasource/grpc_datasource/transport.go new file mode 100644 index 0000000000..6bdd0208d1 --- /dev/null +++ b/v2/pkg/engine/datasource/grpc_datasource/transport.go @@ -0,0 +1,36 @@ +package grpcdatasource + +import ( + "context" + "errors" + + "google.golang.org/grpc" + protoref "google.golang.org/protobuf/reflect/protoreflect" +) + +// RPCTransport abstracts the transport protocol for RPC calls. +// Both gRPC and Connect protocol implement this interface. +type RPCTransport interface { + Invoke(ctx context.Context, methodFullName string, input, output protoref.Message) error +} + +// grpcTransport wraps grpc.ClientConnInterface to implement RPCTransport. +type grpcTransport struct { + cc grpc.ClientConnInterface +} + +// NewGRPCTransport creates an RPCTransport that delegates to a gRPC ClientConnInterface. +func NewGRPCTransport(cc grpc.ClientConnInterface) RPCTransport { + return &grpcTransport{cc: cc} +} + +func (t *grpcTransport) Invoke(ctx context.Context, method string, input, output protoref.Message) error { + if t.cc == nil { + return errors.New("grpc transport: nil client connection") + } + // grpc.ClientConnInterface.Invoke accepts (ctx, method, args any, reply any, opts ...grpc.CallOption). + // protoref.Message satisfies the any constraint; variadic opts can be omitted. + // This wrapper intentionally does not forward grpc.CallOption, as RPCTransport + // is protocol-agnostic. The existing grpc_datasource code does not use any CallOption at the Invoke site. + return t.cc.Invoke(ctx, method, input, output) +} diff --git a/v2/pkg/engine/datasource/grpc_datasource/transport_connect.go b/v2/pkg/engine/datasource/grpc_datasource/transport_connect.go new file mode 100644 index 0000000000..ff7c38ec90 --- /dev/null +++ b/v2/pkg/engine/datasource/grpc_datasource/transport_connect.go @@ -0,0 +1,174 @@ +package grpcdatasource + +import ( + "bytes" + "context" + "encoding/base64" + "encoding/json" + "fmt" + "io" + "net/http" + "strings" + + "google.golang.org/grpc/metadata" + "google.golang.org/protobuf/encoding/protojson" + "google.golang.org/protobuf/proto" + protoref "google.golang.org/protobuf/reflect/protoreflect" +) + +// ConnectEncoding represents the encoding format for Connect protocol requests. +type ConnectEncoding int + +const ( + // ConnectEncodingProtobuf uses binary protobuf encoding. + ConnectEncodingProtobuf ConnectEncoding = iota + // ConnectEncodingJSON uses JSON encoding via protojson. + ConnectEncodingJSON +) + +// maxConnectResponseSize limits the response body read from a Connect service to 10 MB +// to prevent memory exhaustion from unexpectedly large or malicious responses. +const maxConnectResponseSize = 10 * 1024 * 1024 + +// ConnectTransportConfig holds the configuration for creating a Connect transport. +type ConnectTransportConfig struct { + // BaseURL is the base URL of the Connect service (e.g., "http://localhost:8080"). + BaseURL string + // HTTPClient is the HTTP client to use. If nil, http.DefaultClient is used. + HTTPClient *http.Client + // Encoding specifies the serialization format (Protobuf or JSON). + Encoding ConnectEncoding +} + +// connectTransport implements RPCTransport using the Connect protocol over HTTP. +type connectTransport struct { + baseURL string + httpClient *http.Client + encoding ConnectEncoding +} + +// NewConnectTransport creates an RPCTransport that uses the Connect protocol. +func NewConnectTransport(config ConnectTransportConfig) RPCTransport { + httpClient := config.HTTPClient + if httpClient == nil { + httpClient = http.DefaultClient + } + + return &connectTransport{ + baseURL: strings.TrimRight(config.BaseURL, "/"), + httpClient: httpClient, + encoding: config.Encoding, + } +} + +func (t *connectTransport) Invoke(ctx context.Context, methodFullName string, input, output protoref.Message) error { + url := t.baseURL + methodFullName + + // protoref.Message (protoreflect.Message) is the reflection interface. + // The underlying runtime type (*dynamicpb.Message) implements proto.Message, + // which is required by proto.Marshal / protojson.Marshal. + // We need to get the proto.Message interface via the ProtoReflect().Interface() path, + // or directly type-assert since dynamicpb.Message implements proto.Message. + inputMsg, ok := input.Interface().(proto.Message) + if !ok { + return fmt.Errorf("connect: input does not implement proto.Message") + } + + var reqBody []byte + var contentType string + var err error + + switch t.encoding { + case ConnectEncodingProtobuf: + contentType = "application/proto" + reqBody, err = proto.Marshal(inputMsg) + case ConnectEncodingJSON: + contentType = "application/json" + reqBody, err = protojson.Marshal(inputMsg) + default: + return fmt.Errorf("connect: unsupported encoding: %d", t.encoding) + } + if err != nil { + return fmt.Errorf("connect: marshal request: %w", err) + } + + req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(reqBody)) + if err != nil { + return fmt.Errorf("connect: create request: %w", err) + } + req.Header.Set("Content-Type", contentType) + req.Header.Set("Connect-Protocol-Version", "1") + + // Forward gRPC metadata as HTTP headers. + // Keys ending in "-bin" carry binary values; the Connect protocol requires + // these to be base64-encoded before placing them in an HTTP header. + if md, ok := metadata.FromOutgoingContext(ctx); ok { + for k, vals := range md { + isBin := strings.HasSuffix(k, "-bin") + for _, v := range vals { + if isBin { + req.Header.Add(k, base64.StdEncoding.EncodeToString([]byte(v))) + } else { + req.Header.Add(k, v) + } + } + } + } + + resp, err := t.httpClient.Do(req) + if err != nil { + return fmt.Errorf("connect: send request: %w", err) + } + defer resp.Body.Close() + + respBody, err := io.ReadAll(io.LimitReader(resp.Body, maxConnectResponseSize+1)) + if err != nil { + return fmt.Errorf("connect: read response: %w", err) + } + if len(respBody) > maxConnectResponseSize { + return fmt.Errorf("connect: response body exceeds %d bytes", maxConnectResponseSize) + } + + if resp.StatusCode != http.StatusOK { + return parseConnectError(resp.StatusCode, respBody) + } + + // Unmarshal response into the output message. + outputMsg, ok := output.Interface().(proto.Message) + if !ok { + return fmt.Errorf("connect: output does not implement proto.Message") + } + + switch t.encoding { + case ConnectEncodingProtobuf: + err = proto.Unmarshal(respBody, outputMsg) + case ConnectEncodingJSON: + err = protojson.Unmarshal(respBody, outputMsg) + } + if err != nil { + return fmt.Errorf("connect: unmarshal response: %w", err) + } + + return nil +} + +// connectError represents an error response from a Connect protocol service. +type connectError struct { + Code string `json:"code"` + Message string `json:"message"` +} + +// parseConnectError parses an error response body from a Connect service. +// Connect errors are always JSON-encoded regardless of the request encoding. +// If the body is not valid JSON (e.g., a 502 from a reverse proxy), falls back to raw status code. +func parseConnectError(statusCode int, body []byte) error { + var ce connectError + if err := json.Unmarshal(body, &ce); err != nil { + bodyStr := string(body) + if len(bodyStr) > 256 { + bodyStr = bodyStr[:256] + "... (truncated)" + } + return fmt.Errorf("connect: HTTP %d: %s", statusCode, bodyStr) + } + return fmt.Errorf("connect: %s: %s", ce.Code, ce.Message) +} diff --git a/v2/pkg/engine/datasource/grpc_datasource/transport_connect_test.go b/v2/pkg/engine/datasource/grpc_datasource/transport_connect_test.go new file mode 100644 index 0000000000..4665568bc3 --- /dev/null +++ b/v2/pkg/engine/datasource/grpc_datasource/transport_connect_test.go @@ -0,0 +1,264 @@ +package grpcdatasource + +import ( + "context" + "encoding/base64" + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "testing" + + "github.com/stretchr/testify/require" + "google.golang.org/grpc/metadata" + "google.golang.org/protobuf/encoding/protojson" + "google.golang.org/protobuf/proto" + protoref "google.golang.org/protobuf/reflect/protoreflect" + "google.golang.org/protobuf/types/dynamicpb" + + "github.com/wundergraph/graphql-go-tools/v2/pkg/grpctest" +) + +func newTestCompiler(t *testing.T) *RPCCompiler { + t.Helper() + compiler, err := NewProtoCompiler(grpctest.MustProtoSchema(t), testMapping()) + require.NoError(t, err) + return compiler +} + +func findMessageDesc(t *testing.T, compiler *RPCCompiler, fullName string) protoref.MessageDescriptor { + t.Helper() + for _, m := range compiler.doc.Messages { + if string(m.Desc.FullName()) == fullName { + return m.Desc + } + } + t.Fatalf("message %q not found in proto document", fullName) + return nil +} + +func TestConnectTransport_Invoke_Protobuf(t *testing.T) { + compiler := newTestCompiler(t) + + reqDesc := findMessageDesc(t, compiler, "productv1.QueryCategoryRequest") + respDesc := findMessageDesc(t, compiler, "productv1.QueryCategoryResponse") + categoryDesc := findMessageDesc(t, compiler, "productv1.Category") + + // Build a response message. + respMsg := dynamicpb.NewMessage(respDesc) + categoryMsg := dynamicpb.NewMessage(categoryDesc) + categoryMsg.Set(categoryDesc.Fields().ByName("id"), protoref.ValueOfString("cat-123")) + categoryMsg.Set(categoryDesc.Fields().ByName("name"), protoref.ValueOfString("Electronics")) + respMsg.Set(respDesc.Fields().ByName("category"), protoref.ValueOfMessage(categoryMsg)) + + respBytes, err := proto.Marshal(respMsg) + require.NoError(t, err) + + var receivedContentType string + var receivedProtocolVersion string + var receivedBody []byte + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + receivedContentType = r.Header.Get("Content-Type") + receivedProtocolVersion = r.Header.Get("Connect-Protocol-Version") + receivedBody, _ = io.ReadAll(r.Body) + w.Header().Set("Content-Type", "application/proto") + w.WriteHeader(http.StatusOK) + _, _ = w.Write(respBytes) + })) + defer server.Close() + + transport := NewConnectTransport(ConnectTransportConfig{ + BaseURL: server.URL, + Encoding: ConnectEncodingProtobuf, + }) + + inputMsg := dynamicpb.NewMessage(reqDesc) + inputMsg.Set(reqDesc.Fields().ByName("id"), protoref.ValueOfString("cat-123")) + + outputMsg := dynamicpb.NewMessage(respDesc) + + err = transport.Invoke(context.Background(), "/productv1.ProductService/QueryCategory", inputMsg, outputMsg) + require.NoError(t, err) + + require.Equal(t, "application/proto", receivedContentType) + require.Equal(t, "1", receivedProtocolVersion) + require.NotEmpty(t, receivedBody) + + outputJSON, err := protojson.Marshal(outputMsg) + require.NoError(t, err) + require.Contains(t, string(outputJSON), "cat-123") + require.Contains(t, string(outputJSON), "Electronics") +} + +func TestConnectTransport_Invoke_JSON(t *testing.T) { + compiler := newTestCompiler(t) + + reqDesc := findMessageDesc(t, compiler, "productv1.QueryCategoryRequest") + respDesc := findMessageDesc(t, compiler, "productv1.QueryCategoryResponse") + + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + require.Equal(t, "application/json", r.Header.Get("Content-Type")) + + body, _ := io.ReadAll(r.Body) + require.True(t, json.Valid(body), "request body should be valid JSON: %s", string(body)) + + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte(`{"category":{"id":"cat-456","name":"Books"}}`)) + })) + defer server.Close() + + transport := NewConnectTransport(ConnectTransportConfig{ + BaseURL: server.URL, + Encoding: ConnectEncodingJSON, + }) + + inputMsg := dynamicpb.NewMessage(reqDesc) + inputMsg.Set(reqDesc.Fields().ByName("id"), protoref.ValueOfString("cat-456")) + + outputMsg := dynamicpb.NewMessage(respDesc) + + err := transport.Invoke(context.Background(), "/productv1.ProductService/QueryCategory", inputMsg, outputMsg) + require.NoError(t, err) + + outputJSON, err := protojson.Marshal(outputMsg) + require.NoError(t, err) + require.Contains(t, string(outputJSON), "cat-456") + require.Contains(t, string(outputJSON), "Books") +} + +func TestConnectTransport_Invoke_ConnectError(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusNotFound) + _, _ = w.Write([]byte(`{"code":"not_found","message":"category not found"}`)) + })) + defer server.Close() + + transport := NewConnectTransport(ConnectTransportConfig{ + BaseURL: server.URL, + Encoding: ConnectEncodingProtobuf, + }) + + compiler := newTestCompiler(t) + reqDesc := findMessageDesc(t, compiler, "productv1.QueryCategoryRequest") + respDesc := findMessageDesc(t, compiler, "productv1.QueryCategoryResponse") + + inputMsg := dynamicpb.NewMessage(reqDesc) + outputMsg := dynamicpb.NewMessage(respDesc) + + err := transport.Invoke(context.Background(), "/productv1.ProductService/QueryCategory", inputMsg, outputMsg) + require.Error(t, err) + require.Contains(t, err.Error(), "not_found") + require.Contains(t, err.Error(), "category not found") +} + +func TestConnectTransport_Invoke_NonJSONError(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "text/html") + w.WriteHeader(http.StatusBadGateway) + _, _ = w.Write([]byte("Bad Gateway")) + })) + defer server.Close() + + transport := NewConnectTransport(ConnectTransportConfig{ + BaseURL: server.URL, + Encoding: ConnectEncodingProtobuf, + }) + + compiler := newTestCompiler(t) + reqDesc := findMessageDesc(t, compiler, "productv1.QueryCategoryRequest") + respDesc := findMessageDesc(t, compiler, "productv1.QueryCategoryResponse") + + inputMsg := dynamicpb.NewMessage(reqDesc) + outputMsg := dynamicpb.NewMessage(respDesc) + + err := transport.Invoke(context.Background(), "/productv1.ProductService/QueryCategory", inputMsg, outputMsg) + require.Error(t, err) + require.Contains(t, err.Error(), "HTTP 502") +} + +func TestConnectTransport_Invoke_HeaderForwarding(t *testing.T) { + var receivedHeaders http.Header + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + receivedHeaders = r.Header.Clone() + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte{}) + })) + defer server.Close() + + transport := NewConnectTransport(ConnectTransportConfig{ + BaseURL: server.URL, + Encoding: ConnectEncodingProtobuf, + }) + + compiler := newTestCompiler(t) + reqDesc := findMessageDesc(t, compiler, "productv1.QueryCategoryRequest") + respDesc := findMessageDesc(t, compiler, "productv1.QueryCategoryResponse") + + inputMsg := dynamicpb.NewMessage(reqDesc) + outputMsg := dynamicpb.NewMessage(respDesc) + + ctx := metadata.AppendToOutgoingContext(context.Background(), + "authorization", "Bearer test-token", + "x-custom-header", "custom-value", + ) + + err := transport.Invoke(ctx, "/productv1.ProductService/QueryCategory", inputMsg, outputMsg) + require.NoError(t, err) + + require.Equal(t, "Bearer test-token", receivedHeaders.Get("Authorization")) + require.Equal(t, "custom-value", receivedHeaders.Get("X-Custom-Header")) +} + +func TestConnectTransport_Invoke_BinaryHeaderForwarding(t *testing.T) { + var receivedHeaders http.Header + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + receivedHeaders = r.Header.Clone() + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte{}) + })) + defer server.Close() + + transport := NewConnectTransport(ConnectTransportConfig{ + BaseURL: server.URL, + Encoding: ConnectEncodingProtobuf, + }) + + compiler := newTestCompiler(t) + reqDesc := findMessageDesc(t, compiler, "productv1.QueryCategoryRequest") + respDesc := findMessageDesc(t, compiler, "productv1.QueryCategoryResponse") + + inputMsg := dynamicpb.NewMessage(reqDesc) + outputMsg := dynamicpb.NewMessage(respDesc) + + binaryValue := "\x00\x01\x02\x03" + ctx := metadata.AppendToOutgoingContext(context.Background(), + "x-trace-id-bin", binaryValue, + "authorization", "Bearer token", + ) + + err := transport.Invoke(ctx, "/productv1.ProductService/QueryCategory", inputMsg, outputMsg) + require.NoError(t, err) + + // Binary header must be base64-encoded per the Connect protocol spec. + require.Equal(t, base64.StdEncoding.EncodeToString([]byte(binaryValue)), receivedHeaders.Get("X-Trace-Id-Bin")) + // String header must be forwarded as-is. + require.Equal(t, "Bearer token", receivedHeaders.Get("Authorization")) +} + +func TestGRPCTransport_Invoke(t *testing.T) { + // Use the existing mockInterface from grpc_datasource_test.go. + mi := mockInterface{} + transport := NewGRPCTransport(mi) + + compiler := newTestCompiler(t) + reqDesc := findMessageDesc(t, compiler, "productv1.QueryComplexFilterTypeRequest") + respDesc := findMessageDesc(t, compiler, "productv1.QueryComplexFilterTypeResponse") + + inputMsg := dynamicpb.NewMessage(reqDesc) + outputMsg := dynamicpb.NewMessage(respDesc) + + err := transport.Invoke(context.Background(), "/productv1.ProductService/QueryComplexFilterType", inputMsg, outputMsg) + require.NoError(t, err) +} diff --git a/v2/pkg/grpctest/Makefile b/v2/pkg/grpctest/Makefile index bb8fd892b4..e83b19730a 100644 --- a/v2/pkg/grpctest/Makefile +++ b/v2/pkg/grpctest/Makefile @@ -5,12 +5,17 @@ grpc_datasource_dir := $(mkfile_dir)/../engine/datasource/grpc_datasource install-protoc: go install google.golang.org/protobuf/cmd/protoc-gen-go@latest go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest - + go install connectrpc.com/connect/cmd/protoc-gen-connect-go@latest + +# generate-proto regenerates the Go code for product.proto via buf. +# This drives three plugins: protoc-gen-go (messages), protoc-gen-go-grpc +# (gRPC server/client), and protoc-gen-connect-go (Connect handler/client). +# The Connect handler accepts gRPC, gRPC-Web, and Connect over the same HTTP +# endpoint, so the mock service can be exercised over either transport from +# tests. See buf.gen.yaml for the plugin configuration. .PHONY: generate-proto generate-proto: install-protoc - protoc --go_out=productv1 --go_opt=paths=source_relative \ - --go-grpc_out=productv1 --go-grpc_opt=paths=source_relative \ - product.proto + buf generate .PHONY: build-plugin build-plugin: diff --git a/v2/pkg/grpctest/buf.gen.yaml b/v2/pkg/grpctest/buf.gen.yaml new file mode 100644 index 0000000000..f06b9e0473 --- /dev/null +++ b/v2/pkg/grpctest/buf.gen.yaml @@ -0,0 +1,30 @@ +version: v2 +# product.proto declares `option go_package = "cosmo/pkg/proto/productv1;productv1"`, +# which is the import path used by the cosmo demo subgraphs. For the +# graphql-go-tools test harness we live at a different module path, so we +# remap the import via the M= option for every code generator. +plugins: + # Generate the message structs and gRPC server/client. + # These outputs are kept in sync with the existing protoc-based pipeline: + # `productv1/product.pb.go` and `productv1/product_grpc.pb.go`. + - local: protoc-gen-go + out: productv1 + opt: + - paths=source_relative + - Mproduct.proto=github.com/wundergraph/graphql-go-tools/v2/pkg/grpctest/productv1 + - local: protoc-gen-go-grpc + out: productv1 + opt: + - paths=source_relative + - Mproduct.proto=github.com/wundergraph/graphql-go-tools/v2/pkg/grpctest/productv1 + # Generate ConnectRPC handlers/clients alongside the gRPC code so that the + # mock service can serve both transports from the same Go package. + - local: protoc-gen-connect-go + out: productv1 + opt: + - paths=source_relative + - Mproduct.proto=github.com/wundergraph/graphql-go-tools/v2/pkg/grpctest/productv1 +inputs: + - directory: . + paths: + - product.proto diff --git a/v2/pkg/grpctest/buf.yaml b/v2/pkg/grpctest/buf.yaml new file mode 100644 index 0000000000..427c848f60 --- /dev/null +++ b/v2/pkg/grpctest/buf.yaml @@ -0,0 +1,15 @@ +version: v2 +modules: + - path: . +deps: + - buf.build/googleapis/googleapis +breaking: + use: + - FILE +lint: + use: + - DEFAULT + except: + - PACKAGE_VERSION_SUFFIX + - DIRECTORY_SAME_PACKAGE + - FILE_LOWER_SNAKE_CASE diff --git a/v2/pkg/grpctest/mockservice_connect.go b/v2/pkg/grpctest/mockservice_connect.go new file mode 100644 index 0000000000..0130f417a3 --- /dev/null +++ b/v2/pkg/grpctest/mockservice_connect.go @@ -0,0 +1,876 @@ +// Code generated by scripts/gen_connect_adapter.py. DO NOT EDIT. +// Regenerate after changing MockService method signatures. + +package grpctest + +import ( + "context" + + "connectrpc.com/connect" + + "github.com/wundergraph/graphql-go-tools/v2/pkg/grpctest/productv1" + "github.com/wundergraph/graphql-go-tools/v2/pkg/grpctest/productv1/productv1connect" +) + +// MockServiceConnect adapts the gRPC MockService onto the ConnectRPC +// handler interface emitted by protoc-gen-connect-go. The same backing +// implementation can therefore serve Connect, gRPC, and gRPC-Web from a +// single HTTP handler, which lets the grpc_datasource tests exercise the +// data source against either transport without duplicating fixtures. +type MockServiceConnect struct { + productv1connect.UnimplementedProductServiceHandler + inner *MockService +} + +// NewMockServiceConnect wraps the supplied MockService. +func NewMockServiceConnect(inner *MockService) *MockServiceConnect { + return &MockServiceConnect{inner: inner} +} + +var _ productv1connect.ProductServiceHandler = (*MockServiceConnect)(nil) + +// LookupProductById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) LookupProductById(ctx context.Context, req *connect.Request[productv1.LookupProductByIdRequest]) (*connect.Response[productv1.LookupProductByIdResponse], error) { + resp, err := s.inner.LookupProductById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// LookupStorageById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) LookupStorageById(ctx context.Context, req *connect.Request[productv1.LookupStorageByIdRequest]) (*connect.Response[productv1.LookupStorageByIdResponse], error) { + resp, err := s.inner.LookupStorageById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// LookupWarehouseById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) LookupWarehouseById(ctx context.Context, req *connect.Request[productv1.LookupWarehouseByIdRequest]) (*connect.Response[productv1.LookupWarehouseByIdResponse], error) { + resp, err := s.inner.LookupWarehouseById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// MutationBulkCreateAuthors forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) MutationBulkCreateAuthors(ctx context.Context, req *connect.Request[productv1.MutationBulkCreateAuthorsRequest]) (*connect.Response[productv1.MutationBulkCreateAuthorsResponse], error) { + resp, err := s.inner.MutationBulkCreateAuthors(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// MutationBulkCreateBlogPosts forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) MutationBulkCreateBlogPosts(ctx context.Context, req *connect.Request[productv1.MutationBulkCreateBlogPostsRequest]) (*connect.Response[productv1.MutationBulkCreateBlogPostsResponse], error) { + resp, err := s.inner.MutationBulkCreateBlogPosts(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// MutationBulkUpdateAuthors forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) MutationBulkUpdateAuthors(ctx context.Context, req *connect.Request[productv1.MutationBulkUpdateAuthorsRequest]) (*connect.Response[productv1.MutationBulkUpdateAuthorsResponse], error) { + resp, err := s.inner.MutationBulkUpdateAuthors(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// MutationBulkUpdateBlogPosts forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) MutationBulkUpdateBlogPosts(ctx context.Context, req *connect.Request[productv1.MutationBulkUpdateBlogPostsRequest]) (*connect.Response[productv1.MutationBulkUpdateBlogPostsResponse], error) { + resp, err := s.inner.MutationBulkUpdateBlogPosts(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// MutationCreateAuthor forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) MutationCreateAuthor(ctx context.Context, req *connect.Request[productv1.MutationCreateAuthorRequest]) (*connect.Response[productv1.MutationCreateAuthorResponse], error) { + resp, err := s.inner.MutationCreateAuthor(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// MutationCreateBlogPost forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) MutationCreateBlogPost(ctx context.Context, req *connect.Request[productv1.MutationCreateBlogPostRequest]) (*connect.Response[productv1.MutationCreateBlogPostResponse], error) { + resp, err := s.inner.MutationCreateBlogPost(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// MutationCreateNullableFieldsType forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) MutationCreateNullableFieldsType(ctx context.Context, req *connect.Request[productv1.MutationCreateNullableFieldsTypeRequest]) (*connect.Response[productv1.MutationCreateNullableFieldsTypeResponse], error) { + resp, err := s.inner.MutationCreateNullableFieldsType(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// MutationCreateUser forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) MutationCreateUser(ctx context.Context, req *connect.Request[productv1.MutationCreateUserRequest]) (*connect.Response[productv1.MutationCreateUserResponse], error) { + resp, err := s.inner.MutationCreateUser(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// MutationPerformAction forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) MutationPerformAction(ctx context.Context, req *connect.Request[productv1.MutationPerformActionRequest]) (*connect.Response[productv1.MutationPerformActionResponse], error) { + resp, err := s.inner.MutationPerformAction(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// MutationUpdateAuthor forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) MutationUpdateAuthor(ctx context.Context, req *connect.Request[productv1.MutationUpdateAuthorRequest]) (*connect.Response[productv1.MutationUpdateAuthorResponse], error) { + resp, err := s.inner.MutationUpdateAuthor(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// MutationUpdateBlogPost forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) MutationUpdateBlogPost(ctx context.Context, req *connect.Request[productv1.MutationUpdateBlogPostRequest]) (*connect.Response[productv1.MutationUpdateBlogPostResponse], error) { + resp, err := s.inner.MutationUpdateBlogPost(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// MutationUpdateNullableFieldsType forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) MutationUpdateNullableFieldsType(ctx context.Context, req *connect.Request[productv1.MutationUpdateNullableFieldsTypeRequest]) (*connect.Response[productv1.MutationUpdateNullableFieldsTypeResponse], error) { + resp, err := s.inner.MutationUpdateNullableFieldsType(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryAllAuthors forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryAllAuthors(ctx context.Context, req *connect.Request[productv1.QueryAllAuthorsRequest]) (*connect.Response[productv1.QueryAllAuthorsResponse], error) { + resp, err := s.inner.QueryAllAuthors(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryAllBlogPosts forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryAllBlogPosts(ctx context.Context, req *connect.Request[productv1.QueryAllBlogPostsRequest]) (*connect.Response[productv1.QueryAllBlogPostsResponse], error) { + resp, err := s.inner.QueryAllBlogPosts(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryAllNullableFieldsTypes forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryAllNullableFieldsTypes(ctx context.Context, req *connect.Request[productv1.QueryAllNullableFieldsTypesRequest]) (*connect.Response[productv1.QueryAllNullableFieldsTypesResponse], error) { + resp, err := s.inner.QueryAllNullableFieldsTypes(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryAllPets forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryAllPets(ctx context.Context, req *connect.Request[productv1.QueryAllPetsRequest]) (*connect.Response[productv1.QueryAllPetsResponse], error) { + resp, err := s.inner.QueryAllPets(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryAuthor forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryAuthor(ctx context.Context, req *connect.Request[productv1.QueryAuthorRequest]) (*connect.Response[productv1.QueryAuthorResponse], error) { + resp, err := s.inner.QueryAuthor(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryAuthorById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryAuthorById(ctx context.Context, req *connect.Request[productv1.QueryAuthorByIdRequest]) (*connect.Response[productv1.QueryAuthorByIdResponse], error) { + resp, err := s.inner.QueryAuthorById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryAuthorsWithFilter forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryAuthorsWithFilter(ctx context.Context, req *connect.Request[productv1.QueryAuthorsWithFilterRequest]) (*connect.Response[productv1.QueryAuthorsWithFilterResponse], error) { + resp, err := s.inner.QueryAuthorsWithFilter(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryBlogPost forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryBlogPost(ctx context.Context, req *connect.Request[productv1.QueryBlogPostRequest]) (*connect.Response[productv1.QueryBlogPostResponse], error) { + resp, err := s.inner.QueryBlogPost(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryBlogPostById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryBlogPostById(ctx context.Context, req *connect.Request[productv1.QueryBlogPostByIdRequest]) (*connect.Response[productv1.QueryBlogPostByIdResponse], error) { + resp, err := s.inner.QueryBlogPostById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryBlogPostsWithFilter forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryBlogPostsWithFilter(ctx context.Context, req *connect.Request[productv1.QueryBlogPostsWithFilterRequest]) (*connect.Response[productv1.QueryBlogPostsWithFilterResponse], error) { + resp, err := s.inner.QueryBlogPostsWithFilter(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryBulkSearchAuthors forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryBulkSearchAuthors(ctx context.Context, req *connect.Request[productv1.QueryBulkSearchAuthorsRequest]) (*connect.Response[productv1.QueryBulkSearchAuthorsResponse], error) { + resp, err := s.inner.QueryBulkSearchAuthors(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryBulkSearchBlogPosts forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryBulkSearchBlogPosts(ctx context.Context, req *connect.Request[productv1.QueryBulkSearchBlogPostsRequest]) (*connect.Response[productv1.QueryBulkSearchBlogPostsResponse], error) { + resp, err := s.inner.QueryBulkSearchBlogPosts(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryCalculateTotals forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryCalculateTotals(ctx context.Context, req *connect.Request[productv1.QueryCalculateTotalsRequest]) (*connect.Response[productv1.QueryCalculateTotalsResponse], error) { + resp, err := s.inner.QueryCalculateTotals(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryCategories forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryCategories(ctx context.Context, req *connect.Request[productv1.QueryCategoriesRequest]) (*connect.Response[productv1.QueryCategoriesResponse], error) { + resp, err := s.inner.QueryCategories(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryCategoriesByKind forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryCategoriesByKind(ctx context.Context, req *connect.Request[productv1.QueryCategoriesByKindRequest]) (*connect.Response[productv1.QueryCategoriesByKindResponse], error) { + resp, err := s.inner.QueryCategoriesByKind(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryCategoriesByKinds forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryCategoriesByKinds(ctx context.Context, req *connect.Request[productv1.QueryCategoriesByKindsRequest]) (*connect.Response[productv1.QueryCategoriesByKindsResponse], error) { + resp, err := s.inner.QueryCategoriesByKinds(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryCategory forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryCategory(ctx context.Context, req *connect.Request[productv1.QueryCategoryRequest]) (*connect.Response[productv1.QueryCategoryResponse], error) { + resp, err := s.inner.QueryCategory(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryComplexFilterType forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryComplexFilterType(ctx context.Context, req *connect.Request[productv1.QueryComplexFilterTypeRequest]) (*connect.Response[productv1.QueryComplexFilterTypeResponse], error) { + resp, err := s.inner.QueryComplexFilterType(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryConditionalSearch forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryConditionalSearch(ctx context.Context, req *connect.Request[productv1.QueryConditionalSearchRequest]) (*connect.Response[productv1.QueryConditionalSearchResponse], error) { + resp, err := s.inner.QueryConditionalSearch(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryFilterCategories forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryFilterCategories(ctx context.Context, req *connect.Request[productv1.QueryFilterCategoriesRequest]) (*connect.Response[productv1.QueryFilterCategoriesResponse], error) { + resp, err := s.inner.QueryFilterCategories(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryNestedType forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryNestedType(ctx context.Context, req *connect.Request[productv1.QueryNestedTypeRequest]) (*connect.Response[productv1.QueryNestedTypeResponse], error) { + resp, err := s.inner.QueryNestedType(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryNullableFieldsType forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryNullableFieldsType(ctx context.Context, req *connect.Request[productv1.QueryNullableFieldsTypeRequest]) (*connect.Response[productv1.QueryNullableFieldsTypeResponse], error) { + resp, err := s.inner.QueryNullableFieldsType(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryNullableFieldsTypeById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryNullableFieldsTypeById(ctx context.Context, req *connect.Request[productv1.QueryNullableFieldsTypeByIdRequest]) (*connect.Response[productv1.QueryNullableFieldsTypeByIdResponse], error) { + resp, err := s.inner.QueryNullableFieldsTypeById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryNullableFieldsTypeWithFilter forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryNullableFieldsTypeWithFilter(ctx context.Context, req *connect.Request[productv1.QueryNullableFieldsTypeWithFilterRequest]) (*connect.Response[productv1.QueryNullableFieldsTypeWithFilterResponse], error) { + resp, err := s.inner.QueryNullableFieldsTypeWithFilter(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryRandomPet forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryRandomPet(ctx context.Context, req *connect.Request[productv1.QueryRandomPetRequest]) (*connect.Response[productv1.QueryRandomPetResponse], error) { + resp, err := s.inner.QueryRandomPet(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryRandomSearchResult forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryRandomSearchResult(ctx context.Context, req *connect.Request[productv1.QueryRandomSearchResultRequest]) (*connect.Response[productv1.QueryRandomSearchResultResponse], error) { + resp, err := s.inner.QueryRandomSearchResult(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryRecursiveType forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryRecursiveType(ctx context.Context, req *connect.Request[productv1.QueryRecursiveTypeRequest]) (*connect.Response[productv1.QueryRecursiveTypeResponse], error) { + resp, err := s.inner.QueryRecursiveType(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QuerySearch forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QuerySearch(ctx context.Context, req *connect.Request[productv1.QuerySearchRequest]) (*connect.Response[productv1.QuerySearchResponse], error) { + resp, err := s.inner.QuerySearch(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryTestContainer forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryTestContainer(ctx context.Context, req *connect.Request[productv1.QueryTestContainerRequest]) (*connect.Response[productv1.QueryTestContainerResponse], error) { + resp, err := s.inner.QueryTestContainer(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryTestContainers forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryTestContainers(ctx context.Context, req *connect.Request[productv1.QueryTestContainersRequest]) (*connect.Response[productv1.QueryTestContainersResponse], error) { + resp, err := s.inner.QueryTestContainers(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryTypeFilterWithArguments forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryTypeFilterWithArguments(ctx context.Context, req *connect.Request[productv1.QueryTypeFilterWithArgumentsRequest]) (*connect.Response[productv1.QueryTypeFilterWithArgumentsResponse], error) { + resp, err := s.inner.QueryTypeFilterWithArguments(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryTypeWithMultipleFilterFields forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryTypeWithMultipleFilterFields(ctx context.Context, req *connect.Request[productv1.QueryTypeWithMultipleFilterFieldsRequest]) (*connect.Response[productv1.QueryTypeWithMultipleFilterFieldsResponse], error) { + resp, err := s.inner.QueryTypeWithMultipleFilterFields(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryUser forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryUser(ctx context.Context, req *connect.Request[productv1.QueryUserRequest]) (*connect.Response[productv1.QueryUserResponse], error) { + resp, err := s.inner.QueryUser(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// QueryUsers forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) QueryUsers(ctx context.Context, req *connect.Request[productv1.QueryUsersRequest]) (*connect.Response[productv1.QueryUsersResponse], error) { + resp, err := s.inner.QueryUsers(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageCategoryInfoSummaryById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageCategoryInfoSummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageCategoryInfoSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageCategoryInfoSummaryByIdResponse], error) { + resp, err := s.inner.RequireStorageCategoryInfoSummaryById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageDeepItemInfoById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageDeepItemInfoById(ctx context.Context, req *connect.Request[productv1.RequireStorageDeepItemInfoByIdRequest]) (*connect.Response[productv1.RequireStorageDeepItemInfoByIdResponse], error) { + resp, err := s.inner.RequireStorageDeepItemInfoById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageFilteredTagSummaryById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageFilteredTagSummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageFilteredTagSummaryByIdResponse], error) { + resp, err := s.inner.RequireStorageFilteredTagSummaryById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageItemHandlerInfoById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageItemHandlerInfoById(ctx context.Context, req *connect.Request[productv1.RequireStorageItemHandlerInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemHandlerInfoByIdResponse], error) { + resp, err := s.inner.RequireStorageItemHandlerInfoById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageItemInfoById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageItemInfoById(ctx context.Context, req *connect.Request[productv1.RequireStorageItemInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemInfoByIdResponse], error) { + resp, err := s.inner.RequireStorageItemInfoById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageItemSpecsInfoById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageItemSpecsInfoById(ctx context.Context, req *connect.Request[productv1.RequireStorageItemSpecsInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemSpecsInfoByIdResponse], error) { + resp, err := s.inner.RequireStorageItemSpecsInfoById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageKindSummaryById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageKindSummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageKindSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageKindSummaryByIdResponse], error) { + resp, err := s.inner.RequireStorageKindSummaryById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageMetadataScoreById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageMetadataScoreById(ctx context.Context, req *connect.Request[productv1.RequireStorageMetadataScoreByIdRequest]) (*connect.Response[productv1.RequireStorageMetadataScoreByIdResponse], error) { + resp, err := s.inner.RequireStorageMetadataScoreById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageMultiFilteredTagSummaryById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageMultiFilteredTagSummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageMultiFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageMultiFilteredTagSummaryByIdResponse], error) { + resp, err := s.inner.RequireStorageMultiFilteredTagSummaryById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageNullableFilteredTagSummaryById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageNullableFilteredTagSummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageNullableFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageNullableFilteredTagSummaryByIdResponse], error) { + resp, err := s.inner.RequireStorageNullableFilteredTagSummaryById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageOperationReportById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageOperationReportById(ctx context.Context, req *connect.Request[productv1.RequireStorageOperationReportByIdRequest]) (*connect.Response[productv1.RequireStorageOperationReportByIdResponse], error) { + resp, err := s.inner.RequireStorageOperationReportById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageOptionalProcessedMetadataById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageOptionalProcessedMetadataById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataByIdResponse], error) { + resp, err := s.inner.RequireStorageOptionalProcessedMetadataById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageOptionalProcessedTagsById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageOptionalProcessedTagsById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedTagsByIdResponse], error) { + resp, err := s.inner.RequireStorageOptionalProcessedTagsById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageOptionalTagSummaryById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageOptionalTagSummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalTagSummaryByIdResponse], error) { + resp, err := s.inner.RequireStorageOptionalTagSummaryById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageProcessedMetadataById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageProcessedMetadataById(ctx context.Context, req *connect.Request[productv1.RequireStorageProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedMetadataByIdResponse], error) { + resp, err := s.inner.RequireStorageProcessedMetadataById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageProcessedMetadataHistoryById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageProcessedMetadataHistoryById(ctx context.Context, req *connect.Request[productv1.RequireStorageProcessedMetadataHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedMetadataHistoryByIdResponse], error) { + resp, err := s.inner.RequireStorageProcessedMetadataHistoryById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageProcessedTagsById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageProcessedTagsById(ctx context.Context, req *connect.Request[productv1.RequireStorageProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedTagsByIdResponse], error) { + resp, err := s.inner.RequireStorageProcessedTagsById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageSecuritySummaryById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageSecuritySummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageSecuritySummaryByIdRequest]) (*connect.Response[productv1.RequireStorageSecuritySummaryByIdResponse], error) { + resp, err := s.inner.RequireStorageSecuritySummaryById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageStockHealthScoreById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageStockHealthScoreById(ctx context.Context, req *connect.Request[productv1.RequireStorageStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireStorageStockHealthScoreByIdResponse], error) { + resp, err := s.inner.RequireStorageStockHealthScoreById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireStorageTagSummaryById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireStorageTagSummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageTagSummaryByIdResponse], error) { + resp, err := s.inner.RequireStorageTagSummaryById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// RequireWarehouseStockHealthScoreById forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) RequireWarehouseStockHealthScoreById(ctx context.Context, req *connect.Request[productv1.RequireWarehouseStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireWarehouseStockHealthScoreByIdResponse], error) { + resp, err := s.inner.RequireWarehouseStockHealthScoreById(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveCategoryActiveSubcategories forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveCategoryActiveSubcategories(ctx context.Context, req *connect.Request[productv1.ResolveCategoryActiveSubcategoriesRequest]) (*connect.Response[productv1.ResolveCategoryActiveSubcategoriesResponse], error) { + resp, err := s.inner.ResolveCategoryActiveSubcategories(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveCategoryCategoryMetrics forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveCategoryCategoryMetrics(ctx context.Context, req *connect.Request[productv1.ResolveCategoryCategoryMetricsRequest]) (*connect.Response[productv1.ResolveCategoryCategoryMetricsResponse], error) { + resp, err := s.inner.ResolveCategoryCategoryMetrics(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveCategoryCategoryStatus forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveCategoryCategoryStatus(ctx context.Context, req *connect.Request[productv1.ResolveCategoryCategoryStatusRequest]) (*connect.Response[productv1.ResolveCategoryCategoryStatusResponse], error) { + resp, err := s.inner.ResolveCategoryCategoryStatus(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveCategoryChildCategories forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveCategoryChildCategories(ctx context.Context, req *connect.Request[productv1.ResolveCategoryChildCategoriesRequest]) (*connect.Response[productv1.ResolveCategoryChildCategoriesResponse], error) { + resp, err := s.inner.ResolveCategoryChildCategories(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveCategoryMascot forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveCategoryMascot(ctx context.Context, req *connect.Request[productv1.ResolveCategoryMascotRequest]) (*connect.Response[productv1.ResolveCategoryMascotResponse], error) { + resp, err := s.inner.ResolveCategoryMascot(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveCategoryMetricsAverageScore forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveCategoryMetricsAverageScore(ctx context.Context, req *connect.Request[productv1.ResolveCategoryMetricsAverageScoreRequest]) (*connect.Response[productv1.ResolveCategoryMetricsAverageScoreResponse], error) { + resp, err := s.inner.ResolveCategoryMetricsAverageScore(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveCategoryMetricsNormalizedScore forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveCategoryMetricsNormalizedScore(ctx context.Context, req *connect.Request[productv1.ResolveCategoryMetricsNormalizedScoreRequest]) (*connect.Response[productv1.ResolveCategoryMetricsNormalizedScoreResponse], error) { + resp, err := s.inner.ResolveCategoryMetricsNormalizedScore(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveCategoryMetricsRelatedCategory forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveCategoryMetricsRelatedCategory(ctx context.Context, req *connect.Request[productv1.ResolveCategoryMetricsRelatedCategoryRequest]) (*connect.Response[productv1.ResolveCategoryMetricsRelatedCategoryResponse], error) { + resp, err := s.inner.ResolveCategoryMetricsRelatedCategory(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveCategoryOptionalCategories forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveCategoryOptionalCategories(ctx context.Context, req *connect.Request[productv1.ResolveCategoryOptionalCategoriesRequest]) (*connect.Response[productv1.ResolveCategoryOptionalCategoriesResponse], error) { + resp, err := s.inner.ResolveCategoryOptionalCategories(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveCategoryPopularityScore forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveCategoryPopularityScore(ctx context.Context, req *connect.Request[productv1.ResolveCategoryPopularityScoreRequest]) (*connect.Response[productv1.ResolveCategoryPopularityScoreResponse], error) { + resp, err := s.inner.ResolveCategoryPopularityScore(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveCategoryProductCount forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveCategoryProductCount(ctx context.Context, req *connect.Request[productv1.ResolveCategoryProductCountRequest]) (*connect.Response[productv1.ResolveCategoryProductCountResponse], error) { + resp, err := s.inner.ResolveCategoryProductCount(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveCategoryTopSubcategory forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveCategoryTopSubcategory(ctx context.Context, req *connect.Request[productv1.ResolveCategoryTopSubcategoryRequest]) (*connect.Response[productv1.ResolveCategoryTopSubcategoryResponse], error) { + resp, err := s.inner.ResolveCategoryTopSubcategory(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveCategoryTotalProducts forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveCategoryTotalProducts(ctx context.Context, req *connect.Request[productv1.ResolveCategoryTotalProductsRequest]) (*connect.Response[productv1.ResolveCategoryTotalProductsResponse], error) { + resp, err := s.inner.ResolveCategoryTotalProducts(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveProductMascotRecommendation forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveProductMascotRecommendation(ctx context.Context, req *connect.Request[productv1.ResolveProductMascotRecommendationRequest]) (*connect.Response[productv1.ResolveProductMascotRecommendationResponse], error) { + resp, err := s.inner.ResolveProductMascotRecommendation(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveProductProductDetails forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveProductProductDetails(ctx context.Context, req *connect.Request[productv1.ResolveProductProductDetailsRequest]) (*connect.Response[productv1.ResolveProductProductDetailsResponse], error) { + resp, err := s.inner.ResolveProductProductDetails(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveProductRecommendedCategory forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveProductRecommendedCategory(ctx context.Context, req *connect.Request[productv1.ResolveProductRecommendedCategoryRequest]) (*connect.Response[productv1.ResolveProductRecommendedCategoryResponse], error) { + resp, err := s.inner.ResolveProductRecommendedCategory(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveProductShippingEstimate forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveProductShippingEstimate(ctx context.Context, req *connect.Request[productv1.ResolveProductShippingEstimateRequest]) (*connect.Response[productv1.ResolveProductShippingEstimateResponse], error) { + resp, err := s.inner.ResolveProductShippingEstimate(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveProductStockStatus forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveProductStockStatus(ctx context.Context, req *connect.Request[productv1.ResolveProductStockStatusRequest]) (*connect.Response[productv1.ResolveProductStockStatusResponse], error) { + resp, err := s.inner.ResolveProductStockStatus(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveStorageLinkedStorages forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveStorageLinkedStorages(ctx context.Context, req *connect.Request[productv1.ResolveStorageLinkedStoragesRequest]) (*connect.Response[productv1.ResolveStorageLinkedStoragesResponse], error) { + resp, err := s.inner.ResolveStorageLinkedStorages(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveStorageNearbyStorages forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveStorageNearbyStorages(ctx context.Context, req *connect.Request[productv1.ResolveStorageNearbyStoragesRequest]) (*connect.Response[productv1.ResolveStorageNearbyStoragesResponse], error) { + resp, err := s.inner.ResolveStorageNearbyStorages(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveStorageStorageStatus forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveStorageStorageStatus(ctx context.Context, req *connect.Request[productv1.ResolveStorageStorageStatusRequest]) (*connect.Response[productv1.ResolveStorageStorageStatusResponse], error) { + resp, err := s.inner.ResolveStorageStorageStatus(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveSubcategoryItemCount forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveSubcategoryItemCount(ctx context.Context, req *connect.Request[productv1.ResolveSubcategoryItemCountRequest]) (*connect.Response[productv1.ResolveSubcategoryItemCountResponse], error) { + resp, err := s.inner.ResolveSubcategoryItemCount(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveSubcategoryParentCategory forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveSubcategoryParentCategory(ctx context.Context, req *connect.Request[productv1.ResolveSubcategoryParentCategoryRequest]) (*connect.Response[productv1.ResolveSubcategoryParentCategoryResponse], error) { + resp, err := s.inner.ResolveSubcategoryParentCategory(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} + +// ResolveTestContainerDetails forwards the Connect call to the gRPC implementation. +func (s *MockServiceConnect) ResolveTestContainerDetails(ctx context.Context, req *connect.Request[productv1.ResolveTestContainerDetailsRequest]) (*connect.Response[productv1.ResolveTestContainerDetailsResponse], error) { + resp, err := s.inner.ResolveTestContainerDetails(ctx, req.Msg) + if err != nil { + return nil, err + } + return connect.NewResponse(resp), nil +} diff --git a/v2/pkg/grpctest/productv1/productv1connect/product.connect.go b/v2/pkg/grpctest/productv1/productv1connect/product.connect.go new file mode 100644 index 0000000000..752a267a30 --- /dev/null +++ b/v2/pkg/grpctest/productv1/productv1connect/product.connect.go @@ -0,0 +1,2865 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: product.proto + +package productv1connect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + productv1 "github.com/wundergraph/graphql-go-tools/v2/pkg/grpctest/productv1" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // ProductServiceName is the fully-qualified name of the ProductService service. + ProductServiceName = "productv1.ProductService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // ProductServiceLookupProductByIdProcedure is the fully-qualified name of the ProductService's + // LookupProductById RPC. + ProductServiceLookupProductByIdProcedure = "/productv1.ProductService/LookupProductById" + // ProductServiceLookupStorageByIdProcedure is the fully-qualified name of the ProductService's + // LookupStorageById RPC. + ProductServiceLookupStorageByIdProcedure = "/productv1.ProductService/LookupStorageById" + // ProductServiceLookupWarehouseByIdProcedure is the fully-qualified name of the ProductService's + // LookupWarehouseById RPC. + ProductServiceLookupWarehouseByIdProcedure = "/productv1.ProductService/LookupWarehouseById" + // ProductServiceMutationBulkCreateAuthorsProcedure is the fully-qualified name of the + // ProductService's MutationBulkCreateAuthors RPC. + ProductServiceMutationBulkCreateAuthorsProcedure = "/productv1.ProductService/MutationBulkCreateAuthors" + // ProductServiceMutationBulkCreateBlogPostsProcedure is the fully-qualified name of the + // ProductService's MutationBulkCreateBlogPosts RPC. + ProductServiceMutationBulkCreateBlogPostsProcedure = "/productv1.ProductService/MutationBulkCreateBlogPosts" + // ProductServiceMutationBulkUpdateAuthorsProcedure is the fully-qualified name of the + // ProductService's MutationBulkUpdateAuthors RPC. + ProductServiceMutationBulkUpdateAuthorsProcedure = "/productv1.ProductService/MutationBulkUpdateAuthors" + // ProductServiceMutationBulkUpdateBlogPostsProcedure is the fully-qualified name of the + // ProductService's MutationBulkUpdateBlogPosts RPC. + ProductServiceMutationBulkUpdateBlogPostsProcedure = "/productv1.ProductService/MutationBulkUpdateBlogPosts" + // ProductServiceMutationCreateAuthorProcedure is the fully-qualified name of the ProductService's + // MutationCreateAuthor RPC. + ProductServiceMutationCreateAuthorProcedure = "/productv1.ProductService/MutationCreateAuthor" + // ProductServiceMutationCreateBlogPostProcedure is the fully-qualified name of the ProductService's + // MutationCreateBlogPost RPC. + ProductServiceMutationCreateBlogPostProcedure = "/productv1.ProductService/MutationCreateBlogPost" + // ProductServiceMutationCreateNullableFieldsTypeProcedure is the fully-qualified name of the + // ProductService's MutationCreateNullableFieldsType RPC. + ProductServiceMutationCreateNullableFieldsTypeProcedure = "/productv1.ProductService/MutationCreateNullableFieldsType" + // ProductServiceMutationCreateUserProcedure is the fully-qualified name of the ProductService's + // MutationCreateUser RPC. + ProductServiceMutationCreateUserProcedure = "/productv1.ProductService/MutationCreateUser" + // ProductServiceMutationPerformActionProcedure is the fully-qualified name of the ProductService's + // MutationPerformAction RPC. + ProductServiceMutationPerformActionProcedure = "/productv1.ProductService/MutationPerformAction" + // ProductServiceMutationUpdateAuthorProcedure is the fully-qualified name of the ProductService's + // MutationUpdateAuthor RPC. + ProductServiceMutationUpdateAuthorProcedure = "/productv1.ProductService/MutationUpdateAuthor" + // ProductServiceMutationUpdateBlogPostProcedure is the fully-qualified name of the ProductService's + // MutationUpdateBlogPost RPC. + ProductServiceMutationUpdateBlogPostProcedure = "/productv1.ProductService/MutationUpdateBlogPost" + // ProductServiceMutationUpdateNullableFieldsTypeProcedure is the fully-qualified name of the + // ProductService's MutationUpdateNullableFieldsType RPC. + ProductServiceMutationUpdateNullableFieldsTypeProcedure = "/productv1.ProductService/MutationUpdateNullableFieldsType" + // ProductServiceQueryAllAuthorsProcedure is the fully-qualified name of the ProductService's + // QueryAllAuthors RPC. + ProductServiceQueryAllAuthorsProcedure = "/productv1.ProductService/QueryAllAuthors" + // ProductServiceQueryAllBlogPostsProcedure is the fully-qualified name of the ProductService's + // QueryAllBlogPosts RPC. + ProductServiceQueryAllBlogPostsProcedure = "/productv1.ProductService/QueryAllBlogPosts" + // ProductServiceQueryAllNullableFieldsTypesProcedure is the fully-qualified name of the + // ProductService's QueryAllNullableFieldsTypes RPC. + ProductServiceQueryAllNullableFieldsTypesProcedure = "/productv1.ProductService/QueryAllNullableFieldsTypes" + // ProductServiceQueryAllPetsProcedure is the fully-qualified name of the ProductService's + // QueryAllPets RPC. + ProductServiceQueryAllPetsProcedure = "/productv1.ProductService/QueryAllPets" + // ProductServiceQueryAuthorProcedure is the fully-qualified name of the ProductService's + // QueryAuthor RPC. + ProductServiceQueryAuthorProcedure = "/productv1.ProductService/QueryAuthor" + // ProductServiceQueryAuthorByIdProcedure is the fully-qualified name of the ProductService's + // QueryAuthorById RPC. + ProductServiceQueryAuthorByIdProcedure = "/productv1.ProductService/QueryAuthorById" + // ProductServiceQueryAuthorsWithFilterProcedure is the fully-qualified name of the ProductService's + // QueryAuthorsWithFilter RPC. + ProductServiceQueryAuthorsWithFilterProcedure = "/productv1.ProductService/QueryAuthorsWithFilter" + // ProductServiceQueryBlogPostProcedure is the fully-qualified name of the ProductService's + // QueryBlogPost RPC. + ProductServiceQueryBlogPostProcedure = "/productv1.ProductService/QueryBlogPost" + // ProductServiceQueryBlogPostByIdProcedure is the fully-qualified name of the ProductService's + // QueryBlogPostById RPC. + ProductServiceQueryBlogPostByIdProcedure = "/productv1.ProductService/QueryBlogPostById" + // ProductServiceQueryBlogPostsWithFilterProcedure is the fully-qualified name of the + // ProductService's QueryBlogPostsWithFilter RPC. + ProductServiceQueryBlogPostsWithFilterProcedure = "/productv1.ProductService/QueryBlogPostsWithFilter" + // ProductServiceQueryBulkSearchAuthorsProcedure is the fully-qualified name of the ProductService's + // QueryBulkSearchAuthors RPC. + ProductServiceQueryBulkSearchAuthorsProcedure = "/productv1.ProductService/QueryBulkSearchAuthors" + // ProductServiceQueryBulkSearchBlogPostsProcedure is the fully-qualified name of the + // ProductService's QueryBulkSearchBlogPosts RPC. + ProductServiceQueryBulkSearchBlogPostsProcedure = "/productv1.ProductService/QueryBulkSearchBlogPosts" + // ProductServiceQueryCalculateTotalsProcedure is the fully-qualified name of the ProductService's + // QueryCalculateTotals RPC. + ProductServiceQueryCalculateTotalsProcedure = "/productv1.ProductService/QueryCalculateTotals" + // ProductServiceQueryCategoriesProcedure is the fully-qualified name of the ProductService's + // QueryCategories RPC. + ProductServiceQueryCategoriesProcedure = "/productv1.ProductService/QueryCategories" + // ProductServiceQueryCategoriesByKindProcedure is the fully-qualified name of the ProductService's + // QueryCategoriesByKind RPC. + ProductServiceQueryCategoriesByKindProcedure = "/productv1.ProductService/QueryCategoriesByKind" + // ProductServiceQueryCategoriesByKindsProcedure is the fully-qualified name of the ProductService's + // QueryCategoriesByKinds RPC. + ProductServiceQueryCategoriesByKindsProcedure = "/productv1.ProductService/QueryCategoriesByKinds" + // ProductServiceQueryCategoryProcedure is the fully-qualified name of the ProductService's + // QueryCategory RPC. + ProductServiceQueryCategoryProcedure = "/productv1.ProductService/QueryCategory" + // ProductServiceQueryComplexFilterTypeProcedure is the fully-qualified name of the ProductService's + // QueryComplexFilterType RPC. + ProductServiceQueryComplexFilterTypeProcedure = "/productv1.ProductService/QueryComplexFilterType" + // ProductServiceQueryConditionalSearchProcedure is the fully-qualified name of the ProductService's + // QueryConditionalSearch RPC. + ProductServiceQueryConditionalSearchProcedure = "/productv1.ProductService/QueryConditionalSearch" + // ProductServiceQueryFilterCategoriesProcedure is the fully-qualified name of the ProductService's + // QueryFilterCategories RPC. + ProductServiceQueryFilterCategoriesProcedure = "/productv1.ProductService/QueryFilterCategories" + // ProductServiceQueryNestedTypeProcedure is the fully-qualified name of the ProductService's + // QueryNestedType RPC. + ProductServiceQueryNestedTypeProcedure = "/productv1.ProductService/QueryNestedType" + // ProductServiceQueryNullableFieldsTypeProcedure is the fully-qualified name of the + // ProductService's QueryNullableFieldsType RPC. + ProductServiceQueryNullableFieldsTypeProcedure = "/productv1.ProductService/QueryNullableFieldsType" + // ProductServiceQueryNullableFieldsTypeByIdProcedure is the fully-qualified name of the + // ProductService's QueryNullableFieldsTypeById RPC. + ProductServiceQueryNullableFieldsTypeByIdProcedure = "/productv1.ProductService/QueryNullableFieldsTypeById" + // ProductServiceQueryNullableFieldsTypeWithFilterProcedure is the fully-qualified name of the + // ProductService's QueryNullableFieldsTypeWithFilter RPC. + ProductServiceQueryNullableFieldsTypeWithFilterProcedure = "/productv1.ProductService/QueryNullableFieldsTypeWithFilter" + // ProductServiceQueryRandomPetProcedure is the fully-qualified name of the ProductService's + // QueryRandomPet RPC. + ProductServiceQueryRandomPetProcedure = "/productv1.ProductService/QueryRandomPet" + // ProductServiceQueryRandomSearchResultProcedure is the fully-qualified name of the + // ProductService's QueryRandomSearchResult RPC. + ProductServiceQueryRandomSearchResultProcedure = "/productv1.ProductService/QueryRandomSearchResult" + // ProductServiceQueryRecursiveTypeProcedure is the fully-qualified name of the ProductService's + // QueryRecursiveType RPC. + ProductServiceQueryRecursiveTypeProcedure = "/productv1.ProductService/QueryRecursiveType" + // ProductServiceQuerySearchProcedure is the fully-qualified name of the ProductService's + // QuerySearch RPC. + ProductServiceQuerySearchProcedure = "/productv1.ProductService/QuerySearch" + // ProductServiceQueryTestContainerProcedure is the fully-qualified name of the ProductService's + // QueryTestContainer RPC. + ProductServiceQueryTestContainerProcedure = "/productv1.ProductService/QueryTestContainer" + // ProductServiceQueryTestContainersProcedure is the fully-qualified name of the ProductService's + // QueryTestContainers RPC. + ProductServiceQueryTestContainersProcedure = "/productv1.ProductService/QueryTestContainers" + // ProductServiceQueryTypeFilterWithArgumentsProcedure is the fully-qualified name of the + // ProductService's QueryTypeFilterWithArguments RPC. + ProductServiceQueryTypeFilterWithArgumentsProcedure = "/productv1.ProductService/QueryTypeFilterWithArguments" + // ProductServiceQueryTypeWithMultipleFilterFieldsProcedure is the fully-qualified name of the + // ProductService's QueryTypeWithMultipleFilterFields RPC. + ProductServiceQueryTypeWithMultipleFilterFieldsProcedure = "/productv1.ProductService/QueryTypeWithMultipleFilterFields" + // ProductServiceQueryUserProcedure is the fully-qualified name of the ProductService's QueryUser + // RPC. + ProductServiceQueryUserProcedure = "/productv1.ProductService/QueryUser" + // ProductServiceQueryUsersProcedure is the fully-qualified name of the ProductService's QueryUsers + // RPC. + ProductServiceQueryUsersProcedure = "/productv1.ProductService/QueryUsers" + // ProductServiceRequireStorageCategoryInfoSummaryByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageCategoryInfoSummaryById RPC. + ProductServiceRequireStorageCategoryInfoSummaryByIdProcedure = "/productv1.ProductService/RequireStorageCategoryInfoSummaryById" + // ProductServiceRequireStorageDeepItemInfoByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageDeepItemInfoById RPC. + ProductServiceRequireStorageDeepItemInfoByIdProcedure = "/productv1.ProductService/RequireStorageDeepItemInfoById" + // ProductServiceRequireStorageFilteredTagSummaryByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageFilteredTagSummaryById RPC. + ProductServiceRequireStorageFilteredTagSummaryByIdProcedure = "/productv1.ProductService/RequireStorageFilteredTagSummaryById" + // ProductServiceRequireStorageItemHandlerInfoByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageItemHandlerInfoById RPC. + ProductServiceRequireStorageItemHandlerInfoByIdProcedure = "/productv1.ProductService/RequireStorageItemHandlerInfoById" + // ProductServiceRequireStorageItemInfoByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageItemInfoById RPC. + ProductServiceRequireStorageItemInfoByIdProcedure = "/productv1.ProductService/RequireStorageItemInfoById" + // ProductServiceRequireStorageItemSpecsInfoByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageItemSpecsInfoById RPC. + ProductServiceRequireStorageItemSpecsInfoByIdProcedure = "/productv1.ProductService/RequireStorageItemSpecsInfoById" + // ProductServiceRequireStorageKindSummaryByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageKindSummaryById RPC. + ProductServiceRequireStorageKindSummaryByIdProcedure = "/productv1.ProductService/RequireStorageKindSummaryById" + // ProductServiceRequireStorageMetadataScoreByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageMetadataScoreById RPC. + ProductServiceRequireStorageMetadataScoreByIdProcedure = "/productv1.ProductService/RequireStorageMetadataScoreById" + // ProductServiceRequireStorageMultiFilteredTagSummaryByIdProcedure is the fully-qualified name of + // the ProductService's RequireStorageMultiFilteredTagSummaryById RPC. + ProductServiceRequireStorageMultiFilteredTagSummaryByIdProcedure = "/productv1.ProductService/RequireStorageMultiFilteredTagSummaryById" + // ProductServiceRequireStorageNullableFilteredTagSummaryByIdProcedure is the fully-qualified name + // of the ProductService's RequireStorageNullableFilteredTagSummaryById RPC. + ProductServiceRequireStorageNullableFilteredTagSummaryByIdProcedure = "/productv1.ProductService/RequireStorageNullableFilteredTagSummaryById" + // ProductServiceRequireStorageOperationReportByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageOperationReportById RPC. + ProductServiceRequireStorageOperationReportByIdProcedure = "/productv1.ProductService/RequireStorageOperationReportById" + // ProductServiceRequireStorageOptionalProcessedMetadataByIdProcedure is the fully-qualified name of + // the ProductService's RequireStorageOptionalProcessedMetadataById RPC. + ProductServiceRequireStorageOptionalProcessedMetadataByIdProcedure = "/productv1.ProductService/RequireStorageOptionalProcessedMetadataById" + // ProductServiceRequireStorageOptionalProcessedTagsByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageOptionalProcessedTagsById RPC. + ProductServiceRequireStorageOptionalProcessedTagsByIdProcedure = "/productv1.ProductService/RequireStorageOptionalProcessedTagsById" + // ProductServiceRequireStorageOptionalTagSummaryByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageOptionalTagSummaryById RPC. + ProductServiceRequireStorageOptionalTagSummaryByIdProcedure = "/productv1.ProductService/RequireStorageOptionalTagSummaryById" + // ProductServiceRequireStorageProcessedMetadataByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageProcessedMetadataById RPC. + ProductServiceRequireStorageProcessedMetadataByIdProcedure = "/productv1.ProductService/RequireStorageProcessedMetadataById" + // ProductServiceRequireStorageProcessedMetadataHistoryByIdProcedure is the fully-qualified name of + // the ProductService's RequireStorageProcessedMetadataHistoryById RPC. + ProductServiceRequireStorageProcessedMetadataHistoryByIdProcedure = "/productv1.ProductService/RequireStorageProcessedMetadataHistoryById" + // ProductServiceRequireStorageProcessedTagsByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageProcessedTagsById RPC. + ProductServiceRequireStorageProcessedTagsByIdProcedure = "/productv1.ProductService/RequireStorageProcessedTagsById" + // ProductServiceRequireStorageSecuritySummaryByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageSecuritySummaryById RPC. + ProductServiceRequireStorageSecuritySummaryByIdProcedure = "/productv1.ProductService/RequireStorageSecuritySummaryById" + // ProductServiceRequireStorageStockHealthScoreByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageStockHealthScoreById RPC. + ProductServiceRequireStorageStockHealthScoreByIdProcedure = "/productv1.ProductService/RequireStorageStockHealthScoreById" + // ProductServiceRequireStorageTagSummaryByIdProcedure is the fully-qualified name of the + // ProductService's RequireStorageTagSummaryById RPC. + ProductServiceRequireStorageTagSummaryByIdProcedure = "/productv1.ProductService/RequireStorageTagSummaryById" + // ProductServiceRequireWarehouseStockHealthScoreByIdProcedure is the fully-qualified name of the + // ProductService's RequireWarehouseStockHealthScoreById RPC. + ProductServiceRequireWarehouseStockHealthScoreByIdProcedure = "/productv1.ProductService/RequireWarehouseStockHealthScoreById" + // ProductServiceResolveCategoryActiveSubcategoriesProcedure is the fully-qualified name of the + // ProductService's ResolveCategoryActiveSubcategories RPC. + ProductServiceResolveCategoryActiveSubcategoriesProcedure = "/productv1.ProductService/ResolveCategoryActiveSubcategories" + // ProductServiceResolveCategoryCategoryMetricsProcedure is the fully-qualified name of the + // ProductService's ResolveCategoryCategoryMetrics RPC. + ProductServiceResolveCategoryCategoryMetricsProcedure = "/productv1.ProductService/ResolveCategoryCategoryMetrics" + // ProductServiceResolveCategoryCategoryStatusProcedure is the fully-qualified name of the + // ProductService's ResolveCategoryCategoryStatus RPC. + ProductServiceResolveCategoryCategoryStatusProcedure = "/productv1.ProductService/ResolveCategoryCategoryStatus" + // ProductServiceResolveCategoryChildCategoriesProcedure is the fully-qualified name of the + // ProductService's ResolveCategoryChildCategories RPC. + ProductServiceResolveCategoryChildCategoriesProcedure = "/productv1.ProductService/ResolveCategoryChildCategories" + // ProductServiceResolveCategoryMascotProcedure is the fully-qualified name of the ProductService's + // ResolveCategoryMascot RPC. + ProductServiceResolveCategoryMascotProcedure = "/productv1.ProductService/ResolveCategoryMascot" + // ProductServiceResolveCategoryMetricsAverageScoreProcedure is the fully-qualified name of the + // ProductService's ResolveCategoryMetricsAverageScore RPC. + ProductServiceResolveCategoryMetricsAverageScoreProcedure = "/productv1.ProductService/ResolveCategoryMetricsAverageScore" + // ProductServiceResolveCategoryMetricsNormalizedScoreProcedure is the fully-qualified name of the + // ProductService's ResolveCategoryMetricsNormalizedScore RPC. + ProductServiceResolveCategoryMetricsNormalizedScoreProcedure = "/productv1.ProductService/ResolveCategoryMetricsNormalizedScore" + // ProductServiceResolveCategoryMetricsRelatedCategoryProcedure is the fully-qualified name of the + // ProductService's ResolveCategoryMetricsRelatedCategory RPC. + ProductServiceResolveCategoryMetricsRelatedCategoryProcedure = "/productv1.ProductService/ResolveCategoryMetricsRelatedCategory" + // ProductServiceResolveCategoryOptionalCategoriesProcedure is the fully-qualified name of the + // ProductService's ResolveCategoryOptionalCategories RPC. + ProductServiceResolveCategoryOptionalCategoriesProcedure = "/productv1.ProductService/ResolveCategoryOptionalCategories" + // ProductServiceResolveCategoryPopularityScoreProcedure is the fully-qualified name of the + // ProductService's ResolveCategoryPopularityScore RPC. + ProductServiceResolveCategoryPopularityScoreProcedure = "/productv1.ProductService/ResolveCategoryPopularityScore" + // ProductServiceResolveCategoryProductCountProcedure is the fully-qualified name of the + // ProductService's ResolveCategoryProductCount RPC. + ProductServiceResolveCategoryProductCountProcedure = "/productv1.ProductService/ResolveCategoryProductCount" + // ProductServiceResolveCategoryTopSubcategoryProcedure is the fully-qualified name of the + // ProductService's ResolveCategoryTopSubcategory RPC. + ProductServiceResolveCategoryTopSubcategoryProcedure = "/productv1.ProductService/ResolveCategoryTopSubcategory" + // ProductServiceResolveCategoryTotalProductsProcedure is the fully-qualified name of the + // ProductService's ResolveCategoryTotalProducts RPC. + ProductServiceResolveCategoryTotalProductsProcedure = "/productv1.ProductService/ResolveCategoryTotalProducts" + // ProductServiceResolveProductMascotRecommendationProcedure is the fully-qualified name of the + // ProductService's ResolveProductMascotRecommendation RPC. + ProductServiceResolveProductMascotRecommendationProcedure = "/productv1.ProductService/ResolveProductMascotRecommendation" + // ProductServiceResolveProductProductDetailsProcedure is the fully-qualified name of the + // ProductService's ResolveProductProductDetails RPC. + ProductServiceResolveProductProductDetailsProcedure = "/productv1.ProductService/ResolveProductProductDetails" + // ProductServiceResolveProductRecommendedCategoryProcedure is the fully-qualified name of the + // ProductService's ResolveProductRecommendedCategory RPC. + ProductServiceResolveProductRecommendedCategoryProcedure = "/productv1.ProductService/ResolveProductRecommendedCategory" + // ProductServiceResolveProductShippingEstimateProcedure is the fully-qualified name of the + // ProductService's ResolveProductShippingEstimate RPC. + ProductServiceResolveProductShippingEstimateProcedure = "/productv1.ProductService/ResolveProductShippingEstimate" + // ProductServiceResolveProductStockStatusProcedure is the fully-qualified name of the + // ProductService's ResolveProductStockStatus RPC. + ProductServiceResolveProductStockStatusProcedure = "/productv1.ProductService/ResolveProductStockStatus" + // ProductServiceResolveStorageLinkedStoragesProcedure is the fully-qualified name of the + // ProductService's ResolveStorageLinkedStorages RPC. + ProductServiceResolveStorageLinkedStoragesProcedure = "/productv1.ProductService/ResolveStorageLinkedStorages" + // ProductServiceResolveStorageNearbyStoragesProcedure is the fully-qualified name of the + // ProductService's ResolveStorageNearbyStorages RPC. + ProductServiceResolveStorageNearbyStoragesProcedure = "/productv1.ProductService/ResolveStorageNearbyStorages" + // ProductServiceResolveStorageStorageStatusProcedure is the fully-qualified name of the + // ProductService's ResolveStorageStorageStatus RPC. + ProductServiceResolveStorageStorageStatusProcedure = "/productv1.ProductService/ResolveStorageStorageStatus" + // ProductServiceResolveSubcategoryFeaturedCategoryProcedure is the fully-qualified name of the + // ProductService's ResolveSubcategoryFeaturedCategory RPC. + ProductServiceResolveSubcategoryFeaturedCategoryProcedure = "/productv1.ProductService/ResolveSubcategoryFeaturedCategory" + // ProductServiceResolveSubcategoryItemCountProcedure is the fully-qualified name of the + // ProductService's ResolveSubcategoryItemCount RPC. + ProductServiceResolveSubcategoryItemCountProcedure = "/productv1.ProductService/ResolveSubcategoryItemCount" + // ProductServiceResolveSubcategoryParentCategoryProcedure is the fully-qualified name of the + // ProductService's ResolveSubcategoryParentCategory RPC. + ProductServiceResolveSubcategoryParentCategoryProcedure = "/productv1.ProductService/ResolveSubcategoryParentCategory" + // ProductServiceResolveTestContainerDetailsProcedure is the fully-qualified name of the + // ProductService's ResolveTestContainerDetails RPC. + ProductServiceResolveTestContainerDetailsProcedure = "/productv1.ProductService/ResolveTestContainerDetails" +) + +// ProductServiceClient is a client for the productv1.ProductService service. +type ProductServiceClient interface { + // Lookup Product entity by id + LookupProductById(context.Context, *connect.Request[productv1.LookupProductByIdRequest]) (*connect.Response[productv1.LookupProductByIdResponse], error) + // Lookup Storage entity by id + LookupStorageById(context.Context, *connect.Request[productv1.LookupStorageByIdRequest]) (*connect.Response[productv1.LookupStorageByIdResponse], error) + // Lookup Warehouse entity by id + LookupWarehouseById(context.Context, *connect.Request[productv1.LookupWarehouseByIdRequest]) (*connect.Response[productv1.LookupWarehouseByIdResponse], error) + MutationBulkCreateAuthors(context.Context, *connect.Request[productv1.MutationBulkCreateAuthorsRequest]) (*connect.Response[productv1.MutationBulkCreateAuthorsResponse], error) + MutationBulkCreateBlogPosts(context.Context, *connect.Request[productv1.MutationBulkCreateBlogPostsRequest]) (*connect.Response[productv1.MutationBulkCreateBlogPostsResponse], error) + MutationBulkUpdateAuthors(context.Context, *connect.Request[productv1.MutationBulkUpdateAuthorsRequest]) (*connect.Response[productv1.MutationBulkUpdateAuthorsResponse], error) + MutationBulkUpdateBlogPosts(context.Context, *connect.Request[productv1.MutationBulkUpdateBlogPostsRequest]) (*connect.Response[productv1.MutationBulkUpdateBlogPostsResponse], error) + MutationCreateAuthor(context.Context, *connect.Request[productv1.MutationCreateAuthorRequest]) (*connect.Response[productv1.MutationCreateAuthorResponse], error) + MutationCreateBlogPost(context.Context, *connect.Request[productv1.MutationCreateBlogPostRequest]) (*connect.Response[productv1.MutationCreateBlogPostResponse], error) + MutationCreateNullableFieldsType(context.Context, *connect.Request[productv1.MutationCreateNullableFieldsTypeRequest]) (*connect.Response[productv1.MutationCreateNullableFieldsTypeResponse], error) + MutationCreateUser(context.Context, *connect.Request[productv1.MutationCreateUserRequest]) (*connect.Response[productv1.MutationCreateUserResponse], error) + MutationPerformAction(context.Context, *connect.Request[productv1.MutationPerformActionRequest]) (*connect.Response[productv1.MutationPerformActionResponse], error) + MutationUpdateAuthor(context.Context, *connect.Request[productv1.MutationUpdateAuthorRequest]) (*connect.Response[productv1.MutationUpdateAuthorResponse], error) + MutationUpdateBlogPost(context.Context, *connect.Request[productv1.MutationUpdateBlogPostRequest]) (*connect.Response[productv1.MutationUpdateBlogPostResponse], error) + MutationUpdateNullableFieldsType(context.Context, *connect.Request[productv1.MutationUpdateNullableFieldsTypeRequest]) (*connect.Response[productv1.MutationUpdateNullableFieldsTypeResponse], error) + QueryAllAuthors(context.Context, *connect.Request[productv1.QueryAllAuthorsRequest]) (*connect.Response[productv1.QueryAllAuthorsResponse], error) + QueryAllBlogPosts(context.Context, *connect.Request[productv1.QueryAllBlogPostsRequest]) (*connect.Response[productv1.QueryAllBlogPostsResponse], error) + QueryAllNullableFieldsTypes(context.Context, *connect.Request[productv1.QueryAllNullableFieldsTypesRequest]) (*connect.Response[productv1.QueryAllNullableFieldsTypesResponse], error) + QueryAllPets(context.Context, *connect.Request[productv1.QueryAllPetsRequest]) (*connect.Response[productv1.QueryAllPetsResponse], error) + QueryAuthor(context.Context, *connect.Request[productv1.QueryAuthorRequest]) (*connect.Response[productv1.QueryAuthorResponse], error) + QueryAuthorById(context.Context, *connect.Request[productv1.QueryAuthorByIdRequest]) (*connect.Response[productv1.QueryAuthorByIdResponse], error) + QueryAuthorsWithFilter(context.Context, *connect.Request[productv1.QueryAuthorsWithFilterRequest]) (*connect.Response[productv1.QueryAuthorsWithFilterResponse], error) + QueryBlogPost(context.Context, *connect.Request[productv1.QueryBlogPostRequest]) (*connect.Response[productv1.QueryBlogPostResponse], error) + QueryBlogPostById(context.Context, *connect.Request[productv1.QueryBlogPostByIdRequest]) (*connect.Response[productv1.QueryBlogPostByIdResponse], error) + QueryBlogPostsWithFilter(context.Context, *connect.Request[productv1.QueryBlogPostsWithFilterRequest]) (*connect.Response[productv1.QueryBlogPostsWithFilterResponse], error) + QueryBulkSearchAuthors(context.Context, *connect.Request[productv1.QueryBulkSearchAuthorsRequest]) (*connect.Response[productv1.QueryBulkSearchAuthorsResponse], error) + QueryBulkSearchBlogPosts(context.Context, *connect.Request[productv1.QueryBulkSearchBlogPostsRequest]) (*connect.Response[productv1.QueryBulkSearchBlogPostsResponse], error) + QueryCalculateTotals(context.Context, *connect.Request[productv1.QueryCalculateTotalsRequest]) (*connect.Response[productv1.QueryCalculateTotalsResponse], error) + QueryCategories(context.Context, *connect.Request[productv1.QueryCategoriesRequest]) (*connect.Response[productv1.QueryCategoriesResponse], error) + QueryCategoriesByKind(context.Context, *connect.Request[productv1.QueryCategoriesByKindRequest]) (*connect.Response[productv1.QueryCategoriesByKindResponse], error) + QueryCategoriesByKinds(context.Context, *connect.Request[productv1.QueryCategoriesByKindsRequest]) (*connect.Response[productv1.QueryCategoriesByKindsResponse], error) + QueryCategory(context.Context, *connect.Request[productv1.QueryCategoryRequest]) (*connect.Response[productv1.QueryCategoryResponse], error) + QueryComplexFilterType(context.Context, *connect.Request[productv1.QueryComplexFilterTypeRequest]) (*connect.Response[productv1.QueryComplexFilterTypeResponse], error) + QueryConditionalSearch(context.Context, *connect.Request[productv1.QueryConditionalSearchRequest]) (*connect.Response[productv1.QueryConditionalSearchResponse], error) + QueryFilterCategories(context.Context, *connect.Request[productv1.QueryFilterCategoriesRequest]) (*connect.Response[productv1.QueryFilterCategoriesResponse], error) + QueryNestedType(context.Context, *connect.Request[productv1.QueryNestedTypeRequest]) (*connect.Response[productv1.QueryNestedTypeResponse], error) + QueryNullableFieldsType(context.Context, *connect.Request[productv1.QueryNullableFieldsTypeRequest]) (*connect.Response[productv1.QueryNullableFieldsTypeResponse], error) + QueryNullableFieldsTypeById(context.Context, *connect.Request[productv1.QueryNullableFieldsTypeByIdRequest]) (*connect.Response[productv1.QueryNullableFieldsTypeByIdResponse], error) + QueryNullableFieldsTypeWithFilter(context.Context, *connect.Request[productv1.QueryNullableFieldsTypeWithFilterRequest]) (*connect.Response[productv1.QueryNullableFieldsTypeWithFilterResponse], error) + QueryRandomPet(context.Context, *connect.Request[productv1.QueryRandomPetRequest]) (*connect.Response[productv1.QueryRandomPetResponse], error) + QueryRandomSearchResult(context.Context, *connect.Request[productv1.QueryRandomSearchResultRequest]) (*connect.Response[productv1.QueryRandomSearchResultResponse], error) + QueryRecursiveType(context.Context, *connect.Request[productv1.QueryRecursiveTypeRequest]) (*connect.Response[productv1.QueryRecursiveTypeResponse], error) + QuerySearch(context.Context, *connect.Request[productv1.QuerySearchRequest]) (*connect.Response[productv1.QuerySearchResponse], error) + QueryTestContainer(context.Context, *connect.Request[productv1.QueryTestContainerRequest]) (*connect.Response[productv1.QueryTestContainerResponse], error) + QueryTestContainers(context.Context, *connect.Request[productv1.QueryTestContainersRequest]) (*connect.Response[productv1.QueryTestContainersResponse], error) + QueryTypeFilterWithArguments(context.Context, *connect.Request[productv1.QueryTypeFilterWithArgumentsRequest]) (*connect.Response[productv1.QueryTypeFilterWithArgumentsResponse], error) + QueryTypeWithMultipleFilterFields(context.Context, *connect.Request[productv1.QueryTypeWithMultipleFilterFieldsRequest]) (*connect.Response[productv1.QueryTypeWithMultipleFilterFieldsResponse], error) + QueryUser(context.Context, *connect.Request[productv1.QueryUserRequest]) (*connect.Response[productv1.QueryUserResponse], error) + QueryUsers(context.Context, *connect.Request[productv1.QueryUsersRequest]) (*connect.Response[productv1.QueryUsersResponse], error) + RequireStorageCategoryInfoSummaryById(context.Context, *connect.Request[productv1.RequireStorageCategoryInfoSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageCategoryInfoSummaryByIdResponse], error) + RequireStorageDeepItemInfoById(context.Context, *connect.Request[productv1.RequireStorageDeepItemInfoByIdRequest]) (*connect.Response[productv1.RequireStorageDeepItemInfoByIdResponse], error) + RequireStorageFilteredTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageFilteredTagSummaryByIdResponse], error) + RequireStorageItemHandlerInfoById(context.Context, *connect.Request[productv1.RequireStorageItemHandlerInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemHandlerInfoByIdResponse], error) + RequireStorageItemInfoById(context.Context, *connect.Request[productv1.RequireStorageItemInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemInfoByIdResponse], error) + RequireStorageItemSpecsInfoById(context.Context, *connect.Request[productv1.RequireStorageItemSpecsInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemSpecsInfoByIdResponse], error) + RequireStorageKindSummaryById(context.Context, *connect.Request[productv1.RequireStorageKindSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageKindSummaryByIdResponse], error) + RequireStorageMetadataScoreById(context.Context, *connect.Request[productv1.RequireStorageMetadataScoreByIdRequest]) (*connect.Response[productv1.RequireStorageMetadataScoreByIdResponse], error) + RequireStorageMultiFilteredTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageMultiFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageMultiFilteredTagSummaryByIdResponse], error) + RequireStorageNullableFilteredTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageNullableFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageNullableFilteredTagSummaryByIdResponse], error) + RequireStorageOperationReportById(context.Context, *connect.Request[productv1.RequireStorageOperationReportByIdRequest]) (*connect.Response[productv1.RequireStorageOperationReportByIdResponse], error) + RequireStorageOptionalProcessedMetadataById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataByIdResponse], error) + RequireStorageOptionalProcessedTagsById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedTagsByIdResponse], error) + RequireStorageOptionalTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageOptionalTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalTagSummaryByIdResponse], error) + RequireStorageProcessedMetadataById(context.Context, *connect.Request[productv1.RequireStorageProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedMetadataByIdResponse], error) + RequireStorageProcessedMetadataHistoryById(context.Context, *connect.Request[productv1.RequireStorageProcessedMetadataHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedMetadataHistoryByIdResponse], error) + RequireStorageProcessedTagsById(context.Context, *connect.Request[productv1.RequireStorageProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedTagsByIdResponse], error) + RequireStorageSecuritySummaryById(context.Context, *connect.Request[productv1.RequireStorageSecuritySummaryByIdRequest]) (*connect.Response[productv1.RequireStorageSecuritySummaryByIdResponse], error) + RequireStorageStockHealthScoreById(context.Context, *connect.Request[productv1.RequireStorageStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireStorageStockHealthScoreByIdResponse], error) + RequireStorageTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageTagSummaryByIdResponse], error) + RequireWarehouseStockHealthScoreById(context.Context, *connect.Request[productv1.RequireWarehouseStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireWarehouseStockHealthScoreByIdResponse], error) + ResolveCategoryActiveSubcategories(context.Context, *connect.Request[productv1.ResolveCategoryActiveSubcategoriesRequest]) (*connect.Response[productv1.ResolveCategoryActiveSubcategoriesResponse], error) + ResolveCategoryCategoryMetrics(context.Context, *connect.Request[productv1.ResolveCategoryCategoryMetricsRequest]) (*connect.Response[productv1.ResolveCategoryCategoryMetricsResponse], error) + ResolveCategoryCategoryStatus(context.Context, *connect.Request[productv1.ResolveCategoryCategoryStatusRequest]) (*connect.Response[productv1.ResolveCategoryCategoryStatusResponse], error) + ResolveCategoryChildCategories(context.Context, *connect.Request[productv1.ResolveCategoryChildCategoriesRequest]) (*connect.Response[productv1.ResolveCategoryChildCategoriesResponse], error) + ResolveCategoryMascot(context.Context, *connect.Request[productv1.ResolveCategoryMascotRequest]) (*connect.Response[productv1.ResolveCategoryMascotResponse], error) + ResolveCategoryMetricsAverageScore(context.Context, *connect.Request[productv1.ResolveCategoryMetricsAverageScoreRequest]) (*connect.Response[productv1.ResolveCategoryMetricsAverageScoreResponse], error) + ResolveCategoryMetricsNormalizedScore(context.Context, *connect.Request[productv1.ResolveCategoryMetricsNormalizedScoreRequest]) (*connect.Response[productv1.ResolveCategoryMetricsNormalizedScoreResponse], error) + ResolveCategoryMetricsRelatedCategory(context.Context, *connect.Request[productv1.ResolveCategoryMetricsRelatedCategoryRequest]) (*connect.Response[productv1.ResolveCategoryMetricsRelatedCategoryResponse], error) + ResolveCategoryOptionalCategories(context.Context, *connect.Request[productv1.ResolveCategoryOptionalCategoriesRequest]) (*connect.Response[productv1.ResolveCategoryOptionalCategoriesResponse], error) + ResolveCategoryPopularityScore(context.Context, *connect.Request[productv1.ResolveCategoryPopularityScoreRequest]) (*connect.Response[productv1.ResolveCategoryPopularityScoreResponse], error) + ResolveCategoryProductCount(context.Context, *connect.Request[productv1.ResolveCategoryProductCountRequest]) (*connect.Response[productv1.ResolveCategoryProductCountResponse], error) + ResolveCategoryTopSubcategory(context.Context, *connect.Request[productv1.ResolveCategoryTopSubcategoryRequest]) (*connect.Response[productv1.ResolveCategoryTopSubcategoryResponse], error) + ResolveCategoryTotalProducts(context.Context, *connect.Request[productv1.ResolveCategoryTotalProductsRequest]) (*connect.Response[productv1.ResolveCategoryTotalProductsResponse], error) + ResolveProductMascotRecommendation(context.Context, *connect.Request[productv1.ResolveProductMascotRecommendationRequest]) (*connect.Response[productv1.ResolveProductMascotRecommendationResponse], error) + ResolveProductProductDetails(context.Context, *connect.Request[productv1.ResolveProductProductDetailsRequest]) (*connect.Response[productv1.ResolveProductProductDetailsResponse], error) + ResolveProductRecommendedCategory(context.Context, *connect.Request[productv1.ResolveProductRecommendedCategoryRequest]) (*connect.Response[productv1.ResolveProductRecommendedCategoryResponse], error) + ResolveProductShippingEstimate(context.Context, *connect.Request[productv1.ResolveProductShippingEstimateRequest]) (*connect.Response[productv1.ResolveProductShippingEstimateResponse], error) + ResolveProductStockStatus(context.Context, *connect.Request[productv1.ResolveProductStockStatusRequest]) (*connect.Response[productv1.ResolveProductStockStatusResponse], error) + ResolveStorageLinkedStorages(context.Context, *connect.Request[productv1.ResolveStorageLinkedStoragesRequest]) (*connect.Response[productv1.ResolveStorageLinkedStoragesResponse], error) + ResolveStorageNearbyStorages(context.Context, *connect.Request[productv1.ResolveStorageNearbyStoragesRequest]) (*connect.Response[productv1.ResolveStorageNearbyStoragesResponse], error) + ResolveStorageStorageStatus(context.Context, *connect.Request[productv1.ResolveStorageStorageStatusRequest]) (*connect.Response[productv1.ResolveStorageStorageStatusResponse], error) + ResolveSubcategoryFeaturedCategory(context.Context, *connect.Request[productv1.ResolveSubcategoryFeaturedCategoryRequest]) (*connect.Response[productv1.ResolveSubcategoryFeaturedCategoryResponse], error) + ResolveSubcategoryItemCount(context.Context, *connect.Request[productv1.ResolveSubcategoryItemCountRequest]) (*connect.Response[productv1.ResolveSubcategoryItemCountResponse], error) + ResolveSubcategoryParentCategory(context.Context, *connect.Request[productv1.ResolveSubcategoryParentCategoryRequest]) (*connect.Response[productv1.ResolveSubcategoryParentCategoryResponse], error) + ResolveTestContainerDetails(context.Context, *connect.Request[productv1.ResolveTestContainerDetailsRequest]) (*connect.Response[productv1.ResolveTestContainerDetailsResponse], error) +} + +// NewProductServiceClient constructs a client for the productv1.ProductService service. By default, +// it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and +// sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() +// or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewProductServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) ProductServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + productServiceMethods := productv1.File_product_proto.Services().ByName("ProductService").Methods() + return &productServiceClient{ + lookupProductById: connect.NewClient[productv1.LookupProductByIdRequest, productv1.LookupProductByIdResponse]( + httpClient, + baseURL+ProductServiceLookupProductByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("LookupProductById")), + connect.WithClientOptions(opts...), + ), + lookupStorageById: connect.NewClient[productv1.LookupStorageByIdRequest, productv1.LookupStorageByIdResponse]( + httpClient, + baseURL+ProductServiceLookupStorageByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("LookupStorageById")), + connect.WithClientOptions(opts...), + ), + lookupWarehouseById: connect.NewClient[productv1.LookupWarehouseByIdRequest, productv1.LookupWarehouseByIdResponse]( + httpClient, + baseURL+ProductServiceLookupWarehouseByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("LookupWarehouseById")), + connect.WithClientOptions(opts...), + ), + mutationBulkCreateAuthors: connect.NewClient[productv1.MutationBulkCreateAuthorsRequest, productv1.MutationBulkCreateAuthorsResponse]( + httpClient, + baseURL+ProductServiceMutationBulkCreateAuthorsProcedure, + connect.WithSchema(productServiceMethods.ByName("MutationBulkCreateAuthors")), + connect.WithClientOptions(opts...), + ), + mutationBulkCreateBlogPosts: connect.NewClient[productv1.MutationBulkCreateBlogPostsRequest, productv1.MutationBulkCreateBlogPostsResponse]( + httpClient, + baseURL+ProductServiceMutationBulkCreateBlogPostsProcedure, + connect.WithSchema(productServiceMethods.ByName("MutationBulkCreateBlogPosts")), + connect.WithClientOptions(opts...), + ), + mutationBulkUpdateAuthors: connect.NewClient[productv1.MutationBulkUpdateAuthorsRequest, productv1.MutationBulkUpdateAuthorsResponse]( + httpClient, + baseURL+ProductServiceMutationBulkUpdateAuthorsProcedure, + connect.WithSchema(productServiceMethods.ByName("MutationBulkUpdateAuthors")), + connect.WithClientOptions(opts...), + ), + mutationBulkUpdateBlogPosts: connect.NewClient[productv1.MutationBulkUpdateBlogPostsRequest, productv1.MutationBulkUpdateBlogPostsResponse]( + httpClient, + baseURL+ProductServiceMutationBulkUpdateBlogPostsProcedure, + connect.WithSchema(productServiceMethods.ByName("MutationBulkUpdateBlogPosts")), + connect.WithClientOptions(opts...), + ), + mutationCreateAuthor: connect.NewClient[productv1.MutationCreateAuthorRequest, productv1.MutationCreateAuthorResponse]( + httpClient, + baseURL+ProductServiceMutationCreateAuthorProcedure, + connect.WithSchema(productServiceMethods.ByName("MutationCreateAuthor")), + connect.WithClientOptions(opts...), + ), + mutationCreateBlogPost: connect.NewClient[productv1.MutationCreateBlogPostRequest, productv1.MutationCreateBlogPostResponse]( + httpClient, + baseURL+ProductServiceMutationCreateBlogPostProcedure, + connect.WithSchema(productServiceMethods.ByName("MutationCreateBlogPost")), + connect.WithClientOptions(opts...), + ), + mutationCreateNullableFieldsType: connect.NewClient[productv1.MutationCreateNullableFieldsTypeRequest, productv1.MutationCreateNullableFieldsTypeResponse]( + httpClient, + baseURL+ProductServiceMutationCreateNullableFieldsTypeProcedure, + connect.WithSchema(productServiceMethods.ByName("MutationCreateNullableFieldsType")), + connect.WithClientOptions(opts...), + ), + mutationCreateUser: connect.NewClient[productv1.MutationCreateUserRequest, productv1.MutationCreateUserResponse]( + httpClient, + baseURL+ProductServiceMutationCreateUserProcedure, + connect.WithSchema(productServiceMethods.ByName("MutationCreateUser")), + connect.WithClientOptions(opts...), + ), + mutationPerformAction: connect.NewClient[productv1.MutationPerformActionRequest, productv1.MutationPerformActionResponse]( + httpClient, + baseURL+ProductServiceMutationPerformActionProcedure, + connect.WithSchema(productServiceMethods.ByName("MutationPerformAction")), + connect.WithClientOptions(opts...), + ), + mutationUpdateAuthor: connect.NewClient[productv1.MutationUpdateAuthorRequest, productv1.MutationUpdateAuthorResponse]( + httpClient, + baseURL+ProductServiceMutationUpdateAuthorProcedure, + connect.WithSchema(productServiceMethods.ByName("MutationUpdateAuthor")), + connect.WithClientOptions(opts...), + ), + mutationUpdateBlogPost: connect.NewClient[productv1.MutationUpdateBlogPostRequest, productv1.MutationUpdateBlogPostResponse]( + httpClient, + baseURL+ProductServiceMutationUpdateBlogPostProcedure, + connect.WithSchema(productServiceMethods.ByName("MutationUpdateBlogPost")), + connect.WithClientOptions(opts...), + ), + mutationUpdateNullableFieldsType: connect.NewClient[productv1.MutationUpdateNullableFieldsTypeRequest, productv1.MutationUpdateNullableFieldsTypeResponse]( + httpClient, + baseURL+ProductServiceMutationUpdateNullableFieldsTypeProcedure, + connect.WithSchema(productServiceMethods.ByName("MutationUpdateNullableFieldsType")), + connect.WithClientOptions(opts...), + ), + queryAllAuthors: connect.NewClient[productv1.QueryAllAuthorsRequest, productv1.QueryAllAuthorsResponse]( + httpClient, + baseURL+ProductServiceQueryAllAuthorsProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryAllAuthors")), + connect.WithClientOptions(opts...), + ), + queryAllBlogPosts: connect.NewClient[productv1.QueryAllBlogPostsRequest, productv1.QueryAllBlogPostsResponse]( + httpClient, + baseURL+ProductServiceQueryAllBlogPostsProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryAllBlogPosts")), + connect.WithClientOptions(opts...), + ), + queryAllNullableFieldsTypes: connect.NewClient[productv1.QueryAllNullableFieldsTypesRequest, productv1.QueryAllNullableFieldsTypesResponse]( + httpClient, + baseURL+ProductServiceQueryAllNullableFieldsTypesProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryAllNullableFieldsTypes")), + connect.WithClientOptions(opts...), + ), + queryAllPets: connect.NewClient[productv1.QueryAllPetsRequest, productv1.QueryAllPetsResponse]( + httpClient, + baseURL+ProductServiceQueryAllPetsProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryAllPets")), + connect.WithClientOptions(opts...), + ), + queryAuthor: connect.NewClient[productv1.QueryAuthorRequest, productv1.QueryAuthorResponse]( + httpClient, + baseURL+ProductServiceQueryAuthorProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryAuthor")), + connect.WithClientOptions(opts...), + ), + queryAuthorById: connect.NewClient[productv1.QueryAuthorByIdRequest, productv1.QueryAuthorByIdResponse]( + httpClient, + baseURL+ProductServiceQueryAuthorByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryAuthorById")), + connect.WithClientOptions(opts...), + ), + queryAuthorsWithFilter: connect.NewClient[productv1.QueryAuthorsWithFilterRequest, productv1.QueryAuthorsWithFilterResponse]( + httpClient, + baseURL+ProductServiceQueryAuthorsWithFilterProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryAuthorsWithFilter")), + connect.WithClientOptions(opts...), + ), + queryBlogPost: connect.NewClient[productv1.QueryBlogPostRequest, productv1.QueryBlogPostResponse]( + httpClient, + baseURL+ProductServiceQueryBlogPostProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryBlogPost")), + connect.WithClientOptions(opts...), + ), + queryBlogPostById: connect.NewClient[productv1.QueryBlogPostByIdRequest, productv1.QueryBlogPostByIdResponse]( + httpClient, + baseURL+ProductServiceQueryBlogPostByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryBlogPostById")), + connect.WithClientOptions(opts...), + ), + queryBlogPostsWithFilter: connect.NewClient[productv1.QueryBlogPostsWithFilterRequest, productv1.QueryBlogPostsWithFilterResponse]( + httpClient, + baseURL+ProductServiceQueryBlogPostsWithFilterProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryBlogPostsWithFilter")), + connect.WithClientOptions(opts...), + ), + queryBulkSearchAuthors: connect.NewClient[productv1.QueryBulkSearchAuthorsRequest, productv1.QueryBulkSearchAuthorsResponse]( + httpClient, + baseURL+ProductServiceQueryBulkSearchAuthorsProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryBulkSearchAuthors")), + connect.WithClientOptions(opts...), + ), + queryBulkSearchBlogPosts: connect.NewClient[productv1.QueryBulkSearchBlogPostsRequest, productv1.QueryBulkSearchBlogPostsResponse]( + httpClient, + baseURL+ProductServiceQueryBulkSearchBlogPostsProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryBulkSearchBlogPosts")), + connect.WithClientOptions(opts...), + ), + queryCalculateTotals: connect.NewClient[productv1.QueryCalculateTotalsRequest, productv1.QueryCalculateTotalsResponse]( + httpClient, + baseURL+ProductServiceQueryCalculateTotalsProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryCalculateTotals")), + connect.WithClientOptions(opts...), + ), + queryCategories: connect.NewClient[productv1.QueryCategoriesRequest, productv1.QueryCategoriesResponse]( + httpClient, + baseURL+ProductServiceQueryCategoriesProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryCategories")), + connect.WithClientOptions(opts...), + ), + queryCategoriesByKind: connect.NewClient[productv1.QueryCategoriesByKindRequest, productv1.QueryCategoriesByKindResponse]( + httpClient, + baseURL+ProductServiceQueryCategoriesByKindProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryCategoriesByKind")), + connect.WithClientOptions(opts...), + ), + queryCategoriesByKinds: connect.NewClient[productv1.QueryCategoriesByKindsRequest, productv1.QueryCategoriesByKindsResponse]( + httpClient, + baseURL+ProductServiceQueryCategoriesByKindsProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryCategoriesByKinds")), + connect.WithClientOptions(opts...), + ), + queryCategory: connect.NewClient[productv1.QueryCategoryRequest, productv1.QueryCategoryResponse]( + httpClient, + baseURL+ProductServiceQueryCategoryProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryCategory")), + connect.WithClientOptions(opts...), + ), + queryComplexFilterType: connect.NewClient[productv1.QueryComplexFilterTypeRequest, productv1.QueryComplexFilterTypeResponse]( + httpClient, + baseURL+ProductServiceQueryComplexFilterTypeProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryComplexFilterType")), + connect.WithClientOptions(opts...), + ), + queryConditionalSearch: connect.NewClient[productv1.QueryConditionalSearchRequest, productv1.QueryConditionalSearchResponse]( + httpClient, + baseURL+ProductServiceQueryConditionalSearchProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryConditionalSearch")), + connect.WithClientOptions(opts...), + ), + queryFilterCategories: connect.NewClient[productv1.QueryFilterCategoriesRequest, productv1.QueryFilterCategoriesResponse]( + httpClient, + baseURL+ProductServiceQueryFilterCategoriesProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryFilterCategories")), + connect.WithClientOptions(opts...), + ), + queryNestedType: connect.NewClient[productv1.QueryNestedTypeRequest, productv1.QueryNestedTypeResponse]( + httpClient, + baseURL+ProductServiceQueryNestedTypeProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryNestedType")), + connect.WithClientOptions(opts...), + ), + queryNullableFieldsType: connect.NewClient[productv1.QueryNullableFieldsTypeRequest, productv1.QueryNullableFieldsTypeResponse]( + httpClient, + baseURL+ProductServiceQueryNullableFieldsTypeProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryNullableFieldsType")), + connect.WithClientOptions(opts...), + ), + queryNullableFieldsTypeById: connect.NewClient[productv1.QueryNullableFieldsTypeByIdRequest, productv1.QueryNullableFieldsTypeByIdResponse]( + httpClient, + baseURL+ProductServiceQueryNullableFieldsTypeByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryNullableFieldsTypeById")), + connect.WithClientOptions(opts...), + ), + queryNullableFieldsTypeWithFilter: connect.NewClient[productv1.QueryNullableFieldsTypeWithFilterRequest, productv1.QueryNullableFieldsTypeWithFilterResponse]( + httpClient, + baseURL+ProductServiceQueryNullableFieldsTypeWithFilterProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryNullableFieldsTypeWithFilter")), + connect.WithClientOptions(opts...), + ), + queryRandomPet: connect.NewClient[productv1.QueryRandomPetRequest, productv1.QueryRandomPetResponse]( + httpClient, + baseURL+ProductServiceQueryRandomPetProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryRandomPet")), + connect.WithClientOptions(opts...), + ), + queryRandomSearchResult: connect.NewClient[productv1.QueryRandomSearchResultRequest, productv1.QueryRandomSearchResultResponse]( + httpClient, + baseURL+ProductServiceQueryRandomSearchResultProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryRandomSearchResult")), + connect.WithClientOptions(opts...), + ), + queryRecursiveType: connect.NewClient[productv1.QueryRecursiveTypeRequest, productv1.QueryRecursiveTypeResponse]( + httpClient, + baseURL+ProductServiceQueryRecursiveTypeProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryRecursiveType")), + connect.WithClientOptions(opts...), + ), + querySearch: connect.NewClient[productv1.QuerySearchRequest, productv1.QuerySearchResponse]( + httpClient, + baseURL+ProductServiceQuerySearchProcedure, + connect.WithSchema(productServiceMethods.ByName("QuerySearch")), + connect.WithClientOptions(opts...), + ), + queryTestContainer: connect.NewClient[productv1.QueryTestContainerRequest, productv1.QueryTestContainerResponse]( + httpClient, + baseURL+ProductServiceQueryTestContainerProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryTestContainer")), + connect.WithClientOptions(opts...), + ), + queryTestContainers: connect.NewClient[productv1.QueryTestContainersRequest, productv1.QueryTestContainersResponse]( + httpClient, + baseURL+ProductServiceQueryTestContainersProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryTestContainers")), + connect.WithClientOptions(opts...), + ), + queryTypeFilterWithArguments: connect.NewClient[productv1.QueryTypeFilterWithArgumentsRequest, productv1.QueryTypeFilterWithArgumentsResponse]( + httpClient, + baseURL+ProductServiceQueryTypeFilterWithArgumentsProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryTypeFilterWithArguments")), + connect.WithClientOptions(opts...), + ), + queryTypeWithMultipleFilterFields: connect.NewClient[productv1.QueryTypeWithMultipleFilterFieldsRequest, productv1.QueryTypeWithMultipleFilterFieldsResponse]( + httpClient, + baseURL+ProductServiceQueryTypeWithMultipleFilterFieldsProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryTypeWithMultipleFilterFields")), + connect.WithClientOptions(opts...), + ), + queryUser: connect.NewClient[productv1.QueryUserRequest, productv1.QueryUserResponse]( + httpClient, + baseURL+ProductServiceQueryUserProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryUser")), + connect.WithClientOptions(opts...), + ), + queryUsers: connect.NewClient[productv1.QueryUsersRequest, productv1.QueryUsersResponse]( + httpClient, + baseURL+ProductServiceQueryUsersProcedure, + connect.WithSchema(productServiceMethods.ByName("QueryUsers")), + connect.WithClientOptions(opts...), + ), + requireStorageCategoryInfoSummaryById: connect.NewClient[productv1.RequireStorageCategoryInfoSummaryByIdRequest, productv1.RequireStorageCategoryInfoSummaryByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageCategoryInfoSummaryByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageCategoryInfoSummaryById")), + connect.WithClientOptions(opts...), + ), + requireStorageDeepItemInfoById: connect.NewClient[productv1.RequireStorageDeepItemInfoByIdRequest, productv1.RequireStorageDeepItemInfoByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageDeepItemInfoByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageDeepItemInfoById")), + connect.WithClientOptions(opts...), + ), + requireStorageFilteredTagSummaryById: connect.NewClient[productv1.RequireStorageFilteredTagSummaryByIdRequest, productv1.RequireStorageFilteredTagSummaryByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageFilteredTagSummaryByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageFilteredTagSummaryById")), + connect.WithClientOptions(opts...), + ), + requireStorageItemHandlerInfoById: connect.NewClient[productv1.RequireStorageItemHandlerInfoByIdRequest, productv1.RequireStorageItemHandlerInfoByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageItemHandlerInfoByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageItemHandlerInfoById")), + connect.WithClientOptions(opts...), + ), + requireStorageItemInfoById: connect.NewClient[productv1.RequireStorageItemInfoByIdRequest, productv1.RequireStorageItemInfoByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageItemInfoByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageItemInfoById")), + connect.WithClientOptions(opts...), + ), + requireStorageItemSpecsInfoById: connect.NewClient[productv1.RequireStorageItemSpecsInfoByIdRequest, productv1.RequireStorageItemSpecsInfoByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageItemSpecsInfoByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageItemSpecsInfoById")), + connect.WithClientOptions(opts...), + ), + requireStorageKindSummaryById: connect.NewClient[productv1.RequireStorageKindSummaryByIdRequest, productv1.RequireStorageKindSummaryByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageKindSummaryByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageKindSummaryById")), + connect.WithClientOptions(opts...), + ), + requireStorageMetadataScoreById: connect.NewClient[productv1.RequireStorageMetadataScoreByIdRequest, productv1.RequireStorageMetadataScoreByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageMetadataScoreByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageMetadataScoreById")), + connect.WithClientOptions(opts...), + ), + requireStorageMultiFilteredTagSummaryById: connect.NewClient[productv1.RequireStorageMultiFilteredTagSummaryByIdRequest, productv1.RequireStorageMultiFilteredTagSummaryByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageMultiFilteredTagSummaryByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageMultiFilteredTagSummaryById")), + connect.WithClientOptions(opts...), + ), + requireStorageNullableFilteredTagSummaryById: connect.NewClient[productv1.RequireStorageNullableFilteredTagSummaryByIdRequest, productv1.RequireStorageNullableFilteredTagSummaryByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageNullableFilteredTagSummaryByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageNullableFilteredTagSummaryById")), + connect.WithClientOptions(opts...), + ), + requireStorageOperationReportById: connect.NewClient[productv1.RequireStorageOperationReportByIdRequest, productv1.RequireStorageOperationReportByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageOperationReportByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageOperationReportById")), + connect.WithClientOptions(opts...), + ), + requireStorageOptionalProcessedMetadataById: connect.NewClient[productv1.RequireStorageOptionalProcessedMetadataByIdRequest, productv1.RequireStorageOptionalProcessedMetadataByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageOptionalProcessedMetadataByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalProcessedMetadataById")), + connect.WithClientOptions(opts...), + ), + requireStorageOptionalProcessedTagsById: connect.NewClient[productv1.RequireStorageOptionalProcessedTagsByIdRequest, productv1.RequireStorageOptionalProcessedTagsByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageOptionalProcessedTagsByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalProcessedTagsById")), + connect.WithClientOptions(opts...), + ), + requireStorageOptionalTagSummaryById: connect.NewClient[productv1.RequireStorageOptionalTagSummaryByIdRequest, productv1.RequireStorageOptionalTagSummaryByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageOptionalTagSummaryByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalTagSummaryById")), + connect.WithClientOptions(opts...), + ), + requireStorageProcessedMetadataById: connect.NewClient[productv1.RequireStorageProcessedMetadataByIdRequest, productv1.RequireStorageProcessedMetadataByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageProcessedMetadataByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageProcessedMetadataById")), + connect.WithClientOptions(opts...), + ), + requireStorageProcessedMetadataHistoryById: connect.NewClient[productv1.RequireStorageProcessedMetadataHistoryByIdRequest, productv1.RequireStorageProcessedMetadataHistoryByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageProcessedMetadataHistoryByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageProcessedMetadataHistoryById")), + connect.WithClientOptions(opts...), + ), + requireStorageProcessedTagsById: connect.NewClient[productv1.RequireStorageProcessedTagsByIdRequest, productv1.RequireStorageProcessedTagsByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageProcessedTagsByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageProcessedTagsById")), + connect.WithClientOptions(opts...), + ), + requireStorageSecuritySummaryById: connect.NewClient[productv1.RequireStorageSecuritySummaryByIdRequest, productv1.RequireStorageSecuritySummaryByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageSecuritySummaryByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageSecuritySummaryById")), + connect.WithClientOptions(opts...), + ), + requireStorageStockHealthScoreById: connect.NewClient[productv1.RequireStorageStockHealthScoreByIdRequest, productv1.RequireStorageStockHealthScoreByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageStockHealthScoreByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageStockHealthScoreById")), + connect.WithClientOptions(opts...), + ), + requireStorageTagSummaryById: connect.NewClient[productv1.RequireStorageTagSummaryByIdRequest, productv1.RequireStorageTagSummaryByIdResponse]( + httpClient, + baseURL+ProductServiceRequireStorageTagSummaryByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireStorageTagSummaryById")), + connect.WithClientOptions(opts...), + ), + requireWarehouseStockHealthScoreById: connect.NewClient[productv1.RequireWarehouseStockHealthScoreByIdRequest, productv1.RequireWarehouseStockHealthScoreByIdResponse]( + httpClient, + baseURL+ProductServiceRequireWarehouseStockHealthScoreByIdProcedure, + connect.WithSchema(productServiceMethods.ByName("RequireWarehouseStockHealthScoreById")), + connect.WithClientOptions(opts...), + ), + resolveCategoryActiveSubcategories: connect.NewClient[productv1.ResolveCategoryActiveSubcategoriesRequest, productv1.ResolveCategoryActiveSubcategoriesResponse]( + httpClient, + baseURL+ProductServiceResolveCategoryActiveSubcategoriesProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryActiveSubcategories")), + connect.WithClientOptions(opts...), + ), + resolveCategoryCategoryMetrics: connect.NewClient[productv1.ResolveCategoryCategoryMetricsRequest, productv1.ResolveCategoryCategoryMetricsResponse]( + httpClient, + baseURL+ProductServiceResolveCategoryCategoryMetricsProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryCategoryMetrics")), + connect.WithClientOptions(opts...), + ), + resolveCategoryCategoryStatus: connect.NewClient[productv1.ResolveCategoryCategoryStatusRequest, productv1.ResolveCategoryCategoryStatusResponse]( + httpClient, + baseURL+ProductServiceResolveCategoryCategoryStatusProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryCategoryStatus")), + connect.WithClientOptions(opts...), + ), + resolveCategoryChildCategories: connect.NewClient[productv1.ResolveCategoryChildCategoriesRequest, productv1.ResolveCategoryChildCategoriesResponse]( + httpClient, + baseURL+ProductServiceResolveCategoryChildCategoriesProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryChildCategories")), + connect.WithClientOptions(opts...), + ), + resolveCategoryMascot: connect.NewClient[productv1.ResolveCategoryMascotRequest, productv1.ResolveCategoryMascotResponse]( + httpClient, + baseURL+ProductServiceResolveCategoryMascotProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryMascot")), + connect.WithClientOptions(opts...), + ), + resolveCategoryMetricsAverageScore: connect.NewClient[productv1.ResolveCategoryMetricsAverageScoreRequest, productv1.ResolveCategoryMetricsAverageScoreResponse]( + httpClient, + baseURL+ProductServiceResolveCategoryMetricsAverageScoreProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryMetricsAverageScore")), + connect.WithClientOptions(opts...), + ), + resolveCategoryMetricsNormalizedScore: connect.NewClient[productv1.ResolveCategoryMetricsNormalizedScoreRequest, productv1.ResolveCategoryMetricsNormalizedScoreResponse]( + httpClient, + baseURL+ProductServiceResolveCategoryMetricsNormalizedScoreProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryMetricsNormalizedScore")), + connect.WithClientOptions(opts...), + ), + resolveCategoryMetricsRelatedCategory: connect.NewClient[productv1.ResolveCategoryMetricsRelatedCategoryRequest, productv1.ResolveCategoryMetricsRelatedCategoryResponse]( + httpClient, + baseURL+ProductServiceResolveCategoryMetricsRelatedCategoryProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryMetricsRelatedCategory")), + connect.WithClientOptions(opts...), + ), + resolveCategoryOptionalCategories: connect.NewClient[productv1.ResolveCategoryOptionalCategoriesRequest, productv1.ResolveCategoryOptionalCategoriesResponse]( + httpClient, + baseURL+ProductServiceResolveCategoryOptionalCategoriesProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryOptionalCategories")), + connect.WithClientOptions(opts...), + ), + resolveCategoryPopularityScore: connect.NewClient[productv1.ResolveCategoryPopularityScoreRequest, productv1.ResolveCategoryPopularityScoreResponse]( + httpClient, + baseURL+ProductServiceResolveCategoryPopularityScoreProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryPopularityScore")), + connect.WithClientOptions(opts...), + ), + resolveCategoryProductCount: connect.NewClient[productv1.ResolveCategoryProductCountRequest, productv1.ResolveCategoryProductCountResponse]( + httpClient, + baseURL+ProductServiceResolveCategoryProductCountProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryProductCount")), + connect.WithClientOptions(opts...), + ), + resolveCategoryTopSubcategory: connect.NewClient[productv1.ResolveCategoryTopSubcategoryRequest, productv1.ResolveCategoryTopSubcategoryResponse]( + httpClient, + baseURL+ProductServiceResolveCategoryTopSubcategoryProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryTopSubcategory")), + connect.WithClientOptions(opts...), + ), + resolveCategoryTotalProducts: connect.NewClient[productv1.ResolveCategoryTotalProductsRequest, productv1.ResolveCategoryTotalProductsResponse]( + httpClient, + baseURL+ProductServiceResolveCategoryTotalProductsProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryTotalProducts")), + connect.WithClientOptions(opts...), + ), + resolveProductMascotRecommendation: connect.NewClient[productv1.ResolveProductMascotRecommendationRequest, productv1.ResolveProductMascotRecommendationResponse]( + httpClient, + baseURL+ProductServiceResolveProductMascotRecommendationProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveProductMascotRecommendation")), + connect.WithClientOptions(opts...), + ), + resolveProductProductDetails: connect.NewClient[productv1.ResolveProductProductDetailsRequest, productv1.ResolveProductProductDetailsResponse]( + httpClient, + baseURL+ProductServiceResolveProductProductDetailsProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveProductProductDetails")), + connect.WithClientOptions(opts...), + ), + resolveProductRecommendedCategory: connect.NewClient[productv1.ResolveProductRecommendedCategoryRequest, productv1.ResolveProductRecommendedCategoryResponse]( + httpClient, + baseURL+ProductServiceResolveProductRecommendedCategoryProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveProductRecommendedCategory")), + connect.WithClientOptions(opts...), + ), + resolveProductShippingEstimate: connect.NewClient[productv1.ResolveProductShippingEstimateRequest, productv1.ResolveProductShippingEstimateResponse]( + httpClient, + baseURL+ProductServiceResolveProductShippingEstimateProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveProductShippingEstimate")), + connect.WithClientOptions(opts...), + ), + resolveProductStockStatus: connect.NewClient[productv1.ResolveProductStockStatusRequest, productv1.ResolveProductStockStatusResponse]( + httpClient, + baseURL+ProductServiceResolveProductStockStatusProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveProductStockStatus")), + connect.WithClientOptions(opts...), + ), + resolveStorageLinkedStorages: connect.NewClient[productv1.ResolveStorageLinkedStoragesRequest, productv1.ResolveStorageLinkedStoragesResponse]( + httpClient, + baseURL+ProductServiceResolveStorageLinkedStoragesProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveStorageLinkedStorages")), + connect.WithClientOptions(opts...), + ), + resolveStorageNearbyStorages: connect.NewClient[productv1.ResolveStorageNearbyStoragesRequest, productv1.ResolveStorageNearbyStoragesResponse]( + httpClient, + baseURL+ProductServiceResolveStorageNearbyStoragesProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveStorageNearbyStorages")), + connect.WithClientOptions(opts...), + ), + resolveStorageStorageStatus: connect.NewClient[productv1.ResolveStorageStorageStatusRequest, productv1.ResolveStorageStorageStatusResponse]( + httpClient, + baseURL+ProductServiceResolveStorageStorageStatusProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveStorageStorageStatus")), + connect.WithClientOptions(opts...), + ), + resolveSubcategoryFeaturedCategory: connect.NewClient[productv1.ResolveSubcategoryFeaturedCategoryRequest, productv1.ResolveSubcategoryFeaturedCategoryResponse]( + httpClient, + baseURL+ProductServiceResolveSubcategoryFeaturedCategoryProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveSubcategoryFeaturedCategory")), + connect.WithClientOptions(opts...), + ), + resolveSubcategoryItemCount: connect.NewClient[productv1.ResolveSubcategoryItemCountRequest, productv1.ResolveSubcategoryItemCountResponse]( + httpClient, + baseURL+ProductServiceResolveSubcategoryItemCountProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveSubcategoryItemCount")), + connect.WithClientOptions(opts...), + ), + resolveSubcategoryParentCategory: connect.NewClient[productv1.ResolveSubcategoryParentCategoryRequest, productv1.ResolveSubcategoryParentCategoryResponse]( + httpClient, + baseURL+ProductServiceResolveSubcategoryParentCategoryProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveSubcategoryParentCategory")), + connect.WithClientOptions(opts...), + ), + resolveTestContainerDetails: connect.NewClient[productv1.ResolveTestContainerDetailsRequest, productv1.ResolveTestContainerDetailsResponse]( + httpClient, + baseURL+ProductServiceResolveTestContainerDetailsProcedure, + connect.WithSchema(productServiceMethods.ByName("ResolveTestContainerDetails")), + connect.WithClientOptions(opts...), + ), + } +} + +// productServiceClient implements ProductServiceClient. +type productServiceClient struct { + lookupProductById *connect.Client[productv1.LookupProductByIdRequest, productv1.LookupProductByIdResponse] + lookupStorageById *connect.Client[productv1.LookupStorageByIdRequest, productv1.LookupStorageByIdResponse] + lookupWarehouseById *connect.Client[productv1.LookupWarehouseByIdRequest, productv1.LookupWarehouseByIdResponse] + mutationBulkCreateAuthors *connect.Client[productv1.MutationBulkCreateAuthorsRequest, productv1.MutationBulkCreateAuthorsResponse] + mutationBulkCreateBlogPosts *connect.Client[productv1.MutationBulkCreateBlogPostsRequest, productv1.MutationBulkCreateBlogPostsResponse] + mutationBulkUpdateAuthors *connect.Client[productv1.MutationBulkUpdateAuthorsRequest, productv1.MutationBulkUpdateAuthorsResponse] + mutationBulkUpdateBlogPosts *connect.Client[productv1.MutationBulkUpdateBlogPostsRequest, productv1.MutationBulkUpdateBlogPostsResponse] + mutationCreateAuthor *connect.Client[productv1.MutationCreateAuthorRequest, productv1.MutationCreateAuthorResponse] + mutationCreateBlogPost *connect.Client[productv1.MutationCreateBlogPostRequest, productv1.MutationCreateBlogPostResponse] + mutationCreateNullableFieldsType *connect.Client[productv1.MutationCreateNullableFieldsTypeRequest, productv1.MutationCreateNullableFieldsTypeResponse] + mutationCreateUser *connect.Client[productv1.MutationCreateUserRequest, productv1.MutationCreateUserResponse] + mutationPerformAction *connect.Client[productv1.MutationPerformActionRequest, productv1.MutationPerformActionResponse] + mutationUpdateAuthor *connect.Client[productv1.MutationUpdateAuthorRequest, productv1.MutationUpdateAuthorResponse] + mutationUpdateBlogPost *connect.Client[productv1.MutationUpdateBlogPostRequest, productv1.MutationUpdateBlogPostResponse] + mutationUpdateNullableFieldsType *connect.Client[productv1.MutationUpdateNullableFieldsTypeRequest, productv1.MutationUpdateNullableFieldsTypeResponse] + queryAllAuthors *connect.Client[productv1.QueryAllAuthorsRequest, productv1.QueryAllAuthorsResponse] + queryAllBlogPosts *connect.Client[productv1.QueryAllBlogPostsRequest, productv1.QueryAllBlogPostsResponse] + queryAllNullableFieldsTypes *connect.Client[productv1.QueryAllNullableFieldsTypesRequest, productv1.QueryAllNullableFieldsTypesResponse] + queryAllPets *connect.Client[productv1.QueryAllPetsRequest, productv1.QueryAllPetsResponse] + queryAuthor *connect.Client[productv1.QueryAuthorRequest, productv1.QueryAuthorResponse] + queryAuthorById *connect.Client[productv1.QueryAuthorByIdRequest, productv1.QueryAuthorByIdResponse] + queryAuthorsWithFilter *connect.Client[productv1.QueryAuthorsWithFilterRequest, productv1.QueryAuthorsWithFilterResponse] + queryBlogPost *connect.Client[productv1.QueryBlogPostRequest, productv1.QueryBlogPostResponse] + queryBlogPostById *connect.Client[productv1.QueryBlogPostByIdRequest, productv1.QueryBlogPostByIdResponse] + queryBlogPostsWithFilter *connect.Client[productv1.QueryBlogPostsWithFilterRequest, productv1.QueryBlogPostsWithFilterResponse] + queryBulkSearchAuthors *connect.Client[productv1.QueryBulkSearchAuthorsRequest, productv1.QueryBulkSearchAuthorsResponse] + queryBulkSearchBlogPosts *connect.Client[productv1.QueryBulkSearchBlogPostsRequest, productv1.QueryBulkSearchBlogPostsResponse] + queryCalculateTotals *connect.Client[productv1.QueryCalculateTotalsRequest, productv1.QueryCalculateTotalsResponse] + queryCategories *connect.Client[productv1.QueryCategoriesRequest, productv1.QueryCategoriesResponse] + queryCategoriesByKind *connect.Client[productv1.QueryCategoriesByKindRequest, productv1.QueryCategoriesByKindResponse] + queryCategoriesByKinds *connect.Client[productv1.QueryCategoriesByKindsRequest, productv1.QueryCategoriesByKindsResponse] + queryCategory *connect.Client[productv1.QueryCategoryRequest, productv1.QueryCategoryResponse] + queryComplexFilterType *connect.Client[productv1.QueryComplexFilterTypeRequest, productv1.QueryComplexFilterTypeResponse] + queryConditionalSearch *connect.Client[productv1.QueryConditionalSearchRequest, productv1.QueryConditionalSearchResponse] + queryFilterCategories *connect.Client[productv1.QueryFilterCategoriesRequest, productv1.QueryFilterCategoriesResponse] + queryNestedType *connect.Client[productv1.QueryNestedTypeRequest, productv1.QueryNestedTypeResponse] + queryNullableFieldsType *connect.Client[productv1.QueryNullableFieldsTypeRequest, productv1.QueryNullableFieldsTypeResponse] + queryNullableFieldsTypeById *connect.Client[productv1.QueryNullableFieldsTypeByIdRequest, productv1.QueryNullableFieldsTypeByIdResponse] + queryNullableFieldsTypeWithFilter *connect.Client[productv1.QueryNullableFieldsTypeWithFilterRequest, productv1.QueryNullableFieldsTypeWithFilterResponse] + queryRandomPet *connect.Client[productv1.QueryRandomPetRequest, productv1.QueryRandomPetResponse] + queryRandomSearchResult *connect.Client[productv1.QueryRandomSearchResultRequest, productv1.QueryRandomSearchResultResponse] + queryRecursiveType *connect.Client[productv1.QueryRecursiveTypeRequest, productv1.QueryRecursiveTypeResponse] + querySearch *connect.Client[productv1.QuerySearchRequest, productv1.QuerySearchResponse] + queryTestContainer *connect.Client[productv1.QueryTestContainerRequest, productv1.QueryTestContainerResponse] + queryTestContainers *connect.Client[productv1.QueryTestContainersRequest, productv1.QueryTestContainersResponse] + queryTypeFilterWithArguments *connect.Client[productv1.QueryTypeFilterWithArgumentsRequest, productv1.QueryTypeFilterWithArgumentsResponse] + queryTypeWithMultipleFilterFields *connect.Client[productv1.QueryTypeWithMultipleFilterFieldsRequest, productv1.QueryTypeWithMultipleFilterFieldsResponse] + queryUser *connect.Client[productv1.QueryUserRequest, productv1.QueryUserResponse] + queryUsers *connect.Client[productv1.QueryUsersRequest, productv1.QueryUsersResponse] + requireStorageCategoryInfoSummaryById *connect.Client[productv1.RequireStorageCategoryInfoSummaryByIdRequest, productv1.RequireStorageCategoryInfoSummaryByIdResponse] + requireStorageDeepItemInfoById *connect.Client[productv1.RequireStorageDeepItemInfoByIdRequest, productv1.RequireStorageDeepItemInfoByIdResponse] + requireStorageFilteredTagSummaryById *connect.Client[productv1.RequireStorageFilteredTagSummaryByIdRequest, productv1.RequireStorageFilteredTagSummaryByIdResponse] + requireStorageItemHandlerInfoById *connect.Client[productv1.RequireStorageItemHandlerInfoByIdRequest, productv1.RequireStorageItemHandlerInfoByIdResponse] + requireStorageItemInfoById *connect.Client[productv1.RequireStorageItemInfoByIdRequest, productv1.RequireStorageItemInfoByIdResponse] + requireStorageItemSpecsInfoById *connect.Client[productv1.RequireStorageItemSpecsInfoByIdRequest, productv1.RequireStorageItemSpecsInfoByIdResponse] + requireStorageKindSummaryById *connect.Client[productv1.RequireStorageKindSummaryByIdRequest, productv1.RequireStorageKindSummaryByIdResponse] + requireStorageMetadataScoreById *connect.Client[productv1.RequireStorageMetadataScoreByIdRequest, productv1.RequireStorageMetadataScoreByIdResponse] + requireStorageMultiFilteredTagSummaryById *connect.Client[productv1.RequireStorageMultiFilteredTagSummaryByIdRequest, productv1.RequireStorageMultiFilteredTagSummaryByIdResponse] + requireStorageNullableFilteredTagSummaryById *connect.Client[productv1.RequireStorageNullableFilteredTagSummaryByIdRequest, productv1.RequireStorageNullableFilteredTagSummaryByIdResponse] + requireStorageOperationReportById *connect.Client[productv1.RequireStorageOperationReportByIdRequest, productv1.RequireStorageOperationReportByIdResponse] + requireStorageOptionalProcessedMetadataById *connect.Client[productv1.RequireStorageOptionalProcessedMetadataByIdRequest, productv1.RequireStorageOptionalProcessedMetadataByIdResponse] + requireStorageOptionalProcessedTagsById *connect.Client[productv1.RequireStorageOptionalProcessedTagsByIdRequest, productv1.RequireStorageOptionalProcessedTagsByIdResponse] + requireStorageOptionalTagSummaryById *connect.Client[productv1.RequireStorageOptionalTagSummaryByIdRequest, productv1.RequireStorageOptionalTagSummaryByIdResponse] + requireStorageProcessedMetadataById *connect.Client[productv1.RequireStorageProcessedMetadataByIdRequest, productv1.RequireStorageProcessedMetadataByIdResponse] + requireStorageProcessedMetadataHistoryById *connect.Client[productv1.RequireStorageProcessedMetadataHistoryByIdRequest, productv1.RequireStorageProcessedMetadataHistoryByIdResponse] + requireStorageProcessedTagsById *connect.Client[productv1.RequireStorageProcessedTagsByIdRequest, productv1.RequireStorageProcessedTagsByIdResponse] + requireStorageSecuritySummaryById *connect.Client[productv1.RequireStorageSecuritySummaryByIdRequest, productv1.RequireStorageSecuritySummaryByIdResponse] + requireStorageStockHealthScoreById *connect.Client[productv1.RequireStorageStockHealthScoreByIdRequest, productv1.RequireStorageStockHealthScoreByIdResponse] + requireStorageTagSummaryById *connect.Client[productv1.RequireStorageTagSummaryByIdRequest, productv1.RequireStorageTagSummaryByIdResponse] + requireWarehouseStockHealthScoreById *connect.Client[productv1.RequireWarehouseStockHealthScoreByIdRequest, productv1.RequireWarehouseStockHealthScoreByIdResponse] + resolveCategoryActiveSubcategories *connect.Client[productv1.ResolveCategoryActiveSubcategoriesRequest, productv1.ResolveCategoryActiveSubcategoriesResponse] + resolveCategoryCategoryMetrics *connect.Client[productv1.ResolveCategoryCategoryMetricsRequest, productv1.ResolveCategoryCategoryMetricsResponse] + resolveCategoryCategoryStatus *connect.Client[productv1.ResolveCategoryCategoryStatusRequest, productv1.ResolveCategoryCategoryStatusResponse] + resolveCategoryChildCategories *connect.Client[productv1.ResolveCategoryChildCategoriesRequest, productv1.ResolveCategoryChildCategoriesResponse] + resolveCategoryMascot *connect.Client[productv1.ResolveCategoryMascotRequest, productv1.ResolveCategoryMascotResponse] + resolveCategoryMetricsAverageScore *connect.Client[productv1.ResolveCategoryMetricsAverageScoreRequest, productv1.ResolveCategoryMetricsAverageScoreResponse] + resolveCategoryMetricsNormalizedScore *connect.Client[productv1.ResolveCategoryMetricsNormalizedScoreRequest, productv1.ResolveCategoryMetricsNormalizedScoreResponse] + resolveCategoryMetricsRelatedCategory *connect.Client[productv1.ResolveCategoryMetricsRelatedCategoryRequest, productv1.ResolveCategoryMetricsRelatedCategoryResponse] + resolveCategoryOptionalCategories *connect.Client[productv1.ResolveCategoryOptionalCategoriesRequest, productv1.ResolveCategoryOptionalCategoriesResponse] + resolveCategoryPopularityScore *connect.Client[productv1.ResolveCategoryPopularityScoreRequest, productv1.ResolveCategoryPopularityScoreResponse] + resolveCategoryProductCount *connect.Client[productv1.ResolveCategoryProductCountRequest, productv1.ResolveCategoryProductCountResponse] + resolveCategoryTopSubcategory *connect.Client[productv1.ResolveCategoryTopSubcategoryRequest, productv1.ResolveCategoryTopSubcategoryResponse] + resolveCategoryTotalProducts *connect.Client[productv1.ResolveCategoryTotalProductsRequest, productv1.ResolveCategoryTotalProductsResponse] + resolveProductMascotRecommendation *connect.Client[productv1.ResolveProductMascotRecommendationRequest, productv1.ResolveProductMascotRecommendationResponse] + resolveProductProductDetails *connect.Client[productv1.ResolveProductProductDetailsRequest, productv1.ResolveProductProductDetailsResponse] + resolveProductRecommendedCategory *connect.Client[productv1.ResolveProductRecommendedCategoryRequest, productv1.ResolveProductRecommendedCategoryResponse] + resolveProductShippingEstimate *connect.Client[productv1.ResolveProductShippingEstimateRequest, productv1.ResolveProductShippingEstimateResponse] + resolveProductStockStatus *connect.Client[productv1.ResolveProductStockStatusRequest, productv1.ResolveProductStockStatusResponse] + resolveStorageLinkedStorages *connect.Client[productv1.ResolveStorageLinkedStoragesRequest, productv1.ResolveStorageLinkedStoragesResponse] + resolveStorageNearbyStorages *connect.Client[productv1.ResolveStorageNearbyStoragesRequest, productv1.ResolveStorageNearbyStoragesResponse] + resolveStorageStorageStatus *connect.Client[productv1.ResolveStorageStorageStatusRequest, productv1.ResolveStorageStorageStatusResponse] + resolveSubcategoryFeaturedCategory *connect.Client[productv1.ResolveSubcategoryFeaturedCategoryRequest, productv1.ResolveSubcategoryFeaturedCategoryResponse] + resolveSubcategoryItemCount *connect.Client[productv1.ResolveSubcategoryItemCountRequest, productv1.ResolveSubcategoryItemCountResponse] + resolveSubcategoryParentCategory *connect.Client[productv1.ResolveSubcategoryParentCategoryRequest, productv1.ResolveSubcategoryParentCategoryResponse] + resolveTestContainerDetails *connect.Client[productv1.ResolveTestContainerDetailsRequest, productv1.ResolveTestContainerDetailsResponse] +} + +// LookupProductById calls productv1.ProductService.LookupProductById. +func (c *productServiceClient) LookupProductById(ctx context.Context, req *connect.Request[productv1.LookupProductByIdRequest]) (*connect.Response[productv1.LookupProductByIdResponse], error) { + return c.lookupProductById.CallUnary(ctx, req) +} + +// LookupStorageById calls productv1.ProductService.LookupStorageById. +func (c *productServiceClient) LookupStorageById(ctx context.Context, req *connect.Request[productv1.LookupStorageByIdRequest]) (*connect.Response[productv1.LookupStorageByIdResponse], error) { + return c.lookupStorageById.CallUnary(ctx, req) +} + +// LookupWarehouseById calls productv1.ProductService.LookupWarehouseById. +func (c *productServiceClient) LookupWarehouseById(ctx context.Context, req *connect.Request[productv1.LookupWarehouseByIdRequest]) (*connect.Response[productv1.LookupWarehouseByIdResponse], error) { + return c.lookupWarehouseById.CallUnary(ctx, req) +} + +// MutationBulkCreateAuthors calls productv1.ProductService.MutationBulkCreateAuthors. +func (c *productServiceClient) MutationBulkCreateAuthors(ctx context.Context, req *connect.Request[productv1.MutationBulkCreateAuthorsRequest]) (*connect.Response[productv1.MutationBulkCreateAuthorsResponse], error) { + return c.mutationBulkCreateAuthors.CallUnary(ctx, req) +} + +// MutationBulkCreateBlogPosts calls productv1.ProductService.MutationBulkCreateBlogPosts. +func (c *productServiceClient) MutationBulkCreateBlogPosts(ctx context.Context, req *connect.Request[productv1.MutationBulkCreateBlogPostsRequest]) (*connect.Response[productv1.MutationBulkCreateBlogPostsResponse], error) { + return c.mutationBulkCreateBlogPosts.CallUnary(ctx, req) +} + +// MutationBulkUpdateAuthors calls productv1.ProductService.MutationBulkUpdateAuthors. +func (c *productServiceClient) MutationBulkUpdateAuthors(ctx context.Context, req *connect.Request[productv1.MutationBulkUpdateAuthorsRequest]) (*connect.Response[productv1.MutationBulkUpdateAuthorsResponse], error) { + return c.mutationBulkUpdateAuthors.CallUnary(ctx, req) +} + +// MutationBulkUpdateBlogPosts calls productv1.ProductService.MutationBulkUpdateBlogPosts. +func (c *productServiceClient) MutationBulkUpdateBlogPosts(ctx context.Context, req *connect.Request[productv1.MutationBulkUpdateBlogPostsRequest]) (*connect.Response[productv1.MutationBulkUpdateBlogPostsResponse], error) { + return c.mutationBulkUpdateBlogPosts.CallUnary(ctx, req) +} + +// MutationCreateAuthor calls productv1.ProductService.MutationCreateAuthor. +func (c *productServiceClient) MutationCreateAuthor(ctx context.Context, req *connect.Request[productv1.MutationCreateAuthorRequest]) (*connect.Response[productv1.MutationCreateAuthorResponse], error) { + return c.mutationCreateAuthor.CallUnary(ctx, req) +} + +// MutationCreateBlogPost calls productv1.ProductService.MutationCreateBlogPost. +func (c *productServiceClient) MutationCreateBlogPost(ctx context.Context, req *connect.Request[productv1.MutationCreateBlogPostRequest]) (*connect.Response[productv1.MutationCreateBlogPostResponse], error) { + return c.mutationCreateBlogPost.CallUnary(ctx, req) +} + +// MutationCreateNullableFieldsType calls productv1.ProductService.MutationCreateNullableFieldsType. +func (c *productServiceClient) MutationCreateNullableFieldsType(ctx context.Context, req *connect.Request[productv1.MutationCreateNullableFieldsTypeRequest]) (*connect.Response[productv1.MutationCreateNullableFieldsTypeResponse], error) { + return c.mutationCreateNullableFieldsType.CallUnary(ctx, req) +} + +// MutationCreateUser calls productv1.ProductService.MutationCreateUser. +func (c *productServiceClient) MutationCreateUser(ctx context.Context, req *connect.Request[productv1.MutationCreateUserRequest]) (*connect.Response[productv1.MutationCreateUserResponse], error) { + return c.mutationCreateUser.CallUnary(ctx, req) +} + +// MutationPerformAction calls productv1.ProductService.MutationPerformAction. +func (c *productServiceClient) MutationPerformAction(ctx context.Context, req *connect.Request[productv1.MutationPerformActionRequest]) (*connect.Response[productv1.MutationPerformActionResponse], error) { + return c.mutationPerformAction.CallUnary(ctx, req) +} + +// MutationUpdateAuthor calls productv1.ProductService.MutationUpdateAuthor. +func (c *productServiceClient) MutationUpdateAuthor(ctx context.Context, req *connect.Request[productv1.MutationUpdateAuthorRequest]) (*connect.Response[productv1.MutationUpdateAuthorResponse], error) { + return c.mutationUpdateAuthor.CallUnary(ctx, req) +} + +// MutationUpdateBlogPost calls productv1.ProductService.MutationUpdateBlogPost. +func (c *productServiceClient) MutationUpdateBlogPost(ctx context.Context, req *connect.Request[productv1.MutationUpdateBlogPostRequest]) (*connect.Response[productv1.MutationUpdateBlogPostResponse], error) { + return c.mutationUpdateBlogPost.CallUnary(ctx, req) +} + +// MutationUpdateNullableFieldsType calls productv1.ProductService.MutationUpdateNullableFieldsType. +func (c *productServiceClient) MutationUpdateNullableFieldsType(ctx context.Context, req *connect.Request[productv1.MutationUpdateNullableFieldsTypeRequest]) (*connect.Response[productv1.MutationUpdateNullableFieldsTypeResponse], error) { + return c.mutationUpdateNullableFieldsType.CallUnary(ctx, req) +} + +// QueryAllAuthors calls productv1.ProductService.QueryAllAuthors. +func (c *productServiceClient) QueryAllAuthors(ctx context.Context, req *connect.Request[productv1.QueryAllAuthorsRequest]) (*connect.Response[productv1.QueryAllAuthorsResponse], error) { + return c.queryAllAuthors.CallUnary(ctx, req) +} + +// QueryAllBlogPosts calls productv1.ProductService.QueryAllBlogPosts. +func (c *productServiceClient) QueryAllBlogPosts(ctx context.Context, req *connect.Request[productv1.QueryAllBlogPostsRequest]) (*connect.Response[productv1.QueryAllBlogPostsResponse], error) { + return c.queryAllBlogPosts.CallUnary(ctx, req) +} + +// QueryAllNullableFieldsTypes calls productv1.ProductService.QueryAllNullableFieldsTypes. +func (c *productServiceClient) QueryAllNullableFieldsTypes(ctx context.Context, req *connect.Request[productv1.QueryAllNullableFieldsTypesRequest]) (*connect.Response[productv1.QueryAllNullableFieldsTypesResponse], error) { + return c.queryAllNullableFieldsTypes.CallUnary(ctx, req) +} + +// QueryAllPets calls productv1.ProductService.QueryAllPets. +func (c *productServiceClient) QueryAllPets(ctx context.Context, req *connect.Request[productv1.QueryAllPetsRequest]) (*connect.Response[productv1.QueryAllPetsResponse], error) { + return c.queryAllPets.CallUnary(ctx, req) +} + +// QueryAuthor calls productv1.ProductService.QueryAuthor. +func (c *productServiceClient) QueryAuthor(ctx context.Context, req *connect.Request[productv1.QueryAuthorRequest]) (*connect.Response[productv1.QueryAuthorResponse], error) { + return c.queryAuthor.CallUnary(ctx, req) +} + +// QueryAuthorById calls productv1.ProductService.QueryAuthorById. +func (c *productServiceClient) QueryAuthorById(ctx context.Context, req *connect.Request[productv1.QueryAuthorByIdRequest]) (*connect.Response[productv1.QueryAuthorByIdResponse], error) { + return c.queryAuthorById.CallUnary(ctx, req) +} + +// QueryAuthorsWithFilter calls productv1.ProductService.QueryAuthorsWithFilter. +func (c *productServiceClient) QueryAuthorsWithFilter(ctx context.Context, req *connect.Request[productv1.QueryAuthorsWithFilterRequest]) (*connect.Response[productv1.QueryAuthorsWithFilterResponse], error) { + return c.queryAuthorsWithFilter.CallUnary(ctx, req) +} + +// QueryBlogPost calls productv1.ProductService.QueryBlogPost. +func (c *productServiceClient) QueryBlogPost(ctx context.Context, req *connect.Request[productv1.QueryBlogPostRequest]) (*connect.Response[productv1.QueryBlogPostResponse], error) { + return c.queryBlogPost.CallUnary(ctx, req) +} + +// QueryBlogPostById calls productv1.ProductService.QueryBlogPostById. +func (c *productServiceClient) QueryBlogPostById(ctx context.Context, req *connect.Request[productv1.QueryBlogPostByIdRequest]) (*connect.Response[productv1.QueryBlogPostByIdResponse], error) { + return c.queryBlogPostById.CallUnary(ctx, req) +} + +// QueryBlogPostsWithFilter calls productv1.ProductService.QueryBlogPostsWithFilter. +func (c *productServiceClient) QueryBlogPostsWithFilter(ctx context.Context, req *connect.Request[productv1.QueryBlogPostsWithFilterRequest]) (*connect.Response[productv1.QueryBlogPostsWithFilterResponse], error) { + return c.queryBlogPostsWithFilter.CallUnary(ctx, req) +} + +// QueryBulkSearchAuthors calls productv1.ProductService.QueryBulkSearchAuthors. +func (c *productServiceClient) QueryBulkSearchAuthors(ctx context.Context, req *connect.Request[productv1.QueryBulkSearchAuthorsRequest]) (*connect.Response[productv1.QueryBulkSearchAuthorsResponse], error) { + return c.queryBulkSearchAuthors.CallUnary(ctx, req) +} + +// QueryBulkSearchBlogPosts calls productv1.ProductService.QueryBulkSearchBlogPosts. +func (c *productServiceClient) QueryBulkSearchBlogPosts(ctx context.Context, req *connect.Request[productv1.QueryBulkSearchBlogPostsRequest]) (*connect.Response[productv1.QueryBulkSearchBlogPostsResponse], error) { + return c.queryBulkSearchBlogPosts.CallUnary(ctx, req) +} + +// QueryCalculateTotals calls productv1.ProductService.QueryCalculateTotals. +func (c *productServiceClient) QueryCalculateTotals(ctx context.Context, req *connect.Request[productv1.QueryCalculateTotalsRequest]) (*connect.Response[productv1.QueryCalculateTotalsResponse], error) { + return c.queryCalculateTotals.CallUnary(ctx, req) +} + +// QueryCategories calls productv1.ProductService.QueryCategories. +func (c *productServiceClient) QueryCategories(ctx context.Context, req *connect.Request[productv1.QueryCategoriesRequest]) (*connect.Response[productv1.QueryCategoriesResponse], error) { + return c.queryCategories.CallUnary(ctx, req) +} + +// QueryCategoriesByKind calls productv1.ProductService.QueryCategoriesByKind. +func (c *productServiceClient) QueryCategoriesByKind(ctx context.Context, req *connect.Request[productv1.QueryCategoriesByKindRequest]) (*connect.Response[productv1.QueryCategoriesByKindResponse], error) { + return c.queryCategoriesByKind.CallUnary(ctx, req) +} + +// QueryCategoriesByKinds calls productv1.ProductService.QueryCategoriesByKinds. +func (c *productServiceClient) QueryCategoriesByKinds(ctx context.Context, req *connect.Request[productv1.QueryCategoriesByKindsRequest]) (*connect.Response[productv1.QueryCategoriesByKindsResponse], error) { + return c.queryCategoriesByKinds.CallUnary(ctx, req) +} + +// QueryCategory calls productv1.ProductService.QueryCategory. +func (c *productServiceClient) QueryCategory(ctx context.Context, req *connect.Request[productv1.QueryCategoryRequest]) (*connect.Response[productv1.QueryCategoryResponse], error) { + return c.queryCategory.CallUnary(ctx, req) +} + +// QueryComplexFilterType calls productv1.ProductService.QueryComplexFilterType. +func (c *productServiceClient) QueryComplexFilterType(ctx context.Context, req *connect.Request[productv1.QueryComplexFilterTypeRequest]) (*connect.Response[productv1.QueryComplexFilterTypeResponse], error) { + return c.queryComplexFilterType.CallUnary(ctx, req) +} + +// QueryConditionalSearch calls productv1.ProductService.QueryConditionalSearch. +func (c *productServiceClient) QueryConditionalSearch(ctx context.Context, req *connect.Request[productv1.QueryConditionalSearchRequest]) (*connect.Response[productv1.QueryConditionalSearchResponse], error) { + return c.queryConditionalSearch.CallUnary(ctx, req) +} + +// QueryFilterCategories calls productv1.ProductService.QueryFilterCategories. +func (c *productServiceClient) QueryFilterCategories(ctx context.Context, req *connect.Request[productv1.QueryFilterCategoriesRequest]) (*connect.Response[productv1.QueryFilterCategoriesResponse], error) { + return c.queryFilterCategories.CallUnary(ctx, req) +} + +// QueryNestedType calls productv1.ProductService.QueryNestedType. +func (c *productServiceClient) QueryNestedType(ctx context.Context, req *connect.Request[productv1.QueryNestedTypeRequest]) (*connect.Response[productv1.QueryNestedTypeResponse], error) { + return c.queryNestedType.CallUnary(ctx, req) +} + +// QueryNullableFieldsType calls productv1.ProductService.QueryNullableFieldsType. +func (c *productServiceClient) QueryNullableFieldsType(ctx context.Context, req *connect.Request[productv1.QueryNullableFieldsTypeRequest]) (*connect.Response[productv1.QueryNullableFieldsTypeResponse], error) { + return c.queryNullableFieldsType.CallUnary(ctx, req) +} + +// QueryNullableFieldsTypeById calls productv1.ProductService.QueryNullableFieldsTypeById. +func (c *productServiceClient) QueryNullableFieldsTypeById(ctx context.Context, req *connect.Request[productv1.QueryNullableFieldsTypeByIdRequest]) (*connect.Response[productv1.QueryNullableFieldsTypeByIdResponse], error) { + return c.queryNullableFieldsTypeById.CallUnary(ctx, req) +} + +// QueryNullableFieldsTypeWithFilter calls +// productv1.ProductService.QueryNullableFieldsTypeWithFilter. +func (c *productServiceClient) QueryNullableFieldsTypeWithFilter(ctx context.Context, req *connect.Request[productv1.QueryNullableFieldsTypeWithFilterRequest]) (*connect.Response[productv1.QueryNullableFieldsTypeWithFilterResponse], error) { + return c.queryNullableFieldsTypeWithFilter.CallUnary(ctx, req) +} + +// QueryRandomPet calls productv1.ProductService.QueryRandomPet. +func (c *productServiceClient) QueryRandomPet(ctx context.Context, req *connect.Request[productv1.QueryRandomPetRequest]) (*connect.Response[productv1.QueryRandomPetResponse], error) { + return c.queryRandomPet.CallUnary(ctx, req) +} + +// QueryRandomSearchResult calls productv1.ProductService.QueryRandomSearchResult. +func (c *productServiceClient) QueryRandomSearchResult(ctx context.Context, req *connect.Request[productv1.QueryRandomSearchResultRequest]) (*connect.Response[productv1.QueryRandomSearchResultResponse], error) { + return c.queryRandomSearchResult.CallUnary(ctx, req) +} + +// QueryRecursiveType calls productv1.ProductService.QueryRecursiveType. +func (c *productServiceClient) QueryRecursiveType(ctx context.Context, req *connect.Request[productv1.QueryRecursiveTypeRequest]) (*connect.Response[productv1.QueryRecursiveTypeResponse], error) { + return c.queryRecursiveType.CallUnary(ctx, req) +} + +// QuerySearch calls productv1.ProductService.QuerySearch. +func (c *productServiceClient) QuerySearch(ctx context.Context, req *connect.Request[productv1.QuerySearchRequest]) (*connect.Response[productv1.QuerySearchResponse], error) { + return c.querySearch.CallUnary(ctx, req) +} + +// QueryTestContainer calls productv1.ProductService.QueryTestContainer. +func (c *productServiceClient) QueryTestContainer(ctx context.Context, req *connect.Request[productv1.QueryTestContainerRequest]) (*connect.Response[productv1.QueryTestContainerResponse], error) { + return c.queryTestContainer.CallUnary(ctx, req) +} + +// QueryTestContainers calls productv1.ProductService.QueryTestContainers. +func (c *productServiceClient) QueryTestContainers(ctx context.Context, req *connect.Request[productv1.QueryTestContainersRequest]) (*connect.Response[productv1.QueryTestContainersResponse], error) { + return c.queryTestContainers.CallUnary(ctx, req) +} + +// QueryTypeFilterWithArguments calls productv1.ProductService.QueryTypeFilterWithArguments. +func (c *productServiceClient) QueryTypeFilterWithArguments(ctx context.Context, req *connect.Request[productv1.QueryTypeFilterWithArgumentsRequest]) (*connect.Response[productv1.QueryTypeFilterWithArgumentsResponse], error) { + return c.queryTypeFilterWithArguments.CallUnary(ctx, req) +} + +// QueryTypeWithMultipleFilterFields calls +// productv1.ProductService.QueryTypeWithMultipleFilterFields. +func (c *productServiceClient) QueryTypeWithMultipleFilterFields(ctx context.Context, req *connect.Request[productv1.QueryTypeWithMultipleFilterFieldsRequest]) (*connect.Response[productv1.QueryTypeWithMultipleFilterFieldsResponse], error) { + return c.queryTypeWithMultipleFilterFields.CallUnary(ctx, req) +} + +// QueryUser calls productv1.ProductService.QueryUser. +func (c *productServiceClient) QueryUser(ctx context.Context, req *connect.Request[productv1.QueryUserRequest]) (*connect.Response[productv1.QueryUserResponse], error) { + return c.queryUser.CallUnary(ctx, req) +} + +// QueryUsers calls productv1.ProductService.QueryUsers. +func (c *productServiceClient) QueryUsers(ctx context.Context, req *connect.Request[productv1.QueryUsersRequest]) (*connect.Response[productv1.QueryUsersResponse], error) { + return c.queryUsers.CallUnary(ctx, req) +} + +// RequireStorageCategoryInfoSummaryById calls +// productv1.ProductService.RequireStorageCategoryInfoSummaryById. +func (c *productServiceClient) RequireStorageCategoryInfoSummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageCategoryInfoSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageCategoryInfoSummaryByIdResponse], error) { + return c.requireStorageCategoryInfoSummaryById.CallUnary(ctx, req) +} + +// RequireStorageDeepItemInfoById calls productv1.ProductService.RequireStorageDeepItemInfoById. +func (c *productServiceClient) RequireStorageDeepItemInfoById(ctx context.Context, req *connect.Request[productv1.RequireStorageDeepItemInfoByIdRequest]) (*connect.Response[productv1.RequireStorageDeepItemInfoByIdResponse], error) { + return c.requireStorageDeepItemInfoById.CallUnary(ctx, req) +} + +// RequireStorageFilteredTagSummaryById calls +// productv1.ProductService.RequireStorageFilteredTagSummaryById. +func (c *productServiceClient) RequireStorageFilteredTagSummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageFilteredTagSummaryByIdResponse], error) { + return c.requireStorageFilteredTagSummaryById.CallUnary(ctx, req) +} + +// RequireStorageItemHandlerInfoById calls +// productv1.ProductService.RequireStorageItemHandlerInfoById. +func (c *productServiceClient) RequireStorageItemHandlerInfoById(ctx context.Context, req *connect.Request[productv1.RequireStorageItemHandlerInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemHandlerInfoByIdResponse], error) { + return c.requireStorageItemHandlerInfoById.CallUnary(ctx, req) +} + +// RequireStorageItemInfoById calls productv1.ProductService.RequireStorageItemInfoById. +func (c *productServiceClient) RequireStorageItemInfoById(ctx context.Context, req *connect.Request[productv1.RequireStorageItemInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemInfoByIdResponse], error) { + return c.requireStorageItemInfoById.CallUnary(ctx, req) +} + +// RequireStorageItemSpecsInfoById calls productv1.ProductService.RequireStorageItemSpecsInfoById. +func (c *productServiceClient) RequireStorageItemSpecsInfoById(ctx context.Context, req *connect.Request[productv1.RequireStorageItemSpecsInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemSpecsInfoByIdResponse], error) { + return c.requireStorageItemSpecsInfoById.CallUnary(ctx, req) +} + +// RequireStorageKindSummaryById calls productv1.ProductService.RequireStorageKindSummaryById. +func (c *productServiceClient) RequireStorageKindSummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageKindSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageKindSummaryByIdResponse], error) { + return c.requireStorageKindSummaryById.CallUnary(ctx, req) +} + +// RequireStorageMetadataScoreById calls productv1.ProductService.RequireStorageMetadataScoreById. +func (c *productServiceClient) RequireStorageMetadataScoreById(ctx context.Context, req *connect.Request[productv1.RequireStorageMetadataScoreByIdRequest]) (*connect.Response[productv1.RequireStorageMetadataScoreByIdResponse], error) { + return c.requireStorageMetadataScoreById.CallUnary(ctx, req) +} + +// RequireStorageMultiFilteredTagSummaryById calls +// productv1.ProductService.RequireStorageMultiFilteredTagSummaryById. +func (c *productServiceClient) RequireStorageMultiFilteredTagSummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageMultiFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageMultiFilteredTagSummaryByIdResponse], error) { + return c.requireStorageMultiFilteredTagSummaryById.CallUnary(ctx, req) +} + +// RequireStorageNullableFilteredTagSummaryById calls +// productv1.ProductService.RequireStorageNullableFilteredTagSummaryById. +func (c *productServiceClient) RequireStorageNullableFilteredTagSummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageNullableFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageNullableFilteredTagSummaryByIdResponse], error) { + return c.requireStorageNullableFilteredTagSummaryById.CallUnary(ctx, req) +} + +// RequireStorageOperationReportById calls +// productv1.ProductService.RequireStorageOperationReportById. +func (c *productServiceClient) RequireStorageOperationReportById(ctx context.Context, req *connect.Request[productv1.RequireStorageOperationReportByIdRequest]) (*connect.Response[productv1.RequireStorageOperationReportByIdResponse], error) { + return c.requireStorageOperationReportById.CallUnary(ctx, req) +} + +// RequireStorageOptionalProcessedMetadataById calls +// productv1.ProductService.RequireStorageOptionalProcessedMetadataById. +func (c *productServiceClient) RequireStorageOptionalProcessedMetadataById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataByIdResponse], error) { + return c.requireStorageOptionalProcessedMetadataById.CallUnary(ctx, req) +} + +// RequireStorageOptionalProcessedTagsById calls +// productv1.ProductService.RequireStorageOptionalProcessedTagsById. +func (c *productServiceClient) RequireStorageOptionalProcessedTagsById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedTagsByIdResponse], error) { + return c.requireStorageOptionalProcessedTagsById.CallUnary(ctx, req) +} + +// RequireStorageOptionalTagSummaryById calls +// productv1.ProductService.RequireStorageOptionalTagSummaryById. +func (c *productServiceClient) RequireStorageOptionalTagSummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageOptionalTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalTagSummaryByIdResponse], error) { + return c.requireStorageOptionalTagSummaryById.CallUnary(ctx, req) +} + +// RequireStorageProcessedMetadataById calls +// productv1.ProductService.RequireStorageProcessedMetadataById. +func (c *productServiceClient) RequireStorageProcessedMetadataById(ctx context.Context, req *connect.Request[productv1.RequireStorageProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedMetadataByIdResponse], error) { + return c.requireStorageProcessedMetadataById.CallUnary(ctx, req) +} + +// RequireStorageProcessedMetadataHistoryById calls +// productv1.ProductService.RequireStorageProcessedMetadataHistoryById. +func (c *productServiceClient) RequireStorageProcessedMetadataHistoryById(ctx context.Context, req *connect.Request[productv1.RequireStorageProcessedMetadataHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedMetadataHistoryByIdResponse], error) { + return c.requireStorageProcessedMetadataHistoryById.CallUnary(ctx, req) +} + +// RequireStorageProcessedTagsById calls productv1.ProductService.RequireStorageProcessedTagsById. +func (c *productServiceClient) RequireStorageProcessedTagsById(ctx context.Context, req *connect.Request[productv1.RequireStorageProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedTagsByIdResponse], error) { + return c.requireStorageProcessedTagsById.CallUnary(ctx, req) +} + +// RequireStorageSecuritySummaryById calls +// productv1.ProductService.RequireStorageSecuritySummaryById. +func (c *productServiceClient) RequireStorageSecuritySummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageSecuritySummaryByIdRequest]) (*connect.Response[productv1.RequireStorageSecuritySummaryByIdResponse], error) { + return c.requireStorageSecuritySummaryById.CallUnary(ctx, req) +} + +// RequireStorageStockHealthScoreById calls +// productv1.ProductService.RequireStorageStockHealthScoreById. +func (c *productServiceClient) RequireStorageStockHealthScoreById(ctx context.Context, req *connect.Request[productv1.RequireStorageStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireStorageStockHealthScoreByIdResponse], error) { + return c.requireStorageStockHealthScoreById.CallUnary(ctx, req) +} + +// RequireStorageTagSummaryById calls productv1.ProductService.RequireStorageTagSummaryById. +func (c *productServiceClient) RequireStorageTagSummaryById(ctx context.Context, req *connect.Request[productv1.RequireStorageTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageTagSummaryByIdResponse], error) { + return c.requireStorageTagSummaryById.CallUnary(ctx, req) +} + +// RequireWarehouseStockHealthScoreById calls +// productv1.ProductService.RequireWarehouseStockHealthScoreById. +func (c *productServiceClient) RequireWarehouseStockHealthScoreById(ctx context.Context, req *connect.Request[productv1.RequireWarehouseStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireWarehouseStockHealthScoreByIdResponse], error) { + return c.requireWarehouseStockHealthScoreById.CallUnary(ctx, req) +} + +// ResolveCategoryActiveSubcategories calls +// productv1.ProductService.ResolveCategoryActiveSubcategories. +func (c *productServiceClient) ResolveCategoryActiveSubcategories(ctx context.Context, req *connect.Request[productv1.ResolveCategoryActiveSubcategoriesRequest]) (*connect.Response[productv1.ResolveCategoryActiveSubcategoriesResponse], error) { + return c.resolveCategoryActiveSubcategories.CallUnary(ctx, req) +} + +// ResolveCategoryCategoryMetrics calls productv1.ProductService.ResolveCategoryCategoryMetrics. +func (c *productServiceClient) ResolveCategoryCategoryMetrics(ctx context.Context, req *connect.Request[productv1.ResolveCategoryCategoryMetricsRequest]) (*connect.Response[productv1.ResolveCategoryCategoryMetricsResponse], error) { + return c.resolveCategoryCategoryMetrics.CallUnary(ctx, req) +} + +// ResolveCategoryCategoryStatus calls productv1.ProductService.ResolveCategoryCategoryStatus. +func (c *productServiceClient) ResolveCategoryCategoryStatus(ctx context.Context, req *connect.Request[productv1.ResolveCategoryCategoryStatusRequest]) (*connect.Response[productv1.ResolveCategoryCategoryStatusResponse], error) { + return c.resolveCategoryCategoryStatus.CallUnary(ctx, req) +} + +// ResolveCategoryChildCategories calls productv1.ProductService.ResolveCategoryChildCategories. +func (c *productServiceClient) ResolveCategoryChildCategories(ctx context.Context, req *connect.Request[productv1.ResolveCategoryChildCategoriesRequest]) (*connect.Response[productv1.ResolveCategoryChildCategoriesResponse], error) { + return c.resolveCategoryChildCategories.CallUnary(ctx, req) +} + +// ResolveCategoryMascot calls productv1.ProductService.ResolveCategoryMascot. +func (c *productServiceClient) ResolveCategoryMascot(ctx context.Context, req *connect.Request[productv1.ResolveCategoryMascotRequest]) (*connect.Response[productv1.ResolveCategoryMascotResponse], error) { + return c.resolveCategoryMascot.CallUnary(ctx, req) +} + +// ResolveCategoryMetricsAverageScore calls +// productv1.ProductService.ResolveCategoryMetricsAverageScore. +func (c *productServiceClient) ResolveCategoryMetricsAverageScore(ctx context.Context, req *connect.Request[productv1.ResolveCategoryMetricsAverageScoreRequest]) (*connect.Response[productv1.ResolveCategoryMetricsAverageScoreResponse], error) { + return c.resolveCategoryMetricsAverageScore.CallUnary(ctx, req) +} + +// ResolveCategoryMetricsNormalizedScore calls +// productv1.ProductService.ResolveCategoryMetricsNormalizedScore. +func (c *productServiceClient) ResolveCategoryMetricsNormalizedScore(ctx context.Context, req *connect.Request[productv1.ResolveCategoryMetricsNormalizedScoreRequest]) (*connect.Response[productv1.ResolveCategoryMetricsNormalizedScoreResponse], error) { + return c.resolveCategoryMetricsNormalizedScore.CallUnary(ctx, req) +} + +// ResolveCategoryMetricsRelatedCategory calls +// productv1.ProductService.ResolveCategoryMetricsRelatedCategory. +func (c *productServiceClient) ResolveCategoryMetricsRelatedCategory(ctx context.Context, req *connect.Request[productv1.ResolveCategoryMetricsRelatedCategoryRequest]) (*connect.Response[productv1.ResolveCategoryMetricsRelatedCategoryResponse], error) { + return c.resolveCategoryMetricsRelatedCategory.CallUnary(ctx, req) +} + +// ResolveCategoryOptionalCategories calls +// productv1.ProductService.ResolveCategoryOptionalCategories. +func (c *productServiceClient) ResolveCategoryOptionalCategories(ctx context.Context, req *connect.Request[productv1.ResolveCategoryOptionalCategoriesRequest]) (*connect.Response[productv1.ResolveCategoryOptionalCategoriesResponse], error) { + return c.resolveCategoryOptionalCategories.CallUnary(ctx, req) +} + +// ResolveCategoryPopularityScore calls productv1.ProductService.ResolveCategoryPopularityScore. +func (c *productServiceClient) ResolveCategoryPopularityScore(ctx context.Context, req *connect.Request[productv1.ResolveCategoryPopularityScoreRequest]) (*connect.Response[productv1.ResolveCategoryPopularityScoreResponse], error) { + return c.resolveCategoryPopularityScore.CallUnary(ctx, req) +} + +// ResolveCategoryProductCount calls productv1.ProductService.ResolveCategoryProductCount. +func (c *productServiceClient) ResolveCategoryProductCount(ctx context.Context, req *connect.Request[productv1.ResolveCategoryProductCountRequest]) (*connect.Response[productv1.ResolveCategoryProductCountResponse], error) { + return c.resolveCategoryProductCount.CallUnary(ctx, req) +} + +// ResolveCategoryTopSubcategory calls productv1.ProductService.ResolveCategoryTopSubcategory. +func (c *productServiceClient) ResolveCategoryTopSubcategory(ctx context.Context, req *connect.Request[productv1.ResolveCategoryTopSubcategoryRequest]) (*connect.Response[productv1.ResolveCategoryTopSubcategoryResponse], error) { + return c.resolveCategoryTopSubcategory.CallUnary(ctx, req) +} + +// ResolveCategoryTotalProducts calls productv1.ProductService.ResolveCategoryTotalProducts. +func (c *productServiceClient) ResolveCategoryTotalProducts(ctx context.Context, req *connect.Request[productv1.ResolveCategoryTotalProductsRequest]) (*connect.Response[productv1.ResolveCategoryTotalProductsResponse], error) { + return c.resolveCategoryTotalProducts.CallUnary(ctx, req) +} + +// ResolveProductMascotRecommendation calls +// productv1.ProductService.ResolveProductMascotRecommendation. +func (c *productServiceClient) ResolveProductMascotRecommendation(ctx context.Context, req *connect.Request[productv1.ResolveProductMascotRecommendationRequest]) (*connect.Response[productv1.ResolveProductMascotRecommendationResponse], error) { + return c.resolveProductMascotRecommendation.CallUnary(ctx, req) +} + +// ResolveProductProductDetails calls productv1.ProductService.ResolveProductProductDetails. +func (c *productServiceClient) ResolveProductProductDetails(ctx context.Context, req *connect.Request[productv1.ResolveProductProductDetailsRequest]) (*connect.Response[productv1.ResolveProductProductDetailsResponse], error) { + return c.resolveProductProductDetails.CallUnary(ctx, req) +} + +// ResolveProductRecommendedCategory calls +// productv1.ProductService.ResolveProductRecommendedCategory. +func (c *productServiceClient) ResolveProductRecommendedCategory(ctx context.Context, req *connect.Request[productv1.ResolveProductRecommendedCategoryRequest]) (*connect.Response[productv1.ResolveProductRecommendedCategoryResponse], error) { + return c.resolveProductRecommendedCategory.CallUnary(ctx, req) +} + +// ResolveProductShippingEstimate calls productv1.ProductService.ResolveProductShippingEstimate. +func (c *productServiceClient) ResolveProductShippingEstimate(ctx context.Context, req *connect.Request[productv1.ResolveProductShippingEstimateRequest]) (*connect.Response[productv1.ResolveProductShippingEstimateResponse], error) { + return c.resolveProductShippingEstimate.CallUnary(ctx, req) +} + +// ResolveProductStockStatus calls productv1.ProductService.ResolveProductStockStatus. +func (c *productServiceClient) ResolveProductStockStatus(ctx context.Context, req *connect.Request[productv1.ResolveProductStockStatusRequest]) (*connect.Response[productv1.ResolveProductStockStatusResponse], error) { + return c.resolveProductStockStatus.CallUnary(ctx, req) +} + +// ResolveStorageLinkedStorages calls productv1.ProductService.ResolveStorageLinkedStorages. +func (c *productServiceClient) ResolveStorageLinkedStorages(ctx context.Context, req *connect.Request[productv1.ResolveStorageLinkedStoragesRequest]) (*connect.Response[productv1.ResolveStorageLinkedStoragesResponse], error) { + return c.resolveStorageLinkedStorages.CallUnary(ctx, req) +} + +// ResolveStorageNearbyStorages calls productv1.ProductService.ResolveStorageNearbyStorages. +func (c *productServiceClient) ResolveStorageNearbyStorages(ctx context.Context, req *connect.Request[productv1.ResolveStorageNearbyStoragesRequest]) (*connect.Response[productv1.ResolveStorageNearbyStoragesResponse], error) { + return c.resolveStorageNearbyStorages.CallUnary(ctx, req) +} + +// ResolveStorageStorageStatus calls productv1.ProductService.ResolveStorageStorageStatus. +func (c *productServiceClient) ResolveStorageStorageStatus(ctx context.Context, req *connect.Request[productv1.ResolveStorageStorageStatusRequest]) (*connect.Response[productv1.ResolveStorageStorageStatusResponse], error) { + return c.resolveStorageStorageStatus.CallUnary(ctx, req) +} + +// ResolveSubcategoryFeaturedCategory calls +// productv1.ProductService.ResolveSubcategoryFeaturedCategory. +func (c *productServiceClient) ResolveSubcategoryFeaturedCategory(ctx context.Context, req *connect.Request[productv1.ResolveSubcategoryFeaturedCategoryRequest]) (*connect.Response[productv1.ResolveSubcategoryFeaturedCategoryResponse], error) { + return c.resolveSubcategoryFeaturedCategory.CallUnary(ctx, req) +} + +// ResolveSubcategoryItemCount calls productv1.ProductService.ResolveSubcategoryItemCount. +func (c *productServiceClient) ResolveSubcategoryItemCount(ctx context.Context, req *connect.Request[productv1.ResolveSubcategoryItemCountRequest]) (*connect.Response[productv1.ResolveSubcategoryItemCountResponse], error) { + return c.resolveSubcategoryItemCount.CallUnary(ctx, req) +} + +// ResolveSubcategoryParentCategory calls productv1.ProductService.ResolveSubcategoryParentCategory. +func (c *productServiceClient) ResolveSubcategoryParentCategory(ctx context.Context, req *connect.Request[productv1.ResolveSubcategoryParentCategoryRequest]) (*connect.Response[productv1.ResolveSubcategoryParentCategoryResponse], error) { + return c.resolveSubcategoryParentCategory.CallUnary(ctx, req) +} + +// ResolveTestContainerDetails calls productv1.ProductService.ResolveTestContainerDetails. +func (c *productServiceClient) ResolveTestContainerDetails(ctx context.Context, req *connect.Request[productv1.ResolveTestContainerDetailsRequest]) (*connect.Response[productv1.ResolveTestContainerDetailsResponse], error) { + return c.resolveTestContainerDetails.CallUnary(ctx, req) +} + +// ProductServiceHandler is an implementation of the productv1.ProductService service. +type ProductServiceHandler interface { + // Lookup Product entity by id + LookupProductById(context.Context, *connect.Request[productv1.LookupProductByIdRequest]) (*connect.Response[productv1.LookupProductByIdResponse], error) + // Lookup Storage entity by id + LookupStorageById(context.Context, *connect.Request[productv1.LookupStorageByIdRequest]) (*connect.Response[productv1.LookupStorageByIdResponse], error) + // Lookup Warehouse entity by id + LookupWarehouseById(context.Context, *connect.Request[productv1.LookupWarehouseByIdRequest]) (*connect.Response[productv1.LookupWarehouseByIdResponse], error) + MutationBulkCreateAuthors(context.Context, *connect.Request[productv1.MutationBulkCreateAuthorsRequest]) (*connect.Response[productv1.MutationBulkCreateAuthorsResponse], error) + MutationBulkCreateBlogPosts(context.Context, *connect.Request[productv1.MutationBulkCreateBlogPostsRequest]) (*connect.Response[productv1.MutationBulkCreateBlogPostsResponse], error) + MutationBulkUpdateAuthors(context.Context, *connect.Request[productv1.MutationBulkUpdateAuthorsRequest]) (*connect.Response[productv1.MutationBulkUpdateAuthorsResponse], error) + MutationBulkUpdateBlogPosts(context.Context, *connect.Request[productv1.MutationBulkUpdateBlogPostsRequest]) (*connect.Response[productv1.MutationBulkUpdateBlogPostsResponse], error) + MutationCreateAuthor(context.Context, *connect.Request[productv1.MutationCreateAuthorRequest]) (*connect.Response[productv1.MutationCreateAuthorResponse], error) + MutationCreateBlogPost(context.Context, *connect.Request[productv1.MutationCreateBlogPostRequest]) (*connect.Response[productv1.MutationCreateBlogPostResponse], error) + MutationCreateNullableFieldsType(context.Context, *connect.Request[productv1.MutationCreateNullableFieldsTypeRequest]) (*connect.Response[productv1.MutationCreateNullableFieldsTypeResponse], error) + MutationCreateUser(context.Context, *connect.Request[productv1.MutationCreateUserRequest]) (*connect.Response[productv1.MutationCreateUserResponse], error) + MutationPerformAction(context.Context, *connect.Request[productv1.MutationPerformActionRequest]) (*connect.Response[productv1.MutationPerformActionResponse], error) + MutationUpdateAuthor(context.Context, *connect.Request[productv1.MutationUpdateAuthorRequest]) (*connect.Response[productv1.MutationUpdateAuthorResponse], error) + MutationUpdateBlogPost(context.Context, *connect.Request[productv1.MutationUpdateBlogPostRequest]) (*connect.Response[productv1.MutationUpdateBlogPostResponse], error) + MutationUpdateNullableFieldsType(context.Context, *connect.Request[productv1.MutationUpdateNullableFieldsTypeRequest]) (*connect.Response[productv1.MutationUpdateNullableFieldsTypeResponse], error) + QueryAllAuthors(context.Context, *connect.Request[productv1.QueryAllAuthorsRequest]) (*connect.Response[productv1.QueryAllAuthorsResponse], error) + QueryAllBlogPosts(context.Context, *connect.Request[productv1.QueryAllBlogPostsRequest]) (*connect.Response[productv1.QueryAllBlogPostsResponse], error) + QueryAllNullableFieldsTypes(context.Context, *connect.Request[productv1.QueryAllNullableFieldsTypesRequest]) (*connect.Response[productv1.QueryAllNullableFieldsTypesResponse], error) + QueryAllPets(context.Context, *connect.Request[productv1.QueryAllPetsRequest]) (*connect.Response[productv1.QueryAllPetsResponse], error) + QueryAuthor(context.Context, *connect.Request[productv1.QueryAuthorRequest]) (*connect.Response[productv1.QueryAuthorResponse], error) + QueryAuthorById(context.Context, *connect.Request[productv1.QueryAuthorByIdRequest]) (*connect.Response[productv1.QueryAuthorByIdResponse], error) + QueryAuthorsWithFilter(context.Context, *connect.Request[productv1.QueryAuthorsWithFilterRequest]) (*connect.Response[productv1.QueryAuthorsWithFilterResponse], error) + QueryBlogPost(context.Context, *connect.Request[productv1.QueryBlogPostRequest]) (*connect.Response[productv1.QueryBlogPostResponse], error) + QueryBlogPostById(context.Context, *connect.Request[productv1.QueryBlogPostByIdRequest]) (*connect.Response[productv1.QueryBlogPostByIdResponse], error) + QueryBlogPostsWithFilter(context.Context, *connect.Request[productv1.QueryBlogPostsWithFilterRequest]) (*connect.Response[productv1.QueryBlogPostsWithFilterResponse], error) + QueryBulkSearchAuthors(context.Context, *connect.Request[productv1.QueryBulkSearchAuthorsRequest]) (*connect.Response[productv1.QueryBulkSearchAuthorsResponse], error) + QueryBulkSearchBlogPosts(context.Context, *connect.Request[productv1.QueryBulkSearchBlogPostsRequest]) (*connect.Response[productv1.QueryBulkSearchBlogPostsResponse], error) + QueryCalculateTotals(context.Context, *connect.Request[productv1.QueryCalculateTotalsRequest]) (*connect.Response[productv1.QueryCalculateTotalsResponse], error) + QueryCategories(context.Context, *connect.Request[productv1.QueryCategoriesRequest]) (*connect.Response[productv1.QueryCategoriesResponse], error) + QueryCategoriesByKind(context.Context, *connect.Request[productv1.QueryCategoriesByKindRequest]) (*connect.Response[productv1.QueryCategoriesByKindResponse], error) + QueryCategoriesByKinds(context.Context, *connect.Request[productv1.QueryCategoriesByKindsRequest]) (*connect.Response[productv1.QueryCategoriesByKindsResponse], error) + QueryCategory(context.Context, *connect.Request[productv1.QueryCategoryRequest]) (*connect.Response[productv1.QueryCategoryResponse], error) + QueryComplexFilterType(context.Context, *connect.Request[productv1.QueryComplexFilterTypeRequest]) (*connect.Response[productv1.QueryComplexFilterTypeResponse], error) + QueryConditionalSearch(context.Context, *connect.Request[productv1.QueryConditionalSearchRequest]) (*connect.Response[productv1.QueryConditionalSearchResponse], error) + QueryFilterCategories(context.Context, *connect.Request[productv1.QueryFilterCategoriesRequest]) (*connect.Response[productv1.QueryFilterCategoriesResponse], error) + QueryNestedType(context.Context, *connect.Request[productv1.QueryNestedTypeRequest]) (*connect.Response[productv1.QueryNestedTypeResponse], error) + QueryNullableFieldsType(context.Context, *connect.Request[productv1.QueryNullableFieldsTypeRequest]) (*connect.Response[productv1.QueryNullableFieldsTypeResponse], error) + QueryNullableFieldsTypeById(context.Context, *connect.Request[productv1.QueryNullableFieldsTypeByIdRequest]) (*connect.Response[productv1.QueryNullableFieldsTypeByIdResponse], error) + QueryNullableFieldsTypeWithFilter(context.Context, *connect.Request[productv1.QueryNullableFieldsTypeWithFilterRequest]) (*connect.Response[productv1.QueryNullableFieldsTypeWithFilterResponse], error) + QueryRandomPet(context.Context, *connect.Request[productv1.QueryRandomPetRequest]) (*connect.Response[productv1.QueryRandomPetResponse], error) + QueryRandomSearchResult(context.Context, *connect.Request[productv1.QueryRandomSearchResultRequest]) (*connect.Response[productv1.QueryRandomSearchResultResponse], error) + QueryRecursiveType(context.Context, *connect.Request[productv1.QueryRecursiveTypeRequest]) (*connect.Response[productv1.QueryRecursiveTypeResponse], error) + QuerySearch(context.Context, *connect.Request[productv1.QuerySearchRequest]) (*connect.Response[productv1.QuerySearchResponse], error) + QueryTestContainer(context.Context, *connect.Request[productv1.QueryTestContainerRequest]) (*connect.Response[productv1.QueryTestContainerResponse], error) + QueryTestContainers(context.Context, *connect.Request[productv1.QueryTestContainersRequest]) (*connect.Response[productv1.QueryTestContainersResponse], error) + QueryTypeFilterWithArguments(context.Context, *connect.Request[productv1.QueryTypeFilterWithArgumentsRequest]) (*connect.Response[productv1.QueryTypeFilterWithArgumentsResponse], error) + QueryTypeWithMultipleFilterFields(context.Context, *connect.Request[productv1.QueryTypeWithMultipleFilterFieldsRequest]) (*connect.Response[productv1.QueryTypeWithMultipleFilterFieldsResponse], error) + QueryUser(context.Context, *connect.Request[productv1.QueryUserRequest]) (*connect.Response[productv1.QueryUserResponse], error) + QueryUsers(context.Context, *connect.Request[productv1.QueryUsersRequest]) (*connect.Response[productv1.QueryUsersResponse], error) + RequireStorageCategoryInfoSummaryById(context.Context, *connect.Request[productv1.RequireStorageCategoryInfoSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageCategoryInfoSummaryByIdResponse], error) + RequireStorageDeepItemInfoById(context.Context, *connect.Request[productv1.RequireStorageDeepItemInfoByIdRequest]) (*connect.Response[productv1.RequireStorageDeepItemInfoByIdResponse], error) + RequireStorageFilteredTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageFilteredTagSummaryByIdResponse], error) + RequireStorageItemHandlerInfoById(context.Context, *connect.Request[productv1.RequireStorageItemHandlerInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemHandlerInfoByIdResponse], error) + RequireStorageItemInfoById(context.Context, *connect.Request[productv1.RequireStorageItemInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemInfoByIdResponse], error) + RequireStorageItemSpecsInfoById(context.Context, *connect.Request[productv1.RequireStorageItemSpecsInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemSpecsInfoByIdResponse], error) + RequireStorageKindSummaryById(context.Context, *connect.Request[productv1.RequireStorageKindSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageKindSummaryByIdResponse], error) + RequireStorageMetadataScoreById(context.Context, *connect.Request[productv1.RequireStorageMetadataScoreByIdRequest]) (*connect.Response[productv1.RequireStorageMetadataScoreByIdResponse], error) + RequireStorageMultiFilteredTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageMultiFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageMultiFilteredTagSummaryByIdResponse], error) + RequireStorageNullableFilteredTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageNullableFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageNullableFilteredTagSummaryByIdResponse], error) + RequireStorageOperationReportById(context.Context, *connect.Request[productv1.RequireStorageOperationReportByIdRequest]) (*connect.Response[productv1.RequireStorageOperationReportByIdResponse], error) + RequireStorageOptionalProcessedMetadataById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataByIdResponse], error) + RequireStorageOptionalProcessedTagsById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedTagsByIdResponse], error) + RequireStorageOptionalTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageOptionalTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalTagSummaryByIdResponse], error) + RequireStorageProcessedMetadataById(context.Context, *connect.Request[productv1.RequireStorageProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedMetadataByIdResponse], error) + RequireStorageProcessedMetadataHistoryById(context.Context, *connect.Request[productv1.RequireStorageProcessedMetadataHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedMetadataHistoryByIdResponse], error) + RequireStorageProcessedTagsById(context.Context, *connect.Request[productv1.RequireStorageProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedTagsByIdResponse], error) + RequireStorageSecuritySummaryById(context.Context, *connect.Request[productv1.RequireStorageSecuritySummaryByIdRequest]) (*connect.Response[productv1.RequireStorageSecuritySummaryByIdResponse], error) + RequireStorageStockHealthScoreById(context.Context, *connect.Request[productv1.RequireStorageStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireStorageStockHealthScoreByIdResponse], error) + RequireStorageTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageTagSummaryByIdResponse], error) + RequireWarehouseStockHealthScoreById(context.Context, *connect.Request[productv1.RequireWarehouseStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireWarehouseStockHealthScoreByIdResponse], error) + ResolveCategoryActiveSubcategories(context.Context, *connect.Request[productv1.ResolveCategoryActiveSubcategoriesRequest]) (*connect.Response[productv1.ResolveCategoryActiveSubcategoriesResponse], error) + ResolveCategoryCategoryMetrics(context.Context, *connect.Request[productv1.ResolveCategoryCategoryMetricsRequest]) (*connect.Response[productv1.ResolveCategoryCategoryMetricsResponse], error) + ResolveCategoryCategoryStatus(context.Context, *connect.Request[productv1.ResolveCategoryCategoryStatusRequest]) (*connect.Response[productv1.ResolveCategoryCategoryStatusResponse], error) + ResolveCategoryChildCategories(context.Context, *connect.Request[productv1.ResolveCategoryChildCategoriesRequest]) (*connect.Response[productv1.ResolveCategoryChildCategoriesResponse], error) + ResolveCategoryMascot(context.Context, *connect.Request[productv1.ResolveCategoryMascotRequest]) (*connect.Response[productv1.ResolveCategoryMascotResponse], error) + ResolveCategoryMetricsAverageScore(context.Context, *connect.Request[productv1.ResolveCategoryMetricsAverageScoreRequest]) (*connect.Response[productv1.ResolveCategoryMetricsAverageScoreResponse], error) + ResolveCategoryMetricsNormalizedScore(context.Context, *connect.Request[productv1.ResolveCategoryMetricsNormalizedScoreRequest]) (*connect.Response[productv1.ResolveCategoryMetricsNormalizedScoreResponse], error) + ResolveCategoryMetricsRelatedCategory(context.Context, *connect.Request[productv1.ResolveCategoryMetricsRelatedCategoryRequest]) (*connect.Response[productv1.ResolveCategoryMetricsRelatedCategoryResponse], error) + ResolveCategoryOptionalCategories(context.Context, *connect.Request[productv1.ResolveCategoryOptionalCategoriesRequest]) (*connect.Response[productv1.ResolveCategoryOptionalCategoriesResponse], error) + ResolveCategoryPopularityScore(context.Context, *connect.Request[productv1.ResolveCategoryPopularityScoreRequest]) (*connect.Response[productv1.ResolveCategoryPopularityScoreResponse], error) + ResolveCategoryProductCount(context.Context, *connect.Request[productv1.ResolveCategoryProductCountRequest]) (*connect.Response[productv1.ResolveCategoryProductCountResponse], error) + ResolveCategoryTopSubcategory(context.Context, *connect.Request[productv1.ResolveCategoryTopSubcategoryRequest]) (*connect.Response[productv1.ResolveCategoryTopSubcategoryResponse], error) + ResolveCategoryTotalProducts(context.Context, *connect.Request[productv1.ResolveCategoryTotalProductsRequest]) (*connect.Response[productv1.ResolveCategoryTotalProductsResponse], error) + ResolveProductMascotRecommendation(context.Context, *connect.Request[productv1.ResolveProductMascotRecommendationRequest]) (*connect.Response[productv1.ResolveProductMascotRecommendationResponse], error) + ResolveProductProductDetails(context.Context, *connect.Request[productv1.ResolveProductProductDetailsRequest]) (*connect.Response[productv1.ResolveProductProductDetailsResponse], error) + ResolveProductRecommendedCategory(context.Context, *connect.Request[productv1.ResolveProductRecommendedCategoryRequest]) (*connect.Response[productv1.ResolveProductRecommendedCategoryResponse], error) + ResolveProductShippingEstimate(context.Context, *connect.Request[productv1.ResolveProductShippingEstimateRequest]) (*connect.Response[productv1.ResolveProductShippingEstimateResponse], error) + ResolveProductStockStatus(context.Context, *connect.Request[productv1.ResolveProductStockStatusRequest]) (*connect.Response[productv1.ResolveProductStockStatusResponse], error) + ResolveStorageLinkedStorages(context.Context, *connect.Request[productv1.ResolveStorageLinkedStoragesRequest]) (*connect.Response[productv1.ResolveStorageLinkedStoragesResponse], error) + ResolveStorageNearbyStorages(context.Context, *connect.Request[productv1.ResolveStorageNearbyStoragesRequest]) (*connect.Response[productv1.ResolveStorageNearbyStoragesResponse], error) + ResolveStorageStorageStatus(context.Context, *connect.Request[productv1.ResolveStorageStorageStatusRequest]) (*connect.Response[productv1.ResolveStorageStorageStatusResponse], error) + ResolveSubcategoryFeaturedCategory(context.Context, *connect.Request[productv1.ResolveSubcategoryFeaturedCategoryRequest]) (*connect.Response[productv1.ResolveSubcategoryFeaturedCategoryResponse], error) + ResolveSubcategoryItemCount(context.Context, *connect.Request[productv1.ResolveSubcategoryItemCountRequest]) (*connect.Response[productv1.ResolveSubcategoryItemCountResponse], error) + ResolveSubcategoryParentCategory(context.Context, *connect.Request[productv1.ResolveSubcategoryParentCategoryRequest]) (*connect.Response[productv1.ResolveSubcategoryParentCategoryResponse], error) + ResolveTestContainerDetails(context.Context, *connect.Request[productv1.ResolveTestContainerDetailsRequest]) (*connect.Response[productv1.ResolveTestContainerDetailsResponse], error) +} + +// NewProductServiceHandler builds an HTTP handler from the service implementation. It returns the +// path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewProductServiceHandler(svc ProductServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + productServiceMethods := productv1.File_product_proto.Services().ByName("ProductService").Methods() + productServiceLookupProductByIdHandler := connect.NewUnaryHandler( + ProductServiceLookupProductByIdProcedure, + svc.LookupProductById, + connect.WithSchema(productServiceMethods.ByName("LookupProductById")), + connect.WithHandlerOptions(opts...), + ) + productServiceLookupStorageByIdHandler := connect.NewUnaryHandler( + ProductServiceLookupStorageByIdProcedure, + svc.LookupStorageById, + connect.WithSchema(productServiceMethods.ByName("LookupStorageById")), + connect.WithHandlerOptions(opts...), + ) + productServiceLookupWarehouseByIdHandler := connect.NewUnaryHandler( + ProductServiceLookupWarehouseByIdProcedure, + svc.LookupWarehouseById, + connect.WithSchema(productServiceMethods.ByName("LookupWarehouseById")), + connect.WithHandlerOptions(opts...), + ) + productServiceMutationBulkCreateAuthorsHandler := connect.NewUnaryHandler( + ProductServiceMutationBulkCreateAuthorsProcedure, + svc.MutationBulkCreateAuthors, + connect.WithSchema(productServiceMethods.ByName("MutationBulkCreateAuthors")), + connect.WithHandlerOptions(opts...), + ) + productServiceMutationBulkCreateBlogPostsHandler := connect.NewUnaryHandler( + ProductServiceMutationBulkCreateBlogPostsProcedure, + svc.MutationBulkCreateBlogPosts, + connect.WithSchema(productServiceMethods.ByName("MutationBulkCreateBlogPosts")), + connect.WithHandlerOptions(opts...), + ) + productServiceMutationBulkUpdateAuthorsHandler := connect.NewUnaryHandler( + ProductServiceMutationBulkUpdateAuthorsProcedure, + svc.MutationBulkUpdateAuthors, + connect.WithSchema(productServiceMethods.ByName("MutationBulkUpdateAuthors")), + connect.WithHandlerOptions(opts...), + ) + productServiceMutationBulkUpdateBlogPostsHandler := connect.NewUnaryHandler( + ProductServiceMutationBulkUpdateBlogPostsProcedure, + svc.MutationBulkUpdateBlogPosts, + connect.WithSchema(productServiceMethods.ByName("MutationBulkUpdateBlogPosts")), + connect.WithHandlerOptions(opts...), + ) + productServiceMutationCreateAuthorHandler := connect.NewUnaryHandler( + ProductServiceMutationCreateAuthorProcedure, + svc.MutationCreateAuthor, + connect.WithSchema(productServiceMethods.ByName("MutationCreateAuthor")), + connect.WithHandlerOptions(opts...), + ) + productServiceMutationCreateBlogPostHandler := connect.NewUnaryHandler( + ProductServiceMutationCreateBlogPostProcedure, + svc.MutationCreateBlogPost, + connect.WithSchema(productServiceMethods.ByName("MutationCreateBlogPost")), + connect.WithHandlerOptions(opts...), + ) + productServiceMutationCreateNullableFieldsTypeHandler := connect.NewUnaryHandler( + ProductServiceMutationCreateNullableFieldsTypeProcedure, + svc.MutationCreateNullableFieldsType, + connect.WithSchema(productServiceMethods.ByName("MutationCreateNullableFieldsType")), + connect.WithHandlerOptions(opts...), + ) + productServiceMutationCreateUserHandler := connect.NewUnaryHandler( + ProductServiceMutationCreateUserProcedure, + svc.MutationCreateUser, + connect.WithSchema(productServiceMethods.ByName("MutationCreateUser")), + connect.WithHandlerOptions(opts...), + ) + productServiceMutationPerformActionHandler := connect.NewUnaryHandler( + ProductServiceMutationPerformActionProcedure, + svc.MutationPerformAction, + connect.WithSchema(productServiceMethods.ByName("MutationPerformAction")), + connect.WithHandlerOptions(opts...), + ) + productServiceMutationUpdateAuthorHandler := connect.NewUnaryHandler( + ProductServiceMutationUpdateAuthorProcedure, + svc.MutationUpdateAuthor, + connect.WithSchema(productServiceMethods.ByName("MutationUpdateAuthor")), + connect.WithHandlerOptions(opts...), + ) + productServiceMutationUpdateBlogPostHandler := connect.NewUnaryHandler( + ProductServiceMutationUpdateBlogPostProcedure, + svc.MutationUpdateBlogPost, + connect.WithSchema(productServiceMethods.ByName("MutationUpdateBlogPost")), + connect.WithHandlerOptions(opts...), + ) + productServiceMutationUpdateNullableFieldsTypeHandler := connect.NewUnaryHandler( + ProductServiceMutationUpdateNullableFieldsTypeProcedure, + svc.MutationUpdateNullableFieldsType, + connect.WithSchema(productServiceMethods.ByName("MutationUpdateNullableFieldsType")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryAllAuthorsHandler := connect.NewUnaryHandler( + ProductServiceQueryAllAuthorsProcedure, + svc.QueryAllAuthors, + connect.WithSchema(productServiceMethods.ByName("QueryAllAuthors")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryAllBlogPostsHandler := connect.NewUnaryHandler( + ProductServiceQueryAllBlogPostsProcedure, + svc.QueryAllBlogPosts, + connect.WithSchema(productServiceMethods.ByName("QueryAllBlogPosts")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryAllNullableFieldsTypesHandler := connect.NewUnaryHandler( + ProductServiceQueryAllNullableFieldsTypesProcedure, + svc.QueryAllNullableFieldsTypes, + connect.WithSchema(productServiceMethods.ByName("QueryAllNullableFieldsTypes")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryAllPetsHandler := connect.NewUnaryHandler( + ProductServiceQueryAllPetsProcedure, + svc.QueryAllPets, + connect.WithSchema(productServiceMethods.ByName("QueryAllPets")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryAuthorHandler := connect.NewUnaryHandler( + ProductServiceQueryAuthorProcedure, + svc.QueryAuthor, + connect.WithSchema(productServiceMethods.ByName("QueryAuthor")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryAuthorByIdHandler := connect.NewUnaryHandler( + ProductServiceQueryAuthorByIdProcedure, + svc.QueryAuthorById, + connect.WithSchema(productServiceMethods.ByName("QueryAuthorById")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryAuthorsWithFilterHandler := connect.NewUnaryHandler( + ProductServiceQueryAuthorsWithFilterProcedure, + svc.QueryAuthorsWithFilter, + connect.WithSchema(productServiceMethods.ByName("QueryAuthorsWithFilter")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryBlogPostHandler := connect.NewUnaryHandler( + ProductServiceQueryBlogPostProcedure, + svc.QueryBlogPost, + connect.WithSchema(productServiceMethods.ByName("QueryBlogPost")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryBlogPostByIdHandler := connect.NewUnaryHandler( + ProductServiceQueryBlogPostByIdProcedure, + svc.QueryBlogPostById, + connect.WithSchema(productServiceMethods.ByName("QueryBlogPostById")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryBlogPostsWithFilterHandler := connect.NewUnaryHandler( + ProductServiceQueryBlogPostsWithFilterProcedure, + svc.QueryBlogPostsWithFilter, + connect.WithSchema(productServiceMethods.ByName("QueryBlogPostsWithFilter")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryBulkSearchAuthorsHandler := connect.NewUnaryHandler( + ProductServiceQueryBulkSearchAuthorsProcedure, + svc.QueryBulkSearchAuthors, + connect.WithSchema(productServiceMethods.ByName("QueryBulkSearchAuthors")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryBulkSearchBlogPostsHandler := connect.NewUnaryHandler( + ProductServiceQueryBulkSearchBlogPostsProcedure, + svc.QueryBulkSearchBlogPosts, + connect.WithSchema(productServiceMethods.ByName("QueryBulkSearchBlogPosts")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryCalculateTotalsHandler := connect.NewUnaryHandler( + ProductServiceQueryCalculateTotalsProcedure, + svc.QueryCalculateTotals, + connect.WithSchema(productServiceMethods.ByName("QueryCalculateTotals")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryCategoriesHandler := connect.NewUnaryHandler( + ProductServiceQueryCategoriesProcedure, + svc.QueryCategories, + connect.WithSchema(productServiceMethods.ByName("QueryCategories")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryCategoriesByKindHandler := connect.NewUnaryHandler( + ProductServiceQueryCategoriesByKindProcedure, + svc.QueryCategoriesByKind, + connect.WithSchema(productServiceMethods.ByName("QueryCategoriesByKind")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryCategoriesByKindsHandler := connect.NewUnaryHandler( + ProductServiceQueryCategoriesByKindsProcedure, + svc.QueryCategoriesByKinds, + connect.WithSchema(productServiceMethods.ByName("QueryCategoriesByKinds")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryCategoryHandler := connect.NewUnaryHandler( + ProductServiceQueryCategoryProcedure, + svc.QueryCategory, + connect.WithSchema(productServiceMethods.ByName("QueryCategory")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryComplexFilterTypeHandler := connect.NewUnaryHandler( + ProductServiceQueryComplexFilterTypeProcedure, + svc.QueryComplexFilterType, + connect.WithSchema(productServiceMethods.ByName("QueryComplexFilterType")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryConditionalSearchHandler := connect.NewUnaryHandler( + ProductServiceQueryConditionalSearchProcedure, + svc.QueryConditionalSearch, + connect.WithSchema(productServiceMethods.ByName("QueryConditionalSearch")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryFilterCategoriesHandler := connect.NewUnaryHandler( + ProductServiceQueryFilterCategoriesProcedure, + svc.QueryFilterCategories, + connect.WithSchema(productServiceMethods.ByName("QueryFilterCategories")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryNestedTypeHandler := connect.NewUnaryHandler( + ProductServiceQueryNestedTypeProcedure, + svc.QueryNestedType, + connect.WithSchema(productServiceMethods.ByName("QueryNestedType")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryNullableFieldsTypeHandler := connect.NewUnaryHandler( + ProductServiceQueryNullableFieldsTypeProcedure, + svc.QueryNullableFieldsType, + connect.WithSchema(productServiceMethods.ByName("QueryNullableFieldsType")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryNullableFieldsTypeByIdHandler := connect.NewUnaryHandler( + ProductServiceQueryNullableFieldsTypeByIdProcedure, + svc.QueryNullableFieldsTypeById, + connect.WithSchema(productServiceMethods.ByName("QueryNullableFieldsTypeById")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryNullableFieldsTypeWithFilterHandler := connect.NewUnaryHandler( + ProductServiceQueryNullableFieldsTypeWithFilterProcedure, + svc.QueryNullableFieldsTypeWithFilter, + connect.WithSchema(productServiceMethods.ByName("QueryNullableFieldsTypeWithFilter")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryRandomPetHandler := connect.NewUnaryHandler( + ProductServiceQueryRandomPetProcedure, + svc.QueryRandomPet, + connect.WithSchema(productServiceMethods.ByName("QueryRandomPet")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryRandomSearchResultHandler := connect.NewUnaryHandler( + ProductServiceQueryRandomSearchResultProcedure, + svc.QueryRandomSearchResult, + connect.WithSchema(productServiceMethods.ByName("QueryRandomSearchResult")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryRecursiveTypeHandler := connect.NewUnaryHandler( + ProductServiceQueryRecursiveTypeProcedure, + svc.QueryRecursiveType, + connect.WithSchema(productServiceMethods.ByName("QueryRecursiveType")), + connect.WithHandlerOptions(opts...), + ) + productServiceQuerySearchHandler := connect.NewUnaryHandler( + ProductServiceQuerySearchProcedure, + svc.QuerySearch, + connect.WithSchema(productServiceMethods.ByName("QuerySearch")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryTestContainerHandler := connect.NewUnaryHandler( + ProductServiceQueryTestContainerProcedure, + svc.QueryTestContainer, + connect.WithSchema(productServiceMethods.ByName("QueryTestContainer")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryTestContainersHandler := connect.NewUnaryHandler( + ProductServiceQueryTestContainersProcedure, + svc.QueryTestContainers, + connect.WithSchema(productServiceMethods.ByName("QueryTestContainers")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryTypeFilterWithArgumentsHandler := connect.NewUnaryHandler( + ProductServiceQueryTypeFilterWithArgumentsProcedure, + svc.QueryTypeFilterWithArguments, + connect.WithSchema(productServiceMethods.ByName("QueryTypeFilterWithArguments")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryTypeWithMultipleFilterFieldsHandler := connect.NewUnaryHandler( + ProductServiceQueryTypeWithMultipleFilterFieldsProcedure, + svc.QueryTypeWithMultipleFilterFields, + connect.WithSchema(productServiceMethods.ByName("QueryTypeWithMultipleFilterFields")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryUserHandler := connect.NewUnaryHandler( + ProductServiceQueryUserProcedure, + svc.QueryUser, + connect.WithSchema(productServiceMethods.ByName("QueryUser")), + connect.WithHandlerOptions(opts...), + ) + productServiceQueryUsersHandler := connect.NewUnaryHandler( + ProductServiceQueryUsersProcedure, + svc.QueryUsers, + connect.WithSchema(productServiceMethods.ByName("QueryUsers")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageCategoryInfoSummaryByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageCategoryInfoSummaryByIdProcedure, + svc.RequireStorageCategoryInfoSummaryById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageCategoryInfoSummaryById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageDeepItemInfoByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageDeepItemInfoByIdProcedure, + svc.RequireStorageDeepItemInfoById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageDeepItemInfoById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageFilteredTagSummaryByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageFilteredTagSummaryByIdProcedure, + svc.RequireStorageFilteredTagSummaryById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageFilteredTagSummaryById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageItemHandlerInfoByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageItemHandlerInfoByIdProcedure, + svc.RequireStorageItemHandlerInfoById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageItemHandlerInfoById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageItemInfoByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageItemInfoByIdProcedure, + svc.RequireStorageItemInfoById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageItemInfoById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageItemSpecsInfoByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageItemSpecsInfoByIdProcedure, + svc.RequireStorageItemSpecsInfoById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageItemSpecsInfoById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageKindSummaryByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageKindSummaryByIdProcedure, + svc.RequireStorageKindSummaryById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageKindSummaryById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageMetadataScoreByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageMetadataScoreByIdProcedure, + svc.RequireStorageMetadataScoreById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageMetadataScoreById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageMultiFilteredTagSummaryByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageMultiFilteredTagSummaryByIdProcedure, + svc.RequireStorageMultiFilteredTagSummaryById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageMultiFilteredTagSummaryById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageNullableFilteredTagSummaryByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageNullableFilteredTagSummaryByIdProcedure, + svc.RequireStorageNullableFilteredTagSummaryById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageNullableFilteredTagSummaryById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageOperationReportByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageOperationReportByIdProcedure, + svc.RequireStorageOperationReportById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageOperationReportById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageOptionalProcessedMetadataByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageOptionalProcessedMetadataByIdProcedure, + svc.RequireStorageOptionalProcessedMetadataById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalProcessedMetadataById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageOptionalProcessedTagsByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageOptionalProcessedTagsByIdProcedure, + svc.RequireStorageOptionalProcessedTagsById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalProcessedTagsById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageOptionalTagSummaryByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageOptionalTagSummaryByIdProcedure, + svc.RequireStorageOptionalTagSummaryById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageOptionalTagSummaryById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageProcessedMetadataByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageProcessedMetadataByIdProcedure, + svc.RequireStorageProcessedMetadataById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageProcessedMetadataById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageProcessedMetadataHistoryByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageProcessedMetadataHistoryByIdProcedure, + svc.RequireStorageProcessedMetadataHistoryById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageProcessedMetadataHistoryById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageProcessedTagsByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageProcessedTagsByIdProcedure, + svc.RequireStorageProcessedTagsById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageProcessedTagsById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageSecuritySummaryByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageSecuritySummaryByIdProcedure, + svc.RequireStorageSecuritySummaryById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageSecuritySummaryById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageStockHealthScoreByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageStockHealthScoreByIdProcedure, + svc.RequireStorageStockHealthScoreById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageStockHealthScoreById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireStorageTagSummaryByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireStorageTagSummaryByIdProcedure, + svc.RequireStorageTagSummaryById, + connect.WithSchema(productServiceMethods.ByName("RequireStorageTagSummaryById")), + connect.WithHandlerOptions(opts...), + ) + productServiceRequireWarehouseStockHealthScoreByIdHandler := connect.NewUnaryHandler( + ProductServiceRequireWarehouseStockHealthScoreByIdProcedure, + svc.RequireWarehouseStockHealthScoreById, + connect.WithSchema(productServiceMethods.ByName("RequireWarehouseStockHealthScoreById")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveCategoryActiveSubcategoriesHandler := connect.NewUnaryHandler( + ProductServiceResolveCategoryActiveSubcategoriesProcedure, + svc.ResolveCategoryActiveSubcategories, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryActiveSubcategories")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveCategoryCategoryMetricsHandler := connect.NewUnaryHandler( + ProductServiceResolveCategoryCategoryMetricsProcedure, + svc.ResolveCategoryCategoryMetrics, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryCategoryMetrics")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveCategoryCategoryStatusHandler := connect.NewUnaryHandler( + ProductServiceResolveCategoryCategoryStatusProcedure, + svc.ResolveCategoryCategoryStatus, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryCategoryStatus")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveCategoryChildCategoriesHandler := connect.NewUnaryHandler( + ProductServiceResolveCategoryChildCategoriesProcedure, + svc.ResolveCategoryChildCategories, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryChildCategories")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveCategoryMascotHandler := connect.NewUnaryHandler( + ProductServiceResolveCategoryMascotProcedure, + svc.ResolveCategoryMascot, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryMascot")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveCategoryMetricsAverageScoreHandler := connect.NewUnaryHandler( + ProductServiceResolveCategoryMetricsAverageScoreProcedure, + svc.ResolveCategoryMetricsAverageScore, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryMetricsAverageScore")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveCategoryMetricsNormalizedScoreHandler := connect.NewUnaryHandler( + ProductServiceResolveCategoryMetricsNormalizedScoreProcedure, + svc.ResolveCategoryMetricsNormalizedScore, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryMetricsNormalizedScore")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveCategoryMetricsRelatedCategoryHandler := connect.NewUnaryHandler( + ProductServiceResolveCategoryMetricsRelatedCategoryProcedure, + svc.ResolveCategoryMetricsRelatedCategory, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryMetricsRelatedCategory")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveCategoryOptionalCategoriesHandler := connect.NewUnaryHandler( + ProductServiceResolveCategoryOptionalCategoriesProcedure, + svc.ResolveCategoryOptionalCategories, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryOptionalCategories")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveCategoryPopularityScoreHandler := connect.NewUnaryHandler( + ProductServiceResolveCategoryPopularityScoreProcedure, + svc.ResolveCategoryPopularityScore, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryPopularityScore")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveCategoryProductCountHandler := connect.NewUnaryHandler( + ProductServiceResolveCategoryProductCountProcedure, + svc.ResolveCategoryProductCount, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryProductCount")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveCategoryTopSubcategoryHandler := connect.NewUnaryHandler( + ProductServiceResolveCategoryTopSubcategoryProcedure, + svc.ResolveCategoryTopSubcategory, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryTopSubcategory")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveCategoryTotalProductsHandler := connect.NewUnaryHandler( + ProductServiceResolveCategoryTotalProductsProcedure, + svc.ResolveCategoryTotalProducts, + connect.WithSchema(productServiceMethods.ByName("ResolveCategoryTotalProducts")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveProductMascotRecommendationHandler := connect.NewUnaryHandler( + ProductServiceResolveProductMascotRecommendationProcedure, + svc.ResolveProductMascotRecommendation, + connect.WithSchema(productServiceMethods.ByName("ResolveProductMascotRecommendation")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveProductProductDetailsHandler := connect.NewUnaryHandler( + ProductServiceResolveProductProductDetailsProcedure, + svc.ResolveProductProductDetails, + connect.WithSchema(productServiceMethods.ByName("ResolveProductProductDetails")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveProductRecommendedCategoryHandler := connect.NewUnaryHandler( + ProductServiceResolveProductRecommendedCategoryProcedure, + svc.ResolveProductRecommendedCategory, + connect.WithSchema(productServiceMethods.ByName("ResolveProductRecommendedCategory")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveProductShippingEstimateHandler := connect.NewUnaryHandler( + ProductServiceResolveProductShippingEstimateProcedure, + svc.ResolveProductShippingEstimate, + connect.WithSchema(productServiceMethods.ByName("ResolveProductShippingEstimate")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveProductStockStatusHandler := connect.NewUnaryHandler( + ProductServiceResolveProductStockStatusProcedure, + svc.ResolveProductStockStatus, + connect.WithSchema(productServiceMethods.ByName("ResolveProductStockStatus")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveStorageLinkedStoragesHandler := connect.NewUnaryHandler( + ProductServiceResolveStorageLinkedStoragesProcedure, + svc.ResolveStorageLinkedStorages, + connect.WithSchema(productServiceMethods.ByName("ResolveStorageLinkedStorages")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveStorageNearbyStoragesHandler := connect.NewUnaryHandler( + ProductServiceResolveStorageNearbyStoragesProcedure, + svc.ResolveStorageNearbyStorages, + connect.WithSchema(productServiceMethods.ByName("ResolveStorageNearbyStorages")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveStorageStorageStatusHandler := connect.NewUnaryHandler( + ProductServiceResolveStorageStorageStatusProcedure, + svc.ResolveStorageStorageStatus, + connect.WithSchema(productServiceMethods.ByName("ResolveStorageStorageStatus")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveSubcategoryFeaturedCategoryHandler := connect.NewUnaryHandler( + ProductServiceResolveSubcategoryFeaturedCategoryProcedure, + svc.ResolveSubcategoryFeaturedCategory, + connect.WithSchema(productServiceMethods.ByName("ResolveSubcategoryFeaturedCategory")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveSubcategoryItemCountHandler := connect.NewUnaryHandler( + ProductServiceResolveSubcategoryItemCountProcedure, + svc.ResolveSubcategoryItemCount, + connect.WithSchema(productServiceMethods.ByName("ResolveSubcategoryItemCount")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveSubcategoryParentCategoryHandler := connect.NewUnaryHandler( + ProductServiceResolveSubcategoryParentCategoryProcedure, + svc.ResolveSubcategoryParentCategory, + connect.WithSchema(productServiceMethods.ByName("ResolveSubcategoryParentCategory")), + connect.WithHandlerOptions(opts...), + ) + productServiceResolveTestContainerDetailsHandler := connect.NewUnaryHandler( + ProductServiceResolveTestContainerDetailsProcedure, + svc.ResolveTestContainerDetails, + connect.WithSchema(productServiceMethods.ByName("ResolveTestContainerDetails")), + connect.WithHandlerOptions(opts...), + ) + return "/productv1.ProductService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case ProductServiceLookupProductByIdProcedure: + productServiceLookupProductByIdHandler.ServeHTTP(w, r) + case ProductServiceLookupStorageByIdProcedure: + productServiceLookupStorageByIdHandler.ServeHTTP(w, r) + case ProductServiceLookupWarehouseByIdProcedure: + productServiceLookupWarehouseByIdHandler.ServeHTTP(w, r) + case ProductServiceMutationBulkCreateAuthorsProcedure: + productServiceMutationBulkCreateAuthorsHandler.ServeHTTP(w, r) + case ProductServiceMutationBulkCreateBlogPostsProcedure: + productServiceMutationBulkCreateBlogPostsHandler.ServeHTTP(w, r) + case ProductServiceMutationBulkUpdateAuthorsProcedure: + productServiceMutationBulkUpdateAuthorsHandler.ServeHTTP(w, r) + case ProductServiceMutationBulkUpdateBlogPostsProcedure: + productServiceMutationBulkUpdateBlogPostsHandler.ServeHTTP(w, r) + case ProductServiceMutationCreateAuthorProcedure: + productServiceMutationCreateAuthorHandler.ServeHTTP(w, r) + case ProductServiceMutationCreateBlogPostProcedure: + productServiceMutationCreateBlogPostHandler.ServeHTTP(w, r) + case ProductServiceMutationCreateNullableFieldsTypeProcedure: + productServiceMutationCreateNullableFieldsTypeHandler.ServeHTTP(w, r) + case ProductServiceMutationCreateUserProcedure: + productServiceMutationCreateUserHandler.ServeHTTP(w, r) + case ProductServiceMutationPerformActionProcedure: + productServiceMutationPerformActionHandler.ServeHTTP(w, r) + case ProductServiceMutationUpdateAuthorProcedure: + productServiceMutationUpdateAuthorHandler.ServeHTTP(w, r) + case ProductServiceMutationUpdateBlogPostProcedure: + productServiceMutationUpdateBlogPostHandler.ServeHTTP(w, r) + case ProductServiceMutationUpdateNullableFieldsTypeProcedure: + productServiceMutationUpdateNullableFieldsTypeHandler.ServeHTTP(w, r) + case ProductServiceQueryAllAuthorsProcedure: + productServiceQueryAllAuthorsHandler.ServeHTTP(w, r) + case ProductServiceQueryAllBlogPostsProcedure: + productServiceQueryAllBlogPostsHandler.ServeHTTP(w, r) + case ProductServiceQueryAllNullableFieldsTypesProcedure: + productServiceQueryAllNullableFieldsTypesHandler.ServeHTTP(w, r) + case ProductServiceQueryAllPetsProcedure: + productServiceQueryAllPetsHandler.ServeHTTP(w, r) + case ProductServiceQueryAuthorProcedure: + productServiceQueryAuthorHandler.ServeHTTP(w, r) + case ProductServiceQueryAuthorByIdProcedure: + productServiceQueryAuthorByIdHandler.ServeHTTP(w, r) + case ProductServiceQueryAuthorsWithFilterProcedure: + productServiceQueryAuthorsWithFilterHandler.ServeHTTP(w, r) + case ProductServiceQueryBlogPostProcedure: + productServiceQueryBlogPostHandler.ServeHTTP(w, r) + case ProductServiceQueryBlogPostByIdProcedure: + productServiceQueryBlogPostByIdHandler.ServeHTTP(w, r) + case ProductServiceQueryBlogPostsWithFilterProcedure: + productServiceQueryBlogPostsWithFilterHandler.ServeHTTP(w, r) + case ProductServiceQueryBulkSearchAuthorsProcedure: + productServiceQueryBulkSearchAuthorsHandler.ServeHTTP(w, r) + case ProductServiceQueryBulkSearchBlogPostsProcedure: + productServiceQueryBulkSearchBlogPostsHandler.ServeHTTP(w, r) + case ProductServiceQueryCalculateTotalsProcedure: + productServiceQueryCalculateTotalsHandler.ServeHTTP(w, r) + case ProductServiceQueryCategoriesProcedure: + productServiceQueryCategoriesHandler.ServeHTTP(w, r) + case ProductServiceQueryCategoriesByKindProcedure: + productServiceQueryCategoriesByKindHandler.ServeHTTP(w, r) + case ProductServiceQueryCategoriesByKindsProcedure: + productServiceQueryCategoriesByKindsHandler.ServeHTTP(w, r) + case ProductServiceQueryCategoryProcedure: + productServiceQueryCategoryHandler.ServeHTTP(w, r) + case ProductServiceQueryComplexFilterTypeProcedure: + productServiceQueryComplexFilterTypeHandler.ServeHTTP(w, r) + case ProductServiceQueryConditionalSearchProcedure: + productServiceQueryConditionalSearchHandler.ServeHTTP(w, r) + case ProductServiceQueryFilterCategoriesProcedure: + productServiceQueryFilterCategoriesHandler.ServeHTTP(w, r) + case ProductServiceQueryNestedTypeProcedure: + productServiceQueryNestedTypeHandler.ServeHTTP(w, r) + case ProductServiceQueryNullableFieldsTypeProcedure: + productServiceQueryNullableFieldsTypeHandler.ServeHTTP(w, r) + case ProductServiceQueryNullableFieldsTypeByIdProcedure: + productServiceQueryNullableFieldsTypeByIdHandler.ServeHTTP(w, r) + case ProductServiceQueryNullableFieldsTypeWithFilterProcedure: + productServiceQueryNullableFieldsTypeWithFilterHandler.ServeHTTP(w, r) + case ProductServiceQueryRandomPetProcedure: + productServiceQueryRandomPetHandler.ServeHTTP(w, r) + case ProductServiceQueryRandomSearchResultProcedure: + productServiceQueryRandomSearchResultHandler.ServeHTTP(w, r) + case ProductServiceQueryRecursiveTypeProcedure: + productServiceQueryRecursiveTypeHandler.ServeHTTP(w, r) + case ProductServiceQuerySearchProcedure: + productServiceQuerySearchHandler.ServeHTTP(w, r) + case ProductServiceQueryTestContainerProcedure: + productServiceQueryTestContainerHandler.ServeHTTP(w, r) + case ProductServiceQueryTestContainersProcedure: + productServiceQueryTestContainersHandler.ServeHTTP(w, r) + case ProductServiceQueryTypeFilterWithArgumentsProcedure: + productServiceQueryTypeFilterWithArgumentsHandler.ServeHTTP(w, r) + case ProductServiceQueryTypeWithMultipleFilterFieldsProcedure: + productServiceQueryTypeWithMultipleFilterFieldsHandler.ServeHTTP(w, r) + case ProductServiceQueryUserProcedure: + productServiceQueryUserHandler.ServeHTTP(w, r) + case ProductServiceQueryUsersProcedure: + productServiceQueryUsersHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageCategoryInfoSummaryByIdProcedure: + productServiceRequireStorageCategoryInfoSummaryByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageDeepItemInfoByIdProcedure: + productServiceRequireStorageDeepItemInfoByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageFilteredTagSummaryByIdProcedure: + productServiceRequireStorageFilteredTagSummaryByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageItemHandlerInfoByIdProcedure: + productServiceRequireStorageItemHandlerInfoByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageItemInfoByIdProcedure: + productServiceRequireStorageItemInfoByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageItemSpecsInfoByIdProcedure: + productServiceRequireStorageItemSpecsInfoByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageKindSummaryByIdProcedure: + productServiceRequireStorageKindSummaryByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageMetadataScoreByIdProcedure: + productServiceRequireStorageMetadataScoreByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageMultiFilteredTagSummaryByIdProcedure: + productServiceRequireStorageMultiFilteredTagSummaryByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageNullableFilteredTagSummaryByIdProcedure: + productServiceRequireStorageNullableFilteredTagSummaryByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageOperationReportByIdProcedure: + productServiceRequireStorageOperationReportByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageOptionalProcessedMetadataByIdProcedure: + productServiceRequireStorageOptionalProcessedMetadataByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageOptionalProcessedTagsByIdProcedure: + productServiceRequireStorageOptionalProcessedTagsByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageOptionalTagSummaryByIdProcedure: + productServiceRequireStorageOptionalTagSummaryByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageProcessedMetadataByIdProcedure: + productServiceRequireStorageProcessedMetadataByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageProcessedMetadataHistoryByIdProcedure: + productServiceRequireStorageProcessedMetadataHistoryByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageProcessedTagsByIdProcedure: + productServiceRequireStorageProcessedTagsByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageSecuritySummaryByIdProcedure: + productServiceRequireStorageSecuritySummaryByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageStockHealthScoreByIdProcedure: + productServiceRequireStorageStockHealthScoreByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireStorageTagSummaryByIdProcedure: + productServiceRequireStorageTagSummaryByIdHandler.ServeHTTP(w, r) + case ProductServiceRequireWarehouseStockHealthScoreByIdProcedure: + productServiceRequireWarehouseStockHealthScoreByIdHandler.ServeHTTP(w, r) + case ProductServiceResolveCategoryActiveSubcategoriesProcedure: + productServiceResolveCategoryActiveSubcategoriesHandler.ServeHTTP(w, r) + case ProductServiceResolveCategoryCategoryMetricsProcedure: + productServiceResolveCategoryCategoryMetricsHandler.ServeHTTP(w, r) + case ProductServiceResolveCategoryCategoryStatusProcedure: + productServiceResolveCategoryCategoryStatusHandler.ServeHTTP(w, r) + case ProductServiceResolveCategoryChildCategoriesProcedure: + productServiceResolveCategoryChildCategoriesHandler.ServeHTTP(w, r) + case ProductServiceResolveCategoryMascotProcedure: + productServiceResolveCategoryMascotHandler.ServeHTTP(w, r) + case ProductServiceResolveCategoryMetricsAverageScoreProcedure: + productServiceResolveCategoryMetricsAverageScoreHandler.ServeHTTP(w, r) + case ProductServiceResolveCategoryMetricsNormalizedScoreProcedure: + productServiceResolveCategoryMetricsNormalizedScoreHandler.ServeHTTP(w, r) + case ProductServiceResolveCategoryMetricsRelatedCategoryProcedure: + productServiceResolveCategoryMetricsRelatedCategoryHandler.ServeHTTP(w, r) + case ProductServiceResolveCategoryOptionalCategoriesProcedure: + productServiceResolveCategoryOptionalCategoriesHandler.ServeHTTP(w, r) + case ProductServiceResolveCategoryPopularityScoreProcedure: + productServiceResolveCategoryPopularityScoreHandler.ServeHTTP(w, r) + case ProductServiceResolveCategoryProductCountProcedure: + productServiceResolveCategoryProductCountHandler.ServeHTTP(w, r) + case ProductServiceResolveCategoryTopSubcategoryProcedure: + productServiceResolveCategoryTopSubcategoryHandler.ServeHTTP(w, r) + case ProductServiceResolveCategoryTotalProductsProcedure: + productServiceResolveCategoryTotalProductsHandler.ServeHTTP(w, r) + case ProductServiceResolveProductMascotRecommendationProcedure: + productServiceResolveProductMascotRecommendationHandler.ServeHTTP(w, r) + case ProductServiceResolveProductProductDetailsProcedure: + productServiceResolveProductProductDetailsHandler.ServeHTTP(w, r) + case ProductServiceResolveProductRecommendedCategoryProcedure: + productServiceResolveProductRecommendedCategoryHandler.ServeHTTP(w, r) + case ProductServiceResolveProductShippingEstimateProcedure: + productServiceResolveProductShippingEstimateHandler.ServeHTTP(w, r) + case ProductServiceResolveProductStockStatusProcedure: + productServiceResolveProductStockStatusHandler.ServeHTTP(w, r) + case ProductServiceResolveStorageLinkedStoragesProcedure: + productServiceResolveStorageLinkedStoragesHandler.ServeHTTP(w, r) + case ProductServiceResolveStorageNearbyStoragesProcedure: + productServiceResolveStorageNearbyStoragesHandler.ServeHTTP(w, r) + case ProductServiceResolveStorageStorageStatusProcedure: + productServiceResolveStorageStorageStatusHandler.ServeHTTP(w, r) + case ProductServiceResolveSubcategoryFeaturedCategoryProcedure: + productServiceResolveSubcategoryFeaturedCategoryHandler.ServeHTTP(w, r) + case ProductServiceResolveSubcategoryItemCountProcedure: + productServiceResolveSubcategoryItemCountHandler.ServeHTTP(w, r) + case ProductServiceResolveSubcategoryParentCategoryProcedure: + productServiceResolveSubcategoryParentCategoryHandler.ServeHTTP(w, r) + case ProductServiceResolveTestContainerDetailsProcedure: + productServiceResolveTestContainerDetailsHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedProductServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedProductServiceHandler struct{} + +func (UnimplementedProductServiceHandler) LookupProductById(context.Context, *connect.Request[productv1.LookupProductByIdRequest]) (*connect.Response[productv1.LookupProductByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.LookupProductById is not implemented")) +} + +func (UnimplementedProductServiceHandler) LookupStorageById(context.Context, *connect.Request[productv1.LookupStorageByIdRequest]) (*connect.Response[productv1.LookupStorageByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.LookupStorageById is not implemented")) +} + +func (UnimplementedProductServiceHandler) LookupWarehouseById(context.Context, *connect.Request[productv1.LookupWarehouseByIdRequest]) (*connect.Response[productv1.LookupWarehouseByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.LookupWarehouseById is not implemented")) +} + +func (UnimplementedProductServiceHandler) MutationBulkCreateAuthors(context.Context, *connect.Request[productv1.MutationBulkCreateAuthorsRequest]) (*connect.Response[productv1.MutationBulkCreateAuthorsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.MutationBulkCreateAuthors is not implemented")) +} + +func (UnimplementedProductServiceHandler) MutationBulkCreateBlogPosts(context.Context, *connect.Request[productv1.MutationBulkCreateBlogPostsRequest]) (*connect.Response[productv1.MutationBulkCreateBlogPostsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.MutationBulkCreateBlogPosts is not implemented")) +} + +func (UnimplementedProductServiceHandler) MutationBulkUpdateAuthors(context.Context, *connect.Request[productv1.MutationBulkUpdateAuthorsRequest]) (*connect.Response[productv1.MutationBulkUpdateAuthorsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.MutationBulkUpdateAuthors is not implemented")) +} + +func (UnimplementedProductServiceHandler) MutationBulkUpdateBlogPosts(context.Context, *connect.Request[productv1.MutationBulkUpdateBlogPostsRequest]) (*connect.Response[productv1.MutationBulkUpdateBlogPostsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.MutationBulkUpdateBlogPosts is not implemented")) +} + +func (UnimplementedProductServiceHandler) MutationCreateAuthor(context.Context, *connect.Request[productv1.MutationCreateAuthorRequest]) (*connect.Response[productv1.MutationCreateAuthorResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.MutationCreateAuthor is not implemented")) +} + +func (UnimplementedProductServiceHandler) MutationCreateBlogPost(context.Context, *connect.Request[productv1.MutationCreateBlogPostRequest]) (*connect.Response[productv1.MutationCreateBlogPostResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.MutationCreateBlogPost is not implemented")) +} + +func (UnimplementedProductServiceHandler) MutationCreateNullableFieldsType(context.Context, *connect.Request[productv1.MutationCreateNullableFieldsTypeRequest]) (*connect.Response[productv1.MutationCreateNullableFieldsTypeResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.MutationCreateNullableFieldsType is not implemented")) +} + +func (UnimplementedProductServiceHandler) MutationCreateUser(context.Context, *connect.Request[productv1.MutationCreateUserRequest]) (*connect.Response[productv1.MutationCreateUserResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.MutationCreateUser is not implemented")) +} + +func (UnimplementedProductServiceHandler) MutationPerformAction(context.Context, *connect.Request[productv1.MutationPerformActionRequest]) (*connect.Response[productv1.MutationPerformActionResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.MutationPerformAction is not implemented")) +} + +func (UnimplementedProductServiceHandler) MutationUpdateAuthor(context.Context, *connect.Request[productv1.MutationUpdateAuthorRequest]) (*connect.Response[productv1.MutationUpdateAuthorResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.MutationUpdateAuthor is not implemented")) +} + +func (UnimplementedProductServiceHandler) MutationUpdateBlogPost(context.Context, *connect.Request[productv1.MutationUpdateBlogPostRequest]) (*connect.Response[productv1.MutationUpdateBlogPostResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.MutationUpdateBlogPost is not implemented")) +} + +func (UnimplementedProductServiceHandler) MutationUpdateNullableFieldsType(context.Context, *connect.Request[productv1.MutationUpdateNullableFieldsTypeRequest]) (*connect.Response[productv1.MutationUpdateNullableFieldsTypeResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.MutationUpdateNullableFieldsType is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryAllAuthors(context.Context, *connect.Request[productv1.QueryAllAuthorsRequest]) (*connect.Response[productv1.QueryAllAuthorsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryAllAuthors is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryAllBlogPosts(context.Context, *connect.Request[productv1.QueryAllBlogPostsRequest]) (*connect.Response[productv1.QueryAllBlogPostsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryAllBlogPosts is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryAllNullableFieldsTypes(context.Context, *connect.Request[productv1.QueryAllNullableFieldsTypesRequest]) (*connect.Response[productv1.QueryAllNullableFieldsTypesResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryAllNullableFieldsTypes is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryAllPets(context.Context, *connect.Request[productv1.QueryAllPetsRequest]) (*connect.Response[productv1.QueryAllPetsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryAllPets is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryAuthor(context.Context, *connect.Request[productv1.QueryAuthorRequest]) (*connect.Response[productv1.QueryAuthorResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryAuthor is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryAuthorById(context.Context, *connect.Request[productv1.QueryAuthorByIdRequest]) (*connect.Response[productv1.QueryAuthorByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryAuthorById is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryAuthorsWithFilter(context.Context, *connect.Request[productv1.QueryAuthorsWithFilterRequest]) (*connect.Response[productv1.QueryAuthorsWithFilterResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryAuthorsWithFilter is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryBlogPost(context.Context, *connect.Request[productv1.QueryBlogPostRequest]) (*connect.Response[productv1.QueryBlogPostResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryBlogPost is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryBlogPostById(context.Context, *connect.Request[productv1.QueryBlogPostByIdRequest]) (*connect.Response[productv1.QueryBlogPostByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryBlogPostById is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryBlogPostsWithFilter(context.Context, *connect.Request[productv1.QueryBlogPostsWithFilterRequest]) (*connect.Response[productv1.QueryBlogPostsWithFilterResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryBlogPostsWithFilter is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryBulkSearchAuthors(context.Context, *connect.Request[productv1.QueryBulkSearchAuthorsRequest]) (*connect.Response[productv1.QueryBulkSearchAuthorsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryBulkSearchAuthors is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryBulkSearchBlogPosts(context.Context, *connect.Request[productv1.QueryBulkSearchBlogPostsRequest]) (*connect.Response[productv1.QueryBulkSearchBlogPostsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryBulkSearchBlogPosts is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryCalculateTotals(context.Context, *connect.Request[productv1.QueryCalculateTotalsRequest]) (*connect.Response[productv1.QueryCalculateTotalsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryCalculateTotals is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryCategories(context.Context, *connect.Request[productv1.QueryCategoriesRequest]) (*connect.Response[productv1.QueryCategoriesResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryCategories is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryCategoriesByKind(context.Context, *connect.Request[productv1.QueryCategoriesByKindRequest]) (*connect.Response[productv1.QueryCategoriesByKindResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryCategoriesByKind is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryCategoriesByKinds(context.Context, *connect.Request[productv1.QueryCategoriesByKindsRequest]) (*connect.Response[productv1.QueryCategoriesByKindsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryCategoriesByKinds is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryCategory(context.Context, *connect.Request[productv1.QueryCategoryRequest]) (*connect.Response[productv1.QueryCategoryResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryCategory is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryComplexFilterType(context.Context, *connect.Request[productv1.QueryComplexFilterTypeRequest]) (*connect.Response[productv1.QueryComplexFilterTypeResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryComplexFilterType is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryConditionalSearch(context.Context, *connect.Request[productv1.QueryConditionalSearchRequest]) (*connect.Response[productv1.QueryConditionalSearchResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryConditionalSearch is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryFilterCategories(context.Context, *connect.Request[productv1.QueryFilterCategoriesRequest]) (*connect.Response[productv1.QueryFilterCategoriesResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryFilterCategories is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryNestedType(context.Context, *connect.Request[productv1.QueryNestedTypeRequest]) (*connect.Response[productv1.QueryNestedTypeResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryNestedType is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryNullableFieldsType(context.Context, *connect.Request[productv1.QueryNullableFieldsTypeRequest]) (*connect.Response[productv1.QueryNullableFieldsTypeResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryNullableFieldsType is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryNullableFieldsTypeById(context.Context, *connect.Request[productv1.QueryNullableFieldsTypeByIdRequest]) (*connect.Response[productv1.QueryNullableFieldsTypeByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryNullableFieldsTypeById is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryNullableFieldsTypeWithFilter(context.Context, *connect.Request[productv1.QueryNullableFieldsTypeWithFilterRequest]) (*connect.Response[productv1.QueryNullableFieldsTypeWithFilterResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryNullableFieldsTypeWithFilter is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryRandomPet(context.Context, *connect.Request[productv1.QueryRandomPetRequest]) (*connect.Response[productv1.QueryRandomPetResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryRandomPet is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryRandomSearchResult(context.Context, *connect.Request[productv1.QueryRandomSearchResultRequest]) (*connect.Response[productv1.QueryRandomSearchResultResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryRandomSearchResult is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryRecursiveType(context.Context, *connect.Request[productv1.QueryRecursiveTypeRequest]) (*connect.Response[productv1.QueryRecursiveTypeResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryRecursiveType is not implemented")) +} + +func (UnimplementedProductServiceHandler) QuerySearch(context.Context, *connect.Request[productv1.QuerySearchRequest]) (*connect.Response[productv1.QuerySearchResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QuerySearch is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryTestContainer(context.Context, *connect.Request[productv1.QueryTestContainerRequest]) (*connect.Response[productv1.QueryTestContainerResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryTestContainer is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryTestContainers(context.Context, *connect.Request[productv1.QueryTestContainersRequest]) (*connect.Response[productv1.QueryTestContainersResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryTestContainers is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryTypeFilterWithArguments(context.Context, *connect.Request[productv1.QueryTypeFilterWithArgumentsRequest]) (*connect.Response[productv1.QueryTypeFilterWithArgumentsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryTypeFilterWithArguments is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryTypeWithMultipleFilterFields(context.Context, *connect.Request[productv1.QueryTypeWithMultipleFilterFieldsRequest]) (*connect.Response[productv1.QueryTypeWithMultipleFilterFieldsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryTypeWithMultipleFilterFields is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryUser(context.Context, *connect.Request[productv1.QueryUserRequest]) (*connect.Response[productv1.QueryUserResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryUser is not implemented")) +} + +func (UnimplementedProductServiceHandler) QueryUsers(context.Context, *connect.Request[productv1.QueryUsersRequest]) (*connect.Response[productv1.QueryUsersResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.QueryUsers is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageCategoryInfoSummaryById(context.Context, *connect.Request[productv1.RequireStorageCategoryInfoSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageCategoryInfoSummaryByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageCategoryInfoSummaryById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageDeepItemInfoById(context.Context, *connect.Request[productv1.RequireStorageDeepItemInfoByIdRequest]) (*connect.Response[productv1.RequireStorageDeepItemInfoByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageDeepItemInfoById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageFilteredTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageFilteredTagSummaryByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageFilteredTagSummaryById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageItemHandlerInfoById(context.Context, *connect.Request[productv1.RequireStorageItemHandlerInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemHandlerInfoByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageItemHandlerInfoById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageItemInfoById(context.Context, *connect.Request[productv1.RequireStorageItemInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemInfoByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageItemInfoById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageItemSpecsInfoById(context.Context, *connect.Request[productv1.RequireStorageItemSpecsInfoByIdRequest]) (*connect.Response[productv1.RequireStorageItemSpecsInfoByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageItemSpecsInfoById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageKindSummaryById(context.Context, *connect.Request[productv1.RequireStorageKindSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageKindSummaryByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageKindSummaryById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageMetadataScoreById(context.Context, *connect.Request[productv1.RequireStorageMetadataScoreByIdRequest]) (*connect.Response[productv1.RequireStorageMetadataScoreByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageMetadataScoreById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageMultiFilteredTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageMultiFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageMultiFilteredTagSummaryByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageMultiFilteredTagSummaryById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageNullableFilteredTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageNullableFilteredTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageNullableFilteredTagSummaryByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageNullableFilteredTagSummaryById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageOperationReportById(context.Context, *connect.Request[productv1.RequireStorageOperationReportByIdRequest]) (*connect.Response[productv1.RequireStorageOperationReportByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageOperationReportById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageOptionalProcessedMetadataById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedMetadataByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageOptionalProcessedMetadataById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageOptionalProcessedTagsById(context.Context, *connect.Request[productv1.RequireStorageOptionalProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalProcessedTagsByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageOptionalProcessedTagsById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageOptionalTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageOptionalTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageOptionalTagSummaryByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageOptionalTagSummaryById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageProcessedMetadataById(context.Context, *connect.Request[productv1.RequireStorageProcessedMetadataByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedMetadataByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageProcessedMetadataById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageProcessedMetadataHistoryById(context.Context, *connect.Request[productv1.RequireStorageProcessedMetadataHistoryByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedMetadataHistoryByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageProcessedMetadataHistoryById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageProcessedTagsById(context.Context, *connect.Request[productv1.RequireStorageProcessedTagsByIdRequest]) (*connect.Response[productv1.RequireStorageProcessedTagsByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageProcessedTagsById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageSecuritySummaryById(context.Context, *connect.Request[productv1.RequireStorageSecuritySummaryByIdRequest]) (*connect.Response[productv1.RequireStorageSecuritySummaryByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageSecuritySummaryById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageStockHealthScoreById(context.Context, *connect.Request[productv1.RequireStorageStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireStorageStockHealthScoreByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageStockHealthScoreById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireStorageTagSummaryById(context.Context, *connect.Request[productv1.RequireStorageTagSummaryByIdRequest]) (*connect.Response[productv1.RequireStorageTagSummaryByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireStorageTagSummaryById is not implemented")) +} + +func (UnimplementedProductServiceHandler) RequireWarehouseStockHealthScoreById(context.Context, *connect.Request[productv1.RequireWarehouseStockHealthScoreByIdRequest]) (*connect.Response[productv1.RequireWarehouseStockHealthScoreByIdResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.RequireWarehouseStockHealthScoreById is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveCategoryActiveSubcategories(context.Context, *connect.Request[productv1.ResolveCategoryActiveSubcategoriesRequest]) (*connect.Response[productv1.ResolveCategoryActiveSubcategoriesResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveCategoryActiveSubcategories is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveCategoryCategoryMetrics(context.Context, *connect.Request[productv1.ResolveCategoryCategoryMetricsRequest]) (*connect.Response[productv1.ResolveCategoryCategoryMetricsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveCategoryCategoryMetrics is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveCategoryCategoryStatus(context.Context, *connect.Request[productv1.ResolveCategoryCategoryStatusRequest]) (*connect.Response[productv1.ResolveCategoryCategoryStatusResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveCategoryCategoryStatus is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveCategoryChildCategories(context.Context, *connect.Request[productv1.ResolveCategoryChildCategoriesRequest]) (*connect.Response[productv1.ResolveCategoryChildCategoriesResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveCategoryChildCategories is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveCategoryMascot(context.Context, *connect.Request[productv1.ResolveCategoryMascotRequest]) (*connect.Response[productv1.ResolveCategoryMascotResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveCategoryMascot is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveCategoryMetricsAverageScore(context.Context, *connect.Request[productv1.ResolveCategoryMetricsAverageScoreRequest]) (*connect.Response[productv1.ResolveCategoryMetricsAverageScoreResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveCategoryMetricsAverageScore is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveCategoryMetricsNormalizedScore(context.Context, *connect.Request[productv1.ResolveCategoryMetricsNormalizedScoreRequest]) (*connect.Response[productv1.ResolveCategoryMetricsNormalizedScoreResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveCategoryMetricsNormalizedScore is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveCategoryMetricsRelatedCategory(context.Context, *connect.Request[productv1.ResolveCategoryMetricsRelatedCategoryRequest]) (*connect.Response[productv1.ResolveCategoryMetricsRelatedCategoryResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveCategoryMetricsRelatedCategory is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveCategoryOptionalCategories(context.Context, *connect.Request[productv1.ResolveCategoryOptionalCategoriesRequest]) (*connect.Response[productv1.ResolveCategoryOptionalCategoriesResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveCategoryOptionalCategories is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveCategoryPopularityScore(context.Context, *connect.Request[productv1.ResolveCategoryPopularityScoreRequest]) (*connect.Response[productv1.ResolveCategoryPopularityScoreResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveCategoryPopularityScore is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveCategoryProductCount(context.Context, *connect.Request[productv1.ResolveCategoryProductCountRequest]) (*connect.Response[productv1.ResolveCategoryProductCountResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveCategoryProductCount is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveCategoryTopSubcategory(context.Context, *connect.Request[productv1.ResolveCategoryTopSubcategoryRequest]) (*connect.Response[productv1.ResolveCategoryTopSubcategoryResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveCategoryTopSubcategory is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveCategoryTotalProducts(context.Context, *connect.Request[productv1.ResolveCategoryTotalProductsRequest]) (*connect.Response[productv1.ResolveCategoryTotalProductsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveCategoryTotalProducts is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveProductMascotRecommendation(context.Context, *connect.Request[productv1.ResolveProductMascotRecommendationRequest]) (*connect.Response[productv1.ResolveProductMascotRecommendationResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveProductMascotRecommendation is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveProductProductDetails(context.Context, *connect.Request[productv1.ResolveProductProductDetailsRequest]) (*connect.Response[productv1.ResolveProductProductDetailsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveProductProductDetails is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveProductRecommendedCategory(context.Context, *connect.Request[productv1.ResolveProductRecommendedCategoryRequest]) (*connect.Response[productv1.ResolveProductRecommendedCategoryResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveProductRecommendedCategory is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveProductShippingEstimate(context.Context, *connect.Request[productv1.ResolveProductShippingEstimateRequest]) (*connect.Response[productv1.ResolveProductShippingEstimateResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveProductShippingEstimate is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveProductStockStatus(context.Context, *connect.Request[productv1.ResolveProductStockStatusRequest]) (*connect.Response[productv1.ResolveProductStockStatusResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveProductStockStatus is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveStorageLinkedStorages(context.Context, *connect.Request[productv1.ResolveStorageLinkedStoragesRequest]) (*connect.Response[productv1.ResolveStorageLinkedStoragesResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveStorageLinkedStorages is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveStorageNearbyStorages(context.Context, *connect.Request[productv1.ResolveStorageNearbyStoragesRequest]) (*connect.Response[productv1.ResolveStorageNearbyStoragesResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveStorageNearbyStorages is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveStorageStorageStatus(context.Context, *connect.Request[productv1.ResolveStorageStorageStatusRequest]) (*connect.Response[productv1.ResolveStorageStorageStatusResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveStorageStorageStatus is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveSubcategoryFeaturedCategory(context.Context, *connect.Request[productv1.ResolveSubcategoryFeaturedCategoryRequest]) (*connect.Response[productv1.ResolveSubcategoryFeaturedCategoryResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveSubcategoryFeaturedCategory is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveSubcategoryItemCount(context.Context, *connect.Request[productv1.ResolveSubcategoryItemCountRequest]) (*connect.Response[productv1.ResolveSubcategoryItemCountResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveSubcategoryItemCount is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveSubcategoryParentCategory(context.Context, *connect.Request[productv1.ResolveSubcategoryParentCategoryRequest]) (*connect.Response[productv1.ResolveSubcategoryParentCategoryResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveSubcategoryParentCategory is not implemented")) +} + +func (UnimplementedProductServiceHandler) ResolveTestContainerDetails(context.Context, *connect.Request[productv1.ResolveTestContainerDetailsRequest]) (*connect.Response[productv1.ResolveTestContainerDetailsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("productv1.ProductService.ResolveTestContainerDetails is not implemented")) +}