diff --git a/v2/pkg/engine/datasource/grpc_datasource/compiler.go b/v2/pkg/engine/datasource/grpc_datasource/compiler.go index c41b829b9b..975f47cef6 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/compiler.go +++ b/v2/pkg/engine/datasource/grpc_datasource/compiler.go @@ -9,6 +9,7 @@ import ( "github.com/bufbuild/protocompile" "github.com/tidwall/gjson" + "google.golang.org/protobuf/proto" protoref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/types/dynamicpb" @@ -389,6 +390,7 @@ func (p *RPCCompiler) processFile(f protoref.FileDescriptor, mapping *GRPCMappin // ServiceCall represents a single gRPC service call with its input and output messages. type ServiceCall struct { + ID int // ServiceName is the name of the gRPC service to call ServiceName string // MethodName is the name of the method on the service to call @@ -401,6 +403,10 @@ type ServiceCall struct { RPC *RPCCall } +func (s *ServiceCall) CloneOutput() protoref.Message { + return proto.Clone(s.Output.Interface()).ProtoReflect() +} + func (s *ServiceCall) MethodFullName() string { var builder strings.Builder @@ -464,7 +470,7 @@ func (p *RPCCompiler) CompileFetches(graph *DependencyGraph, fetches []FetchItem return nil, err } - graph.SetFetchData(node.ID, &serviceCall) + serviceCall.ID = node.ID serviceCalls = append(serviceCalls, serviceCall) } @@ -600,10 +606,10 @@ func (p *RPCCompiler) buildProtoMessageWithContext(inputMessage Message, rpcMess contextList := p.newEmptyListMessageByName(rootMessage, contextSchemaField.Name) contextData := p.resolveContextData(context[0], contextRPCField) // TODO handle multiple contexts (resolver requires another resolver) - for _, data := range contextData { + for _, contextElement := range contextData { val := contextList.NewElement() valMsg := val.Message() - for fieldName, value := range data { + for fieldName, value := range contextElement { if err := p.setMessageValue(valMsg, fieldName, value); err != nil { return nil, err } @@ -636,13 +642,13 @@ func (p *RPCCompiler) buildProtoMessageWithContext(inputMessage Message, rpcMess } func (p *RPCCompiler) resolveContextData(context FetchItem, contextField *RPCField) []map[string]protoref.Value { - if context.ServiceCall == nil || context.ServiceCall.Output == nil { + if context.Output == nil { return []map[string]protoref.Value{} } contextValues := make([]map[string]protoref.Value, 0) for _, field := range contextField.Message.Fields { - values := p.resolveContextDataForPath(context.ServiceCall.Output, field.ResolvePath) + values := p.resolveContextDataForPath(context.Output, field.ResolvePath) for index, value := range values { if index >= len(contextValues) { @@ -676,7 +682,6 @@ func (p *RPCCompiler) resolveContextDataForPath(message protoref.Message, path a } return p.resolveDataForPath(msg.Message(), path) - } // resolveListDataForPath resolves the data for a given path in a list message. @@ -696,13 +701,14 @@ func (p *RPCCompiler) resolveListDataForPath(message protoref.List, fd protoref. for _, val := range values { if list, isList := val.Interface().(protoref.List); isList { - values := p.resolveListDataForPath(list, fd, path) + values := p.resolveListDataForPath(list, fd, path[1:]) result = append(result, values...) continue + } else { + result = append(result, val) } } - result = append(result, values...) default: result = append(result, item) } diff --git a/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go b/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go index 3a1c12b00f..9332803e7b 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go @@ -76,6 +76,8 @@ const ( // RPCCall represents a single call to a gRPC service method. // It contains all the information needed to make the call and process the response. type RPCCall struct { + // ID indicates the expected index of the call in the execution plan + ID int // Kind of call, used to decide how to execute the call // This is used to identify the call type and execution behaviour. Kind CallKind @@ -131,20 +133,6 @@ func (r *RPCMessage) SelectValidTypes(typeName string) []string { return []string{r.Name, typeName} } -// AppendTypeNameField appends a typename field to the message. -func (r *RPCMessage) AppendTypeNameField(typeName string) { - if r.Fields != nil && r.Fields.Exists(typenameFieldName, "") { - return - } - - r.Fields = append(r.Fields, RPCField{ - Name: typenameFieldName, - ProtoTypeName: DataTypeString, - StaticValue: typeName, - JSONPath: typenameFieldName, - }) -} - // RPCFieldSelectionSet is a map of field selections based on inline fragments type RPCFieldSelectionSet map[string]RPCFields @@ -292,8 +280,8 @@ func (r *RPCExecutionPlan) String() string { result.WriteString("RPCExecutionPlan:\n") - for j, call := range r.Calls { - result.WriteString(fmt.Sprintf(" Call %d:\n", j)) + for _, call := range r.Calls { + result.WriteString(fmt.Sprintf(" Call %d:\n", call.ID)) if len(call.DependentCalls) > 0 { result.WriteString(" DependentCalls: [") @@ -362,6 +350,7 @@ func formatRPCMessage(sb *strings.Builder, message RPCMessage, indent int) { fmt.Fprintf(sb, "%s TypeName: %s\n", indentStr, field.ProtoTypeName) fmt.Fprintf(sb, "%s Repeated: %v\n", indentStr, field.Repeated) fmt.Fprintf(sb, "%s JSONPath: %s\n", indentStr, field.JSONPath) + fmt.Fprintf(sb, "%s ResolvePath: %s\n", indentStr, field.ResolvePath.String()) if field.Message != nil { fmt.Fprintf(sb, "%s Message:\n", indentStr) @@ -474,6 +463,15 @@ func (r *rpcPlanningContext) newMessageFromSelectionSet(enclosingTypeNode ast.No return message } +func (r *rpcPlanningContext) findResolverFieldMapping(typeName, fieldName string) string { + resolveConfig := r.mapping.FindResolveTypeFieldMapping(typeName, fieldName) + if resolveConfig == nil { + return fieldName + } + + return resolveConfig.FieldMappingData.TargetName +} + // resolveFieldMapping resolves the field mapping for a field. // This applies both for complex types in the input and for all fields in the response. func (r *rpcPlanningContext) resolveFieldMapping(typeName, fieldName string) string { @@ -531,25 +529,25 @@ func (r *rpcPlanningContext) createListMetadata(typeRef int) (*ListMetadata, err // buildField builds a field from a field definition. // It handles lists, enums, and other types. -func (r *rpcPlanningContext) buildField(enclosingTypeNode ast.Node, fd int, fieldName, fieldAlias string) (RPCField, error) { - fdt := r.definition.FieldDefinitionType(fd) - typeName := r.toDataType(&r.definition.Types[fdt]) +func (r *rpcPlanningContext) buildField(enclosingTypeNode ast.Node, fieldDef int, fieldName, fieldAlias string) (RPCField, error) { + fieldDefType := r.definition.FieldDefinitionType(fieldDef) + typeName := r.toDataType(&r.definition.Types[fieldDefType]) parentTypeName := enclosingTypeNode.NameString(r.definition) field := RPCField{ Name: r.resolveFieldMapping(parentTypeName, fieldName), Alias: fieldAlias, - Optional: !r.definition.TypeIsNonNull(fdt), + Optional: !r.definition.TypeIsNonNull(fieldDefType), JSONPath: fieldName, ProtoTypeName: typeName, } - if r.definition.TypeIsList(fdt) { + if r.definition.TypeIsList(fieldDefType) { switch { // for nullable or nested lists we need to build a wrapper message // Nullability is handled by the datasource during the execution. - case r.typeIsNullableOrNestedList(fdt): - md, err := r.createListMetadata(fdt) + case r.typeIsNullableOrNestedList(fieldDefType): + md, err := r.createListMetadata(fieldDefType) if err != nil { return field, err } @@ -562,7 +560,7 @@ func (r *rpcPlanningContext) buildField(enclosingTypeNode ast.Node, fd int, fiel } if typeName == DataTypeEnum { - field.EnumName = r.definition.FieldDefinitionTypeNameString(fd) + field.EnumName = r.definition.FieldDefinitionTypeNameString(fieldDef) } if fieldName == typenameFieldName { @@ -808,17 +806,20 @@ func (r *rpcPlanningContext) resolveServiceName(subgraphName string) string { } type resolverField struct { + id int callerRef int parentTypeNode ast.Node fieldRef int fieldDefinitionTypeRef int fieldsSelectionSetRef int responsePath ast.Path + contextPath ast.Path contextFields []contextField fieldArguments []fieldArgument fragmentSelections []fragmentSelection fragmentType OneOfType + listNestingLevel int memberTypes []string } @@ -907,8 +908,11 @@ func (r *rpcPlanningContext) setResolvedField(walker *astvisitor.Walker, fieldDe } for _, contextFieldRef := range contextFields { - contextFieldName := r.definition.FieldDefinitionNameBytes(contextFieldRef) - resolvedPath := fieldPath.WithFieldNameItem(contextFieldName) + mapping := r.resolveFieldMapping( + walker.EnclosingTypeDefinition.NameString(r.definition), + r.definition.FieldDefinitionNameString(contextFieldRef), + ) + resolvedPath := fieldPath.WithFieldNameItem([]byte(mapping)) resolvedField.contextFields = append(resolvedField.contextFields, contextField{ fieldRef: contextFieldRef, @@ -922,6 +926,12 @@ func (r *rpcPlanningContext) setResolvedField(walker *astvisitor.Walker, fieldDe } resolvedField.fieldArguments = fieldArguments + + fieldDefType := r.definition.FieldDefinitionType(fieldDefRef) + if r.typeIsNullableOrNestedList(fieldDefType) { + resolvedField.listNestingLevel = r.definition.TypeNumberOfListWraps(fieldDefType) + } + return nil } @@ -1306,6 +1316,19 @@ func (r *rpcPlanningContext) newResolveRPCCall(config *resolveRPCCallConfig) (RP } } + fd := r.fieldDefinitionRefForType(r.operation.FieldNameString(resolvedField.fieldRef), resolvedField.parentTypeNode.NameString(r.definition)) + if fd == ast.InvalidRef { + return RPCCall{}, fmt.Errorf("unable to build response field: field definition not found for field %s", r.operation.FieldNameString(resolvedField.fieldRef)) + } + + field, err := r.buildField(resolvedField.parentTypeNode, fd, r.operation.FieldNameString(resolvedField.fieldRef), r.operation.FieldAliasString(resolvedField.fieldRef)) + if err != nil { + return RPCCall{}, err + } + + field.Name = resolveConfig.FieldMappingData.TargetName + field.Message = responseFieldsMessage + response := RPCMessage{ Name: resolveConfig.Response, Fields: RPCFields{ @@ -1315,22 +1338,15 @@ func (r *rpcPlanningContext) newResolveRPCCall(config *resolveRPCCallConfig) (RP JSONPath: resultFieldName, Repeated: true, Message: &RPCMessage{ - Name: resolveConfig.RPC + "Result", - Fields: RPCFields{ - { - Name: resolveConfig.FieldMappingData.TargetName, - ProtoTypeName: dataType, - JSONPath: r.operation.FieldAliasOrNameString(resolvedField.fieldRef), - Message: responseFieldsMessage, - Optional: !r.definition.TypeIsNonNull(resolvedField.fieldDefinitionTypeRef), - }, - }, + Name: resolveConfig.RPC + "Result", + Fields: RPCFields{field}, }, }, }, } return RPCCall{ + ID: resolvedField.id, DependentCalls: []int{resolvedField.callerRef}, ResponsePath: resolvedField.responsePath, MethodName: resolveConfig.RPC, diff --git a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_federation_test.go b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_federation_test.go index 7f19058c31..d858b173fb 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_federation_test.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_federation_test.go @@ -202,6 +202,7 @@ func TestEntityLookup(t *testing.T) { }, }, { + ID: 1, ServiceName: "Products", MethodName: "LookupStorageById", Kind: CallKindEntity, @@ -1078,6 +1079,7 @@ func TestEntityLookupWithFieldResolvers(t *testing.T) { }, }, { + ID: 1, ServiceName: "Products", MethodName: "ResolveProductShippingEstimate", Kind: CallKindResolve, @@ -1254,6 +1256,7 @@ func TestEntityLookupWithFieldResolvers(t *testing.T) { }, }, { + ID: 1, ServiceName: "Products", MethodName: "LookupProductById", Kind: CallKindEntity, @@ -1318,6 +1321,7 @@ func TestEntityLookupWithFieldResolvers(t *testing.T) { }, }, { + ID: 2, ServiceName: "Products", MethodName: "ResolveProductShippingEstimate", Kind: CallKindResolve, @@ -1525,6 +1529,7 @@ func TestEntityLookupWithFieldResolvers_WithCompositeTypes(t *testing.T) { }, }, { + ID: 1, ServiceName: "Products", MethodName: "ResolveProductMascotRecommendation", Kind: CallKindResolve, @@ -1702,6 +1707,7 @@ func TestEntityLookupWithFieldResolvers_WithCompositeTypes(t *testing.T) { }, }, { + ID: 1, ServiceName: "Products", MethodName: "ResolveProductStockStatus", Kind: CallKindResolve, @@ -1889,6 +1895,7 @@ func TestEntityLookupWithFieldResolvers_WithCompositeTypes(t *testing.T) { }, }, { + ID: 1, ServiceName: "Products", MethodName: "ResolveProductProductDetails", Kind: CallKindResolve, diff --git a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_field_resolvers_test.go b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_field_resolvers_test.go index b9d534368e..43ca958dc4 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_field_resolvers_test.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_field_resolvers_test.go @@ -62,6 +62,7 @@ func TestExecutionPlanFieldResolvers(t *testing.T) { }, }, { + ID: 1, DependentCalls: []int{0}, ServiceName: "Products", MethodName: "ResolveCategoryProductCount", @@ -193,6 +194,7 @@ func TestExecutionPlanFieldResolvers(t *testing.T) { }, }, { + ID: 1, DependentCalls: []int{0}, ServiceName: "Products", MethodName: "ResolveCategoryProductCount", @@ -285,7 +287,8 @@ func TestExecutionPlanFieldResolvers(t *testing.T) { { Name: "product_count", ProtoTypeName: DataTypeInt32, - JSONPath: "productCount1", + JSONPath: "productCount", + Alias: "productCount1", }, }, }, @@ -294,6 +297,7 @@ func TestExecutionPlanFieldResolvers(t *testing.T) { }, }, { + ID: 2, DependentCalls: []int{0}, ServiceName: "Products", MethodName: "ResolveCategoryProductCount", @@ -386,7 +390,8 @@ func TestExecutionPlanFieldResolvers(t *testing.T) { { Name: "product_count", ProtoTypeName: DataTypeInt32, - JSONPath: "productCount2", + JSONPath: "productCount", + Alias: "productCount2", }, }, }, @@ -469,6 +474,7 @@ func TestExecutionPlanFieldResolvers(t *testing.T) { }, }, { + ID: 1, DependentCalls: []int{0}, ServiceName: "Products", MethodName: "ResolveSubcategoryItemCount", @@ -600,6 +606,7 @@ func TestExecutionPlanFieldResolvers(t *testing.T) { }, }, { + ID: 1, DependentCalls: []int{0}, Kind: CallKindResolve, ServiceName: "Products", @@ -723,6 +730,7 @@ func TestExecutionPlanFieldResolvers(t *testing.T) { }, }, { + ID: 1, DependentCalls: []int{0}, Kind: CallKindResolve, ServiceName: "Products", @@ -849,6 +857,7 @@ func TestExecutionPlanFieldResolvers(t *testing.T) { }, }, { + ID: 1, DependentCalls: []int{0}, ServiceName: "Products", MethodName: "ResolveCategoryPopularityScore", @@ -916,6 +925,7 @@ func TestExecutionPlanFieldResolvers(t *testing.T) { }, }, { + ID: 2, DependentCalls: []int{0}, ServiceName: "Products", MethodName: "ResolveCategoryCategoryMetrics", @@ -1060,6 +1070,7 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, { + ID: 1, DependentCalls: []int{0}, ServiceName: "Products", MethodName: "ResolveCategoryCategoryMetrics", @@ -1150,6 +1161,7 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, { + ID: 2, DependentCalls: []int{1}, ServiceName: "Products", MethodName: "ResolveCategoryMetricsNormalizedScore", @@ -1169,19 +1181,19 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { Name: "id", ProtoTypeName: DataTypeString, JSONPath: "id", - ResolvePath: buildPath("categories.categoryMetrics.id"), + ResolvePath: buildPath("result.category_metrics.id"), }, { Name: "value", ProtoTypeName: DataTypeDouble, JSONPath: "value", - ResolvePath: buildPath("categories.categoryMetrics.value"), + ResolvePath: buildPath("result.category_metrics.value"), }, { Name: "metric_type", ProtoTypeName: DataTypeString, JSONPath: "metricType", - ResolvePath: buildPath("categories.categoryMetrics.metricType"), + ResolvePath: buildPath("result.category_metrics.metric_type"), }, }, }, @@ -1227,18 +1239,1627 @@ func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { }, }, }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - runTest(t, testCase{ - query: tt.query, - expectedPlan: tt.expectedPlan, - expectedError: tt.expectedError, - }) - }) - } + { + name: "Should create an execution plan for a query with child categories field resolver", + query: "query CategoriesWithChildCategoriesFieldResolver { categories { childCategories { id name kind } } }", + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "QueryCategories", + Request: RPCMessage{ + Name: "QueryCategoriesRequest", + }, + Response: RPCMessage{ + Name: "QueryCategoriesResponse", + Fields: []RPCField{ + { + Name: "categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "categories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{}, + }, + }, + }, + }, + }, + { + ID: 1, + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryChildCategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.childCategories"), + Request: RPCMessage{ + Name: "ResolveCategoryChildCategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesArgs", + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryChildCategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesResult", + Fields: []RPCField{ + { + Name: "child_categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "childCategories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Should create an execution plan for a query with recursive child categories field resolver", + query: "query CategoriesWithRecursiveChildCategoriesFieldResolver { categories { childCategories { id name kind childCategories { id name kind } } } }", + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "QueryCategories", + Request: RPCMessage{ + Name: "QueryCategoriesRequest", + }, + Response: RPCMessage{ + Name: "QueryCategoriesResponse", + Fields: []RPCField{ + { + Name: "categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "categories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{}, + }, + }, + }, + }, + }, + { + ID: 1, + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryChildCategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.childCategories"), + Request: RPCMessage{ + Name: "ResolveCategoryChildCategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesArgs", + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryChildCategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesResult", + Fields: []RPCField{ + { + Name: "child_categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "childCategories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + ID: 2, + DependentCalls: []int{1}, + ServiceName: "Products", + MethodName: "ResolveCategoryChildCategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.childCategories.childCategories"), + Request: RPCMessage{ + Name: "ResolveCategoryChildCategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("result.child_categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("result.child_categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesArgs", + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryChildCategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesResult", + Fields: []RPCField{ + { + Name: "child_categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "childCategories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Should create an execution plan for a query with recursive child categories field resolver and aliases", + query: "query CategoriesWithRecursiveChildCategoriesFieldResolverAndAliases { categories { child: childCategories { id name kind childchild: childCategories { id name kind } } } }", + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "QueryCategories", + Request: RPCMessage{ + Name: "QueryCategoriesRequest", + }, + Response: RPCMessage{ + Name: "QueryCategoriesResponse", + Fields: []RPCField{ + { + Name: "categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "categories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{}, + }, + }, + }, + }, + }, + { + ID: 1, + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryChildCategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.child"), + Request: RPCMessage{ + Name: "ResolveCategoryChildCategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesArgs", + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryChildCategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesResult", + Fields: []RPCField{ + { + Name: "child_categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "childCategories", + Alias: "child", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + ID: 2, + DependentCalls: []int{1}, + ServiceName: "Products", + MethodName: "ResolveCategoryChildCategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.child.childchild"), + Request: RPCMessage{ + Name: "ResolveCategoryChildCategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("result.child_categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("result.child_categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesArgs", + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryChildCategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesResult", + Fields: []RPCField{ + { + Name: "child_categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "childCategories", + Alias: "childchild", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Should create an execution plan for a query with recursive multiple recursive field resolvers", + query: "query CategoriesWithRecursiveChildCategoriesFieldResolver { categories { childCategories { id name kind childCategories { id name kind childCategories { id name kind childCategories { id name kind } } } } } }", + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "QueryCategories", + Request: RPCMessage{ + Name: "QueryCategoriesRequest", + }, + Response: RPCMessage{ + Name: "QueryCategoriesResponse", + Fields: []RPCField{ + { + Name: "categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "categories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{}, + }, + }, + }, + }, + }, + { + ID: 1, + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryChildCategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.childCategories"), + Request: RPCMessage{ + Name: "ResolveCategoryChildCategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesArgs", + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryChildCategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesResult", + Fields: []RPCField{ + { + Name: "child_categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "childCategories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + ID: 2, + DependentCalls: []int{1}, + ServiceName: "Products", + MethodName: "ResolveCategoryChildCategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.childCategories.childCategories"), + Request: RPCMessage{ + Name: "ResolveCategoryChildCategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("result.child_categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("result.child_categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesArgs", + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryChildCategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesResult", + Fields: []RPCField{ + { + Name: "child_categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "childCategories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + ID: 3, + DependentCalls: []int{2}, + ServiceName: "Products", + MethodName: "ResolveCategoryChildCategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.childCategories.childCategories.childCategories"), + Request: RPCMessage{ + Name: "ResolveCategoryChildCategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("result.child_categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("result.child_categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesArgs", + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryChildCategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesResult", + Fields: []RPCField{ + { + Name: "child_categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "childCategories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + ID: 4, + DependentCalls: []int{3}, + ServiceName: "Products", + MethodName: "ResolveCategoryChildCategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.childCategories.childCategories.childCategories.childCategories"), + Request: RPCMessage{ + Name: "ResolveCategoryChildCategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("result.child_categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("result.child_categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesArgs", + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryChildCategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesResult", + Fields: []RPCField{ + { + Name: "child_categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "childCategories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Should create an execution plan for a query with optional categories field resolver without providing include argument", + query: "query CategoriesWithOptionalCategories { categories { optionalCategories { id name kind } } }", + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "QueryCategories", + Request: RPCMessage{ + Name: "QueryCategoriesRequest", + }, + Response: RPCMessage{ + Name: "QueryCategoriesResponse", + Fields: []RPCField{ + { + Name: "categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "categories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{}, + }, + }, + }, + }, + }, + { + ID: 1, + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryOptionalCategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.optionalCategories"), + Request: RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesArgs", + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesResult", + Fields: []RPCField{ + { + Name: "optional_categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "optionalCategories", + Optional: true, + IsListType: true, + ListMetadata: &ListMetadata{ + NestingLevel: 1, + LevelInfo: []LevelInfo{{Optional: true}}, + }, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Should create an execution plan for a query with optional categories and nested optional categories field resolver", + query: "query CategoriesWithOptionalCategories { categories { optionalCategories { id name kind optionalCategories { id name kind } } } }", + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "QueryCategories", + Request: RPCMessage{ + Name: "QueryCategoriesRequest", + }, + Response: RPCMessage{ + Name: "QueryCategoriesResponse", + Fields: []RPCField{ + { + Name: "categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "categories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{}, + }, + }, + }, + }, + }, + { + ID: 1, + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryOptionalCategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.optionalCategories"), + Request: RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesArgs", + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesResult", + Fields: []RPCField{ + { + Name: "optional_categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "optionalCategories", + Optional: true, + IsListType: true, + ListMetadata: &ListMetadata{ + NestingLevel: 1, + LevelInfo: []LevelInfo{{Optional: true}}, + }, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + ID: 2, + DependentCalls: []int{1}, + ServiceName: "Products", + MethodName: "ResolveCategoryOptionalCategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.optionalCategories.optionalCategories"), + Request: RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("result.@optional_categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("result.@optional_categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesArgs", + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesResult", + Fields: []RPCField{ + { + Name: "optional_categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "optionalCategories", + Optional: true, + IsListType: true, + ListMetadata: &ListMetadata{ + NestingLevel: 1, + LevelInfo: []LevelInfo{{Optional: true}}, + }, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Should create an execution plan for a query with both childCategories and optionalCategories with nested field resolvers sibling field resolvers", + query: "query CategoriesWithBothFieldResolversNested { categories { id name childCategories { id name kind optionalCategories { id name kind } } optionalCategories { id name kind childCategories { id name kind } } } }", + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "QueryCategories", + Request: RPCMessage{ + Name: "QueryCategoriesRequest", + }, + Response: RPCMessage{ + Name: "QueryCategoriesResponse", + Fields: []RPCField{ + { + Name: "categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "categories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + }, + }, + }, + }, + }, + { + ID: 1, + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryChildCategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.childCategories"), + Request: RPCMessage{ + Name: "ResolveCategoryChildCategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesArgs", + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryChildCategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesResult", + Fields: []RPCField{ + { + Name: "child_categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "childCategories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + ID: 2, + DependentCalls: []int{1}, + ServiceName: "Products", + MethodName: "ResolveCategoryOptionalCategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.childCategories.optionalCategories"), + Request: RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("result.child_categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("result.child_categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesArgs", + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesResult", + Fields: []RPCField{ + { + Name: "optional_categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "optionalCategories", + Optional: true, + IsListType: true, + ListMetadata: &ListMetadata{ + NestingLevel: 1, + LevelInfo: []LevelInfo{{Optional: true}}, + }, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + ID: 3, + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryOptionalCategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.optionalCategories"), + Request: RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesArgs", + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryOptionalCategoriesResult", + Fields: []RPCField{ + { + Name: "optional_categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "optionalCategories", + Optional: true, + IsListType: true, + ListMetadata: &ListMetadata{ + NestingLevel: 1, + LevelInfo: []LevelInfo{{Optional: true}}, + }, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + ID: 4, + DependentCalls: []int{3}, + ServiceName: "Products", + MethodName: "ResolveCategoryChildCategories", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.optionalCategories.childCategories"), + Request: RPCMessage{ + Name: "ResolveCategoryChildCategoriesRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("result.@optional_categories.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("result.@optional_categories.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesArgs", + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryChildCategoriesResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryChildCategoriesResult", + Fields: []RPCField{ + { + Name: "child_categories", + ProtoTypeName: DataTypeMessage, + JSONPath: "childCategories", + Repeated: true, + Message: &RPCMessage{ + Name: "Category", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + runTest(t, testCase{ + query: tt.query, + expectedPlan: tt.expectedPlan, + expectedError: tt.expectedError, + }) + }) + } + } func TestExecutionPlanFieldResolvers_WithCompositeTypes(t *testing.T) { @@ -1277,6 +2898,7 @@ func TestExecutionPlanFieldResolvers_WithCompositeTypes(t *testing.T) { }, }, { + ID: 1, DependentCalls: []int{0}, ServiceName: "Products", MethodName: "ResolveCategoryMascot", @@ -1399,6 +3021,7 @@ func TestExecutionPlanFieldResolvers_WithCompositeTypes(t *testing.T) { }, }, { + ID: 1, DependentCalls: []int{0}, ServiceName: "Products", MethodName: "ResolveCategoryCategoryStatus", @@ -1540,6 +3163,7 @@ func TestExecutionPlanFieldResolvers_WithCompositeTypes(t *testing.T) { }, }, { + ID: 1, DependentCalls: []int{0}, ServiceName: "Products", MethodName: "ResolveTestContainerDetails", @@ -1702,6 +3326,7 @@ func TestExecutionPlanFieldResolvers_WithCompositeTypes(t *testing.T) { }, }, { + ID: 1, DependentCalls: []int{0}, ServiceName: "Products", MethodName: "ResolveTestContainerDetails", @@ -1864,6 +3489,7 @@ func TestExecutionPlanFieldResolvers_WithCompositeTypes(t *testing.T) { }, }, { + ID: 1, DependentCalls: []int{0}, ServiceName: "Products", MethodName: "ResolveTestContainerDetails", @@ -2062,6 +3688,7 @@ func TestExecutionPlanFieldResolvers_WithCompositeTypes(t *testing.T) { }, }, { + ID: 1, DependentCalls: []int{0}, ServiceName: "Products", MethodName: "ResolveTestContainerDetails", @@ -2369,6 +3996,7 @@ func TestExecutionPlanFieldResolvers_CustomSchemas(t *testing.T) { }, }, { + ID: 1, Kind: CallKindResolve, DependentCalls: []int{0}, ResponsePath: buildPath("foo.fooResolver"), @@ -2438,6 +4066,7 @@ func TestExecutionPlanFieldResolvers_CustomSchemas(t *testing.T) { }, }, { + ID: 2, Kind: CallKindResolve, DependentCalls: []int{1}, ResponsePath: buildPath("foo.fooResolver.bazResolver"), @@ -2457,7 +4086,7 @@ func TestExecutionPlanFieldResolvers_CustomSchemas(t *testing.T) { Name: "id", ProtoTypeName: DataTypeString, JSONPath: "id", - ResolvePath: buildPath("foo.fooResolver.id"), + ResolvePath: buildPath("result.foo_resolver.id"), }, }, }, @@ -2540,6 +4169,7 @@ func TestExecutionPlanFieldResolvers_CustomSchemas(t *testing.T) { }, }, { + ID: 1, Kind: CallKindResolve, DependentCalls: []int{0}, ResponsePath: buildPath("foo.fooResolver"), @@ -2655,6 +4285,7 @@ func TestExecutionPlanFieldResolvers_CustomSchemas(t *testing.T) { }, }, { + ID: 1, Kind: CallKindResolve, DependentCalls: []int{0}, ResponsePath: buildPath("foo.fooResolverOptionalArgument"), diff --git a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_test.go b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_test.go index 94c22cdc49..a80896fb89 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_test.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_test.go @@ -191,6 +191,7 @@ func TestQueryExecutionPlans(t *testing.T) { }, }, { + ID: 1, ServiceName: "Products", MethodName: "QueryUser", Request: RPCMessage{ @@ -1647,6 +1648,7 @@ func TestProductExecutionPlanWithAliases(t *testing.T) { }, }, { + ID: 1, ServiceName: "Products", MethodName: "QueryCategories", Request: RPCMessage{ @@ -2165,6 +2167,7 @@ func TestProductExecutionPlanWithAliases(t *testing.T) { }, }, { + ID: 1, ServiceName: "Products", MethodName: "QueryUser", Request: RPCMessage{ @@ -2206,6 +2209,7 @@ func TestProductExecutionPlanWithAliases(t *testing.T) { }, }, { + ID: 2, ServiceName: "Products", MethodName: "QueryUser", Request: RPCMessage{ diff --git a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor.go b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor.go index 5e9391c1df..85f1878dd2 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor.go @@ -1,6 +1,7 @@ package grpcdatasource import ( + "bytes" "errors" "fmt" "strings" @@ -20,11 +21,8 @@ type planningInfo struct { currentRequestMessage *RPCMessage - responseMessageAncestors []*RPCMessage - currentResponseMessage *RPCMessage - currentResponseFieldIndex int - - responseFieldIndexAncestors []int + responseMessageAncestors []*RPCMessage + currentResponseMessage *RPCMessage } type contextField struct { @@ -46,17 +44,17 @@ type rpcPlanVisitor struct { planInfo planningInfo planCtx *rpcPlanningContext - subgraphName string - mapping *GRPCMapping - plan *RPCExecutionPlan - operationFieldRef int + subgraphName string + mapping *GRPCMapping + plan *RPCExecutionPlan + // The field reference to all operation fields in the operation. + // The first element is always pointing to the current root operation and shifts when a call is finalized. operationFieldRefs []int currentCall *RPCCall - currentCallID int + callIndex int // Global counter for all calls. - parentCallID int - fieldResolverAncestors stack[int] - resolverFields []resolverField + fieldResolverAncestors stack[int] // contains the indices of the resolver fields in the resolverFields slice + resolverFields []resolverField // contains information about the resolver fields. These are used to create the resolver calls when leaving the document. fieldPath ast.Path } @@ -76,9 +74,7 @@ func newRPCPlanVisitor(config rpcPlanVisitorConfig) *rpcPlanVisitor { plan: &RPCExecutionPlan{}, subgraphName: cases.Title(language.Und, cases.NoLower).String(config.subgraphName), mapping: config.mapping, - operationFieldRef: ast.InvalidRef, resolverFields: make([]resolverField, 0), - parentCallID: ast.InvalidRef, fieldResolverAncestors: newStack[int](0), fieldPath: make(ast.Path, 0), } @@ -135,9 +131,14 @@ func (r *rpcPlanVisitor) EnterOperationDefinition(ref int) { // These fields determine the names for the RPC functions to call. // TODO: handle fragments on root level `... on Query {}` selectionSetRef := r.operation.OperationDefinitions[ref].SelectionSet - r.operationFieldRefs = r.operation.SelectionSetFieldSelections(selectionSetRef) + r.operationFieldRefs = r.operation.SelectionSetFieldRefs(selectionSetRef) + + if len(r.operationFieldRefs) == 0 { + r.walker.StopWithInternalErr(fmt.Errorf("internal: unexpected operation definition with no fields")) + return + } - r.plan.Calls = make([]RPCCall, len(r.operationFieldRefs)) + r.plan.Calls = make([]RPCCall, 0, len(r.operationFieldRefs)) r.planInfo.operationType = r.operation.OperationDefinitions[ref].OperationType } @@ -146,7 +147,7 @@ func (r *rpcPlanVisitor) EnterOperationDefinition(ref int) { // and builds the request message from the input argument. func (r *rpcPlanVisitor) EnterArgument(ref int) { ancestor := r.walker.Ancestor() - if ancestor.Kind != ast.NodeKindField || ancestor.Ref != r.operationFieldRef { + if ancestor.Kind != ast.NodeKindField || ancestor.Ref != r.operationFieldRefs[0] { return } argumentInputValueDefinitionRef, exists := r.walker.ArgumentInputValueDefinition(ref) @@ -219,18 +220,21 @@ func (r *rpcPlanVisitor) EnterSelectionSet(ref int) { return } - if len(r.planInfo.currentResponseMessage.Fields) == 0 || len(r.planInfo.currentResponseMessage.Fields) <= r.planInfo.currentResponseFieldIndex { + // If we don't have any fields or selecting on a field, we can return. + if len(r.planInfo.currentResponseMessage.Fields) == 0 || r.walker.Ancestor().Kind != ast.NodeKindField { return } + lastIndex := len(r.planInfo.currentResponseMessage.Fields) - 1 + // In nested selection sets, a new message needs to be created, which will be added to the current response message. - if r.planInfo.currentResponseMessage.Fields[r.planInfo.currentResponseFieldIndex].Message == nil { - r.planInfo.currentResponseMessage.Fields[r.planInfo.currentResponseFieldIndex].Message = r.planCtx.newMessageFromSelectionSet(r.walker.EnclosingTypeDefinition, ref) + if r.planInfo.currentResponseMessage.Fields[lastIndex].Message == nil { + r.planInfo.currentResponseMessage.Fields[lastIndex].Message = r.planCtx.newMessageFromSelectionSet(r.walker.EnclosingTypeDefinition, ref) } // Add the current response message to the ancestors and set the current response message to the current field message r.planInfo.responseMessageAncestors = append(r.planInfo.responseMessageAncestors, r.planInfo.currentResponseMessage) - r.planInfo.currentResponseMessage = r.planInfo.currentResponseMessage.Fields[r.planInfo.currentResponseFieldIndex].Message + r.planInfo.currentResponseMessage = r.planInfo.currentResponseMessage.Fields[lastIndex].Message // Check if the ancestor type is a composite type (interface or union) // and set the oneof type and member types. @@ -240,13 +244,6 @@ func (r *rpcPlanVisitor) EnterSelectionSet(ref int) { r.walker.StopWithInternalErr(err) return } - - // Keep track of the field indices for the current response message. - // This is used to set the correct field index for the current response message - // when leaving the selection set. - r.planInfo.responseFieldIndexAncestors = append(r.planInfo.responseFieldIndexAncestors, r.planInfo.currentResponseFieldIndex) - - r.planInfo.currentResponseFieldIndex = 0 // reset the field index for the current selection set } func (r *rpcPlanVisitor) handleCompositeType(node ast.Node) error { @@ -293,11 +290,6 @@ func (r *rpcPlanVisitor) LeaveSelectionSet(ref int) { return } - if len(r.planInfo.responseFieldIndexAncestors) > 0 { - r.planInfo.currentResponseFieldIndex = r.planInfo.responseFieldIndexAncestors[len(r.planInfo.responseFieldIndexAncestors)-1] - r.planInfo.responseFieldIndexAncestors = r.planInfo.responseFieldIndexAncestors[:len(r.planInfo.responseFieldIndexAncestors)-1] - } - if len(r.planInfo.responseMessageAncestors) > 0 { r.planInfo.currentResponseMessage = r.planInfo.responseMessageAncestors[len(r.planInfo.responseMessageAncestors)-1] r.planInfo.responseMessageAncestors = r.planInfo.responseMessageAncestors[:len(r.planInfo.responseMessageAncestors)-1] @@ -309,14 +301,14 @@ func (r *rpcPlanVisitor) handleRootField(isRootField bool, ref int) error { return nil } - r.operationFieldRef = ref r.planInfo.operationFieldName = r.operation.FieldNameString(ref) r.currentCall = &RPCCall{ + ID: r.callIndex, ServiceName: r.planCtx.resolveServiceName(r.subgraphName), } - r.parentCallID = r.currentCallID + r.callIndex++ r.planInfo.currentRequestMessage = &r.currentCall.Request r.planInfo.currentResponseMessage = &r.currentCall.Response @@ -429,58 +421,65 @@ func (r *rpcPlanVisitor) LeaveField(ref int) { if r.planCtx.isFieldResolver(fieldDefRef, inRootField) { // Pop the field resolver ancestor only when leaving a field resolver field. r.fieldResolverAncestors.pop() - - // If the field has arguments, we need to decrement the related call ID. - // This is because we can also have nested arguments, which require the underlying field to be resolved - // by values provided by the parent call. - r.parentCallID-- - - // We handle field resolvers differently, so we don't want to increment the response field index. - return } - - // If we are not in the operation field, we can increment the response field index. - r.planInfo.currentResponseFieldIndex++ } // finalizeCall finalizes the current call and resets the current call. func (r *rpcPlanVisitor) finalizeCall() { - r.plan.Calls[r.currentCallID] = *r.currentCall + r.plan.Calls = append(r.plan.Calls, *r.currentCall) r.currentCall = nil - r.currentCallID++ - if r.currentCallID < len(r.operationFieldRefs) { - r.operationFieldRef = r.operationFieldRefs[r.currentCallID] + // If we have more than one root level operation field we remove the first one. + if len(r.operationFieldRefs) > 1 { + r.operationFieldRefs = r.operationFieldRefs[1:] } - - r.planInfo.currentResponseFieldIndex = 0 } // enterFieldResolver enters a field resolver. // ref is the field reference in the operation document. // fieldDefRef is the field definition reference in the definition document. +// TODO: extract to planCtx func (r *rpcPlanVisitor) enterFieldResolver(ref int, fieldDefRef int) { + defaultContextPath := ast.Path{{Kind: ast.FieldName, FieldName: []byte("result")}} // Field arguments for non root types will be handled as resolver calls. // We need to make sure to handle a hierarchy of arguments in order to perform parallel calls in order to retrieve the data. fieldArgs := r.operation.FieldArguments(ref) + + parentID := r.currentCall.ID + fieldPath := r.fieldPath + if r.fieldResolverAncestors.len() > 0 { + fieldPath = r.resolverFields[r.fieldResolverAncestors.peek()].contextPath + parentID = r.resolverFields[r.fieldResolverAncestors.peek()].id + } + // We don't want to add fields from the selection set to the actual call resolvedField := resolverField{ - callerRef: r.parentCallID, + id: r.callIndex, + callerRef: parentID, parentTypeNode: r.walker.EnclosingTypeDefinition, fieldRef: ref, responsePath: r.walker.Path[1:].WithoutInlineFragmentNames().WithFieldNameItem(r.operation.FieldAliasOrNameBytes(ref)), fieldDefinitionTypeRef: r.definition.FieldDefinitionType(fieldDefRef), } - if err := r.planCtx.setResolvedField(r.walker, fieldDefRef, fieldArgs, r.fieldPath, &resolvedField); err != nil { + r.callIndex++ + + if err := r.planCtx.setResolvedField(r.walker, fieldDefRef, fieldArgs, fieldPath, &resolvedField); err != nil { r.walker.StopWithInternalErr(err) return } + buf := bytes.Buffer{} + buf.Write(bytes.Repeat([]byte("@"), resolvedField.listNestingLevel)) + buf.WriteString(r.planCtx.findResolverFieldMapping( + r.walker.EnclosingTypeDefinition.NameString(r.definition), + r.definition.FieldDefinitionNameString(fieldDefRef), + )) + + resolvedField.contextPath = defaultContextPath.WithFieldNameItem(buf.Bytes()) + r.resolverFields = append(r.resolverFields, resolvedField) r.fieldResolverAncestors.push(len(r.resolverFields) - 1) - r.fieldPath = r.fieldPath.WithFieldNameItem(r.operation.FieldNameBytes(ref)) - // In case of nested fields with arguments, we need to increment the related call ID. - r.parentCallID++ + r.fieldPath = r.fieldPath.WithFieldNameItem(buf.Bytes()) } diff --git a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor_federation.go b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor_federation.go index c64f50fc55..2481dc224f 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor_federation.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor_federation.go @@ -1,6 +1,7 @@ package grpcdatasource import ( + "bytes" "errors" "fmt" "strings" @@ -50,9 +51,10 @@ type rpcPlanVisitorFederation struct { subgraphName string currentCall *RPCCall - parentCallID int + callIndex int // global counter for all calls. + // contains the indices of the resolver fields in the resolverFields slice fieldResolverAncestors stack[int] - resolvedFields []resolverField + resolverFields []resolverField fieldPath ast.Path } @@ -69,9 +71,8 @@ func newRPCPlanVisitorFederation(config rpcPlanVisitorConfig) *rpcPlanVisitorFed entityInlineFragmentRef: ast.InvalidRef, }, federationConfigData: parseFederationConfigData(config.federationConfigs), - resolvedFields: make([]resolverField, 0), + resolverFields: make([]resolverField, 0), fieldResolverAncestors: newStack[int](0), - parentCallID: ast.InvalidRef, fieldPath: ast.Path{}.WithFieldNameItem([]byte("result")), } @@ -104,18 +105,18 @@ func (r *rpcPlanVisitorFederation) EnterDocument(operation *ast.Document, defini // LeaveDocument implements astvisitor.DocumentVisitor. func (r *rpcPlanVisitorFederation) LeaveDocument(_, _ *ast.Document) { - if len(r.resolvedFields) == 0 { + if len(r.resolverFields) == 0 { return } - calls, err := r.planCtx.createResolverRPCCalls(r.subgraphName, r.resolvedFields) + calls, err := r.planCtx.createResolverRPCCalls(r.subgraphName, r.resolverFields) if err != nil { r.walker.StopWithInternalErr(err) return } r.plan.Calls = append(r.plan.Calls, calls...) - r.resolvedFields = nil + r.resolverFields = nil } @@ -138,11 +139,12 @@ func (r *rpcPlanVisitorFederation) EnterInlineFragment(ref int) { } r.currentCall = &RPCCall{ + ID: r.callIndex, ServiceName: r.planCtx.resolveServiceName(r.subgraphName), Kind: CallKindEntity, } - r.parentCallID = len(r.plan.Calls) + r.callIndex++ r.planInfo.currentRequestMessage = &r.currentCall.Request r.planInfo.currentResponseMessage = &r.currentCall.Response @@ -168,13 +170,11 @@ func (r *rpcPlanVisitorFederation) LeaveInlineFragment(ref int) { r.currentCall = &RPCCall{} r.planInfo = planningInfo{ - operationType: r.planInfo.operationType, - operationFieldName: r.planInfo.operationFieldName, - currentRequestMessage: &RPCMessage{}, - currentResponseMessage: &RPCMessage{}, - currentResponseFieldIndex: 0, - responseMessageAncestors: []*RPCMessage{}, - responseFieldIndexAncestors: []int{}, + operationType: r.planInfo.operationType, + operationFieldName: r.planInfo.operationFieldName, + currentRequestMessage: &RPCMessage{}, + currentResponseMessage: &RPCMessage{}, + responseMessageAncestors: []*RPCMessage{}, } r.entityInfo.entityInlineFragmentRef = ast.InvalidRef @@ -199,34 +199,31 @@ func (r *rpcPlanVisitorFederation) EnterSelectionSet(ref int) { r.walker.StopWithInternalErr(err) return } - resolvedField := &r.resolvedFields[resolvedFieldAncestor] + resolvedField := &r.resolverFields[resolvedFieldAncestor] resolvedField.memberTypes = memberTypes r.planCtx.enterResolverCompositeSelectionSet(compositType, ref, resolvedField) return } - r.resolvedFields[resolvedFieldAncestor].fieldsSelectionSetRef = ref + r.resolverFields[resolvedFieldAncestor].fieldsSelectionSetRef = ref return } - if r.planInfo.currentRequestMessage == nil || len(r.planInfo.currentResponseMessage.Fields) == 0 || len(r.planInfo.currentResponseMessage.Fields) <= r.planInfo.currentResponseFieldIndex { + if r.planInfo.currentRequestMessage == nil || len(r.planInfo.currentResponseMessage.Fields) == 0 || r.walker.Ancestor().Kind != ast.NodeKindField { return } + // We ignore selection sets from inline fragments or fragment spreads. + lastIndex := len(r.planInfo.currentResponseMessage.Fields) - 1 + // In nested selection sets, a new message needs to be created, which will be added to the current response message. - if r.planInfo.currentResponseMessage.Fields[r.planInfo.currentResponseFieldIndex].Message == nil { - r.planInfo.currentResponseMessage.Fields[r.planInfo.currentResponseFieldIndex].Message = r.planCtx.newMessageFromSelectionSet(r.walker.EnclosingTypeDefinition, ref) + if r.planInfo.currentResponseMessage.Fields[lastIndex].Message == nil { + r.planInfo.currentResponseMessage.Fields[lastIndex].Message = r.planCtx.newMessageFromSelectionSet(r.walker.EnclosingTypeDefinition, ref) } // Add the current response message to the ancestors and set the current response message to the current field message r.planInfo.responseMessageAncestors = append(r.planInfo.responseMessageAncestors, r.planInfo.currentResponseMessage) - r.planInfo.currentResponseMessage = r.planInfo.currentResponseMessage.Fields[r.planInfo.currentResponseFieldIndex].Message - - // Ensure that the entity inline fragment message has a typename field, - // to map the json data after receiving the response. - if r.IsEntityInlineFragment(r.walker.Ancestor()) { - r.planInfo.currentResponseMessage.AppendTypeNameField(r.entityInfo.typeName) - } + r.planInfo.currentResponseMessage = r.planInfo.currentResponseMessage.Fields[lastIndex].Message // Check if the ancestor type is a composite type (interface or union) // and set the oneof type and member types. @@ -237,13 +234,6 @@ func (r *rpcPlanVisitorFederation) EnterSelectionSet(ref int) { return } - // Keep track of the field indices for the current response message. - // This is used to set the correct field index for the current response message - // when leaving the selection set. - r.planInfo.responseFieldIndexAncestors = append(r.planInfo.responseFieldIndexAncestors, r.planInfo.currentResponseFieldIndex) - - // Reset the field index for the current selection set to the length of the current response message fields. - r.planInfo.currentResponseFieldIndex = len(r.planInfo.currentResponseMessage.Fields) } func (r *rpcPlanVisitorFederation) handleCompositeType(node ast.Node) error { @@ -288,11 +278,6 @@ func (r *rpcPlanVisitorFederation) LeaveSelectionSet(ref int) { return } - if len(r.planInfo.responseFieldIndexAncestors) > 0 { - r.planInfo.currentResponseFieldIndex = r.planInfo.responseFieldIndexAncestors[len(r.planInfo.responseFieldIndexAncestors)-1] - r.planInfo.responseFieldIndexAncestors = r.planInfo.responseFieldIndexAncestors[:len(r.planInfo.responseFieldIndexAncestors)-1] - } - if len(r.planInfo.responseMessageAncestors) > 0 { r.planInfo.currentResponseMessage = r.planInfo.responseMessageAncestors[len(r.planInfo.responseMessageAncestors)-1] r.planInfo.responseMessageAncestors = r.planInfo.responseMessageAncestors[:len(r.planInfo.responseMessageAncestors)-1] @@ -398,47 +383,55 @@ func (r *rpcPlanVisitorFederation) LeaveField(ref int) { if r.planCtx.isFieldResolver(fieldDefRef, inRootField) { // Pop the field resolver ancestor only when leaving a field resolver field. r.fieldResolverAncestors.pop() - - // If the field has arguments, we need to decrement the related call ID. - // This is because we can also have nested arguments, which require the underlying field to be resolved - // by values provided by the parent call. - r.parentCallID-- - - // We handle field resolvers differently, so we don't want to increment the response field index. - return } - - // If we are not in the operation field, we can increment the response field index. - r.planInfo.currentResponseFieldIndex++ } // enterFieldResolver enters a field resolver. // ref is the field reference in the operation document. // fieldDefRef is the field definition reference in the definition document. +// TODO: extract to planCtx func (r *rpcPlanVisitorFederation) enterFieldResolver(ref int, fieldDefRef int) { + defaultContextPath := ast.Path{{Kind: ast.FieldName, FieldName: []byte("result")}} // Field arguments for non root types will be handled as resolver calls. // We need to make sure to handle a hierarchy of arguments in order to perform parallel calls in order to retrieve the data. fieldArgs := r.operation.FieldArguments(ref) // We don't want to add fields from the selection set to the actual call + + parentID := r.currentCall.ID + fieldPath := r.fieldPath + if r.fieldResolverAncestors.len() > 0 { + fieldPath = r.resolverFields[r.fieldResolverAncestors.peek()].contextPath + parentID = r.resolverFields[r.fieldResolverAncestors.peek()].id + } + resolvedField := resolverField{ - callerRef: r.parentCallID, + id: r.callIndex, + callerRef: parentID, parentTypeNode: r.walker.EnclosingTypeDefinition, fieldRef: ref, responsePath: r.walker.Path[1:].WithoutInlineFragmentNames().WithFieldNameItem(r.operation.FieldAliasOrNameBytes(ref)), fieldDefinitionTypeRef: r.definition.FieldDefinitionType(fieldDefRef), } - if err := r.planCtx.setResolvedField(r.walker, fieldDefRef, fieldArgs, r.fieldPath, &resolvedField); err != nil { + r.callIndex++ + + if err := r.planCtx.setResolvedField(r.walker, fieldDefRef, fieldArgs, fieldPath, &resolvedField); err != nil { r.walker.StopWithInternalErr(err) return } - r.resolvedFields = append(r.resolvedFields, resolvedField) - r.fieldResolverAncestors.push(len(r.resolvedFields) - 1) - r.fieldPath = r.fieldPath.WithFieldNameItem(r.operation.FieldNameBytes(ref)) + buf := bytes.Buffer{} + buf.Write(bytes.Repeat([]byte("@"), resolvedField.listNestingLevel)) + buf.WriteString(r.planCtx.findResolverFieldMapping( + r.walker.EnclosingTypeDefinition.NameString(r.definition), + r.definition.FieldDefinitionNameString(fieldDefRef), + )) - // In case of nested fields with arguments, we need to increment the related call ID. - r.parentCallID++ + resolvedField.contextPath = defaultContextPath.WithFieldNameItem(buf.Bytes()) + + r.resolverFields = append(r.resolverFields, resolvedField) + r.fieldResolverAncestors.push(len(r.resolverFields) - 1) + r.fieldPath = r.fieldPath.WithFieldNameItem(buf.Bytes()) } func (r *rpcPlanVisitorFederation) resolveEntityInformation(inlineFragmentRef int, fc federationConfigData) error { @@ -494,6 +487,18 @@ func (r *rpcPlanVisitorFederation) scaffoldEntityLookup(fc federationConfigData) }, } + entityMessage := &RPCMessage{ + Name: fc.entityTypeName, + Fields: []RPCField{ + { + Name: "__typename", + ProtoTypeName: DataTypeString, + JSONPath: "__typename", + StaticValue: fc.entityTypeName, + }, + }, + } + // The proto response message has a field `result` which is a list of entities. // As this is a special case we directly map it to _entities. r.planInfo.currentResponseMessage.Fields = []RPCField{ @@ -502,8 +507,11 @@ func (r *rpcPlanVisitorFederation) scaffoldEntityLookup(fc federationConfigData) ProtoTypeName: DataTypeMessage, JSONPath: "_entities", Repeated: true, + Message: entityMessage, }, } + + r.planInfo.currentResponseMessage = entityMessage } // FederationConfigDataByEntityTypeName returns the entity config data for the given entity type name. diff --git a/v2/pkg/engine/datasource/grpc_datasource/fetch.go b/v2/pkg/engine/datasource/grpc_datasource/fetch.go index 4752268575..a68bbe8c7c 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/fetch.go +++ b/v2/pkg/engine/datasource/grpc_datasource/fetch.go @@ -2,6 +2,9 @@ package grpcdatasource import ( "fmt" + "sync" + + protoref "google.golang.org/protobuf/reflect/protoreflect" ) // FetchItem is a single fetch item in the execution plan. @@ -9,13 +12,14 @@ import ( type FetchItem struct { ID int Plan *RPCCall - ServiceCall *ServiceCall + Output protoref.Message DependentFetches []int } // DependencyGraph is a graph of the calls in the execution plan. // It is used to determine the order in which to execute the calls. type DependencyGraph struct { + mu sync.RWMutex fetches []FetchItem // nodes is a list of lists of dependent calls. // Each node index corresponds to a call index in the execution plan @@ -38,12 +42,11 @@ func NewDependencyGraph(executionPlan *RPCExecutionPlan) *DependencyGraph { // Initialize the graph with the calls in the execution plan. // We create a FetchItem for each call and store the dependent call references. - for index, call := range executionPlan.Calls { - graph.nodes[index] = call.DependentCalls - graph.fetches[index] = FetchItem{ - ID: index, + for _, call := range executionPlan.Calls { + graph.nodes[call.ID] = call.DependentCalls + graph.fetches[call.ID] = FetchItem{ + ID: call.ID, Plan: &call, - ServiceCall: nil, DependentFetches: call.DependentCalls, } } @@ -119,7 +122,11 @@ func (g *DependencyGraph) TopologicalSortResolve(resolver func(nodes []FetchItem // After setting up the call hierarchy, we are grouping the calls by their level. chunks := make(map[int][]FetchItem) for callIndex, chunkIndex := range callHierarchyRefs { - chunks[chunkIndex] = append(chunks[chunkIndex], g.fetches[callIndex]) + fetch, err := g.Fetch(callIndex) + if err != nil { + return err + } + chunks[chunkIndex] = append(chunks[chunkIndex], fetch) } // We are iterating over the chunks and resolving the calls in the correct order. @@ -134,6 +141,9 @@ func (g *DependencyGraph) TopologicalSortResolve(resolver func(nodes []FetchItem // Fetch returns the fetch item for a given index. func (g *DependencyGraph) Fetch(index int) (FetchItem, error) { + g.mu.RLock() + defer g.mu.RUnlock() + if index < 0 || index >= len(g.fetches) { return FetchItem{}, fmt.Errorf("unable to find fetch %d in execution plan", index) } @@ -157,6 +167,9 @@ func (g *DependencyGraph) FetchDependencies(fetch *FetchItem) ([]FetchItem, erro } // SetFetchData sets the service call for a given index. -func (g *DependencyGraph) SetFetchData(index int, serviceCall *ServiceCall) { - g.fetches[index].ServiceCall = serviceCall +func (g *DependencyGraph) SetFetchData(index int, outputMessage protoref.Message) { + g.mu.Lock() + defer g.mu.Unlock() + + g.fetches[index].Output = outputMessage } diff --git a/v2/pkg/engine/datasource/grpc_datasource/fetch_test.go b/v2/pkg/engine/datasource/grpc_datasource/fetch_test.go index 8b9cefd6ba..e2edb26cf7 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/fetch_test.go +++ b/v2/pkg/engine/datasource/grpc_datasource/fetch_test.go @@ -10,30 +10,36 @@ func BenchmarkBuildDependencyGraph(b *testing.B) { executionPlan := &RPCExecutionPlan{ Calls: []RPCCall{ { + ID: 0, Kind: CallKindStandard, DependentCalls: []int{1}, MethodName: "Method1", }, { + ID: 1, Kind: CallKindStandard, MethodName: "Method2", }, { + ID: 2, Kind: CallKindStandard, DependentCalls: []int{0}, MethodName: "Method3", }, { + ID: 3, Kind: CallKindStandard, DependentCalls: []int{0}, MethodName: "Method4", }, { + ID: 4, Kind: CallKindStandard, DependentCalls: []int{0, 2}, MethodName: "Method5", }, { + ID: 5, Kind: CallKindStandard, MethodName: "Method6", }, @@ -54,30 +60,36 @@ func TestBuildDependencyGraph(t *testing.T) { executionPlan := &RPCExecutionPlan{ Calls: []RPCCall{ { + ID: 0, Kind: CallKindStandard, DependentCalls: []int{1}, MethodName: "Method1", }, { + ID: 1, Kind: CallKindStandard, MethodName: "Method2", }, { + ID: 2, Kind: CallKindStandard, DependentCalls: []int{0}, MethodName: "Method3", }, { + ID: 3, Kind: CallKindStandard, DependentCalls: []int{0}, MethodName: "Method4", }, { + ID: 4, Kind: CallKindStandard, DependentCalls: []int{0, 2}, MethodName: "Method5", }, { + ID: 5, Kind: CallKindStandard, MethodName: "Method6", }, @@ -101,10 +113,12 @@ func TestBuildDependencyGraph(t *testing.T) { executionPlan := &RPCExecutionPlan{ Calls: []RPCCall{ { + ID: 0, Kind: CallKindStandard, DependentCalls: []int{1}, }, { + ID: 1, Kind: CallKindStandard, }, }, @@ -129,10 +143,12 @@ func TestBuildDependencyGraph(t *testing.T) { executionPlan := &RPCExecutionPlan{ Calls: []RPCCall{ { + ID: 0, Kind: CallKindStandard, DependentCalls: []int{1}, }, { + ID: 1, Kind: CallKindStandard, DependentCalls: []int{0}, }, @@ -156,10 +172,12 @@ func TestBuildDependencyGraph(t *testing.T) { executionPlan := &RPCExecutionPlan{ Calls: []RPCCall{ { + ID: 0, Kind: CallKindStandard, DependentCalls: []int{1}, }, { + ID: 1, Kind: CallKindStandard, DependentCalls: []int{2}, }, diff --git a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource.go b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource.go index 948c182c3b..c5df124dd4 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource.go +++ b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource.go @@ -37,7 +37,6 @@ var _ resolve.DataSource = (*DataSource)(nil) // It handles the conversion of GraphQL queries to gRPC requests and // transforms the responses back to GraphQL format. type DataSource struct { - plan *RPCExecutionPlan graph *DependencyGraph cc grpc.ClientConnInterface rc *RPCCompiler @@ -72,7 +71,6 @@ func NewDataSource(client grpc.ClientConnInterface, config DataSourceConfig) (*D } return &DataSource{ - plan: plan, graph: NewDependencyGraph(plan), cc: client, rc: config.Compiler, @@ -122,6 +120,7 @@ func (d *DataSource) Load(ctx context.Context, input []byte, out *bytes.Buffer) return err } + d.graph.SetFetchData(serviceCall.ID, serviceCall.CloneOutput()) response, err := builder.marshalResponseJSON(&a, &serviceCall.RPC.Response, serviceCall.Output) if err != nil { return err 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 b4e4ef5cb3..836e177bd3 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_test.go +++ b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_test.go @@ -4566,10 +4566,660 @@ func Test_Datasource_Load_WithFieldResolvers(t *testing.T) { require.Empty(t, errData) }, }, + { + name: "Query with nested field resolver", + query: "query CategoriesWithNestedResolvers($metricType: String, $baseline: Float!) { categories { categoryMetrics(metricType: $metricType) { id normalizedScore(baseline: $baseline) metricType value } } }", + vars: `{"variables":{"metricType":"popularity_score","baseline":100}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + categories, ok := data["categories"].([]interface{}) + require.True(t, ok, "categories should be an array") + require.NotEmpty(t, categories, "categories should not be empty") + require.Len(t, categories, 4, "Should return 4 categories") + + for i, cat := range categories { + category, ok := cat.(map[string]interface{}) + require.True(t, ok, "category[%d] should be an object", i) + + // Validate categoryMetrics is present (returns a single object, not an array) + require.Contains(t, category, "categoryMetrics", "category[%d] should have 'categoryMetrics' field", i) + metric, ok := category["categoryMetrics"].(map[string]interface{}) + require.True(t, ok, "category[%d].categoryMetrics should be an object, got %T", i, category["categoryMetrics"]) + + // Validate id field is present and non-empty + require.Contains(t, metric, "id", "category[%d].categoryMetrics should have 'id' field", i) + require.NotEmpty(t, metric["id"], "category[%d].categoryMetrics.id should not be empty", i) + + // Validate normalizedScore is a numeric value (baseline was provided) + require.Contains(t, metric, "normalizedScore", "category[%d].categoryMetrics should have 'normalizedScore' field", i) + normalizedScore, ok := metric["normalizedScore"].(float64) + require.True(t, ok, "category[%d].categoryMetrics.normalizedScore should be a float64, got %T", i, metric["normalizedScore"]) + require.GreaterOrEqual(t, normalizedScore, float64(0), "category[%d].categoryMetrics.normalizedScore should be >= 0", i) + + // Validate metricType equals the requested value "popularity_score" + require.Contains(t, metric, "metricType", "category[%d].categoryMetrics should have 'metricType' field", i) + require.Equal(t, "popularity_score", metric["metricType"], "category[%d].categoryMetrics.metricType should equal 'popularity_score'", i) + + // Validate value field is present and is numeric + require.Contains(t, metric, "value", "category[%d].categoryMetrics should have 'value' field", i) + _, ok = metric["value"].(float64) + require.True(t, ok, "category[%d].categoryMetrics.value should be a float64, got %T", i, metric["value"]) + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with recursive child categories field resolver", + query: "query CategoriesWithRecursiveChildCategoriesFieldResolver { categories { id name kind childCategories { id name kind childCategories { id name kind } } } }", + vars: `{"variables":{}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + categories, ok := data["categories"].([]interface{}) + require.True(t, ok, "categories should be an array") + require.NotEmpty(t, categories, "categories should not be empty") + require.Len(t, categories, 4, "Should return 4 categories") + + // Traverse child categories recursively until no more children found + currentLevel := categories + depth, maxDepth := 0, 3 + + for depth < maxDepth { + var nextChildren []interface{} + + for _, cat := range currentLevel { + category, ok := cat.(map[string]interface{}) + require.True(t, ok, "category at depth %d should be an object", depth) + require.NotEmpty(t, category["id"], "category id at depth %d should not be empty", depth) + require.NotEmpty(t, category["name"], "category name at depth %d should not be empty", depth) + require.NotEmpty(t, category["kind"], "category kind at depth %d should not be empty", depth) + + if children, ok := category["childCategories"].([]interface{}); ok { + nextChildren = append(nextChildren, children...) + } + } + + if len(nextChildren) == 0 { + break + } + + depth++ + currentLevel = nextChildren + } + + require.Equal(t, 2, depth, "expected 2 levels of child categories") + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with optional categories field resolver without providing include argument", + query: "query CategoriesWithOptionalCategories { categories { id name optionalCategories { id name kind } } }", + vars: `{"variables":{}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + categories, ok := data["categories"].([]interface{}) + require.True(t, ok, "categories should be an array") + require.Len(t, categories, 4, "Should return 4 categories") + + for _, cat := range categories { + category, ok := cat.(map[string]interface{}) + require.True(t, ok, "category should be an object") + require.NotEmpty(t, category["id"], "category id should not be empty") + require.NotEmpty(t, category["name"], "category name should not be empty") + + // optionalCategories uses a wrapper type (ListOfCategory) for nullable list support + // The field resolver was called successfully if the field is present + require.Contains(t, category, "optionalCategories", "optionalCategories field should be present") + require.Len(t, category["optionalCategories"], 2, "optionalCategories should return 2 categories") + for _, optionalCategory := range category["optionalCategories"].([]interface{}) { + optionalCategory, ok := optionalCategory.(map[string]interface{}) + require.True(t, ok, "optionalCategory should be an object") + require.NotEmpty(t, optionalCategory["id"], "optionalCategory id should not be empty") + require.NotEmpty(t, optionalCategory["name"], "optionalCategory name should not be empty") + require.NotEmpty(t, optionalCategory["kind"], "optionalCategory kind should not be empty") + } + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with optional categories and nested optional categories field resolver", + query: "query CategoriesWithOptionalCategories { categories { id name optionalCategories { id name kind optionalCategories { id name kind } } } }", + vars: `{"variables":{}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + categories, ok := data["categories"].([]interface{}) + require.True(t, ok, "categories should be an array") + require.Len(t, categories, 4, "Should return 4 categories") + + for _, cat := range categories { + category, ok := cat.(map[string]interface{}) + require.True(t, ok, "category should be an object") + require.NotEmpty(t, category["id"], "category id should not be empty") + require.NotEmpty(t, category["name"], "category name should not be empty") + + // optionalCategories uses a wrapper type (ListOfCategory) for nullable list support + // The field resolver was called successfully if the field is present + require.Contains(t, category, "optionalCategories", "optionalCategories field should be present") + require.Len(t, category["optionalCategories"], 2, "optionalCategories should return 2 categories") + for _, optionalCategory := range category["optionalCategories"].([]interface{}) { + optionalCategory, ok := optionalCategory.(map[string]interface{}) + require.True(t, ok, "optionalCategory should be an object") + require.NotEmpty(t, optionalCategory["id"], "optionalCategory id should not be empty") + require.NotEmpty(t, optionalCategory["name"], "optionalCategory name should not be empty") + require.NotEmpty(t, optionalCategory["kind"], "optionalCategory kind should not be empty") + + // nested optionalCategories uses a wrapper type (ListOfCategory) for nullable list support + // The field resolver was called successfully if the field is present + require.Contains(t, optionalCategory, "optionalCategories", "optionalCategories field should be present") + require.Len(t, optionalCategory["optionalCategories"], 2, "optionalCategories should return 2 categories") + for _, nestedOptionalCategory := range optionalCategory["optionalCategories"].([]interface{}) { + nestedOptionalCategory, ok := nestedOptionalCategory.(map[string]interface{}) + require.True(t, ok, "nestedOptionalCategory should be an object") + require.NotEmpty(t, nestedOptionalCategory["id"], "nestedOptionalCategory id should not be empty") + require.NotEmpty(t, nestedOptionalCategory["name"], "nestedOptionalCategory name should not be empty") + require.NotEmpty(t, nestedOptionalCategory["kind"], "nestedOptionalCategory kind should not be empty") + } + } + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with optional categories with 3 levels of recursion", + query: "query CategoriesWithDeepOptionalCategories { categories { id name optionalCategories { id name optionalCategories { id name optionalCategories { id name kind } } } } }", + vars: `{"variables":{}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + categories, ok := data["categories"].([]interface{}) + require.True(t, ok, "categories should be an array") + require.Len(t, categories, 4, "Should return 4 categories") + + for _, cat := range categories { + category, ok := cat.(map[string]interface{}) + require.True(t, ok, "category should be an object") + require.NotEmpty(t, category["id"], "category id should not be empty") + require.NotEmpty(t, category["name"], "category name should not be empty") + + // Level 1: optionalCategories + require.Contains(t, category, "optionalCategories", "optionalCategories field should be present") + level1, ok := category["optionalCategories"].([]interface{}) + require.True(t, ok, "level1 optionalCategories should be an array") + require.Len(t, level1, 2, "level1 optionalCategories should return 2 categories") + + for _, l1 := range level1 { + l1Cat, ok := l1.(map[string]interface{}) + require.True(t, ok, "level1 category should be an object") + require.NotEmpty(t, l1Cat["id"], "level1 category id should not be empty") + require.NotEmpty(t, l1Cat["name"], "level1 category name should not be empty") + + // Level 2: nested optionalCategories + require.Contains(t, l1Cat, "optionalCategories", "level2 optionalCategories field should be present") + level2, ok := l1Cat["optionalCategories"].([]interface{}) + require.True(t, ok, "level2 optionalCategories should be an array") + require.Len(t, level2, 2, "level2 optionalCategories should return 2 categories") + + for _, l2 := range level2 { + l2Cat, ok := l2.(map[string]interface{}) + require.True(t, ok, "level2 category should be an object") + require.NotEmpty(t, l2Cat["id"], "level2 category id should not be empty") + require.NotEmpty(t, l2Cat["name"], "level2 category name should not be empty") + + // Level 3: deeply nested optionalCategories + require.Contains(t, l2Cat, "optionalCategories", "level3 optionalCategories field should be present") + level3, ok := l2Cat["optionalCategories"].([]interface{}) + require.True(t, ok, "level3 optionalCategories should be an array") + require.Len(t, level3, 2, "level3 optionalCategories should return 2 categories") + + for _, l3 := range level3 { + l3Cat, ok := l3.(map[string]interface{}) + require.True(t, ok, "level3 category should be an object") + require.NotEmpty(t, l3Cat["id"], "level3 category id should not be empty") + require.NotEmpty(t, l3Cat["name"], "level3 category name should not be empty") + require.NotEmpty(t, l3Cat["kind"], "level3 category kind should not be empty") + } + } + } + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with both childCategories and optionalCategories at root level", + query: "query CategoriesWithBothFieldResolvers { categories { id name childCategories { id name kind } optionalCategories { id name kind } } }", + vars: `{"variables":{}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + categories, ok := data["categories"].([]interface{}) + require.True(t, ok, "categories should be an array") + require.Len(t, categories, 4, "Should return 4 categories") + + for _, cat := range categories { + category, ok := cat.(map[string]interface{}) + require.True(t, ok, "category should be an object") + require.NotEmpty(t, category["id"], "category id should not be empty") + require.NotEmpty(t, category["name"], "category name should not be empty") + + // Validate childCategories + childCategories, ok := category["childCategories"].([]interface{}) + require.True(t, ok, "childCategories should be an array") + require.NotEmpty(t, childCategories, "childCategories should not be empty") + + for _, child := range childCategories { + childCat, ok := child.(map[string]interface{}) + require.True(t, ok, "childCategory should be an object") + require.NotEmpty(t, childCat["id"], "childCategory id should not be empty") + require.NotEmpty(t, childCat["name"], "childCategory name should not be empty") + require.NotEmpty(t, childCat["kind"], "childCategory kind should not be empty") + } + + // Validate optionalCategories + optionalCategories, ok := category["optionalCategories"].([]interface{}) + require.True(t, ok, "optionalCategories should be an array") + require.Len(t, optionalCategories, 2, "optionalCategories should return 2 categories") + + for _, optional := range optionalCategories { + optionalCat, ok := optional.(map[string]interface{}) + require.True(t, ok, "optionalCategory should be an object") + require.NotEmpty(t, optionalCat["id"], "optionalCategory id should not be empty") + require.NotEmpty(t, optionalCat["name"], "optionalCategory name should not be empty") + require.NotEmpty(t, optionalCat["kind"], "optionalCategory kind should not be empty") + } + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with sibling field resolvers - nested optionalCategories only in childCategories", + query: "query CategoriesWithBothFieldResolversNested { categories { id name childCategories { id name kind optionalCategories { id name kind } } optionalCategories { id name kind } } }", + vars: `{"variables":{}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + categories, ok := data["categories"].([]interface{}) + require.True(t, ok, "categories should be an array") + require.Len(t, categories, 4, "Should return 4 categories") + + for _, cat := range categories { + category, ok := cat.(map[string]interface{}) + require.True(t, ok, "category should be an object") + require.NotEmpty(t, category["id"], "category id should not be empty") + require.NotEmpty(t, category["name"], "category name should not be empty") + + // Validate childCategories with nested optionalCategories + childCategories, ok := category["childCategories"].([]interface{}) + require.True(t, ok, "childCategories should be an array") + require.NotEmpty(t, childCategories, "childCategories should not be empty") + + for _, child := range childCategories { + childCat, ok := child.(map[string]interface{}) + require.True(t, ok, "childCategory should be an object") + require.NotEmpty(t, childCat["id"], "childCategory id should not be empty") + require.NotEmpty(t, childCat["name"], "childCategory name should not be empty") + require.NotEmpty(t, childCat["kind"], "childCategory kind should not be empty") + + nestedOptional, ok := childCat["optionalCategories"].([]interface{}) + require.True(t, ok, "nested optionalCategories should be an array") + require.Len(t, nestedOptional, 2, "nested optionalCategories should return 2 categories") + } + + // Validate optionalCategories with nested childCategories + optionalCategories, ok := category["optionalCategories"].([]interface{}) + require.True(t, ok, "optionalCategories should be an array") + require.Len(t, optionalCategories, 2, "optionalCategories should return 2 categories") + + for _, optional := range optionalCategories { + optionalCat, ok := optional.(map[string]interface{}) + require.True(t, ok, "optionalCategory should be an object") + require.NotEmpty(t, optionalCat["id"], "optionalCategory id should not be empty") + require.NotEmpty(t, optionalCat["name"], "optionalCategory name should not be empty") + require.NotEmpty(t, optionalCat["kind"], "optionalCategory kind should not be empty") + + require.NotContains(t, optionalCat, "childCategories", "childCategories should not be present") + } + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with sibling field resolvers - nested resolvers in both branches", + query: "query CategoriesWithBothFieldResolversNested { categories { id name childCategories { id name kind optionalCategories { id name kind } } optionalCategories { id name kind childCategories { id name kind } } } }", + vars: `{"variables":{}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + categories, ok := data["categories"].([]interface{}) + require.True(t, ok, "categories should be an array") + require.Len(t, categories, 4, "Should return 4 categories") + + for _, cat := range categories { + category, ok := cat.(map[string]interface{}) + require.True(t, ok, "category should be an object") + require.NotEmpty(t, category["id"], "category id should not be empty") + require.NotEmpty(t, category["name"], "category name should not be empty") + + // Validate childCategories with nested optionalCategories + childCategories, ok := category["childCategories"].([]interface{}) + require.True(t, ok, "childCategories should be an array") + require.NotEmpty(t, childCategories, "childCategories should not be empty") + + for _, child := range childCategories { + childCat, ok := child.(map[string]interface{}) + require.True(t, ok, "childCategory should be an object") + require.NotEmpty(t, childCat["id"], "childCategory id should not be empty") + require.NotEmpty(t, childCat["name"], "childCategory name should not be empty") + require.NotEmpty(t, childCat["kind"], "childCategory kind should not be empty") + + nestedOptional, ok := childCat["optionalCategories"].([]interface{}) + require.True(t, ok, "nested optionalCategories should be an array") + require.Len(t, nestedOptional, 2, "nested optionalCategories should return 2 categories") + } + + // Validate optionalCategories with nested childCategories + optionalCategories, ok := category["optionalCategories"].([]interface{}) + require.True(t, ok, "optionalCategories should be an array") + require.Len(t, optionalCategories, 2, "optionalCategories should return 2 categories") + + for _, optional := range optionalCategories { + optionalCat, ok := optional.(map[string]interface{}) + require.True(t, ok, "optionalCategory should be an object") + require.NotEmpty(t, optionalCat["id"], "optionalCategory id should not be empty") + require.NotEmpty(t, optionalCat["name"], "optionalCategory name should not be empty") + require.NotEmpty(t, optionalCat["kind"], "optionalCategory kind should not be empty") + + nestedChildren, ok := optionalCat["childCategories"].([]interface{}) + require.True(t, ok, "nested childCategories should be an array") + require.NotEmpty(t, nestedChildren, "nested childCategories should not be empty") + } + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with childCategories containing nested optionalCategories", + query: "query CategoriesWithChildThenOptional { categories { id name childCategories { id name kind optionalCategories { id name kind } } } }", + vars: `{"variables":{}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + categories, ok := data["categories"].([]interface{}) + require.True(t, ok, "categories should be an array") + require.Len(t, categories, 4, "Should return 4 categories") + + for _, cat := range categories { + category, ok := cat.(map[string]interface{}) + require.True(t, ok, "category should be an object") + require.NotEmpty(t, category["id"], "category id should not be empty") + require.NotEmpty(t, category["name"], "category name should not be empty") + + // Validate childCategories with nested optionalCategories + childCategories, ok := category["childCategories"].([]interface{}) + require.True(t, ok, "childCategories should be an array") + require.NotEmpty(t, childCategories, "childCategories should not be empty") + + for _, child := range childCategories { + childCat, ok := child.(map[string]interface{}) + require.True(t, ok, "childCategory should be an object") + require.NotEmpty(t, childCat["id"], "childCategory id should not be empty") + require.NotEmpty(t, childCat["name"], "childCategory name should not be empty") + require.NotEmpty(t, childCat["kind"], "childCategory kind should not be empty") + + // Nested optionalCategories inside childCategories + require.Contains(t, childCat, "optionalCategories", "optionalCategories inside childCategories should be present") + nestedOptional, ok := childCat["optionalCategories"].([]interface{}) + require.True(t, ok, "nested optionalCategories should be an array") + require.Len(t, nestedOptional, 2, "nested optionalCategories should return 2 categories") + + for _, nested := range nestedOptional { + nestedCat, ok := nested.(map[string]interface{}) + require.True(t, ok, "nested optionalCategory should be an object") + require.NotEmpty(t, nestedCat["id"], "nested optionalCategory id should not be empty") + require.NotEmpty(t, nestedCat["name"], "nested optionalCategory name should not be empty") + require.NotEmpty(t, nestedCat["kind"], "nested optionalCategory kind should not be empty") + } + } + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with optionalCategories containing nested childCategories", + query: "query CategoriesWithOptionalThenChild { categories { id name optionalCategories { id name kind childCategories { id name kind } } } }", + vars: `{"variables":{}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + categories, ok := data["categories"].([]interface{}) + require.True(t, ok, "categories should be an array") + require.Len(t, categories, 4, "Should return 4 categories") + + for _, cat := range categories { + category, ok := cat.(map[string]interface{}) + require.True(t, ok, "category should be an object") + require.NotEmpty(t, category["id"], "category id should not be empty") + require.NotEmpty(t, category["name"], "category name should not be empty") + + // Validate optionalCategories with nested childCategories + optionalCategories, ok := category["optionalCategories"].([]interface{}) + require.True(t, ok, "optionalCategories should be an array") + require.Len(t, optionalCategories, 2, "optionalCategories should return 2 categories") + + for _, optional := range optionalCategories { + optionalCat, ok := optional.(map[string]interface{}) + require.True(t, ok, "optionalCategory should be an object") + require.NotEmpty(t, optionalCat["id"], "optionalCategory id should not be empty") + require.NotEmpty(t, optionalCat["name"], "optionalCategory name should not be empty") + require.NotEmpty(t, optionalCat["kind"], "optionalCategory kind should not be empty") + + // Nested childCategories inside optionalCategories + nestedChildren, ok := optionalCat["childCategories"].([]interface{}) + require.True(t, ok, "childCategories inside optionalCategories should be an array") + require.NotEmpty(t, nestedChildren, "nested childCategories should not be empty") + + for _, nested := range nestedChildren { + nestedCat, ok := nested.(map[string]interface{}) + require.True(t, ok, "nested childCategory should be an object") + require.NotEmpty(t, nestedCat["id"], "nested childCategory id should not be empty") + require.NotEmpty(t, nestedCat["name"], "nested childCategory name should not be empty") + require.NotEmpty(t, nestedCat["kind"], "nested childCategory kind should not be empty") + } + } + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with alternating childCategories and optionalCategories at multiple levels", + query: "query CategoriesWithAlternatingResolvers { categories { id childCategories { id optionalCategories { id childCategories { id kind } } } } }", + vars: `{"variables":{}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + categories, ok := data["categories"].([]interface{}) + require.True(t, ok, "categories should be an array") + require.Len(t, categories, 4, "Should return 4 categories") + + for _, cat := range categories { + category, ok := cat.(map[string]interface{}) + require.True(t, ok, "category should be an object") + require.NotEmpty(t, category["id"], "category id should not be empty") + + // Level 1: childCategories + childCategories, ok := category["childCategories"].([]interface{}) + require.True(t, ok, "childCategories should be an array") + require.NotEmpty(t, childCategories, "childCategories should not be empty") + + for _, child := range childCategories { + childCat, ok := child.(map[string]interface{}) + require.True(t, ok, "level1 childCategory should be an object") + require.NotEmpty(t, childCat["id"], "level1 childCategory id should not be empty") + + // Level 2: optionalCategories + optionalCats, ok := childCat["optionalCategories"].([]interface{}) + require.True(t, ok, "level2 optionalCategories should be an array") + require.Len(t, optionalCats, 2, "level2 optionalCategories should return 2 categories") + + for _, optional := range optionalCats { + optionalCat, ok := optional.(map[string]interface{}) + require.True(t, ok, "level2 optionalCategory should be an object") + require.NotEmpty(t, optionalCat["id"], "level2 optionalCategory id should not be empty") + + // Level 3: childCategories again + nestedChildren, ok := optionalCat["childCategories"].([]interface{}) + require.True(t, ok, "level3 childCategories should be an array") + require.NotEmpty(t, nestedChildren, "level3 childCategories should not be empty") + + for _, nestedChild := range nestedChildren { + nestedChildCat, ok := nestedChild.(map[string]interface{}) + require.True(t, ok, "level3 childCategory should be an object") + require.NotEmpty(t, nestedChildCat["id"], "level3 childCategory id should not be empty") + require.NotEmpty(t, nestedChildCat["kind"], "level3 childCategory kind should not be empty") + } + } + } + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with optional categories field resolver (include=true)", + query: "query CategoriesWithOptionalCategories($include: Boolean) { categories { id name optionalCategories(include: $include) { id name kind } } }", + vars: `{"variables":{"include":true}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + categories, ok := data["categories"].([]interface{}) + require.True(t, ok, "categories should be an array") + require.Len(t, categories, 4, "Should return 4 categories") + + for _, cat := range categories { + category, ok := cat.(map[string]interface{}) + require.True(t, ok, "category should be an object") + require.NotEmpty(t, category["id"], "category id should not be empty") + require.NotEmpty(t, category["name"], "category name should not be empty") + + // optionalCategories uses a wrapper type (ListOfCategory) for nullable list support + // The field resolver was called successfully if the field is present + require.Contains(t, category, "optionalCategories", "optionalCategories field should be present") + require.Len(t, category["optionalCategories"], 2, "optionalCategories should return 2 categories") + for _, optionalCategory := range category["optionalCategories"].([]interface{}) { + optionalCategory, ok := optionalCategory.(map[string]interface{}) + require.True(t, ok, "optionalCategory should be an object") + require.NotEmpty(t, optionalCategory["id"], "optionalCategory id should not be empty") + require.NotEmpty(t, optionalCategory["name"], "optionalCategory name should not be empty") + require.NotEmpty(t, optionalCategory["kind"], "optionalCategory kind should not be empty") + } + + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with optional categories field resolver (include=false)", + query: "query CategoriesWithOptionalCategories($include: Boolean) { categories { id name optionalCategories(include: $include) { id name kind } } }", + vars: `{"variables":{"include":false}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + categories, ok := data["categories"].([]interface{}) + require.True(t, ok, "categories should be an array") + require.Len(t, categories, 4, "Should return 4 categories") + + for _, cat := range categories { + category, ok := cat.(map[string]interface{}) + require.True(t, ok, "category should be an object") + require.NotEmpty(t, category["id"], "category id should not be empty") + require.NotEmpty(t, category["name"], "category name should not be empty") + + // When include=false, optionalCategories should be null + require.Nil(t, category["optionalCategories"], "optionalCategories should be null when include=false") + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with recursive child categories field resolver and aliases", + query: "query CategoriesWithRecursiveChildCategoriesFieldResolverAndAliases { categories { child: childCategories { id name kind childchild: childCategories { id name kind } } } }", + vars: `{"variables":{}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + categories, ok := data["categories"].([]interface{}) + require.True(t, ok, "categories should be an array") + require.NotEmpty(t, categories, "categories should not be empty") + require.Len(t, categories, 4, "Should return 4 categories") + + for _, cat := range categories { + category, ok := cat.(map[string]interface{}) + require.True(t, ok, "category should be an object") + + // Check aliased field "child" (childCategories) + child, ok := category["child"].([]interface{}) + require.True(t, ok, "child (aliased childCategories) should be an array") + require.NotEmpty(t, child, "child should not be empty") + + for _, ch := range child { + childCategory, ok := ch.(map[string]interface{}) + require.True(t, ok, "child category should be an object") + require.NotEmpty(t, childCategory["id"], "child category id should not be empty") + require.NotEmpty(t, childCategory["name"], "child category name should not be empty") + require.NotEmpty(t, childCategory["kind"], "child category kind should not be empty") + + // Check nested aliased field "childchild" (childCategories) + childchild, ok := childCategory["childchild"].([]interface{}) + require.True(t, ok, "childchild (aliased childCategories) should be an array") + require.NotEmpty(t, childchild, "childchild should not be empty") + + for _, chch := range childchild { + childchildCategory, ok := chch.(map[string]interface{}) + require.True(t, ok, "childchild category should be an object") + require.NotEmpty(t, childchildCategory["id"], "childchild category id should not be empty") + require.NotEmpty(t, childchildCategory["name"], "childchild category name should not be empty") + require.NotEmpty(t, childchildCategory["kind"], "childchild category kind should not be empty") + } + } + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { + t.Parallel() // Parse the GraphQL schema schemaDoc := grpctest.MustGraphQLSchema(t) diff --git a/v2/pkg/engine/datasource/grpc_datasource/json_builder.go b/v2/pkg/engine/datasource/grpc_datasource/json_builder.go index 6e521b041b..28b5adb1d2 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/json_builder.go +++ b/v2/pkg/engine/datasource/grpc_datasource/json_builder.go @@ -227,6 +227,9 @@ func (j *jsonBuilder) mergeWithPath(base *astjson.Value, resolved *astjson.Value } resolvedValues := resolved.GetArray(resolveResponsePath) + if len(resolvedValues) == 0 { + return nil + } searchPath := path[:len(path)-1] elementName := path[len(path)-1].FieldName.String() diff --git a/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go b/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go index c8b63d09cb..8b36b7b98f 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go +++ b/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go @@ -285,6 +285,28 @@ func testMapping() *GRPCMapping { Request: "ResolveCategoryCategoryStatusRequest", Response: "ResolveCategoryCategoryStatusResponse", }, + "childCategories": { + FieldMappingData: FieldMapData{ + TargetName: "child_categories", + ArgumentMappings: FieldArgumentMap{ + "include": "include", + }, + }, + RPC: "ResolveCategoryChildCategories", + Request: "ResolveCategoryChildCategoriesRequest", + Response: "ResolveCategoryChildCategoriesResponse", + }, + "optionalCategories": { + FieldMappingData: FieldMapData{ + TargetName: "optional_categories", + ArgumentMappings: FieldArgumentMap{ + "include": "include", + }, + }, + RPC: "ResolveCategoryOptionalCategories", + Request: "ResolveCategoryOptionalCategoriesRequest", + Response: "ResolveCategoryOptionalCategoriesResponse", + }, }, "CategoryMetrics": { "normalizedScore": { @@ -940,6 +962,18 @@ func testMapping() *GRPCMapping { "checkHealth": "check_health", }, }, + "childCategories": { + TargetName: "child_categories", + ArgumentMappings: FieldArgumentMap{ + "include": "include", + }, + }, + "optionalCategories": { + TargetName: "optional_categories", + ArgumentMappings: FieldArgumentMap{ + "include": "include", + }, + }, }, "Subcategory": { "id": { diff --git a/v2/pkg/grpctest/mapping/mapping.go b/v2/pkg/grpctest/mapping/mapping.go index 5acef534da..c3ff0f8425 100644 --- a/v2/pkg/grpctest/mapping/mapping.go +++ b/v2/pkg/grpctest/mapping/mapping.go @@ -292,6 +292,28 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { Request: "ResolveCategoryCategoryStatusRequest", Response: "ResolveCategoryCategoryStatusResponse", }, + "childCategories": { + FieldMappingData: grpcdatasource.FieldMapData{ + TargetName: "child_categories", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "include": "include", + }, + }, + RPC: "ResolveCategoryChildCategories", + Request: "ResolveCategoryChildCategoriesRequest", + Response: "ResolveCategoryChildCategoriesResponse", + }, + "optionalCategories": { + FieldMappingData: grpcdatasource.FieldMapData{ + TargetName: "optional_categories", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "include": "include", + }, + }, + RPC: "ResolveCategoryOptionalCategories", + Request: "ResolveCategoryOptionalCategoriesRequest", + Response: "ResolveCategoryOptionalCategoriesResponse", + }, }, "CategoryMetrics": { "normalizedScore": { @@ -947,6 +969,18 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { "checkHealth": "check_health", }, }, + "childCategories": { + TargetName: "child_categories", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "include": "include", + }, + }, + "optionalCategories": { + TargetName: "optional_categories", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "include": "include", + }, + }, }, "Subcategory": { "id": { diff --git a/v2/pkg/grpctest/mockservice_resolve.go b/v2/pkg/grpctest/mockservice_resolve.go index 107364ffe0..44e0aa92aa 100644 --- a/v2/pkg/grpctest/mockservice_resolve.go +++ b/v2/pkg/grpctest/mockservice_resolve.go @@ -590,6 +590,77 @@ func (s *MockService) ResolveCategoryCategoryStatus(_ context.Context, req *prod return resp, nil } +// ResolveCategoryChildCategories implements [productv1.ProductServiceServer]. +func (s *MockService) ResolveCategoryChildCategories(_ context.Context, req *productv1.ResolveCategoryChildCategoriesRequest) (*productv1.ResolveCategoryChildCategoriesResponse, error) { + results := make([]*productv1.ResolveCategoryChildCategoriesResult, len(req.GetContext())) + + for i, ctx := range req.GetContext() { + results[i] = &productv1.ResolveCategoryChildCategoriesResult{ + ChildCategories: []*productv1.Category{ + { + Id: fmt.Sprintf("child-category-%s-%d", ctx.GetId(), i), + Name: fmt.Sprintf("Child Category %s %d", ctx.GetName(), i), + Kind: productv1.CategoryKind_CATEGORY_KIND_OTHER, + }, + { + Id: fmt.Sprintf("child-category-%s-%d", ctx.GetId(), i+1), + Name: fmt.Sprintf("Child Category %s %d", ctx.GetName(), i+1), + Kind: productv1.CategoryKind_CATEGORY_KIND_OTHER, + }, + }, + } + } + + resp := &productv1.ResolveCategoryChildCategoriesResponse{ + Result: results, + } + + return resp, nil +} + +// ResolveCategoryOptionalCategories implements [productv1.ProductServiceServer]. +func (s *MockService) ResolveCategoryOptionalCategories(_ context.Context, req *productv1.ResolveCategoryOptionalCategoriesRequest) (*productv1.ResolveCategoryOptionalCategoriesResponse, error) { + results := make([]*productv1.ResolveCategoryOptionalCategoriesResult, 0, len(req.GetContext())) + + // Check if include arg is set - if false, return nil for optionalCategories + include := true + if req.GetFieldArgs() != nil && req.GetFieldArgs().GetInclude() != nil { + include = req.GetFieldArgs().GetInclude().GetValue() + } + + for i, ctx := range req.GetContext() { + var optionalCategories *productv1.ListOfCategory + + if include { + // Generate 2 optional categories per parent category + optionalCategories = &productv1.ListOfCategory{ + List: &productv1.ListOfCategory_List{ + Items: []*productv1.Category{ + { + Id: fmt.Sprintf("optional-category-%s-%d", ctx.GetId(), i*2), + Name: fmt.Sprintf("Optional Category %s %d", ctx.GetName(), i*2), + Kind: productv1.CategoryKind_CATEGORY_KIND_OTHER, + }, + { + Id: fmt.Sprintf("optional-category-%s-%d", ctx.GetId(), i*2+1), + Name: fmt.Sprintf("Optional Category %s %d", ctx.GetName(), i*2+1), + Kind: productv1.CategoryKind_CATEGORY_KIND_OTHER, + }, + }, + }, + } + } + + results = append(results, &productv1.ResolveCategoryOptionalCategoriesResult{ + OptionalCategories: optionalCategories, + }) + } + + return &productv1.ResolveCategoryOptionalCategoriesResponse{ + Result: results, + }, nil +} + // ResolveProductRecommendedCategory implements productv1.ProductServiceServer. func (s *MockService) ResolveProductRecommendedCategory(_ context.Context, req *productv1.ResolveProductRecommendedCategoryRequest) (*productv1.ResolveProductRecommendedCategoryResponse, error) { results := make([]*productv1.ResolveProductRecommendedCategoryResult, 0, len(req.GetContext())) diff --git a/v2/pkg/grpctest/product.proto b/v2/pkg/grpctest/product.proto index 855c1cdde1..f58706ffbe 100644 --- a/v2/pkg/grpctest/product.proto +++ b/v2/pkg/grpctest/product.proto @@ -59,8 +59,10 @@ service ProductService { rpc QueryUsers(QueryUsersRequest) returns (QueryUsersResponse) {} rpc ResolveCategoryCategoryMetrics(ResolveCategoryCategoryMetricsRequest) returns (ResolveCategoryCategoryMetricsResponse) {} rpc ResolveCategoryCategoryStatus(ResolveCategoryCategoryStatusRequest) returns (ResolveCategoryCategoryStatusResponse) {} + rpc ResolveCategoryChildCategories(ResolveCategoryChildCategoriesRequest) returns (ResolveCategoryChildCategoriesResponse) {} rpc ResolveCategoryMascot(ResolveCategoryMascotRequest) returns (ResolveCategoryMascotResponse) {} rpc ResolveCategoryMetricsNormalizedScore(ResolveCategoryMetricsNormalizedScoreRequest) returns (ResolveCategoryMetricsNormalizedScoreResponse) {} + rpc ResolveCategoryOptionalCategories(ResolveCategoryOptionalCategoriesRequest) returns (ResolveCategoryOptionalCategoriesResponse) {} rpc ResolveCategoryPopularityScore(ResolveCategoryPopularityScoreRequest) returns (ResolveCategoryPopularityScoreResponse) {} rpc ResolveCategoryProductCount(ResolveCategoryProductCountRequest) returns (ResolveCategoryProductCountResponse) {} rpc ResolveProductMascotRecommendation(ResolveProductMascotRecommendationRequest) returns (ResolveProductMascotRecommendationResponse) {} @@ -898,6 +900,54 @@ message ResolveCategoryCategoryStatusResponse { repeated ResolveCategoryCategoryStatusResult result = 1; } +message ResolveCategoryChildCategoriesArgs { + google.protobuf.BoolValue include = 1; +} + +message ResolveCategoryChildCategoriesContext { + string id = 1; + string name = 2; +} + +message ResolveCategoryChildCategoriesRequest { + // context provides the resolver context for the field childCategories of type Category. + repeated ResolveCategoryChildCategoriesContext context = 1; + // field_args provides the arguments for the resolver field childCategories of type Category. + ResolveCategoryChildCategoriesArgs field_args = 2; +} + +message ResolveCategoryChildCategoriesResult { + repeated Category child_categories = 1; +} + +message ResolveCategoryChildCategoriesResponse { + repeated ResolveCategoryChildCategoriesResult result = 1; +} + +message ResolveCategoryOptionalCategoriesArgs { + google.protobuf.BoolValue include = 1; +} + +message ResolveCategoryOptionalCategoriesContext { + string id = 1; + string name = 2; +} + +message ResolveCategoryOptionalCategoriesRequest { + // context provides the resolver context for the field optionalCategories of type Category. + repeated ResolveCategoryOptionalCategoriesContext context = 1; + // field_args provides the arguments for the resolver field optionalCategories of type Category. + ResolveCategoryOptionalCategoriesArgs field_args = 2; +} + +message ResolveCategoryOptionalCategoriesResult { + ListOfCategory optional_categories = 1; +} + +message ResolveCategoryOptionalCategoriesResponse { + repeated ResolveCategoryOptionalCategoriesResult result = 1; +} + message ResolveSubcategoryItemCountArgs { SubcategoryItemFilter filters = 1; } @@ -927,7 +977,7 @@ message ResolveCategoryMetricsNormalizedScoreArgs { message ResolveCategoryMetricsNormalizedScoreContext { string id = 1; - string metricType = 2; + string metric_type = 2; double value = 3; } diff --git a/v2/pkg/grpctest/productv1/product.pb.go b/v2/pkg/grpctest/productv1/product.pb.go index 92c0c81871..e0fe992662 100644 --- a/v2/pkg/grpctest/productv1/product.pb.go +++ b/v2/pkg/grpctest/productv1/product.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.10 +// protoc-gen-go v1.36.11 // protoc v6.32.0 // source: product.proto @@ -7758,6 +7758,482 @@ func (x *ResolveCategoryCategoryStatusResponse) GetResult() []*ResolveCategoryCa return nil } +type ResolveCategoryChildCategoriesArgs struct { + state protoimpl.MessageState `protogen:"open.v1"` + Include *wrapperspb.BoolValue `protobuf:"bytes,1,opt,name=include,proto3" json:"include,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryChildCategoriesArgs) Reset() { + *x = ResolveCategoryChildCategoriesArgs{} + mi := &file_product_proto_msgTypes[167] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryChildCategoriesArgs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryChildCategoriesArgs) ProtoMessage() {} + +func (x *ResolveCategoryChildCategoriesArgs) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[167] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveCategoryChildCategoriesArgs.ProtoReflect.Descriptor instead. +func (*ResolveCategoryChildCategoriesArgs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{167} +} + +func (x *ResolveCategoryChildCategoriesArgs) GetInclude() *wrapperspb.BoolValue { + if x != nil { + return x.Include + } + return nil +} + +type ResolveCategoryChildCategoriesContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryChildCategoriesContext) Reset() { + *x = ResolveCategoryChildCategoriesContext{} + mi := &file_product_proto_msgTypes[168] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryChildCategoriesContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryChildCategoriesContext) ProtoMessage() {} + +func (x *ResolveCategoryChildCategoriesContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[168] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveCategoryChildCategoriesContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryChildCategoriesContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{168} +} + +func (x *ResolveCategoryChildCategoriesContext) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *ResolveCategoryChildCategoriesContext) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type ResolveCategoryChildCategoriesRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field childCategories of type Category. + Context []*ResolveCategoryChildCategoriesContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field childCategories of type Category. + FieldArgs *ResolveCategoryChildCategoriesArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryChildCategoriesRequest) Reset() { + *x = ResolveCategoryChildCategoriesRequest{} + mi := &file_product_proto_msgTypes[169] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryChildCategoriesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryChildCategoriesRequest) ProtoMessage() {} + +func (x *ResolveCategoryChildCategoriesRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[169] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveCategoryChildCategoriesRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryChildCategoriesRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{169} +} + +func (x *ResolveCategoryChildCategoriesRequest) GetContext() []*ResolveCategoryChildCategoriesContext { + if x != nil { + return x.Context + } + return nil +} + +func (x *ResolveCategoryChildCategoriesRequest) GetFieldArgs() *ResolveCategoryChildCategoriesArgs { + if x != nil { + return x.FieldArgs + } + return nil +} + +type ResolveCategoryChildCategoriesResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + ChildCategories []*Category `protobuf:"bytes,1,rep,name=child_categories,json=childCategories,proto3" json:"child_categories,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryChildCategoriesResult) Reset() { + *x = ResolveCategoryChildCategoriesResult{} + mi := &file_product_proto_msgTypes[170] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryChildCategoriesResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryChildCategoriesResult) ProtoMessage() {} + +func (x *ResolveCategoryChildCategoriesResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[170] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveCategoryChildCategoriesResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryChildCategoriesResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{170} +} + +func (x *ResolveCategoryChildCategoriesResult) GetChildCategories() []*Category { + if x != nil { + return x.ChildCategories + } + return nil +} + +type ResolveCategoryChildCategoriesResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveCategoryChildCategoriesResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryChildCategoriesResponse) Reset() { + *x = ResolveCategoryChildCategoriesResponse{} + mi := &file_product_proto_msgTypes[171] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryChildCategoriesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryChildCategoriesResponse) ProtoMessage() {} + +func (x *ResolveCategoryChildCategoriesResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[171] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveCategoryChildCategoriesResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryChildCategoriesResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{171} +} + +func (x *ResolveCategoryChildCategoriesResponse) GetResult() []*ResolveCategoryChildCategoriesResult { + if x != nil { + return x.Result + } + return nil +} + +type ResolveCategoryOptionalCategoriesArgs struct { + state protoimpl.MessageState `protogen:"open.v1"` + Include *wrapperspb.BoolValue `protobuf:"bytes,1,opt,name=include,proto3" json:"include,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryOptionalCategoriesArgs) Reset() { + *x = ResolveCategoryOptionalCategoriesArgs{} + mi := &file_product_proto_msgTypes[172] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryOptionalCategoriesArgs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryOptionalCategoriesArgs) ProtoMessage() {} + +func (x *ResolveCategoryOptionalCategoriesArgs) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[172] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveCategoryOptionalCategoriesArgs.ProtoReflect.Descriptor instead. +func (*ResolveCategoryOptionalCategoriesArgs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{172} +} + +func (x *ResolveCategoryOptionalCategoriesArgs) GetInclude() *wrapperspb.BoolValue { + if x != nil { + return x.Include + } + return nil +} + +type ResolveCategoryOptionalCategoriesContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryOptionalCategoriesContext) Reset() { + *x = ResolveCategoryOptionalCategoriesContext{} + mi := &file_product_proto_msgTypes[173] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryOptionalCategoriesContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryOptionalCategoriesContext) ProtoMessage() {} + +func (x *ResolveCategoryOptionalCategoriesContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[173] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveCategoryOptionalCategoriesContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryOptionalCategoriesContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{173} +} + +func (x *ResolveCategoryOptionalCategoriesContext) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *ResolveCategoryOptionalCategoriesContext) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type ResolveCategoryOptionalCategoriesRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field optionalCategories of type Category. + Context []*ResolveCategoryOptionalCategoriesContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field optionalCategories of type Category. + FieldArgs *ResolveCategoryOptionalCategoriesArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryOptionalCategoriesRequest) Reset() { + *x = ResolveCategoryOptionalCategoriesRequest{} + mi := &file_product_proto_msgTypes[174] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryOptionalCategoriesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryOptionalCategoriesRequest) ProtoMessage() {} + +func (x *ResolveCategoryOptionalCategoriesRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[174] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveCategoryOptionalCategoriesRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryOptionalCategoriesRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{174} +} + +func (x *ResolveCategoryOptionalCategoriesRequest) GetContext() []*ResolveCategoryOptionalCategoriesContext { + if x != nil { + return x.Context + } + return nil +} + +func (x *ResolveCategoryOptionalCategoriesRequest) GetFieldArgs() *ResolveCategoryOptionalCategoriesArgs { + if x != nil { + return x.FieldArgs + } + return nil +} + +type ResolveCategoryOptionalCategoriesResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + OptionalCategories *ListOfCategory `protobuf:"bytes,1,opt,name=optional_categories,json=optionalCategories,proto3" json:"optional_categories,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryOptionalCategoriesResult) Reset() { + *x = ResolveCategoryOptionalCategoriesResult{} + mi := &file_product_proto_msgTypes[175] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryOptionalCategoriesResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryOptionalCategoriesResult) ProtoMessage() {} + +func (x *ResolveCategoryOptionalCategoriesResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[175] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveCategoryOptionalCategoriesResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryOptionalCategoriesResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{175} +} + +func (x *ResolveCategoryOptionalCategoriesResult) GetOptionalCategories() *ListOfCategory { + if x != nil { + return x.OptionalCategories + } + return nil +} + +type ResolveCategoryOptionalCategoriesResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveCategoryOptionalCategoriesResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryOptionalCategoriesResponse) Reset() { + *x = ResolveCategoryOptionalCategoriesResponse{} + mi := &file_product_proto_msgTypes[176] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryOptionalCategoriesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryOptionalCategoriesResponse) ProtoMessage() {} + +func (x *ResolveCategoryOptionalCategoriesResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[176] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResolveCategoryOptionalCategoriesResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryOptionalCategoriesResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{176} +} + +func (x *ResolveCategoryOptionalCategoriesResponse) GetResult() []*ResolveCategoryOptionalCategoriesResult { + if x != nil { + return x.Result + } + return nil +} + type ResolveSubcategoryItemCountArgs struct { state protoimpl.MessageState `protogen:"open.v1"` Filters *SubcategoryItemFilter `protobuf:"bytes,1,opt,name=filters,proto3" json:"filters,omitempty"` @@ -7767,7 +8243,7 @@ type ResolveSubcategoryItemCountArgs struct { func (x *ResolveSubcategoryItemCountArgs) Reset() { *x = ResolveSubcategoryItemCountArgs{} - mi := &file_product_proto_msgTypes[167] + mi := &file_product_proto_msgTypes[177] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7779,7 +8255,7 @@ func (x *ResolveSubcategoryItemCountArgs) String() string { func (*ResolveSubcategoryItemCountArgs) ProtoMessage() {} func (x *ResolveSubcategoryItemCountArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[167] + mi := &file_product_proto_msgTypes[177] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7792,7 +8268,7 @@ func (x *ResolveSubcategoryItemCountArgs) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveSubcategoryItemCountArgs.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryItemCountArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{167} + return file_product_proto_rawDescGZIP(), []int{177} } func (x *ResolveSubcategoryItemCountArgs) GetFilters() *SubcategoryItemFilter { @@ -7811,7 +8287,7 @@ type ResolveSubcategoryItemCountContext struct { func (x *ResolveSubcategoryItemCountContext) Reset() { *x = ResolveSubcategoryItemCountContext{} - mi := &file_product_proto_msgTypes[168] + mi := &file_product_proto_msgTypes[178] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7823,7 +8299,7 @@ func (x *ResolveSubcategoryItemCountContext) String() string { func (*ResolveSubcategoryItemCountContext) ProtoMessage() {} func (x *ResolveSubcategoryItemCountContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[168] + mi := &file_product_proto_msgTypes[178] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7836,7 +8312,7 @@ func (x *ResolveSubcategoryItemCountContext) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveSubcategoryItemCountContext.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryItemCountContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{168} + return file_product_proto_rawDescGZIP(), []int{178} } func (x *ResolveSubcategoryItemCountContext) GetId() string { @@ -7858,7 +8334,7 @@ type ResolveSubcategoryItemCountRequest struct { func (x *ResolveSubcategoryItemCountRequest) Reset() { *x = ResolveSubcategoryItemCountRequest{} - mi := &file_product_proto_msgTypes[169] + mi := &file_product_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7870,7 +8346,7 @@ func (x *ResolveSubcategoryItemCountRequest) String() string { func (*ResolveSubcategoryItemCountRequest) ProtoMessage() {} func (x *ResolveSubcategoryItemCountRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[169] + mi := &file_product_proto_msgTypes[179] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7883,7 +8359,7 @@ func (x *ResolveSubcategoryItemCountRequest) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveSubcategoryItemCountRequest.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryItemCountRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{169} + return file_product_proto_rawDescGZIP(), []int{179} } func (x *ResolveSubcategoryItemCountRequest) GetContext() []*ResolveSubcategoryItemCountContext { @@ -7909,7 +8385,7 @@ type ResolveSubcategoryItemCountResult struct { func (x *ResolveSubcategoryItemCountResult) Reset() { *x = ResolveSubcategoryItemCountResult{} - mi := &file_product_proto_msgTypes[170] + mi := &file_product_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7921,7 +8397,7 @@ func (x *ResolveSubcategoryItemCountResult) String() string { func (*ResolveSubcategoryItemCountResult) ProtoMessage() {} func (x *ResolveSubcategoryItemCountResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[170] + mi := &file_product_proto_msgTypes[180] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7934,7 +8410,7 @@ func (x *ResolveSubcategoryItemCountResult) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveSubcategoryItemCountResult.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryItemCountResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{170} + return file_product_proto_rawDescGZIP(), []int{180} } func (x *ResolveSubcategoryItemCountResult) GetItemCount() int32 { @@ -7953,7 +8429,7 @@ type ResolveSubcategoryItemCountResponse struct { func (x *ResolveSubcategoryItemCountResponse) Reset() { *x = ResolveSubcategoryItemCountResponse{} - mi := &file_product_proto_msgTypes[171] + mi := &file_product_proto_msgTypes[181] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7965,7 +8441,7 @@ func (x *ResolveSubcategoryItemCountResponse) String() string { func (*ResolveSubcategoryItemCountResponse) ProtoMessage() {} func (x *ResolveSubcategoryItemCountResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[171] + mi := &file_product_proto_msgTypes[181] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7978,7 +8454,7 @@ func (x *ResolveSubcategoryItemCountResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveSubcategoryItemCountResponse.ProtoReflect.Descriptor instead. func (*ResolveSubcategoryItemCountResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{171} + return file_product_proto_rawDescGZIP(), []int{181} } func (x *ResolveSubcategoryItemCountResponse) GetResult() []*ResolveSubcategoryItemCountResult { @@ -7997,7 +8473,7 @@ type ResolveCategoryMetricsNormalizedScoreArgs struct { func (x *ResolveCategoryMetricsNormalizedScoreArgs) Reset() { *x = ResolveCategoryMetricsNormalizedScoreArgs{} - mi := &file_product_proto_msgTypes[172] + mi := &file_product_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8009,7 +8485,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreArgs) String() string { func (*ResolveCategoryMetricsNormalizedScoreArgs) ProtoMessage() {} func (x *ResolveCategoryMetricsNormalizedScoreArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[172] + mi := &file_product_proto_msgTypes[182] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8022,7 +8498,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreArgs) ProtoReflect() protoreflect. // Deprecated: Use ResolveCategoryMetricsNormalizedScoreArgs.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsNormalizedScoreArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{172} + return file_product_proto_rawDescGZIP(), []int{182} } func (x *ResolveCategoryMetricsNormalizedScoreArgs) GetBaseline() float64 { @@ -8035,7 +8511,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreArgs) GetBaseline() float64 { type ResolveCategoryMetricsNormalizedScoreContext struct { state protoimpl.MessageState `protogen:"open.v1"` Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - MetricType string `protobuf:"bytes,2,opt,name=metricType,proto3" json:"metricType,omitempty"` + MetricType string `protobuf:"bytes,2,opt,name=metric_type,json=metricType,proto3" json:"metric_type,omitempty"` Value float64 `protobuf:"fixed64,3,opt,name=value,proto3" json:"value,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -8043,7 +8519,7 @@ type ResolveCategoryMetricsNormalizedScoreContext struct { func (x *ResolveCategoryMetricsNormalizedScoreContext) Reset() { *x = ResolveCategoryMetricsNormalizedScoreContext{} - mi := &file_product_proto_msgTypes[173] + mi := &file_product_proto_msgTypes[183] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8055,7 +8531,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreContext) String() string { func (*ResolveCategoryMetricsNormalizedScoreContext) ProtoMessage() {} func (x *ResolveCategoryMetricsNormalizedScoreContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[173] + mi := &file_product_proto_msgTypes[183] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8068,7 +8544,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreContext) ProtoReflect() protorefle // Deprecated: Use ResolveCategoryMetricsNormalizedScoreContext.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsNormalizedScoreContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{173} + return file_product_proto_rawDescGZIP(), []int{183} } func (x *ResolveCategoryMetricsNormalizedScoreContext) GetId() string { @@ -8104,7 +8580,7 @@ type ResolveCategoryMetricsNormalizedScoreRequest struct { func (x *ResolveCategoryMetricsNormalizedScoreRequest) Reset() { *x = ResolveCategoryMetricsNormalizedScoreRequest{} - mi := &file_product_proto_msgTypes[174] + mi := &file_product_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8116,7 +8592,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreRequest) String() string { func (*ResolveCategoryMetricsNormalizedScoreRequest) ProtoMessage() {} func (x *ResolveCategoryMetricsNormalizedScoreRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[174] + mi := &file_product_proto_msgTypes[184] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8129,7 +8605,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreRequest) ProtoReflect() protorefle // Deprecated: Use ResolveCategoryMetricsNormalizedScoreRequest.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsNormalizedScoreRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{174} + return file_product_proto_rawDescGZIP(), []int{184} } func (x *ResolveCategoryMetricsNormalizedScoreRequest) GetContext() []*ResolveCategoryMetricsNormalizedScoreContext { @@ -8155,7 +8631,7 @@ type ResolveCategoryMetricsNormalizedScoreResult struct { func (x *ResolveCategoryMetricsNormalizedScoreResult) Reset() { *x = ResolveCategoryMetricsNormalizedScoreResult{} - mi := &file_product_proto_msgTypes[175] + mi := &file_product_proto_msgTypes[185] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8167,7 +8643,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreResult) String() string { func (*ResolveCategoryMetricsNormalizedScoreResult) ProtoMessage() {} func (x *ResolveCategoryMetricsNormalizedScoreResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[175] + mi := &file_product_proto_msgTypes[185] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8180,7 +8656,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreResult) ProtoReflect() protoreflec // Deprecated: Use ResolveCategoryMetricsNormalizedScoreResult.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsNormalizedScoreResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{175} + return file_product_proto_rawDescGZIP(), []int{185} } func (x *ResolveCategoryMetricsNormalizedScoreResult) GetNormalizedScore() float64 { @@ -8199,7 +8675,7 @@ type ResolveCategoryMetricsNormalizedScoreResponse struct { func (x *ResolveCategoryMetricsNormalizedScoreResponse) Reset() { *x = ResolveCategoryMetricsNormalizedScoreResponse{} - mi := &file_product_proto_msgTypes[176] + mi := &file_product_proto_msgTypes[186] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8211,7 +8687,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreResponse) String() string { func (*ResolveCategoryMetricsNormalizedScoreResponse) ProtoMessage() {} func (x *ResolveCategoryMetricsNormalizedScoreResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[176] + mi := &file_product_proto_msgTypes[186] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8224,7 +8700,7 @@ func (x *ResolveCategoryMetricsNormalizedScoreResponse) ProtoReflect() protorefl // Deprecated: Use ResolveCategoryMetricsNormalizedScoreResponse.ProtoReflect.Descriptor instead. func (*ResolveCategoryMetricsNormalizedScoreResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{176} + return file_product_proto_rawDescGZIP(), []int{186} } func (x *ResolveCategoryMetricsNormalizedScoreResponse) GetResult() []*ResolveCategoryMetricsNormalizedScoreResult { @@ -8243,7 +8719,7 @@ type ResolveTestContainerDetailsArgs struct { func (x *ResolveTestContainerDetailsArgs) Reset() { *x = ResolveTestContainerDetailsArgs{} - mi := &file_product_proto_msgTypes[177] + mi := &file_product_proto_msgTypes[187] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8255,7 +8731,7 @@ func (x *ResolveTestContainerDetailsArgs) String() string { func (*ResolveTestContainerDetailsArgs) ProtoMessage() {} func (x *ResolveTestContainerDetailsArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[177] + mi := &file_product_proto_msgTypes[187] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8268,7 +8744,7 @@ func (x *ResolveTestContainerDetailsArgs) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveTestContainerDetailsArgs.ProtoReflect.Descriptor instead. func (*ResolveTestContainerDetailsArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{177} + return file_product_proto_rawDescGZIP(), []int{187} } func (x *ResolveTestContainerDetailsArgs) GetIncludeExtended() bool { @@ -8288,7 +8764,7 @@ type ResolveTestContainerDetailsContext struct { func (x *ResolveTestContainerDetailsContext) Reset() { *x = ResolveTestContainerDetailsContext{} - mi := &file_product_proto_msgTypes[178] + mi := &file_product_proto_msgTypes[188] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8300,7 +8776,7 @@ func (x *ResolveTestContainerDetailsContext) String() string { func (*ResolveTestContainerDetailsContext) ProtoMessage() {} func (x *ResolveTestContainerDetailsContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[178] + mi := &file_product_proto_msgTypes[188] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8313,7 +8789,7 @@ func (x *ResolveTestContainerDetailsContext) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveTestContainerDetailsContext.ProtoReflect.Descriptor instead. func (*ResolveTestContainerDetailsContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{178} + return file_product_proto_rawDescGZIP(), []int{188} } func (x *ResolveTestContainerDetailsContext) GetId() string { @@ -8342,7 +8818,7 @@ type ResolveTestContainerDetailsRequest struct { func (x *ResolveTestContainerDetailsRequest) Reset() { *x = ResolveTestContainerDetailsRequest{} - mi := &file_product_proto_msgTypes[179] + mi := &file_product_proto_msgTypes[189] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8354,7 +8830,7 @@ func (x *ResolveTestContainerDetailsRequest) String() string { func (*ResolveTestContainerDetailsRequest) ProtoMessage() {} func (x *ResolveTestContainerDetailsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[179] + mi := &file_product_proto_msgTypes[189] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8367,7 +8843,7 @@ func (x *ResolveTestContainerDetailsRequest) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveTestContainerDetailsRequest.ProtoReflect.Descriptor instead. func (*ResolveTestContainerDetailsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{179} + return file_product_proto_rawDescGZIP(), []int{189} } func (x *ResolveTestContainerDetailsRequest) GetContext() []*ResolveTestContainerDetailsContext { @@ -8393,7 +8869,7 @@ type ResolveTestContainerDetailsResult struct { func (x *ResolveTestContainerDetailsResult) Reset() { *x = ResolveTestContainerDetailsResult{} - mi := &file_product_proto_msgTypes[180] + mi := &file_product_proto_msgTypes[190] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8405,7 +8881,7 @@ func (x *ResolveTestContainerDetailsResult) String() string { func (*ResolveTestContainerDetailsResult) ProtoMessage() {} func (x *ResolveTestContainerDetailsResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[180] + mi := &file_product_proto_msgTypes[190] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8418,7 +8894,7 @@ func (x *ResolveTestContainerDetailsResult) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveTestContainerDetailsResult.ProtoReflect.Descriptor instead. func (*ResolveTestContainerDetailsResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{180} + return file_product_proto_rawDescGZIP(), []int{190} } func (x *ResolveTestContainerDetailsResult) GetDetails() *TestDetails { @@ -8437,7 +8913,7 @@ type ResolveTestContainerDetailsResponse struct { func (x *ResolveTestContainerDetailsResponse) Reset() { *x = ResolveTestContainerDetailsResponse{} - mi := &file_product_proto_msgTypes[181] + mi := &file_product_proto_msgTypes[191] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8449,7 +8925,7 @@ func (x *ResolveTestContainerDetailsResponse) String() string { func (*ResolveTestContainerDetailsResponse) ProtoMessage() {} func (x *ResolveTestContainerDetailsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[181] + mi := &file_product_proto_msgTypes[191] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8462,7 +8938,7 @@ func (x *ResolveTestContainerDetailsResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use ResolveTestContainerDetailsResponse.ProtoReflect.Descriptor instead. func (*ResolveTestContainerDetailsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{181} + return file_product_proto_rawDescGZIP(), []int{191} } func (x *ResolveTestContainerDetailsResponse) GetResult() []*ResolveTestContainerDetailsResult { @@ -8483,7 +8959,7 @@ type Product struct { func (x *Product) Reset() { *x = Product{} - mi := &file_product_proto_msgTypes[182] + mi := &file_product_proto_msgTypes[192] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8495,7 +8971,7 @@ func (x *Product) String() string { func (*Product) ProtoMessage() {} func (x *Product) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[182] + mi := &file_product_proto_msgTypes[192] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8508,7 +8984,7 @@ func (x *Product) ProtoReflect() protoreflect.Message { // Deprecated: Use Product.ProtoReflect.Descriptor instead. func (*Product) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{182} + return file_product_proto_rawDescGZIP(), []int{192} } func (x *Product) GetId() string { @@ -8543,7 +9019,7 @@ type Storage struct { func (x *Storage) Reset() { *x = Storage{} - mi := &file_product_proto_msgTypes[183] + mi := &file_product_proto_msgTypes[193] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8555,7 +9031,7 @@ func (x *Storage) String() string { func (*Storage) ProtoMessage() {} func (x *Storage) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[183] + mi := &file_product_proto_msgTypes[193] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8568,7 +9044,7 @@ func (x *Storage) ProtoReflect() protoreflect.Message { // Deprecated: Use Storage.ProtoReflect.Descriptor instead. func (*Storage) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{183} + return file_product_proto_rawDescGZIP(), []int{193} } func (x *Storage) GetId() string { @@ -8603,7 +9079,7 @@ type Warehouse struct { func (x *Warehouse) Reset() { *x = Warehouse{} - mi := &file_product_proto_msgTypes[184] + mi := &file_product_proto_msgTypes[194] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8615,7 +9091,7 @@ func (x *Warehouse) String() string { func (*Warehouse) ProtoMessage() {} func (x *Warehouse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[184] + mi := &file_product_proto_msgTypes[194] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8628,7 +9104,7 @@ func (x *Warehouse) ProtoReflect() protoreflect.Message { // Deprecated: Use Warehouse.ProtoReflect.Descriptor instead. func (*Warehouse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{184} + return file_product_proto_rawDescGZIP(), []int{194} } func (x *Warehouse) GetId() string { @@ -8662,7 +9138,7 @@ type User struct { func (x *User) Reset() { *x = User{} - mi := &file_product_proto_msgTypes[185] + mi := &file_product_proto_msgTypes[195] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8674,7 +9150,7 @@ func (x *User) String() string { func (*User) ProtoMessage() {} func (x *User) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[185] + mi := &file_product_proto_msgTypes[195] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8687,7 +9163,7 @@ func (x *User) ProtoReflect() protoreflect.Message { // Deprecated: Use User.ProtoReflect.Descriptor instead. func (*User) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{185} + return file_product_proto_rawDescGZIP(), []int{195} } func (x *User) GetId() string { @@ -8715,7 +9191,7 @@ type NestedTypeA struct { func (x *NestedTypeA) Reset() { *x = NestedTypeA{} - mi := &file_product_proto_msgTypes[186] + mi := &file_product_proto_msgTypes[196] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8727,7 +9203,7 @@ func (x *NestedTypeA) String() string { func (*NestedTypeA) ProtoMessage() {} func (x *NestedTypeA) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[186] + mi := &file_product_proto_msgTypes[196] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8740,7 +9216,7 @@ func (x *NestedTypeA) ProtoReflect() protoreflect.Message { // Deprecated: Use NestedTypeA.ProtoReflect.Descriptor instead. func (*NestedTypeA) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{186} + return file_product_proto_rawDescGZIP(), []int{196} } func (x *NestedTypeA) GetId() string { @@ -8775,7 +9251,7 @@ type RecursiveType struct { func (x *RecursiveType) Reset() { *x = RecursiveType{} - mi := &file_product_proto_msgTypes[187] + mi := &file_product_proto_msgTypes[197] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8787,7 +9263,7 @@ func (x *RecursiveType) String() string { func (*RecursiveType) ProtoMessage() {} func (x *RecursiveType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[187] + mi := &file_product_proto_msgTypes[197] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8800,7 +9276,7 @@ func (x *RecursiveType) ProtoReflect() protoreflect.Message { // Deprecated: Use RecursiveType.ProtoReflect.Descriptor instead. func (*RecursiveType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{187} + return file_product_proto_rawDescGZIP(), []int{197} } func (x *RecursiveType) GetId() string { @@ -8836,7 +9312,7 @@ type TypeWithMultipleFilterFields struct { func (x *TypeWithMultipleFilterFields) Reset() { *x = TypeWithMultipleFilterFields{} - mi := &file_product_proto_msgTypes[188] + mi := &file_product_proto_msgTypes[198] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8848,7 +9324,7 @@ func (x *TypeWithMultipleFilterFields) String() string { func (*TypeWithMultipleFilterFields) ProtoMessage() {} func (x *TypeWithMultipleFilterFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[188] + mi := &file_product_proto_msgTypes[198] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8861,7 +9337,7 @@ func (x *TypeWithMultipleFilterFields) ProtoReflect() protoreflect.Message { // Deprecated: Use TypeWithMultipleFilterFields.ProtoReflect.Descriptor instead. func (*TypeWithMultipleFilterFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{188} + return file_product_proto_rawDescGZIP(), []int{198} } func (x *TypeWithMultipleFilterFields) GetId() string { @@ -8902,7 +9378,7 @@ type FilterTypeInput struct { func (x *FilterTypeInput) Reset() { *x = FilterTypeInput{} - mi := &file_product_proto_msgTypes[189] + mi := &file_product_proto_msgTypes[199] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8914,7 +9390,7 @@ func (x *FilterTypeInput) String() string { func (*FilterTypeInput) ProtoMessage() {} func (x *FilterTypeInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[189] + mi := &file_product_proto_msgTypes[199] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8927,7 +9403,7 @@ func (x *FilterTypeInput) ProtoReflect() protoreflect.Message { // Deprecated: Use FilterTypeInput.ProtoReflect.Descriptor instead. func (*FilterTypeInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{189} + return file_product_proto_rawDescGZIP(), []int{199} } func (x *FilterTypeInput) GetFilterField_1() string { @@ -8953,7 +9429,7 @@ type ComplexFilterTypeInput struct { func (x *ComplexFilterTypeInput) Reset() { *x = ComplexFilterTypeInput{} - mi := &file_product_proto_msgTypes[190] + mi := &file_product_proto_msgTypes[200] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8965,7 +9441,7 @@ func (x *ComplexFilterTypeInput) String() string { func (*ComplexFilterTypeInput) ProtoMessage() {} func (x *ComplexFilterTypeInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[190] + mi := &file_product_proto_msgTypes[200] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8978,7 +9454,7 @@ func (x *ComplexFilterTypeInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ComplexFilterTypeInput.ProtoReflect.Descriptor instead. func (*ComplexFilterTypeInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{190} + return file_product_proto_rawDescGZIP(), []int{200} } func (x *ComplexFilterTypeInput) GetFilter() *FilterType { @@ -8998,7 +9474,7 @@ type TypeWithComplexFilterInput struct { func (x *TypeWithComplexFilterInput) Reset() { *x = TypeWithComplexFilterInput{} - mi := &file_product_proto_msgTypes[191] + mi := &file_product_proto_msgTypes[201] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9010,7 +9486,7 @@ func (x *TypeWithComplexFilterInput) String() string { func (*TypeWithComplexFilterInput) ProtoMessage() {} func (x *TypeWithComplexFilterInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[191] + mi := &file_product_proto_msgTypes[201] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9023,7 +9499,7 @@ func (x *TypeWithComplexFilterInput) ProtoReflect() protoreflect.Message { // Deprecated: Use TypeWithComplexFilterInput.ProtoReflect.Descriptor instead. func (*TypeWithComplexFilterInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{191} + return file_product_proto_rawDescGZIP(), []int{201} } func (x *TypeWithComplexFilterInput) GetId() string { @@ -9051,7 +9527,7 @@ type OrderInput struct { func (x *OrderInput) Reset() { *x = OrderInput{} - mi := &file_product_proto_msgTypes[192] + mi := &file_product_proto_msgTypes[202] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9063,7 +9539,7 @@ func (x *OrderInput) String() string { func (*OrderInput) ProtoMessage() {} func (x *OrderInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[192] + mi := &file_product_proto_msgTypes[202] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9076,7 +9552,7 @@ func (x *OrderInput) ProtoReflect() protoreflect.Message { // Deprecated: Use OrderInput.ProtoReflect.Descriptor instead. func (*OrderInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{192} + return file_product_proto_rawDescGZIP(), []int{202} } func (x *OrderInput) GetOrderId() string { @@ -9112,7 +9588,7 @@ type Order struct { func (x *Order) Reset() { *x = Order{} - mi := &file_product_proto_msgTypes[193] + mi := &file_product_proto_msgTypes[203] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9124,7 +9600,7 @@ func (x *Order) String() string { func (*Order) ProtoMessage() {} func (x *Order) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[193] + mi := &file_product_proto_msgTypes[203] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9137,7 +9613,7 @@ func (x *Order) ProtoReflect() protoreflect.Message { // Deprecated: Use Order.ProtoReflect.Descriptor instead. func (*Order) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{193} + return file_product_proto_rawDescGZIP(), []int{203} } func (x *Order) GetOrderId() string { @@ -9180,7 +9656,7 @@ type Category struct { func (x *Category) Reset() { *x = Category{} - mi := &file_product_proto_msgTypes[194] + mi := &file_product_proto_msgTypes[204] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9192,7 +9668,7 @@ func (x *Category) String() string { func (*Category) ProtoMessage() {} func (x *Category) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[194] + mi := &file_product_proto_msgTypes[204] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9205,7 +9681,7 @@ func (x *Category) ProtoReflect() protoreflect.Message { // Deprecated: Use Category.ProtoReflect.Descriptor instead. func (*Category) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{194} + return file_product_proto_rawDescGZIP(), []int{204} } func (x *Category) GetId() string { @@ -9246,7 +9722,7 @@ type CategoryFilter struct { func (x *CategoryFilter) Reset() { *x = CategoryFilter{} - mi := &file_product_proto_msgTypes[195] + mi := &file_product_proto_msgTypes[205] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9258,7 +9734,7 @@ func (x *CategoryFilter) String() string { func (*CategoryFilter) ProtoMessage() {} func (x *CategoryFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[195] + mi := &file_product_proto_msgTypes[205] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9271,7 +9747,7 @@ func (x *CategoryFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use CategoryFilter.ProtoReflect.Descriptor instead. func (*CategoryFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{195} + return file_product_proto_rawDescGZIP(), []int{205} } func (x *CategoryFilter) GetCategory() CategoryKind { @@ -9301,7 +9777,7 @@ type Animal struct { func (x *Animal) Reset() { *x = Animal{} - mi := &file_product_proto_msgTypes[196] + mi := &file_product_proto_msgTypes[206] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9313,7 +9789,7 @@ func (x *Animal) String() string { func (*Animal) ProtoMessage() {} func (x *Animal) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[196] + mi := &file_product_proto_msgTypes[206] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9326,7 +9802,7 @@ func (x *Animal) ProtoReflect() protoreflect.Message { // Deprecated: Use Animal.ProtoReflect.Descriptor instead. func (*Animal) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{196} + return file_product_proto_rawDescGZIP(), []int{206} } func (x *Animal) GetInstance() isAnimal_Instance { @@ -9380,7 +9856,7 @@ type SearchInput struct { func (x *SearchInput) Reset() { *x = SearchInput{} - mi := &file_product_proto_msgTypes[197] + mi := &file_product_proto_msgTypes[207] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9392,7 +9868,7 @@ func (x *SearchInput) String() string { func (*SearchInput) ProtoMessage() {} func (x *SearchInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[197] + mi := &file_product_proto_msgTypes[207] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9405,7 +9881,7 @@ func (x *SearchInput) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchInput.ProtoReflect.Descriptor instead. func (*SearchInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{197} + return file_product_proto_rawDescGZIP(), []int{207} } func (x *SearchInput) GetQuery() string { @@ -9436,7 +9912,7 @@ type SearchResult struct { func (x *SearchResult) Reset() { *x = SearchResult{} - mi := &file_product_proto_msgTypes[198] + mi := &file_product_proto_msgTypes[208] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9448,7 +9924,7 @@ func (x *SearchResult) String() string { func (*SearchResult) ProtoMessage() {} func (x *SearchResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[198] + mi := &file_product_proto_msgTypes[208] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9461,7 +9937,7 @@ func (x *SearchResult) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchResult.ProtoReflect.Descriptor instead. func (*SearchResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{198} + return file_product_proto_rawDescGZIP(), []int{208} } func (x *SearchResult) GetValue() isSearchResult_Value { @@ -9536,7 +10012,7 @@ type NullableFieldsType struct { func (x *NullableFieldsType) Reset() { *x = NullableFieldsType{} - mi := &file_product_proto_msgTypes[199] + mi := &file_product_proto_msgTypes[209] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9548,7 +10024,7 @@ func (x *NullableFieldsType) String() string { func (*NullableFieldsType) ProtoMessage() {} func (x *NullableFieldsType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[199] + mi := &file_product_proto_msgTypes[209] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9561,7 +10037,7 @@ func (x *NullableFieldsType) ProtoReflect() protoreflect.Message { // Deprecated: Use NullableFieldsType.ProtoReflect.Descriptor instead. func (*NullableFieldsType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{199} + return file_product_proto_rawDescGZIP(), []int{209} } func (x *NullableFieldsType) GetId() string { @@ -9631,7 +10107,7 @@ type NullableFieldsFilter struct { func (x *NullableFieldsFilter) Reset() { *x = NullableFieldsFilter{} - mi := &file_product_proto_msgTypes[200] + mi := &file_product_proto_msgTypes[210] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9643,7 +10119,7 @@ func (x *NullableFieldsFilter) String() string { func (*NullableFieldsFilter) ProtoMessage() {} func (x *NullableFieldsFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[200] + mi := &file_product_proto_msgTypes[210] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9656,7 +10132,7 @@ func (x *NullableFieldsFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use NullableFieldsFilter.ProtoReflect.Descriptor instead. func (*NullableFieldsFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{200} + return file_product_proto_rawDescGZIP(), []int{210} } func (x *NullableFieldsFilter) GetName() *wrapperspb.StringValue { @@ -9708,7 +10184,7 @@ type BlogPost struct { func (x *BlogPost) Reset() { *x = BlogPost{} - mi := &file_product_proto_msgTypes[201] + mi := &file_product_proto_msgTypes[211] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9720,7 +10196,7 @@ func (x *BlogPost) String() string { func (*BlogPost) ProtoMessage() {} func (x *BlogPost) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[201] + mi := &file_product_proto_msgTypes[211] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9733,7 +10209,7 @@ func (x *BlogPost) ProtoReflect() protoreflect.Message { // Deprecated: Use BlogPost.ProtoReflect.Descriptor instead. func (*BlogPost) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{201} + return file_product_proto_rawDescGZIP(), []int{211} } func (x *BlogPost) GetId() string { @@ -9887,7 +10363,7 @@ type BlogPostFilter struct { func (x *BlogPostFilter) Reset() { *x = BlogPostFilter{} - mi := &file_product_proto_msgTypes[202] + mi := &file_product_proto_msgTypes[212] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9899,7 +10375,7 @@ func (x *BlogPostFilter) String() string { func (*BlogPostFilter) ProtoMessage() {} func (x *BlogPostFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[202] + mi := &file_product_proto_msgTypes[212] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9912,7 +10388,7 @@ func (x *BlogPostFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use BlogPostFilter.ProtoReflect.Descriptor instead. func (*BlogPostFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{202} + return file_product_proto_rawDescGZIP(), []int{212} } func (x *BlogPostFilter) GetTitle() *wrapperspb.StringValue { @@ -9959,7 +10435,7 @@ type Author struct { func (x *Author) Reset() { *x = Author{} - mi := &file_product_proto_msgTypes[203] + mi := &file_product_proto_msgTypes[213] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9971,7 +10447,7 @@ func (x *Author) String() string { func (*Author) ProtoMessage() {} func (x *Author) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[203] + mi := &file_product_proto_msgTypes[213] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9984,7 +10460,7 @@ func (x *Author) ProtoReflect() protoreflect.Message { // Deprecated: Use Author.ProtoReflect.Descriptor instead. func (*Author) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{203} + return file_product_proto_rawDescGZIP(), []int{213} } func (x *Author) GetId() string { @@ -10103,7 +10579,7 @@ type AuthorFilter struct { func (x *AuthorFilter) Reset() { *x = AuthorFilter{} - mi := &file_product_proto_msgTypes[204] + mi := &file_product_proto_msgTypes[214] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10115,7 +10591,7 @@ func (x *AuthorFilter) String() string { func (*AuthorFilter) ProtoMessage() {} func (x *AuthorFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[204] + mi := &file_product_proto_msgTypes[214] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10128,7 +10604,7 @@ func (x *AuthorFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use AuthorFilter.ProtoReflect.Descriptor instead. func (*AuthorFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{204} + return file_product_proto_rawDescGZIP(), []int{214} } func (x *AuthorFilter) GetName() *wrapperspb.StringValue { @@ -10163,7 +10639,7 @@ type TestContainer struct { func (x *TestContainer) Reset() { *x = TestContainer{} - mi := &file_product_proto_msgTypes[205] + mi := &file_product_proto_msgTypes[215] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10175,7 +10651,7 @@ func (x *TestContainer) String() string { func (*TestContainer) ProtoMessage() {} func (x *TestContainer) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[205] + mi := &file_product_proto_msgTypes[215] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10188,7 +10664,7 @@ func (x *TestContainer) ProtoReflect() protoreflect.Message { // Deprecated: Use TestContainer.ProtoReflect.Descriptor instead. func (*TestContainer) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{205} + return file_product_proto_rawDescGZIP(), []int{215} } func (x *TestContainer) GetId() string { @@ -10221,7 +10697,7 @@ type UserInput struct { func (x *UserInput) Reset() { *x = UserInput{} - mi := &file_product_proto_msgTypes[206] + mi := &file_product_proto_msgTypes[216] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10233,7 +10709,7 @@ func (x *UserInput) String() string { func (*UserInput) ProtoMessage() {} func (x *UserInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[206] + mi := &file_product_proto_msgTypes[216] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10246,7 +10722,7 @@ func (x *UserInput) ProtoReflect() protoreflect.Message { // Deprecated: Use UserInput.ProtoReflect.Descriptor instead. func (*UserInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{206} + return file_product_proto_rawDescGZIP(), []int{216} } func (x *UserInput) GetName() string { @@ -10266,7 +10742,7 @@ type ActionInput struct { func (x *ActionInput) Reset() { *x = ActionInput{} - mi := &file_product_proto_msgTypes[207] + mi := &file_product_proto_msgTypes[217] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10278,7 +10754,7 @@ func (x *ActionInput) String() string { func (*ActionInput) ProtoMessage() {} func (x *ActionInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[207] + mi := &file_product_proto_msgTypes[217] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10291,7 +10767,7 @@ func (x *ActionInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionInput.ProtoReflect.Descriptor instead. func (*ActionInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{207} + return file_product_proto_rawDescGZIP(), []int{217} } func (x *ActionInput) GetType() string { @@ -10321,7 +10797,7 @@ type ActionResult struct { func (x *ActionResult) Reset() { *x = ActionResult{} - mi := &file_product_proto_msgTypes[208] + mi := &file_product_proto_msgTypes[218] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10333,7 +10809,7 @@ func (x *ActionResult) String() string { func (*ActionResult) ProtoMessage() {} func (x *ActionResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[208] + mi := &file_product_proto_msgTypes[218] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10346,7 +10822,7 @@ func (x *ActionResult) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionResult.ProtoReflect.Descriptor instead. func (*ActionResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{208} + return file_product_proto_rawDescGZIP(), []int{218} } func (x *ActionResult) GetValue() isActionResult_Value { @@ -10405,7 +10881,7 @@ type NullableFieldsInput struct { func (x *NullableFieldsInput) Reset() { *x = NullableFieldsInput{} - mi := &file_product_proto_msgTypes[209] + mi := &file_product_proto_msgTypes[219] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10417,7 +10893,7 @@ func (x *NullableFieldsInput) String() string { func (*NullableFieldsInput) ProtoMessage() {} func (x *NullableFieldsInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[209] + mi := &file_product_proto_msgTypes[219] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10430,7 +10906,7 @@ func (x *NullableFieldsInput) ProtoReflect() protoreflect.Message { // Deprecated: Use NullableFieldsInput.ProtoReflect.Descriptor instead. func (*NullableFieldsInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{209} + return file_product_proto_rawDescGZIP(), []int{219} } func (x *NullableFieldsInput) GetName() string { @@ -10506,7 +10982,7 @@ type BlogPostInput struct { func (x *BlogPostInput) Reset() { *x = BlogPostInput{} - mi := &file_product_proto_msgTypes[210] + mi := &file_product_proto_msgTypes[220] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10518,7 +10994,7 @@ func (x *BlogPostInput) String() string { func (*BlogPostInput) ProtoMessage() {} func (x *BlogPostInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[210] + mi := &file_product_proto_msgTypes[220] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10531,7 +11007,7 @@ func (x *BlogPostInput) ProtoReflect() protoreflect.Message { // Deprecated: Use BlogPostInput.ProtoReflect.Descriptor instead. func (*BlogPostInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{210} + return file_product_proto_rawDescGZIP(), []int{220} } func (x *BlogPostInput) GetTitle() string { @@ -10664,7 +11140,7 @@ type AuthorInput struct { func (x *AuthorInput) Reset() { *x = AuthorInput{} - mi := &file_product_proto_msgTypes[211] + mi := &file_product_proto_msgTypes[221] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10676,7 +11152,7 @@ func (x *AuthorInput) String() string { func (*AuthorInput) ProtoMessage() {} func (x *AuthorInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[211] + mi := &file_product_proto_msgTypes[221] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10689,7 +11165,7 @@ func (x *AuthorInput) ProtoReflect() protoreflect.Message { // Deprecated: Use AuthorInput.ProtoReflect.Descriptor instead. func (*AuthorInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{211} + return file_product_proto_rawDescGZIP(), []int{221} } func (x *AuthorInput) GetName() string { @@ -10774,7 +11250,7 @@ type ProductDetails struct { func (x *ProductDetails) Reset() { *x = ProductDetails{} - mi := &file_product_proto_msgTypes[212] + mi := &file_product_proto_msgTypes[222] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10786,7 +11262,7 @@ func (x *ProductDetails) String() string { func (*ProductDetails) ProtoMessage() {} func (x *ProductDetails) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[212] + mi := &file_product_proto_msgTypes[222] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10799,7 +11275,7 @@ func (x *ProductDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use ProductDetails.ProtoReflect.Descriptor instead. func (*ProductDetails) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{212} + return file_product_proto_rawDescGZIP(), []int{222} } func (x *ProductDetails) GetId() string { @@ -10841,7 +11317,7 @@ type NestedTypeB struct { func (x *NestedTypeB) Reset() { *x = NestedTypeB{} - mi := &file_product_proto_msgTypes[213] + mi := &file_product_proto_msgTypes[223] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10853,7 +11329,7 @@ func (x *NestedTypeB) String() string { func (*NestedTypeB) ProtoMessage() {} func (x *NestedTypeB) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[213] + mi := &file_product_proto_msgTypes[223] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10866,7 +11342,7 @@ func (x *NestedTypeB) ProtoReflect() protoreflect.Message { // Deprecated: Use NestedTypeB.ProtoReflect.Descriptor instead. func (*NestedTypeB) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{213} + return file_product_proto_rawDescGZIP(), []int{223} } func (x *NestedTypeB) GetId() string { @@ -10900,7 +11376,7 @@ type NestedTypeC struct { func (x *NestedTypeC) Reset() { *x = NestedTypeC{} - mi := &file_product_proto_msgTypes[214] + mi := &file_product_proto_msgTypes[224] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10912,7 +11388,7 @@ func (x *NestedTypeC) String() string { func (*NestedTypeC) ProtoMessage() {} func (x *NestedTypeC) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[214] + mi := &file_product_proto_msgTypes[224] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10925,7 +11401,7 @@ func (x *NestedTypeC) ProtoReflect() protoreflect.Message { // Deprecated: Use NestedTypeC.ProtoReflect.Descriptor instead. func (*NestedTypeC) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{214} + return file_product_proto_rawDescGZIP(), []int{224} } func (x *NestedTypeC) GetId() string { @@ -10954,7 +11430,7 @@ type FilterType struct { func (x *FilterType) Reset() { *x = FilterType{} - mi := &file_product_proto_msgTypes[215] + mi := &file_product_proto_msgTypes[225] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10966,7 +11442,7 @@ func (x *FilterType) String() string { func (*FilterType) ProtoMessage() {} func (x *FilterType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[215] + mi := &file_product_proto_msgTypes[225] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10979,7 +11455,7 @@ func (x *FilterType) ProtoReflect() protoreflect.Message { // Deprecated: Use FilterType.ProtoReflect.Descriptor instead. func (*FilterType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{215} + return file_product_proto_rawDescGZIP(), []int{225} } func (x *FilterType) GetName() string { @@ -11020,7 +11496,7 @@ type Pagination struct { func (x *Pagination) Reset() { *x = Pagination{} - mi := &file_product_proto_msgTypes[216] + mi := &file_product_proto_msgTypes[226] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11032,7 +11508,7 @@ func (x *Pagination) String() string { func (*Pagination) ProtoMessage() {} func (x *Pagination) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[216] + mi := &file_product_proto_msgTypes[226] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11045,7 +11521,7 @@ func (x *Pagination) ProtoReflect() protoreflect.Message { // Deprecated: Use Pagination.ProtoReflect.Descriptor instead. func (*Pagination) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{216} + return file_product_proto_rawDescGZIP(), []int{226} } func (x *Pagination) GetPage() int32 { @@ -11073,7 +11549,7 @@ type OrderLineInput struct { func (x *OrderLineInput) Reset() { *x = OrderLineInput{} - mi := &file_product_proto_msgTypes[217] + mi := &file_product_proto_msgTypes[227] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11085,7 +11561,7 @@ func (x *OrderLineInput) String() string { func (*OrderLineInput) ProtoMessage() {} func (x *OrderLineInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[217] + mi := &file_product_proto_msgTypes[227] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11098,7 +11574,7 @@ func (x *OrderLineInput) ProtoReflect() protoreflect.Message { // Deprecated: Use OrderLineInput.ProtoReflect.Descriptor instead. func (*OrderLineInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{217} + return file_product_proto_rawDescGZIP(), []int{227} } func (x *OrderLineInput) GetProductId() string { @@ -11133,7 +11609,7 @@ type OrderLine struct { func (x *OrderLine) Reset() { *x = OrderLine{} - mi := &file_product_proto_msgTypes[218] + mi := &file_product_proto_msgTypes[228] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11145,7 +11621,7 @@ func (x *OrderLine) String() string { func (*OrderLine) ProtoMessage() {} func (x *OrderLine) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[218] + mi := &file_product_proto_msgTypes[228] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11158,7 +11634,7 @@ func (x *OrderLine) ProtoReflect() protoreflect.Message { // Deprecated: Use OrderLine.ProtoReflect.Descriptor instead. func (*OrderLine) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{218} + return file_product_proto_rawDescGZIP(), []int{228} } func (x *OrderLine) GetProductId() string { @@ -11194,7 +11670,7 @@ type Subcategory struct { func (x *Subcategory) Reset() { *x = Subcategory{} - mi := &file_product_proto_msgTypes[219] + mi := &file_product_proto_msgTypes[229] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11206,7 +11682,7 @@ func (x *Subcategory) String() string { func (*Subcategory) ProtoMessage() {} func (x *Subcategory) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[219] + mi := &file_product_proto_msgTypes[229] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11219,7 +11695,7 @@ func (x *Subcategory) ProtoReflect() protoreflect.Message { // Deprecated: Use Subcategory.ProtoReflect.Descriptor instead. func (*Subcategory) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{219} + return file_product_proto_rawDescGZIP(), []int{229} } func (x *Subcategory) GetId() string { @@ -11264,7 +11740,7 @@ type CategoryMetrics struct { func (x *CategoryMetrics) Reset() { *x = CategoryMetrics{} - mi := &file_product_proto_msgTypes[220] + mi := &file_product_proto_msgTypes[230] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11276,7 +11752,7 @@ func (x *CategoryMetrics) String() string { func (*CategoryMetrics) ProtoMessage() {} func (x *CategoryMetrics) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[220] + mi := &file_product_proto_msgTypes[230] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11289,7 +11765,7 @@ func (x *CategoryMetrics) ProtoReflect() protoreflect.Message { // Deprecated: Use CategoryMetrics.ProtoReflect.Descriptor instead. func (*CategoryMetrics) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{220} + return file_product_proto_rawDescGZIP(), []int{230} } func (x *CategoryMetrics) GetId() string { @@ -11348,7 +11824,7 @@ type Cat struct { func (x *Cat) Reset() { *x = Cat{} - mi := &file_product_proto_msgTypes[221] + mi := &file_product_proto_msgTypes[231] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11360,7 +11836,7 @@ func (x *Cat) String() string { func (*Cat) ProtoMessage() {} func (x *Cat) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[221] + mi := &file_product_proto_msgTypes[231] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11373,7 +11849,7 @@ func (x *Cat) ProtoReflect() protoreflect.Message { // Deprecated: Use Cat.ProtoReflect.Descriptor instead. func (*Cat) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{221} + return file_product_proto_rawDescGZIP(), []int{231} } func (x *Cat) GetId() string { @@ -11432,7 +11908,7 @@ type Dog struct { func (x *Dog) Reset() { *x = Dog{} - mi := &file_product_proto_msgTypes[222] + mi := &file_product_proto_msgTypes[232] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11444,7 +11920,7 @@ func (x *Dog) String() string { func (*Dog) ProtoMessage() {} func (x *Dog) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[222] + mi := &file_product_proto_msgTypes[232] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11457,7 +11933,7 @@ func (x *Dog) ProtoReflect() protoreflect.Message { // Deprecated: Use Dog.ProtoReflect.Descriptor instead. func (*Dog) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{222} + return file_product_proto_rawDescGZIP(), []int{232} } func (x *Dog) GetId() string { @@ -11513,7 +11989,7 @@ type Owner struct { func (x *Owner) Reset() { *x = Owner{} - mi := &file_product_proto_msgTypes[223] + mi := &file_product_proto_msgTypes[233] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11525,7 +12001,7 @@ func (x *Owner) String() string { func (*Owner) ProtoMessage() {} func (x *Owner) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[223] + mi := &file_product_proto_msgTypes[233] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11538,7 +12014,7 @@ func (x *Owner) ProtoReflect() protoreflect.Message { // Deprecated: Use Owner.ProtoReflect.Descriptor instead. func (*Owner) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{223} + return file_product_proto_rawDescGZIP(), []int{233} } func (x *Owner) GetId() string { @@ -11573,7 +12049,7 @@ type ContactInfo struct { func (x *ContactInfo) Reset() { *x = ContactInfo{} - mi := &file_product_proto_msgTypes[224] + mi := &file_product_proto_msgTypes[234] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11585,7 +12061,7 @@ func (x *ContactInfo) String() string { func (*ContactInfo) ProtoMessage() {} func (x *ContactInfo) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[224] + mi := &file_product_proto_msgTypes[234] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11598,7 +12074,7 @@ func (x *ContactInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use ContactInfo.ProtoReflect.Descriptor instead. func (*ContactInfo) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{224} + return file_product_proto_rawDescGZIP(), []int{234} } func (x *ContactInfo) GetEmail() string { @@ -11634,7 +12110,7 @@ type Address struct { func (x *Address) Reset() { *x = Address{} - mi := &file_product_proto_msgTypes[225] + mi := &file_product_proto_msgTypes[235] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11646,7 +12122,7 @@ func (x *Address) String() string { func (*Address) ProtoMessage() {} func (x *Address) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[225] + mi := &file_product_proto_msgTypes[235] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11659,7 +12135,7 @@ func (x *Address) ProtoReflect() protoreflect.Message { // Deprecated: Use Address.ProtoReflect.Descriptor instead. func (*Address) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{225} + return file_product_proto_rawDescGZIP(), []int{235} } func (x *Address) GetStreet() string { @@ -11702,7 +12178,7 @@ type CatBreed struct { func (x *CatBreed) Reset() { *x = CatBreed{} - mi := &file_product_proto_msgTypes[226] + mi := &file_product_proto_msgTypes[236] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11714,7 +12190,7 @@ func (x *CatBreed) String() string { func (*CatBreed) ProtoMessage() {} func (x *CatBreed) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[226] + mi := &file_product_proto_msgTypes[236] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11727,7 +12203,7 @@ func (x *CatBreed) ProtoReflect() protoreflect.Message { // Deprecated: Use CatBreed.ProtoReflect.Descriptor instead. func (*CatBreed) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{226} + return file_product_proto_rawDescGZIP(), []int{236} } func (x *CatBreed) GetId() string { @@ -11770,7 +12246,7 @@ type DogBreed struct { func (x *DogBreed) Reset() { *x = DogBreed{} - mi := &file_product_proto_msgTypes[227] + mi := &file_product_proto_msgTypes[237] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11782,7 +12258,7 @@ func (x *DogBreed) String() string { func (*DogBreed) ProtoMessage() {} func (x *DogBreed) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[227] + mi := &file_product_proto_msgTypes[237] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11795,7 +12271,7 @@ func (x *DogBreed) ProtoReflect() protoreflect.Message { // Deprecated: Use DogBreed.ProtoReflect.Descriptor instead. func (*DogBreed) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{227} + return file_product_proto_rawDescGZIP(), []int{237} } func (x *DogBreed) GetId() string { @@ -11837,7 +12313,7 @@ type BreedCharacteristics struct { func (x *BreedCharacteristics) Reset() { *x = BreedCharacteristics{} - mi := &file_product_proto_msgTypes[228] + mi := &file_product_proto_msgTypes[238] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11849,7 +12325,7 @@ func (x *BreedCharacteristics) String() string { func (*BreedCharacteristics) ProtoMessage() {} func (x *BreedCharacteristics) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[228] + mi := &file_product_proto_msgTypes[238] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11862,7 +12338,7 @@ func (x *BreedCharacteristics) ProtoReflect() protoreflect.Message { // Deprecated: Use BreedCharacteristics.ProtoReflect.Descriptor instead. func (*BreedCharacteristics) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{228} + return file_product_proto_rawDescGZIP(), []int{238} } func (x *BreedCharacteristics) GetSize() string { @@ -11896,7 +12372,7 @@ type ActionSuccess struct { func (x *ActionSuccess) Reset() { *x = ActionSuccess{} - mi := &file_product_proto_msgTypes[229] + mi := &file_product_proto_msgTypes[239] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11908,7 +12384,7 @@ func (x *ActionSuccess) String() string { func (*ActionSuccess) ProtoMessage() {} func (x *ActionSuccess) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[229] + mi := &file_product_proto_msgTypes[239] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11921,7 +12397,7 @@ func (x *ActionSuccess) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionSuccess.ProtoReflect.Descriptor instead. func (*ActionSuccess) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{229} + return file_product_proto_rawDescGZIP(), []int{239} } func (x *ActionSuccess) GetMessage() string { @@ -11948,7 +12424,7 @@ type ActionError struct { func (x *ActionError) Reset() { *x = ActionError{} - mi := &file_product_proto_msgTypes[230] + mi := &file_product_proto_msgTypes[240] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11960,7 +12436,7 @@ func (x *ActionError) String() string { func (*ActionError) ProtoMessage() {} func (x *ActionError) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[230] + mi := &file_product_proto_msgTypes[240] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11973,7 +12449,7 @@ func (x *ActionError) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionError.ProtoReflect.Descriptor instead. func (*ActionError) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{230} + return file_product_proto_rawDescGZIP(), []int{240} } func (x *ActionError) GetMessage() string { @@ -12002,7 +12478,7 @@ type TestDetails struct { func (x *TestDetails) Reset() { *x = TestDetails{} - mi := &file_product_proto_msgTypes[231] + mi := &file_product_proto_msgTypes[241] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12014,7 +12490,7 @@ func (x *TestDetails) String() string { func (*TestDetails) ProtoMessage() {} func (x *TestDetails) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[231] + mi := &file_product_proto_msgTypes[241] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12027,7 +12503,7 @@ func (x *TestDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use TestDetails.ProtoReflect.Descriptor instead. func (*TestDetails) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{231} + return file_product_proto_rawDescGZIP(), []int{241} } func (x *TestDetails) GetId() string { @@ -12068,7 +12544,7 @@ type CategoryInput struct { func (x *CategoryInput) Reset() { *x = CategoryInput{} - mi := &file_product_proto_msgTypes[232] + mi := &file_product_proto_msgTypes[242] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12080,7 +12556,7 @@ func (x *CategoryInput) String() string { func (*CategoryInput) ProtoMessage() {} func (x *CategoryInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[232] + mi := &file_product_proto_msgTypes[242] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12093,7 +12569,7 @@ func (x *CategoryInput) ProtoReflect() protoreflect.Message { // Deprecated: Use CategoryInput.ProtoReflect.Descriptor instead. func (*CategoryInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{232} + return file_product_proto_rawDescGZIP(), []int{242} } func (x *CategoryInput) GetName() string { @@ -12122,7 +12598,7 @@ type ProductCountFilter struct { func (x *ProductCountFilter) Reset() { *x = ProductCountFilter{} - mi := &file_product_proto_msgTypes[233] + mi := &file_product_proto_msgTypes[243] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12134,7 +12610,7 @@ func (x *ProductCountFilter) String() string { func (*ProductCountFilter) ProtoMessage() {} func (x *ProductCountFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[233] + mi := &file_product_proto_msgTypes[243] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12147,7 +12623,7 @@ func (x *ProductCountFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use ProductCountFilter.ProtoReflect.Descriptor instead. func (*ProductCountFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{233} + return file_product_proto_rawDescGZIP(), []int{243} } func (x *ProductCountFilter) GetMinPrice() *wrapperspb.DoubleValue { @@ -12191,7 +12667,7 @@ type SubcategoryItemFilter struct { func (x *SubcategoryItemFilter) Reset() { *x = SubcategoryItemFilter{} - mi := &file_product_proto_msgTypes[234] + mi := &file_product_proto_msgTypes[244] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12203,7 +12679,7 @@ func (x *SubcategoryItemFilter) String() string { func (*SubcategoryItemFilter) ProtoMessage() {} func (x *SubcategoryItemFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[234] + mi := &file_product_proto_msgTypes[244] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12216,7 +12692,7 @@ func (x *SubcategoryItemFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use SubcategoryItemFilter.ProtoReflect.Descriptor instead. func (*SubcategoryItemFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{234} + return file_product_proto_rawDescGZIP(), []int{244} } func (x *SubcategoryItemFilter) GetMinPrice() *wrapperspb.DoubleValue { @@ -12265,7 +12741,7 @@ type ShippingEstimateInput struct { func (x *ShippingEstimateInput) Reset() { *x = ShippingEstimateInput{} - mi := &file_product_proto_msgTypes[235] + mi := &file_product_proto_msgTypes[245] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12277,7 +12753,7 @@ func (x *ShippingEstimateInput) String() string { func (*ShippingEstimateInput) ProtoMessage() {} func (x *ShippingEstimateInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[235] + mi := &file_product_proto_msgTypes[245] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12290,7 +12766,7 @@ func (x *ShippingEstimateInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ShippingEstimateInput.ProtoReflect.Descriptor instead. func (*ShippingEstimateInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{235} + return file_product_proto_rawDescGZIP(), []int{245} } func (x *ShippingEstimateInput) GetDestination() ShippingDestination { @@ -12323,7 +12799,7 @@ type ListOfAuthorFilter_List struct { func (x *ListOfAuthorFilter_List) Reset() { *x = ListOfAuthorFilter_List{} - mi := &file_product_proto_msgTypes[236] + mi := &file_product_proto_msgTypes[246] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12335,7 +12811,7 @@ func (x *ListOfAuthorFilter_List) String() string { func (*ListOfAuthorFilter_List) ProtoMessage() {} func (x *ListOfAuthorFilter_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[236] + mi := &file_product_proto_msgTypes[246] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12367,7 +12843,7 @@ type ListOfAuthorInput_List struct { func (x *ListOfAuthorInput_List) Reset() { *x = ListOfAuthorInput_List{} - mi := &file_product_proto_msgTypes[237] + mi := &file_product_proto_msgTypes[247] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12379,7 +12855,7 @@ func (x *ListOfAuthorInput_List) String() string { func (*ListOfAuthorInput_List) ProtoMessage() {} func (x *ListOfAuthorInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[237] + mi := &file_product_proto_msgTypes[247] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12411,7 +12887,7 @@ type ListOfBlogPost_List struct { func (x *ListOfBlogPost_List) Reset() { *x = ListOfBlogPost_List{} - mi := &file_product_proto_msgTypes[238] + mi := &file_product_proto_msgTypes[248] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12423,7 +12899,7 @@ func (x *ListOfBlogPost_List) String() string { func (*ListOfBlogPost_List) ProtoMessage() {} func (x *ListOfBlogPost_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[238] + mi := &file_product_proto_msgTypes[248] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12455,7 +12931,7 @@ type ListOfBlogPostFilter_List struct { func (x *ListOfBlogPostFilter_List) Reset() { *x = ListOfBlogPostFilter_List{} - mi := &file_product_proto_msgTypes[239] + mi := &file_product_proto_msgTypes[249] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12467,7 +12943,7 @@ func (x *ListOfBlogPostFilter_List) String() string { func (*ListOfBlogPostFilter_List) ProtoMessage() {} func (x *ListOfBlogPostFilter_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[239] + mi := &file_product_proto_msgTypes[249] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12499,7 +12975,7 @@ type ListOfBlogPostInput_List struct { func (x *ListOfBlogPostInput_List) Reset() { *x = ListOfBlogPostInput_List{} - mi := &file_product_proto_msgTypes[240] + mi := &file_product_proto_msgTypes[250] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12511,7 +12987,7 @@ func (x *ListOfBlogPostInput_List) String() string { func (*ListOfBlogPostInput_List) ProtoMessage() {} func (x *ListOfBlogPostInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[240] + mi := &file_product_proto_msgTypes[250] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12543,7 +13019,7 @@ type ListOfBoolean_List struct { func (x *ListOfBoolean_List) Reset() { *x = ListOfBoolean_List{} - mi := &file_product_proto_msgTypes[241] + mi := &file_product_proto_msgTypes[251] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12555,7 +13031,7 @@ func (x *ListOfBoolean_List) String() string { func (*ListOfBoolean_List) ProtoMessage() {} func (x *ListOfBoolean_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[241] + mi := &file_product_proto_msgTypes[251] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12587,7 +13063,7 @@ type ListOfCategory_List struct { func (x *ListOfCategory_List) Reset() { *x = ListOfCategory_List{} - mi := &file_product_proto_msgTypes[242] + mi := &file_product_proto_msgTypes[252] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12599,7 +13075,7 @@ func (x *ListOfCategory_List) String() string { func (*ListOfCategory_List) ProtoMessage() {} func (x *ListOfCategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[242] + mi := &file_product_proto_msgTypes[252] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12631,7 +13107,7 @@ type ListOfCategoryInput_List struct { func (x *ListOfCategoryInput_List) Reset() { *x = ListOfCategoryInput_List{} - mi := &file_product_proto_msgTypes[243] + mi := &file_product_proto_msgTypes[253] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12643,7 +13119,7 @@ func (x *ListOfCategoryInput_List) String() string { func (*ListOfCategoryInput_List) ProtoMessage() {} func (x *ListOfCategoryInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[243] + mi := &file_product_proto_msgTypes[253] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12675,7 +13151,7 @@ type ListOfFloat_List struct { func (x *ListOfFloat_List) Reset() { *x = ListOfFloat_List{} - mi := &file_product_proto_msgTypes[244] + mi := &file_product_proto_msgTypes[254] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12687,7 +13163,7 @@ func (x *ListOfFloat_List) String() string { func (*ListOfFloat_List) ProtoMessage() {} func (x *ListOfFloat_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[244] + mi := &file_product_proto_msgTypes[254] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12719,7 +13195,7 @@ type ListOfListOfCategory_List struct { func (x *ListOfListOfCategory_List) Reset() { *x = ListOfListOfCategory_List{} - mi := &file_product_proto_msgTypes[245] + mi := &file_product_proto_msgTypes[255] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12731,7 +13207,7 @@ func (x *ListOfListOfCategory_List) String() string { func (*ListOfListOfCategory_List) ProtoMessage() {} func (x *ListOfListOfCategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[245] + mi := &file_product_proto_msgTypes[255] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12763,7 +13239,7 @@ type ListOfListOfCategoryInput_List struct { func (x *ListOfListOfCategoryInput_List) Reset() { *x = ListOfListOfCategoryInput_List{} - mi := &file_product_proto_msgTypes[246] + mi := &file_product_proto_msgTypes[256] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12775,7 +13251,7 @@ func (x *ListOfListOfCategoryInput_List) String() string { func (*ListOfListOfCategoryInput_List) ProtoMessage() {} func (x *ListOfListOfCategoryInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[246] + mi := &file_product_proto_msgTypes[256] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12807,7 +13283,7 @@ type ListOfListOfString_List struct { func (x *ListOfListOfString_List) Reset() { *x = ListOfListOfString_List{} - mi := &file_product_proto_msgTypes[247] + mi := &file_product_proto_msgTypes[257] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12819,7 +13295,7 @@ func (x *ListOfListOfString_List) String() string { func (*ListOfListOfString_List) ProtoMessage() {} func (x *ListOfListOfString_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[247] + mi := &file_product_proto_msgTypes[257] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12851,7 +13327,7 @@ type ListOfListOfUser_List struct { func (x *ListOfListOfUser_List) Reset() { *x = ListOfListOfUser_List{} - mi := &file_product_proto_msgTypes[248] + mi := &file_product_proto_msgTypes[258] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12863,7 +13339,7 @@ func (x *ListOfListOfUser_List) String() string { func (*ListOfListOfUser_List) ProtoMessage() {} func (x *ListOfListOfUser_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[248] + mi := &file_product_proto_msgTypes[258] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12895,7 +13371,7 @@ type ListOfListOfUserInput_List struct { func (x *ListOfListOfUserInput_List) Reset() { *x = ListOfListOfUserInput_List{} - mi := &file_product_proto_msgTypes[249] + mi := &file_product_proto_msgTypes[259] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12907,7 +13383,7 @@ func (x *ListOfListOfUserInput_List) String() string { func (*ListOfListOfUserInput_List) ProtoMessage() {} func (x *ListOfListOfUserInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[249] + mi := &file_product_proto_msgTypes[259] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12939,7 +13415,7 @@ type ListOfOrderLine_List struct { func (x *ListOfOrderLine_List) Reset() { *x = ListOfOrderLine_List{} - mi := &file_product_proto_msgTypes[250] + mi := &file_product_proto_msgTypes[260] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12951,7 +13427,7 @@ func (x *ListOfOrderLine_List) String() string { func (*ListOfOrderLine_List) ProtoMessage() {} func (x *ListOfOrderLine_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[250] + mi := &file_product_proto_msgTypes[260] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12983,7 +13459,7 @@ type ListOfProduct_List struct { func (x *ListOfProduct_List) Reset() { *x = ListOfProduct_List{} - mi := &file_product_proto_msgTypes[251] + mi := &file_product_proto_msgTypes[261] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12995,7 +13471,7 @@ func (x *ListOfProduct_List) String() string { func (*ListOfProduct_List) ProtoMessage() {} func (x *ListOfProduct_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[251] + mi := &file_product_proto_msgTypes[261] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13027,7 +13503,7 @@ type ListOfString_List struct { func (x *ListOfString_List) Reset() { *x = ListOfString_List{} - mi := &file_product_proto_msgTypes[252] + mi := &file_product_proto_msgTypes[262] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13039,7 +13515,7 @@ func (x *ListOfString_List) String() string { func (*ListOfString_List) ProtoMessage() {} func (x *ListOfString_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[252] + mi := &file_product_proto_msgTypes[262] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13071,7 +13547,7 @@ type ListOfSubcategory_List struct { func (x *ListOfSubcategory_List) Reset() { *x = ListOfSubcategory_List{} - mi := &file_product_proto_msgTypes[253] + mi := &file_product_proto_msgTypes[263] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13083,7 +13559,7 @@ func (x *ListOfSubcategory_List) String() string { func (*ListOfSubcategory_List) ProtoMessage() {} func (x *ListOfSubcategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[253] + mi := &file_product_proto_msgTypes[263] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13115,7 +13591,7 @@ type ListOfUser_List struct { func (x *ListOfUser_List) Reset() { *x = ListOfUser_List{} - mi := &file_product_proto_msgTypes[254] + mi := &file_product_proto_msgTypes[264] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13127,7 +13603,7 @@ func (x *ListOfUser_List) String() string { func (*ListOfUser_List) ProtoMessage() {} func (x *ListOfUser_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[254] + mi := &file_product_proto_msgTypes[264] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13159,7 +13635,7 @@ type ListOfUserInput_List struct { func (x *ListOfUserInput_List) Reset() { *x = ListOfUserInput_List{} - mi := &file_product_proto_msgTypes[255] + mi := &file_product_proto_msgTypes[265] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13171,7 +13647,7 @@ func (x *ListOfUserInput_List) String() string { func (*ListOfUserInput_List) ProtoMessage() {} func (x *ListOfUserInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[255] + mi := &file_product_proto_msgTypes[265] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13605,7 +14081,33 @@ const file_product_proto_rawDesc = "" + "#ResolveCategoryCategoryStatusResult\x12@\n" + "\x0fcategory_status\x18\x01 \x01(\v2\x17.productv1.ActionResultR\x0ecategoryStatus\"o\n" + "%ResolveCategoryCategoryStatusResponse\x12F\n" + - "\x06result\x18\x01 \x03(\v2..productv1.ResolveCategoryCategoryStatusResultR\x06result\"]\n" + + "\x06result\x18\x01 \x03(\v2..productv1.ResolveCategoryCategoryStatusResultR\x06result\"Z\n" + + "\"ResolveCategoryChildCategoriesArgs\x124\n" + + "\ainclude\x18\x01 \x01(\v2\x1a.google.protobuf.BoolValueR\ainclude\"K\n" + + "%ResolveCategoryChildCategoriesContext\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + + "\x04name\x18\x02 \x01(\tR\x04name\"\xc1\x01\n" + + "%ResolveCategoryChildCategoriesRequest\x12J\n" + + "\acontext\x18\x01 \x03(\v20.productv1.ResolveCategoryChildCategoriesContextR\acontext\x12L\n" + + "\n" + + "field_args\x18\x02 \x01(\v2-.productv1.ResolveCategoryChildCategoriesArgsR\tfieldArgs\"f\n" + + "$ResolveCategoryChildCategoriesResult\x12>\n" + + "\x10child_categories\x18\x01 \x03(\v2\x13.productv1.CategoryR\x0fchildCategories\"q\n" + + "&ResolveCategoryChildCategoriesResponse\x12G\n" + + "\x06result\x18\x01 \x03(\v2/.productv1.ResolveCategoryChildCategoriesResultR\x06result\"]\n" + + "%ResolveCategoryOptionalCategoriesArgs\x124\n" + + "\ainclude\x18\x01 \x01(\v2\x1a.google.protobuf.BoolValueR\ainclude\"N\n" + + "(ResolveCategoryOptionalCategoriesContext\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + + "\x04name\x18\x02 \x01(\tR\x04name\"\xca\x01\n" + + "(ResolveCategoryOptionalCategoriesRequest\x12M\n" + + "\acontext\x18\x01 \x03(\v23.productv1.ResolveCategoryOptionalCategoriesContextR\acontext\x12O\n" + + "\n" + + "field_args\x18\x02 \x01(\v20.productv1.ResolveCategoryOptionalCategoriesArgsR\tfieldArgs\"u\n" + + "'ResolveCategoryOptionalCategoriesResult\x12J\n" + + "\x13optional_categories\x18\x01 \x01(\v2\x19.productv1.ListOfCategoryR\x12optionalCategories\"w\n" + + ")ResolveCategoryOptionalCategoriesResponse\x12J\n" + + "\x06result\x18\x01 \x03(\v22.productv1.ResolveCategoryOptionalCategoriesResultR\x06result\"]\n" + "\x1fResolveSubcategoryItemCountArgs\x12:\n" + "\afilters\x18\x01 \x01(\v2 .productv1.SubcategoryItemFilterR\afilters\"4\n" + "\"ResolveSubcategoryItemCountContext\x12\x0e\n" + @@ -13620,11 +14122,10 @@ const file_product_proto_rawDesc = "" + "#ResolveSubcategoryItemCountResponse\x12D\n" + "\x06result\x18\x01 \x03(\v2,.productv1.ResolveSubcategoryItemCountResultR\x06result\"G\n" + ")ResolveCategoryMetricsNormalizedScoreArgs\x12\x1a\n" + - "\bbaseline\x18\x01 \x01(\x01R\bbaseline\"t\n" + + "\bbaseline\x18\x01 \x01(\x01R\bbaseline\"u\n" + ",ResolveCategoryMetricsNormalizedScoreContext\x12\x0e\n" + - "\x02id\x18\x01 \x01(\tR\x02id\x12\x1e\n" + - "\n" + - "metricType\x18\x02 \x01(\tR\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x1f\n" + + "\vmetric_type\x18\x02 \x01(\tR\n" + "metricType\x12\x14\n" + "\x05value\x18\x03 \x01(\x01R\x05value\"\xd6\x01\n" + ",ResolveCategoryMetricsNormalizedScoreRequest\x12Q\n" + @@ -13971,7 +14472,7 @@ const file_product_proto_rawDesc = "" + " SHIPPING_DESTINATION_UNSPECIFIED\x10\x00\x12!\n" + "\x1dSHIPPING_DESTINATION_DOMESTIC\x10\x01\x12 \n" + "\x1cSHIPPING_DESTINATION_EXPRESS\x10\x02\x12&\n" + - "\"SHIPPING_DESTINATION_INTERNATIONAL\x10\x032\xde5\n" + + "\"SHIPPING_DESTINATION_INTERNATIONAL\x10\x032\xfb7\n" + "\x0eProductService\x12`\n" + "\x11LookupProductById\x12#.productv1.LookupProductByIdRequest\x1a$.productv1.LookupProductByIdResponse\"\x00\x12`\n" + "\x11LookupStorageById\x12#.productv1.LookupStorageByIdRequest\x1a$.productv1.LookupStorageByIdResponse\"\x00\x12f\n" + @@ -14022,9 +14523,11 @@ const file_product_proto_rawDesc = "" + "\n" + "QueryUsers\x12\x1c.productv1.QueryUsersRequest\x1a\x1d.productv1.QueryUsersResponse\"\x00\x12\x87\x01\n" + "\x1eResolveCategoryCategoryMetrics\x120.productv1.ResolveCategoryCategoryMetricsRequest\x1a1.productv1.ResolveCategoryCategoryMetricsResponse\"\x00\x12\x84\x01\n" + - "\x1dResolveCategoryCategoryStatus\x12/.productv1.ResolveCategoryCategoryStatusRequest\x1a0.productv1.ResolveCategoryCategoryStatusResponse\"\x00\x12l\n" + + "\x1dResolveCategoryCategoryStatus\x12/.productv1.ResolveCategoryCategoryStatusRequest\x1a0.productv1.ResolveCategoryCategoryStatusResponse\"\x00\x12\x87\x01\n" + + "\x1eResolveCategoryChildCategories\x120.productv1.ResolveCategoryChildCategoriesRequest\x1a1.productv1.ResolveCategoryChildCategoriesResponse\"\x00\x12l\n" + "\x15ResolveCategoryMascot\x12'.productv1.ResolveCategoryMascotRequest\x1a(.productv1.ResolveCategoryMascotResponse\"\x00\x12\x9c\x01\n" + - "%ResolveCategoryMetricsNormalizedScore\x127.productv1.ResolveCategoryMetricsNormalizedScoreRequest\x1a8.productv1.ResolveCategoryMetricsNormalizedScoreResponse\"\x00\x12\x87\x01\n" + + "%ResolveCategoryMetricsNormalizedScore\x127.productv1.ResolveCategoryMetricsNormalizedScoreRequest\x1a8.productv1.ResolveCategoryMetricsNormalizedScoreResponse\"\x00\x12\x90\x01\n" + + "!ResolveCategoryOptionalCategories\x123.productv1.ResolveCategoryOptionalCategoriesRequest\x1a4.productv1.ResolveCategoryOptionalCategoriesResponse\"\x00\x12\x87\x01\n" + "\x1eResolveCategoryPopularityScore\x120.productv1.ResolveCategoryPopularityScoreRequest\x1a1.productv1.ResolveCategoryPopularityScoreResponse\"\x00\x12~\n" + "\x1bResolveCategoryProductCount\x12-.productv1.ResolveCategoryProductCountRequest\x1a..productv1.ResolveCategoryProductCountResponse\"\x00\x12\x93\x01\n" + "\"ResolveProductMascotRecommendation\x124.productv1.ResolveProductMascotRecommendationRequest\x1a5.productv1.ResolveProductMascotRecommendationResponse\"\x00\x12\x81\x01\n" + @@ -14048,7 +14551,7 @@ func file_product_proto_rawDescGZIP() []byte { } var file_product_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_product_proto_msgTypes = make([]protoimpl.MessageInfo, 256) +var file_product_proto_msgTypes = make([]protoimpl.MessageInfo, 266) var file_product_proto_goTypes = []any{ (CategoryKind)(0), // 0: productv1.CategoryKind (ShippingDestination)(0), // 1: productv1.ShippingDestination @@ -14219,498 +14722,522 @@ var file_product_proto_goTypes = []any{ (*ResolveCategoryCategoryStatusRequest)(nil), // 166: productv1.ResolveCategoryCategoryStatusRequest (*ResolveCategoryCategoryStatusResult)(nil), // 167: productv1.ResolveCategoryCategoryStatusResult (*ResolveCategoryCategoryStatusResponse)(nil), // 168: productv1.ResolveCategoryCategoryStatusResponse - (*ResolveSubcategoryItemCountArgs)(nil), // 169: productv1.ResolveSubcategoryItemCountArgs - (*ResolveSubcategoryItemCountContext)(nil), // 170: productv1.ResolveSubcategoryItemCountContext - (*ResolveSubcategoryItemCountRequest)(nil), // 171: productv1.ResolveSubcategoryItemCountRequest - (*ResolveSubcategoryItemCountResult)(nil), // 172: productv1.ResolveSubcategoryItemCountResult - (*ResolveSubcategoryItemCountResponse)(nil), // 173: productv1.ResolveSubcategoryItemCountResponse - (*ResolveCategoryMetricsNormalizedScoreArgs)(nil), // 174: productv1.ResolveCategoryMetricsNormalizedScoreArgs - (*ResolveCategoryMetricsNormalizedScoreContext)(nil), // 175: productv1.ResolveCategoryMetricsNormalizedScoreContext - (*ResolveCategoryMetricsNormalizedScoreRequest)(nil), // 176: productv1.ResolveCategoryMetricsNormalizedScoreRequest - (*ResolveCategoryMetricsNormalizedScoreResult)(nil), // 177: productv1.ResolveCategoryMetricsNormalizedScoreResult - (*ResolveCategoryMetricsNormalizedScoreResponse)(nil), // 178: productv1.ResolveCategoryMetricsNormalizedScoreResponse - (*ResolveTestContainerDetailsArgs)(nil), // 179: productv1.ResolveTestContainerDetailsArgs - (*ResolveTestContainerDetailsContext)(nil), // 180: productv1.ResolveTestContainerDetailsContext - (*ResolveTestContainerDetailsRequest)(nil), // 181: productv1.ResolveTestContainerDetailsRequest - (*ResolveTestContainerDetailsResult)(nil), // 182: productv1.ResolveTestContainerDetailsResult - (*ResolveTestContainerDetailsResponse)(nil), // 183: productv1.ResolveTestContainerDetailsResponse - (*Product)(nil), // 184: productv1.Product - (*Storage)(nil), // 185: productv1.Storage - (*Warehouse)(nil), // 186: productv1.Warehouse - (*User)(nil), // 187: productv1.User - (*NestedTypeA)(nil), // 188: productv1.NestedTypeA - (*RecursiveType)(nil), // 189: productv1.RecursiveType - (*TypeWithMultipleFilterFields)(nil), // 190: productv1.TypeWithMultipleFilterFields - (*FilterTypeInput)(nil), // 191: productv1.FilterTypeInput - (*ComplexFilterTypeInput)(nil), // 192: productv1.ComplexFilterTypeInput - (*TypeWithComplexFilterInput)(nil), // 193: productv1.TypeWithComplexFilterInput - (*OrderInput)(nil), // 194: productv1.OrderInput - (*Order)(nil), // 195: productv1.Order - (*Category)(nil), // 196: productv1.Category - (*CategoryFilter)(nil), // 197: productv1.CategoryFilter - (*Animal)(nil), // 198: productv1.Animal - (*SearchInput)(nil), // 199: productv1.SearchInput - (*SearchResult)(nil), // 200: productv1.SearchResult - (*NullableFieldsType)(nil), // 201: productv1.NullableFieldsType - (*NullableFieldsFilter)(nil), // 202: productv1.NullableFieldsFilter - (*BlogPost)(nil), // 203: productv1.BlogPost - (*BlogPostFilter)(nil), // 204: productv1.BlogPostFilter - (*Author)(nil), // 205: productv1.Author - (*AuthorFilter)(nil), // 206: productv1.AuthorFilter - (*TestContainer)(nil), // 207: productv1.TestContainer - (*UserInput)(nil), // 208: productv1.UserInput - (*ActionInput)(nil), // 209: productv1.ActionInput - (*ActionResult)(nil), // 210: productv1.ActionResult - (*NullableFieldsInput)(nil), // 211: productv1.NullableFieldsInput - (*BlogPostInput)(nil), // 212: productv1.BlogPostInput - (*AuthorInput)(nil), // 213: productv1.AuthorInput - (*ProductDetails)(nil), // 214: productv1.ProductDetails - (*NestedTypeB)(nil), // 215: productv1.NestedTypeB - (*NestedTypeC)(nil), // 216: productv1.NestedTypeC - (*FilterType)(nil), // 217: productv1.FilterType - (*Pagination)(nil), // 218: productv1.Pagination - (*OrderLineInput)(nil), // 219: productv1.OrderLineInput - (*OrderLine)(nil), // 220: productv1.OrderLine - (*Subcategory)(nil), // 221: productv1.Subcategory - (*CategoryMetrics)(nil), // 222: productv1.CategoryMetrics - (*Cat)(nil), // 223: productv1.Cat - (*Dog)(nil), // 224: productv1.Dog - (*Owner)(nil), // 225: productv1.Owner - (*ContactInfo)(nil), // 226: productv1.ContactInfo - (*Address)(nil), // 227: productv1.Address - (*CatBreed)(nil), // 228: productv1.CatBreed - (*DogBreed)(nil), // 229: productv1.DogBreed - (*BreedCharacteristics)(nil), // 230: productv1.BreedCharacteristics - (*ActionSuccess)(nil), // 231: productv1.ActionSuccess - (*ActionError)(nil), // 232: productv1.ActionError - (*TestDetails)(nil), // 233: productv1.TestDetails - (*CategoryInput)(nil), // 234: productv1.CategoryInput - (*ProductCountFilter)(nil), // 235: productv1.ProductCountFilter - (*SubcategoryItemFilter)(nil), // 236: productv1.SubcategoryItemFilter - (*ShippingEstimateInput)(nil), // 237: productv1.ShippingEstimateInput - (*ListOfAuthorFilter_List)(nil), // 238: productv1.ListOfAuthorFilter.List - (*ListOfAuthorInput_List)(nil), // 239: productv1.ListOfAuthorInput.List - (*ListOfBlogPost_List)(nil), // 240: productv1.ListOfBlogPost.List - (*ListOfBlogPostFilter_List)(nil), // 241: productv1.ListOfBlogPostFilter.List - (*ListOfBlogPostInput_List)(nil), // 242: productv1.ListOfBlogPostInput.List - (*ListOfBoolean_List)(nil), // 243: productv1.ListOfBoolean.List - (*ListOfCategory_List)(nil), // 244: productv1.ListOfCategory.List - (*ListOfCategoryInput_List)(nil), // 245: productv1.ListOfCategoryInput.List - (*ListOfFloat_List)(nil), // 246: productv1.ListOfFloat.List - (*ListOfListOfCategory_List)(nil), // 247: productv1.ListOfListOfCategory.List - (*ListOfListOfCategoryInput_List)(nil), // 248: productv1.ListOfListOfCategoryInput.List - (*ListOfListOfString_List)(nil), // 249: productv1.ListOfListOfString.List - (*ListOfListOfUser_List)(nil), // 250: productv1.ListOfListOfUser.List - (*ListOfListOfUserInput_List)(nil), // 251: productv1.ListOfListOfUserInput.List - (*ListOfOrderLine_List)(nil), // 252: productv1.ListOfOrderLine.List - (*ListOfProduct_List)(nil), // 253: productv1.ListOfProduct.List - (*ListOfString_List)(nil), // 254: productv1.ListOfString.List - (*ListOfSubcategory_List)(nil), // 255: productv1.ListOfSubcategory.List - (*ListOfUser_List)(nil), // 256: productv1.ListOfUser.List - (*ListOfUserInput_List)(nil), // 257: productv1.ListOfUserInput.List - (*wrapperspb.Int32Value)(nil), // 258: google.protobuf.Int32Value - (*wrapperspb.StringValue)(nil), // 259: google.protobuf.StringValue - (*wrapperspb.DoubleValue)(nil), // 260: google.protobuf.DoubleValue - (*wrapperspb.BoolValue)(nil), // 261: google.protobuf.BoolValue + (*ResolveCategoryChildCategoriesArgs)(nil), // 169: productv1.ResolveCategoryChildCategoriesArgs + (*ResolveCategoryChildCategoriesContext)(nil), // 170: productv1.ResolveCategoryChildCategoriesContext + (*ResolveCategoryChildCategoriesRequest)(nil), // 171: productv1.ResolveCategoryChildCategoriesRequest + (*ResolveCategoryChildCategoriesResult)(nil), // 172: productv1.ResolveCategoryChildCategoriesResult + (*ResolveCategoryChildCategoriesResponse)(nil), // 173: productv1.ResolveCategoryChildCategoriesResponse + (*ResolveCategoryOptionalCategoriesArgs)(nil), // 174: productv1.ResolveCategoryOptionalCategoriesArgs + (*ResolveCategoryOptionalCategoriesContext)(nil), // 175: productv1.ResolveCategoryOptionalCategoriesContext + (*ResolveCategoryOptionalCategoriesRequest)(nil), // 176: productv1.ResolveCategoryOptionalCategoriesRequest + (*ResolveCategoryOptionalCategoriesResult)(nil), // 177: productv1.ResolveCategoryOptionalCategoriesResult + (*ResolveCategoryOptionalCategoriesResponse)(nil), // 178: productv1.ResolveCategoryOptionalCategoriesResponse + (*ResolveSubcategoryItemCountArgs)(nil), // 179: productv1.ResolveSubcategoryItemCountArgs + (*ResolveSubcategoryItemCountContext)(nil), // 180: productv1.ResolveSubcategoryItemCountContext + (*ResolveSubcategoryItemCountRequest)(nil), // 181: productv1.ResolveSubcategoryItemCountRequest + (*ResolveSubcategoryItemCountResult)(nil), // 182: productv1.ResolveSubcategoryItemCountResult + (*ResolveSubcategoryItemCountResponse)(nil), // 183: productv1.ResolveSubcategoryItemCountResponse + (*ResolveCategoryMetricsNormalizedScoreArgs)(nil), // 184: productv1.ResolveCategoryMetricsNormalizedScoreArgs + (*ResolveCategoryMetricsNormalizedScoreContext)(nil), // 185: productv1.ResolveCategoryMetricsNormalizedScoreContext + (*ResolveCategoryMetricsNormalizedScoreRequest)(nil), // 186: productv1.ResolveCategoryMetricsNormalizedScoreRequest + (*ResolveCategoryMetricsNormalizedScoreResult)(nil), // 187: productv1.ResolveCategoryMetricsNormalizedScoreResult + (*ResolveCategoryMetricsNormalizedScoreResponse)(nil), // 188: productv1.ResolveCategoryMetricsNormalizedScoreResponse + (*ResolveTestContainerDetailsArgs)(nil), // 189: productv1.ResolveTestContainerDetailsArgs + (*ResolveTestContainerDetailsContext)(nil), // 190: productv1.ResolveTestContainerDetailsContext + (*ResolveTestContainerDetailsRequest)(nil), // 191: productv1.ResolveTestContainerDetailsRequest + (*ResolveTestContainerDetailsResult)(nil), // 192: productv1.ResolveTestContainerDetailsResult + (*ResolveTestContainerDetailsResponse)(nil), // 193: productv1.ResolveTestContainerDetailsResponse + (*Product)(nil), // 194: productv1.Product + (*Storage)(nil), // 195: productv1.Storage + (*Warehouse)(nil), // 196: productv1.Warehouse + (*User)(nil), // 197: productv1.User + (*NestedTypeA)(nil), // 198: productv1.NestedTypeA + (*RecursiveType)(nil), // 199: productv1.RecursiveType + (*TypeWithMultipleFilterFields)(nil), // 200: productv1.TypeWithMultipleFilterFields + (*FilterTypeInput)(nil), // 201: productv1.FilterTypeInput + (*ComplexFilterTypeInput)(nil), // 202: productv1.ComplexFilterTypeInput + (*TypeWithComplexFilterInput)(nil), // 203: productv1.TypeWithComplexFilterInput + (*OrderInput)(nil), // 204: productv1.OrderInput + (*Order)(nil), // 205: productv1.Order + (*Category)(nil), // 206: productv1.Category + (*CategoryFilter)(nil), // 207: productv1.CategoryFilter + (*Animal)(nil), // 208: productv1.Animal + (*SearchInput)(nil), // 209: productv1.SearchInput + (*SearchResult)(nil), // 210: productv1.SearchResult + (*NullableFieldsType)(nil), // 211: productv1.NullableFieldsType + (*NullableFieldsFilter)(nil), // 212: productv1.NullableFieldsFilter + (*BlogPost)(nil), // 213: productv1.BlogPost + (*BlogPostFilter)(nil), // 214: productv1.BlogPostFilter + (*Author)(nil), // 215: productv1.Author + (*AuthorFilter)(nil), // 216: productv1.AuthorFilter + (*TestContainer)(nil), // 217: productv1.TestContainer + (*UserInput)(nil), // 218: productv1.UserInput + (*ActionInput)(nil), // 219: productv1.ActionInput + (*ActionResult)(nil), // 220: productv1.ActionResult + (*NullableFieldsInput)(nil), // 221: productv1.NullableFieldsInput + (*BlogPostInput)(nil), // 222: productv1.BlogPostInput + (*AuthorInput)(nil), // 223: productv1.AuthorInput + (*ProductDetails)(nil), // 224: productv1.ProductDetails + (*NestedTypeB)(nil), // 225: productv1.NestedTypeB + (*NestedTypeC)(nil), // 226: productv1.NestedTypeC + (*FilterType)(nil), // 227: productv1.FilterType + (*Pagination)(nil), // 228: productv1.Pagination + (*OrderLineInput)(nil), // 229: productv1.OrderLineInput + (*OrderLine)(nil), // 230: productv1.OrderLine + (*Subcategory)(nil), // 231: productv1.Subcategory + (*CategoryMetrics)(nil), // 232: productv1.CategoryMetrics + (*Cat)(nil), // 233: productv1.Cat + (*Dog)(nil), // 234: productv1.Dog + (*Owner)(nil), // 235: productv1.Owner + (*ContactInfo)(nil), // 236: productv1.ContactInfo + (*Address)(nil), // 237: productv1.Address + (*CatBreed)(nil), // 238: productv1.CatBreed + (*DogBreed)(nil), // 239: productv1.DogBreed + (*BreedCharacteristics)(nil), // 240: productv1.BreedCharacteristics + (*ActionSuccess)(nil), // 241: productv1.ActionSuccess + (*ActionError)(nil), // 242: productv1.ActionError + (*TestDetails)(nil), // 243: productv1.TestDetails + (*CategoryInput)(nil), // 244: productv1.CategoryInput + (*ProductCountFilter)(nil), // 245: productv1.ProductCountFilter + (*SubcategoryItemFilter)(nil), // 246: productv1.SubcategoryItemFilter + (*ShippingEstimateInput)(nil), // 247: productv1.ShippingEstimateInput + (*ListOfAuthorFilter_List)(nil), // 248: productv1.ListOfAuthorFilter.List + (*ListOfAuthorInput_List)(nil), // 249: productv1.ListOfAuthorInput.List + (*ListOfBlogPost_List)(nil), // 250: productv1.ListOfBlogPost.List + (*ListOfBlogPostFilter_List)(nil), // 251: productv1.ListOfBlogPostFilter.List + (*ListOfBlogPostInput_List)(nil), // 252: productv1.ListOfBlogPostInput.List + (*ListOfBoolean_List)(nil), // 253: productv1.ListOfBoolean.List + (*ListOfCategory_List)(nil), // 254: productv1.ListOfCategory.List + (*ListOfCategoryInput_List)(nil), // 255: productv1.ListOfCategoryInput.List + (*ListOfFloat_List)(nil), // 256: productv1.ListOfFloat.List + (*ListOfListOfCategory_List)(nil), // 257: productv1.ListOfListOfCategory.List + (*ListOfListOfCategoryInput_List)(nil), // 258: productv1.ListOfListOfCategoryInput.List + (*ListOfListOfString_List)(nil), // 259: productv1.ListOfListOfString.List + (*ListOfListOfUser_List)(nil), // 260: productv1.ListOfListOfUser.List + (*ListOfListOfUserInput_List)(nil), // 261: productv1.ListOfListOfUserInput.List + (*ListOfOrderLine_List)(nil), // 262: productv1.ListOfOrderLine.List + (*ListOfProduct_List)(nil), // 263: productv1.ListOfProduct.List + (*ListOfString_List)(nil), // 264: productv1.ListOfString.List + (*ListOfSubcategory_List)(nil), // 265: productv1.ListOfSubcategory.List + (*ListOfUser_List)(nil), // 266: productv1.ListOfUser.List + (*ListOfUserInput_List)(nil), // 267: productv1.ListOfUserInput.List + (*wrapperspb.Int32Value)(nil), // 268: google.protobuf.Int32Value + (*wrapperspb.BoolValue)(nil), // 269: google.protobuf.BoolValue + (*wrapperspb.StringValue)(nil), // 270: google.protobuf.StringValue + (*wrapperspb.DoubleValue)(nil), // 271: google.protobuf.DoubleValue } var file_product_proto_depIdxs = []int32{ - 238, // 0: productv1.ListOfAuthorFilter.list:type_name -> productv1.ListOfAuthorFilter.List - 239, // 1: productv1.ListOfAuthorInput.list:type_name -> productv1.ListOfAuthorInput.List - 240, // 2: productv1.ListOfBlogPost.list:type_name -> productv1.ListOfBlogPost.List - 241, // 3: productv1.ListOfBlogPostFilter.list:type_name -> productv1.ListOfBlogPostFilter.List - 242, // 4: productv1.ListOfBlogPostInput.list:type_name -> productv1.ListOfBlogPostInput.List - 243, // 5: productv1.ListOfBoolean.list:type_name -> productv1.ListOfBoolean.List - 244, // 6: productv1.ListOfCategory.list:type_name -> productv1.ListOfCategory.List - 245, // 7: productv1.ListOfCategoryInput.list:type_name -> productv1.ListOfCategoryInput.List - 246, // 8: productv1.ListOfFloat.list:type_name -> productv1.ListOfFloat.List - 247, // 9: productv1.ListOfListOfCategory.list:type_name -> productv1.ListOfListOfCategory.List - 248, // 10: productv1.ListOfListOfCategoryInput.list:type_name -> productv1.ListOfListOfCategoryInput.List - 249, // 11: productv1.ListOfListOfString.list:type_name -> productv1.ListOfListOfString.List - 250, // 12: productv1.ListOfListOfUser.list:type_name -> productv1.ListOfListOfUser.List - 251, // 13: productv1.ListOfListOfUserInput.list:type_name -> productv1.ListOfListOfUserInput.List - 252, // 14: productv1.ListOfOrderLine.list:type_name -> productv1.ListOfOrderLine.List - 253, // 15: productv1.ListOfProduct.list:type_name -> productv1.ListOfProduct.List - 254, // 16: productv1.ListOfString.list:type_name -> productv1.ListOfString.List - 255, // 17: productv1.ListOfSubcategory.list:type_name -> productv1.ListOfSubcategory.List - 256, // 18: productv1.ListOfUser.list:type_name -> productv1.ListOfUser.List - 257, // 19: productv1.ListOfUserInput.list:type_name -> productv1.ListOfUserInput.List + 248, // 0: productv1.ListOfAuthorFilter.list:type_name -> productv1.ListOfAuthorFilter.List + 249, // 1: productv1.ListOfAuthorInput.list:type_name -> productv1.ListOfAuthorInput.List + 250, // 2: productv1.ListOfBlogPost.list:type_name -> productv1.ListOfBlogPost.List + 251, // 3: productv1.ListOfBlogPostFilter.list:type_name -> productv1.ListOfBlogPostFilter.List + 252, // 4: productv1.ListOfBlogPostInput.list:type_name -> productv1.ListOfBlogPostInput.List + 253, // 5: productv1.ListOfBoolean.list:type_name -> productv1.ListOfBoolean.List + 254, // 6: productv1.ListOfCategory.list:type_name -> productv1.ListOfCategory.List + 255, // 7: productv1.ListOfCategoryInput.list:type_name -> productv1.ListOfCategoryInput.List + 256, // 8: productv1.ListOfFloat.list:type_name -> productv1.ListOfFloat.List + 257, // 9: productv1.ListOfListOfCategory.list:type_name -> productv1.ListOfListOfCategory.List + 258, // 10: productv1.ListOfListOfCategoryInput.list:type_name -> productv1.ListOfListOfCategoryInput.List + 259, // 11: productv1.ListOfListOfString.list:type_name -> productv1.ListOfListOfString.List + 260, // 12: productv1.ListOfListOfUser.list:type_name -> productv1.ListOfListOfUser.List + 261, // 13: productv1.ListOfListOfUserInput.list:type_name -> productv1.ListOfListOfUserInput.List + 262, // 14: productv1.ListOfOrderLine.list:type_name -> productv1.ListOfOrderLine.List + 263, // 15: productv1.ListOfProduct.list:type_name -> productv1.ListOfProduct.List + 264, // 16: productv1.ListOfString.list:type_name -> productv1.ListOfString.List + 265, // 17: productv1.ListOfSubcategory.list:type_name -> productv1.ListOfSubcategory.List + 266, // 18: productv1.ListOfUser.list:type_name -> productv1.ListOfUser.List + 267, // 19: productv1.ListOfUserInput.list:type_name -> productv1.ListOfUserInput.List 22, // 20: productv1.LookupProductByIdRequest.keys:type_name -> productv1.LookupProductByIdRequestKey - 184, // 21: productv1.LookupProductByIdResponse.result:type_name -> productv1.Product + 194, // 21: productv1.LookupProductByIdResponse.result:type_name -> productv1.Product 25, // 22: productv1.LookupStorageByIdRequest.keys:type_name -> productv1.LookupStorageByIdRequestKey - 185, // 23: productv1.LookupStorageByIdResponse.result:type_name -> productv1.Storage + 195, // 23: productv1.LookupStorageByIdResponse.result:type_name -> productv1.Storage 28, // 24: productv1.LookupWarehouseByIdRequest.keys:type_name -> productv1.LookupWarehouseByIdRequestKey - 186, // 25: productv1.LookupWarehouseByIdResponse.result:type_name -> productv1.Warehouse - 187, // 26: productv1.QueryUsersResponse.users:type_name -> productv1.User - 187, // 27: productv1.QueryUserResponse.user:type_name -> productv1.User - 188, // 28: productv1.QueryNestedTypeResponse.nested_type:type_name -> productv1.NestedTypeA - 189, // 29: productv1.QueryRecursiveTypeResponse.recursive_type:type_name -> productv1.RecursiveType - 190, // 30: productv1.QueryTypeFilterWithArgumentsResponse.type_filter_with_arguments:type_name -> productv1.TypeWithMultipleFilterFields - 191, // 31: productv1.QueryTypeWithMultipleFilterFieldsRequest.filter:type_name -> productv1.FilterTypeInput - 190, // 32: productv1.QueryTypeWithMultipleFilterFieldsResponse.type_with_multiple_filter_fields:type_name -> productv1.TypeWithMultipleFilterFields - 192, // 33: productv1.QueryComplexFilterTypeRequest.filter:type_name -> productv1.ComplexFilterTypeInput - 193, // 34: productv1.QueryComplexFilterTypeResponse.complex_filter_type:type_name -> productv1.TypeWithComplexFilterInput - 194, // 35: productv1.QueryCalculateTotalsRequest.orders:type_name -> productv1.OrderInput - 195, // 36: productv1.QueryCalculateTotalsResponse.calculate_totals:type_name -> productv1.Order - 196, // 37: productv1.QueryCategoriesResponse.categories:type_name -> productv1.Category + 196, // 25: productv1.LookupWarehouseByIdResponse.result:type_name -> productv1.Warehouse + 197, // 26: productv1.QueryUsersResponse.users:type_name -> productv1.User + 197, // 27: productv1.QueryUserResponse.user:type_name -> productv1.User + 198, // 28: productv1.QueryNestedTypeResponse.nested_type:type_name -> productv1.NestedTypeA + 199, // 29: productv1.QueryRecursiveTypeResponse.recursive_type:type_name -> productv1.RecursiveType + 200, // 30: productv1.QueryTypeFilterWithArgumentsResponse.type_filter_with_arguments:type_name -> productv1.TypeWithMultipleFilterFields + 201, // 31: productv1.QueryTypeWithMultipleFilterFieldsRequest.filter:type_name -> productv1.FilterTypeInput + 200, // 32: productv1.QueryTypeWithMultipleFilterFieldsResponse.type_with_multiple_filter_fields:type_name -> productv1.TypeWithMultipleFilterFields + 202, // 33: productv1.QueryComplexFilterTypeRequest.filter:type_name -> productv1.ComplexFilterTypeInput + 203, // 34: productv1.QueryComplexFilterTypeResponse.complex_filter_type:type_name -> productv1.TypeWithComplexFilterInput + 204, // 35: productv1.QueryCalculateTotalsRequest.orders:type_name -> productv1.OrderInput + 205, // 36: productv1.QueryCalculateTotalsResponse.calculate_totals:type_name -> productv1.Order + 206, // 37: productv1.QueryCategoriesResponse.categories:type_name -> productv1.Category 0, // 38: productv1.QueryCategoriesByKindRequest.kind:type_name -> productv1.CategoryKind - 196, // 39: productv1.QueryCategoriesByKindResponse.categories_by_kind:type_name -> productv1.Category + 206, // 39: productv1.QueryCategoriesByKindResponse.categories_by_kind:type_name -> productv1.Category 0, // 40: productv1.QueryCategoriesByKindsRequest.kinds:type_name -> productv1.CategoryKind - 196, // 41: productv1.QueryCategoriesByKindsResponse.categories_by_kinds:type_name -> productv1.Category - 197, // 42: productv1.QueryFilterCategoriesRequest.filter:type_name -> productv1.CategoryFilter - 196, // 43: productv1.QueryFilterCategoriesResponse.filter_categories:type_name -> productv1.Category - 198, // 44: productv1.QueryRandomPetResponse.random_pet:type_name -> productv1.Animal - 198, // 45: productv1.QueryAllPetsResponse.all_pets:type_name -> productv1.Animal - 199, // 46: productv1.QuerySearchRequest.input:type_name -> productv1.SearchInput - 200, // 47: productv1.QuerySearchResponse.search:type_name -> productv1.SearchResult - 200, // 48: productv1.QueryRandomSearchResultResponse.random_search_result:type_name -> productv1.SearchResult - 201, // 49: productv1.QueryNullableFieldsTypeResponse.nullable_fields_type:type_name -> productv1.NullableFieldsType - 201, // 50: productv1.QueryNullableFieldsTypeByIdResponse.nullable_fields_type_by_id:type_name -> productv1.NullableFieldsType - 202, // 51: productv1.QueryNullableFieldsTypeWithFilterRequest.filter:type_name -> productv1.NullableFieldsFilter - 201, // 52: productv1.QueryNullableFieldsTypeWithFilterResponse.nullable_fields_type_with_filter:type_name -> productv1.NullableFieldsType - 201, // 53: productv1.QueryAllNullableFieldsTypesResponse.all_nullable_fields_types:type_name -> productv1.NullableFieldsType - 203, // 54: productv1.QueryBlogPostResponse.blog_post:type_name -> productv1.BlogPost - 203, // 55: productv1.QueryBlogPostByIdResponse.blog_post_by_id:type_name -> productv1.BlogPost - 204, // 56: productv1.QueryBlogPostsWithFilterRequest.filter:type_name -> productv1.BlogPostFilter - 203, // 57: productv1.QueryBlogPostsWithFilterResponse.blog_posts_with_filter:type_name -> productv1.BlogPost - 203, // 58: productv1.QueryAllBlogPostsResponse.all_blog_posts:type_name -> productv1.BlogPost - 205, // 59: productv1.QueryAuthorResponse.author:type_name -> productv1.Author - 205, // 60: productv1.QueryAuthorByIdResponse.author_by_id:type_name -> productv1.Author - 206, // 61: productv1.QueryAuthorsWithFilterRequest.filter:type_name -> productv1.AuthorFilter - 205, // 62: productv1.QueryAuthorsWithFilterResponse.authors_with_filter:type_name -> productv1.Author - 205, // 63: productv1.QueryAllAuthorsResponse.all_authors:type_name -> productv1.Author + 206, // 41: productv1.QueryCategoriesByKindsResponse.categories_by_kinds:type_name -> productv1.Category + 207, // 42: productv1.QueryFilterCategoriesRequest.filter:type_name -> productv1.CategoryFilter + 206, // 43: productv1.QueryFilterCategoriesResponse.filter_categories:type_name -> productv1.Category + 208, // 44: productv1.QueryRandomPetResponse.random_pet:type_name -> productv1.Animal + 208, // 45: productv1.QueryAllPetsResponse.all_pets:type_name -> productv1.Animal + 209, // 46: productv1.QuerySearchRequest.input:type_name -> productv1.SearchInput + 210, // 47: productv1.QuerySearchResponse.search:type_name -> productv1.SearchResult + 210, // 48: productv1.QueryRandomSearchResultResponse.random_search_result:type_name -> productv1.SearchResult + 211, // 49: productv1.QueryNullableFieldsTypeResponse.nullable_fields_type:type_name -> productv1.NullableFieldsType + 211, // 50: productv1.QueryNullableFieldsTypeByIdResponse.nullable_fields_type_by_id:type_name -> productv1.NullableFieldsType + 212, // 51: productv1.QueryNullableFieldsTypeWithFilterRequest.filter:type_name -> productv1.NullableFieldsFilter + 211, // 52: productv1.QueryNullableFieldsTypeWithFilterResponse.nullable_fields_type_with_filter:type_name -> productv1.NullableFieldsType + 211, // 53: productv1.QueryAllNullableFieldsTypesResponse.all_nullable_fields_types:type_name -> productv1.NullableFieldsType + 213, // 54: productv1.QueryBlogPostResponse.blog_post:type_name -> productv1.BlogPost + 213, // 55: productv1.QueryBlogPostByIdResponse.blog_post_by_id:type_name -> productv1.BlogPost + 214, // 56: productv1.QueryBlogPostsWithFilterRequest.filter:type_name -> productv1.BlogPostFilter + 213, // 57: productv1.QueryBlogPostsWithFilterResponse.blog_posts_with_filter:type_name -> productv1.BlogPost + 213, // 58: productv1.QueryAllBlogPostsResponse.all_blog_posts:type_name -> productv1.BlogPost + 215, // 59: productv1.QueryAuthorResponse.author:type_name -> productv1.Author + 215, // 60: productv1.QueryAuthorByIdResponse.author_by_id:type_name -> productv1.Author + 216, // 61: productv1.QueryAuthorsWithFilterRequest.filter:type_name -> productv1.AuthorFilter + 215, // 62: productv1.QueryAuthorsWithFilterResponse.authors_with_filter:type_name -> productv1.Author + 215, // 63: productv1.QueryAllAuthorsResponse.all_authors:type_name -> productv1.Author 2, // 64: productv1.QueryBulkSearchAuthorsRequest.filters:type_name -> productv1.ListOfAuthorFilter - 205, // 65: productv1.QueryBulkSearchAuthorsResponse.bulk_search_authors:type_name -> productv1.Author + 215, // 65: productv1.QueryBulkSearchAuthorsResponse.bulk_search_authors:type_name -> productv1.Author 5, // 66: productv1.QueryBulkSearchBlogPostsRequest.filters:type_name -> productv1.ListOfBlogPostFilter - 203, // 67: productv1.QueryBulkSearchBlogPostsResponse.bulk_search_blog_posts:type_name -> productv1.BlogPost - 207, // 68: productv1.QueryTestContainerResponse.test_container:type_name -> productv1.TestContainer - 207, // 69: productv1.QueryTestContainersResponse.test_containers:type_name -> productv1.TestContainer - 208, // 70: productv1.MutationCreateUserRequest.input:type_name -> productv1.UserInput - 187, // 71: productv1.MutationCreateUserResponse.create_user:type_name -> productv1.User - 209, // 72: productv1.MutationPerformActionRequest.input:type_name -> productv1.ActionInput - 210, // 73: productv1.MutationPerformActionResponse.perform_action:type_name -> productv1.ActionResult - 211, // 74: productv1.MutationCreateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput - 201, // 75: productv1.MutationCreateNullableFieldsTypeResponse.create_nullable_fields_type:type_name -> productv1.NullableFieldsType - 211, // 76: productv1.MutationUpdateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput - 201, // 77: productv1.MutationUpdateNullableFieldsTypeResponse.update_nullable_fields_type:type_name -> productv1.NullableFieldsType - 212, // 78: productv1.MutationCreateBlogPostRequest.input:type_name -> productv1.BlogPostInput - 203, // 79: productv1.MutationCreateBlogPostResponse.create_blog_post:type_name -> productv1.BlogPost - 212, // 80: productv1.MutationUpdateBlogPostRequest.input:type_name -> productv1.BlogPostInput - 203, // 81: productv1.MutationUpdateBlogPostResponse.update_blog_post:type_name -> productv1.BlogPost - 213, // 82: productv1.MutationCreateAuthorRequest.input:type_name -> productv1.AuthorInput - 205, // 83: productv1.MutationCreateAuthorResponse.create_author:type_name -> productv1.Author - 213, // 84: productv1.MutationUpdateAuthorRequest.input:type_name -> productv1.AuthorInput - 205, // 85: productv1.MutationUpdateAuthorResponse.update_author:type_name -> productv1.Author + 213, // 67: productv1.QueryBulkSearchBlogPostsResponse.bulk_search_blog_posts:type_name -> productv1.BlogPost + 217, // 68: productv1.QueryTestContainerResponse.test_container:type_name -> productv1.TestContainer + 217, // 69: productv1.QueryTestContainersResponse.test_containers:type_name -> productv1.TestContainer + 218, // 70: productv1.MutationCreateUserRequest.input:type_name -> productv1.UserInput + 197, // 71: productv1.MutationCreateUserResponse.create_user:type_name -> productv1.User + 219, // 72: productv1.MutationPerformActionRequest.input:type_name -> productv1.ActionInput + 220, // 73: productv1.MutationPerformActionResponse.perform_action:type_name -> productv1.ActionResult + 221, // 74: productv1.MutationCreateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput + 211, // 75: productv1.MutationCreateNullableFieldsTypeResponse.create_nullable_fields_type:type_name -> productv1.NullableFieldsType + 221, // 76: productv1.MutationUpdateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput + 211, // 77: productv1.MutationUpdateNullableFieldsTypeResponse.update_nullable_fields_type:type_name -> productv1.NullableFieldsType + 222, // 78: productv1.MutationCreateBlogPostRequest.input:type_name -> productv1.BlogPostInput + 213, // 79: productv1.MutationCreateBlogPostResponse.create_blog_post:type_name -> productv1.BlogPost + 222, // 80: productv1.MutationUpdateBlogPostRequest.input:type_name -> productv1.BlogPostInput + 213, // 81: productv1.MutationUpdateBlogPostResponse.update_blog_post:type_name -> productv1.BlogPost + 223, // 82: productv1.MutationCreateAuthorRequest.input:type_name -> productv1.AuthorInput + 215, // 83: productv1.MutationCreateAuthorResponse.create_author:type_name -> productv1.Author + 223, // 84: productv1.MutationUpdateAuthorRequest.input:type_name -> productv1.AuthorInput + 215, // 85: productv1.MutationUpdateAuthorResponse.update_author:type_name -> productv1.Author 3, // 86: productv1.MutationBulkCreateAuthorsRequest.authors:type_name -> productv1.ListOfAuthorInput - 205, // 87: productv1.MutationBulkCreateAuthorsResponse.bulk_create_authors:type_name -> productv1.Author + 215, // 87: productv1.MutationBulkCreateAuthorsResponse.bulk_create_authors:type_name -> productv1.Author 3, // 88: productv1.MutationBulkUpdateAuthorsRequest.authors:type_name -> productv1.ListOfAuthorInput - 205, // 89: productv1.MutationBulkUpdateAuthorsResponse.bulk_update_authors:type_name -> productv1.Author + 215, // 89: productv1.MutationBulkUpdateAuthorsResponse.bulk_update_authors:type_name -> productv1.Author 6, // 90: productv1.MutationBulkCreateBlogPostsRequest.blog_posts:type_name -> productv1.ListOfBlogPostInput - 203, // 91: productv1.MutationBulkCreateBlogPostsResponse.bulk_create_blog_posts:type_name -> productv1.BlogPost + 213, // 91: productv1.MutationBulkCreateBlogPostsResponse.bulk_create_blog_posts:type_name -> productv1.BlogPost 6, // 92: productv1.MutationBulkUpdateBlogPostsRequest.blog_posts:type_name -> productv1.ListOfBlogPostInput - 203, // 93: productv1.MutationBulkUpdateBlogPostsResponse.bulk_update_blog_posts:type_name -> productv1.BlogPost - 237, // 94: productv1.ResolveProductShippingEstimateArgs.input:type_name -> productv1.ShippingEstimateInput + 213, // 93: productv1.MutationBulkUpdateBlogPostsResponse.bulk_update_blog_posts:type_name -> productv1.BlogPost + 247, // 94: productv1.ResolveProductShippingEstimateArgs.input:type_name -> productv1.ShippingEstimateInput 120, // 95: productv1.ResolveProductShippingEstimateRequest.context:type_name -> productv1.ResolveProductShippingEstimateContext 119, // 96: productv1.ResolveProductShippingEstimateRequest.field_args:type_name -> productv1.ResolveProductShippingEstimateArgs 122, // 97: productv1.ResolveProductShippingEstimateResponse.result:type_name -> productv1.ResolveProductShippingEstimateResult 125, // 98: productv1.ResolveProductRecommendedCategoryRequest.context:type_name -> productv1.ResolveProductRecommendedCategoryContext 124, // 99: productv1.ResolveProductRecommendedCategoryRequest.field_args:type_name -> productv1.ResolveProductRecommendedCategoryArgs - 196, // 100: productv1.ResolveProductRecommendedCategoryResult.recommended_category:type_name -> productv1.Category + 206, // 100: productv1.ResolveProductRecommendedCategoryResult.recommended_category:type_name -> productv1.Category 127, // 101: productv1.ResolveProductRecommendedCategoryResponse.result:type_name -> productv1.ResolveProductRecommendedCategoryResult 130, // 102: productv1.ResolveProductMascotRecommendationRequest.context:type_name -> productv1.ResolveProductMascotRecommendationContext 129, // 103: productv1.ResolveProductMascotRecommendationRequest.field_args:type_name -> productv1.ResolveProductMascotRecommendationArgs - 198, // 104: productv1.ResolveProductMascotRecommendationResult.mascot_recommendation:type_name -> productv1.Animal + 208, // 104: productv1.ResolveProductMascotRecommendationResult.mascot_recommendation:type_name -> productv1.Animal 132, // 105: productv1.ResolveProductMascotRecommendationResponse.result:type_name -> productv1.ResolveProductMascotRecommendationResult 135, // 106: productv1.ResolveProductStockStatusRequest.context:type_name -> productv1.ResolveProductStockStatusContext 134, // 107: productv1.ResolveProductStockStatusRequest.field_args:type_name -> productv1.ResolveProductStockStatusArgs - 210, // 108: productv1.ResolveProductStockStatusResult.stock_status:type_name -> productv1.ActionResult + 220, // 108: productv1.ResolveProductStockStatusResult.stock_status:type_name -> productv1.ActionResult 137, // 109: productv1.ResolveProductStockStatusResponse.result:type_name -> productv1.ResolveProductStockStatusResult 140, // 110: productv1.ResolveProductProductDetailsRequest.context:type_name -> productv1.ResolveProductProductDetailsContext 139, // 111: productv1.ResolveProductProductDetailsRequest.field_args:type_name -> productv1.ResolveProductProductDetailsArgs - 214, // 112: productv1.ResolveProductProductDetailsResult.product_details:type_name -> productv1.ProductDetails + 224, // 112: productv1.ResolveProductProductDetailsResult.product_details:type_name -> productv1.ProductDetails 142, // 113: productv1.ResolveProductProductDetailsResponse.result:type_name -> productv1.ResolveProductProductDetailsResult - 235, // 114: productv1.ResolveCategoryProductCountArgs.filters:type_name -> productv1.ProductCountFilter + 245, // 114: productv1.ResolveCategoryProductCountArgs.filters:type_name -> productv1.ProductCountFilter 145, // 115: productv1.ResolveCategoryProductCountRequest.context:type_name -> productv1.ResolveCategoryProductCountContext 144, // 116: productv1.ResolveCategoryProductCountRequest.field_args:type_name -> productv1.ResolveCategoryProductCountArgs 147, // 117: productv1.ResolveCategoryProductCountResponse.result:type_name -> productv1.ResolveCategoryProductCountResult - 258, // 118: productv1.ResolveCategoryPopularityScoreArgs.threshold:type_name -> google.protobuf.Int32Value + 268, // 118: productv1.ResolveCategoryPopularityScoreArgs.threshold:type_name -> google.protobuf.Int32Value 150, // 119: productv1.ResolveCategoryPopularityScoreRequest.context:type_name -> productv1.ResolveCategoryPopularityScoreContext 149, // 120: productv1.ResolveCategoryPopularityScoreRequest.field_args:type_name -> productv1.ResolveCategoryPopularityScoreArgs - 258, // 121: productv1.ResolveCategoryPopularityScoreResult.popularity_score:type_name -> google.protobuf.Int32Value + 268, // 121: productv1.ResolveCategoryPopularityScoreResult.popularity_score:type_name -> google.protobuf.Int32Value 152, // 122: productv1.ResolveCategoryPopularityScoreResponse.result:type_name -> productv1.ResolveCategoryPopularityScoreResult 155, // 123: productv1.ResolveCategoryCategoryMetricsRequest.context:type_name -> productv1.ResolveCategoryCategoryMetricsContext 154, // 124: productv1.ResolveCategoryCategoryMetricsRequest.field_args:type_name -> productv1.ResolveCategoryCategoryMetricsArgs - 222, // 125: productv1.ResolveCategoryCategoryMetricsResult.category_metrics:type_name -> productv1.CategoryMetrics + 232, // 125: productv1.ResolveCategoryCategoryMetricsResult.category_metrics:type_name -> productv1.CategoryMetrics 157, // 126: productv1.ResolveCategoryCategoryMetricsResponse.result:type_name -> productv1.ResolveCategoryCategoryMetricsResult 0, // 127: productv1.ResolveCategoryMascotContext.kind:type_name -> productv1.CategoryKind 160, // 128: productv1.ResolveCategoryMascotRequest.context:type_name -> productv1.ResolveCategoryMascotContext 159, // 129: productv1.ResolveCategoryMascotRequest.field_args:type_name -> productv1.ResolveCategoryMascotArgs - 198, // 130: productv1.ResolveCategoryMascotResult.mascot:type_name -> productv1.Animal + 208, // 130: productv1.ResolveCategoryMascotResult.mascot:type_name -> productv1.Animal 162, // 131: productv1.ResolveCategoryMascotResponse.result:type_name -> productv1.ResolveCategoryMascotResult 165, // 132: productv1.ResolveCategoryCategoryStatusRequest.context:type_name -> productv1.ResolveCategoryCategoryStatusContext 164, // 133: productv1.ResolveCategoryCategoryStatusRequest.field_args:type_name -> productv1.ResolveCategoryCategoryStatusArgs - 210, // 134: productv1.ResolveCategoryCategoryStatusResult.category_status:type_name -> productv1.ActionResult + 220, // 134: productv1.ResolveCategoryCategoryStatusResult.category_status:type_name -> productv1.ActionResult 167, // 135: productv1.ResolveCategoryCategoryStatusResponse.result:type_name -> productv1.ResolveCategoryCategoryStatusResult - 236, // 136: productv1.ResolveSubcategoryItemCountArgs.filters:type_name -> productv1.SubcategoryItemFilter - 170, // 137: productv1.ResolveSubcategoryItemCountRequest.context:type_name -> productv1.ResolveSubcategoryItemCountContext - 169, // 138: productv1.ResolveSubcategoryItemCountRequest.field_args:type_name -> productv1.ResolveSubcategoryItemCountArgs - 172, // 139: productv1.ResolveSubcategoryItemCountResponse.result:type_name -> productv1.ResolveSubcategoryItemCountResult - 175, // 140: productv1.ResolveCategoryMetricsNormalizedScoreRequest.context:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreContext - 174, // 141: productv1.ResolveCategoryMetricsNormalizedScoreRequest.field_args:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreArgs - 177, // 142: productv1.ResolveCategoryMetricsNormalizedScoreResponse.result:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreResult - 180, // 143: productv1.ResolveTestContainerDetailsRequest.context:type_name -> productv1.ResolveTestContainerDetailsContext - 179, // 144: productv1.ResolveTestContainerDetailsRequest.field_args:type_name -> productv1.ResolveTestContainerDetailsArgs - 233, // 145: productv1.ResolveTestContainerDetailsResult.details:type_name -> productv1.TestDetails - 182, // 146: productv1.ResolveTestContainerDetailsResponse.result:type_name -> productv1.ResolveTestContainerDetailsResult - 215, // 147: productv1.NestedTypeA.b:type_name -> productv1.NestedTypeB - 189, // 148: productv1.RecursiveType.recursive_type:type_name -> productv1.RecursiveType - 217, // 149: productv1.ComplexFilterTypeInput.filter:type_name -> productv1.FilterType - 219, // 150: productv1.OrderInput.lines:type_name -> productv1.OrderLineInput - 16, // 151: productv1.Order.order_lines:type_name -> productv1.ListOfOrderLine - 0, // 152: productv1.Category.kind:type_name -> productv1.CategoryKind - 19, // 153: productv1.Category.subcategories:type_name -> productv1.ListOfSubcategory - 0, // 154: productv1.CategoryFilter.category:type_name -> productv1.CategoryKind - 218, // 155: productv1.CategoryFilter.pagination:type_name -> productv1.Pagination - 223, // 156: productv1.Animal.cat:type_name -> productv1.Cat - 224, // 157: productv1.Animal.dog:type_name -> productv1.Dog - 258, // 158: productv1.SearchInput.limit:type_name -> google.protobuf.Int32Value - 184, // 159: productv1.SearchResult.product:type_name -> productv1.Product - 187, // 160: productv1.SearchResult.user:type_name -> productv1.User - 196, // 161: productv1.SearchResult.category:type_name -> productv1.Category - 259, // 162: productv1.NullableFieldsType.optional_string:type_name -> google.protobuf.StringValue - 258, // 163: productv1.NullableFieldsType.optional_int:type_name -> google.protobuf.Int32Value - 260, // 164: productv1.NullableFieldsType.optional_float:type_name -> google.protobuf.DoubleValue - 261, // 165: productv1.NullableFieldsType.optional_boolean:type_name -> google.protobuf.BoolValue - 259, // 166: productv1.NullableFieldsFilter.name:type_name -> google.protobuf.StringValue - 259, // 167: productv1.NullableFieldsFilter.optional_string:type_name -> google.protobuf.StringValue - 261, // 168: productv1.NullableFieldsFilter.include_nulls:type_name -> google.protobuf.BoolValue - 18, // 169: productv1.BlogPost.optional_tags:type_name -> productv1.ListOfString - 18, // 170: productv1.BlogPost.keywords:type_name -> productv1.ListOfString - 10, // 171: productv1.BlogPost.ratings:type_name -> productv1.ListOfFloat - 7, // 172: productv1.BlogPost.is_published:type_name -> productv1.ListOfBoolean - 13, // 173: productv1.BlogPost.tag_groups:type_name -> productv1.ListOfListOfString - 13, // 174: productv1.BlogPost.related_topics:type_name -> productv1.ListOfListOfString - 13, // 175: productv1.BlogPost.comment_threads:type_name -> productv1.ListOfListOfString - 13, // 176: productv1.BlogPost.suggestions:type_name -> productv1.ListOfListOfString - 196, // 177: productv1.BlogPost.related_categories:type_name -> productv1.Category - 187, // 178: productv1.BlogPost.contributors:type_name -> productv1.User - 17, // 179: productv1.BlogPost.mentioned_products:type_name -> productv1.ListOfProduct - 20, // 180: productv1.BlogPost.mentioned_users:type_name -> productv1.ListOfUser - 11, // 181: productv1.BlogPost.category_groups:type_name -> productv1.ListOfListOfCategory - 14, // 182: productv1.BlogPost.contributor_teams:type_name -> productv1.ListOfListOfUser - 259, // 183: productv1.BlogPostFilter.title:type_name -> google.protobuf.StringValue - 261, // 184: productv1.BlogPostFilter.has_categories:type_name -> google.protobuf.BoolValue - 258, // 185: productv1.BlogPostFilter.min_tags:type_name -> google.protobuf.Int32Value - 259, // 186: productv1.Author.email:type_name -> google.protobuf.StringValue - 18, // 187: productv1.Author.social_links:type_name -> productv1.ListOfString - 13, // 188: productv1.Author.teams_by_project:type_name -> productv1.ListOfListOfString - 13, // 189: productv1.Author.collaborations:type_name -> productv1.ListOfListOfString - 4, // 190: productv1.Author.written_posts:type_name -> productv1.ListOfBlogPost - 196, // 191: productv1.Author.favorite_categories:type_name -> productv1.Category - 20, // 192: productv1.Author.related_authors:type_name -> productv1.ListOfUser - 17, // 193: productv1.Author.product_reviews:type_name -> productv1.ListOfProduct - 14, // 194: productv1.Author.author_groups:type_name -> productv1.ListOfListOfUser - 11, // 195: productv1.Author.category_preferences:type_name -> productv1.ListOfListOfCategory - 14, // 196: productv1.Author.project_teams:type_name -> productv1.ListOfListOfUser - 259, // 197: productv1.AuthorFilter.name:type_name -> google.protobuf.StringValue - 261, // 198: productv1.AuthorFilter.has_teams:type_name -> google.protobuf.BoolValue - 258, // 199: productv1.AuthorFilter.skill_count:type_name -> google.protobuf.Int32Value - 259, // 200: productv1.TestContainer.description:type_name -> google.protobuf.StringValue - 231, // 201: productv1.ActionResult.action_success:type_name -> productv1.ActionSuccess - 232, // 202: productv1.ActionResult.action_error:type_name -> productv1.ActionError - 259, // 203: productv1.NullableFieldsInput.optional_string:type_name -> google.protobuf.StringValue - 258, // 204: productv1.NullableFieldsInput.optional_int:type_name -> google.protobuf.Int32Value - 260, // 205: productv1.NullableFieldsInput.optional_float:type_name -> google.protobuf.DoubleValue - 261, // 206: productv1.NullableFieldsInput.optional_boolean:type_name -> google.protobuf.BoolValue - 18, // 207: productv1.BlogPostInput.optional_tags:type_name -> productv1.ListOfString - 18, // 208: productv1.BlogPostInput.keywords:type_name -> productv1.ListOfString - 10, // 209: productv1.BlogPostInput.ratings:type_name -> productv1.ListOfFloat - 7, // 210: productv1.BlogPostInput.is_published:type_name -> productv1.ListOfBoolean - 13, // 211: productv1.BlogPostInput.tag_groups:type_name -> productv1.ListOfListOfString - 13, // 212: productv1.BlogPostInput.related_topics:type_name -> productv1.ListOfListOfString - 13, // 213: productv1.BlogPostInput.comment_threads:type_name -> productv1.ListOfListOfString - 13, // 214: productv1.BlogPostInput.suggestions:type_name -> productv1.ListOfListOfString - 9, // 215: productv1.BlogPostInput.related_categories:type_name -> productv1.ListOfCategoryInput - 21, // 216: productv1.BlogPostInput.contributors:type_name -> productv1.ListOfUserInput - 12, // 217: productv1.BlogPostInput.category_groups:type_name -> productv1.ListOfListOfCategoryInput - 259, // 218: productv1.AuthorInput.email:type_name -> google.protobuf.StringValue - 18, // 219: productv1.AuthorInput.social_links:type_name -> productv1.ListOfString - 13, // 220: productv1.AuthorInput.teams_by_project:type_name -> productv1.ListOfListOfString - 13, // 221: productv1.AuthorInput.collaborations:type_name -> productv1.ListOfListOfString - 234, // 222: productv1.AuthorInput.favorite_categories:type_name -> productv1.CategoryInput - 15, // 223: productv1.AuthorInput.author_groups:type_name -> productv1.ListOfListOfUserInput - 15, // 224: productv1.AuthorInput.project_teams:type_name -> productv1.ListOfListOfUserInput - 210, // 225: productv1.ProductDetails.review_summary:type_name -> productv1.ActionResult - 198, // 226: productv1.ProductDetails.recommended_pet:type_name -> productv1.Animal - 216, // 227: productv1.NestedTypeB.c:type_name -> productv1.NestedTypeC - 218, // 228: productv1.FilterType.pagination:type_name -> productv1.Pagination - 18, // 229: productv1.OrderLineInput.modifiers:type_name -> productv1.ListOfString - 18, // 230: productv1.OrderLine.modifiers:type_name -> productv1.ListOfString - 259, // 231: productv1.Subcategory.description:type_name -> google.protobuf.StringValue - 196, // 232: productv1.CategoryMetrics.related_category:type_name -> productv1.Category - 225, // 233: productv1.Cat.owner:type_name -> productv1.Owner - 228, // 234: productv1.Cat.breed:type_name -> productv1.CatBreed - 225, // 235: productv1.Dog.owner:type_name -> productv1.Owner - 229, // 236: productv1.Dog.breed:type_name -> productv1.DogBreed - 226, // 237: productv1.Owner.contact:type_name -> productv1.ContactInfo - 227, // 238: productv1.ContactInfo.address:type_name -> productv1.Address - 230, // 239: productv1.CatBreed.characteristics:type_name -> productv1.BreedCharacteristics - 230, // 240: productv1.DogBreed.characteristics:type_name -> productv1.BreedCharacteristics - 198, // 241: productv1.TestDetails.pet:type_name -> productv1.Animal - 210, // 242: productv1.TestDetails.status:type_name -> productv1.ActionResult - 0, // 243: productv1.CategoryInput.kind:type_name -> productv1.CategoryKind - 260, // 244: productv1.ProductCountFilter.min_price:type_name -> google.protobuf.DoubleValue - 260, // 245: productv1.ProductCountFilter.max_price:type_name -> google.protobuf.DoubleValue - 261, // 246: productv1.ProductCountFilter.in_stock:type_name -> google.protobuf.BoolValue - 259, // 247: productv1.ProductCountFilter.search_term:type_name -> google.protobuf.StringValue - 260, // 248: productv1.SubcategoryItemFilter.min_price:type_name -> google.protobuf.DoubleValue - 260, // 249: productv1.SubcategoryItemFilter.max_price:type_name -> google.protobuf.DoubleValue - 261, // 250: productv1.SubcategoryItemFilter.in_stock:type_name -> google.protobuf.BoolValue - 261, // 251: productv1.SubcategoryItemFilter.is_active:type_name -> google.protobuf.BoolValue - 259, // 252: productv1.SubcategoryItemFilter.search_term:type_name -> google.protobuf.StringValue - 1, // 253: productv1.ShippingEstimateInput.destination:type_name -> productv1.ShippingDestination - 261, // 254: productv1.ShippingEstimateInput.expedited:type_name -> google.protobuf.BoolValue - 206, // 255: productv1.ListOfAuthorFilter.List.items:type_name -> productv1.AuthorFilter - 213, // 256: productv1.ListOfAuthorInput.List.items:type_name -> productv1.AuthorInput - 203, // 257: productv1.ListOfBlogPost.List.items:type_name -> productv1.BlogPost - 204, // 258: productv1.ListOfBlogPostFilter.List.items:type_name -> productv1.BlogPostFilter - 212, // 259: productv1.ListOfBlogPostInput.List.items:type_name -> productv1.BlogPostInput - 196, // 260: productv1.ListOfCategory.List.items:type_name -> productv1.Category - 234, // 261: productv1.ListOfCategoryInput.List.items:type_name -> productv1.CategoryInput - 8, // 262: productv1.ListOfListOfCategory.List.items:type_name -> productv1.ListOfCategory - 9, // 263: productv1.ListOfListOfCategoryInput.List.items:type_name -> productv1.ListOfCategoryInput - 18, // 264: productv1.ListOfListOfString.List.items:type_name -> productv1.ListOfString - 20, // 265: productv1.ListOfListOfUser.List.items:type_name -> productv1.ListOfUser - 21, // 266: productv1.ListOfListOfUserInput.List.items:type_name -> productv1.ListOfUserInput - 220, // 267: productv1.ListOfOrderLine.List.items:type_name -> productv1.OrderLine - 184, // 268: productv1.ListOfProduct.List.items:type_name -> productv1.Product - 221, // 269: productv1.ListOfSubcategory.List.items:type_name -> productv1.Subcategory - 187, // 270: productv1.ListOfUser.List.items:type_name -> productv1.User - 208, // 271: productv1.ListOfUserInput.List.items:type_name -> productv1.UserInput - 23, // 272: productv1.ProductService.LookupProductById:input_type -> productv1.LookupProductByIdRequest - 26, // 273: productv1.ProductService.LookupStorageById:input_type -> productv1.LookupStorageByIdRequest - 29, // 274: productv1.ProductService.LookupWarehouseById:input_type -> productv1.LookupWarehouseByIdRequest - 111, // 275: productv1.ProductService.MutationBulkCreateAuthors:input_type -> productv1.MutationBulkCreateAuthorsRequest - 115, // 276: productv1.ProductService.MutationBulkCreateBlogPosts:input_type -> productv1.MutationBulkCreateBlogPostsRequest - 113, // 277: productv1.ProductService.MutationBulkUpdateAuthors:input_type -> productv1.MutationBulkUpdateAuthorsRequest - 117, // 278: productv1.ProductService.MutationBulkUpdateBlogPosts:input_type -> productv1.MutationBulkUpdateBlogPostsRequest - 107, // 279: productv1.ProductService.MutationCreateAuthor:input_type -> productv1.MutationCreateAuthorRequest - 103, // 280: productv1.ProductService.MutationCreateBlogPost:input_type -> productv1.MutationCreateBlogPostRequest - 99, // 281: productv1.ProductService.MutationCreateNullableFieldsType:input_type -> productv1.MutationCreateNullableFieldsTypeRequest - 95, // 282: productv1.ProductService.MutationCreateUser:input_type -> productv1.MutationCreateUserRequest - 97, // 283: productv1.ProductService.MutationPerformAction:input_type -> productv1.MutationPerformActionRequest - 109, // 284: productv1.ProductService.MutationUpdateAuthor:input_type -> productv1.MutationUpdateAuthorRequest - 105, // 285: productv1.ProductService.MutationUpdateBlogPost:input_type -> productv1.MutationUpdateBlogPostRequest - 101, // 286: productv1.ProductService.MutationUpdateNullableFieldsType:input_type -> productv1.MutationUpdateNullableFieldsTypeRequest - 85, // 287: productv1.ProductService.QueryAllAuthors:input_type -> productv1.QueryAllAuthorsRequest - 77, // 288: productv1.ProductService.QueryAllBlogPosts:input_type -> productv1.QueryAllBlogPostsRequest - 69, // 289: productv1.ProductService.QueryAllNullableFieldsTypes:input_type -> productv1.QueryAllNullableFieldsTypesRequest - 57, // 290: productv1.ProductService.QueryAllPets:input_type -> productv1.QueryAllPetsRequest - 79, // 291: productv1.ProductService.QueryAuthor:input_type -> productv1.QueryAuthorRequest - 81, // 292: productv1.ProductService.QueryAuthorById:input_type -> productv1.QueryAuthorByIdRequest - 83, // 293: productv1.ProductService.QueryAuthorsWithFilter:input_type -> productv1.QueryAuthorsWithFilterRequest - 71, // 294: productv1.ProductService.QueryBlogPost:input_type -> productv1.QueryBlogPostRequest - 73, // 295: productv1.ProductService.QueryBlogPostById:input_type -> productv1.QueryBlogPostByIdRequest - 75, // 296: productv1.ProductService.QueryBlogPostsWithFilter:input_type -> productv1.QueryBlogPostsWithFilterRequest - 87, // 297: productv1.ProductService.QueryBulkSearchAuthors:input_type -> productv1.QueryBulkSearchAuthorsRequest - 89, // 298: productv1.ProductService.QueryBulkSearchBlogPosts:input_type -> productv1.QueryBulkSearchBlogPostsRequest - 45, // 299: productv1.ProductService.QueryCalculateTotals:input_type -> productv1.QueryCalculateTotalsRequest - 47, // 300: productv1.ProductService.QueryCategories:input_type -> productv1.QueryCategoriesRequest - 49, // 301: productv1.ProductService.QueryCategoriesByKind:input_type -> productv1.QueryCategoriesByKindRequest - 51, // 302: productv1.ProductService.QueryCategoriesByKinds:input_type -> productv1.QueryCategoriesByKindsRequest - 43, // 303: productv1.ProductService.QueryComplexFilterType:input_type -> productv1.QueryComplexFilterTypeRequest - 53, // 304: productv1.ProductService.QueryFilterCategories:input_type -> productv1.QueryFilterCategoriesRequest - 35, // 305: productv1.ProductService.QueryNestedType:input_type -> productv1.QueryNestedTypeRequest - 63, // 306: productv1.ProductService.QueryNullableFieldsType:input_type -> productv1.QueryNullableFieldsTypeRequest - 65, // 307: productv1.ProductService.QueryNullableFieldsTypeById:input_type -> productv1.QueryNullableFieldsTypeByIdRequest - 67, // 308: productv1.ProductService.QueryNullableFieldsTypeWithFilter:input_type -> productv1.QueryNullableFieldsTypeWithFilterRequest - 55, // 309: productv1.ProductService.QueryRandomPet:input_type -> productv1.QueryRandomPetRequest - 61, // 310: productv1.ProductService.QueryRandomSearchResult:input_type -> productv1.QueryRandomSearchResultRequest - 37, // 311: productv1.ProductService.QueryRecursiveType:input_type -> productv1.QueryRecursiveTypeRequest - 59, // 312: productv1.ProductService.QuerySearch:input_type -> productv1.QuerySearchRequest - 91, // 313: productv1.ProductService.QueryTestContainer:input_type -> productv1.QueryTestContainerRequest - 93, // 314: productv1.ProductService.QueryTestContainers:input_type -> productv1.QueryTestContainersRequest - 39, // 315: productv1.ProductService.QueryTypeFilterWithArguments:input_type -> productv1.QueryTypeFilterWithArgumentsRequest - 41, // 316: productv1.ProductService.QueryTypeWithMultipleFilterFields:input_type -> productv1.QueryTypeWithMultipleFilterFieldsRequest - 33, // 317: productv1.ProductService.QueryUser:input_type -> productv1.QueryUserRequest - 31, // 318: productv1.ProductService.QueryUsers:input_type -> productv1.QueryUsersRequest - 156, // 319: productv1.ProductService.ResolveCategoryCategoryMetrics:input_type -> productv1.ResolveCategoryCategoryMetricsRequest - 166, // 320: productv1.ProductService.ResolveCategoryCategoryStatus:input_type -> productv1.ResolveCategoryCategoryStatusRequest - 161, // 321: productv1.ProductService.ResolveCategoryMascot:input_type -> productv1.ResolveCategoryMascotRequest - 176, // 322: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:input_type -> productv1.ResolveCategoryMetricsNormalizedScoreRequest - 151, // 323: productv1.ProductService.ResolveCategoryPopularityScore:input_type -> productv1.ResolveCategoryPopularityScoreRequest - 146, // 324: productv1.ProductService.ResolveCategoryProductCount:input_type -> productv1.ResolveCategoryProductCountRequest - 131, // 325: productv1.ProductService.ResolveProductMascotRecommendation:input_type -> productv1.ResolveProductMascotRecommendationRequest - 141, // 326: productv1.ProductService.ResolveProductProductDetails:input_type -> productv1.ResolveProductProductDetailsRequest - 126, // 327: productv1.ProductService.ResolveProductRecommendedCategory:input_type -> productv1.ResolveProductRecommendedCategoryRequest - 121, // 328: productv1.ProductService.ResolveProductShippingEstimate:input_type -> productv1.ResolveProductShippingEstimateRequest - 136, // 329: productv1.ProductService.ResolveProductStockStatus:input_type -> productv1.ResolveProductStockStatusRequest - 171, // 330: productv1.ProductService.ResolveSubcategoryItemCount:input_type -> productv1.ResolveSubcategoryItemCountRequest - 181, // 331: productv1.ProductService.ResolveTestContainerDetails:input_type -> productv1.ResolveTestContainerDetailsRequest - 24, // 332: productv1.ProductService.LookupProductById:output_type -> productv1.LookupProductByIdResponse - 27, // 333: productv1.ProductService.LookupStorageById:output_type -> productv1.LookupStorageByIdResponse - 30, // 334: productv1.ProductService.LookupWarehouseById:output_type -> productv1.LookupWarehouseByIdResponse - 112, // 335: productv1.ProductService.MutationBulkCreateAuthors:output_type -> productv1.MutationBulkCreateAuthorsResponse - 116, // 336: productv1.ProductService.MutationBulkCreateBlogPosts:output_type -> productv1.MutationBulkCreateBlogPostsResponse - 114, // 337: productv1.ProductService.MutationBulkUpdateAuthors:output_type -> productv1.MutationBulkUpdateAuthorsResponse - 118, // 338: productv1.ProductService.MutationBulkUpdateBlogPosts:output_type -> productv1.MutationBulkUpdateBlogPostsResponse - 108, // 339: productv1.ProductService.MutationCreateAuthor:output_type -> productv1.MutationCreateAuthorResponse - 104, // 340: productv1.ProductService.MutationCreateBlogPost:output_type -> productv1.MutationCreateBlogPostResponse - 100, // 341: productv1.ProductService.MutationCreateNullableFieldsType:output_type -> productv1.MutationCreateNullableFieldsTypeResponse - 96, // 342: productv1.ProductService.MutationCreateUser:output_type -> productv1.MutationCreateUserResponse - 98, // 343: productv1.ProductService.MutationPerformAction:output_type -> productv1.MutationPerformActionResponse - 110, // 344: productv1.ProductService.MutationUpdateAuthor:output_type -> productv1.MutationUpdateAuthorResponse - 106, // 345: productv1.ProductService.MutationUpdateBlogPost:output_type -> productv1.MutationUpdateBlogPostResponse - 102, // 346: productv1.ProductService.MutationUpdateNullableFieldsType:output_type -> productv1.MutationUpdateNullableFieldsTypeResponse - 86, // 347: productv1.ProductService.QueryAllAuthors:output_type -> productv1.QueryAllAuthorsResponse - 78, // 348: productv1.ProductService.QueryAllBlogPosts:output_type -> productv1.QueryAllBlogPostsResponse - 70, // 349: productv1.ProductService.QueryAllNullableFieldsTypes:output_type -> productv1.QueryAllNullableFieldsTypesResponse - 58, // 350: productv1.ProductService.QueryAllPets:output_type -> productv1.QueryAllPetsResponse - 80, // 351: productv1.ProductService.QueryAuthor:output_type -> productv1.QueryAuthorResponse - 82, // 352: productv1.ProductService.QueryAuthorById:output_type -> productv1.QueryAuthorByIdResponse - 84, // 353: productv1.ProductService.QueryAuthorsWithFilter:output_type -> productv1.QueryAuthorsWithFilterResponse - 72, // 354: productv1.ProductService.QueryBlogPost:output_type -> productv1.QueryBlogPostResponse - 74, // 355: productv1.ProductService.QueryBlogPostById:output_type -> productv1.QueryBlogPostByIdResponse - 76, // 356: productv1.ProductService.QueryBlogPostsWithFilter:output_type -> productv1.QueryBlogPostsWithFilterResponse - 88, // 357: productv1.ProductService.QueryBulkSearchAuthors:output_type -> productv1.QueryBulkSearchAuthorsResponse - 90, // 358: productv1.ProductService.QueryBulkSearchBlogPosts:output_type -> productv1.QueryBulkSearchBlogPostsResponse - 46, // 359: productv1.ProductService.QueryCalculateTotals:output_type -> productv1.QueryCalculateTotalsResponse - 48, // 360: productv1.ProductService.QueryCategories:output_type -> productv1.QueryCategoriesResponse - 50, // 361: productv1.ProductService.QueryCategoriesByKind:output_type -> productv1.QueryCategoriesByKindResponse - 52, // 362: productv1.ProductService.QueryCategoriesByKinds:output_type -> productv1.QueryCategoriesByKindsResponse - 44, // 363: productv1.ProductService.QueryComplexFilterType:output_type -> productv1.QueryComplexFilterTypeResponse - 54, // 364: productv1.ProductService.QueryFilterCategories:output_type -> productv1.QueryFilterCategoriesResponse - 36, // 365: productv1.ProductService.QueryNestedType:output_type -> productv1.QueryNestedTypeResponse - 64, // 366: productv1.ProductService.QueryNullableFieldsType:output_type -> productv1.QueryNullableFieldsTypeResponse - 66, // 367: productv1.ProductService.QueryNullableFieldsTypeById:output_type -> productv1.QueryNullableFieldsTypeByIdResponse - 68, // 368: productv1.ProductService.QueryNullableFieldsTypeWithFilter:output_type -> productv1.QueryNullableFieldsTypeWithFilterResponse - 56, // 369: productv1.ProductService.QueryRandomPet:output_type -> productv1.QueryRandomPetResponse - 62, // 370: productv1.ProductService.QueryRandomSearchResult:output_type -> productv1.QueryRandomSearchResultResponse - 38, // 371: productv1.ProductService.QueryRecursiveType:output_type -> productv1.QueryRecursiveTypeResponse - 60, // 372: productv1.ProductService.QuerySearch:output_type -> productv1.QuerySearchResponse - 92, // 373: productv1.ProductService.QueryTestContainer:output_type -> productv1.QueryTestContainerResponse - 94, // 374: productv1.ProductService.QueryTestContainers:output_type -> productv1.QueryTestContainersResponse - 40, // 375: productv1.ProductService.QueryTypeFilterWithArguments:output_type -> productv1.QueryTypeFilterWithArgumentsResponse - 42, // 376: productv1.ProductService.QueryTypeWithMultipleFilterFields:output_type -> productv1.QueryTypeWithMultipleFilterFieldsResponse - 34, // 377: productv1.ProductService.QueryUser:output_type -> productv1.QueryUserResponse - 32, // 378: productv1.ProductService.QueryUsers:output_type -> productv1.QueryUsersResponse - 158, // 379: productv1.ProductService.ResolveCategoryCategoryMetrics:output_type -> productv1.ResolveCategoryCategoryMetricsResponse - 168, // 380: productv1.ProductService.ResolveCategoryCategoryStatus:output_type -> productv1.ResolveCategoryCategoryStatusResponse - 163, // 381: productv1.ProductService.ResolveCategoryMascot:output_type -> productv1.ResolveCategoryMascotResponse - 178, // 382: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:output_type -> productv1.ResolveCategoryMetricsNormalizedScoreResponse - 153, // 383: productv1.ProductService.ResolveCategoryPopularityScore:output_type -> productv1.ResolveCategoryPopularityScoreResponse - 148, // 384: productv1.ProductService.ResolveCategoryProductCount:output_type -> productv1.ResolveCategoryProductCountResponse - 133, // 385: productv1.ProductService.ResolveProductMascotRecommendation:output_type -> productv1.ResolveProductMascotRecommendationResponse - 143, // 386: productv1.ProductService.ResolveProductProductDetails:output_type -> productv1.ResolveProductProductDetailsResponse - 128, // 387: productv1.ProductService.ResolveProductRecommendedCategory:output_type -> productv1.ResolveProductRecommendedCategoryResponse - 123, // 388: productv1.ProductService.ResolveProductShippingEstimate:output_type -> productv1.ResolveProductShippingEstimateResponse - 138, // 389: productv1.ProductService.ResolveProductStockStatus:output_type -> productv1.ResolveProductStockStatusResponse - 173, // 390: productv1.ProductService.ResolveSubcategoryItemCount:output_type -> productv1.ResolveSubcategoryItemCountResponse - 183, // 391: productv1.ProductService.ResolveTestContainerDetails:output_type -> productv1.ResolveTestContainerDetailsResponse - 332, // [332:392] is the sub-list for method output_type - 272, // [272:332] is the sub-list for method input_type - 272, // [272:272] is the sub-list for extension type_name - 272, // [272:272] is the sub-list for extension extendee - 0, // [0:272] is the sub-list for field type_name + 269, // 136: productv1.ResolveCategoryChildCategoriesArgs.include:type_name -> google.protobuf.BoolValue + 170, // 137: productv1.ResolveCategoryChildCategoriesRequest.context:type_name -> productv1.ResolveCategoryChildCategoriesContext + 169, // 138: productv1.ResolveCategoryChildCategoriesRequest.field_args:type_name -> productv1.ResolveCategoryChildCategoriesArgs + 206, // 139: productv1.ResolveCategoryChildCategoriesResult.child_categories:type_name -> productv1.Category + 172, // 140: productv1.ResolveCategoryChildCategoriesResponse.result:type_name -> productv1.ResolveCategoryChildCategoriesResult + 269, // 141: productv1.ResolveCategoryOptionalCategoriesArgs.include:type_name -> google.protobuf.BoolValue + 175, // 142: productv1.ResolveCategoryOptionalCategoriesRequest.context:type_name -> productv1.ResolveCategoryOptionalCategoriesContext + 174, // 143: productv1.ResolveCategoryOptionalCategoriesRequest.field_args:type_name -> productv1.ResolveCategoryOptionalCategoriesArgs + 8, // 144: productv1.ResolveCategoryOptionalCategoriesResult.optional_categories:type_name -> productv1.ListOfCategory + 177, // 145: productv1.ResolveCategoryOptionalCategoriesResponse.result:type_name -> productv1.ResolveCategoryOptionalCategoriesResult + 246, // 146: productv1.ResolveSubcategoryItemCountArgs.filters:type_name -> productv1.SubcategoryItemFilter + 180, // 147: productv1.ResolveSubcategoryItemCountRequest.context:type_name -> productv1.ResolveSubcategoryItemCountContext + 179, // 148: productv1.ResolveSubcategoryItemCountRequest.field_args:type_name -> productv1.ResolveSubcategoryItemCountArgs + 182, // 149: productv1.ResolveSubcategoryItemCountResponse.result:type_name -> productv1.ResolveSubcategoryItemCountResult + 185, // 150: productv1.ResolveCategoryMetricsNormalizedScoreRequest.context:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreContext + 184, // 151: productv1.ResolveCategoryMetricsNormalizedScoreRequest.field_args:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreArgs + 187, // 152: productv1.ResolveCategoryMetricsNormalizedScoreResponse.result:type_name -> productv1.ResolveCategoryMetricsNormalizedScoreResult + 190, // 153: productv1.ResolveTestContainerDetailsRequest.context:type_name -> productv1.ResolveTestContainerDetailsContext + 189, // 154: productv1.ResolveTestContainerDetailsRequest.field_args:type_name -> productv1.ResolveTestContainerDetailsArgs + 243, // 155: productv1.ResolveTestContainerDetailsResult.details:type_name -> productv1.TestDetails + 192, // 156: productv1.ResolveTestContainerDetailsResponse.result:type_name -> productv1.ResolveTestContainerDetailsResult + 225, // 157: productv1.NestedTypeA.b:type_name -> productv1.NestedTypeB + 199, // 158: productv1.RecursiveType.recursive_type:type_name -> productv1.RecursiveType + 227, // 159: productv1.ComplexFilterTypeInput.filter:type_name -> productv1.FilterType + 229, // 160: productv1.OrderInput.lines:type_name -> productv1.OrderLineInput + 16, // 161: productv1.Order.order_lines:type_name -> productv1.ListOfOrderLine + 0, // 162: productv1.Category.kind:type_name -> productv1.CategoryKind + 19, // 163: productv1.Category.subcategories:type_name -> productv1.ListOfSubcategory + 0, // 164: productv1.CategoryFilter.category:type_name -> productv1.CategoryKind + 228, // 165: productv1.CategoryFilter.pagination:type_name -> productv1.Pagination + 233, // 166: productv1.Animal.cat:type_name -> productv1.Cat + 234, // 167: productv1.Animal.dog:type_name -> productv1.Dog + 268, // 168: productv1.SearchInput.limit:type_name -> google.protobuf.Int32Value + 194, // 169: productv1.SearchResult.product:type_name -> productv1.Product + 197, // 170: productv1.SearchResult.user:type_name -> productv1.User + 206, // 171: productv1.SearchResult.category:type_name -> productv1.Category + 270, // 172: productv1.NullableFieldsType.optional_string:type_name -> google.protobuf.StringValue + 268, // 173: productv1.NullableFieldsType.optional_int:type_name -> google.protobuf.Int32Value + 271, // 174: productv1.NullableFieldsType.optional_float:type_name -> google.protobuf.DoubleValue + 269, // 175: productv1.NullableFieldsType.optional_boolean:type_name -> google.protobuf.BoolValue + 270, // 176: productv1.NullableFieldsFilter.name:type_name -> google.protobuf.StringValue + 270, // 177: productv1.NullableFieldsFilter.optional_string:type_name -> google.protobuf.StringValue + 269, // 178: productv1.NullableFieldsFilter.include_nulls:type_name -> google.protobuf.BoolValue + 18, // 179: productv1.BlogPost.optional_tags:type_name -> productv1.ListOfString + 18, // 180: productv1.BlogPost.keywords:type_name -> productv1.ListOfString + 10, // 181: productv1.BlogPost.ratings:type_name -> productv1.ListOfFloat + 7, // 182: productv1.BlogPost.is_published:type_name -> productv1.ListOfBoolean + 13, // 183: productv1.BlogPost.tag_groups:type_name -> productv1.ListOfListOfString + 13, // 184: productv1.BlogPost.related_topics:type_name -> productv1.ListOfListOfString + 13, // 185: productv1.BlogPost.comment_threads:type_name -> productv1.ListOfListOfString + 13, // 186: productv1.BlogPost.suggestions:type_name -> productv1.ListOfListOfString + 206, // 187: productv1.BlogPost.related_categories:type_name -> productv1.Category + 197, // 188: productv1.BlogPost.contributors:type_name -> productv1.User + 17, // 189: productv1.BlogPost.mentioned_products:type_name -> productv1.ListOfProduct + 20, // 190: productv1.BlogPost.mentioned_users:type_name -> productv1.ListOfUser + 11, // 191: productv1.BlogPost.category_groups:type_name -> productv1.ListOfListOfCategory + 14, // 192: productv1.BlogPost.contributor_teams:type_name -> productv1.ListOfListOfUser + 270, // 193: productv1.BlogPostFilter.title:type_name -> google.protobuf.StringValue + 269, // 194: productv1.BlogPostFilter.has_categories:type_name -> google.protobuf.BoolValue + 268, // 195: productv1.BlogPostFilter.min_tags:type_name -> google.protobuf.Int32Value + 270, // 196: productv1.Author.email:type_name -> google.protobuf.StringValue + 18, // 197: productv1.Author.social_links:type_name -> productv1.ListOfString + 13, // 198: productv1.Author.teams_by_project:type_name -> productv1.ListOfListOfString + 13, // 199: productv1.Author.collaborations:type_name -> productv1.ListOfListOfString + 4, // 200: productv1.Author.written_posts:type_name -> productv1.ListOfBlogPost + 206, // 201: productv1.Author.favorite_categories:type_name -> productv1.Category + 20, // 202: productv1.Author.related_authors:type_name -> productv1.ListOfUser + 17, // 203: productv1.Author.product_reviews:type_name -> productv1.ListOfProduct + 14, // 204: productv1.Author.author_groups:type_name -> productv1.ListOfListOfUser + 11, // 205: productv1.Author.category_preferences:type_name -> productv1.ListOfListOfCategory + 14, // 206: productv1.Author.project_teams:type_name -> productv1.ListOfListOfUser + 270, // 207: productv1.AuthorFilter.name:type_name -> google.protobuf.StringValue + 269, // 208: productv1.AuthorFilter.has_teams:type_name -> google.protobuf.BoolValue + 268, // 209: productv1.AuthorFilter.skill_count:type_name -> google.protobuf.Int32Value + 270, // 210: productv1.TestContainer.description:type_name -> google.protobuf.StringValue + 241, // 211: productv1.ActionResult.action_success:type_name -> productv1.ActionSuccess + 242, // 212: productv1.ActionResult.action_error:type_name -> productv1.ActionError + 270, // 213: productv1.NullableFieldsInput.optional_string:type_name -> google.protobuf.StringValue + 268, // 214: productv1.NullableFieldsInput.optional_int:type_name -> google.protobuf.Int32Value + 271, // 215: productv1.NullableFieldsInput.optional_float:type_name -> google.protobuf.DoubleValue + 269, // 216: productv1.NullableFieldsInput.optional_boolean:type_name -> google.protobuf.BoolValue + 18, // 217: productv1.BlogPostInput.optional_tags:type_name -> productv1.ListOfString + 18, // 218: productv1.BlogPostInput.keywords:type_name -> productv1.ListOfString + 10, // 219: productv1.BlogPostInput.ratings:type_name -> productv1.ListOfFloat + 7, // 220: productv1.BlogPostInput.is_published:type_name -> productv1.ListOfBoolean + 13, // 221: productv1.BlogPostInput.tag_groups:type_name -> productv1.ListOfListOfString + 13, // 222: productv1.BlogPostInput.related_topics:type_name -> productv1.ListOfListOfString + 13, // 223: productv1.BlogPostInput.comment_threads:type_name -> productv1.ListOfListOfString + 13, // 224: productv1.BlogPostInput.suggestions:type_name -> productv1.ListOfListOfString + 9, // 225: productv1.BlogPostInput.related_categories:type_name -> productv1.ListOfCategoryInput + 21, // 226: productv1.BlogPostInput.contributors:type_name -> productv1.ListOfUserInput + 12, // 227: productv1.BlogPostInput.category_groups:type_name -> productv1.ListOfListOfCategoryInput + 270, // 228: productv1.AuthorInput.email:type_name -> google.protobuf.StringValue + 18, // 229: productv1.AuthorInput.social_links:type_name -> productv1.ListOfString + 13, // 230: productv1.AuthorInput.teams_by_project:type_name -> productv1.ListOfListOfString + 13, // 231: productv1.AuthorInput.collaborations:type_name -> productv1.ListOfListOfString + 244, // 232: productv1.AuthorInput.favorite_categories:type_name -> productv1.CategoryInput + 15, // 233: productv1.AuthorInput.author_groups:type_name -> productv1.ListOfListOfUserInput + 15, // 234: productv1.AuthorInput.project_teams:type_name -> productv1.ListOfListOfUserInput + 220, // 235: productv1.ProductDetails.review_summary:type_name -> productv1.ActionResult + 208, // 236: productv1.ProductDetails.recommended_pet:type_name -> productv1.Animal + 226, // 237: productv1.NestedTypeB.c:type_name -> productv1.NestedTypeC + 228, // 238: productv1.FilterType.pagination:type_name -> productv1.Pagination + 18, // 239: productv1.OrderLineInput.modifiers:type_name -> productv1.ListOfString + 18, // 240: productv1.OrderLine.modifiers:type_name -> productv1.ListOfString + 270, // 241: productv1.Subcategory.description:type_name -> google.protobuf.StringValue + 206, // 242: productv1.CategoryMetrics.related_category:type_name -> productv1.Category + 235, // 243: productv1.Cat.owner:type_name -> productv1.Owner + 238, // 244: productv1.Cat.breed:type_name -> productv1.CatBreed + 235, // 245: productv1.Dog.owner:type_name -> productv1.Owner + 239, // 246: productv1.Dog.breed:type_name -> productv1.DogBreed + 236, // 247: productv1.Owner.contact:type_name -> productv1.ContactInfo + 237, // 248: productv1.ContactInfo.address:type_name -> productv1.Address + 240, // 249: productv1.CatBreed.characteristics:type_name -> productv1.BreedCharacteristics + 240, // 250: productv1.DogBreed.characteristics:type_name -> productv1.BreedCharacteristics + 208, // 251: productv1.TestDetails.pet:type_name -> productv1.Animal + 220, // 252: productv1.TestDetails.status:type_name -> productv1.ActionResult + 0, // 253: productv1.CategoryInput.kind:type_name -> productv1.CategoryKind + 271, // 254: productv1.ProductCountFilter.min_price:type_name -> google.protobuf.DoubleValue + 271, // 255: productv1.ProductCountFilter.max_price:type_name -> google.protobuf.DoubleValue + 269, // 256: productv1.ProductCountFilter.in_stock:type_name -> google.protobuf.BoolValue + 270, // 257: productv1.ProductCountFilter.search_term:type_name -> google.protobuf.StringValue + 271, // 258: productv1.SubcategoryItemFilter.min_price:type_name -> google.protobuf.DoubleValue + 271, // 259: productv1.SubcategoryItemFilter.max_price:type_name -> google.protobuf.DoubleValue + 269, // 260: productv1.SubcategoryItemFilter.in_stock:type_name -> google.protobuf.BoolValue + 269, // 261: productv1.SubcategoryItemFilter.is_active:type_name -> google.protobuf.BoolValue + 270, // 262: productv1.SubcategoryItemFilter.search_term:type_name -> google.protobuf.StringValue + 1, // 263: productv1.ShippingEstimateInput.destination:type_name -> productv1.ShippingDestination + 269, // 264: productv1.ShippingEstimateInput.expedited:type_name -> google.protobuf.BoolValue + 216, // 265: productv1.ListOfAuthorFilter.List.items:type_name -> productv1.AuthorFilter + 223, // 266: productv1.ListOfAuthorInput.List.items:type_name -> productv1.AuthorInput + 213, // 267: productv1.ListOfBlogPost.List.items:type_name -> productv1.BlogPost + 214, // 268: productv1.ListOfBlogPostFilter.List.items:type_name -> productv1.BlogPostFilter + 222, // 269: productv1.ListOfBlogPostInput.List.items:type_name -> productv1.BlogPostInput + 206, // 270: productv1.ListOfCategory.List.items:type_name -> productv1.Category + 244, // 271: productv1.ListOfCategoryInput.List.items:type_name -> productv1.CategoryInput + 8, // 272: productv1.ListOfListOfCategory.List.items:type_name -> productv1.ListOfCategory + 9, // 273: productv1.ListOfListOfCategoryInput.List.items:type_name -> productv1.ListOfCategoryInput + 18, // 274: productv1.ListOfListOfString.List.items:type_name -> productv1.ListOfString + 20, // 275: productv1.ListOfListOfUser.List.items:type_name -> productv1.ListOfUser + 21, // 276: productv1.ListOfListOfUserInput.List.items:type_name -> productv1.ListOfUserInput + 230, // 277: productv1.ListOfOrderLine.List.items:type_name -> productv1.OrderLine + 194, // 278: productv1.ListOfProduct.List.items:type_name -> productv1.Product + 231, // 279: productv1.ListOfSubcategory.List.items:type_name -> productv1.Subcategory + 197, // 280: productv1.ListOfUser.List.items:type_name -> productv1.User + 218, // 281: productv1.ListOfUserInput.List.items:type_name -> productv1.UserInput + 23, // 282: productv1.ProductService.LookupProductById:input_type -> productv1.LookupProductByIdRequest + 26, // 283: productv1.ProductService.LookupStorageById:input_type -> productv1.LookupStorageByIdRequest + 29, // 284: productv1.ProductService.LookupWarehouseById:input_type -> productv1.LookupWarehouseByIdRequest + 111, // 285: productv1.ProductService.MutationBulkCreateAuthors:input_type -> productv1.MutationBulkCreateAuthorsRequest + 115, // 286: productv1.ProductService.MutationBulkCreateBlogPosts:input_type -> productv1.MutationBulkCreateBlogPostsRequest + 113, // 287: productv1.ProductService.MutationBulkUpdateAuthors:input_type -> productv1.MutationBulkUpdateAuthorsRequest + 117, // 288: productv1.ProductService.MutationBulkUpdateBlogPosts:input_type -> productv1.MutationBulkUpdateBlogPostsRequest + 107, // 289: productv1.ProductService.MutationCreateAuthor:input_type -> productv1.MutationCreateAuthorRequest + 103, // 290: productv1.ProductService.MutationCreateBlogPost:input_type -> productv1.MutationCreateBlogPostRequest + 99, // 291: productv1.ProductService.MutationCreateNullableFieldsType:input_type -> productv1.MutationCreateNullableFieldsTypeRequest + 95, // 292: productv1.ProductService.MutationCreateUser:input_type -> productv1.MutationCreateUserRequest + 97, // 293: productv1.ProductService.MutationPerformAction:input_type -> productv1.MutationPerformActionRequest + 109, // 294: productv1.ProductService.MutationUpdateAuthor:input_type -> productv1.MutationUpdateAuthorRequest + 105, // 295: productv1.ProductService.MutationUpdateBlogPost:input_type -> productv1.MutationUpdateBlogPostRequest + 101, // 296: productv1.ProductService.MutationUpdateNullableFieldsType:input_type -> productv1.MutationUpdateNullableFieldsTypeRequest + 85, // 297: productv1.ProductService.QueryAllAuthors:input_type -> productv1.QueryAllAuthorsRequest + 77, // 298: productv1.ProductService.QueryAllBlogPosts:input_type -> productv1.QueryAllBlogPostsRequest + 69, // 299: productv1.ProductService.QueryAllNullableFieldsTypes:input_type -> productv1.QueryAllNullableFieldsTypesRequest + 57, // 300: productv1.ProductService.QueryAllPets:input_type -> productv1.QueryAllPetsRequest + 79, // 301: productv1.ProductService.QueryAuthor:input_type -> productv1.QueryAuthorRequest + 81, // 302: productv1.ProductService.QueryAuthorById:input_type -> productv1.QueryAuthorByIdRequest + 83, // 303: productv1.ProductService.QueryAuthorsWithFilter:input_type -> productv1.QueryAuthorsWithFilterRequest + 71, // 304: productv1.ProductService.QueryBlogPost:input_type -> productv1.QueryBlogPostRequest + 73, // 305: productv1.ProductService.QueryBlogPostById:input_type -> productv1.QueryBlogPostByIdRequest + 75, // 306: productv1.ProductService.QueryBlogPostsWithFilter:input_type -> productv1.QueryBlogPostsWithFilterRequest + 87, // 307: productv1.ProductService.QueryBulkSearchAuthors:input_type -> productv1.QueryBulkSearchAuthorsRequest + 89, // 308: productv1.ProductService.QueryBulkSearchBlogPosts:input_type -> productv1.QueryBulkSearchBlogPostsRequest + 45, // 309: productv1.ProductService.QueryCalculateTotals:input_type -> productv1.QueryCalculateTotalsRequest + 47, // 310: productv1.ProductService.QueryCategories:input_type -> productv1.QueryCategoriesRequest + 49, // 311: productv1.ProductService.QueryCategoriesByKind:input_type -> productv1.QueryCategoriesByKindRequest + 51, // 312: productv1.ProductService.QueryCategoriesByKinds:input_type -> productv1.QueryCategoriesByKindsRequest + 43, // 313: productv1.ProductService.QueryComplexFilterType:input_type -> productv1.QueryComplexFilterTypeRequest + 53, // 314: productv1.ProductService.QueryFilterCategories:input_type -> productv1.QueryFilterCategoriesRequest + 35, // 315: productv1.ProductService.QueryNestedType:input_type -> productv1.QueryNestedTypeRequest + 63, // 316: productv1.ProductService.QueryNullableFieldsType:input_type -> productv1.QueryNullableFieldsTypeRequest + 65, // 317: productv1.ProductService.QueryNullableFieldsTypeById:input_type -> productv1.QueryNullableFieldsTypeByIdRequest + 67, // 318: productv1.ProductService.QueryNullableFieldsTypeWithFilter:input_type -> productv1.QueryNullableFieldsTypeWithFilterRequest + 55, // 319: productv1.ProductService.QueryRandomPet:input_type -> productv1.QueryRandomPetRequest + 61, // 320: productv1.ProductService.QueryRandomSearchResult:input_type -> productv1.QueryRandomSearchResultRequest + 37, // 321: productv1.ProductService.QueryRecursiveType:input_type -> productv1.QueryRecursiveTypeRequest + 59, // 322: productv1.ProductService.QuerySearch:input_type -> productv1.QuerySearchRequest + 91, // 323: productv1.ProductService.QueryTestContainer:input_type -> productv1.QueryTestContainerRequest + 93, // 324: productv1.ProductService.QueryTestContainers:input_type -> productv1.QueryTestContainersRequest + 39, // 325: productv1.ProductService.QueryTypeFilterWithArguments:input_type -> productv1.QueryTypeFilterWithArgumentsRequest + 41, // 326: productv1.ProductService.QueryTypeWithMultipleFilterFields:input_type -> productv1.QueryTypeWithMultipleFilterFieldsRequest + 33, // 327: productv1.ProductService.QueryUser:input_type -> productv1.QueryUserRequest + 31, // 328: productv1.ProductService.QueryUsers:input_type -> productv1.QueryUsersRequest + 156, // 329: productv1.ProductService.ResolveCategoryCategoryMetrics:input_type -> productv1.ResolveCategoryCategoryMetricsRequest + 166, // 330: productv1.ProductService.ResolveCategoryCategoryStatus:input_type -> productv1.ResolveCategoryCategoryStatusRequest + 171, // 331: productv1.ProductService.ResolveCategoryChildCategories:input_type -> productv1.ResolveCategoryChildCategoriesRequest + 161, // 332: productv1.ProductService.ResolveCategoryMascot:input_type -> productv1.ResolveCategoryMascotRequest + 186, // 333: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:input_type -> productv1.ResolveCategoryMetricsNormalizedScoreRequest + 176, // 334: productv1.ProductService.ResolveCategoryOptionalCategories:input_type -> productv1.ResolveCategoryOptionalCategoriesRequest + 151, // 335: productv1.ProductService.ResolveCategoryPopularityScore:input_type -> productv1.ResolveCategoryPopularityScoreRequest + 146, // 336: productv1.ProductService.ResolveCategoryProductCount:input_type -> productv1.ResolveCategoryProductCountRequest + 131, // 337: productv1.ProductService.ResolveProductMascotRecommendation:input_type -> productv1.ResolveProductMascotRecommendationRequest + 141, // 338: productv1.ProductService.ResolveProductProductDetails:input_type -> productv1.ResolveProductProductDetailsRequest + 126, // 339: productv1.ProductService.ResolveProductRecommendedCategory:input_type -> productv1.ResolveProductRecommendedCategoryRequest + 121, // 340: productv1.ProductService.ResolveProductShippingEstimate:input_type -> productv1.ResolveProductShippingEstimateRequest + 136, // 341: productv1.ProductService.ResolveProductStockStatus:input_type -> productv1.ResolveProductStockStatusRequest + 181, // 342: productv1.ProductService.ResolveSubcategoryItemCount:input_type -> productv1.ResolveSubcategoryItemCountRequest + 191, // 343: productv1.ProductService.ResolveTestContainerDetails:input_type -> productv1.ResolveTestContainerDetailsRequest + 24, // 344: productv1.ProductService.LookupProductById:output_type -> productv1.LookupProductByIdResponse + 27, // 345: productv1.ProductService.LookupStorageById:output_type -> productv1.LookupStorageByIdResponse + 30, // 346: productv1.ProductService.LookupWarehouseById:output_type -> productv1.LookupWarehouseByIdResponse + 112, // 347: productv1.ProductService.MutationBulkCreateAuthors:output_type -> productv1.MutationBulkCreateAuthorsResponse + 116, // 348: productv1.ProductService.MutationBulkCreateBlogPosts:output_type -> productv1.MutationBulkCreateBlogPostsResponse + 114, // 349: productv1.ProductService.MutationBulkUpdateAuthors:output_type -> productv1.MutationBulkUpdateAuthorsResponse + 118, // 350: productv1.ProductService.MutationBulkUpdateBlogPosts:output_type -> productv1.MutationBulkUpdateBlogPostsResponse + 108, // 351: productv1.ProductService.MutationCreateAuthor:output_type -> productv1.MutationCreateAuthorResponse + 104, // 352: productv1.ProductService.MutationCreateBlogPost:output_type -> productv1.MutationCreateBlogPostResponse + 100, // 353: productv1.ProductService.MutationCreateNullableFieldsType:output_type -> productv1.MutationCreateNullableFieldsTypeResponse + 96, // 354: productv1.ProductService.MutationCreateUser:output_type -> productv1.MutationCreateUserResponse + 98, // 355: productv1.ProductService.MutationPerformAction:output_type -> productv1.MutationPerformActionResponse + 110, // 356: productv1.ProductService.MutationUpdateAuthor:output_type -> productv1.MutationUpdateAuthorResponse + 106, // 357: productv1.ProductService.MutationUpdateBlogPost:output_type -> productv1.MutationUpdateBlogPostResponse + 102, // 358: productv1.ProductService.MutationUpdateNullableFieldsType:output_type -> productv1.MutationUpdateNullableFieldsTypeResponse + 86, // 359: productv1.ProductService.QueryAllAuthors:output_type -> productv1.QueryAllAuthorsResponse + 78, // 360: productv1.ProductService.QueryAllBlogPosts:output_type -> productv1.QueryAllBlogPostsResponse + 70, // 361: productv1.ProductService.QueryAllNullableFieldsTypes:output_type -> productv1.QueryAllNullableFieldsTypesResponse + 58, // 362: productv1.ProductService.QueryAllPets:output_type -> productv1.QueryAllPetsResponse + 80, // 363: productv1.ProductService.QueryAuthor:output_type -> productv1.QueryAuthorResponse + 82, // 364: productv1.ProductService.QueryAuthorById:output_type -> productv1.QueryAuthorByIdResponse + 84, // 365: productv1.ProductService.QueryAuthorsWithFilter:output_type -> productv1.QueryAuthorsWithFilterResponse + 72, // 366: productv1.ProductService.QueryBlogPost:output_type -> productv1.QueryBlogPostResponse + 74, // 367: productv1.ProductService.QueryBlogPostById:output_type -> productv1.QueryBlogPostByIdResponse + 76, // 368: productv1.ProductService.QueryBlogPostsWithFilter:output_type -> productv1.QueryBlogPostsWithFilterResponse + 88, // 369: productv1.ProductService.QueryBulkSearchAuthors:output_type -> productv1.QueryBulkSearchAuthorsResponse + 90, // 370: productv1.ProductService.QueryBulkSearchBlogPosts:output_type -> productv1.QueryBulkSearchBlogPostsResponse + 46, // 371: productv1.ProductService.QueryCalculateTotals:output_type -> productv1.QueryCalculateTotalsResponse + 48, // 372: productv1.ProductService.QueryCategories:output_type -> productv1.QueryCategoriesResponse + 50, // 373: productv1.ProductService.QueryCategoriesByKind:output_type -> productv1.QueryCategoriesByKindResponse + 52, // 374: productv1.ProductService.QueryCategoriesByKinds:output_type -> productv1.QueryCategoriesByKindsResponse + 44, // 375: productv1.ProductService.QueryComplexFilterType:output_type -> productv1.QueryComplexFilterTypeResponse + 54, // 376: productv1.ProductService.QueryFilterCategories:output_type -> productv1.QueryFilterCategoriesResponse + 36, // 377: productv1.ProductService.QueryNestedType:output_type -> productv1.QueryNestedTypeResponse + 64, // 378: productv1.ProductService.QueryNullableFieldsType:output_type -> productv1.QueryNullableFieldsTypeResponse + 66, // 379: productv1.ProductService.QueryNullableFieldsTypeById:output_type -> productv1.QueryNullableFieldsTypeByIdResponse + 68, // 380: productv1.ProductService.QueryNullableFieldsTypeWithFilter:output_type -> productv1.QueryNullableFieldsTypeWithFilterResponse + 56, // 381: productv1.ProductService.QueryRandomPet:output_type -> productv1.QueryRandomPetResponse + 62, // 382: productv1.ProductService.QueryRandomSearchResult:output_type -> productv1.QueryRandomSearchResultResponse + 38, // 383: productv1.ProductService.QueryRecursiveType:output_type -> productv1.QueryRecursiveTypeResponse + 60, // 384: productv1.ProductService.QuerySearch:output_type -> productv1.QuerySearchResponse + 92, // 385: productv1.ProductService.QueryTestContainer:output_type -> productv1.QueryTestContainerResponse + 94, // 386: productv1.ProductService.QueryTestContainers:output_type -> productv1.QueryTestContainersResponse + 40, // 387: productv1.ProductService.QueryTypeFilterWithArguments:output_type -> productv1.QueryTypeFilterWithArgumentsResponse + 42, // 388: productv1.ProductService.QueryTypeWithMultipleFilterFields:output_type -> productv1.QueryTypeWithMultipleFilterFieldsResponse + 34, // 389: productv1.ProductService.QueryUser:output_type -> productv1.QueryUserResponse + 32, // 390: productv1.ProductService.QueryUsers:output_type -> productv1.QueryUsersResponse + 158, // 391: productv1.ProductService.ResolveCategoryCategoryMetrics:output_type -> productv1.ResolveCategoryCategoryMetricsResponse + 168, // 392: productv1.ProductService.ResolveCategoryCategoryStatus:output_type -> productv1.ResolveCategoryCategoryStatusResponse + 173, // 393: productv1.ProductService.ResolveCategoryChildCategories:output_type -> productv1.ResolveCategoryChildCategoriesResponse + 163, // 394: productv1.ProductService.ResolveCategoryMascot:output_type -> productv1.ResolveCategoryMascotResponse + 188, // 395: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:output_type -> productv1.ResolveCategoryMetricsNormalizedScoreResponse + 178, // 396: productv1.ProductService.ResolveCategoryOptionalCategories:output_type -> productv1.ResolveCategoryOptionalCategoriesResponse + 153, // 397: productv1.ProductService.ResolveCategoryPopularityScore:output_type -> productv1.ResolveCategoryPopularityScoreResponse + 148, // 398: productv1.ProductService.ResolveCategoryProductCount:output_type -> productv1.ResolveCategoryProductCountResponse + 133, // 399: productv1.ProductService.ResolveProductMascotRecommendation:output_type -> productv1.ResolveProductMascotRecommendationResponse + 143, // 400: productv1.ProductService.ResolveProductProductDetails:output_type -> productv1.ResolveProductProductDetailsResponse + 128, // 401: productv1.ProductService.ResolveProductRecommendedCategory:output_type -> productv1.ResolveProductRecommendedCategoryResponse + 123, // 402: productv1.ProductService.ResolveProductShippingEstimate:output_type -> productv1.ResolveProductShippingEstimateResponse + 138, // 403: productv1.ProductService.ResolveProductStockStatus:output_type -> productv1.ResolveProductStockStatusResponse + 183, // 404: productv1.ProductService.ResolveSubcategoryItemCount:output_type -> productv1.ResolveSubcategoryItemCountResponse + 193, // 405: productv1.ProductService.ResolveTestContainerDetails:output_type -> productv1.ResolveTestContainerDetailsResponse + 344, // [344:406] is the sub-list for method output_type + 282, // [282:344] is the sub-list for method input_type + 282, // [282:282] is the sub-list for extension type_name + 282, // [282:282] is the sub-list for extension extendee + 0, // [0:282] is the sub-list for field type_name } func init() { file_product_proto_init() } @@ -14718,16 +15245,16 @@ func file_product_proto_init() { if File_product_proto != nil { return } - file_product_proto_msgTypes[196].OneofWrappers = []any{ + file_product_proto_msgTypes[206].OneofWrappers = []any{ (*Animal_Cat)(nil), (*Animal_Dog)(nil), } - file_product_proto_msgTypes[198].OneofWrappers = []any{ + file_product_proto_msgTypes[208].OneofWrappers = []any{ (*SearchResult_Product)(nil), (*SearchResult_User)(nil), (*SearchResult_Category)(nil), } - file_product_proto_msgTypes[208].OneofWrappers = []any{ + file_product_proto_msgTypes[218].OneofWrappers = []any{ (*ActionResult_ActionSuccess)(nil), (*ActionResult_ActionError)(nil), } @@ -14737,7 +15264,7 @@ func file_product_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_product_proto_rawDesc), len(file_product_proto_rawDesc)), NumEnums: 2, - NumMessages: 256, + NumMessages: 266, NumExtensions: 0, NumServices: 1, }, diff --git a/v2/pkg/grpctest/productv1/product_grpc.pb.go b/v2/pkg/grpctest/productv1/product_grpc.pb.go index 3439376c1f..3cd40a6eb3 100644 --- a/v2/pkg/grpctest/productv1/product_grpc.pb.go +++ b/v2/pkg/grpctest/productv1/product_grpc.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: -// - protoc-gen-go-grpc v1.5.1 +// - protoc-gen-go-grpc v1.6.0 // - protoc v6.32.0 // source: product.proto @@ -68,8 +68,10 @@ const ( ProductService_QueryUsers_FullMethodName = "/productv1.ProductService/QueryUsers" ProductService_ResolveCategoryCategoryMetrics_FullMethodName = "/productv1.ProductService/ResolveCategoryCategoryMetrics" ProductService_ResolveCategoryCategoryStatus_FullMethodName = "/productv1.ProductService/ResolveCategoryCategoryStatus" + ProductService_ResolveCategoryChildCategories_FullMethodName = "/productv1.ProductService/ResolveCategoryChildCategories" ProductService_ResolveCategoryMascot_FullMethodName = "/productv1.ProductService/ResolveCategoryMascot" ProductService_ResolveCategoryMetricsNormalizedScore_FullMethodName = "/productv1.ProductService/ResolveCategoryMetricsNormalizedScore" + ProductService_ResolveCategoryOptionalCategories_FullMethodName = "/productv1.ProductService/ResolveCategoryOptionalCategories" ProductService_ResolveCategoryPopularityScore_FullMethodName = "/productv1.ProductService/ResolveCategoryPopularityScore" ProductService_ResolveCategoryProductCount_FullMethodName = "/productv1.ProductService/ResolveCategoryProductCount" ProductService_ResolveProductMascotRecommendation_FullMethodName = "/productv1.ProductService/ResolveProductMascotRecommendation" @@ -139,8 +141,10 @@ type ProductServiceClient interface { QueryUsers(ctx context.Context, in *QueryUsersRequest, opts ...grpc.CallOption) (*QueryUsersResponse, error) ResolveCategoryCategoryMetrics(ctx context.Context, in *ResolveCategoryCategoryMetricsRequest, opts ...grpc.CallOption) (*ResolveCategoryCategoryMetricsResponse, error) ResolveCategoryCategoryStatus(ctx context.Context, in *ResolveCategoryCategoryStatusRequest, opts ...grpc.CallOption) (*ResolveCategoryCategoryStatusResponse, error) + ResolveCategoryChildCategories(ctx context.Context, in *ResolveCategoryChildCategoriesRequest, opts ...grpc.CallOption) (*ResolveCategoryChildCategoriesResponse, error) ResolveCategoryMascot(ctx context.Context, in *ResolveCategoryMascotRequest, opts ...grpc.CallOption) (*ResolveCategoryMascotResponse, error) ResolveCategoryMetricsNormalizedScore(ctx context.Context, in *ResolveCategoryMetricsNormalizedScoreRequest, opts ...grpc.CallOption) (*ResolveCategoryMetricsNormalizedScoreResponse, error) + ResolveCategoryOptionalCategories(ctx context.Context, in *ResolveCategoryOptionalCategoriesRequest, opts ...grpc.CallOption) (*ResolveCategoryOptionalCategoriesResponse, error) ResolveCategoryPopularityScore(ctx context.Context, in *ResolveCategoryPopularityScoreRequest, opts ...grpc.CallOption) (*ResolveCategoryPopularityScoreResponse, error) ResolveCategoryProductCount(ctx context.Context, in *ResolveCategoryProductCountRequest, opts ...grpc.CallOption) (*ResolveCategoryProductCountResponse, error) ResolveProductMascotRecommendation(ctx context.Context, in *ResolveProductMascotRecommendationRequest, opts ...grpc.CallOption) (*ResolveProductMascotRecommendationResponse, error) @@ -650,6 +654,16 @@ func (c *productServiceClient) ResolveCategoryCategoryStatus(ctx context.Context return out, nil } +func (c *productServiceClient) ResolveCategoryChildCategories(ctx context.Context, in *ResolveCategoryChildCategoriesRequest, opts ...grpc.CallOption) (*ResolveCategoryChildCategoriesResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ResolveCategoryChildCategoriesResponse) + err := c.cc.Invoke(ctx, ProductService_ResolveCategoryChildCategories_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) ResolveCategoryMascot(ctx context.Context, in *ResolveCategoryMascotRequest, opts ...grpc.CallOption) (*ResolveCategoryMascotResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ResolveCategoryMascotResponse) @@ -670,6 +684,16 @@ func (c *productServiceClient) ResolveCategoryMetricsNormalizedScore(ctx context return out, nil } +func (c *productServiceClient) ResolveCategoryOptionalCategories(ctx context.Context, in *ResolveCategoryOptionalCategoriesRequest, opts ...grpc.CallOption) (*ResolveCategoryOptionalCategoriesResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ResolveCategoryOptionalCategoriesResponse) + err := c.cc.Invoke(ctx, ProductService_ResolveCategoryOptionalCategories_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) ResolveCategoryPopularityScore(ctx context.Context, in *ResolveCategoryPopularityScoreRequest, opts ...grpc.CallOption) (*ResolveCategoryPopularityScoreResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ResolveCategoryPopularityScoreResponse) @@ -818,8 +842,10 @@ type ProductServiceServer interface { QueryUsers(context.Context, *QueryUsersRequest) (*QueryUsersResponse, error) ResolveCategoryCategoryMetrics(context.Context, *ResolveCategoryCategoryMetricsRequest) (*ResolveCategoryCategoryMetricsResponse, error) ResolveCategoryCategoryStatus(context.Context, *ResolveCategoryCategoryStatusRequest) (*ResolveCategoryCategoryStatusResponse, error) + ResolveCategoryChildCategories(context.Context, *ResolveCategoryChildCategoriesRequest) (*ResolveCategoryChildCategoriesResponse, error) ResolveCategoryMascot(context.Context, *ResolveCategoryMascotRequest) (*ResolveCategoryMascotResponse, error) ResolveCategoryMetricsNormalizedScore(context.Context, *ResolveCategoryMetricsNormalizedScoreRequest) (*ResolveCategoryMetricsNormalizedScoreResponse, error) + ResolveCategoryOptionalCategories(context.Context, *ResolveCategoryOptionalCategoriesRequest) (*ResolveCategoryOptionalCategoriesResponse, error) ResolveCategoryPopularityScore(context.Context, *ResolveCategoryPopularityScoreRequest) (*ResolveCategoryPopularityScoreResponse, error) ResolveCategoryProductCount(context.Context, *ResolveCategoryProductCountRequest) (*ResolveCategoryProductCountResponse, error) ResolveProductMascotRecommendation(context.Context, *ResolveProductMascotRecommendationRequest) (*ResolveProductMascotRecommendationResponse, error) @@ -840,184 +866,190 @@ type ProductServiceServer interface { type UnimplementedProductServiceServer struct{} func (UnimplementedProductServiceServer) LookupProductById(context.Context, *LookupProductByIdRequest) (*LookupProductByIdResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method LookupProductById not implemented") + return nil, status.Error(codes.Unimplemented, "method LookupProductById not implemented") } func (UnimplementedProductServiceServer) LookupStorageById(context.Context, *LookupStorageByIdRequest) (*LookupStorageByIdResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method LookupStorageById not implemented") + return nil, status.Error(codes.Unimplemented, "method LookupStorageById not implemented") } func (UnimplementedProductServiceServer) LookupWarehouseById(context.Context, *LookupWarehouseByIdRequest) (*LookupWarehouseByIdResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method LookupWarehouseById not implemented") + return nil, status.Error(codes.Unimplemented, "method LookupWarehouseById not implemented") } func (UnimplementedProductServiceServer) MutationBulkCreateAuthors(context.Context, *MutationBulkCreateAuthorsRequest) (*MutationBulkCreateAuthorsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MutationBulkCreateAuthors not implemented") + return nil, status.Error(codes.Unimplemented, "method MutationBulkCreateAuthors not implemented") } func (UnimplementedProductServiceServer) MutationBulkCreateBlogPosts(context.Context, *MutationBulkCreateBlogPostsRequest) (*MutationBulkCreateBlogPostsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MutationBulkCreateBlogPosts not implemented") + return nil, status.Error(codes.Unimplemented, "method MutationBulkCreateBlogPosts not implemented") } func (UnimplementedProductServiceServer) MutationBulkUpdateAuthors(context.Context, *MutationBulkUpdateAuthorsRequest) (*MutationBulkUpdateAuthorsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MutationBulkUpdateAuthors not implemented") + return nil, status.Error(codes.Unimplemented, "method MutationBulkUpdateAuthors not implemented") } func (UnimplementedProductServiceServer) MutationBulkUpdateBlogPosts(context.Context, *MutationBulkUpdateBlogPostsRequest) (*MutationBulkUpdateBlogPostsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MutationBulkUpdateBlogPosts not implemented") + return nil, status.Error(codes.Unimplemented, "method MutationBulkUpdateBlogPosts not implemented") } func (UnimplementedProductServiceServer) MutationCreateAuthor(context.Context, *MutationCreateAuthorRequest) (*MutationCreateAuthorResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MutationCreateAuthor not implemented") + return nil, status.Error(codes.Unimplemented, "method MutationCreateAuthor not implemented") } func (UnimplementedProductServiceServer) MutationCreateBlogPost(context.Context, *MutationCreateBlogPostRequest) (*MutationCreateBlogPostResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MutationCreateBlogPost not implemented") + return nil, status.Error(codes.Unimplemented, "method MutationCreateBlogPost not implemented") } func (UnimplementedProductServiceServer) MutationCreateNullableFieldsType(context.Context, *MutationCreateNullableFieldsTypeRequest) (*MutationCreateNullableFieldsTypeResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MutationCreateNullableFieldsType not implemented") + return nil, status.Error(codes.Unimplemented, "method MutationCreateNullableFieldsType not implemented") } func (UnimplementedProductServiceServer) MutationCreateUser(context.Context, *MutationCreateUserRequest) (*MutationCreateUserResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MutationCreateUser not implemented") + return nil, status.Error(codes.Unimplemented, "method MutationCreateUser not implemented") } func (UnimplementedProductServiceServer) MutationPerformAction(context.Context, *MutationPerformActionRequest) (*MutationPerformActionResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MutationPerformAction not implemented") + return nil, status.Error(codes.Unimplemented, "method MutationPerformAction not implemented") } func (UnimplementedProductServiceServer) MutationUpdateAuthor(context.Context, *MutationUpdateAuthorRequest) (*MutationUpdateAuthorResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MutationUpdateAuthor not implemented") + return nil, status.Error(codes.Unimplemented, "method MutationUpdateAuthor not implemented") } func (UnimplementedProductServiceServer) MutationUpdateBlogPost(context.Context, *MutationUpdateBlogPostRequest) (*MutationUpdateBlogPostResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MutationUpdateBlogPost not implemented") + return nil, status.Error(codes.Unimplemented, "method MutationUpdateBlogPost not implemented") } func (UnimplementedProductServiceServer) MutationUpdateNullableFieldsType(context.Context, *MutationUpdateNullableFieldsTypeRequest) (*MutationUpdateNullableFieldsTypeResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MutationUpdateNullableFieldsType not implemented") + return nil, status.Error(codes.Unimplemented, "method MutationUpdateNullableFieldsType not implemented") } func (UnimplementedProductServiceServer) QueryAllAuthors(context.Context, *QueryAllAuthorsRequest) (*QueryAllAuthorsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryAllAuthors not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryAllAuthors not implemented") } func (UnimplementedProductServiceServer) QueryAllBlogPosts(context.Context, *QueryAllBlogPostsRequest) (*QueryAllBlogPostsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryAllBlogPosts not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryAllBlogPosts not implemented") } func (UnimplementedProductServiceServer) QueryAllNullableFieldsTypes(context.Context, *QueryAllNullableFieldsTypesRequest) (*QueryAllNullableFieldsTypesResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryAllNullableFieldsTypes not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryAllNullableFieldsTypes not implemented") } func (UnimplementedProductServiceServer) QueryAllPets(context.Context, *QueryAllPetsRequest) (*QueryAllPetsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryAllPets not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryAllPets not implemented") } func (UnimplementedProductServiceServer) QueryAuthor(context.Context, *QueryAuthorRequest) (*QueryAuthorResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryAuthor not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryAuthor not implemented") } func (UnimplementedProductServiceServer) QueryAuthorById(context.Context, *QueryAuthorByIdRequest) (*QueryAuthorByIdResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryAuthorById not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryAuthorById not implemented") } func (UnimplementedProductServiceServer) QueryAuthorsWithFilter(context.Context, *QueryAuthorsWithFilterRequest) (*QueryAuthorsWithFilterResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryAuthorsWithFilter not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryAuthorsWithFilter not implemented") } func (UnimplementedProductServiceServer) QueryBlogPost(context.Context, *QueryBlogPostRequest) (*QueryBlogPostResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryBlogPost not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryBlogPost not implemented") } func (UnimplementedProductServiceServer) QueryBlogPostById(context.Context, *QueryBlogPostByIdRequest) (*QueryBlogPostByIdResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryBlogPostById not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryBlogPostById not implemented") } func (UnimplementedProductServiceServer) QueryBlogPostsWithFilter(context.Context, *QueryBlogPostsWithFilterRequest) (*QueryBlogPostsWithFilterResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryBlogPostsWithFilter not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryBlogPostsWithFilter not implemented") } func (UnimplementedProductServiceServer) QueryBulkSearchAuthors(context.Context, *QueryBulkSearchAuthorsRequest) (*QueryBulkSearchAuthorsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryBulkSearchAuthors not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryBulkSearchAuthors not implemented") } func (UnimplementedProductServiceServer) QueryBulkSearchBlogPosts(context.Context, *QueryBulkSearchBlogPostsRequest) (*QueryBulkSearchBlogPostsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryBulkSearchBlogPosts not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryBulkSearchBlogPosts not implemented") } func (UnimplementedProductServiceServer) QueryCalculateTotals(context.Context, *QueryCalculateTotalsRequest) (*QueryCalculateTotalsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryCalculateTotals not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryCalculateTotals not implemented") } func (UnimplementedProductServiceServer) QueryCategories(context.Context, *QueryCategoriesRequest) (*QueryCategoriesResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryCategories not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryCategories not implemented") } func (UnimplementedProductServiceServer) QueryCategoriesByKind(context.Context, *QueryCategoriesByKindRequest) (*QueryCategoriesByKindResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryCategoriesByKind not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryCategoriesByKind not implemented") } func (UnimplementedProductServiceServer) QueryCategoriesByKinds(context.Context, *QueryCategoriesByKindsRequest) (*QueryCategoriesByKindsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryCategoriesByKinds not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryCategoriesByKinds not implemented") } func (UnimplementedProductServiceServer) QueryComplexFilterType(context.Context, *QueryComplexFilterTypeRequest) (*QueryComplexFilterTypeResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryComplexFilterType not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryComplexFilterType not implemented") } func (UnimplementedProductServiceServer) QueryFilterCategories(context.Context, *QueryFilterCategoriesRequest) (*QueryFilterCategoriesResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryFilterCategories not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryFilterCategories not implemented") } func (UnimplementedProductServiceServer) QueryNestedType(context.Context, *QueryNestedTypeRequest) (*QueryNestedTypeResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryNestedType not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryNestedType not implemented") } func (UnimplementedProductServiceServer) QueryNullableFieldsType(context.Context, *QueryNullableFieldsTypeRequest) (*QueryNullableFieldsTypeResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryNullableFieldsType not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryNullableFieldsType not implemented") } func (UnimplementedProductServiceServer) QueryNullableFieldsTypeById(context.Context, *QueryNullableFieldsTypeByIdRequest) (*QueryNullableFieldsTypeByIdResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryNullableFieldsTypeById not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryNullableFieldsTypeById not implemented") } func (UnimplementedProductServiceServer) QueryNullableFieldsTypeWithFilter(context.Context, *QueryNullableFieldsTypeWithFilterRequest) (*QueryNullableFieldsTypeWithFilterResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryNullableFieldsTypeWithFilter not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryNullableFieldsTypeWithFilter not implemented") } func (UnimplementedProductServiceServer) QueryRandomPet(context.Context, *QueryRandomPetRequest) (*QueryRandomPetResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryRandomPet not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryRandomPet not implemented") } func (UnimplementedProductServiceServer) QueryRandomSearchResult(context.Context, *QueryRandomSearchResultRequest) (*QueryRandomSearchResultResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryRandomSearchResult not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryRandomSearchResult not implemented") } func (UnimplementedProductServiceServer) QueryRecursiveType(context.Context, *QueryRecursiveTypeRequest) (*QueryRecursiveTypeResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryRecursiveType not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryRecursiveType not implemented") } func (UnimplementedProductServiceServer) QuerySearch(context.Context, *QuerySearchRequest) (*QuerySearchResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QuerySearch not implemented") + return nil, status.Error(codes.Unimplemented, "method QuerySearch not implemented") } func (UnimplementedProductServiceServer) QueryTestContainer(context.Context, *QueryTestContainerRequest) (*QueryTestContainerResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryTestContainer not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryTestContainer not implemented") } func (UnimplementedProductServiceServer) QueryTestContainers(context.Context, *QueryTestContainersRequest) (*QueryTestContainersResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryTestContainers not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryTestContainers not implemented") } func (UnimplementedProductServiceServer) QueryTypeFilterWithArguments(context.Context, *QueryTypeFilterWithArgumentsRequest) (*QueryTypeFilterWithArgumentsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryTypeFilterWithArguments not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryTypeFilterWithArguments not implemented") } func (UnimplementedProductServiceServer) QueryTypeWithMultipleFilterFields(context.Context, *QueryTypeWithMultipleFilterFieldsRequest) (*QueryTypeWithMultipleFilterFieldsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryTypeWithMultipleFilterFields not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryTypeWithMultipleFilterFields not implemented") } func (UnimplementedProductServiceServer) QueryUser(context.Context, *QueryUserRequest) (*QueryUserResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryUser not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryUser not implemented") } func (UnimplementedProductServiceServer) QueryUsers(context.Context, *QueryUsersRequest) (*QueryUsersResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryUsers not implemented") + return nil, status.Error(codes.Unimplemented, "method QueryUsers not implemented") } func (UnimplementedProductServiceServer) ResolveCategoryCategoryMetrics(context.Context, *ResolveCategoryCategoryMetricsRequest) (*ResolveCategoryCategoryMetricsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ResolveCategoryCategoryMetrics not implemented") + return nil, status.Error(codes.Unimplemented, "method ResolveCategoryCategoryMetrics not implemented") } func (UnimplementedProductServiceServer) ResolveCategoryCategoryStatus(context.Context, *ResolveCategoryCategoryStatusRequest) (*ResolveCategoryCategoryStatusResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ResolveCategoryCategoryStatus not implemented") + return nil, status.Error(codes.Unimplemented, "method ResolveCategoryCategoryStatus not implemented") +} +func (UnimplementedProductServiceServer) ResolveCategoryChildCategories(context.Context, *ResolveCategoryChildCategoriesRequest) (*ResolveCategoryChildCategoriesResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ResolveCategoryChildCategories not implemented") } func (UnimplementedProductServiceServer) ResolveCategoryMascot(context.Context, *ResolveCategoryMascotRequest) (*ResolveCategoryMascotResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ResolveCategoryMascot not implemented") + return nil, status.Error(codes.Unimplemented, "method ResolveCategoryMascot not implemented") } func (UnimplementedProductServiceServer) ResolveCategoryMetricsNormalizedScore(context.Context, *ResolveCategoryMetricsNormalizedScoreRequest) (*ResolveCategoryMetricsNormalizedScoreResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ResolveCategoryMetricsNormalizedScore not implemented") + return nil, status.Error(codes.Unimplemented, "method ResolveCategoryMetricsNormalizedScore not implemented") +} +func (UnimplementedProductServiceServer) ResolveCategoryOptionalCategories(context.Context, *ResolveCategoryOptionalCategoriesRequest) (*ResolveCategoryOptionalCategoriesResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ResolveCategoryOptionalCategories not implemented") } func (UnimplementedProductServiceServer) ResolveCategoryPopularityScore(context.Context, *ResolveCategoryPopularityScoreRequest) (*ResolveCategoryPopularityScoreResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ResolveCategoryPopularityScore not implemented") + return nil, status.Error(codes.Unimplemented, "method ResolveCategoryPopularityScore not implemented") } func (UnimplementedProductServiceServer) ResolveCategoryProductCount(context.Context, *ResolveCategoryProductCountRequest) (*ResolveCategoryProductCountResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ResolveCategoryProductCount not implemented") + return nil, status.Error(codes.Unimplemented, "method ResolveCategoryProductCount not implemented") } func (UnimplementedProductServiceServer) ResolveProductMascotRecommendation(context.Context, *ResolveProductMascotRecommendationRequest) (*ResolveProductMascotRecommendationResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ResolveProductMascotRecommendation not implemented") + return nil, status.Error(codes.Unimplemented, "method ResolveProductMascotRecommendation not implemented") } func (UnimplementedProductServiceServer) ResolveProductProductDetails(context.Context, *ResolveProductProductDetailsRequest) (*ResolveProductProductDetailsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ResolveProductProductDetails not implemented") + return nil, status.Error(codes.Unimplemented, "method ResolveProductProductDetails not implemented") } func (UnimplementedProductServiceServer) ResolveProductRecommendedCategory(context.Context, *ResolveProductRecommendedCategoryRequest) (*ResolveProductRecommendedCategoryResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ResolveProductRecommendedCategory not implemented") + return nil, status.Error(codes.Unimplemented, "method ResolveProductRecommendedCategory not implemented") } func (UnimplementedProductServiceServer) ResolveProductShippingEstimate(context.Context, *ResolveProductShippingEstimateRequest) (*ResolveProductShippingEstimateResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ResolveProductShippingEstimate not implemented") + return nil, status.Error(codes.Unimplemented, "method ResolveProductShippingEstimate not implemented") } func (UnimplementedProductServiceServer) ResolveProductStockStatus(context.Context, *ResolveProductStockStatusRequest) (*ResolveProductStockStatusResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ResolveProductStockStatus not implemented") + return nil, status.Error(codes.Unimplemented, "method ResolveProductStockStatus not implemented") } func (UnimplementedProductServiceServer) ResolveSubcategoryItemCount(context.Context, *ResolveSubcategoryItemCountRequest) (*ResolveSubcategoryItemCountResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ResolveSubcategoryItemCount not implemented") + return nil, status.Error(codes.Unimplemented, "method ResolveSubcategoryItemCount not implemented") } func (UnimplementedProductServiceServer) ResolveTestContainerDetails(context.Context, *ResolveTestContainerDetailsRequest) (*ResolveTestContainerDetailsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ResolveTestContainerDetails not implemented") + return nil, status.Error(codes.Unimplemented, "method ResolveTestContainerDetails not implemented") } func (UnimplementedProductServiceServer) mustEmbedUnimplementedProductServiceServer() {} func (UnimplementedProductServiceServer) testEmbeddedByValue() {} @@ -1030,7 +1062,7 @@ type UnsafeProductServiceServer interface { } func RegisterProductServiceServer(s grpc.ServiceRegistrar, srv ProductServiceServer) { - // If the following call pancis, it indicates UnimplementedProductServiceServer was + // If the following call panics, it indicates UnimplementedProductServiceServer was // embedded by pointer and is nil. This will cause panics if an // unimplemented method is ever invoked, so we test this at initialization // time to prevent it from happening at runtime later due to I/O. @@ -1922,6 +1954,24 @@ func _ProductService_ResolveCategoryCategoryStatus_Handler(srv interface{}, ctx return interceptor(ctx, in, info, handler) } +func _ProductService_ResolveCategoryChildCategories_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResolveCategoryChildCategoriesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).ResolveCategoryChildCategories(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_ResolveCategoryChildCategories_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).ResolveCategoryChildCategories(ctx, req.(*ResolveCategoryChildCategoriesRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_ResolveCategoryMascot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ResolveCategoryMascotRequest) if err := dec(in); err != nil { @@ -1958,6 +2008,24 @@ func _ProductService_ResolveCategoryMetricsNormalizedScore_Handler(srv interface return interceptor(ctx, in, info, handler) } +func _ProductService_ResolveCategoryOptionalCategories_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResolveCategoryOptionalCategoriesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).ResolveCategoryOptionalCategories(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_ResolveCategoryOptionalCategories_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).ResolveCategoryOptionalCategories(ctx, req.(*ResolveCategoryOptionalCategoriesRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_ResolveCategoryPopularityScore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ResolveCategoryPopularityScoreRequest) if err := dec(in); err != nil { @@ -2323,6 +2391,10 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "ResolveCategoryCategoryStatus", Handler: _ProductService_ResolveCategoryCategoryStatus_Handler, }, + { + MethodName: "ResolveCategoryChildCategories", + Handler: _ProductService_ResolveCategoryChildCategories_Handler, + }, { MethodName: "ResolveCategoryMascot", Handler: _ProductService_ResolveCategoryMascot_Handler, @@ -2331,6 +2403,10 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "ResolveCategoryMetricsNormalizedScore", Handler: _ProductService_ResolveCategoryMetricsNormalizedScore_Handler, }, + { + MethodName: "ResolveCategoryOptionalCategories", + Handler: _ProductService_ResolveCategoryOptionalCategories_Handler, + }, { MethodName: "ResolveCategoryPopularityScore", Handler: _ProductService_ResolveCategoryPopularityScore_Handler, diff --git a/v2/pkg/grpctest/testdata/products.graphqls b/v2/pkg/grpctest/testdata/products.graphqls index 47662bfeda..531d431168 100644 --- a/v2/pkg/grpctest/testdata/products.graphqls +++ b/v2/pkg/grpctest/testdata/products.graphqls @@ -130,6 +130,8 @@ type Category { categoryMetrics(metricType: String!): CategoryMetrics @connect__fieldResolver(context: "id name") mascot(includeVolume: Boolean!): Animal @connect__fieldResolver(context: "id kind") categoryStatus(checkHealth: Boolean!): ActionResult! @connect__fieldResolver(context: "id name") + childCategories(include: Boolean): [Category!]! @connect__fieldResolver(context: "id name") + optionalCategories(include: Boolean): [Category!] @connect__fieldResolver(context: "id name") } type Subcategory {