diff --git a/v2/pkg/ast/ast_selection.go b/v2/pkg/ast/ast_selection.go index 0c7b643c8..2ef6a482b 100644 --- a/v2/pkg/ast/ast_selection.go +++ b/v2/pkg/ast/ast_selection.go @@ -212,6 +212,18 @@ func (d *Document) SelectionSetHasFieldSelectionWithExactName(set int, name []by return false, InvalidRef } +// SelectionSetFieldRefs returns a list of field refs in the selection set. +// It traverses through the field selections of the selection set and returns the actual field refs. +func (d *Document) SelectionSetFieldRefs(set int) (refs []int) { + for _, selectionRef := range d.SelectionSets[set].SelectionRefs { + if d.Selections[selectionRef].Kind == SelectionKindField { + refs = append(refs, d.Selections[selectionRef].Ref) + } + } + return +} + +// SelectionSetFieldSelections returns a list of field selection refs in the selection set. func (d *Document) SelectionSetFieldSelections(set int) (refs []int) { for _, selectionRef := range d.SelectionSets[set].SelectionRefs { if d.Selections[selectionRef].Kind == SelectionKindField { diff --git a/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go b/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go index e7b486280..52cc4d519 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan.go @@ -1,6 +1,7 @@ package grpcdatasource import ( + "errors" "fmt" "slices" "strings" @@ -8,6 +9,7 @@ import ( "github.com/wundergraph/graphql-go-tools/v2/pkg/ast" "github.com/wundergraph/graphql-go-tools/v2/pkg/astvisitor" "github.com/wundergraph/graphql-go-tools/v2/pkg/engine/plan" + "github.com/wundergraph/graphql-go-tools/v2/pkg/internal/unsafebytes" ) const ( @@ -60,7 +62,7 @@ type RPCExecutionPlan struct { } // CallKind is the type of call operation to perform. -type CallKind int +type CallKind uint8 const ( // CallKindStandard is a basic fetch operation. @@ -147,12 +149,8 @@ func (r *RPCMessage) AppendTypeNameField(typeName string) { type RPCFieldSelectionSet map[string]RPCFields // Add adds a field selection set to the map -func (r RPCFieldSelectionSet) Add(fragmentName string, field RPCField) { - if r[fragmentName] == nil { - r[fragmentName] = make(RPCFields, 0) - } - - r[fragmentName] = append(r[fragmentName], field) +func (r RPCFieldSelectionSet) Add(fragmentName string, field ...RPCField) { + r[fragmentName] = append(r[fragmentName], field...) } // SelectFieldsForTypes returns the fields for the given valid types. @@ -718,6 +716,77 @@ func (r *rpcPlanningContext) buildInputMessageField(typeRef int, fieldName, json return field, nil } +func (r *rpcPlanningContext) buildFieldMessage(fieldTypeNode ast.Node, fieldRef int) (*RPCMessage, error) { + field := r.operation.Fields[fieldRef] + if !field.HasSelections { + return nil, nil + } + + fieldRefs := make([]int, 0) + inlineFragmentRefs := make([]int, 0) + selections := r.operation.SelectionSets[field.SelectionSet].SelectionRefs + for i := range selections { + selection := r.operation.Selections[selections[i]] + switch selection.Kind { + case ast.SelectionKindField: + fieldRefs = append(fieldRefs, selection.Ref) + case ast.SelectionKindInlineFragment: + inlineFragmentRefs = append(inlineFragmentRefs, selection.Ref) + } + } + + message := &RPCMessage{ + Name: fieldTypeNode.NameString(r.definition), + } + + if compositeType := r.getCompositeType(fieldTypeNode); compositeType != OneOfTypeNone { + memberTypes, err := r.getMemberTypes(fieldTypeNode) + if err != nil { + return nil, err + } + message.MemberTypes = memberTypes + message.OneOfType = compositeType + } + + for _, inlineFragmentRef := range inlineFragmentRefs { + selectionSetRef, ok := r.operation.InlineFragmentSelectionSet(inlineFragmentRef) + if !ok { + continue + } + + typeName := r.operation.InlineFragmentTypeConditionNameString(inlineFragmentRef) + inlineFragmentTypeNode, found := r.definition.NodeByNameStr(typeName) + if !found { + return nil, fmt.Errorf("unable to resolve type node for inline fragment %s", typeName) + } + + fields, err := r.buildCompositeField(inlineFragmentTypeNode, fragmentSelection{ + typeName: typeName, + selectionSetRef: selectionSetRef, + }) + + if err != nil { + return nil, err + } + + if message.FieldSelectionSet == nil { + message.FieldSelectionSet = make(RPCFieldSelectionSet) + } + + message.FieldSelectionSet.Add(typeName, fields...) + } + + for _, fieldRef := range fieldRefs { + field, err := r.buildRequiredField(fieldTypeNode, fieldRef) + if err != nil { + return nil, err + } + message.Fields = append(message.Fields, field) + } + + return message, nil +} + // resolveServiceName resolves the service name for a given subgraph name. func (r *rpcPlanningContext) resolveServiceName(subgraphName string) string { if r.mapping == nil || r.mapping.Service == "" { @@ -729,14 +798,86 @@ func (r *rpcPlanningContext) resolveServiceName(subgraphName string) string { type resolvedField struct { callerRef int - parentTypeRef int + parentTypeNode ast.Node fieldRef int fieldDefinitionTypeRef int fieldsSelectionSetRef int responsePath ast.Path - contextFields []contextField - fieldArguments []fieldArgument + contextFields []contextField + fieldArguments []fieldArgument + fragmentSelections []fragmentSelection + fragmentType OneOfType + memberTypes []string +} + +type fragmentSelection struct { + typeName string + selectionSetRef int +} + +// enterResolverCompositeSelectionSet handles logic when entering a composite selection set for a given field resolver. +// It appends the inline fragment selections to the resolved field and sets the fragment type. +func (r *rpcPlanningContext) enterResolverCompositeSelectionSet(oneOfType OneOfType, selectionSetRef int, resolvedField *resolvedField) { + inlineFragSelections := r.operation.SelectionSetInlineFragmentSelections(selectionSetRef) + if len(inlineFragSelections) == 0 { + return + } + + for _, inlineFragSelectionRef := range inlineFragSelections { + inlineFragRef := r.operation.Selections[inlineFragSelectionRef].Ref + inlinFragSelectionSetRef, ok := r.operation.InlineFragmentSelectionSet(inlineFragRef) + if !ok { + continue + } + + resolvedField.fragmentSelections = append(resolvedField.fragmentSelections, fragmentSelection{ + typeName: r.operation.InlineFragmentTypeConditionNameString(inlineFragRef), + selectionSetRef: inlinFragSelectionSetRef, + }) + } + + resolvedField.fragmentType = oneOfType +} + +// isFieldResolver checks if a field is a field resolver. +func (r *rpcPlanningContext) isFieldResolver(fieldRef int, isRootField bool) bool { + if isRootField { + return false + } + + return len(r.operation.FieldArguments(fieldRef)) > 0 +} + +// getCompositeType returns the most recent composite type from the type definitions. +func (r *rpcPlanningContext) getCompositeType(node ast.Node) OneOfType { + switch node.Kind { + case ast.NodeKindInterfaceTypeDefinition: + return OneOfTypeInterface + case ast.NodeKindUnionTypeDefinition: + return OneOfTypeUnion + default: + return OneOfTypeNone + } +} + +func (r *rpcPlanningContext) getMemberTypes(node ast.Node) ([]string, error) { + switch node.Kind { + case ast.NodeKindInterfaceTypeDefinition: + memberTypes, ok := r.definition.InterfaceTypeDefinitionImplementedByObjectWithNames(node.Ref) + if !ok { + return nil, fmt.Errorf("interface type %s is not implemented by any object", r.definition.InterfaceTypeDefinitionNameString(node.Ref)) + } + return memberTypes, nil + case ast.NodeKindUnionTypeDefinition: + memberTypes, ok := r.definition.UnionTypeDefinitionMemberTypeNames(node.Ref) + if !ok { + return nil, fmt.Errorf("union type %s is not defined", r.definition.UnionTypeDefinitionNameString(node.Ref)) + } + return memberTypes, nil + default: + return nil, fmt.Errorf("invalid node kind: %s", node.Kind) + } } // setResolvedField sets the resolved field for a given field definition reference. @@ -832,7 +973,7 @@ func (r *rpcPlanningContext) getFieldsFromFieldResolverDirective(parentNode ast. defer walker.Release() v := newRequiredFieldsVisitor(walker, &RPCMessage{}, r) - if err := v.visitRequiredFields(r.definition, parentNode.NameString(r.definition), fieldsString); err != nil { + if err := v.visitWithDefaults(r.definition, parentNode.NameString(r.definition), fieldsString); err != nil { return nil, err } @@ -895,20 +1036,125 @@ type resolveRPCCallConfig struct { fieldArgsMessage *RPCMessage } -func (r *rpcPlanningContext) resolveRequiredFields(typeName string, requiredFieldSelection int) (*RPCMessage, error) { - walker := astvisitor.WalkerFromPool() - defer walker.Release() +func (r *rpcPlanningContext) resolveRequiredFields(typeName string, resolvedField *resolvedField) (*RPCMessage, error) { message := &RPCMessage{ Name: typeName, } - rfv := newRequiredFieldsVisitor(walker, message, r) - if err := rfv.visitWithMemberTypes(r.definition, typeName, r.operation.SelectionSetFieldSetString(requiredFieldSelection), nil); err != nil { - return nil, err + // TODO: handle composite types. + if len(resolvedField.fragmentSelections) > 0 { + message.FieldSelectionSet = make(RPCFieldSelectionSet, len(resolvedField.fragmentSelections)) + message.OneOfType = resolvedField.fragmentType + message.MemberTypes = resolvedField.memberTypes + + for _, fragmentSelection := range resolvedField.fragmentSelections { + inlineFragmentTypeNode, found := r.definition.NodeByNameStr(fragmentSelection.typeName) + if !found { + return nil, fmt.Errorf("unable to build composite field: underlying fragment type node not found for type %s", fragmentSelection.typeName) + } + + fields, err := r.buildCompositeField(inlineFragmentTypeNode, fragmentSelection) + if err != nil { + return nil, err + } + + message.FieldSelectionSet[fragmentSelection.typeName] = fields + } + + return message, nil + } + + if resolvedField.fieldsSelectionSetRef == ast.InvalidRef { + return nil, errors.New("unable to resolve required fields: no fields selection set found") + } + + parentTypeNode, found := r.definition.NodeByNameStr(typeName) + if !found { + return nil, fmt.Errorf("parent type node not found for type %s", typeName) + } + + fieldRefs := r.operation.SelectionSetFieldRefs(resolvedField.fieldsSelectionSetRef) + message.Fields = make(RPCFields, 0, len(fieldRefs)) + + for _, fieldRef := range fieldRefs { + if r.isFieldResolver(fieldRef, false) { + continue + } + + if message.Fields.Exists(r.operation.FieldNameString(fieldRef), "") { + continue + } + + field, err := r.buildRequiredField(parentTypeNode, fieldRef) + if err != nil { + return nil, err + } + + message.Fields = append(message.Fields, field) } + + message.Fields = slices.Clip(message.Fields) return message, nil } +func (r *rpcPlanningContext) buildRequiredField(typeNode ast.Node, fieldRef int) (RPCField, error) { + fieldName := r.operation.FieldNameString(fieldRef) + fieldDef, found := r.definition.NodeFieldDefinitionByName(typeNode, r.operation.FieldNameBytes(fieldRef)) + if !found { + return RPCField{}, fmt.Errorf("unable to build required field: field definition not found for field %s", fieldName) + } + + field, err := r.buildField(typeNode, fieldDef, r.operation.FieldNameString(fieldRef), "") + if err != nil { + return RPCField{}, err + } + + // If the field is a message type and has selections, we need to build a nested message. + if field.ProtoTypeName == DataTypeMessage && r.operation.FieldHasSelections(fieldRef) { + fieldTypeNode, found := r.definition.ResolveNodeFromTypeRef(r.definition.FieldDefinitionType(fieldDef)) + if !found { + return RPCField{}, fmt.Errorf("unable to build required field: unable to resolve field type node for field %s", fieldName) + } + + message, err := r.buildFieldMessage(fieldTypeNode, fieldRef) + if err != nil { + return RPCField{}, err + } + + field.Message = message + } + + return field, nil +} + +func (r *rpcPlanningContext) buildCompositeField(inlineFragmentNode ast.Node, fragmentSelection fragmentSelection) ([]RPCField, error) { + fieldRefs := r.operation.SelectionSetFieldRefs(fragmentSelection.selectionSetRef) + result := make([]RPCField, 0, len(fieldRefs)) + + for _, fieldRef := range fieldRefs { + fieldDef, found := r.fieldDefinitionForType(r.operation.FieldNameString(fieldRef), fragmentSelection.typeName) + if !found { + return nil, fmt.Errorf("unable to build composite field: field definition not found for field %s", r.operation.FieldNameString(fieldRef)) + } + + field, err := r.buildField(inlineFragmentNode, fieldDef, r.operation.FieldNameString(fieldRef), "") + if err != nil { + return nil, err + } + result = append(result, field) + } + return result, nil +} + +func (r *rpcPlanningContext) fieldDefinitionForType(fieldName, typeName string) (ref int, exists bool) { + node, found := r.definition.NodeByNameStr(typeName) + if !found { + return ast.InvalidRef, false + } + + return r.definition.NodeFieldDefinitionByName(node, unsafebytes.StringToBytes(fieldName)) +} + // createResolverRPCCalls creates a new call for each resolved field. func (r *rpcPlanningContext) createResolverRPCCalls(subgraphName string, resolvedFields []resolvedField) ([]RPCCall, error) { // We need to create a new call for each resolved field. @@ -916,12 +1162,12 @@ func (r *rpcPlanningContext) createResolverRPCCalls(subgraphName string, resolve for _, resolvedField := range resolvedFields { resolveConfig := r.mapping.FindResolveTypeFieldMapping( - r.definition.ObjectTypeDefinitionNameString(resolvedField.parentTypeRef), + resolvedField.parentTypeNode.NameString(r.definition), r.operation.FieldNameString(resolvedField.fieldRef), ) if resolveConfig == nil { - return nil, fmt.Errorf("resolve config not found for type: %s, field: %s", r.definition.ResolveTypeNameString(resolvedField.parentTypeRef), r.operation.FieldAliasString(resolvedField.fieldRef)) + return nil, fmt.Errorf("resolve config not found for type: %s, field: %s", r.definition.NodeNameString(resolvedField.parentTypeNode), r.operation.FieldAliasString(resolvedField.fieldRef)) } contextMessage := &RPCMessage{ @@ -947,13 +1193,9 @@ func (r *rpcPlanningContext) createResolverRPCCalls(subgraphName string, resolve contextMessage.Fields = make(RPCFields, len(resolvedField.contextFields)) for i := range resolvedField.contextFields { - typeDefNode, found := r.definition.NodeByNameStr(r.definition.ResolveTypeNameString(resolvedField.parentTypeRef)) - if !found { - return nil, fmt.Errorf("type definition node not found for type: %s", r.definition.ResolveTypeNameString(resolvedField.parentTypeRef)) - } field, err := r.buildField( - typeDefNode, + resolvedField.parentTypeNode, resolvedField.contextFields[i].fieldRef, r.definition.FieldDefinitionNameString(resolvedField.contextFields[i].fieldRef), "", @@ -1004,7 +1246,7 @@ func (r *rpcPlanningContext) newResolveRPCCall(config *resolveRPCCallConfig) (RP var err error responseFieldsMessage, err = r.resolveRequiredFields( r.definition.ResolveTypeNameString(underlyingTypeRef), - resolvedField.fieldsSelectionSetRef, + resolvedField, ) if err != nil { 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 21d0a8615..2d8f76fce 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 @@ -1323,6 +1323,649 @@ func TestEntityLookupWithFieldResolvers(t *testing.T) { } } +func TestEntityLookupWithFieldResolvers_WithCompositeTypes(t *testing.T) { + t.Parallel() + tests := []struct { + name string + query string + expectedPlan *RPCExecutionPlan + mapping *GRPCMapping + federationConfigs plan.FederationFieldConfigurations + }{ + { + name: "Should create an execution plan for an entity lookup with a field resolver returning interface type", + query: `query EntityLookupWithInterface($representations: [_Any!]!, $includeDetails: Boolean!) { _entities(representations: $representations) { ... on Product { __typename id name mascotRecommendation(includeDetails: $includeDetails) { ... on Cat { name meowVolume } ... on Dog { name barkVolume } } } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Product", + SelectionSet: "id", + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "LookupProductById", + Kind: CallKindEntity, + Request: RPCMessage{ + Name: "LookupProductByIdRequest", + Fields: []RPCField{ + { + Name: "keys", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "LookupProductByIdKey", + MemberTypes: []string{"Product"}, + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "LookupProductByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "_entities", + Message: &RPCMessage{ + Name: "Product", + Fields: []RPCField{ + { + Name: "__typename", + ProtoTypeName: DataTypeString, + JSONPath: "__typename", + StaticValue: "Product", + }, + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + }, + }, + }, + }, + }, + { + ServiceName: "Products", + MethodName: "ResolveProductMascotRecommendation", + Kind: CallKindResolve, + DependentCalls: []int{0}, + ResponsePath: buildPath("_entities.mascotRecommendation"), + Request: RPCMessage{ + Name: "ResolveProductMascotRecommendationRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + JSONPath: "", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveProductMascotRecommendationContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("result.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("result.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + JSONPath: "", + Message: &RPCMessage{ + Name: "ResolveProductMascotRecommendationArgs", + Fields: []RPCField{ + { + Name: "include_details", + ProtoTypeName: DataTypeBool, + JSONPath: "includeDetails", + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveProductMascotRecommendationResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveProductMascotRecommendationResult", + Fields: []RPCField{ + { + Name: "mascot_recommendation", + ProtoTypeName: DataTypeMessage, + JSONPath: "mascotRecommendation", + Optional: true, + Message: &RPCMessage{ + Name: "Animal", + OneOfType: OneOfTypeInterface, + MemberTypes: []string{"Cat", "Dog"}, + FieldSelectionSet: RPCFieldSelectionSet{ + "Cat": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "meow_volume", + ProtoTypeName: DataTypeInt32, + JSONPath: "meowVolume", + }, + }, + "Dog": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "bark_volume", + ProtoTypeName: DataTypeInt32, + JSONPath: "barkVolume", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Should create an execution plan for an entity lookup with a field resolver returning union type", + query: `query EntityLookupWithUnion($representations: [_Any!]!, $checkAvailability: Boolean!) { _entities(representations: $representations) { ... on Product { __typename id name stockStatus(checkAvailability: $checkAvailability) { ... on ActionSuccess { message timestamp } ... on ActionError { message code } } } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Product", + SelectionSet: "id", + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "LookupProductById", + Kind: CallKindEntity, + Request: RPCMessage{ + Name: "LookupProductByIdRequest", + Fields: []RPCField{ + { + Name: "keys", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "LookupProductByIdKey", + MemberTypes: []string{"Product"}, + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "LookupProductByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "_entities", + Message: &RPCMessage{ + Name: "Product", + Fields: []RPCField{ + { + Name: "__typename", + ProtoTypeName: DataTypeString, + JSONPath: "__typename", + StaticValue: "Product", + }, + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + }, + }, + }, + }, + }, + { + ServiceName: "Products", + MethodName: "ResolveProductStockStatus", + Kind: CallKindResolve, + DependentCalls: []int{0}, + ResponsePath: buildPath("_entities.stockStatus"), + Request: RPCMessage{ + Name: "ResolveProductStockStatusRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + JSONPath: "", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveProductStockStatusContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("result.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("result.name"), + }, + { + Name: "price", + ProtoTypeName: DataTypeDouble, + JSONPath: "price", + ResolvePath: buildPath("result.price"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + JSONPath: "", + Message: &RPCMessage{ + Name: "ResolveProductStockStatusArgs", + Fields: []RPCField{ + { + Name: "check_availability", + ProtoTypeName: DataTypeBool, + JSONPath: "checkAvailability", + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveProductStockStatusResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveProductStockStatusResult", + Fields: []RPCField{ + { + Name: "stock_status", + ProtoTypeName: DataTypeMessage, + JSONPath: "stockStatus", + Message: &RPCMessage{ + Name: "ActionResult", + OneOfType: OneOfTypeUnion, + MemberTypes: []string{"ActionSuccess", "ActionError"}, + FieldSelectionSet: RPCFieldSelectionSet{ + "ActionSuccess": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + { + Name: "timestamp", + ProtoTypeName: DataTypeString, + JSONPath: "timestamp", + }, + }, + "ActionError": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + { + Name: "code", + ProtoTypeName: DataTypeString, + JSONPath: "code", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Should create an execution plan for an entity lookup with a field resolver returning nested composite types", + query: `query EntityLookupWithNested($representations: [_Any!]!, $includeExtended: Boolean!) { _entities(representations: $representations) { ... on Product { __typename id name price productDetails(includeExtended: $includeExtended) { id description recommendedPet { ... on Cat { name meowVolume } ... on Dog { name barkVolume } } reviewSummary { ... on ActionSuccess { message timestamp } ... on ActionError { message code } } } } } }`, + mapping: testMapping(), + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Product", + SelectionSet: "id", + }, + }, + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "LookupProductById", + Kind: CallKindEntity, + Request: RPCMessage{ + Name: "LookupProductByIdRequest", + Fields: []RPCField{ + { + Name: "keys", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "representations", + Message: &RPCMessage{ + Name: "LookupProductByIdKey", + MemberTypes: []string{"Product"}, + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "LookupProductByIdResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + Repeated: true, + JSONPath: "_entities", + Message: &RPCMessage{ + Name: "Product", + Fields: []RPCField{ + { + Name: "__typename", + ProtoTypeName: DataTypeString, + JSONPath: "__typename", + StaticValue: "Product", + }, + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "price", + ProtoTypeName: DataTypeDouble, + JSONPath: "price", + }, + }, + }, + }, + }, + }, + }, + { + ServiceName: "Products", + MethodName: "ResolveProductProductDetails", + Kind: CallKindResolve, + DependentCalls: []int{0}, + ResponsePath: buildPath("_entities.productDetails"), + Request: RPCMessage{ + Name: "ResolveProductProductDetailsRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + JSONPath: "", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveProductProductDetailsContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("result.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("result.name"), + }, + { + Name: "price", + ProtoTypeName: DataTypeDouble, + JSONPath: "price", + ResolvePath: buildPath("result.price"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + JSONPath: "", + Message: &RPCMessage{ + Name: "ResolveProductProductDetailsArgs", + Fields: []RPCField{ + { + Name: "include_extended", + ProtoTypeName: DataTypeBool, + JSONPath: "includeExtended", + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveProductProductDetailsResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveProductProductDetailsResult", + Fields: []RPCField{ + { + Name: "product_details", + ProtoTypeName: DataTypeMessage, + JSONPath: "productDetails", + Optional: true, + Message: &RPCMessage{ + Name: "ProductDetails", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "description", + ProtoTypeName: DataTypeString, + JSONPath: "description", + }, + { + Name: "recommended_pet", + ProtoTypeName: DataTypeMessage, + JSONPath: "recommendedPet", + Message: &RPCMessage{ + Name: "Animal", + OneOfType: OneOfTypeInterface, + MemberTypes: []string{"Cat", "Dog"}, + FieldSelectionSet: RPCFieldSelectionSet{ + "Cat": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "meow_volume", + ProtoTypeName: DataTypeInt32, + JSONPath: "meowVolume", + }, + }, + "Dog": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "bark_volume", + ProtoTypeName: DataTypeInt32, + JSONPath: "barkVolume", + }, + }, + }, + }, + }, + { + Name: "review_summary", + ProtoTypeName: DataTypeMessage, + JSONPath: "reviewSummary", + Message: &RPCMessage{ + Name: "ActionResult", + OneOfType: OneOfTypeUnion, + MemberTypes: []string{"ActionSuccess", "ActionError"}, + FieldSelectionSet: RPCFieldSelectionSet{ + "ActionSuccess": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + { + Name: "timestamp", + ProtoTypeName: DataTypeString, + JSONPath: "timestamp", + }, + }, + "ActionError": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + { + Name: "code", + ProtoTypeName: DataTypeString, + JSONPath: "code", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + // Parse the GraphQL schema + schemaDoc := grpctest.MustGraphQLSchema(t) + + // Parse the GraphQL query + queryDoc, report := astparser.ParseGraphqlDocumentString(tt.query) + if report.HasErrors() { + t.Fatalf("failed to parse query: %s", report.Error()) + } + + planner, err := NewPlanner("Products", tt.mapping, tt.federationConfigs) + if err != nil { + t.Fatalf("failed to create planner: %s", err) + } + plan, err := planner.PlanOperation(&queryDoc, &schemaDoc) + if err != nil { + t.Fatalf("failed to plan operation: %s", err) + } + + diff := cmp.Diff(tt.expectedPlan, plan) + if diff != "" { + t.Fatalf("execution plan mismatch: %s", diff) + } + }) + } +} + func runFederationTest(t *testing.T, tt struct { name string query string 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 a07573ba9..aa2b529f9 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 @@ -892,3 +892,1016 @@ func TestExecutionPlanFieldResolvers(t *testing.T) { }) } } + +func TestExecutionPlanFieldResolvers_WithNestedResolvers(t *testing.T) { + t.Parallel() + tests := []struct { + name string + query string + expectedPlan *RPCExecutionPlan + expectedError string + }{ + { + name: "Should create an execution plan for a query with nested field resolvers", + query: "query CategoriesWithNestedResolvers($metricType: String, $baseline: Float!) { categories { categoryMetrics(metricType: $metricType) { id metricType value normalizedScore(baseline: $baseline) } } }", + 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{}, + }, + }, + }, + }, + }, + { + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryCategoryMetrics", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.categoryMetrics"), + Request: RPCMessage{ + Name: "ResolveCategoryCategoryMetricsRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryCategoryMetricsContext", + 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: "ResolveCategoryCategoryMetricsArgs", + Fields: []RPCField{ + { + Name: "metric_type", + ProtoTypeName: DataTypeString, + JSONPath: "metricType", + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryCategoryMetricsResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryCategoryMetricsResult", + Fields: []RPCField{ + { + Name: "category_metrics", + ProtoTypeName: DataTypeMessage, + JSONPath: "categoryMetrics", + Optional: true, + Message: &RPCMessage{ + Name: "CategoryMetrics", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "metric_type", + ProtoTypeName: DataTypeString, + JSONPath: "metricType", + }, + { + Name: "value", + ProtoTypeName: DataTypeDouble, + JSONPath: "value", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + DependentCalls: []int{1}, + ServiceName: "Products", + MethodName: "ResolveCategoryMetricsNormalizedScore", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.categoryMetrics.normalizedScore"), + Request: RPCMessage{ + Name: "ResolveCategoryMetricsNormalizedScoreRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryMetricsNormalizedScoreContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("categories.categoryMetrics.id"), + }, + { + Name: "value", + ProtoTypeName: DataTypeDouble, + JSONPath: "value", + ResolvePath: buildPath("categories.categoryMetrics.value"), + }, + { + Name: "metric_type", + ProtoTypeName: DataTypeString, + JSONPath: "metricType", + ResolvePath: buildPath("categories.categoryMetrics.metricType"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryMetricsNormalizedScoreArgs", + Fields: []RPCField{ + { + Name: "baseline", + ProtoTypeName: DataTypeDouble, + JSONPath: "baseline", + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryMetricsNormalizedScoreResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryMetricsNormalizedScoreResult", + Fields: []RPCField{ + { + Name: "normalized_score", + ProtoTypeName: DataTypeDouble, + JSONPath: "normalizedScore", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + } + + 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) { + t.Parallel() + tests := []struct { + name string + query string + expectedPlan *RPCExecutionPlan + expectedError string + }{ + { + name: "Should create an execution plan for a query with interface type", + query: "query CategoriesWithNestedResolvers($includeValue: Boolean!) { categories { mascot(includeVolume: $includeVolume) { ... on Cat { name } ... on Dog { name } } } }", + 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{}, + }, + }, + }, + }, + }, + { + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryMascot", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.mascot"), + Request: RPCMessage{ + Name: "ResolveCategoryMascotRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryMascotContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("categories.id"), + }, + { + Name: "kind", + ProtoTypeName: DataTypeEnum, + JSONPath: "kind", + EnumName: "CategoryKind", + ResolvePath: buildPath("categories.kind"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveCategoryMascotArgs", + Fields: []RPCField{ + { + Name: "include_volume", + ProtoTypeName: DataTypeBool, + JSONPath: "includeVolume", + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryMascotResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryMascotResult", + Fields: []RPCField{ + { + Name: "mascot", + ProtoTypeName: DataTypeMessage, + JSONPath: "mascot", + Optional: true, + Message: &RPCMessage{ + Name: "Animal", + OneOfType: OneOfTypeInterface, + MemberTypes: []string{"Cat", "Dog"}, + FieldSelectionSet: RPCFieldSelectionSet{ + "Cat": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + "Dog": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Should create an execution plan for a query with union type", + query: "query CategoriesWithUnionResolver($checkHealth: Boolean!) { categories { categoryStatus(checkHealth: $checkHealth) { ... on ActionSuccess { message timestamp } ... on ActionError { message code } } } }", + 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{}, + }, + }, + }, + }, + }, + { + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveCategoryCategoryStatus", + Kind: CallKindResolve, + ResponsePath: buildPath("categories.categoryStatus"), + Request: RPCMessage{ + Name: "ResolveCategoryCategoryStatusRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryCategoryStatusContext", + 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: "ResolveCategoryCategoryStatusArgs", + Fields: []RPCField{ + { + Name: "check_health", + ProtoTypeName: DataTypeBool, + JSONPath: "checkHealth", + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveCategoryCategoryStatusResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveCategoryCategoryStatusResult", + Fields: []RPCField{ + { + Name: "category_status", + ProtoTypeName: DataTypeMessage, + JSONPath: "categoryStatus", + Message: &RPCMessage{ + Name: "ActionResult", + OneOfType: OneOfTypeUnion, + MemberTypes: []string{"ActionSuccess", "ActionError"}, + FieldSelectionSet: RPCFieldSelectionSet{ + "ActionSuccess": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + { + Name: "timestamp", + ProtoTypeName: DataTypeString, + JSONPath: "timestamp", + }, + }, + "ActionError": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + { + Name: "code", + ProtoTypeName: DataTypeString, + JSONPath: "code", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Should create an execution plan for a query with nested interface type", + query: "query TestContainersWithInterface($includeExtended: Boolean!) { testContainers { id name details(includeExtended: $includeExtended) { id summary pet { ... on Cat { name meowVolume } ... on Dog { name barkVolume } } } } }", + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "QueryTestContainers", + Request: RPCMessage{ + Name: "QueryTestContainersRequest", + }, + Response: RPCMessage{ + Name: "QueryTestContainersResponse", + Fields: []RPCField{ + { + Name: "test_containers", + ProtoTypeName: DataTypeMessage, + JSONPath: "testContainers", + Repeated: true, + Message: &RPCMessage{ + Name: "TestContainer", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + }, + }, + }, + }, + }, + { + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveTestContainerDetails", + Kind: CallKindResolve, + ResponsePath: buildPath("testContainers.details"), + Request: RPCMessage{ + Name: "ResolveTestContainerDetailsRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveTestContainerDetailsContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("test_containers.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("test_containers.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveTestContainerDetailsArgs", + Fields: []RPCField{ + { + Name: "include_extended", + ProtoTypeName: DataTypeBool, + JSONPath: "includeExtended", + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveTestContainerDetailsResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveTestContainerDetailsResult", + Fields: []RPCField{ + { + Name: "details", + ProtoTypeName: DataTypeMessage, + JSONPath: "details", + Optional: true, + Message: &RPCMessage{ + Name: "TestDetails", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "summary", + ProtoTypeName: DataTypeString, + JSONPath: "summary", + }, + { + Name: "pet", + ProtoTypeName: DataTypeMessage, + JSONPath: "pet", + Message: &RPCMessage{ + Name: "Animal", + OneOfType: OneOfTypeInterface, + MemberTypes: []string{"Cat", "Dog"}, + FieldSelectionSet: RPCFieldSelectionSet{ + "Cat": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "meow_volume", + ProtoTypeName: DataTypeInt32, + JSONPath: "meowVolume", + }, + }, + "Dog": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "bark_volume", + ProtoTypeName: DataTypeInt32, + JSONPath: "barkVolume", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Should create an execution plan for a query with nested union type", + query: "query TestContainersWithUnion($includeExtended: Boolean!) { testContainers { id name details(includeExtended: $includeExtended) { id summary status { ... on ActionSuccess { message timestamp } ... on ActionError { message code } } } } }", + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "QueryTestContainers", + Request: RPCMessage{ + Name: "QueryTestContainersRequest", + }, + Response: RPCMessage{ + Name: "QueryTestContainersResponse", + Fields: []RPCField{ + { + Name: "test_containers", + ProtoTypeName: DataTypeMessage, + JSONPath: "testContainers", + Repeated: true, + Message: &RPCMessage{ + Name: "TestContainer", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + }, + }, + }, + }, + }, + { + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveTestContainerDetails", + Kind: CallKindResolve, + ResponsePath: buildPath("testContainers.details"), + Request: RPCMessage{ + Name: "ResolveTestContainerDetailsRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveTestContainerDetailsContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("test_containers.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("test_containers.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveTestContainerDetailsArgs", + Fields: []RPCField{ + { + Name: "include_extended", + ProtoTypeName: DataTypeBool, + JSONPath: "includeExtended", + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveTestContainerDetailsResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveTestContainerDetailsResult", + Fields: []RPCField{ + { + Name: "details", + ProtoTypeName: DataTypeMessage, + JSONPath: "details", + Optional: true, + Message: &RPCMessage{ + Name: "TestDetails", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "summary", + ProtoTypeName: DataTypeString, + JSONPath: "summary", + }, + { + Name: "status", + ProtoTypeName: DataTypeMessage, + JSONPath: "status", + Message: &RPCMessage{ + Name: "ActionResult", + OneOfType: OneOfTypeUnion, + MemberTypes: []string{"ActionSuccess", "ActionError"}, + FieldSelectionSet: RPCFieldSelectionSet{ + "ActionSuccess": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + { + Name: "timestamp", + ProtoTypeName: DataTypeString, + JSONPath: "timestamp", + }, + }, + "ActionError": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + { + Name: "code", + ProtoTypeName: DataTypeString, + JSONPath: "code", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Should create an execution plan for a query with both nested interface and union types", + query: "query TestContainersWithBoth($includeExtended: Boolean!) { testContainers { id name details(includeExtended: $includeExtended) { id summary pet { ... on Cat { name meowVolume } ... on Dog { name barkVolume } } status { ... on ActionSuccess { message timestamp } ... on ActionError { message code } } } } }", + expectedPlan: &RPCExecutionPlan{ + Calls: []RPCCall{ + { + ServiceName: "Products", + MethodName: "QueryTestContainers", + Request: RPCMessage{ + Name: "QueryTestContainersRequest", + }, + Response: RPCMessage{ + Name: "QueryTestContainersResponse", + Fields: []RPCField{ + { + Name: "test_containers", + ProtoTypeName: DataTypeMessage, + JSONPath: "testContainers", + Repeated: true, + Message: &RPCMessage{ + Name: "TestContainer", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + }, + }, + }, + }, + }, + }, + { + DependentCalls: []int{0}, + ServiceName: "Products", + MethodName: "ResolveTestContainerDetails", + Kind: CallKindResolve, + ResponsePath: buildPath("testContainers.details"), + Request: RPCMessage{ + Name: "ResolveTestContainerDetailsRequest", + Fields: []RPCField{ + { + Name: "context", + ProtoTypeName: DataTypeMessage, + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveTestContainerDetailsContext", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + ResolvePath: buildPath("test_containers.id"), + }, + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + ResolvePath: buildPath("test_containers.name"), + }, + }, + }, + }, + { + Name: "field_args", + ProtoTypeName: DataTypeMessage, + Message: &RPCMessage{ + Name: "ResolveTestContainerDetailsArgs", + Fields: []RPCField{ + { + Name: "include_extended", + ProtoTypeName: DataTypeBool, + JSONPath: "includeExtended", + }, + }, + }, + }, + }, + }, + Response: RPCMessage{ + Name: "ResolveTestContainerDetailsResponse", + Fields: []RPCField{ + { + Name: "result", + ProtoTypeName: DataTypeMessage, + JSONPath: "result", + Repeated: true, + Message: &RPCMessage{ + Name: "ResolveTestContainerDetailsResult", + Fields: []RPCField{ + { + Name: "details", + ProtoTypeName: DataTypeMessage, + JSONPath: "details", + Optional: true, + Message: &RPCMessage{ + Name: "TestDetails", + Fields: []RPCField{ + { + Name: "id", + ProtoTypeName: DataTypeString, + JSONPath: "id", + }, + { + Name: "summary", + ProtoTypeName: DataTypeString, + JSONPath: "summary", + }, + { + Name: "pet", + ProtoTypeName: DataTypeMessage, + JSONPath: "pet", + Message: &RPCMessage{ + Name: "Animal", + OneOfType: OneOfTypeInterface, + MemberTypes: []string{"Cat", "Dog"}, + FieldSelectionSet: RPCFieldSelectionSet{ + "Cat": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "meow_volume", + ProtoTypeName: DataTypeInt32, + JSONPath: "meowVolume", + }, + }, + "Dog": { + { + Name: "name", + ProtoTypeName: DataTypeString, + JSONPath: "name", + }, + { + Name: "bark_volume", + ProtoTypeName: DataTypeInt32, + JSONPath: "barkVolume", + }, + }, + }, + }, + }, + { + Name: "status", + ProtoTypeName: DataTypeMessage, + JSONPath: "status", + Message: &RPCMessage{ + Name: "ActionResult", + OneOfType: OneOfTypeUnion, + MemberTypes: []string{"ActionSuccess", "ActionError"}, + FieldSelectionSet: RPCFieldSelectionSet{ + "ActionSuccess": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + { + Name: "timestamp", + ProtoTypeName: DataTypeString, + JSONPath: "timestamp", + }, + }, + "ActionError": { + { + Name: "message", + ProtoTypeName: DataTypeString, + JSONPath: "message", + }, + { + Name: "code", + ProtoTypeName: DataTypeString, + JSONPath: "code", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + } + + 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, + }) + }) + } +} 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 6fbc030b9..40ddfda92 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor.go +++ b/v2/pkg/engine/datasource/grpc_datasource/execution_plan_visitor.go @@ -54,9 +54,9 @@ type rpcPlanVisitor struct { currentCall *RPCCall currentCallID int - parentCallID int - resolvedFieldIndex int - resolvedFields []resolvedField + parentCallID int + fieldResolverAncestors stack[int] + resolvedFields []resolvedField fieldPath ast.Path } @@ -72,15 +72,15 @@ type rpcPlanVisitorConfig struct { func newRPCPlanVisitor(config rpcPlanVisitorConfig) *rpcPlanVisitor { walker := astvisitor.NewWalker(48) visitor := &rpcPlanVisitor{ - walker: &walker, - plan: &RPCExecutionPlan{}, - subgraphName: cases.Title(language.Und, cases.NoLower).String(config.subgraphName), - mapping: config.mapping, - operationFieldRef: ast.InvalidRef, - resolvedFields: make([]resolvedField, 0), - parentCallID: ast.InvalidRef, - resolvedFieldIndex: ast.InvalidRef, - fieldPath: make(ast.Path, 0), + walker: &walker, + plan: &RPCExecutionPlan{}, + subgraphName: cases.Title(language.Und, cases.NoLower).String(config.subgraphName), + mapping: config.mapping, + operationFieldRef: ast.InvalidRef, + resolvedFields: make([]resolvedField, 0), + parentCallID: ast.InvalidRef, + fieldResolverAncestors: newStack[int](0), + fieldPath: make(ast.Path, 0), } walker.RegisterDocumentVisitor(visitor) @@ -197,10 +197,28 @@ func (r *rpcPlanVisitor) EnterSelectionSet(ref int) { } // If we are inside of a resolved field that selects multiple fields, we get all the fields from the input and pass them to the required fields visitor. - if r.resolvedFieldIndex != ast.InvalidRef { + if r.fieldResolverAncestors.len() > 0 { + if r.walker.Ancestor().Kind == ast.NodeKindInlineFragment { + return + } + + resolvedFieldAncestor := r.fieldResolverAncestors.peek() + if compositType := r.planCtx.getCompositeType(r.walker.EnclosingTypeDefinition); compositType != OneOfTypeNone { + memberTypes, err := r.planCtx.getMemberTypes(r.walker.EnclosingTypeDefinition) + if err != nil { + r.walker.StopWithInternalErr(err) + return + } + resolvedField := &r.resolvedFields[resolvedFieldAncestor] + resolvedField.memberTypes = memberTypes + resolvedField.fieldsSelectionSetRef = ast.InvalidRef + + r.planCtx.enterResolverCompositeSelectionSet(compositType, ref, resolvedField) + return + } + // TODO: handle nested resolved fields. - r.resolvedFields[r.resolvedFieldIndex].fieldsSelectionSetRef = ref - r.walker.SkipNode() + r.resolvedFields[resolvedFieldAncestor].fieldsSelectionSetRef = ref return } @@ -333,13 +351,7 @@ func (r *rpcPlanVisitor) EnterField(ref int) { return } - // prevent duplicate fields - fieldAlias := r.operation.FieldAliasString(ref) - if r.planInfo.currentResponseMessage.Fields.Exists(fieldName, fieldAlias) { - return - } - - fd, ok := r.walker.FieldDefinition(ref) + fieldDefRef, ok := r.walker.FieldDefinition(ref) if !ok { r.walker.Report.AddExternalError(operationreport.ExternalError{ Message: fmt.Sprintf("Field %s not found in definition %s", r.operation.FieldNameString(ref), r.walker.EnclosingTypeDefinition.NameString(r.definition)), @@ -347,34 +359,27 @@ func (r *rpcPlanVisitor) EnterField(ref int) { return } - // 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. - // TODO: this needs to be available for both visitors and added to the plancontext - if fieldArgs := r.operation.FieldArguments(ref); !inRootField && len(fieldArgs) > 0 { - // We don't want to add fields from the selection set to the actual call - resolvedField := resolvedField{ - callerRef: r.parentCallID, - parentTypeRef: r.walker.EnclosingTypeDefinition.Ref, - fieldRef: ref, - responsePath: r.walker.Path[1:].WithoutInlineFragmentNames().WithFieldNameItem(r.operation.FieldAliasOrNameBytes(ref)), - fieldDefinitionTypeRef: r.definition.FieldDefinitionType(fd), - } - - if err := r.planCtx.setResolvedField(r.walker, fd, fieldArgs, r.fieldPath, &resolvedField); err != nil { - r.walker.StopWithInternalErr(err) - return - } + // If the field is a field resolver, we need to handle it later in a separate resolver call. + // We only store the information about the field and create the call later. + if r.planCtx.isFieldResolver(ref, inRootField) { + r.enterFieldResolver(ref, fieldDefRef) + return + } - r.resolvedFields = append(r.resolvedFields, resolvedField) - r.resolvedFieldIndex = len(r.resolvedFields) - 1 - r.fieldPath = r.fieldPath.WithFieldNameItem(r.operation.FieldNameBytes(ref)) + // Check if the field is inside of a resolver call. + if r.fieldResolverAncestors.len() > 0 { + // We don't want to call LeaveField here because we ignore the field entirely. + r.walker.SkipNode() + return + } - // In case of nested fields with arguments, we need to increment the related call ID. - r.parentCallID++ + // prevent duplicate fields + fieldAlias := r.operation.FieldAliasString(ref) + if r.planInfo.currentResponseMessage.Fields.Exists(fieldName, fieldAlias) { return } - field, err := r.planCtx.buildField(r.walker.EnclosingTypeDefinition, fd, fieldName, fieldAlias) + field, err := r.planCtx.buildField(r.walker.EnclosingTypeDefinition, fieldDefRef, fieldName, fieldAlias) if err != nil { r.walker.StopWithInternalErr(err) return @@ -405,7 +410,7 @@ func (r *rpcPlanVisitor) EnterField(ref int) { // LeaveField implements astvisitor.FieldVisitor. func (r *rpcPlanVisitor) LeaveField(ref int) { r.fieldPath = r.fieldPath.RemoveLastItem() - r.resolvedFieldIndex = ast.InvalidRef + r.fieldResolverAncestors.pop() // If we are not in the operation field, we can increment the response field index. if !r.walker.InRootField() { @@ -430,3 +435,32 @@ func (r *rpcPlanVisitor) LeaveField(ref int) { 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. +func (r *rpcPlanVisitor) enterFieldResolver(ref int, fieldDefRef int) { + // 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 + resolvedField := resolvedField{ + callerRef: r.parentCallID, + 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.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)) + + // In case of nested fields with arguments, we need to increment the related call ID. + r.parentCallID++ +} 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 ef0a2644f..2b1a34157 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 @@ -50,9 +50,9 @@ type rpcPlanVisitorFederation struct { subgraphName string currentCall *RPCCall - parentCallID int - resolvedFieldIndex int - resolvedFields []resolvedField + parentCallID int + fieldResolverAncestors stack[int] + resolvedFields []resolvedField fieldPath ast.Path } @@ -68,11 +68,11 @@ func newRPCPlanVisitorFederation(config rpcPlanVisitorConfig) *rpcPlanVisitorFed entityRootFieldRef: ast.InvalidRef, entityInlineFragmentRef: ast.InvalidRef, }, - federationConfigData: parseFederationConfigData(config.federationConfigs), - resolvedFields: make([]resolvedField, 0), - resolvedFieldIndex: ast.InvalidRef, - parentCallID: ast.InvalidRef, - fieldPath: ast.Path{}.WithFieldNameItem([]byte("result")), + federationConfigData: parseFederationConfigData(config.federationConfigs), + resolvedFields: make([]resolvedField, 0), + fieldResolverAncestors: newStack[int](0), + parentCallID: ast.InvalidRef, + fieldPath: ast.Path{}.WithFieldNameItem([]byte("result")), } walker.RegisterDocumentVisitor(visitor) @@ -187,9 +187,29 @@ func (r *rpcPlanVisitorFederation) EnterSelectionSet(ref int) { } // If we are inside of a resolved field that selects multiple fields, we get all the fields from the input and pass them to the required fields visitor. - if r.resolvedFieldIndex != ast.InvalidRef { - r.resolvedFields[r.resolvedFieldIndex].fieldsSelectionSetRef = ref - r.walker.SkipNode() + if r.fieldResolverAncestors.len() > 0 { + if r.walker.Ancestor().Kind == ast.NodeKindInlineFragment { + return + } + + resolvedFieldAncestor := r.fieldResolverAncestors.peek() + if compositType := r.planCtx.getCompositeType(r.walker.EnclosingTypeDefinition); compositType != OneOfTypeNone { + memberTypes, err := r.planCtx.getMemberTypes(r.walker.EnclosingTypeDefinition) + if err != nil { + r.walker.StopWithInternalErr(err) + return + } + resolvedField := &r.resolvedFields[resolvedFieldAncestor] + + resolvedField.memberTypes = memberTypes + resolvedField.fieldsSelectionSetRef = ast.InvalidRef + + r.planCtx.enterResolverCompositeSelectionSet(compositType, ref, resolvedField) + return + } + + // TODO: handle nested resolved fields. + r.resolvedFields[resolvedFieldAncestor].fieldsSelectionSetRef = ref return } @@ -302,14 +322,7 @@ func (r *rpcPlanVisitorFederation) EnterField(ref int) { return } - // prevent duplicate fields - fieldAlias := r.operation.FieldAliasString(ref) - if r.planInfo.currentResponseMessage.Fields.Exists(fieldName, fieldAlias) { - r.fieldPath = r.fieldPath.WithFieldNameItem([]byte{}) - return - } - - fd, ok := r.walker.FieldDefinition(ref) + fieldDefRef, ok := r.walker.FieldDefinition(ref) if !ok { r.walker.Report.AddExternalError(operationreport.ExternalError{ Message: fmt.Sprintf("Field %s not found in definition %s", r.operation.FieldNameString(ref), r.walker.EnclosingTypeDefinition.NameString(r.definition)), @@ -317,31 +330,28 @@ func (r *rpcPlanVisitorFederation) EnterField(ref int) { return } - if fieldArgs := r.operation.FieldArguments(ref); !inRootField && len(fieldArgs) > 0 { - // We don't want to add fields from the selection set to the actual call - resolvedField := resolvedField{ - callerRef: r.parentCallID, - parentTypeRef: r.walker.EnclosingTypeDefinition.Ref, - fieldRef: ref, - responsePath: r.walker.Path[1:].WithoutInlineFragmentNames().WithFieldNameItem(r.operation.FieldAliasOrNameBytes(ref)), - fieldDefinitionTypeRef: r.definition.FieldDefinitionType(fd), - } - - if err := r.planCtx.setResolvedField(r.walker, fd, fieldArgs, r.fieldPath, &resolvedField); err != nil { - r.walker.StopWithInternalErr(err) - return - } + // If the field is a field resolver, we need to handle it later in a separate resolver call. + // We only store the information about the field and create the call later. + if r.planCtx.isFieldResolver(ref, inRootField) { + r.enterFieldResolver(ref, fieldDefRef) + return + } - r.resolvedFields = append(r.resolvedFields, resolvedField) - r.resolvedFieldIndex = len(r.resolvedFields) - 1 - r.fieldPath = r.fieldPath.WithFieldNameItem(r.operation.FieldNameBytes(ref)) + // Check if the field is inside of a resolver call. + if r.fieldResolverAncestors.len() > 0 { + // We don't want to call LeaveField here because we ignore the field entirely. + r.walker.SkipNode() + return + } - // In case of nested fields with arguments, we need to increment the related call ID. - r.parentCallID++ + // prevent duplicate fields + fieldAlias := r.operation.FieldAliasString(ref) + if r.planInfo.currentResponseMessage.Fields.Exists(fieldName, fieldAlias) { + r.fieldPath = r.fieldPath.WithFieldNameItem([]byte{}) return } - field, err := r.planCtx.buildField(r.walker.EnclosingTypeDefinition, fd, fieldName, fieldAlias) + field, err := r.planCtx.buildField(r.walker.EnclosingTypeDefinition, fieldDefRef, fieldName, fieldAlias) if err != nil { r.walker.StopWithInternalErr(err) return @@ -372,7 +382,7 @@ func (r *rpcPlanVisitorFederation) EnterField(ref int) { // LeaveField implements astvisitor.FieldVisitor. func (r *rpcPlanVisitorFederation) LeaveField(ref int) { r.fieldPath = r.fieldPath.RemoveLastItem() - r.resolvedFieldIndex = ast.InvalidRef + r.fieldResolverAncestors.pop() // If we are not in the operation field, we can increment the response field index. if !r.walker.InRootField() { // If the field has arguments, we need to decrement the related call ID. @@ -389,6 +399,35 @@ func (r *rpcPlanVisitorFederation) LeaveField(ref int) { 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. +func (r *rpcPlanVisitorFederation) enterFieldResolver(ref int, fieldDefRef int) { + // 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 + resolvedField := resolvedField{ + callerRef: r.parentCallID, + 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.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)) + + // In case of nested fields with arguments, we need to increment the related call ID. + r.parentCallID++ +} + func (r *rpcPlanVisitorFederation) resolveEntityInformation(inlineFragmentRef int, fc federationConfigData) error { fragmentName := r.operation.InlineFragmentTypeConditionNameString(inlineFragmentRef) node, found := r.definition.NodeByNameStr(r.operation.InlineFragmentTypeConditionNameString(inlineFragmentRef)) @@ -426,7 +465,7 @@ func (r *rpcPlanVisitorFederation) scaffoldEntityLookup(fc federationConfigData) defer walker.Release() requiredFieldsVisitor := newRequiredFieldsVisitor(walker, keyFieldMessage, r.planCtx) - err := requiredFieldsVisitor.visitRequiredFields(r.definition, fc.entityTypeName, fc.keyFields) + err := requiredFieldsVisitor.visitWithDefaults(r.definition, fc.entityTypeName, fc.keyFields) if err != nil { r.walker.StopWithInternalErr(err) return 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 8191b5b08..f6872b7e2 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_test.go +++ b/v2/pkg/engine/datasource/grpc_datasource/grpc_datasource_test.go @@ -3758,6 +3758,307 @@ func Test_DataSource_Load_WithEntity_Calls(t *testing.T) { } } +func Test_DataSource_Load_WithEntity_Calls_WithCompositeTypes(t *testing.T) { + conn, cleanup := setupTestGRPCServer(t) + t.Cleanup(cleanup) + + type graphqlError struct { + Message string `json:"message"` + } + type graphqlResponse struct { + Data map[string]interface{} `json:"data"` + Errors []graphqlError `json:"errors,omitempty"` + } + + testCases := []struct { + name string + query string + vars string + federationConfigs plan.FederationFieldConfigurations + validate func(t *testing.T, data map[string]interface{}) + validateError func(t *testing.T, errData []graphqlError) + }{ + { + name: "Query Product with field resolver returning interface type", + query: `query($representations: [_Any!]!, $includeDetails: Boolean!) { _entities(representations: $representations) { ...on Product { __typename id name mascotRecommendation(includeDetails: $includeDetails) { ... on Cat { __typename name meowVolume } ... on Dog { __typename name barkVolume } } } } }`, + vars: `{ + "variables": { + "representations": [ + {"__typename":"Product","id":"1"}, + {"__typename":"Product","id":"2"}, + {"__typename":"Product","id":"3"} + ], + "includeDetails": true + } + }`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Product", + SelectionSet: "id", + }, + }, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + entities, ok := data["_entities"].([]interface{}) + require.True(t, ok, "_entities should be an array") + require.NotEmpty(t, entities, "_entities should not be empty") + require.Len(t, entities, 3, "Should return 3 entities") + + for index, entity := range entities { + entity, ok := entity.(map[string]interface{}) + require.True(t, ok, "entity should be an object") + productID := index + 1 + + require.Equal(t, fmt.Sprintf("%d", productID), entity["id"]) + require.Equal(t, fmt.Sprintf("Product %d", productID), entity["name"]) + + mascot, ok := entity["mascotRecommendation"].(map[string]interface{}) + require.True(t, ok, "mascotRecommendation should be an object") + + // Alternates between Cat and Dog based on index + if index%2 == 0 { + // Should be Cat + typename, ok := mascot["__typename"].(string) + require.True(t, ok, "__typename should be present") + require.Equal(t, "Cat", typename) + + require.Contains(t, mascot, "name") + require.Contains(t, mascot["name"], "MascotCat") + + // Validate meowVolume field + require.Contains(t, mascot, "meowVolume") + meowVolume, ok := mascot["meowVolume"].(float64) + require.True(t, ok, "meowVolume should be a number") + require.Greater(t, meowVolume, float64(0), "meowVolume should be greater than 0") + } else { + // Should be Dog + typename, ok := mascot["__typename"].(string) + require.True(t, ok, "__typename should be present") + require.Equal(t, "Dog", typename) + + require.Contains(t, mascot, "name") + require.Contains(t, mascot["name"], "MascotDog") + + // Validate barkVolume field + require.Contains(t, mascot, "barkVolume") + barkVolume, ok := mascot["barkVolume"].(float64) + require.True(t, ok, "barkVolume should be a number") + require.Greater(t, barkVolume, float64(0), "barkVolume should be greater than 0") + } + } + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + { + name: "Query Product with field resolver returning union type", + query: `query($representations: [_Any!]!, $checkAvailability: Boolean!) { _entities(representations: $representations) { ...on Product { __typename id name stockStatus(checkAvailability: $checkAvailability) { ... on ActionSuccess { __typename message timestamp } ... on ActionError { __typename message code } } } } }`, + vars: `{ + "variables": { + "representations": [ + {"__typename":"Product","id":"1"}, + {"__typename":"Product","id":"2"}, + {"__typename":"Product","id":"3"} + ], + "checkAvailability": false + } + }`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Product", + SelectionSet: "id", + }, + }, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + entities, ok := data["_entities"].([]interface{}) + require.True(t, ok, "_entities should be an array") + require.NotEmpty(t, entities, "_entities should not be empty") + require.Len(t, entities, 3, "Should return 3 entities") + + for index, entity := range entities { + entity, ok := entity.(map[string]interface{}) + require.True(t, ok, "entity should be an object") + productID := index + 1 + + require.Equal(t, fmt.Sprintf("%d", productID), entity["id"]) + require.Equal(t, fmt.Sprintf("Product %d", productID), entity["name"]) + + stockStatus, ok := entity["stockStatus"].(map[string]interface{}) + require.True(t, ok, "stockStatus should be an object") + + // With checkAvailability: false, all should be success + typename, ok := stockStatus["__typename"].(string) + require.True(t, ok, "__typename should be present") + require.Equal(t, "ActionSuccess", typename) + + require.Contains(t, stockStatus, "message") + require.Contains(t, stockStatus, "timestamp") + + message, ok := stockStatus["message"].(string) + require.True(t, ok, "message should be a string") + require.Contains(t, message, "in stock and available") + + timestamp, ok := stockStatus["timestamp"].(string) + require.True(t, ok, "timestamp should be a string") + require.NotEmpty(t, timestamp) + } + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + { + name: "Query Product with field resolver returning nested composite types", + query: `query($representations: [_Any!]!, $includeExtended: Boolean!) { _entities(representations: $representations) { ...on Product { __typename id name price productDetails(includeExtended: $includeExtended) { id description recommendedPet { __typename ... on Cat { name meowVolume } ... on Dog { name barkVolume } } reviewSummary { __typename ... on ActionSuccess { message timestamp } ... on ActionError { message code } } } } } }`, + vars: `{ + "variables": { + "representations": [ + {"__typename":"Product","id":"1"}, + {"__typename":"Product","id":"2"} + ], + "includeExtended": false + } + }`, + federationConfigs: plan.FederationFieldConfigurations{ + { + TypeName: "Product", + SelectionSet: "id", + }, + }, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + entities, ok := data["_entities"].([]interface{}) + require.True(t, ok, "_entities should be an array") + require.NotEmpty(t, entities, "_entities should not be empty") + require.Len(t, entities, 2, "Should return 2 entities") + + for index, entity := range entities { + entity, ok := entity.(map[string]interface{}) + require.True(t, ok, "entity should be an object") + productID := index + 1 + + require.Equal(t, fmt.Sprintf("%d", productID), entity["id"]) + require.Equal(t, fmt.Sprintf("Product %d", productID), entity["name"]) + + details, ok := entity["productDetails"].(map[string]interface{}) + require.True(t, ok, "productDetails should be an object") + + require.Contains(t, details, "id") + require.Contains(t, details, "description") + require.Contains(t, details["description"], "Standard details") + + // Check recommendedPet (interface) + pet, ok := details["recommendedPet"].(map[string]interface{}) + require.True(t, ok, "recommendedPet should be an object") + + // Alternates between Cat and Dog + if index%2 == 0 { + // Should be Cat + petTypename, ok := pet["__typename"].(string) + require.True(t, ok, "pet __typename should be present") + require.Equal(t, "Cat", petTypename) + + require.Contains(t, pet, "name") + require.Contains(t, pet["name"], "RecommendedCat") + + // Validate meowVolume field + require.Contains(t, pet, "meowVolume") + meowVolume, ok := pet["meowVolume"].(float64) + require.True(t, ok, "meowVolume should be a number") + require.Greater(t, meowVolume, float64(0), "meowVolume should be greater than 0") + } else { + // Should be Dog + petTypename, ok := pet["__typename"].(string) + require.True(t, ok, "pet __typename should be present") + require.Equal(t, "Dog", petTypename) + + require.Contains(t, pet, "name") + require.Contains(t, pet["name"], "RecommendedDog") + + // Validate barkVolume field + require.Contains(t, pet, "barkVolume") + barkVolume, ok := pet["barkVolume"].(float64) + require.True(t, ok, "barkVolume should be a number") + require.Greater(t, barkVolume, float64(0), "barkVolume should be greater than 0") + } + + // Check reviewSummary (union) + reviewSummary, ok := details["reviewSummary"].(map[string]interface{}) + require.True(t, ok, "reviewSummary should be an object") + + // With includeExtended: false and low prices, should be success + reviewTypename, ok := reviewSummary["__typename"].(string) + require.True(t, ok, "reviewSummary __typename should be present") + require.Equal(t, "ActionSuccess", reviewTypename) + + require.Contains(t, reviewSummary, "message") + require.Contains(t, reviewSummary, "timestamp") + + message, ok := reviewSummary["message"].(string) + require.True(t, ok, "message should be a string") + require.Contains(t, message, "positive reviews") + + timestamp, ok := reviewSummary["timestamp"].(string) + require.True(t, ok, "timestamp should be a string") + require.NotEmpty(t, timestamp) + } + }, + validateError: func(t *testing.T, errorData []graphqlError) { + require.Empty(t, errorData) + }, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + // Parse the GraphQL schema + schemaDoc := grpctest.MustGraphQLSchema(t) + + // Parse the GraphQL query + queryDoc, report := astparser.ParseGraphqlDocumentString(tc.query) + if report.HasErrors() { + t.Fatalf("failed to parse query: %s", report.Error()) + } + + compiler, err := NewProtoCompiler(grpctest.MustProtoSchema(t), testMapping()) + if err != nil { + t.Fatalf("failed to compile proto: %v", err) + } + + // Create the datasource + ds, err := NewDataSource(conn, DataSourceConfig{ + Operation: &queryDoc, + Definition: &schemaDoc, + SubgraphName: "Products", + Mapping: testMapping(), + Compiler: compiler, + FederationConfigs: tc.federationConfigs, + }) + require.NoError(t, err) + + // Execute the query through our datasource + output := new(bytes.Buffer) + input := fmt.Sprintf(`{"query":%q,"body":%s}`, tc.query, tc.vars) + err = ds.Load(context.Background(), []byte(input), output) + require.NoError(t, err) + + // Parse the response + var resp graphqlResponse + + err = json.Unmarshal(output.Bytes(), &resp) + require.NoError(t, err, "Failed to unmarshal response") + + tc.validate(t, resp.Data) + tc.validateError(t, resp.Errors) + }) + } +} + func Test_Datasource_Load_WithFieldResolvers(t *testing.T) { conn, cleanup := setupTestGRPCServer(t) t.Cleanup(cleanup) @@ -3898,6 +4199,253 @@ func Test_Datasource_Load_WithFieldResolvers(t *testing.T) { require.Empty(t, errData) }, }, + { + name: "Query with field resolvers and Interface type", + query: "query CategoriesWithInterfaceType($includeVolume: Boolean!) { categories { kind mascot(includeVolume: $includeVolume) { ... on Cat { name } ... on Dog { name } } } }", + vars: `{"variables":{"includeVolume":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.NotEmpty(t, categories, "categories should not be empty") + + for _, category := range categories { + category, ok := category.(map[string]interface{}) + require.True(t, ok, "category should be an object") + require.NotEmpty(t, category["kind"]) + if category["kind"] == "OTHER" { + require.Empty(t, category["mascot"]) + continue + } + + require.NotEmpty(t, category["mascot"]) + mascot, ok := category["mascot"].(map[string]interface{}) + require.True(t, ok, "mascot should be an object") + require.NotEmpty(t, mascot["name"]) + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with field resolvers and Union type", + query: "query CategoriesWithUnionType($checkHealth: Boolean!) { categories { id name categoryStatus(checkHealth: $checkHealth) { ... on ActionSuccess { message timestamp } ... on ActionError { message code } } } }", + vars: `{"variables":{"checkHealth":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.NotEmpty(t, categories, "categories should not be empty") + require.Len(t, categories, 4, "Should return 4 categories") + + // Based on mockservice.go implementation: + // - If checkHealth && i%3 == 0, returns ActionError + // - Otherwise, returns ActionSuccess + for i, category := range categories { + category, ok := category.(map[string]interface{}) + require.True(t, ok, "category should be an object") + require.NotEmpty(t, category["id"]) + require.NotEmpty(t, category["name"]) + require.NotEmpty(t, category["categoryStatus"]) + + categoryStatus, ok := category["categoryStatus"].(map[string]interface{}) + require.True(t, ok, "categoryStatus should be an object") + + if i%3 == 0 { + // Should be ActionError + require.NotEmpty(t, categoryStatus["message"], "ActionError should have message") + require.NotEmpty(t, categoryStatus["code"], "ActionError should have code") + require.Empty(t, categoryStatus["timestamp"], "ActionError should not have timestamp") + require.Contains(t, categoryStatus["message"], "Health check failed", "ActionError message should contain 'Health check failed'") + require.Equal(t, "HEALTH_CHECK_FAILED", categoryStatus["code"], "ActionError code should be HEALTH_CHECK_FAILED") + } else { + // Should be ActionSuccess + require.NotEmpty(t, categoryStatus["message"], "ActionSuccess should have message") + require.NotEmpty(t, categoryStatus["timestamp"], "ActionSuccess should have timestamp") + require.Empty(t, categoryStatus["code"], "ActionSuccess should not have code") + require.Contains(t, categoryStatus["message"], "is healthy", "ActionSuccess message should contain 'is healthy'") + require.Equal(t, "2024-01-01T00:00:00Z", categoryStatus["timestamp"], "ActionSuccess timestamp should match") + } + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with nested field resolver returning interface type", + query: "query TestContainersWithInterface($includeExtended: Boolean!) { testContainers { id name details(includeExtended: $includeExtended) { id summary pet { ... on Cat { name meowVolume } ... on Dog { name barkVolume } } } } }", + vars: `{"variables":{"includeExtended":false}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + containers, ok := data["testContainers"].([]interface{}) + require.True(t, ok, "testContainers should be an array") + require.NotEmpty(t, containers, "testContainers should not be empty") + require.Len(t, containers, 3, "Should return 3 test containers") + + // Based on mockservice.go implementation: + // - Even indices (0, 2) return Cat + // - Odd indices (1) return Dog + for i, container := range containers { + container, ok := container.(map[string]interface{}) + require.True(t, ok, "container should be an object") + require.NotEmpty(t, container["id"]) + require.NotEmpty(t, container["name"]) + require.NotEmpty(t, container["details"]) + + details, ok := container["details"].(map[string]interface{}) + require.True(t, ok, "details should be an object") + require.NotEmpty(t, details["id"]) + require.NotEmpty(t, details["summary"]) + require.NotEmpty(t, details["pet"]) + + pet, ok := details["pet"].(map[string]interface{}) + require.True(t, ok, "pet should be an object") + require.NotEmpty(t, pet["name"]) + + if i%2 == 0 { + // Should be Cat + require.NotEmpty(t, pet["meowVolume"], "Cat should have meowVolume") + require.Empty(t, pet["barkVolume"], "Cat should not have barkVolume") + require.Contains(t, pet["name"], "TestCat", "Cat name should contain 'TestCat'") + } else { + // Should be Dog + require.NotEmpty(t, pet["barkVolume"], "Dog should have barkVolume") + require.Empty(t, pet["meowVolume"], "Dog should not have meowVolume") + require.Contains(t, pet["name"], "TestDog", "Dog name should contain 'TestDog'") + } + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with nested field resolver returning union type", + query: "query TestContainersWithUnion($includeExtended: Boolean!) { testContainers { id name details(includeExtended: $includeExtended) { id summary status { ... on ActionSuccess { message timestamp } ... on ActionError { message code } } } } }", + vars: `{"variables":{"includeExtended":true}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + containers, ok := data["testContainers"].([]interface{}) + require.True(t, ok, "testContainers should be an array") + require.NotEmpty(t, containers, "testContainers should not be empty") + require.Len(t, containers, 3, "Should return 3 test containers") + + // Based on mockservice.go implementation: + // - When includeExtended=true && i%3 == 0, returns ActionError + // - Otherwise, returns ActionSuccess + for i, container := range containers { + container, ok := container.(map[string]interface{}) + require.True(t, ok, "container should be an object") + require.NotEmpty(t, container["id"]) + require.NotEmpty(t, container["name"]) + require.NotEmpty(t, container["details"]) + + details, ok := container["details"].(map[string]interface{}) + require.True(t, ok, "details should be an object") + require.NotEmpty(t, details["id"]) + require.NotEmpty(t, details["summary"]) + require.Contains(t, details["summary"], "Extended summary", "Summary should contain 'Extended summary'") + require.NotEmpty(t, details["status"]) + + status, ok := details["status"].(map[string]interface{}) + require.True(t, ok, "status should be an object") + + if i%3 == 0 { + // Should be ActionError + require.NotEmpty(t, status["message"], "ActionError should have message") + require.NotEmpty(t, status["code"], "ActionError should have code") + require.Empty(t, status["timestamp"], "ActionError should not have timestamp") + require.Contains(t, status["message"], "Extended check failed", "ActionError message should contain 'Extended check failed'") + require.Equal(t, "EXTENDED_CHECK_FAILED", status["code"], "ActionError code should be EXTENDED_CHECK_FAILED") + } else { + // Should be ActionSuccess + require.NotEmpty(t, status["message"], "ActionSuccess should have message") + require.NotEmpty(t, status["timestamp"], "ActionSuccess should have timestamp") + require.Empty(t, status["code"], "ActionSuccess should not have code") + require.Contains(t, status["message"], "details loaded successfully", "ActionSuccess message should contain 'details loaded successfully'") + require.Equal(t, "2024-01-01T12:00:00Z", status["timestamp"], "ActionSuccess timestamp should match") + } + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, + { + name: "Query with nested field resolver returning both interface and union types", + query: "query TestContainersWithBoth($includeExtended: Boolean!) { testContainers { id name details(includeExtended: $includeExtended) { id summary pet { ... on Cat { name meowVolume } ... on Dog { name barkVolume } } status { ... on ActionSuccess { message timestamp } ... on ActionError { message code } } } } }", + vars: `{"variables":{"includeExtended":true}}`, + validate: func(t *testing.T, data map[string]interface{}) { + require.NotEmpty(t, data) + + containers, ok := data["testContainers"].([]interface{}) + require.True(t, ok, "testContainers should be an array") + require.NotEmpty(t, containers, "testContainers should not be empty") + require.Len(t, containers, 3, "Should return 3 test containers") + + // Validate both pet (interface) and status (union) fields + for i, container := range containers { + container, ok := container.(map[string]interface{}) + require.True(t, ok, "container should be an object") + require.NotEmpty(t, container["id"]) + require.NotEmpty(t, container["name"]) + require.NotEmpty(t, container["details"]) + + details, ok := container["details"].(map[string]interface{}) + require.True(t, ok, "details should be an object") + require.NotEmpty(t, details["id"]) + require.NotEmpty(t, details["summary"]) + require.NotEmpty(t, details["pet"]) + require.NotEmpty(t, details["status"]) + + // Validate pet (Animal interface) + pet, ok := details["pet"].(map[string]interface{}) + require.True(t, ok, "pet should be an object") + require.NotEmpty(t, pet["name"]) + + if i%2 == 0 { + // Should be Cat + require.NotEmpty(t, pet["meowVolume"], "Cat should have meowVolume") + require.Empty(t, pet["barkVolume"], "Cat should not have barkVolume") + require.Contains(t, pet["name"], "TestCat", "Cat name should contain 'TestCat'") + } else { + // Should be Dog + require.NotEmpty(t, pet["barkVolume"], "Dog should have barkVolume") + require.Empty(t, pet["meowVolume"], "Dog should not have meowVolume") + require.Contains(t, pet["name"], "TestDog", "Dog name should contain 'TestDog'") + } + + // Validate status (ActionResult union) + status, ok := details["status"].(map[string]interface{}) + require.True(t, ok, "status should be an object") + + if i%3 == 0 { + // Should be ActionError + require.NotEmpty(t, status["message"], "ActionError should have message") + require.NotEmpty(t, status["code"], "ActionError should have code") + require.Empty(t, status["timestamp"], "ActionError should not have timestamp") + require.Contains(t, status["message"], "Extended check failed", "ActionError message should contain 'Extended check failed'") + require.Equal(t, "EXTENDED_CHECK_FAILED", status["code"], "ActionError code should be EXTENDED_CHECK_FAILED") + } else { + // Should be ActionSuccess + require.NotEmpty(t, status["message"], "ActionSuccess should have message") + require.NotEmpty(t, status["timestamp"], "ActionSuccess should have timestamp") + require.Empty(t, status["code"], "ActionSuccess should not have code") + require.Contains(t, status["message"], "details loaded successfully", "ActionSuccess message should contain 'details loaded successfully'") + require.Equal(t, "2024-01-01T12:00:00Z", status["timestamp"], "ActionSuccess timestamp should match") + } + } + }, + validateError: func(t *testing.T, errData []graphqlError) { + require.Empty(t, errData) + }, + }, } for _, tc := range testCases { 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 148cd51dc..aabc3e10e 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go +++ b/v2/pkg/engine/datasource/grpc_datasource/mapping_test_helper.go @@ -154,6 +154,16 @@ func testMapping() *GRPCMapping { Request: "QueryBulkSearchBlogPostsRequest", Response: "QueryBulkSearchBlogPostsResponse", }, + "testContainer": { + RPC: "QueryTestContainer", + Request: "QueryTestContainerRequest", + Response: "QueryTestContainerResponse", + }, + "testContainers": { + RPC: "QueryTestContainers", + Request: "QueryTestContainersRequest", + Response: "QueryTestContainersResponse", + }, }, MutationRPCs: RPCConfigMap[RPCConfig]{ "createUser": { @@ -253,6 +263,41 @@ func testMapping() *GRPCMapping { Request: "ResolveCategoryCategoryMetricsRequest", Response: "ResolveCategoryCategoryMetricsResponse", }, + "mascot": { + FieldMappingData: FieldMapData{ + TargetName: "mascot", + ArgumentMappings: FieldArgumentMap{ + "includeVolume": "include_volume", + }, + }, + RPC: "ResolveCategoryMascot", + Request: "ResolveCategoryMascotRequest", + Response: "ResolveCategoryMascotResponse", + }, + "categoryStatus": { + FieldMappingData: FieldMapData{ + TargetName: "category_status", + ArgumentMappings: FieldArgumentMap{ + "checkHealth": "check_health", + }, + }, + RPC: "ResolveCategoryCategoryStatus", + Request: "ResolveCategoryCategoryStatusRequest", + Response: "ResolveCategoryCategoryStatusResponse", + }, + }, + "CategoryMetrics": { + "normalizedScore": { + FieldMappingData: FieldMapData{ + TargetName: "normalized_score", + ArgumentMappings: FieldArgumentMap{ + "baseline": "baseline", + }, + }, + RPC: "ResolveCategoryMetricsNormalizedScore", + Request: "ResolveCategoryMetricsNormalizedScoreRequest", + Response: "ResolveCategoryMetricsNormalizedScoreResponse", + }, }, "Product": { "shippingEstimate": { @@ -277,6 +322,39 @@ func testMapping() *GRPCMapping { Request: "ResolveProductRecommendedCategoryRequest", Response: "ResolveProductRecommendedCategoryResponse", }, + "mascotRecommendation": { + FieldMappingData: FieldMapData{ + TargetName: "mascot_recommendation", + ArgumentMappings: FieldArgumentMap{ + "includeDetails": "include_details", + }, + }, + RPC: "ResolveProductMascotRecommendation", + Request: "ResolveProductMascotRecommendationRequest", + Response: "ResolveProductMascotRecommendationResponse", + }, + "stockStatus": { + FieldMappingData: FieldMapData{ + TargetName: "stock_status", + ArgumentMappings: FieldArgumentMap{ + "checkAvailability": "check_availability", + }, + }, + RPC: "ResolveProductStockStatus", + Request: "ResolveProductStockStatusRequest", + Response: "ResolveProductStockStatusResponse", + }, + "productDetails": { + FieldMappingData: FieldMapData{ + TargetName: "product_details", + ArgumentMappings: FieldArgumentMap{ + "includeExtended": "include_extended", + }, + }, + RPC: "ResolveProductProductDetails", + Request: "ResolveProductProductDetailsRequest", + Response: "ResolveProductProductDetailsResponse", + }, }, "Subcategory": { "itemCount": { @@ -291,6 +369,19 @@ func testMapping() *GRPCMapping { Response: "ResolveSubcategoryItemCountResponse", }, }, + "TestContainer": { + "details": { + FieldMappingData: FieldMapData{ + TargetName: "details", + ArgumentMappings: FieldArgumentMap{ + "includeExtended": "include_extended", + }, + }, + RPC: "ResolveTestContainerDetails", + Request: "ResolveTestContainerDetailsRequest", + Response: "ResolveTestContainerDetailsResponse", + }, + }, }, EntityRPCs: map[string][]EntityRPCConfig{ "Product": { @@ -481,6 +572,15 @@ func testMapping() *GRPCMapping { "filters": "filters", }, }, + "testContainer": { + TargetName: "test_container", + ArgumentMappings: FieldArgumentMap{ + "id": "id", + }, + }, + "testContainers": { + TargetName: "test_containers", + }, }, "Mutation": { "createUser": { @@ -581,6 +681,38 @@ func testMapping() *GRPCMapping { "maxPrice": "max_price", }, }, + "mascotRecommendation": { + TargetName: "mascot_recommendation", + ArgumentMappings: FieldArgumentMap{ + "includeDetails": "include_details", + }, + }, + "stockStatus": { + TargetName: "stock_status", + ArgumentMappings: FieldArgumentMap{ + "checkAvailability": "check_availability", + }, + }, + "productDetails": { + TargetName: "product_details", + ArgumentMappings: FieldArgumentMap{ + "includeExtended": "include_extended", + }, + }, + }, + "ProductDetails": { + "id": { + TargetName: "id", + }, + "description": { + TargetName: "description", + }, + "reviewSummary": { + TargetName: "review_summary", + }, + "recommendedPet": { + TargetName: "recommended_pet", + }, }, "Storage": { "id": { @@ -796,6 +928,18 @@ func testMapping() *GRPCMapping { "metricType": "metric_type", }, }, + "mascot": { + TargetName: "mascot", + ArgumentMappings: FieldArgumentMap{ + "includeVolume": "include_volume", + }, + }, + "categoryStatus": { + TargetName: "category_status", + ArgumentMappings: FieldArgumentMap{ + "checkHealth": "check_health", + }, + }, }, "Subcategory": { "id": { @@ -833,6 +977,15 @@ func testMapping() *GRPCMapping { "categoryId": { TargetName: "category_id", }, + "normalizedScore": { + TargetName: "normalized_score", + ArgumentMappings: FieldArgumentMap{ + "baseline": "baseline", + }, + }, + "relatedCategory": { + TargetName: "related_category", + }, }, "Cat": { "id": { @@ -878,6 +1031,37 @@ func testMapping() *GRPCMapping { TargetName: "code", }, }, + "TestContainer": { + "id": { + TargetName: "id", + }, + "name": { + TargetName: "name", + }, + "description": { + TargetName: "description", + }, + "details": { + TargetName: "details", + ArgumentMappings: FieldArgumentMap{ + "includeExtended": "include_extended", + }, + }, + }, + "TestDetails": { + "id": { + TargetName: "id", + }, + "summary": { + TargetName: "summary", + }, + "pet": { + TargetName: "pet", + }, + "status": { + TargetName: "status", + }, + }, "SearchInput": { "query": { TargetName: "query", @@ -1224,4 +1408,5 @@ func testMapping() *GRPCMapping { }, }, } + } diff --git a/v2/pkg/engine/datasource/grpc_datasource/required_fields_visitor.go b/v2/pkg/engine/datasource/grpc_datasource/required_fields_visitor.go index c78f4ea6a..42c132ec2 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/required_fields_visitor.go +++ b/v2/pkg/engine/datasource/grpc_datasource/required_fields_visitor.go @@ -7,9 +7,15 @@ import ( "github.com/wundergraph/graphql-go-tools/v2/pkg/ast" "github.com/wundergraph/graphql-go-tools/v2/pkg/astvisitor" "github.com/wundergraph/graphql-go-tools/v2/pkg/engine/plan" - "github.com/wundergraph/graphql-go-tools/v2/pkg/operationreport" ) +type requiredFieldVisitorConfig struct { + // includeMemberType indicates if the member type should be included in the message. + includeMemberType bool + // skipFieldResolvers indicates if the field resolvers should be skipped. + skipFieldResolvers bool +} + // requiredFieldsVisitor is a visitor that visits the required fields of a message. type requiredFieldsVisitor struct { operation *ast.Document @@ -22,6 +28,8 @@ type requiredFieldsVisitor struct { planCtx *rpcPlanningContext messageAncestors []*RPCMessage + + skipFieldResolvers bool } // newRequiredFieldsVisitor creates a new requiredFieldsVisitor. @@ -42,20 +50,30 @@ func newRequiredFieldsVisitor(walker *astvisitor.Walker, message *RPCMessage, pl return visitor } -// visitRequiredFields visits the required fields of a message. +// visitWithDefaults visits the required fields of a message. // It creates a new document with the required fields and walks it. // To achieve that we create a fragment with the required fields and walk it. -func (r *requiredFieldsVisitor) visitRequiredFields(definition *ast.Document, typeName, requiredFields string) error { - return r.visitWithMemberTypes(definition, typeName, requiredFields, []string{typeName}) +func (r *requiredFieldsVisitor) visitWithDefaults(definition *ast.Document, typeName, requiredFields string) error { + return r.visit(definition, typeName, requiredFields, requiredFieldVisitorConfig{ + includeMemberType: true, + skipFieldResolvers: false, + }) } -func (r *requiredFieldsVisitor) visitWithMemberTypes(definition *ast.Document, typeName, requiredFields string, memberTypes []string) error { +// visit visits the required fields of a message. +// The function can be provided with options to customize the visitor. +func (r *requiredFieldsVisitor) visit(definition *ast.Document, typeName, requiredFields string, options requiredFieldVisitorConfig) error { doc, report := plan.RequiredFieldsFragment(typeName, requiredFields, false) if report.HasErrors() { return report } - r.message.MemberTypes = memberTypes + if options.includeMemberType { + r.message.MemberTypes = []string{typeName} + } + + r.skipFieldResolvers = options.skipFieldResolvers + r.walker.Walk(doc, definition, report) if report.HasErrors() { return report @@ -124,9 +142,12 @@ func (r *requiredFieldsVisitor) EnterField(ref int) { fd, ok := r.walker.FieldDefinition(ref) if !ok { - r.walker.Report.AddExternalError(operationreport.ExternalError{ - Message: fmt.Sprintf("Field %s not found in definition %s", fieldName, r.walker.EnclosingTypeDefinition.NameString(r.definition)), - }) + r.walker.StopWithInternalErr(fmt.Errorf("RequiredFieldsVisitor: field definition not found for field %s", fieldName)) + return + } + + if r.planCtx.isFieldResolver(ref, r.walker.InRootField()) && r.skipFieldResolvers { + r.walker.SkipNode() return } diff --git a/v2/pkg/engine/datasource/grpc_datasource/util.go b/v2/pkg/engine/datasource/grpc_datasource/util.go index 1a6a1f55d..48dc37d44 100644 --- a/v2/pkg/engine/datasource/grpc_datasource/util.go +++ b/v2/pkg/engine/datasource/grpc_datasource/util.go @@ -8,3 +8,42 @@ func initializeSlice[T any](len int, zero T) []T { } return s } + +// stack is a generic LIFO (Last In First Out) data structure that stores elements of type T. +type stack[T any] []T + +// newStack creates and returns a new empty stack for elements of type T. +func newStack[T any](size int) stack[T] { + return make(stack[T], 0, size) +} + +// push adds a new element to the top of the stack. +func (a *stack[T]) push(value T) { + *a = append(*a, value) +} + +// pop removes the top element from the stack. +// If the stack is empty, this operation is a no-op. +func (a *stack[T]) pop() { + if a.len() == 0 { + return + } + + *a = (*a)[:len(*a)-1] +} + +// peek returns the top element of the stack without removing it. +// Note: This function will panic if called on an empty stack. +func (a *stack[T]) peek() T { + return (*a)[len(*a)-1] +} + +// len returns the number of elements currently in the stack. +func (a *stack[T]) len() int { + return len(*a) +} + +// capacity returns the capacity of the stack. +func (a *stack[T]) capacity() int { + return cap(*a) +} diff --git a/v2/pkg/engine/datasource/grpc_datasource/util_test.go b/v2/pkg/engine/datasource/grpc_datasource/util_test.go new file mode 100644 index 000000000..6257b0dfe --- /dev/null +++ b/v2/pkg/engine/datasource/grpc_datasource/util_test.go @@ -0,0 +1,220 @@ +package grpcdatasource + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestStack(t *testing.T) { + t.Run("basic push pop and peek operations", func(t *testing.T) { + s := newStack[int](10) + s.push(1) + s.push(2) + s.push(3) + require.Equal(t, 10, s.capacity()) + require.Equal(t, 3, s.len()) + s.pop() + require.Equal(t, 2, s.len()) + require.Equal(t, 2, s.peek()) + require.Equal(t, 2, s.len()) + }) + + t.Run("empty stack", func(t *testing.T) { + s := newStack[int](5) + require.Equal(t, 0, s.len()) + require.Equal(t, 5, s.capacity()) + + // Pop on empty stack should not panic (documented as no-op) + s.pop() + require.Equal(t, 0, s.len()) + + // Peek on empty stack should panic (documented behavior) + require.Panics(t, func() { + s.peek() + }) + }) + + t.Run("push and pop to empty", func(t *testing.T) { + s := newStack[int](5) + s.push(10) + s.push(20) + s.push(30) + require.Equal(t, 3, s.len()) + require.Equal(t, 30, s.peek()) + + s.pop() + require.Equal(t, 2, s.len()) + require.Equal(t, 20, s.peek()) + + s.pop() + require.Equal(t, 1, s.len()) + require.Equal(t, 10, s.peek()) + + s.pop() + require.Equal(t, 0, s.len()) + + // After popping all elements, peek should panic + require.Panics(t, func() { + s.peek() + }) + }) + + t.Run("push after pop", func(t *testing.T) { + s := newStack[int](10) + s.push(1) + s.push(2) + s.push(3) + require.Equal(t, 3, s.len()) + + s.pop() + require.Equal(t, 2, s.len()) + + s.push(4) + require.Equal(t, 3, s.len()) + require.Equal(t, 4, s.peek()) + }) + + t.Run("fill to capacity and beyond", func(t *testing.T) { + s := newStack[int](3) + s.push(1) + s.push(2) + s.push(3) + require.Equal(t, 3, s.len()) + require.Equal(t, 3, s.capacity()) + + // Push beyond initial capacity (should grow) + s.push(4) + require.Equal(t, 4, s.len()) + require.Greater(t, s.capacity(), 3) + require.Equal(t, 4, s.peek()) + }) + + t.Run("LIFO order verification", func(t *testing.T) { + s := newStack[int](10) + for i := 1; i <= 5; i++ { + s.push(i) + } + + // Verify LIFO order + require.Equal(t, 5, s.peek()) + s.pop() + require.Equal(t, 4, s.peek()) + s.pop() + require.Equal(t, 3, s.peek()) + s.pop() + require.Equal(t, 2, s.peek()) + s.pop() + require.Equal(t, 1, s.peek()) + s.pop() + require.Equal(t, 0, s.len()) + }) + + t.Run("peek does not modify stack", func(t *testing.T) { + s := newStack[int](5) + s.push(100) + s.push(200) + + // Multiple peeks should return same value and not change length + for i := 0; i < 5; i++ { + require.Equal(t, 200, s.peek()) + require.Equal(t, 2, s.len()) + } + }) + + t.Run("stack with string type", func(t *testing.T) { + s := newStack[string](5) + s.push("hello") + s.push("world") + s.push("test") + + require.Equal(t, 3, s.len()) + require.Equal(t, "test", s.peek()) + + s.pop() + require.Equal(t, "world", s.peek()) + + s.pop() + require.Equal(t, "hello", s.peek()) + }) + + t.Run("stack with struct type", func(t *testing.T) { + type testStruct struct { + id int + name string + } + + s := newStack[testStruct](5) + s.push(testStruct{id: 1, name: "first"}) + s.push(testStruct{id: 2, name: "second"}) + + require.Equal(t, 2, s.len()) + top := s.peek() + require.Equal(t, 2, top.id) + require.Equal(t, "second", top.name) + + s.pop() + top = s.peek() + require.Equal(t, 1, top.id) + require.Equal(t, "first", top.name) + }) + + t.Run("large number of operations", func(t *testing.T) { + s := newStack[int](10) + + // Push 100 items + for i := 0; i < 100; i++ { + s.push(i) + } + require.Equal(t, 100, s.len()) + require.Equal(t, 99, s.peek()) + + // Pop 50 items + for i := 0; i < 50; i++ { + s.pop() + } + require.Equal(t, 50, s.len()) + require.Equal(t, 49, s.peek()) + + // Push 25 more items + for i := 100; i < 125; i++ { + s.push(i) + } + require.Equal(t, 75, s.len()) + require.Equal(t, 124, s.peek()) + }) + + t.Run("alternating push and pop", func(t *testing.T) { + s := newStack[int](5) + + s.push(1) + require.Equal(t, 1, s.len()) + + s.pop() + require.Equal(t, 0, s.len()) + + s.push(2) + s.push(3) + require.Equal(t, 2, s.len()) + + s.pop() + require.Equal(t, 1, s.len()) + require.Equal(t, 2, s.peek()) + + s.push(4) + s.push(5) + require.Equal(t, 3, s.len()) + require.Equal(t, 5, s.peek()) + }) + + t.Run("zero capacity stack", func(t *testing.T) { + s := newStack[int](0) + require.Equal(t, 0, s.len()) + require.Equal(t, 0, s.capacity()) + + // Should still be able to push (will grow) + s.push(42) + require.Equal(t, 1, s.len()) + require.Equal(t, 42, s.peek()) + }) +} diff --git a/v2/pkg/grpctest/mapping/mapping.go b/v2/pkg/grpctest/mapping/mapping.go index 6397adc31..7f7060237 100644 --- a/v2/pkg/grpctest/mapping/mapping.go +++ b/v2/pkg/grpctest/mapping/mapping.go @@ -161,6 +161,16 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { Request: "QueryBulkSearchBlogPostsRequest", Response: "QueryBulkSearchBlogPostsResponse", }, + "testContainer": { + RPC: "QueryTestContainer", + Request: "QueryTestContainerRequest", + Response: "QueryTestContainerResponse", + }, + "testContainers": { + RPC: "QueryTestContainers", + Request: "QueryTestContainersRequest", + Response: "QueryTestContainersResponse", + }, }, MutationRPCs: grpcdatasource.RPCConfigMap[grpcdatasource.RPCConfig]{ "createUser": { @@ -260,6 +270,41 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { Request: "ResolveCategoryCategoryMetricsRequest", Response: "ResolveCategoryCategoryMetricsResponse", }, + "mascot": { + FieldMappingData: grpcdatasource.FieldMapData{ + TargetName: "mascot", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "includeVolume": "include_volume", + }, + }, + RPC: "ResolveCategoryMascot", + Request: "ResolveCategoryMascotRequest", + Response: "ResolveCategoryMascotResponse", + }, + "categoryStatus": { + FieldMappingData: grpcdatasource.FieldMapData{ + TargetName: "category_status", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "checkHealth": "check_health", + }, + }, + RPC: "ResolveCategoryCategoryStatus", + Request: "ResolveCategoryCategoryStatusRequest", + Response: "ResolveCategoryCategoryStatusResponse", + }, + }, + "CategoryMetrics": { + "normalizedScore": { + FieldMappingData: grpcdatasource.FieldMapData{ + TargetName: "normalized_score", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "baseline": "baseline", + }, + }, + RPC: "ResolveCategoryMetricsNormalizedScore", + Request: "ResolveCategoryMetricsNormalizedScoreRequest", + Response: "ResolveCategoryMetricsNormalizedScoreResponse", + }, }, "Product": { "shippingEstimate": { @@ -284,6 +329,39 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { Request: "ResolveProductRecommendedCategoryRequest", Response: "ResolveProductRecommendedCategoryResponse", }, + "mascotRecommendation": { + FieldMappingData: grpcdatasource.FieldMapData{ + TargetName: "mascot_recommendation", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "includeDetails": "include_details", + }, + }, + RPC: "ResolveProductMascotRecommendation", + Request: "ResolveProductMascotRecommendationRequest", + Response: "ResolveProductMascotRecommendationResponse", + }, + "stockStatus": { + FieldMappingData: grpcdatasource.FieldMapData{ + TargetName: "stock_status", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "checkAvailability": "check_availability", + }, + }, + RPC: "ResolveProductStockStatus", + Request: "ResolveProductStockStatusRequest", + Response: "ResolveProductStockStatusResponse", + }, + "productDetails": { + FieldMappingData: grpcdatasource.FieldMapData{ + TargetName: "product_details", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "includeExtended": "include_extended", + }, + }, + RPC: "ResolveProductProductDetails", + Request: "ResolveProductProductDetailsRequest", + Response: "ResolveProductProductDetailsResponse", + }, }, "Subcategory": { "itemCount": { @@ -298,6 +376,19 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { Response: "ResolveSubcategoryItemCountResponse", }, }, + "TestContainer": { + "details": { + FieldMappingData: grpcdatasource.FieldMapData{ + TargetName: "details", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "includeExtended": "include_extended", + }, + }, + RPC: "ResolveTestContainerDetails", + Request: "ResolveTestContainerDetailsRequest", + Response: "ResolveTestContainerDetailsResponse", + }, + }, }, EntityRPCs: map[string][]grpcdatasource.EntityRPCConfig{ "Product": { @@ -488,6 +579,15 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { "filters": "filters", }, }, + "testContainer": { + TargetName: "test_container", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "id": "id", + }, + }, + "testContainers": { + TargetName: "test_containers", + }, }, "Mutation": { "createUser": { @@ -588,6 +688,38 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { "maxPrice": "max_price", }, }, + "mascotRecommendation": { + TargetName: "mascot_recommendation", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "includeDetails": "include_details", + }, + }, + "stockStatus": { + TargetName: "stock_status", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "checkAvailability": "check_availability", + }, + }, + "productDetails": { + TargetName: "product_details", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "includeExtended": "include_extended", + }, + }, + }, + "ProductDetails": { + "id": { + TargetName: "id", + }, + "description": { + TargetName: "description", + }, + "reviewSummary": { + TargetName: "review_summary", + }, + "recommendedPet": { + TargetName: "recommended_pet", + }, }, "Storage": { "id": { @@ -803,6 +935,18 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { "metricType": "metric_type", }, }, + "mascot": { + TargetName: "mascot", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "includeVolume": "include_volume", + }, + }, + "categoryStatus": { + TargetName: "category_status", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "checkHealth": "check_health", + }, + }, }, "Subcategory": { "id": { @@ -840,6 +984,15 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { "categoryId": { TargetName: "category_id", }, + "normalizedScore": { + TargetName: "normalized_score", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "baseline": "baseline", + }, + }, + "relatedCategory": { + TargetName: "related_category", + }, }, "Cat": { "id": { @@ -885,6 +1038,37 @@ func DefaultGRPCMapping() *grpcdatasource.GRPCMapping { TargetName: "code", }, }, + "TestContainer": { + "id": { + TargetName: "id", + }, + "name": { + TargetName: "name", + }, + "description": { + TargetName: "description", + }, + "details": { + TargetName: "details", + ArgumentMappings: grpcdatasource.FieldArgumentMap{ + "includeExtended": "include_extended", + }, + }, + }, + "TestDetails": { + "id": { + TargetName: "id", + }, + "summary": { + TargetName: "summary", + }, + "pet": { + TargetName: "pet", + }, + "status": { + TargetName: "status", + }, + }, "SearchInput": { "query": { TargetName: "query", diff --git a/v2/pkg/grpctest/mockservice.go b/v2/pkg/grpctest/mockservice.go index 3a50d1c1f..99c19bad8 100644 --- a/v2/pkg/grpctest/mockservice.go +++ b/v2/pkg/grpctest/mockservice.go @@ -20,6 +20,426 @@ type MockService struct { productv1.UnimplementedProductServiceServer } +// ResolveProductMascotRecommendation implements productv1.ProductServiceServer. +func (s *MockService) ResolveProductMascotRecommendation(_ context.Context, req *productv1.ResolveProductMascotRecommendationRequest) (*productv1.ResolveProductMascotRecommendationResponse, error) { + results := make([]*productv1.ResolveProductMascotRecommendationResult, 0, len(req.GetContext())) + + includeDetails := false + if req.GetFieldArgs() != nil { + includeDetails = req.GetFieldArgs().GetIncludeDetails() + } + + for i, ctx := range req.GetContext() { + // Alternate between Cat and Dog based on index + var animal *productv1.Animal + if i%2 == 0 { + volume := int32(5) + if includeDetails { + volume = int32((i + 1) * 8) + } + animal = &productv1.Animal{ + Instance: &productv1.Animal_Cat{ + Cat: &productv1.Cat{ + Id: fmt.Sprintf("mascot-cat-%s", ctx.GetId()), + Name: fmt.Sprintf("MascotCat for %s", ctx.GetName()), + Kind: "Cat", + MeowVolume: volume, + }, + }, + } + } else { + volume := int32(7) + if includeDetails { + volume = int32((i + 1) * 10) + } + animal = &productv1.Animal{ + Instance: &productv1.Animal_Dog{ + Dog: &productv1.Dog{ + Id: fmt.Sprintf("mascot-dog-%s", ctx.GetId()), + Name: fmt.Sprintf("MascotDog for %s", ctx.GetName()), + Kind: "Dog", + BarkVolume: volume, + }, + }, + } + } + + results = append(results, &productv1.ResolveProductMascotRecommendationResult{ + MascotRecommendation: animal, + }) + } + + return &productv1.ResolveProductMascotRecommendationResponse{ + Result: results, + }, nil +} + +// ResolveProductProductDetails implements productv1.ProductServiceServer. +func (s *MockService) ResolveProductProductDetails(_ context.Context, req *productv1.ResolveProductProductDetailsRequest) (*productv1.ResolveProductProductDetailsResponse, error) { + results := make([]*productv1.ResolveProductProductDetailsResult, 0, len(req.GetContext())) + + includeExtended := false + if req.GetFieldArgs() != nil { + includeExtended = req.GetFieldArgs().GetIncludeExtended() + } + + for i, ctx := range req.GetContext() { + // Create recommended pet (alternate between Cat and Dog) + var pet *productv1.Animal + if i%2 == 0 { + pet = &productv1.Animal{ + Instance: &productv1.Animal_Cat{ + Cat: &productv1.Cat{ + Id: fmt.Sprintf("details-cat-%s", ctx.GetId()), + Name: fmt.Sprintf("RecommendedCat for %s", ctx.GetName()), + Kind: "Cat", + MeowVolume: int32((i + 1) * 6), + }, + }, + } + } else { + pet = &productv1.Animal{ + Instance: &productv1.Animal_Dog{ + Dog: &productv1.Dog{ + Id: fmt.Sprintf("details-dog-%s", ctx.GetId()), + Name: fmt.Sprintf("RecommendedDog for %s", ctx.GetName()), + Kind: "Dog", + BarkVolume: int32((i + 1) * 9), + }, + }, + } + } + + // Create review summary (alternate between success and error based on price and extended flag) + var reviewSummary *productv1.ActionResult + if includeExtended && ctx.GetPrice() > 500 { + reviewSummary = &productv1.ActionResult{ + Value: &productv1.ActionResult_ActionError{ + ActionError: &productv1.ActionError{ + Message: fmt.Sprintf("Product %s has negative reviews", ctx.GetName()), + Code: "NEGATIVE_REVIEWS", + }, + }, + } + } else { + reviewSummary = &productv1.ActionResult{ + Value: &productv1.ActionResult_ActionSuccess{ + ActionSuccess: &productv1.ActionSuccess{ + Message: fmt.Sprintf("Product %s has positive reviews", ctx.GetName()), + Timestamp: "2024-01-01T15:00:00Z", + }, + }, + } + } + + description := fmt.Sprintf("Standard details for %s", ctx.GetName()) + if includeExtended { + description = fmt.Sprintf("Extended details for %s with comprehensive information", ctx.GetName()) + } + + results = append(results, &productv1.ResolveProductProductDetailsResult{ + ProductDetails: &productv1.ProductDetails{ + Id: fmt.Sprintf("details-%s-%d", ctx.GetId(), i), + Description: description, + ReviewSummary: reviewSummary, + RecommendedPet: pet, + }, + }) + } + + return &productv1.ResolveProductProductDetailsResponse{ + Result: results, + }, nil +} + +// ResolveProductStockStatus implements productv1.ProductServiceServer. +func (s *MockService) ResolveProductStockStatus(_ context.Context, req *productv1.ResolveProductStockStatusRequest) (*productv1.ResolveProductStockStatusResponse, error) { + results := make([]*productv1.ResolveProductStockStatusResult, 0, len(req.GetContext())) + + checkAvailability := false + if req.GetFieldArgs() != nil { + checkAvailability = req.GetFieldArgs().GetCheckAvailability() + } + + for i, ctx := range req.GetContext() { + var stockStatus *productv1.ActionResult + + // If checking availability and price is high, return out of stock error + if checkAvailability && ctx.GetPrice() > 300 && i%2 == 0 { + stockStatus = &productv1.ActionResult{ + Value: &productv1.ActionResult_ActionError{ + ActionError: &productv1.ActionError{ + Message: fmt.Sprintf("Product %s is currently out of stock", ctx.GetName()), + Code: "OUT_OF_STOCK", + }, + }, + } + } else { + stockStatus = &productv1.ActionResult{ + Value: &productv1.ActionResult_ActionSuccess{ + ActionSuccess: &productv1.ActionSuccess{ + Message: fmt.Sprintf("Product %s is in stock and available", ctx.GetName()), + Timestamp: "2024-01-01T10:00:00Z", + }, + }, + } + } + + results = append(results, &productv1.ResolveProductStockStatusResult{ + StockStatus: stockStatus, + }) + } + + return &productv1.ResolveProductStockStatusResponse{ + Result: results, + }, nil +} + +// QueryTestContainer implements productv1.ProductServiceServer. +func (s *MockService) QueryTestContainer(_ context.Context, req *productv1.QueryTestContainerRequest) (*productv1.QueryTestContainerResponse, error) { + id := req.GetId() + + return &productv1.QueryTestContainerResponse{ + TestContainer: &productv1.TestContainer{ + Id: id, + Name: fmt.Sprintf("TestContainer-%s", id), + Description: &wrapperspb.StringValue{Value: fmt.Sprintf("Description for TestContainer %s", id)}, + }, + }, nil +} + +// QueryTestContainers implements productv1.ProductServiceServer. +func (s *MockService) QueryTestContainers(_ context.Context, _ *productv1.QueryTestContainersRequest) (*productv1.QueryTestContainersResponse, error) { + var containers []*productv1.TestContainer + + // Generate 3 test containers + for i := 1; i <= 3; i++ { + containers = append(containers, &productv1.TestContainer{ + Id: fmt.Sprintf("container-%d", i), + Name: fmt.Sprintf("TestContainer %d", i), + Description: &wrapperspb.StringValue{Value: fmt.Sprintf("Description for container %d", i)}, + }) + } + + return &productv1.QueryTestContainersResponse{ + TestContainers: containers, + }, nil +} + +// ResolveTestContainerDetails implements productv1.ProductServiceServer. +func (s *MockService) ResolveTestContainerDetails(_ context.Context, req *productv1.ResolveTestContainerDetailsRequest) (*productv1.ResolveTestContainerDetailsResponse, error) { + results := make([]*productv1.ResolveTestContainerDetailsResult, 0, len(req.GetContext())) + + includeExtended := false + if req.GetFieldArgs() != nil { + includeExtended = req.GetFieldArgs().GetIncludeExtended() + } + + for i, ctx := range req.GetContext() { + // Alternate between Cat and Dog for the pet field (Animal interface) + var pet *productv1.Animal + if i%2 == 0 { + pet = &productv1.Animal{ + Instance: &productv1.Animal_Cat{ + Cat: &productv1.Cat{ + Id: fmt.Sprintf("test-cat-%s", ctx.GetId()), + Name: fmt.Sprintf("TestCat-%s", ctx.GetName()), + Kind: "Cat", + MeowVolume: int32((i + 1) * 5), + }, + }, + } + } else { + pet = &productv1.Animal{ + Instance: &productv1.Animal_Dog{ + Dog: &productv1.Dog{ + Id: fmt.Sprintf("test-dog-%s", ctx.GetId()), + Name: fmt.Sprintf("TestDog-%s", ctx.GetName()), + Kind: "Dog", + BarkVolume: int32((i + 1) * 7), + }, + }, + } + } + + // Alternate between ActionSuccess and ActionError for the status field (ActionResult union) + var status *productv1.ActionResult + if includeExtended && i%3 == 0 { + // Return error status for extended mode on certain items + status = &productv1.ActionResult{ + Value: &productv1.ActionResult_ActionError{ + ActionError: &productv1.ActionError{ + Message: fmt.Sprintf("Extended check failed for %s", ctx.GetName()), + Code: "EXTENDED_CHECK_FAILED", + }, + }, + } + } else { + // Return success status + status = &productv1.ActionResult{ + Value: &productv1.ActionResult_ActionSuccess{ + ActionSuccess: &productv1.ActionSuccess{ + Message: fmt.Sprintf("TestContainer %s details loaded successfully", ctx.GetName()), + Timestamp: "2024-01-01T12:00:00Z", + }, + }, + } + } + + summary := fmt.Sprintf("Summary for %s", ctx.GetName()) + if includeExtended { + summary = fmt.Sprintf("Extended summary for %s with additional details", ctx.GetName()) + } + + results = append(results, &productv1.ResolveTestContainerDetailsResult{ + Details: &productv1.TestDetails{ + Id: fmt.Sprintf("details-%s-%d", ctx.GetId(), i), + Summary: summary, + Pet: pet, + Status: status, + }, + }) + } + + return &productv1.ResolveTestContainerDetailsResponse{ + Result: results, + }, nil +} + +// ResolveCategoryMetricsNormalizedScore implements productv1.ProductServiceServer. +func (s *MockService) ResolveCategoryMetricsNormalizedScore(_ context.Context, req *productv1.ResolveCategoryMetricsNormalizedScoreRequest) (*productv1.ResolveCategoryMetricsNormalizedScoreResponse, error) { + results := make([]*productv1.ResolveCategoryMetricsNormalizedScoreResult, 0, len(req.GetContext())) + + baseline := req.GetFieldArgs().GetBaseline() + if baseline == 0 { + baseline = 1.0 // Avoid division by zero + } + + for _, ctx := range req.GetContext() { + // Calculate normalized score: (value / baseline) * 100 + // This gives a percentage relative to the baseline + normalizedScore := (ctx.GetValue() / baseline) * 100.0 + + results = append(results, &productv1.ResolveCategoryMetricsNormalizedScoreResult{ + NormalizedScore: normalizedScore, + }) + } + + resp := &productv1.ResolveCategoryMetricsNormalizedScoreResponse{ + Result: results, + } + + return resp, nil +} + +// ResolveCategoryMascot implements productv1.ProductServiceServer. +func (s *MockService) ResolveCategoryMascot(_ context.Context, req *productv1.ResolveCategoryMascotRequest) (*productv1.ResolveCategoryMascotResponse, error) { + results := make([]*productv1.ResolveCategoryMascotResult, 0, len(req.GetContext())) + + includeVolume := false + if req.GetFieldArgs() != nil { + includeVolume = req.GetFieldArgs().GetIncludeVolume() + } + + for i, ctx := range req.GetContext() { + // Return nil for certain categories to test optional return + if ctx.GetKind() == productv1.CategoryKind_CATEGORY_KIND_OTHER { + results = append(results, &productv1.ResolveCategoryMascotResult{ + Mascot: nil, + }) + } else { + // Alternate between Cat and Dog based on category kind + var animal *productv1.Animal + if ctx.GetKind() == productv1.CategoryKind_CATEGORY_KIND_BOOK || ctx.GetKind() == productv1.CategoryKind_CATEGORY_KIND_ELECTRONICS { + volume := int32(0) + if includeVolume { + volume = int32(i*10 + 5) + } + animal = &productv1.Animal{ + Instance: &productv1.Animal_Cat{ + Cat: &productv1.Cat{ + Id: fmt.Sprintf("cat-mascot-%s", ctx.GetId()), + Name: fmt.Sprintf("Whiskers-%s", ctx.GetId()), + Kind: "Cat", + MeowVolume: volume, + }, + }, + } + } else { + volume := int32(0) + if includeVolume { + volume = int32(i*10 + 10) + } + animal = &productv1.Animal{ + Instance: &productv1.Animal_Dog{ + Dog: &productv1.Dog{ + Id: fmt.Sprintf("dog-mascot-%s", ctx.GetId()), + Name: fmt.Sprintf("Buddy-%s", ctx.GetId()), + Kind: "Dog", + BarkVolume: volume, + }, + }, + } + } + results = append(results, &productv1.ResolveCategoryMascotResult{ + Mascot: animal, + }) + } + } + + resp := &productv1.ResolveCategoryMascotResponse{ + Result: results, + } + + return resp, nil +} + +// ResolveCategoryCategoryStatus implements productv1.ProductServiceServer. +func (s *MockService) ResolveCategoryCategoryStatus(_ context.Context, req *productv1.ResolveCategoryCategoryStatusRequest) (*productv1.ResolveCategoryCategoryStatusResponse, error) { + results := make([]*productv1.ResolveCategoryCategoryStatusResult, 0, len(req.GetContext())) + + checkHealth := false + if req.GetFieldArgs() != nil { + checkHealth = req.GetFieldArgs().GetCheckHealth() + } + + for i, ctx := range req.GetContext() { + var actionResult *productv1.ActionResult + + if checkHealth && i%3 == 0 { + // Return error status for health check failures + actionResult = &productv1.ActionResult{ + Value: &productv1.ActionResult_ActionError{ + ActionError: &productv1.ActionError{ + Message: fmt.Sprintf("Health check failed for category %s", ctx.GetName()), + Code: "HEALTH_CHECK_FAILED", + }, + }, + } + } else { + // Return success status + actionResult = &productv1.ActionResult{ + Value: &productv1.ActionResult_ActionSuccess{ + ActionSuccess: &productv1.ActionSuccess{ + Message: fmt.Sprintf("Category %s is healthy", ctx.GetName()), + Timestamp: "2024-01-01T00:00:00Z", + }, + }, + } + } + + results = append(results, &productv1.ResolveCategoryCategoryStatusResult{ + CategoryStatus: actionResult, + }) + } + + resp := &productv1.ResolveCategoryCategoryStatusResponse{ + Result: results, + } + + return resp, 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 ac6ec65b2..480a1c3ea 100644 --- a/v2/pkg/grpctest/product.proto +++ b/v2/pkg/grpctest/product.proto @@ -51,16 +51,25 @@ service ProductService { rpc QueryRandomSearchResult(QueryRandomSearchResultRequest) returns (QueryRandomSearchResultResponse) {} rpc QueryRecursiveType(QueryRecursiveTypeRequest) returns (QueryRecursiveTypeResponse) {} rpc QuerySearch(QuerySearchRequest) returns (QuerySearchResponse) {} + rpc QueryTestContainer(QueryTestContainerRequest) returns (QueryTestContainerResponse) {} + rpc QueryTestContainers(QueryTestContainersRequest) returns (QueryTestContainersResponse) {} rpc QueryTypeFilterWithArguments(QueryTypeFilterWithArgumentsRequest) returns (QueryTypeFilterWithArgumentsResponse) {} rpc QueryTypeWithMultipleFilterFields(QueryTypeWithMultipleFilterFieldsRequest) returns (QueryTypeWithMultipleFilterFieldsResponse) {} rpc QueryUser(QueryUserRequest) returns (QueryUserResponse) {} rpc QueryUsers(QueryUsersRequest) returns (QueryUsersResponse) {} rpc ResolveCategoryCategoryMetrics(ResolveCategoryCategoryMetricsRequest) returns (ResolveCategoryCategoryMetricsResponse) {} + rpc ResolveCategoryCategoryStatus(ResolveCategoryCategoryStatusRequest) returns (ResolveCategoryCategoryStatusResponse) {} + rpc ResolveCategoryMascot(ResolveCategoryMascotRequest) returns (ResolveCategoryMascotResponse) {} + rpc ResolveCategoryMetricsNormalizedScore(ResolveCategoryMetricsNormalizedScoreRequest) returns (ResolveCategoryMetricsNormalizedScoreResponse) {} rpc ResolveCategoryPopularityScore(ResolveCategoryPopularityScoreRequest) returns (ResolveCategoryPopularityScoreResponse) {} rpc ResolveCategoryProductCount(ResolveCategoryProductCountRequest) returns (ResolveCategoryProductCountResponse) {} + rpc ResolveProductMascotRecommendation(ResolveProductMascotRecommendationRequest) returns (ResolveProductMascotRecommendationResponse) {} + rpc ResolveProductProductDetails(ResolveProductProductDetailsRequest) returns (ResolveProductProductDetailsResponse) {} rpc ResolveProductRecommendedCategory(ResolveProductRecommendedCategoryRequest) returns (ResolveProductRecommendedCategoryResponse) {} rpc ResolveProductShippingEstimate(ResolveProductShippingEstimateRequest) returns (ResolveProductShippingEstimateResponse) {} + rpc ResolveProductStockStatus(ResolveProductStockStatusRequest) returns (ResolveProductStockStatusResponse) {} rpc ResolveSubcategoryItemCount(ResolveSubcategoryItemCountRequest) returns (ResolveSubcategoryItemCountResponse) {} + rpc ResolveTestContainerDetails(ResolveTestContainerDetailsRequest) returns (ResolveTestContainerDetailsResponse) {} } // Wrapper message for a list of AuthorFilter. @@ -533,6 +542,21 @@ message QueryBulkSearchBlogPostsRequest { message QueryBulkSearchBlogPostsResponse { repeated BlogPost bulk_search_blog_posts = 1; } +// Request message for testContainer operation. +message QueryTestContainerRequest { + string id = 1; +} +// Response message for testContainer operation. +message QueryTestContainerResponse { + TestContainer test_container = 1; +} +// Request message for testContainers operation. +message QueryTestContainersRequest { +} +// Response message for testContainers operation. +message QueryTestContainersResponse { + repeated TestContainer test_containers = 1; +} // Request message for createUser operation. message MutationCreateUserRequest { UserInput input = 1; @@ -681,6 +705,80 @@ message ResolveProductRecommendedCategoryResponse { repeated ResolveProductRecommendedCategoryResult result = 1; } +message ResolveProductMascotRecommendationArgs { + bool include_details = 1; +} + +message ResolveProductMascotRecommendationContext { + string id = 1; + string name = 2; +} + +message ResolveProductMascotRecommendationRequest { + // context provides the resolver context for the field mascotRecommendation of type Product. + repeated ResolveProductMascotRecommendationContext context = 1; + // field_args provides the arguments for the resolver field mascotRecommendation of type Product. + ResolveProductMascotRecommendationArgs field_args = 2; +} + +message ResolveProductMascotRecommendationResult { + Animal mascot_recommendation = 1; +} + +message ResolveProductMascotRecommendationResponse { + repeated ResolveProductMascotRecommendationResult result = 1; +} + +message ResolveProductStockStatusArgs { + bool check_availability = 1; +} + +message ResolveProductStockStatusContext { + string id = 1; + string name = 2; + double price = 3; +} + +message ResolveProductStockStatusRequest { + // context provides the resolver context for the field stockStatus of type Product. + repeated ResolveProductStockStatusContext context = 1; + // field_args provides the arguments for the resolver field stockStatus of type Product. + ResolveProductStockStatusArgs field_args = 2; +} + +message ResolveProductStockStatusResult { + ActionResult stock_status = 1; +} + +message ResolveProductStockStatusResponse { + repeated ResolveProductStockStatusResult result = 1; +} + +message ResolveProductProductDetailsArgs { + bool include_extended = 1; +} + +message ResolveProductProductDetailsContext { + string id = 1; + string name = 2; + double price = 3; +} + +message ResolveProductProductDetailsRequest { + // context provides the resolver context for the field productDetails of type Product. + repeated ResolveProductProductDetailsContext context = 1; + // field_args provides the arguments for the resolver field productDetails of type Product. + ResolveProductProductDetailsArgs field_args = 2; +} + +message ResolveProductProductDetailsResult { + ProductDetails product_details = 1; +} + +message ResolveProductProductDetailsResponse { + repeated ResolveProductProductDetailsResult result = 1; +} + message ResolveCategoryProductCountArgs { ProductCountFilter filters = 1; } @@ -752,6 +850,54 @@ message ResolveCategoryCategoryMetricsResponse { repeated ResolveCategoryCategoryMetricsResult result = 1; } +message ResolveCategoryMascotArgs { + bool include_volume = 1; +} + +message ResolveCategoryMascotContext { + string id = 1; + CategoryKind kind = 2; +} + +message ResolveCategoryMascotRequest { + // context provides the resolver context for the field mascot of type Category. + repeated ResolveCategoryMascotContext context = 1; + // field_args provides the arguments for the resolver field mascot of type Category. + ResolveCategoryMascotArgs field_args = 2; +} + +message ResolveCategoryMascotResult { + Animal mascot = 1; +} + +message ResolveCategoryMascotResponse { + repeated ResolveCategoryMascotResult result = 1; +} + +message ResolveCategoryCategoryStatusArgs { + bool check_health = 1; +} + +message ResolveCategoryCategoryStatusContext { + string id = 1; + string name = 2; +} + +message ResolveCategoryCategoryStatusRequest { + // context provides the resolver context for the field categoryStatus of type Category. + repeated ResolveCategoryCategoryStatusContext context = 1; + // field_args provides the arguments for the resolver field categoryStatus of type Category. + ResolveCategoryCategoryStatusArgs field_args = 2; +} + +message ResolveCategoryCategoryStatusResult { + ActionResult category_status = 1; +} + +message ResolveCategoryCategoryStatusResponse { + repeated ResolveCategoryCategoryStatusResult result = 1; +} + message ResolveSubcategoryItemCountArgs { SubcategoryItemFilter filters = 1; } @@ -775,6 +921,55 @@ message ResolveSubcategoryItemCountResponse { repeated ResolveSubcategoryItemCountResult result = 1; } +message ResolveCategoryMetricsNormalizedScoreArgs { + double baseline = 1; +} + +message ResolveCategoryMetricsNormalizedScoreContext { + string id = 1; + string metricType = 2; + double value = 3; +} + +message ResolveCategoryMetricsNormalizedScoreRequest { + // context provides the resolver context for the field normalizedScore of type CategoryMetrics. + repeated ResolveCategoryMetricsNormalizedScoreContext context = 1; + // field_args provides the arguments for the resolver field normalizedScore of type CategoryMetrics. + ResolveCategoryMetricsNormalizedScoreArgs field_args = 2; +} + +message ResolveCategoryMetricsNormalizedScoreResult { + double normalized_score = 1; +} + +message ResolveCategoryMetricsNormalizedScoreResponse { + repeated ResolveCategoryMetricsNormalizedScoreResult result = 1; +} + +message ResolveTestContainerDetailsArgs { + bool include_extended = 1; +} + +message ResolveTestContainerDetailsContext { + string id = 1; + string name = 2; +} + +message ResolveTestContainerDetailsRequest { + // context provides the resolver context for the field details of type TestContainer. + repeated ResolveTestContainerDetailsContext context = 1; + // field_args provides the arguments for the resolver field details of type TestContainer. + ResolveTestContainerDetailsArgs field_args = 2; +} + +message ResolveTestContainerDetailsResult { + TestDetails details = 1; +} + +message ResolveTestContainerDetailsResponse { + repeated ResolveTestContainerDetailsResult result = 1; +} + message Product { string id = 1; string name = 2; @@ -946,6 +1141,12 @@ message AuthorFilter { google.protobuf.Int32Value skill_count = 3; } +message TestContainer { + string id = 1; + string name = 2; + google.protobuf.StringValue description = 3; +} + message UserInput { string name = 1; } @@ -1004,6 +1205,13 @@ message AuthorInput { ListOfListOfUserInput project_teams = 10; } +message ProductDetails { + string id = 1; + string description = 2; + ActionResult review_summary = 3; + Animal recommended_pet = 4; +} + message NestedTypeB { string id = 1; string name = 2; @@ -1052,6 +1260,7 @@ message CategoryMetrics { double value = 3; string timestamp = 4; string category_id = 5; + Category related_category = 6; } enum CategoryKind { @@ -1086,6 +1295,13 @@ message ActionError { string code = 2; } +message TestDetails { + string id = 1; + string summary = 2; + Animal pet = 3; + ActionResult status = 4; +} + message CategoryInput { string name = 1; CategoryKind kind = 2; diff --git a/v2/pkg/grpctest/productv1/product.pb.go b/v2/pkg/grpctest/productv1/product.pb.go index ed265f796..57b62207e 100644 --- a/v2/pkg/grpctest/productv1/product.pb.go +++ b/v2/pkg/grpctest/productv1/product.pb.go @@ -4086,6 +4086,178 @@ func (x *QueryBulkSearchBlogPostsResponse) GetBulkSearchBlogPosts() []*BlogPost return nil } +// Request message for testContainer operation. +type QueryTestContainerRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *QueryTestContainerRequest) Reset() { + *x = QueryTestContainerRequest{} + mi := &file_product_proto_msgTypes[89] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *QueryTestContainerRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryTestContainerRequest) ProtoMessage() {} + +func (x *QueryTestContainerRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[89] + 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 QueryTestContainerRequest.ProtoReflect.Descriptor instead. +func (*QueryTestContainerRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{89} +} + +func (x *QueryTestContainerRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +// Response message for testContainer operation. +type QueryTestContainerResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + TestContainer *TestContainer `protobuf:"bytes,1,opt,name=test_container,json=testContainer,proto3" json:"test_container,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *QueryTestContainerResponse) Reset() { + *x = QueryTestContainerResponse{} + mi := &file_product_proto_msgTypes[90] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *QueryTestContainerResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryTestContainerResponse) ProtoMessage() {} + +func (x *QueryTestContainerResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[90] + 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 QueryTestContainerResponse.ProtoReflect.Descriptor instead. +func (*QueryTestContainerResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{90} +} + +func (x *QueryTestContainerResponse) GetTestContainer() *TestContainer { + if x != nil { + return x.TestContainer + } + return nil +} + +// Request message for testContainers operation. +type QueryTestContainersRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *QueryTestContainersRequest) Reset() { + *x = QueryTestContainersRequest{} + mi := &file_product_proto_msgTypes[91] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *QueryTestContainersRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryTestContainersRequest) ProtoMessage() {} + +func (x *QueryTestContainersRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[91] + 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 QueryTestContainersRequest.ProtoReflect.Descriptor instead. +func (*QueryTestContainersRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{91} +} + +// Response message for testContainers operation. +type QueryTestContainersResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + TestContainers []*TestContainer `protobuf:"bytes,1,rep,name=test_containers,json=testContainers,proto3" json:"test_containers,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *QueryTestContainersResponse) Reset() { + *x = QueryTestContainersResponse{} + mi := &file_product_proto_msgTypes[92] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *QueryTestContainersResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryTestContainersResponse) ProtoMessage() {} + +func (x *QueryTestContainersResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[92] + 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 QueryTestContainersResponse.ProtoReflect.Descriptor instead. +func (*QueryTestContainersResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{92} +} + +func (x *QueryTestContainersResponse) GetTestContainers() []*TestContainer { + if x != nil { + return x.TestContainers + } + return nil +} + // Request message for createUser operation. type MutationCreateUserRequest struct { state protoimpl.MessageState `protogen:"open.v1"` @@ -4096,7 +4268,7 @@ type MutationCreateUserRequest struct { func (x *MutationCreateUserRequest) Reset() { *x = MutationCreateUserRequest{} - mi := &file_product_proto_msgTypes[89] + mi := &file_product_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4108,7 +4280,7 @@ func (x *MutationCreateUserRequest) String() string { func (*MutationCreateUserRequest) ProtoMessage() {} func (x *MutationCreateUserRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[89] + mi := &file_product_proto_msgTypes[93] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4121,7 +4293,7 @@ func (x *MutationCreateUserRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationCreateUserRequest.ProtoReflect.Descriptor instead. func (*MutationCreateUserRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{89} + return file_product_proto_rawDescGZIP(), []int{93} } func (x *MutationCreateUserRequest) GetInput() *UserInput { @@ -4141,7 +4313,7 @@ type MutationCreateUserResponse struct { func (x *MutationCreateUserResponse) Reset() { *x = MutationCreateUserResponse{} - mi := &file_product_proto_msgTypes[90] + mi := &file_product_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4153,7 +4325,7 @@ func (x *MutationCreateUserResponse) String() string { func (*MutationCreateUserResponse) ProtoMessage() {} func (x *MutationCreateUserResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[90] + mi := &file_product_proto_msgTypes[94] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4166,7 +4338,7 @@ func (x *MutationCreateUserResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationCreateUserResponse.ProtoReflect.Descriptor instead. func (*MutationCreateUserResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{90} + return file_product_proto_rawDescGZIP(), []int{94} } func (x *MutationCreateUserResponse) GetCreateUser() *User { @@ -4186,7 +4358,7 @@ type MutationPerformActionRequest struct { func (x *MutationPerformActionRequest) Reset() { *x = MutationPerformActionRequest{} - mi := &file_product_proto_msgTypes[91] + mi := &file_product_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4198,7 +4370,7 @@ func (x *MutationPerformActionRequest) String() string { func (*MutationPerformActionRequest) ProtoMessage() {} func (x *MutationPerformActionRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[91] + mi := &file_product_proto_msgTypes[95] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4211,7 +4383,7 @@ func (x *MutationPerformActionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationPerformActionRequest.ProtoReflect.Descriptor instead. func (*MutationPerformActionRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{91} + return file_product_proto_rawDescGZIP(), []int{95} } func (x *MutationPerformActionRequest) GetInput() *ActionInput { @@ -4231,7 +4403,7 @@ type MutationPerformActionResponse struct { func (x *MutationPerformActionResponse) Reset() { *x = MutationPerformActionResponse{} - mi := &file_product_proto_msgTypes[92] + mi := &file_product_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4243,7 +4415,7 @@ func (x *MutationPerformActionResponse) String() string { func (*MutationPerformActionResponse) ProtoMessage() {} func (x *MutationPerformActionResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[92] + mi := &file_product_proto_msgTypes[96] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4256,7 +4428,7 @@ func (x *MutationPerformActionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationPerformActionResponse.ProtoReflect.Descriptor instead. func (*MutationPerformActionResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{92} + return file_product_proto_rawDescGZIP(), []int{96} } func (x *MutationPerformActionResponse) GetPerformAction() *ActionResult { @@ -4276,7 +4448,7 @@ type MutationCreateNullableFieldsTypeRequest struct { func (x *MutationCreateNullableFieldsTypeRequest) Reset() { *x = MutationCreateNullableFieldsTypeRequest{} - mi := &file_product_proto_msgTypes[93] + mi := &file_product_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4288,7 +4460,7 @@ func (x *MutationCreateNullableFieldsTypeRequest) String() string { func (*MutationCreateNullableFieldsTypeRequest) ProtoMessage() {} func (x *MutationCreateNullableFieldsTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[93] + mi := &file_product_proto_msgTypes[97] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4301,7 +4473,7 @@ func (x *MutationCreateNullableFieldsTypeRequest) ProtoReflect() protoreflect.Me // Deprecated: Use MutationCreateNullableFieldsTypeRequest.ProtoReflect.Descriptor instead. func (*MutationCreateNullableFieldsTypeRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{93} + return file_product_proto_rawDescGZIP(), []int{97} } func (x *MutationCreateNullableFieldsTypeRequest) GetInput() *NullableFieldsInput { @@ -4321,7 +4493,7 @@ type MutationCreateNullableFieldsTypeResponse struct { func (x *MutationCreateNullableFieldsTypeResponse) Reset() { *x = MutationCreateNullableFieldsTypeResponse{} - mi := &file_product_proto_msgTypes[94] + mi := &file_product_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4333,7 +4505,7 @@ func (x *MutationCreateNullableFieldsTypeResponse) String() string { func (*MutationCreateNullableFieldsTypeResponse) ProtoMessage() {} func (x *MutationCreateNullableFieldsTypeResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[94] + mi := &file_product_proto_msgTypes[98] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4346,7 +4518,7 @@ func (x *MutationCreateNullableFieldsTypeResponse) ProtoReflect() protoreflect.M // Deprecated: Use MutationCreateNullableFieldsTypeResponse.ProtoReflect.Descriptor instead. func (*MutationCreateNullableFieldsTypeResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{94} + return file_product_proto_rawDescGZIP(), []int{98} } func (x *MutationCreateNullableFieldsTypeResponse) GetCreateNullableFieldsType() *NullableFieldsType { @@ -4367,7 +4539,7 @@ type MutationUpdateNullableFieldsTypeRequest struct { func (x *MutationUpdateNullableFieldsTypeRequest) Reset() { *x = MutationUpdateNullableFieldsTypeRequest{} - mi := &file_product_proto_msgTypes[95] + mi := &file_product_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4379,7 +4551,7 @@ func (x *MutationUpdateNullableFieldsTypeRequest) String() string { func (*MutationUpdateNullableFieldsTypeRequest) ProtoMessage() {} func (x *MutationUpdateNullableFieldsTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[95] + mi := &file_product_proto_msgTypes[99] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4392,7 +4564,7 @@ func (x *MutationUpdateNullableFieldsTypeRequest) ProtoReflect() protoreflect.Me // Deprecated: Use MutationUpdateNullableFieldsTypeRequest.ProtoReflect.Descriptor instead. func (*MutationUpdateNullableFieldsTypeRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{95} + return file_product_proto_rawDescGZIP(), []int{99} } func (x *MutationUpdateNullableFieldsTypeRequest) GetId() string { @@ -4419,7 +4591,7 @@ type MutationUpdateNullableFieldsTypeResponse struct { func (x *MutationUpdateNullableFieldsTypeResponse) Reset() { *x = MutationUpdateNullableFieldsTypeResponse{} - mi := &file_product_proto_msgTypes[96] + mi := &file_product_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4431,7 +4603,7 @@ func (x *MutationUpdateNullableFieldsTypeResponse) String() string { func (*MutationUpdateNullableFieldsTypeResponse) ProtoMessage() {} func (x *MutationUpdateNullableFieldsTypeResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[96] + mi := &file_product_proto_msgTypes[100] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4444,7 +4616,7 @@ func (x *MutationUpdateNullableFieldsTypeResponse) ProtoReflect() protoreflect.M // Deprecated: Use MutationUpdateNullableFieldsTypeResponse.ProtoReflect.Descriptor instead. func (*MutationUpdateNullableFieldsTypeResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{96} + return file_product_proto_rawDescGZIP(), []int{100} } func (x *MutationUpdateNullableFieldsTypeResponse) GetUpdateNullableFieldsType() *NullableFieldsType { @@ -4464,7 +4636,7 @@ type MutationCreateBlogPostRequest struct { func (x *MutationCreateBlogPostRequest) Reset() { *x = MutationCreateBlogPostRequest{} - mi := &file_product_proto_msgTypes[97] + mi := &file_product_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4476,7 +4648,7 @@ func (x *MutationCreateBlogPostRequest) String() string { func (*MutationCreateBlogPostRequest) ProtoMessage() {} func (x *MutationCreateBlogPostRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[97] + mi := &file_product_proto_msgTypes[101] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4489,7 +4661,7 @@ func (x *MutationCreateBlogPostRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationCreateBlogPostRequest.ProtoReflect.Descriptor instead. func (*MutationCreateBlogPostRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{97} + return file_product_proto_rawDescGZIP(), []int{101} } func (x *MutationCreateBlogPostRequest) GetInput() *BlogPostInput { @@ -4509,7 +4681,7 @@ type MutationCreateBlogPostResponse struct { func (x *MutationCreateBlogPostResponse) Reset() { *x = MutationCreateBlogPostResponse{} - mi := &file_product_proto_msgTypes[98] + mi := &file_product_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4521,7 +4693,7 @@ func (x *MutationCreateBlogPostResponse) String() string { func (*MutationCreateBlogPostResponse) ProtoMessage() {} func (x *MutationCreateBlogPostResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[98] + mi := &file_product_proto_msgTypes[102] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4534,7 +4706,7 @@ func (x *MutationCreateBlogPostResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationCreateBlogPostResponse.ProtoReflect.Descriptor instead. func (*MutationCreateBlogPostResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{98} + return file_product_proto_rawDescGZIP(), []int{102} } func (x *MutationCreateBlogPostResponse) GetCreateBlogPost() *BlogPost { @@ -4555,7 +4727,7 @@ type MutationUpdateBlogPostRequest struct { func (x *MutationUpdateBlogPostRequest) Reset() { *x = MutationUpdateBlogPostRequest{} - mi := &file_product_proto_msgTypes[99] + mi := &file_product_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4567,7 +4739,7 @@ func (x *MutationUpdateBlogPostRequest) String() string { func (*MutationUpdateBlogPostRequest) ProtoMessage() {} func (x *MutationUpdateBlogPostRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[99] + mi := &file_product_proto_msgTypes[103] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4580,7 +4752,7 @@ func (x *MutationUpdateBlogPostRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationUpdateBlogPostRequest.ProtoReflect.Descriptor instead. func (*MutationUpdateBlogPostRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{99} + return file_product_proto_rawDescGZIP(), []int{103} } func (x *MutationUpdateBlogPostRequest) GetId() string { @@ -4607,7 +4779,7 @@ type MutationUpdateBlogPostResponse struct { func (x *MutationUpdateBlogPostResponse) Reset() { *x = MutationUpdateBlogPostResponse{} - mi := &file_product_proto_msgTypes[100] + mi := &file_product_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4619,7 +4791,7 @@ func (x *MutationUpdateBlogPostResponse) String() string { func (*MutationUpdateBlogPostResponse) ProtoMessage() {} func (x *MutationUpdateBlogPostResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[100] + mi := &file_product_proto_msgTypes[104] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4632,7 +4804,7 @@ func (x *MutationUpdateBlogPostResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationUpdateBlogPostResponse.ProtoReflect.Descriptor instead. func (*MutationUpdateBlogPostResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{100} + return file_product_proto_rawDescGZIP(), []int{104} } func (x *MutationUpdateBlogPostResponse) GetUpdateBlogPost() *BlogPost { @@ -4652,7 +4824,7 @@ type MutationCreateAuthorRequest struct { func (x *MutationCreateAuthorRequest) Reset() { *x = MutationCreateAuthorRequest{} - mi := &file_product_proto_msgTypes[101] + mi := &file_product_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4664,7 +4836,7 @@ func (x *MutationCreateAuthorRequest) String() string { func (*MutationCreateAuthorRequest) ProtoMessage() {} func (x *MutationCreateAuthorRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[101] + mi := &file_product_proto_msgTypes[105] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4677,7 +4849,7 @@ func (x *MutationCreateAuthorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationCreateAuthorRequest.ProtoReflect.Descriptor instead. func (*MutationCreateAuthorRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{101} + return file_product_proto_rawDescGZIP(), []int{105} } func (x *MutationCreateAuthorRequest) GetInput() *AuthorInput { @@ -4697,7 +4869,7 @@ type MutationCreateAuthorResponse struct { func (x *MutationCreateAuthorResponse) Reset() { *x = MutationCreateAuthorResponse{} - mi := &file_product_proto_msgTypes[102] + mi := &file_product_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4709,7 +4881,7 @@ func (x *MutationCreateAuthorResponse) String() string { func (*MutationCreateAuthorResponse) ProtoMessage() {} func (x *MutationCreateAuthorResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[102] + mi := &file_product_proto_msgTypes[106] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4722,7 +4894,7 @@ func (x *MutationCreateAuthorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationCreateAuthorResponse.ProtoReflect.Descriptor instead. func (*MutationCreateAuthorResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{102} + return file_product_proto_rawDescGZIP(), []int{106} } func (x *MutationCreateAuthorResponse) GetCreateAuthor() *Author { @@ -4743,7 +4915,7 @@ type MutationUpdateAuthorRequest struct { func (x *MutationUpdateAuthorRequest) Reset() { *x = MutationUpdateAuthorRequest{} - mi := &file_product_proto_msgTypes[103] + mi := &file_product_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4755,7 +4927,7 @@ func (x *MutationUpdateAuthorRequest) String() string { func (*MutationUpdateAuthorRequest) ProtoMessage() {} func (x *MutationUpdateAuthorRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[103] + mi := &file_product_proto_msgTypes[107] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4768,7 +4940,7 @@ func (x *MutationUpdateAuthorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationUpdateAuthorRequest.ProtoReflect.Descriptor instead. func (*MutationUpdateAuthorRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{103} + return file_product_proto_rawDescGZIP(), []int{107} } func (x *MutationUpdateAuthorRequest) GetId() string { @@ -4795,7 +4967,7 @@ type MutationUpdateAuthorResponse struct { func (x *MutationUpdateAuthorResponse) Reset() { *x = MutationUpdateAuthorResponse{} - mi := &file_product_proto_msgTypes[104] + mi := &file_product_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4807,7 +4979,7 @@ func (x *MutationUpdateAuthorResponse) String() string { func (*MutationUpdateAuthorResponse) ProtoMessage() {} func (x *MutationUpdateAuthorResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[104] + mi := &file_product_proto_msgTypes[108] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4820,7 +4992,7 @@ func (x *MutationUpdateAuthorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationUpdateAuthorResponse.ProtoReflect.Descriptor instead. func (*MutationUpdateAuthorResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{104} + return file_product_proto_rawDescGZIP(), []int{108} } func (x *MutationUpdateAuthorResponse) GetUpdateAuthor() *Author { @@ -4840,7 +5012,7 @@ type MutationBulkCreateAuthorsRequest struct { func (x *MutationBulkCreateAuthorsRequest) Reset() { *x = MutationBulkCreateAuthorsRequest{} - mi := &file_product_proto_msgTypes[105] + mi := &file_product_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4852,7 +5024,7 @@ func (x *MutationBulkCreateAuthorsRequest) String() string { func (*MutationBulkCreateAuthorsRequest) ProtoMessage() {} func (x *MutationBulkCreateAuthorsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[105] + mi := &file_product_proto_msgTypes[109] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4865,7 +5037,7 @@ func (x *MutationBulkCreateAuthorsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationBulkCreateAuthorsRequest.ProtoReflect.Descriptor instead. func (*MutationBulkCreateAuthorsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{105} + return file_product_proto_rawDescGZIP(), []int{109} } func (x *MutationBulkCreateAuthorsRequest) GetAuthors() *ListOfAuthorInput { @@ -4885,7 +5057,7 @@ type MutationBulkCreateAuthorsResponse struct { func (x *MutationBulkCreateAuthorsResponse) Reset() { *x = MutationBulkCreateAuthorsResponse{} - mi := &file_product_proto_msgTypes[106] + mi := &file_product_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4897,7 +5069,7 @@ func (x *MutationBulkCreateAuthorsResponse) String() string { func (*MutationBulkCreateAuthorsResponse) ProtoMessage() {} func (x *MutationBulkCreateAuthorsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[106] + mi := &file_product_proto_msgTypes[110] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4910,7 +5082,7 @@ func (x *MutationBulkCreateAuthorsResponse) ProtoReflect() protoreflect.Message // Deprecated: Use MutationBulkCreateAuthorsResponse.ProtoReflect.Descriptor instead. func (*MutationBulkCreateAuthorsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{106} + return file_product_proto_rawDescGZIP(), []int{110} } func (x *MutationBulkCreateAuthorsResponse) GetBulkCreateAuthors() []*Author { @@ -4930,7 +5102,7 @@ type MutationBulkUpdateAuthorsRequest struct { func (x *MutationBulkUpdateAuthorsRequest) Reset() { *x = MutationBulkUpdateAuthorsRequest{} - mi := &file_product_proto_msgTypes[107] + mi := &file_product_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4942,7 +5114,7 @@ func (x *MutationBulkUpdateAuthorsRequest) String() string { func (*MutationBulkUpdateAuthorsRequest) ProtoMessage() {} func (x *MutationBulkUpdateAuthorsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[107] + mi := &file_product_proto_msgTypes[111] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4955,7 +5127,7 @@ func (x *MutationBulkUpdateAuthorsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MutationBulkUpdateAuthorsRequest.ProtoReflect.Descriptor instead. func (*MutationBulkUpdateAuthorsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{107} + return file_product_proto_rawDescGZIP(), []int{111} } func (x *MutationBulkUpdateAuthorsRequest) GetAuthors() *ListOfAuthorInput { @@ -4975,7 +5147,7 @@ type MutationBulkUpdateAuthorsResponse struct { func (x *MutationBulkUpdateAuthorsResponse) Reset() { *x = MutationBulkUpdateAuthorsResponse{} - mi := &file_product_proto_msgTypes[108] + mi := &file_product_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4987,7 +5159,7 @@ func (x *MutationBulkUpdateAuthorsResponse) String() string { func (*MutationBulkUpdateAuthorsResponse) ProtoMessage() {} func (x *MutationBulkUpdateAuthorsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[108] + mi := &file_product_proto_msgTypes[112] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5000,7 +5172,7 @@ func (x *MutationBulkUpdateAuthorsResponse) ProtoReflect() protoreflect.Message // Deprecated: Use MutationBulkUpdateAuthorsResponse.ProtoReflect.Descriptor instead. func (*MutationBulkUpdateAuthorsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{108} + return file_product_proto_rawDescGZIP(), []int{112} } func (x *MutationBulkUpdateAuthorsResponse) GetBulkUpdateAuthors() []*Author { @@ -5020,7 +5192,7 @@ type MutationBulkCreateBlogPostsRequest struct { func (x *MutationBulkCreateBlogPostsRequest) Reset() { *x = MutationBulkCreateBlogPostsRequest{} - mi := &file_product_proto_msgTypes[109] + mi := &file_product_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5032,7 +5204,7 @@ func (x *MutationBulkCreateBlogPostsRequest) String() string { func (*MutationBulkCreateBlogPostsRequest) ProtoMessage() {} func (x *MutationBulkCreateBlogPostsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[109] + mi := &file_product_proto_msgTypes[113] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5045,7 +5217,7 @@ func (x *MutationBulkCreateBlogPostsRequest) ProtoReflect() protoreflect.Message // Deprecated: Use MutationBulkCreateBlogPostsRequest.ProtoReflect.Descriptor instead. func (*MutationBulkCreateBlogPostsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{109} + return file_product_proto_rawDescGZIP(), []int{113} } func (x *MutationBulkCreateBlogPostsRequest) GetBlogPosts() *ListOfBlogPostInput { @@ -5065,7 +5237,7 @@ type MutationBulkCreateBlogPostsResponse struct { func (x *MutationBulkCreateBlogPostsResponse) Reset() { *x = MutationBulkCreateBlogPostsResponse{} - mi := &file_product_proto_msgTypes[110] + mi := &file_product_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5077,7 +5249,7 @@ func (x *MutationBulkCreateBlogPostsResponse) String() string { func (*MutationBulkCreateBlogPostsResponse) ProtoMessage() {} func (x *MutationBulkCreateBlogPostsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[110] + mi := &file_product_proto_msgTypes[114] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5090,7 +5262,7 @@ func (x *MutationBulkCreateBlogPostsResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use MutationBulkCreateBlogPostsResponse.ProtoReflect.Descriptor instead. func (*MutationBulkCreateBlogPostsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{110} + return file_product_proto_rawDescGZIP(), []int{114} } func (x *MutationBulkCreateBlogPostsResponse) GetBulkCreateBlogPosts() []*BlogPost { @@ -5110,7 +5282,7 @@ type MutationBulkUpdateBlogPostsRequest struct { func (x *MutationBulkUpdateBlogPostsRequest) Reset() { *x = MutationBulkUpdateBlogPostsRequest{} - mi := &file_product_proto_msgTypes[111] + mi := &file_product_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5122,7 +5294,7 @@ func (x *MutationBulkUpdateBlogPostsRequest) String() string { func (*MutationBulkUpdateBlogPostsRequest) ProtoMessage() {} func (x *MutationBulkUpdateBlogPostsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[111] + mi := &file_product_proto_msgTypes[115] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5135,7 +5307,7 @@ func (x *MutationBulkUpdateBlogPostsRequest) ProtoReflect() protoreflect.Message // Deprecated: Use MutationBulkUpdateBlogPostsRequest.ProtoReflect.Descriptor instead. func (*MutationBulkUpdateBlogPostsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{111} + return file_product_proto_rawDescGZIP(), []int{115} } func (x *MutationBulkUpdateBlogPostsRequest) GetBlogPosts() *ListOfBlogPostInput { @@ -5155,7 +5327,7 @@ type MutationBulkUpdateBlogPostsResponse struct { func (x *MutationBulkUpdateBlogPostsResponse) Reset() { *x = MutationBulkUpdateBlogPostsResponse{} - mi := &file_product_proto_msgTypes[112] + mi := &file_product_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5167,7 +5339,7 @@ func (x *MutationBulkUpdateBlogPostsResponse) String() string { func (*MutationBulkUpdateBlogPostsResponse) ProtoMessage() {} func (x *MutationBulkUpdateBlogPostsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[112] + mi := &file_product_proto_msgTypes[116] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5180,7 +5352,7 @@ func (x *MutationBulkUpdateBlogPostsResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use MutationBulkUpdateBlogPostsResponse.ProtoReflect.Descriptor instead. func (*MutationBulkUpdateBlogPostsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{112} + return file_product_proto_rawDescGZIP(), []int{116} } func (x *MutationBulkUpdateBlogPostsResponse) GetBulkUpdateBlogPosts() []*BlogPost { @@ -5199,7 +5371,7 @@ type ResolveProductShippingEstimateArgs struct { func (x *ResolveProductShippingEstimateArgs) Reset() { *x = ResolveProductShippingEstimateArgs{} - mi := &file_product_proto_msgTypes[113] + mi := &file_product_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5211,7 +5383,7 @@ func (x *ResolveProductShippingEstimateArgs) String() string { func (*ResolveProductShippingEstimateArgs) ProtoMessage() {} func (x *ResolveProductShippingEstimateArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[113] + mi := &file_product_proto_msgTypes[117] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5224,7 +5396,7 @@ func (x *ResolveProductShippingEstimateArgs) ProtoReflect() protoreflect.Message // Deprecated: Use ResolveProductShippingEstimateArgs.ProtoReflect.Descriptor instead. func (*ResolveProductShippingEstimateArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{113} + return file_product_proto_rawDescGZIP(), []int{117} } func (x *ResolveProductShippingEstimateArgs) GetInput() *ShippingEstimateInput { @@ -5244,7 +5416,7 @@ type ResolveProductShippingEstimateContext struct { func (x *ResolveProductShippingEstimateContext) Reset() { *x = ResolveProductShippingEstimateContext{} - mi := &file_product_proto_msgTypes[114] + mi := &file_product_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5256,7 +5428,7 @@ func (x *ResolveProductShippingEstimateContext) String() string { func (*ResolveProductShippingEstimateContext) ProtoMessage() {} func (x *ResolveProductShippingEstimateContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[114] + mi := &file_product_proto_msgTypes[118] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5269,7 +5441,7 @@ func (x *ResolveProductShippingEstimateContext) ProtoReflect() protoreflect.Mess // Deprecated: Use ResolveProductShippingEstimateContext.ProtoReflect.Descriptor instead. func (*ResolveProductShippingEstimateContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{114} + return file_product_proto_rawDescGZIP(), []int{118} } func (x *ResolveProductShippingEstimateContext) GetId() string { @@ -5298,7 +5470,7 @@ type ResolveProductShippingEstimateRequest struct { func (x *ResolveProductShippingEstimateRequest) Reset() { *x = ResolveProductShippingEstimateRequest{} - mi := &file_product_proto_msgTypes[115] + mi := &file_product_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5310,7 +5482,7 @@ func (x *ResolveProductShippingEstimateRequest) String() string { func (*ResolveProductShippingEstimateRequest) ProtoMessage() {} func (x *ResolveProductShippingEstimateRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[115] + mi := &file_product_proto_msgTypes[119] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5323,7 +5495,7 @@ func (x *ResolveProductShippingEstimateRequest) ProtoReflect() protoreflect.Mess // Deprecated: Use ResolveProductShippingEstimateRequest.ProtoReflect.Descriptor instead. func (*ResolveProductShippingEstimateRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{115} + return file_product_proto_rawDescGZIP(), []int{119} } func (x *ResolveProductShippingEstimateRequest) GetContext() []*ResolveProductShippingEstimateContext { @@ -5349,7 +5521,7 @@ type ResolveProductShippingEstimateResult struct { func (x *ResolveProductShippingEstimateResult) Reset() { *x = ResolveProductShippingEstimateResult{} - mi := &file_product_proto_msgTypes[116] + mi := &file_product_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5361,7 +5533,7 @@ func (x *ResolveProductShippingEstimateResult) String() string { func (*ResolveProductShippingEstimateResult) ProtoMessage() {} func (x *ResolveProductShippingEstimateResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[116] + mi := &file_product_proto_msgTypes[120] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5374,7 +5546,7 @@ func (x *ResolveProductShippingEstimateResult) ProtoReflect() protoreflect.Messa // Deprecated: Use ResolveProductShippingEstimateResult.ProtoReflect.Descriptor instead. func (*ResolveProductShippingEstimateResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{116} + return file_product_proto_rawDescGZIP(), []int{120} } func (x *ResolveProductShippingEstimateResult) GetShippingEstimate() float64 { @@ -5393,7 +5565,7 @@ type ResolveProductShippingEstimateResponse struct { func (x *ResolveProductShippingEstimateResponse) Reset() { *x = ResolveProductShippingEstimateResponse{} - mi := &file_product_proto_msgTypes[117] + mi := &file_product_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5405,7 +5577,7 @@ func (x *ResolveProductShippingEstimateResponse) String() string { func (*ResolveProductShippingEstimateResponse) ProtoMessage() {} func (x *ResolveProductShippingEstimateResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[117] + mi := &file_product_proto_msgTypes[121] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5418,7 +5590,7 @@ func (x *ResolveProductShippingEstimateResponse) ProtoReflect() protoreflect.Mes // Deprecated: Use ResolveProductShippingEstimateResponse.ProtoReflect.Descriptor instead. func (*ResolveProductShippingEstimateResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{117} + return file_product_proto_rawDescGZIP(), []int{121} } func (x *ResolveProductShippingEstimateResponse) GetResult() []*ResolveProductShippingEstimateResult { @@ -5437,7 +5609,7 @@ type ResolveProductRecommendedCategoryArgs struct { func (x *ResolveProductRecommendedCategoryArgs) Reset() { *x = ResolveProductRecommendedCategoryArgs{} - mi := &file_product_proto_msgTypes[118] + mi := &file_product_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5449,7 +5621,7 @@ func (x *ResolveProductRecommendedCategoryArgs) String() string { func (*ResolveProductRecommendedCategoryArgs) ProtoMessage() {} func (x *ResolveProductRecommendedCategoryArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[118] + mi := &file_product_proto_msgTypes[122] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5462,7 +5634,7 @@ func (x *ResolveProductRecommendedCategoryArgs) ProtoReflect() protoreflect.Mess // Deprecated: Use ResolveProductRecommendedCategoryArgs.ProtoReflect.Descriptor instead. func (*ResolveProductRecommendedCategoryArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{118} + return file_product_proto_rawDescGZIP(), []int{122} } func (x *ResolveProductRecommendedCategoryArgs) GetMaxPrice() int32 { @@ -5483,7 +5655,7 @@ type ResolveProductRecommendedCategoryContext struct { func (x *ResolveProductRecommendedCategoryContext) Reset() { *x = ResolveProductRecommendedCategoryContext{} - mi := &file_product_proto_msgTypes[119] + mi := &file_product_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5495,7 +5667,7 @@ func (x *ResolveProductRecommendedCategoryContext) String() string { func (*ResolveProductRecommendedCategoryContext) ProtoMessage() {} func (x *ResolveProductRecommendedCategoryContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[119] + mi := &file_product_proto_msgTypes[123] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5508,7 +5680,7 @@ func (x *ResolveProductRecommendedCategoryContext) ProtoReflect() protoreflect.M // Deprecated: Use ResolveProductRecommendedCategoryContext.ProtoReflect.Descriptor instead. func (*ResolveProductRecommendedCategoryContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{119} + return file_product_proto_rawDescGZIP(), []int{123} } func (x *ResolveProductRecommendedCategoryContext) GetId() string { @@ -5544,7 +5716,7 @@ type ResolveProductRecommendedCategoryRequest struct { func (x *ResolveProductRecommendedCategoryRequest) Reset() { *x = ResolveProductRecommendedCategoryRequest{} - mi := &file_product_proto_msgTypes[120] + mi := &file_product_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5556,7 +5728,7 @@ func (x *ResolveProductRecommendedCategoryRequest) String() string { func (*ResolveProductRecommendedCategoryRequest) ProtoMessage() {} func (x *ResolveProductRecommendedCategoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[120] + mi := &file_product_proto_msgTypes[124] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5569,7 +5741,7 @@ func (x *ResolveProductRecommendedCategoryRequest) ProtoReflect() protoreflect.M // Deprecated: Use ResolveProductRecommendedCategoryRequest.ProtoReflect.Descriptor instead. func (*ResolveProductRecommendedCategoryRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{120} + return file_product_proto_rawDescGZIP(), []int{124} } func (x *ResolveProductRecommendedCategoryRequest) GetContext() []*ResolveProductRecommendedCategoryContext { @@ -5595,7 +5767,7 @@ type ResolveProductRecommendedCategoryResult struct { func (x *ResolveProductRecommendedCategoryResult) Reset() { *x = ResolveProductRecommendedCategoryResult{} - mi := &file_product_proto_msgTypes[121] + mi := &file_product_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5607,7 +5779,7 @@ func (x *ResolveProductRecommendedCategoryResult) String() string { func (*ResolveProductRecommendedCategoryResult) ProtoMessage() {} func (x *ResolveProductRecommendedCategoryResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[121] + mi := &file_product_proto_msgTypes[125] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5620,7 +5792,7 @@ func (x *ResolveProductRecommendedCategoryResult) ProtoReflect() protoreflect.Me // Deprecated: Use ResolveProductRecommendedCategoryResult.ProtoReflect.Descriptor instead. func (*ResolveProductRecommendedCategoryResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{121} + return file_product_proto_rawDescGZIP(), []int{125} } func (x *ResolveProductRecommendedCategoryResult) GetRecommendedCategory() *Category { @@ -5639,7 +5811,7 @@ type ResolveProductRecommendedCategoryResponse struct { func (x *ResolveProductRecommendedCategoryResponse) Reset() { *x = ResolveProductRecommendedCategoryResponse{} - mi := &file_product_proto_msgTypes[122] + mi := &file_product_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5651,7 +5823,7 @@ func (x *ResolveProductRecommendedCategoryResponse) String() string { func (*ResolveProductRecommendedCategoryResponse) ProtoMessage() {} func (x *ResolveProductRecommendedCategoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[122] + mi := &file_product_proto_msgTypes[126] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5664,7 +5836,7 @@ func (x *ResolveProductRecommendedCategoryResponse) ProtoReflect() protoreflect. // Deprecated: Use ResolveProductRecommendedCategoryResponse.ProtoReflect.Descriptor instead. func (*ResolveProductRecommendedCategoryResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{122} + return file_product_proto_rawDescGZIP(), []int{126} } func (x *ResolveProductRecommendedCategoryResponse) GetResult() []*ResolveProductRecommendedCategoryResult { @@ -5674,28 +5846,28 @@ func (x *ResolveProductRecommendedCategoryResponse) GetResult() []*ResolveProduc return nil } -type ResolveCategoryProductCountArgs struct { - state protoimpl.MessageState `protogen:"open.v1"` - Filters *ProductCountFilter `protobuf:"bytes,1,opt,name=filters,proto3" json:"filters,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type ResolveProductMascotRecommendationArgs struct { + state protoimpl.MessageState `protogen:"open.v1"` + IncludeDetails bool `protobuf:"varint,1,opt,name=include_details,json=includeDetails,proto3" json:"include_details,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryProductCountArgs) Reset() { - *x = ResolveCategoryProductCountArgs{} - mi := &file_product_proto_msgTypes[123] +func (x *ResolveProductMascotRecommendationArgs) Reset() { + *x = ResolveProductMascotRecommendationArgs{} + mi := &file_product_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryProductCountArgs) String() string { +func (x *ResolveProductMascotRecommendationArgs) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryProductCountArgs) ProtoMessage() {} +func (*ResolveProductMascotRecommendationArgs) ProtoMessage() {} -func (x *ResolveCategoryProductCountArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[123] +func (x *ResolveProductMascotRecommendationArgs) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[127] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5706,19 +5878,19 @@ func (x *ResolveCategoryProductCountArgs) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryProductCountArgs.ProtoReflect.Descriptor instead. -func (*ResolveCategoryProductCountArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{123} +// Deprecated: Use ResolveProductMascotRecommendationArgs.ProtoReflect.Descriptor instead. +func (*ResolveProductMascotRecommendationArgs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{127} } -func (x *ResolveCategoryProductCountArgs) GetFilters() *ProductCountFilter { +func (x *ResolveProductMascotRecommendationArgs) GetIncludeDetails() bool { if x != nil { - return x.Filters + return x.IncludeDetails } - return nil + return false } -type ResolveCategoryProductCountContext struct { +type ResolveProductMascotRecommendationContext 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"` @@ -5726,21 +5898,21 @@ type ResolveCategoryProductCountContext struct { sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryProductCountContext) Reset() { - *x = ResolveCategoryProductCountContext{} - mi := &file_product_proto_msgTypes[124] +func (x *ResolveProductMascotRecommendationContext) Reset() { + *x = ResolveProductMascotRecommendationContext{} + mi := &file_product_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryProductCountContext) String() string { +func (x *ResolveProductMascotRecommendationContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryProductCountContext) ProtoMessage() {} +func (*ResolveProductMascotRecommendationContext) ProtoMessage() {} -func (x *ResolveCategoryProductCountContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[124] +func (x *ResolveProductMascotRecommendationContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[128] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5751,50 +5923,50 @@ func (x *ResolveCategoryProductCountContext) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryProductCountContext.ProtoReflect.Descriptor instead. -func (*ResolveCategoryProductCountContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{124} +// Deprecated: Use ResolveProductMascotRecommendationContext.ProtoReflect.Descriptor instead. +func (*ResolveProductMascotRecommendationContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{128} } -func (x *ResolveCategoryProductCountContext) GetId() string { +func (x *ResolveProductMascotRecommendationContext) GetId() string { if x != nil { return x.Id } return "" } -func (x *ResolveCategoryProductCountContext) GetName() string { +func (x *ResolveProductMascotRecommendationContext) GetName() string { if x != nil { return x.Name } return "" } -type ResolveCategoryProductCountRequest struct { +type ResolveProductMascotRecommendationRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // context provides the resolver context for the field productCount of type Category. - Context []*ResolveCategoryProductCountContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` - // field_args provides the arguments for the resolver field productCount of type Category. - FieldArgs *ResolveCategoryProductCountArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` + // context provides the resolver context for the field mascotRecommendation of type Product. + Context []*ResolveProductMascotRecommendationContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field mascotRecommendation of type Product. + FieldArgs *ResolveProductMascotRecommendationArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryProductCountRequest) Reset() { - *x = ResolveCategoryProductCountRequest{} - mi := &file_product_proto_msgTypes[125] +func (x *ResolveProductMascotRecommendationRequest) Reset() { + *x = ResolveProductMascotRecommendationRequest{} + mi := &file_product_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryProductCountRequest) String() string { +func (x *ResolveProductMascotRecommendationRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryProductCountRequest) ProtoMessage() {} +func (*ResolveProductMascotRecommendationRequest) ProtoMessage() {} -func (x *ResolveCategoryProductCountRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[125] +func (x *ResolveProductMascotRecommendationRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[129] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5805,47 +5977,47 @@ func (x *ResolveCategoryProductCountRequest) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryProductCountRequest.ProtoReflect.Descriptor instead. -func (*ResolveCategoryProductCountRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{125} +// Deprecated: Use ResolveProductMascotRecommendationRequest.ProtoReflect.Descriptor instead. +func (*ResolveProductMascotRecommendationRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{129} } -func (x *ResolveCategoryProductCountRequest) GetContext() []*ResolveCategoryProductCountContext { +func (x *ResolveProductMascotRecommendationRequest) GetContext() []*ResolveProductMascotRecommendationContext { if x != nil { return x.Context } return nil } -func (x *ResolveCategoryProductCountRequest) GetFieldArgs() *ResolveCategoryProductCountArgs { +func (x *ResolveProductMascotRecommendationRequest) GetFieldArgs() *ResolveProductMascotRecommendationArgs { if x != nil { return x.FieldArgs } return nil } -type ResolveCategoryProductCountResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - ProductCount int32 `protobuf:"varint,1,opt,name=product_count,json=productCount,proto3" json:"product_count,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type ResolveProductMascotRecommendationResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + MascotRecommendation *Animal `protobuf:"bytes,1,opt,name=mascot_recommendation,json=mascotRecommendation,proto3" json:"mascot_recommendation,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryProductCountResult) Reset() { - *x = ResolveCategoryProductCountResult{} - mi := &file_product_proto_msgTypes[126] +func (x *ResolveProductMascotRecommendationResult) Reset() { + *x = ResolveProductMascotRecommendationResult{} + mi := &file_product_proto_msgTypes[130] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryProductCountResult) String() string { +func (x *ResolveProductMascotRecommendationResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryProductCountResult) ProtoMessage() {} +func (*ResolveProductMascotRecommendationResult) ProtoMessage() {} -func (x *ResolveCategoryProductCountResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[126] +func (x *ResolveProductMascotRecommendationResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[130] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5856,40 +6028,40 @@ func (x *ResolveCategoryProductCountResult) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryProductCountResult.ProtoReflect.Descriptor instead. -func (*ResolveCategoryProductCountResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{126} +// Deprecated: Use ResolveProductMascotRecommendationResult.ProtoReflect.Descriptor instead. +func (*ResolveProductMascotRecommendationResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{130} } -func (x *ResolveCategoryProductCountResult) GetProductCount() int32 { +func (x *ResolveProductMascotRecommendationResult) GetMascotRecommendation() *Animal { if x != nil { - return x.ProductCount + return x.MascotRecommendation } - return 0 + return nil } -type ResolveCategoryProductCountResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Result []*ResolveCategoryProductCountResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` +type ResolveProductMascotRecommendationResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveProductMascotRecommendationResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryProductCountResponse) Reset() { - *x = ResolveCategoryProductCountResponse{} - mi := &file_product_proto_msgTypes[127] +func (x *ResolveProductMascotRecommendationResponse) Reset() { + *x = ResolveProductMascotRecommendationResponse{} + mi := &file_product_proto_msgTypes[131] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryProductCountResponse) String() string { +func (x *ResolveProductMascotRecommendationResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryProductCountResponse) ProtoMessage() {} +func (*ResolveProductMascotRecommendationResponse) ProtoMessage() {} -func (x *ResolveCategoryProductCountResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[127] +func (x *ResolveProductMascotRecommendationResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[131] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5900,40 +6072,40 @@ func (x *ResolveCategoryProductCountResponse) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryProductCountResponse.ProtoReflect.Descriptor instead. -func (*ResolveCategoryProductCountResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{127} +// Deprecated: Use ResolveProductMascotRecommendationResponse.ProtoReflect.Descriptor instead. +func (*ResolveProductMascotRecommendationResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{131} } -func (x *ResolveCategoryProductCountResponse) GetResult() []*ResolveCategoryProductCountResult { +func (x *ResolveProductMascotRecommendationResponse) GetResult() []*ResolveProductMascotRecommendationResult { if x != nil { return x.Result } return nil } -type ResolveCategoryPopularityScoreArgs struct { - state protoimpl.MessageState `protogen:"open.v1"` - Threshold *wrapperspb.Int32Value `protobuf:"bytes,1,opt,name=threshold,proto3" json:"threshold,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type ResolveProductStockStatusArgs struct { + state protoimpl.MessageState `protogen:"open.v1"` + CheckAvailability bool `protobuf:"varint,1,opt,name=check_availability,json=checkAvailability,proto3" json:"check_availability,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryPopularityScoreArgs) Reset() { - *x = ResolveCategoryPopularityScoreArgs{} - mi := &file_product_proto_msgTypes[128] +func (x *ResolveProductStockStatusArgs) Reset() { + *x = ResolveProductStockStatusArgs{} + mi := &file_product_proto_msgTypes[132] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryPopularityScoreArgs) String() string { +func (x *ResolveProductStockStatusArgs) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryPopularityScoreArgs) ProtoMessage() {} +func (*ResolveProductStockStatusArgs) ProtoMessage() {} -func (x *ResolveCategoryPopularityScoreArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[128] +func (x *ResolveProductStockStatusArgs) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[132] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5944,40 +6116,42 @@ func (x *ResolveCategoryPopularityScoreArgs) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryPopularityScoreArgs.ProtoReflect.Descriptor instead. -func (*ResolveCategoryPopularityScoreArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{128} +// Deprecated: Use ResolveProductStockStatusArgs.ProtoReflect.Descriptor instead. +func (*ResolveProductStockStatusArgs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{132} } -func (x *ResolveCategoryPopularityScoreArgs) GetThreshold() *wrapperspb.Int32Value { +func (x *ResolveProductStockStatusArgs) GetCheckAvailability() bool { if x != nil { - return x.Threshold + return x.CheckAvailability } - return nil + return false } -type ResolveCategoryPopularityScoreContext struct { +type ResolveProductStockStatusContext 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"` + Price float64 `protobuf:"fixed64,3,opt,name=price,proto3" json:"price,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryPopularityScoreContext) Reset() { - *x = ResolveCategoryPopularityScoreContext{} - mi := &file_product_proto_msgTypes[129] +func (x *ResolveProductStockStatusContext) Reset() { + *x = ResolveProductStockStatusContext{} + mi := &file_product_proto_msgTypes[133] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryPopularityScoreContext) String() string { +func (x *ResolveProductStockStatusContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryPopularityScoreContext) ProtoMessage() {} +func (*ResolveProductStockStatusContext) ProtoMessage() {} -func (x *ResolveCategoryPopularityScoreContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[129] +func (x *ResolveProductStockStatusContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[133] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5988,43 +6162,57 @@ func (x *ResolveCategoryPopularityScoreContext) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryPopularityScoreContext.ProtoReflect.Descriptor instead. -func (*ResolveCategoryPopularityScoreContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{129} +// Deprecated: Use ResolveProductStockStatusContext.ProtoReflect.Descriptor instead. +func (*ResolveProductStockStatusContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{133} } -func (x *ResolveCategoryPopularityScoreContext) GetId() string { +func (x *ResolveProductStockStatusContext) GetId() string { if x != nil { return x.Id } return "" } -type ResolveCategoryPopularityScoreRequest struct { +func (x *ResolveProductStockStatusContext) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *ResolveProductStockStatusContext) GetPrice() float64 { + if x != nil { + return x.Price + } + return 0 +} + +type ResolveProductStockStatusRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // context provides the resolver context for the field popularityScore of type Category. - Context []*ResolveCategoryPopularityScoreContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` - // field_args provides the arguments for the resolver field popularityScore of type Category. - FieldArgs *ResolveCategoryPopularityScoreArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` + // context provides the resolver context for the field stockStatus of type Product. + Context []*ResolveProductStockStatusContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field stockStatus of type Product. + FieldArgs *ResolveProductStockStatusArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryPopularityScoreRequest) Reset() { - *x = ResolveCategoryPopularityScoreRequest{} - mi := &file_product_proto_msgTypes[130] +func (x *ResolveProductStockStatusRequest) Reset() { + *x = ResolveProductStockStatusRequest{} + mi := &file_product_proto_msgTypes[134] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryPopularityScoreRequest) String() string { +func (x *ResolveProductStockStatusRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryPopularityScoreRequest) ProtoMessage() {} +func (*ResolveProductStockStatusRequest) ProtoMessage() {} -func (x *ResolveCategoryPopularityScoreRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[130] +func (x *ResolveProductStockStatusRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[134] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6035,47 +6223,47 @@ func (x *ResolveCategoryPopularityScoreRequest) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryPopularityScoreRequest.ProtoReflect.Descriptor instead. -func (*ResolveCategoryPopularityScoreRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{130} +// Deprecated: Use ResolveProductStockStatusRequest.ProtoReflect.Descriptor instead. +func (*ResolveProductStockStatusRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{134} } -func (x *ResolveCategoryPopularityScoreRequest) GetContext() []*ResolveCategoryPopularityScoreContext { +func (x *ResolveProductStockStatusRequest) GetContext() []*ResolveProductStockStatusContext { if x != nil { return x.Context } return nil } -func (x *ResolveCategoryPopularityScoreRequest) GetFieldArgs() *ResolveCategoryPopularityScoreArgs { +func (x *ResolveProductStockStatusRequest) GetFieldArgs() *ResolveProductStockStatusArgs { if x != nil { return x.FieldArgs } return nil } -type ResolveCategoryPopularityScoreResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - PopularityScore *wrapperspb.Int32Value `protobuf:"bytes,1,opt,name=popularity_score,json=popularityScore,proto3" json:"popularity_score,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type ResolveProductStockStatusResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + StockStatus *ActionResult `protobuf:"bytes,1,opt,name=stock_status,json=stockStatus,proto3" json:"stock_status,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryPopularityScoreResult) Reset() { - *x = ResolveCategoryPopularityScoreResult{} - mi := &file_product_proto_msgTypes[131] +func (x *ResolveProductStockStatusResult) Reset() { + *x = ResolveProductStockStatusResult{} + mi := &file_product_proto_msgTypes[135] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryPopularityScoreResult) String() string { +func (x *ResolveProductStockStatusResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryPopularityScoreResult) ProtoMessage() {} +func (*ResolveProductStockStatusResult) ProtoMessage() {} -func (x *ResolveCategoryPopularityScoreResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[131] +func (x *ResolveProductStockStatusResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[135] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6086,40 +6274,40 @@ func (x *ResolveCategoryPopularityScoreResult) ProtoReflect() protoreflect.Messa return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryPopularityScoreResult.ProtoReflect.Descriptor instead. -func (*ResolveCategoryPopularityScoreResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{131} +// Deprecated: Use ResolveProductStockStatusResult.ProtoReflect.Descriptor instead. +func (*ResolveProductStockStatusResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{135} } -func (x *ResolveCategoryPopularityScoreResult) GetPopularityScore() *wrapperspb.Int32Value { +func (x *ResolveProductStockStatusResult) GetStockStatus() *ActionResult { if x != nil { - return x.PopularityScore + return x.StockStatus } return nil } -type ResolveCategoryPopularityScoreResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Result []*ResolveCategoryPopularityScoreResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` +type ResolveProductStockStatusResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveProductStockStatusResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryPopularityScoreResponse) Reset() { - *x = ResolveCategoryPopularityScoreResponse{} - mi := &file_product_proto_msgTypes[132] +func (x *ResolveProductStockStatusResponse) Reset() { + *x = ResolveProductStockStatusResponse{} + mi := &file_product_proto_msgTypes[136] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryPopularityScoreResponse) String() string { +func (x *ResolveProductStockStatusResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryPopularityScoreResponse) ProtoMessage() {} +func (*ResolveProductStockStatusResponse) ProtoMessage() {} -func (x *ResolveCategoryPopularityScoreResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[132] +func (x *ResolveProductStockStatusResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[136] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6130,40 +6318,40 @@ func (x *ResolveCategoryPopularityScoreResponse) ProtoReflect() protoreflect.Mes return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryPopularityScoreResponse.ProtoReflect.Descriptor instead. -func (*ResolveCategoryPopularityScoreResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{132} +// Deprecated: Use ResolveProductStockStatusResponse.ProtoReflect.Descriptor instead. +func (*ResolveProductStockStatusResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{136} } -func (x *ResolveCategoryPopularityScoreResponse) GetResult() []*ResolveCategoryPopularityScoreResult { +func (x *ResolveProductStockStatusResponse) GetResult() []*ResolveProductStockStatusResult { if x != nil { return x.Result } return nil } -type ResolveCategoryCategoryMetricsArgs struct { - state protoimpl.MessageState `protogen:"open.v1"` - MetricType string `protobuf:"bytes,1,opt,name=metric_type,json=metricType,proto3" json:"metric_type,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type ResolveProductProductDetailsArgs struct { + state protoimpl.MessageState `protogen:"open.v1"` + IncludeExtended bool `protobuf:"varint,1,opt,name=include_extended,json=includeExtended,proto3" json:"include_extended,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryCategoryMetricsArgs) Reset() { - *x = ResolveCategoryCategoryMetricsArgs{} - mi := &file_product_proto_msgTypes[133] +func (x *ResolveProductProductDetailsArgs) Reset() { + *x = ResolveProductProductDetailsArgs{} + mi := &file_product_proto_msgTypes[137] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryCategoryMetricsArgs) String() string { +func (x *ResolveProductProductDetailsArgs) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryCategoryMetricsArgs) ProtoMessage() {} +func (*ResolveProductProductDetailsArgs) ProtoMessage() {} -func (x *ResolveCategoryCategoryMetricsArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[133] +func (x *ResolveProductProductDetailsArgs) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[137] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6174,41 +6362,42 @@ func (x *ResolveCategoryCategoryMetricsArgs) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryCategoryMetricsArgs.ProtoReflect.Descriptor instead. -func (*ResolveCategoryCategoryMetricsArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{133} +// Deprecated: Use ResolveProductProductDetailsArgs.ProtoReflect.Descriptor instead. +func (*ResolveProductProductDetailsArgs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{137} } -func (x *ResolveCategoryCategoryMetricsArgs) GetMetricType() string { +func (x *ResolveProductProductDetailsArgs) GetIncludeExtended() bool { if x != nil { - return x.MetricType + return x.IncludeExtended } - return "" + return false } -type ResolveCategoryCategoryMetricsContext struct { +type ResolveProductProductDetailsContext 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"` + Price float64 `protobuf:"fixed64,3,opt,name=price,proto3" json:"price,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryCategoryMetricsContext) Reset() { - *x = ResolveCategoryCategoryMetricsContext{} - mi := &file_product_proto_msgTypes[134] +func (x *ResolveProductProductDetailsContext) Reset() { + *x = ResolveProductProductDetailsContext{} + mi := &file_product_proto_msgTypes[138] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryCategoryMetricsContext) String() string { +func (x *ResolveProductProductDetailsContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryCategoryMetricsContext) ProtoMessage() {} +func (*ResolveProductProductDetailsContext) ProtoMessage() {} -func (x *ResolveCategoryCategoryMetricsContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[134] +func (x *ResolveProductProductDetailsContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[138] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6219,50 +6408,57 @@ func (x *ResolveCategoryCategoryMetricsContext) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryCategoryMetricsContext.ProtoReflect.Descriptor instead. -func (*ResolveCategoryCategoryMetricsContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{134} +// Deprecated: Use ResolveProductProductDetailsContext.ProtoReflect.Descriptor instead. +func (*ResolveProductProductDetailsContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{138} } -func (x *ResolveCategoryCategoryMetricsContext) GetId() string { +func (x *ResolveProductProductDetailsContext) GetId() string { if x != nil { return x.Id } return "" } -func (x *ResolveCategoryCategoryMetricsContext) GetName() string { +func (x *ResolveProductProductDetailsContext) GetName() string { if x != nil { return x.Name } return "" } -type ResolveCategoryCategoryMetricsRequest struct { +func (x *ResolveProductProductDetailsContext) GetPrice() float64 { + if x != nil { + return x.Price + } + return 0 +} + +type ResolveProductProductDetailsRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // context provides the resolver context for the field categoryMetrics of type Category. - Context []*ResolveCategoryCategoryMetricsContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` - // field_args provides the arguments for the resolver field categoryMetrics of type Category. - FieldArgs *ResolveCategoryCategoryMetricsArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` + // context provides the resolver context for the field productDetails of type Product. + Context []*ResolveProductProductDetailsContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field productDetails of type Product. + FieldArgs *ResolveProductProductDetailsArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryCategoryMetricsRequest) Reset() { - *x = ResolveCategoryCategoryMetricsRequest{} - mi := &file_product_proto_msgTypes[135] +func (x *ResolveProductProductDetailsRequest) Reset() { + *x = ResolveProductProductDetailsRequest{} + mi := &file_product_proto_msgTypes[139] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryCategoryMetricsRequest) String() string { +func (x *ResolveProductProductDetailsRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryCategoryMetricsRequest) ProtoMessage() {} +func (*ResolveProductProductDetailsRequest) ProtoMessage() {} -func (x *ResolveCategoryCategoryMetricsRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[135] +func (x *ResolveProductProductDetailsRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[139] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6273,47 +6469,47 @@ func (x *ResolveCategoryCategoryMetricsRequest) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryCategoryMetricsRequest.ProtoReflect.Descriptor instead. -func (*ResolveCategoryCategoryMetricsRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{135} +// Deprecated: Use ResolveProductProductDetailsRequest.ProtoReflect.Descriptor instead. +func (*ResolveProductProductDetailsRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{139} } -func (x *ResolveCategoryCategoryMetricsRequest) GetContext() []*ResolveCategoryCategoryMetricsContext { +func (x *ResolveProductProductDetailsRequest) GetContext() []*ResolveProductProductDetailsContext { if x != nil { return x.Context } return nil } -func (x *ResolveCategoryCategoryMetricsRequest) GetFieldArgs() *ResolveCategoryCategoryMetricsArgs { +func (x *ResolveProductProductDetailsRequest) GetFieldArgs() *ResolveProductProductDetailsArgs { if x != nil { return x.FieldArgs } return nil } -type ResolveCategoryCategoryMetricsResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - CategoryMetrics *CategoryMetrics `protobuf:"bytes,1,opt,name=category_metrics,json=categoryMetrics,proto3" json:"category_metrics,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type ResolveProductProductDetailsResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + ProductDetails *ProductDetails `protobuf:"bytes,1,opt,name=product_details,json=productDetails,proto3" json:"product_details,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryCategoryMetricsResult) Reset() { - *x = ResolveCategoryCategoryMetricsResult{} - mi := &file_product_proto_msgTypes[136] +func (x *ResolveProductProductDetailsResult) Reset() { + *x = ResolveProductProductDetailsResult{} + mi := &file_product_proto_msgTypes[140] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryCategoryMetricsResult) String() string { +func (x *ResolveProductProductDetailsResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryCategoryMetricsResult) ProtoMessage() {} +func (*ResolveProductProductDetailsResult) ProtoMessage() {} -func (x *ResolveCategoryCategoryMetricsResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[136] +func (x *ResolveProductProductDetailsResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[140] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6324,40 +6520,40 @@ func (x *ResolveCategoryCategoryMetricsResult) ProtoReflect() protoreflect.Messa return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryCategoryMetricsResult.ProtoReflect.Descriptor instead. -func (*ResolveCategoryCategoryMetricsResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{136} +// Deprecated: Use ResolveProductProductDetailsResult.ProtoReflect.Descriptor instead. +func (*ResolveProductProductDetailsResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{140} } -func (x *ResolveCategoryCategoryMetricsResult) GetCategoryMetrics() *CategoryMetrics { +func (x *ResolveProductProductDetailsResult) GetProductDetails() *ProductDetails { if x != nil { - return x.CategoryMetrics + return x.ProductDetails } return nil } -type ResolveCategoryCategoryMetricsResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Result []*ResolveCategoryCategoryMetricsResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` +type ResolveProductProductDetailsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveProductProductDetailsResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveCategoryCategoryMetricsResponse) Reset() { - *x = ResolveCategoryCategoryMetricsResponse{} - mi := &file_product_proto_msgTypes[137] +func (x *ResolveProductProductDetailsResponse) Reset() { + *x = ResolveProductProductDetailsResponse{} + mi := &file_product_proto_msgTypes[141] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveCategoryCategoryMetricsResponse) String() string { +func (x *ResolveProductProductDetailsResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveCategoryCategoryMetricsResponse) ProtoMessage() {} +func (*ResolveProductProductDetailsResponse) ProtoMessage() {} -func (x *ResolveCategoryCategoryMetricsResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[137] +func (x *ResolveProductProductDetailsResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[141] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6368,40 +6564,40 @@ func (x *ResolveCategoryCategoryMetricsResponse) ProtoReflect() protoreflect.Mes return mi.MessageOf(x) } -// Deprecated: Use ResolveCategoryCategoryMetricsResponse.ProtoReflect.Descriptor instead. -func (*ResolveCategoryCategoryMetricsResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{137} +// Deprecated: Use ResolveProductProductDetailsResponse.ProtoReflect.Descriptor instead. +func (*ResolveProductProductDetailsResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{141} } -func (x *ResolveCategoryCategoryMetricsResponse) GetResult() []*ResolveCategoryCategoryMetricsResult { +func (x *ResolveProductProductDetailsResponse) GetResult() []*ResolveProductProductDetailsResult { if x != nil { return x.Result } return nil } -type ResolveSubcategoryItemCountArgs struct { +type ResolveCategoryProductCountArgs struct { state protoimpl.MessageState `protogen:"open.v1"` - Filters *SubcategoryItemFilter `protobuf:"bytes,1,opt,name=filters,proto3" json:"filters,omitempty"` + Filters *ProductCountFilter `protobuf:"bytes,1,opt,name=filters,proto3" json:"filters,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveSubcategoryItemCountArgs) Reset() { - *x = ResolveSubcategoryItemCountArgs{} - mi := &file_product_proto_msgTypes[138] +func (x *ResolveCategoryProductCountArgs) Reset() { + *x = ResolveCategoryProductCountArgs{} + mi := &file_product_proto_msgTypes[142] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryItemCountArgs) String() string { +func (x *ResolveCategoryProductCountArgs) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryItemCountArgs) ProtoMessage() {} +func (*ResolveCategoryProductCountArgs) ProtoMessage() {} -func (x *ResolveSubcategoryItemCountArgs) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[138] +func (x *ResolveCategoryProductCountArgs) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[142] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6412,40 +6608,1699 @@ func (x *ResolveSubcategoryItemCountArgs) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryItemCountArgs.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryItemCountArgs) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{138} +// Deprecated: Use ResolveCategoryProductCountArgs.ProtoReflect.Descriptor instead. +func (*ResolveCategoryProductCountArgs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{142} +} + +func (x *ResolveCategoryProductCountArgs) GetFilters() *ProductCountFilter { + if x != nil { + return x.Filters + } + return nil +} + +type ResolveCategoryProductCountContext 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 *ResolveCategoryProductCountContext) Reset() { + *x = ResolveCategoryProductCountContext{} + mi := &file_product_proto_msgTypes[143] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryProductCountContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryProductCountContext) ProtoMessage() {} + +func (x *ResolveCategoryProductCountContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[143] + 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 ResolveCategoryProductCountContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryProductCountContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{143} +} + +func (x *ResolveCategoryProductCountContext) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *ResolveCategoryProductCountContext) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type ResolveCategoryProductCountRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field productCount of type Category. + Context []*ResolveCategoryProductCountContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field productCount of type Category. + FieldArgs *ResolveCategoryProductCountArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryProductCountRequest) Reset() { + *x = ResolveCategoryProductCountRequest{} + mi := &file_product_proto_msgTypes[144] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryProductCountRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryProductCountRequest) ProtoMessage() {} + +func (x *ResolveCategoryProductCountRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[144] + 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 ResolveCategoryProductCountRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryProductCountRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{144} +} + +func (x *ResolveCategoryProductCountRequest) GetContext() []*ResolveCategoryProductCountContext { + if x != nil { + return x.Context + } + return nil +} + +func (x *ResolveCategoryProductCountRequest) GetFieldArgs() *ResolveCategoryProductCountArgs { + if x != nil { + return x.FieldArgs + } + return nil +} + +type ResolveCategoryProductCountResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + ProductCount int32 `protobuf:"varint,1,opt,name=product_count,json=productCount,proto3" json:"product_count,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryProductCountResult) Reset() { + *x = ResolveCategoryProductCountResult{} + mi := &file_product_proto_msgTypes[145] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryProductCountResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryProductCountResult) ProtoMessage() {} + +func (x *ResolveCategoryProductCountResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[145] + 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 ResolveCategoryProductCountResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryProductCountResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{145} +} + +func (x *ResolveCategoryProductCountResult) GetProductCount() int32 { + if x != nil { + return x.ProductCount + } + return 0 +} + +type ResolveCategoryProductCountResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveCategoryProductCountResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryProductCountResponse) Reset() { + *x = ResolveCategoryProductCountResponse{} + mi := &file_product_proto_msgTypes[146] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryProductCountResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryProductCountResponse) ProtoMessage() {} + +func (x *ResolveCategoryProductCountResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[146] + 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 ResolveCategoryProductCountResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryProductCountResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{146} +} + +func (x *ResolveCategoryProductCountResponse) GetResult() []*ResolveCategoryProductCountResult { + if x != nil { + return x.Result + } + return nil +} + +type ResolveCategoryPopularityScoreArgs struct { + state protoimpl.MessageState `protogen:"open.v1"` + Threshold *wrapperspb.Int32Value `protobuf:"bytes,1,opt,name=threshold,proto3" json:"threshold,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryPopularityScoreArgs) Reset() { + *x = ResolveCategoryPopularityScoreArgs{} + mi := &file_product_proto_msgTypes[147] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryPopularityScoreArgs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryPopularityScoreArgs) ProtoMessage() {} + +func (x *ResolveCategoryPopularityScoreArgs) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[147] + 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 ResolveCategoryPopularityScoreArgs.ProtoReflect.Descriptor instead. +func (*ResolveCategoryPopularityScoreArgs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{147} +} + +func (x *ResolveCategoryPopularityScoreArgs) GetThreshold() *wrapperspb.Int32Value { + if x != nil { + return x.Threshold + } + return nil +} + +type ResolveCategoryPopularityScoreContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryPopularityScoreContext) Reset() { + *x = ResolveCategoryPopularityScoreContext{} + mi := &file_product_proto_msgTypes[148] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryPopularityScoreContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryPopularityScoreContext) ProtoMessage() {} + +func (x *ResolveCategoryPopularityScoreContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[148] + 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 ResolveCategoryPopularityScoreContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryPopularityScoreContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{148} +} + +func (x *ResolveCategoryPopularityScoreContext) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +type ResolveCategoryPopularityScoreRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field popularityScore of type Category. + Context []*ResolveCategoryPopularityScoreContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field popularityScore of type Category. + FieldArgs *ResolveCategoryPopularityScoreArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryPopularityScoreRequest) Reset() { + *x = ResolveCategoryPopularityScoreRequest{} + mi := &file_product_proto_msgTypes[149] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryPopularityScoreRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryPopularityScoreRequest) ProtoMessage() {} + +func (x *ResolveCategoryPopularityScoreRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[149] + 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 ResolveCategoryPopularityScoreRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryPopularityScoreRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{149} +} + +func (x *ResolveCategoryPopularityScoreRequest) GetContext() []*ResolveCategoryPopularityScoreContext { + if x != nil { + return x.Context + } + return nil +} + +func (x *ResolveCategoryPopularityScoreRequest) GetFieldArgs() *ResolveCategoryPopularityScoreArgs { + if x != nil { + return x.FieldArgs + } + return nil +} + +type ResolveCategoryPopularityScoreResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + PopularityScore *wrapperspb.Int32Value `protobuf:"bytes,1,opt,name=popularity_score,json=popularityScore,proto3" json:"popularity_score,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryPopularityScoreResult) Reset() { + *x = ResolveCategoryPopularityScoreResult{} + mi := &file_product_proto_msgTypes[150] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryPopularityScoreResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryPopularityScoreResult) ProtoMessage() {} + +func (x *ResolveCategoryPopularityScoreResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[150] + 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 ResolveCategoryPopularityScoreResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryPopularityScoreResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{150} +} + +func (x *ResolveCategoryPopularityScoreResult) GetPopularityScore() *wrapperspb.Int32Value { + if x != nil { + return x.PopularityScore + } + return nil +} + +type ResolveCategoryPopularityScoreResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveCategoryPopularityScoreResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryPopularityScoreResponse) Reset() { + *x = ResolveCategoryPopularityScoreResponse{} + mi := &file_product_proto_msgTypes[151] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryPopularityScoreResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryPopularityScoreResponse) ProtoMessage() {} + +func (x *ResolveCategoryPopularityScoreResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[151] + 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 ResolveCategoryPopularityScoreResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryPopularityScoreResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{151} +} + +func (x *ResolveCategoryPopularityScoreResponse) GetResult() []*ResolveCategoryPopularityScoreResult { + if x != nil { + return x.Result + } + return nil +} + +type ResolveCategoryCategoryMetricsArgs struct { + state protoimpl.MessageState `protogen:"open.v1"` + MetricType string `protobuf:"bytes,1,opt,name=metric_type,json=metricType,proto3" json:"metric_type,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryCategoryMetricsArgs) Reset() { + *x = ResolveCategoryCategoryMetricsArgs{} + mi := &file_product_proto_msgTypes[152] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryCategoryMetricsArgs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryCategoryMetricsArgs) ProtoMessage() {} + +func (x *ResolveCategoryCategoryMetricsArgs) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[152] + 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 ResolveCategoryCategoryMetricsArgs.ProtoReflect.Descriptor instead. +func (*ResolveCategoryCategoryMetricsArgs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{152} +} + +func (x *ResolveCategoryCategoryMetricsArgs) GetMetricType() string { + if x != nil { + return x.MetricType + } + return "" +} + +type ResolveCategoryCategoryMetricsContext 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 *ResolveCategoryCategoryMetricsContext) Reset() { + *x = ResolveCategoryCategoryMetricsContext{} + mi := &file_product_proto_msgTypes[153] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryCategoryMetricsContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryCategoryMetricsContext) ProtoMessage() {} + +func (x *ResolveCategoryCategoryMetricsContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[153] + 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 ResolveCategoryCategoryMetricsContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryCategoryMetricsContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{153} +} + +func (x *ResolveCategoryCategoryMetricsContext) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *ResolveCategoryCategoryMetricsContext) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type ResolveCategoryCategoryMetricsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field categoryMetrics of type Category. + Context []*ResolveCategoryCategoryMetricsContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field categoryMetrics of type Category. + FieldArgs *ResolveCategoryCategoryMetricsArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryCategoryMetricsRequest) Reset() { + *x = ResolveCategoryCategoryMetricsRequest{} + mi := &file_product_proto_msgTypes[154] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryCategoryMetricsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryCategoryMetricsRequest) ProtoMessage() {} + +func (x *ResolveCategoryCategoryMetricsRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[154] + 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 ResolveCategoryCategoryMetricsRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryCategoryMetricsRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{154} +} + +func (x *ResolveCategoryCategoryMetricsRequest) GetContext() []*ResolveCategoryCategoryMetricsContext { + if x != nil { + return x.Context + } + return nil +} + +func (x *ResolveCategoryCategoryMetricsRequest) GetFieldArgs() *ResolveCategoryCategoryMetricsArgs { + if x != nil { + return x.FieldArgs + } + return nil +} + +type ResolveCategoryCategoryMetricsResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + CategoryMetrics *CategoryMetrics `protobuf:"bytes,1,opt,name=category_metrics,json=categoryMetrics,proto3" json:"category_metrics,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryCategoryMetricsResult) Reset() { + *x = ResolveCategoryCategoryMetricsResult{} + mi := &file_product_proto_msgTypes[155] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryCategoryMetricsResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryCategoryMetricsResult) ProtoMessage() {} + +func (x *ResolveCategoryCategoryMetricsResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[155] + 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 ResolveCategoryCategoryMetricsResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryCategoryMetricsResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{155} +} + +func (x *ResolveCategoryCategoryMetricsResult) GetCategoryMetrics() *CategoryMetrics { + if x != nil { + return x.CategoryMetrics + } + return nil +} + +type ResolveCategoryCategoryMetricsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveCategoryCategoryMetricsResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryCategoryMetricsResponse) Reset() { + *x = ResolveCategoryCategoryMetricsResponse{} + mi := &file_product_proto_msgTypes[156] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryCategoryMetricsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryCategoryMetricsResponse) ProtoMessage() {} + +func (x *ResolveCategoryCategoryMetricsResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[156] + 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 ResolveCategoryCategoryMetricsResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryCategoryMetricsResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{156} +} + +func (x *ResolveCategoryCategoryMetricsResponse) GetResult() []*ResolveCategoryCategoryMetricsResult { + if x != nil { + return x.Result + } + return nil +} + +type ResolveCategoryMascotArgs struct { + state protoimpl.MessageState `protogen:"open.v1"` + IncludeVolume bool `protobuf:"varint,1,opt,name=include_volume,json=includeVolume,proto3" json:"include_volume,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMascotArgs) Reset() { + *x = ResolveCategoryMascotArgs{} + mi := &file_product_proto_msgTypes[157] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryMascotArgs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryMascotArgs) ProtoMessage() {} + +func (x *ResolveCategoryMascotArgs) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[157] + 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 ResolveCategoryMascotArgs.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMascotArgs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{157} +} + +func (x *ResolveCategoryMascotArgs) GetIncludeVolume() bool { + if x != nil { + return x.IncludeVolume + } + return false +} + +type ResolveCategoryMascotContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Kind CategoryKind `protobuf:"varint,2,opt,name=kind,proto3,enum=productv1.CategoryKind" json:"kind,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMascotContext) Reset() { + *x = ResolveCategoryMascotContext{} + mi := &file_product_proto_msgTypes[158] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryMascotContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryMascotContext) ProtoMessage() {} + +func (x *ResolveCategoryMascotContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[158] + 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 ResolveCategoryMascotContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMascotContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{158} +} + +func (x *ResolveCategoryMascotContext) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *ResolveCategoryMascotContext) GetKind() CategoryKind { + if x != nil { + return x.Kind + } + return CategoryKind_CATEGORY_KIND_UNSPECIFIED +} + +type ResolveCategoryMascotRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field mascot of type Category. + Context []*ResolveCategoryMascotContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field mascot of type Category. + FieldArgs *ResolveCategoryMascotArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMascotRequest) Reset() { + *x = ResolveCategoryMascotRequest{} + mi := &file_product_proto_msgTypes[159] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryMascotRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryMascotRequest) ProtoMessage() {} + +func (x *ResolveCategoryMascotRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[159] + 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 ResolveCategoryMascotRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMascotRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{159} +} + +func (x *ResolveCategoryMascotRequest) GetContext() []*ResolveCategoryMascotContext { + if x != nil { + return x.Context + } + return nil +} + +func (x *ResolveCategoryMascotRequest) GetFieldArgs() *ResolveCategoryMascotArgs { + if x != nil { + return x.FieldArgs + } + return nil +} + +type ResolveCategoryMascotResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + Mascot *Animal `protobuf:"bytes,1,opt,name=mascot,proto3" json:"mascot,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMascotResult) Reset() { + *x = ResolveCategoryMascotResult{} + mi := &file_product_proto_msgTypes[160] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryMascotResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryMascotResult) ProtoMessage() {} + +func (x *ResolveCategoryMascotResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[160] + 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 ResolveCategoryMascotResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMascotResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{160} +} + +func (x *ResolveCategoryMascotResult) GetMascot() *Animal { + if x != nil { + return x.Mascot + } + return nil +} + +type ResolveCategoryMascotResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveCategoryMascotResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMascotResponse) Reset() { + *x = ResolveCategoryMascotResponse{} + mi := &file_product_proto_msgTypes[161] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryMascotResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryMascotResponse) ProtoMessage() {} + +func (x *ResolveCategoryMascotResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[161] + 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 ResolveCategoryMascotResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMascotResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{161} +} + +func (x *ResolveCategoryMascotResponse) GetResult() []*ResolveCategoryMascotResult { + if x != nil { + return x.Result + } + return nil +} + +type ResolveCategoryCategoryStatusArgs struct { + state protoimpl.MessageState `protogen:"open.v1"` + CheckHealth bool `protobuf:"varint,1,opt,name=check_health,json=checkHealth,proto3" json:"check_health,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryCategoryStatusArgs) Reset() { + *x = ResolveCategoryCategoryStatusArgs{} + mi := &file_product_proto_msgTypes[162] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryCategoryStatusArgs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryCategoryStatusArgs) ProtoMessage() {} + +func (x *ResolveCategoryCategoryStatusArgs) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[162] + 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 ResolveCategoryCategoryStatusArgs.ProtoReflect.Descriptor instead. +func (*ResolveCategoryCategoryStatusArgs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{162} +} + +func (x *ResolveCategoryCategoryStatusArgs) GetCheckHealth() bool { + if x != nil { + return x.CheckHealth + } + return false +} + +type ResolveCategoryCategoryStatusContext 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 *ResolveCategoryCategoryStatusContext) Reset() { + *x = ResolveCategoryCategoryStatusContext{} + mi := &file_product_proto_msgTypes[163] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryCategoryStatusContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryCategoryStatusContext) ProtoMessage() {} + +func (x *ResolveCategoryCategoryStatusContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[163] + 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 ResolveCategoryCategoryStatusContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryCategoryStatusContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{163} +} + +func (x *ResolveCategoryCategoryStatusContext) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *ResolveCategoryCategoryStatusContext) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type ResolveCategoryCategoryStatusRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field categoryStatus of type Category. + Context []*ResolveCategoryCategoryStatusContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field categoryStatus of type Category. + FieldArgs *ResolveCategoryCategoryStatusArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryCategoryStatusRequest) Reset() { + *x = ResolveCategoryCategoryStatusRequest{} + mi := &file_product_proto_msgTypes[164] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryCategoryStatusRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryCategoryStatusRequest) ProtoMessage() {} + +func (x *ResolveCategoryCategoryStatusRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[164] + 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 ResolveCategoryCategoryStatusRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryCategoryStatusRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{164} +} + +func (x *ResolveCategoryCategoryStatusRequest) GetContext() []*ResolveCategoryCategoryStatusContext { + if x != nil { + return x.Context + } + return nil +} + +func (x *ResolveCategoryCategoryStatusRequest) GetFieldArgs() *ResolveCategoryCategoryStatusArgs { + if x != nil { + return x.FieldArgs + } + return nil +} + +type ResolveCategoryCategoryStatusResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + CategoryStatus *ActionResult `protobuf:"bytes,1,opt,name=category_status,json=categoryStatus,proto3" json:"category_status,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryCategoryStatusResult) Reset() { + *x = ResolveCategoryCategoryStatusResult{} + mi := &file_product_proto_msgTypes[165] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryCategoryStatusResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryCategoryStatusResult) ProtoMessage() {} + +func (x *ResolveCategoryCategoryStatusResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[165] + 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 ResolveCategoryCategoryStatusResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryCategoryStatusResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{165} +} + +func (x *ResolveCategoryCategoryStatusResult) GetCategoryStatus() *ActionResult { + if x != nil { + return x.CategoryStatus + } + return nil +} + +type ResolveCategoryCategoryStatusResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveCategoryCategoryStatusResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryCategoryStatusResponse) Reset() { + *x = ResolveCategoryCategoryStatusResponse{} + mi := &file_product_proto_msgTypes[166] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryCategoryStatusResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryCategoryStatusResponse) ProtoMessage() {} + +func (x *ResolveCategoryCategoryStatusResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[166] + 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 ResolveCategoryCategoryStatusResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryCategoryStatusResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{166} +} + +func (x *ResolveCategoryCategoryStatusResponse) GetResult() []*ResolveCategoryCategoryStatusResult { + 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveSubcategoryItemCountArgs) Reset() { + *x = ResolveSubcategoryItemCountArgs{} + mi := &file_product_proto_msgTypes[167] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveSubcategoryItemCountArgs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveSubcategoryItemCountArgs) ProtoMessage() {} + +func (x *ResolveSubcategoryItemCountArgs) 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 ResolveSubcategoryItemCountArgs.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryItemCountArgs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{167} +} + +func (x *ResolveSubcategoryItemCountArgs) GetFilters() *SubcategoryItemFilter { + if x != nil { + return x.Filters + } + return nil +} + +type ResolveSubcategoryItemCountContext struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveSubcategoryItemCountContext) Reset() { + *x = ResolveSubcategoryItemCountContext{} + mi := &file_product_proto_msgTypes[168] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveSubcategoryItemCountContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveSubcategoryItemCountContext) ProtoMessage() {} + +func (x *ResolveSubcategoryItemCountContext) 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 ResolveSubcategoryItemCountContext.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryItemCountContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{168} +} + +func (x *ResolveSubcategoryItemCountContext) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +type ResolveSubcategoryItemCountRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field itemCount of type Subcategory. + Context []*ResolveSubcategoryItemCountContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field itemCount of type Subcategory. + FieldArgs *ResolveSubcategoryItemCountArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveSubcategoryItemCountRequest) Reset() { + *x = ResolveSubcategoryItemCountRequest{} + mi := &file_product_proto_msgTypes[169] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveSubcategoryItemCountRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveSubcategoryItemCountRequest) ProtoMessage() {} + +func (x *ResolveSubcategoryItemCountRequest) 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 ResolveSubcategoryItemCountRequest.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryItemCountRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{169} +} + +func (x *ResolveSubcategoryItemCountRequest) GetContext() []*ResolveSubcategoryItemCountContext { + if x != nil { + return x.Context + } + return nil +} + +func (x *ResolveSubcategoryItemCountRequest) GetFieldArgs() *ResolveSubcategoryItemCountArgs { + if x != nil { + return x.FieldArgs + } + return nil +} + +type ResolveSubcategoryItemCountResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + ItemCount int32 `protobuf:"varint,1,opt,name=item_count,json=itemCount,proto3" json:"item_count,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveSubcategoryItemCountResult) Reset() { + *x = ResolveSubcategoryItemCountResult{} + mi := &file_product_proto_msgTypes[170] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveSubcategoryItemCountResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveSubcategoryItemCountResult) ProtoMessage() {} + +func (x *ResolveSubcategoryItemCountResult) 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 ResolveSubcategoryItemCountResult.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryItemCountResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{170} +} + +func (x *ResolveSubcategoryItemCountResult) GetItemCount() int32 { + if x != nil { + return x.ItemCount + } + return 0 +} + +type ResolveSubcategoryItemCountResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveSubcategoryItemCountResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveSubcategoryItemCountResponse) Reset() { + *x = ResolveSubcategoryItemCountResponse{} + mi := &file_product_proto_msgTypes[171] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveSubcategoryItemCountResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveSubcategoryItemCountResponse) ProtoMessage() {} + +func (x *ResolveSubcategoryItemCountResponse) 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 ResolveSubcategoryItemCountResponse.ProtoReflect.Descriptor instead. +func (*ResolveSubcategoryItemCountResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{171} +} + +func (x *ResolveSubcategoryItemCountResponse) GetResult() []*ResolveSubcategoryItemCountResult { + if x != nil { + return x.Result + } + return nil +} + +type ResolveCategoryMetricsNormalizedScoreArgs struct { + state protoimpl.MessageState `protogen:"open.v1"` + Baseline float64 `protobuf:"fixed64,1,opt,name=baseline,proto3" json:"baseline,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMetricsNormalizedScoreArgs) Reset() { + *x = ResolveCategoryMetricsNormalizedScoreArgs{} + mi := &file_product_proto_msgTypes[172] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryMetricsNormalizedScoreArgs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryMetricsNormalizedScoreArgs) ProtoMessage() {} + +func (x *ResolveCategoryMetricsNormalizedScoreArgs) 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 ResolveCategoryMetricsNormalizedScoreArgs.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsNormalizedScoreArgs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{172} +} + +func (x *ResolveCategoryMetricsNormalizedScoreArgs) GetBaseline() float64 { + if x != nil { + return x.Baseline + } + return 0 +} + +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"` + Value float64 `protobuf:"fixed64,3,opt,name=value,proto3" json:"value,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMetricsNormalizedScoreContext) Reset() { + *x = ResolveCategoryMetricsNormalizedScoreContext{} + mi := &file_product_proto_msgTypes[173] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryMetricsNormalizedScoreContext) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryMetricsNormalizedScoreContext) ProtoMessage() {} + +func (x *ResolveCategoryMetricsNormalizedScoreContext) 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 ResolveCategoryMetricsNormalizedScoreContext.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsNormalizedScoreContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{173} +} + +func (x *ResolveCategoryMetricsNormalizedScoreContext) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *ResolveCategoryMetricsNormalizedScoreContext) GetMetricType() string { + if x != nil { + return x.MetricType + } + return "" +} + +func (x *ResolveCategoryMetricsNormalizedScoreContext) GetValue() float64 { + if x != nil { + return x.Value + } + return 0 +} + +type ResolveCategoryMetricsNormalizedScoreRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // context provides the resolver context for the field normalizedScore of type CategoryMetrics. + Context []*ResolveCategoryMetricsNormalizedScoreContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field normalizedScore of type CategoryMetrics. + FieldArgs *ResolveCategoryMetricsNormalizedScoreArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMetricsNormalizedScoreRequest) Reset() { + *x = ResolveCategoryMetricsNormalizedScoreRequest{} + mi := &file_product_proto_msgTypes[174] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryMetricsNormalizedScoreRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryMetricsNormalizedScoreRequest) ProtoMessage() {} + +func (x *ResolveCategoryMetricsNormalizedScoreRequest) 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 ResolveCategoryMetricsNormalizedScoreRequest.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsNormalizedScoreRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{174} +} + +func (x *ResolveCategoryMetricsNormalizedScoreRequest) GetContext() []*ResolveCategoryMetricsNormalizedScoreContext { + if x != nil { + return x.Context + } + return nil +} + +func (x *ResolveCategoryMetricsNormalizedScoreRequest) GetFieldArgs() *ResolveCategoryMetricsNormalizedScoreArgs { + if x != nil { + return x.FieldArgs + } + return nil +} + +type ResolveCategoryMetricsNormalizedScoreResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + NormalizedScore float64 `protobuf:"fixed64,1,opt,name=normalized_score,json=normalizedScore,proto3" json:"normalized_score,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMetricsNormalizedScoreResult) Reset() { + *x = ResolveCategoryMetricsNormalizedScoreResult{} + mi := &file_product_proto_msgTypes[175] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryMetricsNormalizedScoreResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryMetricsNormalizedScoreResult) ProtoMessage() {} + +func (x *ResolveCategoryMetricsNormalizedScoreResult) 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 ResolveCategoryMetricsNormalizedScoreResult.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsNormalizedScoreResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{175} +} + +func (x *ResolveCategoryMetricsNormalizedScoreResult) GetNormalizedScore() float64 { + if x != nil { + return x.NormalizedScore + } + return 0 +} + +type ResolveCategoryMetricsNormalizedScoreResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Result []*ResolveCategoryMetricsNormalizedScoreResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveCategoryMetricsNormalizedScoreResponse) Reset() { + *x = ResolveCategoryMetricsNormalizedScoreResponse{} + mi := &file_product_proto_msgTypes[176] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveCategoryMetricsNormalizedScoreResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveCategoryMetricsNormalizedScoreResponse) ProtoMessage() {} + +func (x *ResolveCategoryMetricsNormalizedScoreResponse) 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 ResolveCategoryMetricsNormalizedScoreResponse.ProtoReflect.Descriptor instead. +func (*ResolveCategoryMetricsNormalizedScoreResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{176} +} + +func (x *ResolveCategoryMetricsNormalizedScoreResponse) GetResult() []*ResolveCategoryMetricsNormalizedScoreResult { + if x != nil { + return x.Result + } + return nil +} + +type ResolveTestContainerDetailsArgs struct { + state protoimpl.MessageState `protogen:"open.v1"` + IncludeExtended bool `protobuf:"varint,1,opt,name=include_extended,json=includeExtended,proto3" json:"include_extended,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResolveTestContainerDetailsArgs) Reset() { + *x = ResolveTestContainerDetailsArgs{} + mi := &file_product_proto_msgTypes[177] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResolveTestContainerDetailsArgs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResolveTestContainerDetailsArgs) ProtoMessage() {} + +func (x *ResolveTestContainerDetailsArgs) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[177] + 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 ResolveTestContainerDetailsArgs.ProtoReflect.Descriptor instead. +func (*ResolveTestContainerDetailsArgs) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{177} } -func (x *ResolveSubcategoryItemCountArgs) GetFilters() *SubcategoryItemFilter { +func (x *ResolveTestContainerDetailsArgs) GetIncludeExtended() bool { if x != nil { - return x.Filters + return x.IncludeExtended } - return nil + return false } -type ResolveSubcategoryItemCountContext struct { +type ResolveTestContainerDetailsContext 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 *ResolveSubcategoryItemCountContext) Reset() { - *x = ResolveSubcategoryItemCountContext{} - mi := &file_product_proto_msgTypes[139] +func (x *ResolveTestContainerDetailsContext) Reset() { + *x = ResolveTestContainerDetailsContext{} + mi := &file_product_proto_msgTypes[178] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryItemCountContext) String() string { +func (x *ResolveTestContainerDetailsContext) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryItemCountContext) ProtoMessage() {} +func (*ResolveTestContainerDetailsContext) ProtoMessage() {} -func (x *ResolveSubcategoryItemCountContext) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[139] +func (x *ResolveTestContainerDetailsContext) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[178] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6456,43 +8311,50 @@ func (x *ResolveSubcategoryItemCountContext) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryItemCountContext.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryItemCountContext) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{139} +// Deprecated: Use ResolveTestContainerDetailsContext.ProtoReflect.Descriptor instead. +func (*ResolveTestContainerDetailsContext) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{178} } -func (x *ResolveSubcategoryItemCountContext) GetId() string { +func (x *ResolveTestContainerDetailsContext) GetId() string { if x != nil { return x.Id } return "" } -type ResolveSubcategoryItemCountRequest struct { +func (x *ResolveTestContainerDetailsContext) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type ResolveTestContainerDetailsRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // context provides the resolver context for the field itemCount of type Subcategory. - Context []*ResolveSubcategoryItemCountContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` - // field_args provides the arguments for the resolver field itemCount of type Subcategory. - FieldArgs *ResolveSubcategoryItemCountArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` + // context provides the resolver context for the field details of type TestContainer. + Context []*ResolveTestContainerDetailsContext `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"` + // field_args provides the arguments for the resolver field details of type TestContainer. + FieldArgs *ResolveTestContainerDetailsArgs `protobuf:"bytes,2,opt,name=field_args,json=fieldArgs,proto3" json:"field_args,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveSubcategoryItemCountRequest) Reset() { - *x = ResolveSubcategoryItemCountRequest{} - mi := &file_product_proto_msgTypes[140] +func (x *ResolveTestContainerDetailsRequest) Reset() { + *x = ResolveTestContainerDetailsRequest{} + mi := &file_product_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryItemCountRequest) String() string { +func (x *ResolveTestContainerDetailsRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryItemCountRequest) ProtoMessage() {} +func (*ResolveTestContainerDetailsRequest) ProtoMessage() {} -func (x *ResolveSubcategoryItemCountRequest) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[140] +func (x *ResolveTestContainerDetailsRequest) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[179] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6503,47 +8365,47 @@ func (x *ResolveSubcategoryItemCountRequest) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryItemCountRequest.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryItemCountRequest) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{140} +// Deprecated: Use ResolveTestContainerDetailsRequest.ProtoReflect.Descriptor instead. +func (*ResolveTestContainerDetailsRequest) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{179} } -func (x *ResolveSubcategoryItemCountRequest) GetContext() []*ResolveSubcategoryItemCountContext { +func (x *ResolveTestContainerDetailsRequest) GetContext() []*ResolveTestContainerDetailsContext { if x != nil { return x.Context } return nil } -func (x *ResolveSubcategoryItemCountRequest) GetFieldArgs() *ResolveSubcategoryItemCountArgs { +func (x *ResolveTestContainerDetailsRequest) GetFieldArgs() *ResolveTestContainerDetailsArgs { if x != nil { return x.FieldArgs } return nil } -type ResolveSubcategoryItemCountResult struct { +type ResolveTestContainerDetailsResult struct { state protoimpl.MessageState `protogen:"open.v1"` - ItemCount int32 `protobuf:"varint,1,opt,name=item_count,json=itemCount,proto3" json:"item_count,omitempty"` + Details *TestDetails `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveSubcategoryItemCountResult) Reset() { - *x = ResolveSubcategoryItemCountResult{} - mi := &file_product_proto_msgTypes[141] +func (x *ResolveTestContainerDetailsResult) Reset() { + *x = ResolveTestContainerDetailsResult{} + mi := &file_product_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryItemCountResult) String() string { +func (x *ResolveTestContainerDetailsResult) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryItemCountResult) ProtoMessage() {} +func (*ResolveTestContainerDetailsResult) ProtoMessage() {} -func (x *ResolveSubcategoryItemCountResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[141] +func (x *ResolveTestContainerDetailsResult) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[180] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6554,40 +8416,40 @@ func (x *ResolveSubcategoryItemCountResult) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryItemCountResult.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryItemCountResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{141} +// Deprecated: Use ResolveTestContainerDetailsResult.ProtoReflect.Descriptor instead. +func (*ResolveTestContainerDetailsResult) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{180} } -func (x *ResolveSubcategoryItemCountResult) GetItemCount() int32 { +func (x *ResolveTestContainerDetailsResult) GetDetails() *TestDetails { if x != nil { - return x.ItemCount + return x.Details } - return 0 + return nil } -type ResolveSubcategoryItemCountResponse struct { +type ResolveTestContainerDetailsResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - Result []*ResolveSubcategoryItemCountResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` + Result []*ResolveTestContainerDetailsResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResolveSubcategoryItemCountResponse) Reset() { - *x = ResolveSubcategoryItemCountResponse{} - mi := &file_product_proto_msgTypes[142] +func (x *ResolveTestContainerDetailsResponse) Reset() { + *x = ResolveTestContainerDetailsResponse{} + mi := &file_product_proto_msgTypes[181] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResolveSubcategoryItemCountResponse) String() string { +func (x *ResolveTestContainerDetailsResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResolveSubcategoryItemCountResponse) ProtoMessage() {} +func (*ResolveTestContainerDetailsResponse) ProtoMessage() {} -func (x *ResolveSubcategoryItemCountResponse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[142] +func (x *ResolveTestContainerDetailsResponse) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[181] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6598,12 +8460,12 @@ func (x *ResolveSubcategoryItemCountResponse) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use ResolveSubcategoryItemCountResponse.ProtoReflect.Descriptor instead. -func (*ResolveSubcategoryItemCountResponse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{142} +// Deprecated: Use ResolveTestContainerDetailsResponse.ProtoReflect.Descriptor instead. +func (*ResolveTestContainerDetailsResponse) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{181} } -func (x *ResolveSubcategoryItemCountResponse) GetResult() []*ResolveSubcategoryItemCountResult { +func (x *ResolveTestContainerDetailsResponse) GetResult() []*ResolveTestContainerDetailsResult { if x != nil { return x.Result } @@ -6621,7 +8483,7 @@ type Product struct { func (x *Product) Reset() { *x = Product{} - mi := &file_product_proto_msgTypes[143] + mi := &file_product_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6633,7 +8495,7 @@ func (x *Product) String() string { func (*Product) ProtoMessage() {} func (x *Product) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[143] + mi := &file_product_proto_msgTypes[182] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6646,7 +8508,7 @@ func (x *Product) ProtoReflect() protoreflect.Message { // Deprecated: Use Product.ProtoReflect.Descriptor instead. func (*Product) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{143} + return file_product_proto_rawDescGZIP(), []int{182} } func (x *Product) GetId() string { @@ -6681,7 +8543,7 @@ type Storage struct { func (x *Storage) Reset() { *x = Storage{} - mi := &file_product_proto_msgTypes[144] + mi := &file_product_proto_msgTypes[183] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6693,7 +8555,7 @@ func (x *Storage) String() string { func (*Storage) ProtoMessage() {} func (x *Storage) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[144] + mi := &file_product_proto_msgTypes[183] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6706,7 +8568,7 @@ func (x *Storage) ProtoReflect() protoreflect.Message { // Deprecated: Use Storage.ProtoReflect.Descriptor instead. func (*Storage) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{144} + return file_product_proto_rawDescGZIP(), []int{183} } func (x *Storage) GetId() string { @@ -6741,7 +8603,7 @@ type Warehouse struct { func (x *Warehouse) Reset() { *x = Warehouse{} - mi := &file_product_proto_msgTypes[145] + mi := &file_product_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6753,7 +8615,7 @@ func (x *Warehouse) String() string { func (*Warehouse) ProtoMessage() {} func (x *Warehouse) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[145] + mi := &file_product_proto_msgTypes[184] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6766,7 +8628,7 @@ func (x *Warehouse) ProtoReflect() protoreflect.Message { // Deprecated: Use Warehouse.ProtoReflect.Descriptor instead. func (*Warehouse) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{145} + return file_product_proto_rawDescGZIP(), []int{184} } func (x *Warehouse) GetId() string { @@ -6800,7 +8662,7 @@ type User struct { func (x *User) Reset() { *x = User{} - mi := &file_product_proto_msgTypes[146] + mi := &file_product_proto_msgTypes[185] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6812,7 +8674,7 @@ func (x *User) String() string { func (*User) ProtoMessage() {} func (x *User) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[146] + mi := &file_product_proto_msgTypes[185] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6825,7 +8687,7 @@ func (x *User) ProtoReflect() protoreflect.Message { // Deprecated: Use User.ProtoReflect.Descriptor instead. func (*User) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{146} + return file_product_proto_rawDescGZIP(), []int{185} } func (x *User) GetId() string { @@ -6853,7 +8715,7 @@ type NestedTypeA struct { func (x *NestedTypeA) Reset() { *x = NestedTypeA{} - mi := &file_product_proto_msgTypes[147] + mi := &file_product_proto_msgTypes[186] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6865,7 +8727,7 @@ func (x *NestedTypeA) String() string { func (*NestedTypeA) ProtoMessage() {} func (x *NestedTypeA) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[147] + mi := &file_product_proto_msgTypes[186] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6878,7 +8740,7 @@ func (x *NestedTypeA) ProtoReflect() protoreflect.Message { // Deprecated: Use NestedTypeA.ProtoReflect.Descriptor instead. func (*NestedTypeA) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{147} + return file_product_proto_rawDescGZIP(), []int{186} } func (x *NestedTypeA) GetId() string { @@ -6913,7 +8775,7 @@ type RecursiveType struct { func (x *RecursiveType) Reset() { *x = RecursiveType{} - mi := &file_product_proto_msgTypes[148] + mi := &file_product_proto_msgTypes[187] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6925,7 +8787,7 @@ func (x *RecursiveType) String() string { func (*RecursiveType) ProtoMessage() {} func (x *RecursiveType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[148] + mi := &file_product_proto_msgTypes[187] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6938,7 +8800,7 @@ func (x *RecursiveType) ProtoReflect() protoreflect.Message { // Deprecated: Use RecursiveType.ProtoReflect.Descriptor instead. func (*RecursiveType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{148} + return file_product_proto_rawDescGZIP(), []int{187} } func (x *RecursiveType) GetId() string { @@ -6974,7 +8836,7 @@ type TypeWithMultipleFilterFields struct { func (x *TypeWithMultipleFilterFields) Reset() { *x = TypeWithMultipleFilterFields{} - mi := &file_product_proto_msgTypes[149] + mi := &file_product_proto_msgTypes[188] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6986,7 +8848,7 @@ func (x *TypeWithMultipleFilterFields) String() string { func (*TypeWithMultipleFilterFields) ProtoMessage() {} func (x *TypeWithMultipleFilterFields) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[149] + mi := &file_product_proto_msgTypes[188] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6999,7 +8861,7 @@ func (x *TypeWithMultipleFilterFields) ProtoReflect() protoreflect.Message { // Deprecated: Use TypeWithMultipleFilterFields.ProtoReflect.Descriptor instead. func (*TypeWithMultipleFilterFields) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{149} + return file_product_proto_rawDescGZIP(), []int{188} } func (x *TypeWithMultipleFilterFields) GetId() string { @@ -7040,7 +8902,7 @@ type FilterTypeInput struct { func (x *FilterTypeInput) Reset() { *x = FilterTypeInput{} - mi := &file_product_proto_msgTypes[150] + mi := &file_product_proto_msgTypes[189] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7052,7 +8914,7 @@ func (x *FilterTypeInput) String() string { func (*FilterTypeInput) ProtoMessage() {} func (x *FilterTypeInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[150] + mi := &file_product_proto_msgTypes[189] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7065,7 +8927,7 @@ func (x *FilterTypeInput) ProtoReflect() protoreflect.Message { // Deprecated: Use FilterTypeInput.ProtoReflect.Descriptor instead. func (*FilterTypeInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{150} + return file_product_proto_rawDescGZIP(), []int{189} } func (x *FilterTypeInput) GetFilterField_1() string { @@ -7091,7 +8953,7 @@ type ComplexFilterTypeInput struct { func (x *ComplexFilterTypeInput) Reset() { *x = ComplexFilterTypeInput{} - mi := &file_product_proto_msgTypes[151] + mi := &file_product_proto_msgTypes[190] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7103,7 +8965,7 @@ func (x *ComplexFilterTypeInput) String() string { func (*ComplexFilterTypeInput) ProtoMessage() {} func (x *ComplexFilterTypeInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[151] + mi := &file_product_proto_msgTypes[190] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7116,7 +8978,7 @@ func (x *ComplexFilterTypeInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ComplexFilterTypeInput.ProtoReflect.Descriptor instead. func (*ComplexFilterTypeInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{151} + return file_product_proto_rawDescGZIP(), []int{190} } func (x *ComplexFilterTypeInput) GetFilter() *FilterType { @@ -7136,7 +8998,7 @@ type TypeWithComplexFilterInput struct { func (x *TypeWithComplexFilterInput) Reset() { *x = TypeWithComplexFilterInput{} - mi := &file_product_proto_msgTypes[152] + mi := &file_product_proto_msgTypes[191] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7148,7 +9010,7 @@ func (x *TypeWithComplexFilterInput) String() string { func (*TypeWithComplexFilterInput) ProtoMessage() {} func (x *TypeWithComplexFilterInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[152] + mi := &file_product_proto_msgTypes[191] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7161,7 +9023,7 @@ func (x *TypeWithComplexFilterInput) ProtoReflect() protoreflect.Message { // Deprecated: Use TypeWithComplexFilterInput.ProtoReflect.Descriptor instead. func (*TypeWithComplexFilterInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{152} + return file_product_proto_rawDescGZIP(), []int{191} } func (x *TypeWithComplexFilterInput) GetId() string { @@ -7189,7 +9051,7 @@ type OrderInput struct { func (x *OrderInput) Reset() { *x = OrderInput{} - mi := &file_product_proto_msgTypes[153] + mi := &file_product_proto_msgTypes[192] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7201,7 +9063,7 @@ func (x *OrderInput) String() string { func (*OrderInput) ProtoMessage() {} func (x *OrderInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[153] + mi := &file_product_proto_msgTypes[192] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7214,7 +9076,7 @@ func (x *OrderInput) ProtoReflect() protoreflect.Message { // Deprecated: Use OrderInput.ProtoReflect.Descriptor instead. func (*OrderInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{153} + return file_product_proto_rawDescGZIP(), []int{192} } func (x *OrderInput) GetOrderId() string { @@ -7250,7 +9112,7 @@ type Order struct { func (x *Order) Reset() { *x = Order{} - mi := &file_product_proto_msgTypes[154] + mi := &file_product_proto_msgTypes[193] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7262,7 +9124,7 @@ func (x *Order) String() string { func (*Order) ProtoMessage() {} func (x *Order) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[154] + mi := &file_product_proto_msgTypes[193] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7275,7 +9137,7 @@ func (x *Order) ProtoReflect() protoreflect.Message { // Deprecated: Use Order.ProtoReflect.Descriptor instead. func (*Order) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{154} + return file_product_proto_rawDescGZIP(), []int{193} } func (x *Order) GetOrderId() string { @@ -7318,7 +9180,7 @@ type Category struct { func (x *Category) Reset() { *x = Category{} - mi := &file_product_proto_msgTypes[155] + mi := &file_product_proto_msgTypes[194] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7330,7 +9192,7 @@ func (x *Category) String() string { func (*Category) ProtoMessage() {} func (x *Category) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[155] + mi := &file_product_proto_msgTypes[194] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7343,7 +9205,7 @@ func (x *Category) ProtoReflect() protoreflect.Message { // Deprecated: Use Category.ProtoReflect.Descriptor instead. func (*Category) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{155} + return file_product_proto_rawDescGZIP(), []int{194} } func (x *Category) GetId() string { @@ -7384,7 +9246,7 @@ type CategoryFilter struct { func (x *CategoryFilter) Reset() { *x = CategoryFilter{} - mi := &file_product_proto_msgTypes[156] + mi := &file_product_proto_msgTypes[195] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7396,7 +9258,7 @@ func (x *CategoryFilter) String() string { func (*CategoryFilter) ProtoMessage() {} func (x *CategoryFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[156] + mi := &file_product_proto_msgTypes[195] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7409,7 +9271,7 @@ func (x *CategoryFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use CategoryFilter.ProtoReflect.Descriptor instead. func (*CategoryFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{156} + return file_product_proto_rawDescGZIP(), []int{195} } func (x *CategoryFilter) GetCategory() CategoryKind { @@ -7439,7 +9301,7 @@ type Animal struct { func (x *Animal) Reset() { *x = Animal{} - mi := &file_product_proto_msgTypes[157] + mi := &file_product_proto_msgTypes[196] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7451,7 +9313,7 @@ func (x *Animal) String() string { func (*Animal) ProtoMessage() {} func (x *Animal) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[157] + mi := &file_product_proto_msgTypes[196] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7464,7 +9326,7 @@ func (x *Animal) ProtoReflect() protoreflect.Message { // Deprecated: Use Animal.ProtoReflect.Descriptor instead. func (*Animal) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{157} + return file_product_proto_rawDescGZIP(), []int{196} } func (x *Animal) GetInstance() isAnimal_Instance { @@ -7518,7 +9380,7 @@ type SearchInput struct { func (x *SearchInput) Reset() { *x = SearchInput{} - mi := &file_product_proto_msgTypes[158] + mi := &file_product_proto_msgTypes[197] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7530,7 +9392,7 @@ func (x *SearchInput) String() string { func (*SearchInput) ProtoMessage() {} func (x *SearchInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[158] + mi := &file_product_proto_msgTypes[197] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7543,7 +9405,7 @@ func (x *SearchInput) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchInput.ProtoReflect.Descriptor instead. func (*SearchInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{158} + return file_product_proto_rawDescGZIP(), []int{197} } func (x *SearchInput) GetQuery() string { @@ -7574,7 +9436,7 @@ type SearchResult struct { func (x *SearchResult) Reset() { *x = SearchResult{} - mi := &file_product_proto_msgTypes[159] + mi := &file_product_proto_msgTypes[198] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7586,7 +9448,7 @@ func (x *SearchResult) String() string { func (*SearchResult) ProtoMessage() {} func (x *SearchResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[159] + mi := &file_product_proto_msgTypes[198] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7599,7 +9461,7 @@ func (x *SearchResult) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchResult.ProtoReflect.Descriptor instead. func (*SearchResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{159} + return file_product_proto_rawDescGZIP(), []int{198} } func (x *SearchResult) GetValue() isSearchResult_Value { @@ -7674,7 +9536,7 @@ type NullableFieldsType struct { func (x *NullableFieldsType) Reset() { *x = NullableFieldsType{} - mi := &file_product_proto_msgTypes[160] + mi := &file_product_proto_msgTypes[199] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7686,7 +9548,7 @@ func (x *NullableFieldsType) String() string { func (*NullableFieldsType) ProtoMessage() {} func (x *NullableFieldsType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[160] + mi := &file_product_proto_msgTypes[199] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7699,7 +9561,7 @@ func (x *NullableFieldsType) ProtoReflect() protoreflect.Message { // Deprecated: Use NullableFieldsType.ProtoReflect.Descriptor instead. func (*NullableFieldsType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{160} + return file_product_proto_rawDescGZIP(), []int{199} } func (x *NullableFieldsType) GetId() string { @@ -7769,7 +9631,7 @@ type NullableFieldsFilter struct { func (x *NullableFieldsFilter) Reset() { *x = NullableFieldsFilter{} - mi := &file_product_proto_msgTypes[161] + mi := &file_product_proto_msgTypes[200] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7781,7 +9643,7 @@ func (x *NullableFieldsFilter) String() string { func (*NullableFieldsFilter) ProtoMessage() {} func (x *NullableFieldsFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[161] + mi := &file_product_proto_msgTypes[200] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7794,7 +9656,7 @@ func (x *NullableFieldsFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use NullableFieldsFilter.ProtoReflect.Descriptor instead. func (*NullableFieldsFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{161} + return file_product_proto_rawDescGZIP(), []int{200} } func (x *NullableFieldsFilter) GetName() *wrapperspb.StringValue { @@ -7846,7 +9708,7 @@ type BlogPost struct { func (x *BlogPost) Reset() { *x = BlogPost{} - mi := &file_product_proto_msgTypes[162] + mi := &file_product_proto_msgTypes[201] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7858,7 +9720,7 @@ func (x *BlogPost) String() string { func (*BlogPost) ProtoMessage() {} func (x *BlogPost) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[162] + mi := &file_product_proto_msgTypes[201] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7871,7 +9733,7 @@ func (x *BlogPost) ProtoReflect() protoreflect.Message { // Deprecated: Use BlogPost.ProtoReflect.Descriptor instead. func (*BlogPost) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{162} + return file_product_proto_rawDescGZIP(), []int{201} } func (x *BlogPost) GetId() string { @@ -8025,7 +9887,7 @@ type BlogPostFilter struct { func (x *BlogPostFilter) Reset() { *x = BlogPostFilter{} - mi := &file_product_proto_msgTypes[163] + mi := &file_product_proto_msgTypes[202] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8037,7 +9899,7 @@ func (x *BlogPostFilter) String() string { func (*BlogPostFilter) ProtoMessage() {} func (x *BlogPostFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[163] + mi := &file_product_proto_msgTypes[202] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8050,7 +9912,7 @@ func (x *BlogPostFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use BlogPostFilter.ProtoReflect.Descriptor instead. func (*BlogPostFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{163} + return file_product_proto_rawDescGZIP(), []int{202} } func (x *BlogPostFilter) GetTitle() *wrapperspb.StringValue { @@ -8097,7 +9959,7 @@ type Author struct { func (x *Author) Reset() { *x = Author{} - mi := &file_product_proto_msgTypes[164] + mi := &file_product_proto_msgTypes[203] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8109,7 +9971,7 @@ func (x *Author) String() string { func (*Author) ProtoMessage() {} func (x *Author) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[164] + mi := &file_product_proto_msgTypes[203] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8122,7 +9984,7 @@ func (x *Author) ProtoReflect() protoreflect.Message { // Deprecated: Use Author.ProtoReflect.Descriptor instead. func (*Author) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{164} + return file_product_proto_rawDescGZIP(), []int{203} } func (x *Author) GetId() string { @@ -8241,7 +10103,7 @@ type AuthorFilter struct { func (x *AuthorFilter) Reset() { *x = AuthorFilter{} - mi := &file_product_proto_msgTypes[165] + mi := &file_product_proto_msgTypes[204] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8250,10 +10112,70 @@ func (x *AuthorFilter) String() string { return protoimpl.X.MessageStringOf(x) } -func (*AuthorFilter) ProtoMessage() {} +func (*AuthorFilter) ProtoMessage() {} + +func (x *AuthorFilter) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[204] + 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 AuthorFilter.ProtoReflect.Descriptor instead. +func (*AuthorFilter) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{204} +} + +func (x *AuthorFilter) GetName() *wrapperspb.StringValue { + if x != nil { + return x.Name + } + return nil +} + +func (x *AuthorFilter) GetHasTeams() *wrapperspb.BoolValue { + if x != nil { + return x.HasTeams + } + return nil +} + +func (x *AuthorFilter) GetSkillCount() *wrapperspb.Int32Value { + if x != nil { + return x.SkillCount + } + return nil +} + +type TestContainer 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"` + Description *wrapperspb.StringValue `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TestContainer) Reset() { + *x = TestContainer{} + mi := &file_product_proto_msgTypes[205] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TestContainer) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestContainer) ProtoMessage() {} -func (x *AuthorFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[165] +func (x *TestContainer) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[205] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8264,28 +10186,28 @@ func (x *AuthorFilter) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use AuthorFilter.ProtoReflect.Descriptor instead. -func (*AuthorFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{165} +// Deprecated: Use TestContainer.ProtoReflect.Descriptor instead. +func (*TestContainer) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{205} } -func (x *AuthorFilter) GetName() *wrapperspb.StringValue { +func (x *TestContainer) GetId() string { if x != nil { - return x.Name + return x.Id } - return nil + return "" } -func (x *AuthorFilter) GetHasTeams() *wrapperspb.BoolValue { +func (x *TestContainer) GetName() string { if x != nil { - return x.HasTeams + return x.Name } - return nil + return "" } -func (x *AuthorFilter) GetSkillCount() *wrapperspb.Int32Value { +func (x *TestContainer) GetDescription() *wrapperspb.StringValue { if x != nil { - return x.SkillCount + return x.Description } return nil } @@ -8299,7 +10221,7 @@ type UserInput struct { func (x *UserInput) Reset() { *x = UserInput{} - mi := &file_product_proto_msgTypes[166] + mi := &file_product_proto_msgTypes[206] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8311,7 +10233,7 @@ func (x *UserInput) String() string { func (*UserInput) ProtoMessage() {} func (x *UserInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[166] + mi := &file_product_proto_msgTypes[206] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8324,7 +10246,7 @@ func (x *UserInput) ProtoReflect() protoreflect.Message { // Deprecated: Use UserInput.ProtoReflect.Descriptor instead. func (*UserInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{166} + return file_product_proto_rawDescGZIP(), []int{206} } func (x *UserInput) GetName() string { @@ -8344,7 +10266,7 @@ type ActionInput struct { func (x *ActionInput) Reset() { *x = ActionInput{} - mi := &file_product_proto_msgTypes[167] + mi := &file_product_proto_msgTypes[207] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8356,7 +10278,7 @@ func (x *ActionInput) String() string { func (*ActionInput) ProtoMessage() {} func (x *ActionInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[167] + mi := &file_product_proto_msgTypes[207] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8369,7 +10291,7 @@ func (x *ActionInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionInput.ProtoReflect.Descriptor instead. func (*ActionInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{167} + return file_product_proto_rawDescGZIP(), []int{207} } func (x *ActionInput) GetType() string { @@ -8399,7 +10321,7 @@ type ActionResult struct { func (x *ActionResult) Reset() { *x = ActionResult{} - mi := &file_product_proto_msgTypes[168] + mi := &file_product_proto_msgTypes[208] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8411,7 +10333,7 @@ func (x *ActionResult) String() string { func (*ActionResult) ProtoMessage() {} func (x *ActionResult) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[168] + mi := &file_product_proto_msgTypes[208] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8424,7 +10346,7 @@ func (x *ActionResult) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionResult.ProtoReflect.Descriptor instead. func (*ActionResult) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{168} + return file_product_proto_rawDescGZIP(), []int{208} } func (x *ActionResult) GetValue() isActionResult_Value { @@ -8483,7 +10405,7 @@ type NullableFieldsInput struct { func (x *NullableFieldsInput) Reset() { *x = NullableFieldsInput{} - mi := &file_product_proto_msgTypes[169] + mi := &file_product_proto_msgTypes[209] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8495,7 +10417,7 @@ func (x *NullableFieldsInput) String() string { func (*NullableFieldsInput) ProtoMessage() {} func (x *NullableFieldsInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[169] + mi := &file_product_proto_msgTypes[209] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8508,7 +10430,7 @@ func (x *NullableFieldsInput) ProtoReflect() protoreflect.Message { // Deprecated: Use NullableFieldsInput.ProtoReflect.Descriptor instead. func (*NullableFieldsInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{169} + return file_product_proto_rawDescGZIP(), []int{209} } func (x *NullableFieldsInput) GetName() string { @@ -8584,7 +10506,7 @@ type BlogPostInput struct { func (x *BlogPostInput) Reset() { *x = BlogPostInput{} - mi := &file_product_proto_msgTypes[170] + mi := &file_product_proto_msgTypes[210] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8596,7 +10518,7 @@ func (x *BlogPostInput) String() string { func (*BlogPostInput) ProtoMessage() {} func (x *BlogPostInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[170] + mi := &file_product_proto_msgTypes[210] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8609,7 +10531,7 @@ func (x *BlogPostInput) ProtoReflect() protoreflect.Message { // Deprecated: Use BlogPostInput.ProtoReflect.Descriptor instead. func (*BlogPostInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{170} + return file_product_proto_rawDescGZIP(), []int{210} } func (x *BlogPostInput) GetTitle() string { @@ -8742,7 +10664,7 @@ type AuthorInput struct { func (x *AuthorInput) Reset() { *x = AuthorInput{} - mi := &file_product_proto_msgTypes[171] + mi := &file_product_proto_msgTypes[211] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8754,7 +10676,7 @@ func (x *AuthorInput) String() string { func (*AuthorInput) ProtoMessage() {} func (x *AuthorInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[171] + mi := &file_product_proto_msgTypes[211] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8767,7 +10689,7 @@ func (x *AuthorInput) ProtoReflect() protoreflect.Message { // Deprecated: Use AuthorInput.ProtoReflect.Descriptor instead. func (*AuthorInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{171} + return file_product_proto_rawDescGZIP(), []int{211} } func (x *AuthorInput) GetName() string { @@ -8840,6 +10762,74 @@ func (x *AuthorInput) GetProjectTeams() *ListOfListOfUserInput { return nil } +type ProductDetails struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + ReviewSummary *ActionResult `protobuf:"bytes,3,opt,name=review_summary,json=reviewSummary,proto3" json:"review_summary,omitempty"` + RecommendedPet *Animal `protobuf:"bytes,4,opt,name=recommended_pet,json=recommendedPet,proto3" json:"recommended_pet,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProductDetails) Reset() { + *x = ProductDetails{} + mi := &file_product_proto_msgTypes[212] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProductDetails) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProductDetails) ProtoMessage() {} + +func (x *ProductDetails) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[212] + 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 ProductDetails.ProtoReflect.Descriptor instead. +func (*ProductDetails) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{212} +} + +func (x *ProductDetails) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *ProductDetails) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +func (x *ProductDetails) GetReviewSummary() *ActionResult { + if x != nil { + return x.ReviewSummary + } + return nil +} + +func (x *ProductDetails) GetRecommendedPet() *Animal { + if x != nil { + return x.RecommendedPet + } + return nil +} + type NestedTypeB struct { state protoimpl.MessageState `protogen:"open.v1"` Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` @@ -8851,7 +10841,7 @@ type NestedTypeB struct { func (x *NestedTypeB) Reset() { *x = NestedTypeB{} - mi := &file_product_proto_msgTypes[172] + mi := &file_product_proto_msgTypes[213] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8863,7 +10853,7 @@ func (x *NestedTypeB) String() string { func (*NestedTypeB) ProtoMessage() {} func (x *NestedTypeB) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[172] + mi := &file_product_proto_msgTypes[213] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8876,7 +10866,7 @@ func (x *NestedTypeB) ProtoReflect() protoreflect.Message { // Deprecated: Use NestedTypeB.ProtoReflect.Descriptor instead. func (*NestedTypeB) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{172} + return file_product_proto_rawDescGZIP(), []int{213} } func (x *NestedTypeB) GetId() string { @@ -8910,7 +10900,7 @@ type NestedTypeC struct { func (x *NestedTypeC) Reset() { *x = NestedTypeC{} - mi := &file_product_proto_msgTypes[173] + mi := &file_product_proto_msgTypes[214] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8922,7 +10912,7 @@ func (x *NestedTypeC) String() string { func (*NestedTypeC) ProtoMessage() {} func (x *NestedTypeC) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[173] + mi := &file_product_proto_msgTypes[214] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8935,7 +10925,7 @@ func (x *NestedTypeC) ProtoReflect() protoreflect.Message { // Deprecated: Use NestedTypeC.ProtoReflect.Descriptor instead. func (*NestedTypeC) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{173} + return file_product_proto_rawDescGZIP(), []int{214} } func (x *NestedTypeC) GetId() string { @@ -8964,7 +10954,7 @@ type FilterType struct { func (x *FilterType) Reset() { *x = FilterType{} - mi := &file_product_proto_msgTypes[174] + mi := &file_product_proto_msgTypes[215] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8976,7 +10966,7 @@ func (x *FilterType) String() string { func (*FilterType) ProtoMessage() {} func (x *FilterType) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[174] + mi := &file_product_proto_msgTypes[215] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8989,7 +10979,7 @@ func (x *FilterType) ProtoReflect() protoreflect.Message { // Deprecated: Use FilterType.ProtoReflect.Descriptor instead. func (*FilterType) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{174} + return file_product_proto_rawDescGZIP(), []int{215} } func (x *FilterType) GetName() string { @@ -9030,7 +11020,7 @@ type Pagination struct { func (x *Pagination) Reset() { *x = Pagination{} - mi := &file_product_proto_msgTypes[175] + mi := &file_product_proto_msgTypes[216] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9042,7 +11032,7 @@ func (x *Pagination) String() string { func (*Pagination) ProtoMessage() {} func (x *Pagination) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[175] + mi := &file_product_proto_msgTypes[216] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9055,7 +11045,7 @@ func (x *Pagination) ProtoReflect() protoreflect.Message { // Deprecated: Use Pagination.ProtoReflect.Descriptor instead. func (*Pagination) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{175} + return file_product_proto_rawDescGZIP(), []int{216} } func (x *Pagination) GetPage() int32 { @@ -9083,7 +11073,7 @@ type OrderLineInput struct { func (x *OrderLineInput) Reset() { *x = OrderLineInput{} - mi := &file_product_proto_msgTypes[176] + mi := &file_product_proto_msgTypes[217] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9095,7 +11085,7 @@ func (x *OrderLineInput) String() string { func (*OrderLineInput) ProtoMessage() {} func (x *OrderLineInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[176] + mi := &file_product_proto_msgTypes[217] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9108,7 +11098,7 @@ func (x *OrderLineInput) ProtoReflect() protoreflect.Message { // Deprecated: Use OrderLineInput.ProtoReflect.Descriptor instead. func (*OrderLineInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{176} + return file_product_proto_rawDescGZIP(), []int{217} } func (x *OrderLineInput) GetProductId() string { @@ -9143,7 +11133,7 @@ type OrderLine struct { func (x *OrderLine) Reset() { *x = OrderLine{} - mi := &file_product_proto_msgTypes[177] + mi := &file_product_proto_msgTypes[218] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9155,7 +11145,7 @@ func (x *OrderLine) String() string { func (*OrderLine) ProtoMessage() {} func (x *OrderLine) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[177] + mi := &file_product_proto_msgTypes[218] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9168,7 +11158,7 @@ func (x *OrderLine) ProtoReflect() protoreflect.Message { // Deprecated: Use OrderLine.ProtoReflect.Descriptor instead. func (*OrderLine) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{177} + return file_product_proto_rawDescGZIP(), []int{218} } func (x *OrderLine) GetProductId() string { @@ -9204,7 +11194,7 @@ type Subcategory struct { func (x *Subcategory) Reset() { *x = Subcategory{} - mi := &file_product_proto_msgTypes[178] + mi := &file_product_proto_msgTypes[219] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9216,7 +11206,7 @@ func (x *Subcategory) String() string { func (*Subcategory) ProtoMessage() {} func (x *Subcategory) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[178] + mi := &file_product_proto_msgTypes[219] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9229,7 +11219,7 @@ func (x *Subcategory) ProtoReflect() protoreflect.Message { // Deprecated: Use Subcategory.ProtoReflect.Descriptor instead. func (*Subcategory) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{178} + return file_product_proto_rawDescGZIP(), []int{219} } func (x *Subcategory) GetId() string { @@ -9261,19 +11251,20 @@ func (x *Subcategory) GetIsActive() bool { } type CategoryMetrics 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=metric_type,json=metricType,proto3" json:"metric_type,omitempty"` - Value float64 `protobuf:"fixed64,3,opt,name=value,proto3" json:"value,omitempty"` - Timestamp string `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"` - CategoryId string `protobuf:"bytes,5,opt,name=category_id,json=categoryId,proto3" json:"category_id,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + 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=metric_type,json=metricType,proto3" json:"metric_type,omitempty"` + Value float64 `protobuf:"fixed64,3,opt,name=value,proto3" json:"value,omitempty"` + Timestamp string `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + CategoryId string `protobuf:"bytes,5,opt,name=category_id,json=categoryId,proto3" json:"category_id,omitempty"` + RelatedCategory *Category `protobuf:"bytes,6,opt,name=related_category,json=relatedCategory,proto3" json:"related_category,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *CategoryMetrics) Reset() { *x = CategoryMetrics{} - mi := &file_product_proto_msgTypes[179] + mi := &file_product_proto_msgTypes[220] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9285,7 +11276,7 @@ func (x *CategoryMetrics) String() string { func (*CategoryMetrics) ProtoMessage() {} func (x *CategoryMetrics) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[179] + mi := &file_product_proto_msgTypes[220] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9298,7 +11289,7 @@ func (x *CategoryMetrics) ProtoReflect() protoreflect.Message { // Deprecated: Use CategoryMetrics.ProtoReflect.Descriptor instead. func (*CategoryMetrics) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{179} + return file_product_proto_rawDescGZIP(), []int{220} } func (x *CategoryMetrics) GetId() string { @@ -9336,6 +11327,13 @@ func (x *CategoryMetrics) GetCategoryId() string { return "" } +func (x *CategoryMetrics) GetRelatedCategory() *Category { + if x != nil { + return x.RelatedCategory + } + return nil +} + type Cat struct { state protoimpl.MessageState `protogen:"open.v1"` Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` @@ -9348,7 +11346,7 @@ type Cat struct { func (x *Cat) Reset() { *x = Cat{} - mi := &file_product_proto_msgTypes[180] + mi := &file_product_proto_msgTypes[221] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9360,7 +11358,7 @@ func (x *Cat) String() string { func (*Cat) ProtoMessage() {} func (x *Cat) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[180] + mi := &file_product_proto_msgTypes[221] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9373,7 +11371,7 @@ func (x *Cat) ProtoReflect() protoreflect.Message { // Deprecated: Use Cat.ProtoReflect.Descriptor instead. func (*Cat) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{180} + return file_product_proto_rawDescGZIP(), []int{221} } func (x *Cat) GetId() string { @@ -9416,7 +11414,7 @@ type Dog struct { func (x *Dog) Reset() { *x = Dog{} - mi := &file_product_proto_msgTypes[181] + mi := &file_product_proto_msgTypes[222] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9428,7 +11426,7 @@ func (x *Dog) String() string { func (*Dog) ProtoMessage() {} func (x *Dog) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[181] + mi := &file_product_proto_msgTypes[222] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9441,7 +11439,7 @@ func (x *Dog) ProtoReflect() protoreflect.Message { // Deprecated: Use Dog.ProtoReflect.Descriptor instead. func (*Dog) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{181} + return file_product_proto_rawDescGZIP(), []int{222} } func (x *Dog) GetId() string { @@ -9482,7 +11480,7 @@ type ActionSuccess struct { func (x *ActionSuccess) Reset() { *x = ActionSuccess{} - mi := &file_product_proto_msgTypes[182] + mi := &file_product_proto_msgTypes[223] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9494,7 +11492,7 @@ func (x *ActionSuccess) String() string { func (*ActionSuccess) ProtoMessage() {} func (x *ActionSuccess) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[182] + mi := &file_product_proto_msgTypes[223] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9507,7 +11505,7 @@ func (x *ActionSuccess) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionSuccess.ProtoReflect.Descriptor instead. func (*ActionSuccess) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{182} + return file_product_proto_rawDescGZIP(), []int{223} } func (x *ActionSuccess) GetMessage() string { @@ -9534,7 +11532,7 @@ type ActionError struct { func (x *ActionError) Reset() { *x = ActionError{} - mi := &file_product_proto_msgTypes[183] + mi := &file_product_proto_msgTypes[224] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9546,7 +11544,7 @@ func (x *ActionError) String() string { func (*ActionError) ProtoMessage() {} func (x *ActionError) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[183] + mi := &file_product_proto_msgTypes[224] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9559,7 +11557,7 @@ func (x *ActionError) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionError.ProtoReflect.Descriptor instead. func (*ActionError) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{183} + return file_product_proto_rawDescGZIP(), []int{224} } func (x *ActionError) GetMessage() string { @@ -9576,6 +11574,74 @@ func (x *ActionError) GetCode() string { return "" } +type TestDetails struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Summary string `protobuf:"bytes,2,opt,name=summary,proto3" json:"summary,omitempty"` + Pet *Animal `protobuf:"bytes,3,opt,name=pet,proto3" json:"pet,omitempty"` + Status *ActionResult `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TestDetails) Reset() { + *x = TestDetails{} + mi := &file_product_proto_msgTypes[225] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TestDetails) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestDetails) ProtoMessage() {} + +func (x *TestDetails) ProtoReflect() protoreflect.Message { + mi := &file_product_proto_msgTypes[225] + 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 TestDetails.ProtoReflect.Descriptor instead. +func (*TestDetails) Descriptor() ([]byte, []int) { + return file_product_proto_rawDescGZIP(), []int{225} +} + +func (x *TestDetails) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *TestDetails) GetSummary() string { + if x != nil { + return x.Summary + } + return "" +} + +func (x *TestDetails) GetPet() *Animal { + if x != nil { + return x.Pet + } + return nil +} + +func (x *TestDetails) GetStatus() *ActionResult { + if x != nil { + return x.Status + } + return nil +} + type CategoryInput struct { state protoimpl.MessageState `protogen:"open.v1"` Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` @@ -9586,7 +11652,7 @@ type CategoryInput struct { func (x *CategoryInput) Reset() { *x = CategoryInput{} - mi := &file_product_proto_msgTypes[184] + mi := &file_product_proto_msgTypes[226] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9598,7 +11664,7 @@ func (x *CategoryInput) String() string { func (*CategoryInput) ProtoMessage() {} func (x *CategoryInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[184] + mi := &file_product_proto_msgTypes[226] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9611,7 +11677,7 @@ func (x *CategoryInput) ProtoReflect() protoreflect.Message { // Deprecated: Use CategoryInput.ProtoReflect.Descriptor instead. func (*CategoryInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{184} + return file_product_proto_rawDescGZIP(), []int{226} } func (x *CategoryInput) GetName() string { @@ -9640,7 +11706,7 @@ type ProductCountFilter struct { func (x *ProductCountFilter) Reset() { *x = ProductCountFilter{} - mi := &file_product_proto_msgTypes[185] + mi := &file_product_proto_msgTypes[227] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9652,7 +11718,7 @@ func (x *ProductCountFilter) String() string { func (*ProductCountFilter) ProtoMessage() {} func (x *ProductCountFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[185] + mi := &file_product_proto_msgTypes[227] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9665,7 +11731,7 @@ func (x *ProductCountFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use ProductCountFilter.ProtoReflect.Descriptor instead. func (*ProductCountFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{185} + return file_product_proto_rawDescGZIP(), []int{227} } func (x *ProductCountFilter) GetMinPrice() *wrapperspb.DoubleValue { @@ -9709,7 +11775,7 @@ type SubcategoryItemFilter struct { func (x *SubcategoryItemFilter) Reset() { *x = SubcategoryItemFilter{} - mi := &file_product_proto_msgTypes[186] + mi := &file_product_proto_msgTypes[228] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9721,7 +11787,7 @@ func (x *SubcategoryItemFilter) String() string { func (*SubcategoryItemFilter) ProtoMessage() {} func (x *SubcategoryItemFilter) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[186] + mi := &file_product_proto_msgTypes[228] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9734,7 +11800,7 @@ func (x *SubcategoryItemFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use SubcategoryItemFilter.ProtoReflect.Descriptor instead. func (*SubcategoryItemFilter) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{186} + return file_product_proto_rawDescGZIP(), []int{228} } func (x *SubcategoryItemFilter) GetMinPrice() *wrapperspb.DoubleValue { @@ -9783,7 +11849,7 @@ type ShippingEstimateInput struct { func (x *ShippingEstimateInput) Reset() { *x = ShippingEstimateInput{} - mi := &file_product_proto_msgTypes[187] + mi := &file_product_proto_msgTypes[229] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9795,7 +11861,7 @@ func (x *ShippingEstimateInput) String() string { func (*ShippingEstimateInput) ProtoMessage() {} func (x *ShippingEstimateInput) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[187] + mi := &file_product_proto_msgTypes[229] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9808,7 +11874,7 @@ func (x *ShippingEstimateInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ShippingEstimateInput.ProtoReflect.Descriptor instead. func (*ShippingEstimateInput) Descriptor() ([]byte, []int) { - return file_product_proto_rawDescGZIP(), []int{187} + return file_product_proto_rawDescGZIP(), []int{229} } func (x *ShippingEstimateInput) GetDestination() ShippingDestination { @@ -9841,7 +11907,7 @@ type ListOfAuthorFilter_List struct { func (x *ListOfAuthorFilter_List) Reset() { *x = ListOfAuthorFilter_List{} - mi := &file_product_proto_msgTypes[188] + mi := &file_product_proto_msgTypes[230] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9853,7 +11919,7 @@ func (x *ListOfAuthorFilter_List) String() string { func (*ListOfAuthorFilter_List) ProtoMessage() {} func (x *ListOfAuthorFilter_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[188] + mi := &file_product_proto_msgTypes[230] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9885,7 +11951,7 @@ type ListOfAuthorInput_List struct { func (x *ListOfAuthorInput_List) Reset() { *x = ListOfAuthorInput_List{} - mi := &file_product_proto_msgTypes[189] + mi := &file_product_proto_msgTypes[231] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9897,7 +11963,7 @@ func (x *ListOfAuthorInput_List) String() string { func (*ListOfAuthorInput_List) ProtoMessage() {} func (x *ListOfAuthorInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[189] + mi := &file_product_proto_msgTypes[231] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9929,7 +11995,7 @@ type ListOfBlogPost_List struct { func (x *ListOfBlogPost_List) Reset() { *x = ListOfBlogPost_List{} - mi := &file_product_proto_msgTypes[190] + mi := &file_product_proto_msgTypes[232] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9941,7 +12007,7 @@ func (x *ListOfBlogPost_List) String() string { func (*ListOfBlogPost_List) ProtoMessage() {} func (x *ListOfBlogPost_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[190] + mi := &file_product_proto_msgTypes[232] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9973,7 +12039,7 @@ type ListOfBlogPostFilter_List struct { func (x *ListOfBlogPostFilter_List) Reset() { *x = ListOfBlogPostFilter_List{} - mi := &file_product_proto_msgTypes[191] + mi := &file_product_proto_msgTypes[233] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9985,7 +12051,7 @@ func (x *ListOfBlogPostFilter_List) String() string { func (*ListOfBlogPostFilter_List) ProtoMessage() {} func (x *ListOfBlogPostFilter_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[191] + mi := &file_product_proto_msgTypes[233] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10017,7 +12083,7 @@ type ListOfBlogPostInput_List struct { func (x *ListOfBlogPostInput_List) Reset() { *x = ListOfBlogPostInput_List{} - mi := &file_product_proto_msgTypes[192] + mi := &file_product_proto_msgTypes[234] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10029,7 +12095,7 @@ func (x *ListOfBlogPostInput_List) String() string { func (*ListOfBlogPostInput_List) ProtoMessage() {} func (x *ListOfBlogPostInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[192] + mi := &file_product_proto_msgTypes[234] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10061,7 +12127,7 @@ type ListOfBoolean_List struct { func (x *ListOfBoolean_List) Reset() { *x = ListOfBoolean_List{} - mi := &file_product_proto_msgTypes[193] + mi := &file_product_proto_msgTypes[235] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10073,7 +12139,7 @@ func (x *ListOfBoolean_List) String() string { func (*ListOfBoolean_List) ProtoMessage() {} func (x *ListOfBoolean_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[193] + mi := &file_product_proto_msgTypes[235] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10105,7 +12171,7 @@ type ListOfCategory_List struct { func (x *ListOfCategory_List) Reset() { *x = ListOfCategory_List{} - mi := &file_product_proto_msgTypes[194] + mi := &file_product_proto_msgTypes[236] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10117,7 +12183,7 @@ func (x *ListOfCategory_List) String() string { func (*ListOfCategory_List) ProtoMessage() {} func (x *ListOfCategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[194] + mi := &file_product_proto_msgTypes[236] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10149,7 +12215,7 @@ type ListOfCategoryInput_List struct { func (x *ListOfCategoryInput_List) Reset() { *x = ListOfCategoryInput_List{} - mi := &file_product_proto_msgTypes[195] + mi := &file_product_proto_msgTypes[237] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10161,7 +12227,7 @@ func (x *ListOfCategoryInput_List) String() string { func (*ListOfCategoryInput_List) ProtoMessage() {} func (x *ListOfCategoryInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[195] + mi := &file_product_proto_msgTypes[237] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10193,7 +12259,7 @@ type ListOfFloat_List struct { func (x *ListOfFloat_List) Reset() { *x = ListOfFloat_List{} - mi := &file_product_proto_msgTypes[196] + mi := &file_product_proto_msgTypes[238] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10205,7 +12271,7 @@ func (x *ListOfFloat_List) String() string { func (*ListOfFloat_List) ProtoMessage() {} func (x *ListOfFloat_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[196] + mi := &file_product_proto_msgTypes[238] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10237,7 +12303,7 @@ type ListOfListOfCategory_List struct { func (x *ListOfListOfCategory_List) Reset() { *x = ListOfListOfCategory_List{} - mi := &file_product_proto_msgTypes[197] + mi := &file_product_proto_msgTypes[239] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10249,7 +12315,7 @@ func (x *ListOfListOfCategory_List) String() string { func (*ListOfListOfCategory_List) ProtoMessage() {} func (x *ListOfListOfCategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[197] + mi := &file_product_proto_msgTypes[239] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10281,7 +12347,7 @@ type ListOfListOfCategoryInput_List struct { func (x *ListOfListOfCategoryInput_List) Reset() { *x = ListOfListOfCategoryInput_List{} - mi := &file_product_proto_msgTypes[198] + mi := &file_product_proto_msgTypes[240] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10293,7 +12359,7 @@ func (x *ListOfListOfCategoryInput_List) String() string { func (*ListOfListOfCategoryInput_List) ProtoMessage() {} func (x *ListOfListOfCategoryInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[198] + mi := &file_product_proto_msgTypes[240] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10325,7 +12391,7 @@ type ListOfListOfString_List struct { func (x *ListOfListOfString_List) Reset() { *x = ListOfListOfString_List{} - mi := &file_product_proto_msgTypes[199] + mi := &file_product_proto_msgTypes[241] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10337,7 +12403,7 @@ func (x *ListOfListOfString_List) String() string { func (*ListOfListOfString_List) ProtoMessage() {} func (x *ListOfListOfString_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[199] + mi := &file_product_proto_msgTypes[241] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10369,7 +12435,7 @@ type ListOfListOfUser_List struct { func (x *ListOfListOfUser_List) Reset() { *x = ListOfListOfUser_List{} - mi := &file_product_proto_msgTypes[200] + mi := &file_product_proto_msgTypes[242] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10381,7 +12447,7 @@ func (x *ListOfListOfUser_List) String() string { func (*ListOfListOfUser_List) ProtoMessage() {} func (x *ListOfListOfUser_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[200] + mi := &file_product_proto_msgTypes[242] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10413,7 +12479,7 @@ type ListOfListOfUserInput_List struct { func (x *ListOfListOfUserInput_List) Reset() { *x = ListOfListOfUserInput_List{} - mi := &file_product_proto_msgTypes[201] + mi := &file_product_proto_msgTypes[243] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10425,7 +12491,7 @@ func (x *ListOfListOfUserInput_List) String() string { func (*ListOfListOfUserInput_List) ProtoMessage() {} func (x *ListOfListOfUserInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[201] + mi := &file_product_proto_msgTypes[243] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10457,7 +12523,7 @@ type ListOfOrderLine_List struct { func (x *ListOfOrderLine_List) Reset() { *x = ListOfOrderLine_List{} - mi := &file_product_proto_msgTypes[202] + mi := &file_product_proto_msgTypes[244] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10469,7 +12535,7 @@ func (x *ListOfOrderLine_List) String() string { func (*ListOfOrderLine_List) ProtoMessage() {} func (x *ListOfOrderLine_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[202] + mi := &file_product_proto_msgTypes[244] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10501,7 +12567,7 @@ type ListOfProduct_List struct { func (x *ListOfProduct_List) Reset() { *x = ListOfProduct_List{} - mi := &file_product_proto_msgTypes[203] + mi := &file_product_proto_msgTypes[245] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10513,7 +12579,7 @@ func (x *ListOfProduct_List) String() string { func (*ListOfProduct_List) ProtoMessage() {} func (x *ListOfProduct_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[203] + mi := &file_product_proto_msgTypes[245] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10545,7 +12611,7 @@ type ListOfString_List struct { func (x *ListOfString_List) Reset() { *x = ListOfString_List{} - mi := &file_product_proto_msgTypes[204] + mi := &file_product_proto_msgTypes[246] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10557,7 +12623,7 @@ func (x *ListOfString_List) String() string { func (*ListOfString_List) ProtoMessage() {} func (x *ListOfString_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[204] + mi := &file_product_proto_msgTypes[246] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10589,7 +12655,7 @@ type ListOfSubcategory_List struct { func (x *ListOfSubcategory_List) Reset() { *x = ListOfSubcategory_List{} - mi := &file_product_proto_msgTypes[205] + mi := &file_product_proto_msgTypes[247] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10601,7 +12667,7 @@ func (x *ListOfSubcategory_List) String() string { func (*ListOfSubcategory_List) ProtoMessage() {} func (x *ListOfSubcategory_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[205] + mi := &file_product_proto_msgTypes[247] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10633,7 +12699,7 @@ type ListOfUser_List struct { func (x *ListOfUser_List) Reset() { *x = ListOfUser_List{} - mi := &file_product_proto_msgTypes[206] + mi := &file_product_proto_msgTypes[248] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10645,7 +12711,7 @@ func (x *ListOfUser_List) String() string { func (*ListOfUser_List) ProtoMessage() {} func (x *ListOfUser_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[206] + mi := &file_product_proto_msgTypes[248] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10677,7 +12743,7 @@ type ListOfUserInput_List struct { func (x *ListOfUserInput_List) Reset() { *x = ListOfUserInput_List{} - mi := &file_product_proto_msgTypes[207] + mi := &file_product_proto_msgTypes[249] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10689,7 +12755,7 @@ func (x *ListOfUserInput_List) String() string { func (*ListOfUserInput_List) ProtoMessage() {} func (x *ListOfUserInput_List) ProtoReflect() protoreflect.Message { - mi := &file_product_proto_msgTypes[207] + mi := &file_product_proto_msgTypes[249] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10929,7 +12995,14 @@ const file_product_proto_rawDesc = "" + "\x1fQueryBulkSearchBlogPostsRequest\x129\n" + "\afilters\x18\x01 \x01(\v2\x1f.productv1.ListOfBlogPostFilterR\afilters\"l\n" + " QueryBulkSearchBlogPostsResponse\x12H\n" + - "\x16bulk_search_blog_posts\x18\x01 \x03(\v2\x13.productv1.BlogPostR\x13bulkSearchBlogPosts\"G\n" + + "\x16bulk_search_blog_posts\x18\x01 \x03(\v2\x13.productv1.BlogPostR\x13bulkSearchBlogPosts\"+\n" + + "\x19QueryTestContainerRequest\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\"]\n" + + "\x1aQueryTestContainerResponse\x12?\n" + + "\x0etest_container\x18\x01 \x01(\v2\x18.productv1.TestContainerR\rtestContainer\"\x1c\n" + + "\x1aQueryTestContainersRequest\"`\n" + + "\x1bQueryTestContainersResponse\x12A\n" + + "\x0ftest_containers\x18\x01 \x03(\v2\x18.productv1.TestContainerR\x0etestContainers\"G\n" + "\x19MutationCreateUserRequest\x12*\n" + "\x05input\x18\x01 \x01(\v2\x14.productv1.UserInputR\x05input\"N\n" + "\x1aMutationCreateUserResponse\x120\n" + @@ -11010,7 +13083,48 @@ const file_product_proto_rawDesc = "" + "'ResolveProductRecommendedCategoryResult\x12F\n" + "\x14recommended_category\x18\x01 \x01(\v2\x13.productv1.CategoryR\x13recommendedCategory\"w\n" + ")ResolveProductRecommendedCategoryResponse\x12J\n" + - "\x06result\x18\x01 \x03(\v22.productv1.ResolveProductRecommendedCategoryResultR\x06result\"Z\n" + + "\x06result\x18\x01 \x03(\v22.productv1.ResolveProductRecommendedCategoryResultR\x06result\"Q\n" + + "&ResolveProductMascotRecommendationArgs\x12'\n" + + "\x0finclude_details\x18\x01 \x01(\bR\x0eincludeDetails\"O\n" + + ")ResolveProductMascotRecommendationContext\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + + "\x04name\x18\x02 \x01(\tR\x04name\"\xcd\x01\n" + + ")ResolveProductMascotRecommendationRequest\x12N\n" + + "\acontext\x18\x01 \x03(\v24.productv1.ResolveProductMascotRecommendationContextR\acontext\x12P\n" + + "\n" + + "field_args\x18\x02 \x01(\v21.productv1.ResolveProductMascotRecommendationArgsR\tfieldArgs\"r\n" + + "(ResolveProductMascotRecommendationResult\x12F\n" + + "\x15mascot_recommendation\x18\x01 \x01(\v2\x11.productv1.AnimalR\x14mascotRecommendation\"y\n" + + "*ResolveProductMascotRecommendationResponse\x12K\n" + + "\x06result\x18\x01 \x03(\v23.productv1.ResolveProductMascotRecommendationResultR\x06result\"N\n" + + "\x1dResolveProductStockStatusArgs\x12-\n" + + "\x12check_availability\x18\x01 \x01(\bR\x11checkAvailability\"\\\n" + + " ResolveProductStockStatusContext\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + + "\x04name\x18\x02 \x01(\tR\x04name\x12\x14\n" + + "\x05price\x18\x03 \x01(\x01R\x05price\"\xb2\x01\n" + + " ResolveProductStockStatusRequest\x12E\n" + + "\acontext\x18\x01 \x03(\v2+.productv1.ResolveProductStockStatusContextR\acontext\x12G\n" + + "\n" + + "field_args\x18\x02 \x01(\v2(.productv1.ResolveProductStockStatusArgsR\tfieldArgs\"]\n" + + "\x1fResolveProductStockStatusResult\x12:\n" + + "\fstock_status\x18\x01 \x01(\v2\x17.productv1.ActionResultR\vstockStatus\"g\n" + + "!ResolveProductStockStatusResponse\x12B\n" + + "\x06result\x18\x01 \x03(\v2*.productv1.ResolveProductStockStatusResultR\x06result\"M\n" + + " ResolveProductProductDetailsArgs\x12)\n" + + "\x10include_extended\x18\x01 \x01(\bR\x0fincludeExtended\"_\n" + + "#ResolveProductProductDetailsContext\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + + "\x04name\x18\x02 \x01(\tR\x04name\x12\x14\n" + + "\x05price\x18\x03 \x01(\x01R\x05price\"\xbb\x01\n" + + "#ResolveProductProductDetailsRequest\x12H\n" + + "\acontext\x18\x01 \x03(\v2..productv1.ResolveProductProductDetailsContextR\acontext\x12J\n" + + "\n" + + "field_args\x18\x02 \x01(\v2+.productv1.ResolveProductProductDetailsArgsR\tfieldArgs\"h\n" + + "\"ResolveProductProductDetailsResult\x12B\n" + + "\x0fproduct_details\x18\x01 \x01(\v2\x19.productv1.ProductDetailsR\x0eproductDetails\"m\n" + + "$ResolveProductProductDetailsResponse\x12E\n" + + "\x06result\x18\x01 \x03(\v2-.productv1.ResolveProductProductDetailsResultR\x06result\"Z\n" + "\x1fResolveCategoryProductCountArgs\x127\n" + "\afilters\x18\x01 \x01(\v2\x1d.productv1.ProductCountFilterR\afilters\"H\n" + "\"ResolveCategoryProductCountContext\x12\x0e\n" + @@ -11049,7 +13163,33 @@ const file_product_proto_rawDesc = "" + "$ResolveCategoryCategoryMetricsResult\x12E\n" + "\x10category_metrics\x18\x01 \x01(\v2\x1a.productv1.CategoryMetricsR\x0fcategoryMetrics\"q\n" + "&ResolveCategoryCategoryMetricsResponse\x12G\n" + - "\x06result\x18\x01 \x03(\v2/.productv1.ResolveCategoryCategoryMetricsResultR\x06result\"]\n" + + "\x06result\x18\x01 \x03(\v2/.productv1.ResolveCategoryCategoryMetricsResultR\x06result\"B\n" + + "\x19ResolveCategoryMascotArgs\x12%\n" + + "\x0einclude_volume\x18\x01 \x01(\bR\rincludeVolume\"[\n" + + "\x1cResolveCategoryMascotContext\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12+\n" + + "\x04kind\x18\x02 \x01(\x0e2\x17.productv1.CategoryKindR\x04kind\"\xa6\x01\n" + + "\x1cResolveCategoryMascotRequest\x12A\n" + + "\acontext\x18\x01 \x03(\v2'.productv1.ResolveCategoryMascotContextR\acontext\x12C\n" + + "\n" + + "field_args\x18\x02 \x01(\v2$.productv1.ResolveCategoryMascotArgsR\tfieldArgs\"H\n" + + "\x1bResolveCategoryMascotResult\x12)\n" + + "\x06mascot\x18\x01 \x01(\v2\x11.productv1.AnimalR\x06mascot\"_\n" + + "\x1dResolveCategoryMascotResponse\x12>\n" + + "\x06result\x18\x01 \x03(\v2&.productv1.ResolveCategoryMascotResultR\x06result\"F\n" + + "!ResolveCategoryCategoryStatusArgs\x12!\n" + + "\fcheck_health\x18\x01 \x01(\bR\vcheckHealth\"J\n" + + "$ResolveCategoryCategoryStatusContext\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + + "\x04name\x18\x02 \x01(\tR\x04name\"\xbe\x01\n" + + "$ResolveCategoryCategoryStatusRequest\x12I\n" + + "\acontext\x18\x01 \x03(\v2/.productv1.ResolveCategoryCategoryStatusContextR\acontext\x12K\n" + + "\n" + + "field_args\x18\x02 \x01(\v2,.productv1.ResolveCategoryCategoryStatusArgsR\tfieldArgs\"g\n" + + "#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" + "\x1fResolveSubcategoryItemCountArgs\x12:\n" + "\afilters\x18\x01 \x01(\v2 .productv1.SubcategoryItemFilterR\afilters\"4\n" + "\"ResolveSubcategoryItemCountContext\x12\x0e\n" + @@ -11062,7 +13202,36 @@ const file_product_proto_rawDesc = "" + "\n" + "item_count\x18\x01 \x01(\x05R\titemCount\"k\n" + "#ResolveSubcategoryItemCountResponse\x12D\n" + - "\x06result\x18\x01 \x03(\v2,.productv1.ResolveSubcategoryItemCountResultR\x06result\"C\n" + + "\x06result\x18\x01 \x03(\v2,.productv1.ResolveSubcategoryItemCountResultR\x06result\"G\n" + + ")ResolveCategoryMetricsNormalizedScoreArgs\x12\x1a\n" + + "\bbaseline\x18\x01 \x01(\x01R\bbaseline\"t\n" + + ",ResolveCategoryMetricsNormalizedScoreContext\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x1e\n" + + "\n" + + "metricType\x18\x02 \x01(\tR\n" + + "metricType\x12\x14\n" + + "\x05value\x18\x03 \x01(\x01R\x05value\"\xd6\x01\n" + + ",ResolveCategoryMetricsNormalizedScoreRequest\x12Q\n" + + "\acontext\x18\x01 \x03(\v27.productv1.ResolveCategoryMetricsNormalizedScoreContextR\acontext\x12S\n" + + "\n" + + "field_args\x18\x02 \x01(\v24.productv1.ResolveCategoryMetricsNormalizedScoreArgsR\tfieldArgs\"X\n" + + "+ResolveCategoryMetricsNormalizedScoreResult\x12)\n" + + "\x10normalized_score\x18\x01 \x01(\x01R\x0fnormalizedScore\"\x7f\n" + + "-ResolveCategoryMetricsNormalizedScoreResponse\x12N\n" + + "\x06result\x18\x01 \x03(\v26.productv1.ResolveCategoryMetricsNormalizedScoreResultR\x06result\"L\n" + + "\x1fResolveTestContainerDetailsArgs\x12)\n" + + "\x10include_extended\x18\x01 \x01(\bR\x0fincludeExtended\"H\n" + + "\"ResolveTestContainerDetailsContext\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + + "\x04name\x18\x02 \x01(\tR\x04name\"\xb8\x01\n" + + "\"ResolveTestContainerDetailsRequest\x12G\n" + + "\acontext\x18\x01 \x03(\v2-.productv1.ResolveTestContainerDetailsContextR\acontext\x12I\n" + + "\n" + + "field_args\x18\x02 \x01(\v2*.productv1.ResolveTestContainerDetailsArgsR\tfieldArgs\"U\n" + + "!ResolveTestContainerDetailsResult\x120\n" + + "\adetails\x18\x01 \x01(\v2\x16.productv1.TestDetailsR\adetails\"k\n" + + "#ResolveTestContainerDetailsResponse\x12D\n" + + "\x06result\x18\x01 \x03(\v2,.productv1.ResolveTestContainerDetailsResultR\x06result\"C\n" + "\aProduct\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + "\x04name\x18\x02 \x01(\tR\x04name\x12\x14\n" + @@ -11198,7 +13367,11 @@ const file_product_proto_rawDesc = "" + "\x04name\x18\x01 \x01(\v2\x1c.google.protobuf.StringValueR\x04name\x127\n" + "\thas_teams\x18\x02 \x01(\v2\x1a.google.protobuf.BoolValueR\bhasTeams\x12<\n" + "\vskill_count\x18\x03 \x01(\v2\x1b.google.protobuf.Int32ValueR\n" + - "skillCount\"\x1f\n" + + "skillCount\"s\n" + + "\rTestContainer\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + + "\x04name\x18\x02 \x01(\tR\x04name\x12>\n" + + "\vdescription\x18\x03 \x01(\v2\x1c.google.protobuf.StringValueR\vdescription\"\x1f\n" + "\tUserInput\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\";\n" + "\vActionInput\x12\x12\n" + @@ -11249,7 +13422,12 @@ const file_product_proto_rawDesc = "" + "\x13favorite_categories\x18\b \x03(\v2\x18.productv1.CategoryInputR\x12favoriteCategories\x12E\n" + "\rauthor_groups\x18\t \x01(\v2 .productv1.ListOfListOfUserInputR\fauthorGroups\x12E\n" + "\rproject_teams\x18\n" + - " \x01(\v2 .productv1.ListOfListOfUserInputR\fprojectTeams\"W\n" + + " \x01(\v2 .productv1.ListOfListOfUserInputR\fprojectTeams\"\xbe\x01\n" + + "\x0eProductDetails\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12 \n" + + "\vdescription\x18\x02 \x01(\tR\vdescription\x12>\n" + + "\x0ereview_summary\x18\x03 \x01(\v2\x17.productv1.ActionResultR\rreviewSummary\x12:\n" + + "\x0frecommended_pet\x18\x04 \x01(\v2\x11.productv1.AnimalR\x0erecommendedPet\"W\n" + "\vNestedTypeB\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + "\x04name\x18\x02 \x01(\tR\x04name\x12$\n" + @@ -11283,7 +13461,7 @@ const file_product_proto_rawDesc = "" + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + "\x04name\x18\x02 \x01(\tR\x04name\x12>\n" + "\vdescription\x18\x03 \x01(\v2\x1c.google.protobuf.StringValueR\vdescription\x12\x1b\n" + - "\tis_active\x18\x04 \x01(\bR\bisActive\"\x97\x01\n" + + "\tis_active\x18\x04 \x01(\bR\bisActive\"\xd7\x01\n" + "\x0fCategoryMetrics\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\x12\x1f\n" + "\vmetric_type\x18\x02 \x01(\tR\n" + @@ -11291,7 +13469,8 @@ const file_product_proto_rawDesc = "" + "\x05value\x18\x03 \x01(\x01R\x05value\x12\x1c\n" + "\ttimestamp\x18\x04 \x01(\tR\ttimestamp\x12\x1f\n" + "\vcategory_id\x18\x05 \x01(\tR\n" + - "categoryId\"^\n" + + "categoryId\x12>\n" + + "\x10related_category\x18\x06 \x01(\v2\x13.productv1.CategoryR\x0frelatedCategory\"^\n" + "\x03Cat\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + "\x04name\x18\x02 \x01(\tR\x04name\x12\x12\n" + @@ -11309,7 +13488,12 @@ const file_product_proto_rawDesc = "" + "\ttimestamp\x18\x02 \x01(\tR\ttimestamp\";\n" + "\vActionError\x12\x18\n" + "\amessage\x18\x01 \x01(\tR\amessage\x12\x12\n" + - "\x04code\x18\x02 \x01(\tR\x04code\"P\n" + + "\x04code\x18\x02 \x01(\tR\x04code\"\x8d\x01\n" + + "\vTestDetails\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x18\n" + + "\asummary\x18\x02 \x01(\tR\asummary\x12#\n" + + "\x03pet\x18\x03 \x01(\v2\x11.productv1.AnimalR\x03pet\x12/\n" + + "\x06status\x18\x04 \x01(\v2\x17.productv1.ActionResultR\x06status\"P\n" + "\rCategoryInput\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\x12+\n" + "\x04kind\x18\x02 \x01(\x0e2\x17.productv1.CategoryKindR\x04kind\"\x80\x02\n" + @@ -11340,7 +13524,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\xe9,\n" + + "\"SHIPPING_DESTINATION_INTERNATIONAL\x10\x032\xde5\n" + "\x0eProductService\x12`\n" + "\x11LookupProductById\x12#.productv1.LookupProductByIdRequest\x1a$.productv1.LookupProductByIdResponse\"\x00\x12`\n" + "\x11LookupStorageById\x12#.productv1.LookupStorageByIdRequest\x1a$.productv1.LookupStorageByIdResponse\"\x00\x12f\n" + @@ -11382,18 +13566,27 @@ const file_product_proto_rawDesc = "" + "\x0eQueryRandomPet\x12 .productv1.QueryRandomPetRequest\x1a!.productv1.QueryRandomPetResponse\"\x00\x12r\n" + "\x17QueryRandomSearchResult\x12).productv1.QueryRandomSearchResultRequest\x1a*.productv1.QueryRandomSearchResultResponse\"\x00\x12c\n" + "\x12QueryRecursiveType\x12$.productv1.QueryRecursiveTypeRequest\x1a%.productv1.QueryRecursiveTypeResponse\"\x00\x12N\n" + - "\vQuerySearch\x12\x1d.productv1.QuerySearchRequest\x1a\x1e.productv1.QuerySearchResponse\"\x00\x12\x81\x01\n" + + "\vQuerySearch\x12\x1d.productv1.QuerySearchRequest\x1a\x1e.productv1.QuerySearchResponse\"\x00\x12c\n" + + "\x12QueryTestContainer\x12$.productv1.QueryTestContainerRequest\x1a%.productv1.QueryTestContainerResponse\"\x00\x12f\n" + + "\x13QueryTestContainers\x12%.productv1.QueryTestContainersRequest\x1a&.productv1.QueryTestContainersResponse\"\x00\x12\x81\x01\n" + "\x1cQueryTypeFilterWithArguments\x12..productv1.QueryTypeFilterWithArgumentsRequest\x1a/.productv1.QueryTypeFilterWithArgumentsResponse\"\x00\x12\x90\x01\n" + "!QueryTypeWithMultipleFilterFields\x123.productv1.QueryTypeWithMultipleFilterFieldsRequest\x1a4.productv1.QueryTypeWithMultipleFilterFieldsResponse\"\x00\x12H\n" + "\tQueryUser\x12\x1b.productv1.QueryUserRequest\x1a\x1c.productv1.QueryUserResponse\"\x00\x12K\n" + "\n" + "QueryUsers\x12\x1c.productv1.QueryUsersRequest\x1a\x1d.productv1.QueryUsersResponse\"\x00\x12\x87\x01\n" + - "\x1eResolveCategoryCategoryMetrics\x120.productv1.ResolveCategoryCategoryMetricsRequest\x1a1.productv1.ResolveCategoryCategoryMetricsResponse\"\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" + + "\x15ResolveCategoryMascot\x12'.productv1.ResolveCategoryMascotRequest\x1a(.productv1.ResolveCategoryMascotResponse\"\x00\x12\x9c\x01\n" + + "%ResolveCategoryMetricsNormalizedScore\x127.productv1.ResolveCategoryMetricsNormalizedScoreRequest\x1a8.productv1.ResolveCategoryMetricsNormalizedScoreResponse\"\x00\x12\x87\x01\n" + "\x1eResolveCategoryPopularityScore\x120.productv1.ResolveCategoryPopularityScoreRequest\x1a1.productv1.ResolveCategoryPopularityScoreResponse\"\x00\x12~\n" + - "\x1bResolveCategoryProductCount\x12-.productv1.ResolveCategoryProductCountRequest\x1a..productv1.ResolveCategoryProductCountResponse\"\x00\x12\x90\x01\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" + + "\x1cResolveProductProductDetails\x12..productv1.ResolveProductProductDetailsRequest\x1a/.productv1.ResolveProductProductDetailsResponse\"\x00\x12\x90\x01\n" + "!ResolveProductRecommendedCategory\x123.productv1.ResolveProductRecommendedCategoryRequest\x1a4.productv1.ResolveProductRecommendedCategoryResponse\"\x00\x12\x87\x01\n" + - "\x1eResolveProductShippingEstimate\x120.productv1.ResolveProductShippingEstimateRequest\x1a1.productv1.ResolveProductShippingEstimateResponse\"\x00\x12~\n" + - "\x1bResolveSubcategoryItemCount\x12-.productv1.ResolveSubcategoryItemCountRequest\x1a..productv1.ResolveSubcategoryItemCountResponse\"\x00B%Z#cosmo/pkg/proto/productv1;productv1b\x06proto3" + "\x1eResolveProductShippingEstimate\x120.productv1.ResolveProductShippingEstimateRequest\x1a1.productv1.ResolveProductShippingEstimateResponse\"\x00\x12x\n" + + "\x19ResolveProductStockStatus\x12+.productv1.ResolveProductStockStatusRequest\x1a,.productv1.ResolveProductStockStatusResponse\"\x00\x12~\n" + + "\x1bResolveSubcategoryItemCount\x12-.productv1.ResolveSubcategoryItemCountRequest\x1a..productv1.ResolveSubcategoryItemCountResponse\"\x00\x12~\n" + + "\x1bResolveTestContainerDetails\x12-.productv1.ResolveTestContainerDetailsRequest\x1a..productv1.ResolveTestContainerDetailsResponse\"\x00B%Z#cosmo/pkg/proto/productv1;productv1b\x06proto3" var ( file_product_proto_rawDescOnce sync.Once @@ -11408,559 +13601,655 @@ func file_product_proto_rawDescGZIP() []byte { } var file_product_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_product_proto_msgTypes = make([]protoimpl.MessageInfo, 208) +var file_product_proto_msgTypes = make([]protoimpl.MessageInfo, 250) var file_product_proto_goTypes = []any{ - (CategoryKind)(0), // 0: productv1.CategoryKind - (ShippingDestination)(0), // 1: productv1.ShippingDestination - (*ListOfAuthorFilter)(nil), // 2: productv1.ListOfAuthorFilter - (*ListOfAuthorInput)(nil), // 3: productv1.ListOfAuthorInput - (*ListOfBlogPost)(nil), // 4: productv1.ListOfBlogPost - (*ListOfBlogPostFilter)(nil), // 5: productv1.ListOfBlogPostFilter - (*ListOfBlogPostInput)(nil), // 6: productv1.ListOfBlogPostInput - (*ListOfBoolean)(nil), // 7: productv1.ListOfBoolean - (*ListOfCategory)(nil), // 8: productv1.ListOfCategory - (*ListOfCategoryInput)(nil), // 9: productv1.ListOfCategoryInput - (*ListOfFloat)(nil), // 10: productv1.ListOfFloat - (*ListOfListOfCategory)(nil), // 11: productv1.ListOfListOfCategory - (*ListOfListOfCategoryInput)(nil), // 12: productv1.ListOfListOfCategoryInput - (*ListOfListOfString)(nil), // 13: productv1.ListOfListOfString - (*ListOfListOfUser)(nil), // 14: productv1.ListOfListOfUser - (*ListOfListOfUserInput)(nil), // 15: productv1.ListOfListOfUserInput - (*ListOfOrderLine)(nil), // 16: productv1.ListOfOrderLine - (*ListOfProduct)(nil), // 17: productv1.ListOfProduct - (*ListOfString)(nil), // 18: productv1.ListOfString - (*ListOfSubcategory)(nil), // 19: productv1.ListOfSubcategory - (*ListOfUser)(nil), // 20: productv1.ListOfUser - (*ListOfUserInput)(nil), // 21: productv1.ListOfUserInput - (*LookupProductByIdRequestKey)(nil), // 22: productv1.LookupProductByIdRequestKey - (*LookupProductByIdRequest)(nil), // 23: productv1.LookupProductByIdRequest - (*LookupProductByIdResponse)(nil), // 24: productv1.LookupProductByIdResponse - (*LookupStorageByIdRequestKey)(nil), // 25: productv1.LookupStorageByIdRequestKey - (*LookupStorageByIdRequest)(nil), // 26: productv1.LookupStorageByIdRequest - (*LookupStorageByIdResponse)(nil), // 27: productv1.LookupStorageByIdResponse - (*LookupWarehouseByIdRequestKey)(nil), // 28: productv1.LookupWarehouseByIdRequestKey - (*LookupWarehouseByIdRequest)(nil), // 29: productv1.LookupWarehouseByIdRequest - (*LookupWarehouseByIdResponse)(nil), // 30: productv1.LookupWarehouseByIdResponse - (*QueryUsersRequest)(nil), // 31: productv1.QueryUsersRequest - (*QueryUsersResponse)(nil), // 32: productv1.QueryUsersResponse - (*QueryUserRequest)(nil), // 33: productv1.QueryUserRequest - (*QueryUserResponse)(nil), // 34: productv1.QueryUserResponse - (*QueryNestedTypeRequest)(nil), // 35: productv1.QueryNestedTypeRequest - (*QueryNestedTypeResponse)(nil), // 36: productv1.QueryNestedTypeResponse - (*QueryRecursiveTypeRequest)(nil), // 37: productv1.QueryRecursiveTypeRequest - (*QueryRecursiveTypeResponse)(nil), // 38: productv1.QueryRecursiveTypeResponse - (*QueryTypeFilterWithArgumentsRequest)(nil), // 39: productv1.QueryTypeFilterWithArgumentsRequest - (*QueryTypeFilterWithArgumentsResponse)(nil), // 40: productv1.QueryTypeFilterWithArgumentsResponse - (*QueryTypeWithMultipleFilterFieldsRequest)(nil), // 41: productv1.QueryTypeWithMultipleFilterFieldsRequest - (*QueryTypeWithMultipleFilterFieldsResponse)(nil), // 42: productv1.QueryTypeWithMultipleFilterFieldsResponse - (*QueryComplexFilterTypeRequest)(nil), // 43: productv1.QueryComplexFilterTypeRequest - (*QueryComplexFilterTypeResponse)(nil), // 44: productv1.QueryComplexFilterTypeResponse - (*QueryCalculateTotalsRequest)(nil), // 45: productv1.QueryCalculateTotalsRequest - (*QueryCalculateTotalsResponse)(nil), // 46: productv1.QueryCalculateTotalsResponse - (*QueryCategoriesRequest)(nil), // 47: productv1.QueryCategoriesRequest - (*QueryCategoriesResponse)(nil), // 48: productv1.QueryCategoriesResponse - (*QueryCategoriesByKindRequest)(nil), // 49: productv1.QueryCategoriesByKindRequest - (*QueryCategoriesByKindResponse)(nil), // 50: productv1.QueryCategoriesByKindResponse - (*QueryCategoriesByKindsRequest)(nil), // 51: productv1.QueryCategoriesByKindsRequest - (*QueryCategoriesByKindsResponse)(nil), // 52: productv1.QueryCategoriesByKindsResponse - (*QueryFilterCategoriesRequest)(nil), // 53: productv1.QueryFilterCategoriesRequest - (*QueryFilterCategoriesResponse)(nil), // 54: productv1.QueryFilterCategoriesResponse - (*QueryRandomPetRequest)(nil), // 55: productv1.QueryRandomPetRequest - (*QueryRandomPetResponse)(nil), // 56: productv1.QueryRandomPetResponse - (*QueryAllPetsRequest)(nil), // 57: productv1.QueryAllPetsRequest - (*QueryAllPetsResponse)(nil), // 58: productv1.QueryAllPetsResponse - (*QuerySearchRequest)(nil), // 59: productv1.QuerySearchRequest - (*QuerySearchResponse)(nil), // 60: productv1.QuerySearchResponse - (*QueryRandomSearchResultRequest)(nil), // 61: productv1.QueryRandomSearchResultRequest - (*QueryRandomSearchResultResponse)(nil), // 62: productv1.QueryRandomSearchResultResponse - (*QueryNullableFieldsTypeRequest)(nil), // 63: productv1.QueryNullableFieldsTypeRequest - (*QueryNullableFieldsTypeResponse)(nil), // 64: productv1.QueryNullableFieldsTypeResponse - (*QueryNullableFieldsTypeByIdRequest)(nil), // 65: productv1.QueryNullableFieldsTypeByIdRequest - (*QueryNullableFieldsTypeByIdResponse)(nil), // 66: productv1.QueryNullableFieldsTypeByIdResponse - (*QueryNullableFieldsTypeWithFilterRequest)(nil), // 67: productv1.QueryNullableFieldsTypeWithFilterRequest - (*QueryNullableFieldsTypeWithFilterResponse)(nil), // 68: productv1.QueryNullableFieldsTypeWithFilterResponse - (*QueryAllNullableFieldsTypesRequest)(nil), // 69: productv1.QueryAllNullableFieldsTypesRequest - (*QueryAllNullableFieldsTypesResponse)(nil), // 70: productv1.QueryAllNullableFieldsTypesResponse - (*QueryBlogPostRequest)(nil), // 71: productv1.QueryBlogPostRequest - (*QueryBlogPostResponse)(nil), // 72: productv1.QueryBlogPostResponse - (*QueryBlogPostByIdRequest)(nil), // 73: productv1.QueryBlogPostByIdRequest - (*QueryBlogPostByIdResponse)(nil), // 74: productv1.QueryBlogPostByIdResponse - (*QueryBlogPostsWithFilterRequest)(nil), // 75: productv1.QueryBlogPostsWithFilterRequest - (*QueryBlogPostsWithFilterResponse)(nil), // 76: productv1.QueryBlogPostsWithFilterResponse - (*QueryAllBlogPostsRequest)(nil), // 77: productv1.QueryAllBlogPostsRequest - (*QueryAllBlogPostsResponse)(nil), // 78: productv1.QueryAllBlogPostsResponse - (*QueryAuthorRequest)(nil), // 79: productv1.QueryAuthorRequest - (*QueryAuthorResponse)(nil), // 80: productv1.QueryAuthorResponse - (*QueryAuthorByIdRequest)(nil), // 81: productv1.QueryAuthorByIdRequest - (*QueryAuthorByIdResponse)(nil), // 82: productv1.QueryAuthorByIdResponse - (*QueryAuthorsWithFilterRequest)(nil), // 83: productv1.QueryAuthorsWithFilterRequest - (*QueryAuthorsWithFilterResponse)(nil), // 84: productv1.QueryAuthorsWithFilterResponse - (*QueryAllAuthorsRequest)(nil), // 85: productv1.QueryAllAuthorsRequest - (*QueryAllAuthorsResponse)(nil), // 86: productv1.QueryAllAuthorsResponse - (*QueryBulkSearchAuthorsRequest)(nil), // 87: productv1.QueryBulkSearchAuthorsRequest - (*QueryBulkSearchAuthorsResponse)(nil), // 88: productv1.QueryBulkSearchAuthorsResponse - (*QueryBulkSearchBlogPostsRequest)(nil), // 89: productv1.QueryBulkSearchBlogPostsRequest - (*QueryBulkSearchBlogPostsResponse)(nil), // 90: productv1.QueryBulkSearchBlogPostsResponse - (*MutationCreateUserRequest)(nil), // 91: productv1.MutationCreateUserRequest - (*MutationCreateUserResponse)(nil), // 92: productv1.MutationCreateUserResponse - (*MutationPerformActionRequest)(nil), // 93: productv1.MutationPerformActionRequest - (*MutationPerformActionResponse)(nil), // 94: productv1.MutationPerformActionResponse - (*MutationCreateNullableFieldsTypeRequest)(nil), // 95: productv1.MutationCreateNullableFieldsTypeRequest - (*MutationCreateNullableFieldsTypeResponse)(nil), // 96: productv1.MutationCreateNullableFieldsTypeResponse - (*MutationUpdateNullableFieldsTypeRequest)(nil), // 97: productv1.MutationUpdateNullableFieldsTypeRequest - (*MutationUpdateNullableFieldsTypeResponse)(nil), // 98: productv1.MutationUpdateNullableFieldsTypeResponse - (*MutationCreateBlogPostRequest)(nil), // 99: productv1.MutationCreateBlogPostRequest - (*MutationCreateBlogPostResponse)(nil), // 100: productv1.MutationCreateBlogPostResponse - (*MutationUpdateBlogPostRequest)(nil), // 101: productv1.MutationUpdateBlogPostRequest - (*MutationUpdateBlogPostResponse)(nil), // 102: productv1.MutationUpdateBlogPostResponse - (*MutationCreateAuthorRequest)(nil), // 103: productv1.MutationCreateAuthorRequest - (*MutationCreateAuthorResponse)(nil), // 104: productv1.MutationCreateAuthorResponse - (*MutationUpdateAuthorRequest)(nil), // 105: productv1.MutationUpdateAuthorRequest - (*MutationUpdateAuthorResponse)(nil), // 106: productv1.MutationUpdateAuthorResponse - (*MutationBulkCreateAuthorsRequest)(nil), // 107: productv1.MutationBulkCreateAuthorsRequest - (*MutationBulkCreateAuthorsResponse)(nil), // 108: productv1.MutationBulkCreateAuthorsResponse - (*MutationBulkUpdateAuthorsRequest)(nil), // 109: productv1.MutationBulkUpdateAuthorsRequest - (*MutationBulkUpdateAuthorsResponse)(nil), // 110: productv1.MutationBulkUpdateAuthorsResponse - (*MutationBulkCreateBlogPostsRequest)(nil), // 111: productv1.MutationBulkCreateBlogPostsRequest - (*MutationBulkCreateBlogPostsResponse)(nil), // 112: productv1.MutationBulkCreateBlogPostsResponse - (*MutationBulkUpdateBlogPostsRequest)(nil), // 113: productv1.MutationBulkUpdateBlogPostsRequest - (*MutationBulkUpdateBlogPostsResponse)(nil), // 114: productv1.MutationBulkUpdateBlogPostsResponse - (*ResolveProductShippingEstimateArgs)(nil), // 115: productv1.ResolveProductShippingEstimateArgs - (*ResolveProductShippingEstimateContext)(nil), // 116: productv1.ResolveProductShippingEstimateContext - (*ResolveProductShippingEstimateRequest)(nil), // 117: productv1.ResolveProductShippingEstimateRequest - (*ResolveProductShippingEstimateResult)(nil), // 118: productv1.ResolveProductShippingEstimateResult - (*ResolveProductShippingEstimateResponse)(nil), // 119: productv1.ResolveProductShippingEstimateResponse - (*ResolveProductRecommendedCategoryArgs)(nil), // 120: productv1.ResolveProductRecommendedCategoryArgs - (*ResolveProductRecommendedCategoryContext)(nil), // 121: productv1.ResolveProductRecommendedCategoryContext - (*ResolveProductRecommendedCategoryRequest)(nil), // 122: productv1.ResolveProductRecommendedCategoryRequest - (*ResolveProductRecommendedCategoryResult)(nil), // 123: productv1.ResolveProductRecommendedCategoryResult - (*ResolveProductRecommendedCategoryResponse)(nil), // 124: productv1.ResolveProductRecommendedCategoryResponse - (*ResolveCategoryProductCountArgs)(nil), // 125: productv1.ResolveCategoryProductCountArgs - (*ResolveCategoryProductCountContext)(nil), // 126: productv1.ResolveCategoryProductCountContext - (*ResolveCategoryProductCountRequest)(nil), // 127: productv1.ResolveCategoryProductCountRequest - (*ResolveCategoryProductCountResult)(nil), // 128: productv1.ResolveCategoryProductCountResult - (*ResolveCategoryProductCountResponse)(nil), // 129: productv1.ResolveCategoryProductCountResponse - (*ResolveCategoryPopularityScoreArgs)(nil), // 130: productv1.ResolveCategoryPopularityScoreArgs - (*ResolveCategoryPopularityScoreContext)(nil), // 131: productv1.ResolveCategoryPopularityScoreContext - (*ResolveCategoryPopularityScoreRequest)(nil), // 132: productv1.ResolveCategoryPopularityScoreRequest - (*ResolveCategoryPopularityScoreResult)(nil), // 133: productv1.ResolveCategoryPopularityScoreResult - (*ResolveCategoryPopularityScoreResponse)(nil), // 134: productv1.ResolveCategoryPopularityScoreResponse - (*ResolveCategoryCategoryMetricsArgs)(nil), // 135: productv1.ResolveCategoryCategoryMetricsArgs - (*ResolveCategoryCategoryMetricsContext)(nil), // 136: productv1.ResolveCategoryCategoryMetricsContext - (*ResolveCategoryCategoryMetricsRequest)(nil), // 137: productv1.ResolveCategoryCategoryMetricsRequest - (*ResolveCategoryCategoryMetricsResult)(nil), // 138: productv1.ResolveCategoryCategoryMetricsResult - (*ResolveCategoryCategoryMetricsResponse)(nil), // 139: productv1.ResolveCategoryCategoryMetricsResponse - (*ResolveSubcategoryItemCountArgs)(nil), // 140: productv1.ResolveSubcategoryItemCountArgs - (*ResolveSubcategoryItemCountContext)(nil), // 141: productv1.ResolveSubcategoryItemCountContext - (*ResolveSubcategoryItemCountRequest)(nil), // 142: productv1.ResolveSubcategoryItemCountRequest - (*ResolveSubcategoryItemCountResult)(nil), // 143: productv1.ResolveSubcategoryItemCountResult - (*ResolveSubcategoryItemCountResponse)(nil), // 144: productv1.ResolveSubcategoryItemCountResponse - (*Product)(nil), // 145: productv1.Product - (*Storage)(nil), // 146: productv1.Storage - (*Warehouse)(nil), // 147: productv1.Warehouse - (*User)(nil), // 148: productv1.User - (*NestedTypeA)(nil), // 149: productv1.NestedTypeA - (*RecursiveType)(nil), // 150: productv1.RecursiveType - (*TypeWithMultipleFilterFields)(nil), // 151: productv1.TypeWithMultipleFilterFields - (*FilterTypeInput)(nil), // 152: productv1.FilterTypeInput - (*ComplexFilterTypeInput)(nil), // 153: productv1.ComplexFilterTypeInput - (*TypeWithComplexFilterInput)(nil), // 154: productv1.TypeWithComplexFilterInput - (*OrderInput)(nil), // 155: productv1.OrderInput - (*Order)(nil), // 156: productv1.Order - (*Category)(nil), // 157: productv1.Category - (*CategoryFilter)(nil), // 158: productv1.CategoryFilter - (*Animal)(nil), // 159: productv1.Animal - (*SearchInput)(nil), // 160: productv1.SearchInput - (*SearchResult)(nil), // 161: productv1.SearchResult - (*NullableFieldsType)(nil), // 162: productv1.NullableFieldsType - (*NullableFieldsFilter)(nil), // 163: productv1.NullableFieldsFilter - (*BlogPost)(nil), // 164: productv1.BlogPost - (*BlogPostFilter)(nil), // 165: productv1.BlogPostFilter - (*Author)(nil), // 166: productv1.Author - (*AuthorFilter)(nil), // 167: productv1.AuthorFilter - (*UserInput)(nil), // 168: productv1.UserInput - (*ActionInput)(nil), // 169: productv1.ActionInput - (*ActionResult)(nil), // 170: productv1.ActionResult - (*NullableFieldsInput)(nil), // 171: productv1.NullableFieldsInput - (*BlogPostInput)(nil), // 172: productv1.BlogPostInput - (*AuthorInput)(nil), // 173: productv1.AuthorInput - (*NestedTypeB)(nil), // 174: productv1.NestedTypeB - (*NestedTypeC)(nil), // 175: productv1.NestedTypeC - (*FilterType)(nil), // 176: productv1.FilterType - (*Pagination)(nil), // 177: productv1.Pagination - (*OrderLineInput)(nil), // 178: productv1.OrderLineInput - (*OrderLine)(nil), // 179: productv1.OrderLine - (*Subcategory)(nil), // 180: productv1.Subcategory - (*CategoryMetrics)(nil), // 181: productv1.CategoryMetrics - (*Cat)(nil), // 182: productv1.Cat - (*Dog)(nil), // 183: productv1.Dog - (*ActionSuccess)(nil), // 184: productv1.ActionSuccess - (*ActionError)(nil), // 185: productv1.ActionError - (*CategoryInput)(nil), // 186: productv1.CategoryInput - (*ProductCountFilter)(nil), // 187: productv1.ProductCountFilter - (*SubcategoryItemFilter)(nil), // 188: productv1.SubcategoryItemFilter - (*ShippingEstimateInput)(nil), // 189: productv1.ShippingEstimateInput - (*ListOfAuthorFilter_List)(nil), // 190: productv1.ListOfAuthorFilter.List - (*ListOfAuthorInput_List)(nil), // 191: productv1.ListOfAuthorInput.List - (*ListOfBlogPost_List)(nil), // 192: productv1.ListOfBlogPost.List - (*ListOfBlogPostFilter_List)(nil), // 193: productv1.ListOfBlogPostFilter.List - (*ListOfBlogPostInput_List)(nil), // 194: productv1.ListOfBlogPostInput.List - (*ListOfBoolean_List)(nil), // 195: productv1.ListOfBoolean.List - (*ListOfCategory_List)(nil), // 196: productv1.ListOfCategory.List - (*ListOfCategoryInput_List)(nil), // 197: productv1.ListOfCategoryInput.List - (*ListOfFloat_List)(nil), // 198: productv1.ListOfFloat.List - (*ListOfListOfCategory_List)(nil), // 199: productv1.ListOfListOfCategory.List - (*ListOfListOfCategoryInput_List)(nil), // 200: productv1.ListOfListOfCategoryInput.List - (*ListOfListOfString_List)(nil), // 201: productv1.ListOfListOfString.List - (*ListOfListOfUser_List)(nil), // 202: productv1.ListOfListOfUser.List - (*ListOfListOfUserInput_List)(nil), // 203: productv1.ListOfListOfUserInput.List - (*ListOfOrderLine_List)(nil), // 204: productv1.ListOfOrderLine.List - (*ListOfProduct_List)(nil), // 205: productv1.ListOfProduct.List - (*ListOfString_List)(nil), // 206: productv1.ListOfString.List - (*ListOfSubcategory_List)(nil), // 207: productv1.ListOfSubcategory.List - (*ListOfUser_List)(nil), // 208: productv1.ListOfUser.List - (*ListOfUserInput_List)(nil), // 209: productv1.ListOfUserInput.List - (*wrapperspb.Int32Value)(nil), // 210: google.protobuf.Int32Value - (*wrapperspb.StringValue)(nil), // 211: google.protobuf.StringValue - (*wrapperspb.DoubleValue)(nil), // 212: google.protobuf.DoubleValue - (*wrapperspb.BoolValue)(nil), // 213: google.protobuf.BoolValue + (CategoryKind)(0), // 0: productv1.CategoryKind + (ShippingDestination)(0), // 1: productv1.ShippingDestination + (*ListOfAuthorFilter)(nil), // 2: productv1.ListOfAuthorFilter + (*ListOfAuthorInput)(nil), // 3: productv1.ListOfAuthorInput + (*ListOfBlogPost)(nil), // 4: productv1.ListOfBlogPost + (*ListOfBlogPostFilter)(nil), // 5: productv1.ListOfBlogPostFilter + (*ListOfBlogPostInput)(nil), // 6: productv1.ListOfBlogPostInput + (*ListOfBoolean)(nil), // 7: productv1.ListOfBoolean + (*ListOfCategory)(nil), // 8: productv1.ListOfCategory + (*ListOfCategoryInput)(nil), // 9: productv1.ListOfCategoryInput + (*ListOfFloat)(nil), // 10: productv1.ListOfFloat + (*ListOfListOfCategory)(nil), // 11: productv1.ListOfListOfCategory + (*ListOfListOfCategoryInput)(nil), // 12: productv1.ListOfListOfCategoryInput + (*ListOfListOfString)(nil), // 13: productv1.ListOfListOfString + (*ListOfListOfUser)(nil), // 14: productv1.ListOfListOfUser + (*ListOfListOfUserInput)(nil), // 15: productv1.ListOfListOfUserInput + (*ListOfOrderLine)(nil), // 16: productv1.ListOfOrderLine + (*ListOfProduct)(nil), // 17: productv1.ListOfProduct + (*ListOfString)(nil), // 18: productv1.ListOfString + (*ListOfSubcategory)(nil), // 19: productv1.ListOfSubcategory + (*ListOfUser)(nil), // 20: productv1.ListOfUser + (*ListOfUserInput)(nil), // 21: productv1.ListOfUserInput + (*LookupProductByIdRequestKey)(nil), // 22: productv1.LookupProductByIdRequestKey + (*LookupProductByIdRequest)(nil), // 23: productv1.LookupProductByIdRequest + (*LookupProductByIdResponse)(nil), // 24: productv1.LookupProductByIdResponse + (*LookupStorageByIdRequestKey)(nil), // 25: productv1.LookupStorageByIdRequestKey + (*LookupStorageByIdRequest)(nil), // 26: productv1.LookupStorageByIdRequest + (*LookupStorageByIdResponse)(nil), // 27: productv1.LookupStorageByIdResponse + (*LookupWarehouseByIdRequestKey)(nil), // 28: productv1.LookupWarehouseByIdRequestKey + (*LookupWarehouseByIdRequest)(nil), // 29: productv1.LookupWarehouseByIdRequest + (*LookupWarehouseByIdResponse)(nil), // 30: productv1.LookupWarehouseByIdResponse + (*QueryUsersRequest)(nil), // 31: productv1.QueryUsersRequest + (*QueryUsersResponse)(nil), // 32: productv1.QueryUsersResponse + (*QueryUserRequest)(nil), // 33: productv1.QueryUserRequest + (*QueryUserResponse)(nil), // 34: productv1.QueryUserResponse + (*QueryNestedTypeRequest)(nil), // 35: productv1.QueryNestedTypeRequest + (*QueryNestedTypeResponse)(nil), // 36: productv1.QueryNestedTypeResponse + (*QueryRecursiveTypeRequest)(nil), // 37: productv1.QueryRecursiveTypeRequest + (*QueryRecursiveTypeResponse)(nil), // 38: productv1.QueryRecursiveTypeResponse + (*QueryTypeFilterWithArgumentsRequest)(nil), // 39: productv1.QueryTypeFilterWithArgumentsRequest + (*QueryTypeFilterWithArgumentsResponse)(nil), // 40: productv1.QueryTypeFilterWithArgumentsResponse + (*QueryTypeWithMultipleFilterFieldsRequest)(nil), // 41: productv1.QueryTypeWithMultipleFilterFieldsRequest + (*QueryTypeWithMultipleFilterFieldsResponse)(nil), // 42: productv1.QueryTypeWithMultipleFilterFieldsResponse + (*QueryComplexFilterTypeRequest)(nil), // 43: productv1.QueryComplexFilterTypeRequest + (*QueryComplexFilterTypeResponse)(nil), // 44: productv1.QueryComplexFilterTypeResponse + (*QueryCalculateTotalsRequest)(nil), // 45: productv1.QueryCalculateTotalsRequest + (*QueryCalculateTotalsResponse)(nil), // 46: productv1.QueryCalculateTotalsResponse + (*QueryCategoriesRequest)(nil), // 47: productv1.QueryCategoriesRequest + (*QueryCategoriesResponse)(nil), // 48: productv1.QueryCategoriesResponse + (*QueryCategoriesByKindRequest)(nil), // 49: productv1.QueryCategoriesByKindRequest + (*QueryCategoriesByKindResponse)(nil), // 50: productv1.QueryCategoriesByKindResponse + (*QueryCategoriesByKindsRequest)(nil), // 51: productv1.QueryCategoriesByKindsRequest + (*QueryCategoriesByKindsResponse)(nil), // 52: productv1.QueryCategoriesByKindsResponse + (*QueryFilterCategoriesRequest)(nil), // 53: productv1.QueryFilterCategoriesRequest + (*QueryFilterCategoriesResponse)(nil), // 54: productv1.QueryFilterCategoriesResponse + (*QueryRandomPetRequest)(nil), // 55: productv1.QueryRandomPetRequest + (*QueryRandomPetResponse)(nil), // 56: productv1.QueryRandomPetResponse + (*QueryAllPetsRequest)(nil), // 57: productv1.QueryAllPetsRequest + (*QueryAllPetsResponse)(nil), // 58: productv1.QueryAllPetsResponse + (*QuerySearchRequest)(nil), // 59: productv1.QuerySearchRequest + (*QuerySearchResponse)(nil), // 60: productv1.QuerySearchResponse + (*QueryRandomSearchResultRequest)(nil), // 61: productv1.QueryRandomSearchResultRequest + (*QueryRandomSearchResultResponse)(nil), // 62: productv1.QueryRandomSearchResultResponse + (*QueryNullableFieldsTypeRequest)(nil), // 63: productv1.QueryNullableFieldsTypeRequest + (*QueryNullableFieldsTypeResponse)(nil), // 64: productv1.QueryNullableFieldsTypeResponse + (*QueryNullableFieldsTypeByIdRequest)(nil), // 65: productv1.QueryNullableFieldsTypeByIdRequest + (*QueryNullableFieldsTypeByIdResponse)(nil), // 66: productv1.QueryNullableFieldsTypeByIdResponse + (*QueryNullableFieldsTypeWithFilterRequest)(nil), // 67: productv1.QueryNullableFieldsTypeWithFilterRequest + (*QueryNullableFieldsTypeWithFilterResponse)(nil), // 68: productv1.QueryNullableFieldsTypeWithFilterResponse + (*QueryAllNullableFieldsTypesRequest)(nil), // 69: productv1.QueryAllNullableFieldsTypesRequest + (*QueryAllNullableFieldsTypesResponse)(nil), // 70: productv1.QueryAllNullableFieldsTypesResponse + (*QueryBlogPostRequest)(nil), // 71: productv1.QueryBlogPostRequest + (*QueryBlogPostResponse)(nil), // 72: productv1.QueryBlogPostResponse + (*QueryBlogPostByIdRequest)(nil), // 73: productv1.QueryBlogPostByIdRequest + (*QueryBlogPostByIdResponse)(nil), // 74: productv1.QueryBlogPostByIdResponse + (*QueryBlogPostsWithFilterRequest)(nil), // 75: productv1.QueryBlogPostsWithFilterRequest + (*QueryBlogPostsWithFilterResponse)(nil), // 76: productv1.QueryBlogPostsWithFilterResponse + (*QueryAllBlogPostsRequest)(nil), // 77: productv1.QueryAllBlogPostsRequest + (*QueryAllBlogPostsResponse)(nil), // 78: productv1.QueryAllBlogPostsResponse + (*QueryAuthorRequest)(nil), // 79: productv1.QueryAuthorRequest + (*QueryAuthorResponse)(nil), // 80: productv1.QueryAuthorResponse + (*QueryAuthorByIdRequest)(nil), // 81: productv1.QueryAuthorByIdRequest + (*QueryAuthorByIdResponse)(nil), // 82: productv1.QueryAuthorByIdResponse + (*QueryAuthorsWithFilterRequest)(nil), // 83: productv1.QueryAuthorsWithFilterRequest + (*QueryAuthorsWithFilterResponse)(nil), // 84: productv1.QueryAuthorsWithFilterResponse + (*QueryAllAuthorsRequest)(nil), // 85: productv1.QueryAllAuthorsRequest + (*QueryAllAuthorsResponse)(nil), // 86: productv1.QueryAllAuthorsResponse + (*QueryBulkSearchAuthorsRequest)(nil), // 87: productv1.QueryBulkSearchAuthorsRequest + (*QueryBulkSearchAuthorsResponse)(nil), // 88: productv1.QueryBulkSearchAuthorsResponse + (*QueryBulkSearchBlogPostsRequest)(nil), // 89: productv1.QueryBulkSearchBlogPostsRequest + (*QueryBulkSearchBlogPostsResponse)(nil), // 90: productv1.QueryBulkSearchBlogPostsResponse + (*QueryTestContainerRequest)(nil), // 91: productv1.QueryTestContainerRequest + (*QueryTestContainerResponse)(nil), // 92: productv1.QueryTestContainerResponse + (*QueryTestContainersRequest)(nil), // 93: productv1.QueryTestContainersRequest + (*QueryTestContainersResponse)(nil), // 94: productv1.QueryTestContainersResponse + (*MutationCreateUserRequest)(nil), // 95: productv1.MutationCreateUserRequest + (*MutationCreateUserResponse)(nil), // 96: productv1.MutationCreateUserResponse + (*MutationPerformActionRequest)(nil), // 97: productv1.MutationPerformActionRequest + (*MutationPerformActionResponse)(nil), // 98: productv1.MutationPerformActionResponse + (*MutationCreateNullableFieldsTypeRequest)(nil), // 99: productv1.MutationCreateNullableFieldsTypeRequest + (*MutationCreateNullableFieldsTypeResponse)(nil), // 100: productv1.MutationCreateNullableFieldsTypeResponse + (*MutationUpdateNullableFieldsTypeRequest)(nil), // 101: productv1.MutationUpdateNullableFieldsTypeRequest + (*MutationUpdateNullableFieldsTypeResponse)(nil), // 102: productv1.MutationUpdateNullableFieldsTypeResponse + (*MutationCreateBlogPostRequest)(nil), // 103: productv1.MutationCreateBlogPostRequest + (*MutationCreateBlogPostResponse)(nil), // 104: productv1.MutationCreateBlogPostResponse + (*MutationUpdateBlogPostRequest)(nil), // 105: productv1.MutationUpdateBlogPostRequest + (*MutationUpdateBlogPostResponse)(nil), // 106: productv1.MutationUpdateBlogPostResponse + (*MutationCreateAuthorRequest)(nil), // 107: productv1.MutationCreateAuthorRequest + (*MutationCreateAuthorResponse)(nil), // 108: productv1.MutationCreateAuthorResponse + (*MutationUpdateAuthorRequest)(nil), // 109: productv1.MutationUpdateAuthorRequest + (*MutationUpdateAuthorResponse)(nil), // 110: productv1.MutationUpdateAuthorResponse + (*MutationBulkCreateAuthorsRequest)(nil), // 111: productv1.MutationBulkCreateAuthorsRequest + (*MutationBulkCreateAuthorsResponse)(nil), // 112: productv1.MutationBulkCreateAuthorsResponse + (*MutationBulkUpdateAuthorsRequest)(nil), // 113: productv1.MutationBulkUpdateAuthorsRequest + (*MutationBulkUpdateAuthorsResponse)(nil), // 114: productv1.MutationBulkUpdateAuthorsResponse + (*MutationBulkCreateBlogPostsRequest)(nil), // 115: productv1.MutationBulkCreateBlogPostsRequest + (*MutationBulkCreateBlogPostsResponse)(nil), // 116: productv1.MutationBulkCreateBlogPostsResponse + (*MutationBulkUpdateBlogPostsRequest)(nil), // 117: productv1.MutationBulkUpdateBlogPostsRequest + (*MutationBulkUpdateBlogPostsResponse)(nil), // 118: productv1.MutationBulkUpdateBlogPostsResponse + (*ResolveProductShippingEstimateArgs)(nil), // 119: productv1.ResolveProductShippingEstimateArgs + (*ResolveProductShippingEstimateContext)(nil), // 120: productv1.ResolveProductShippingEstimateContext + (*ResolveProductShippingEstimateRequest)(nil), // 121: productv1.ResolveProductShippingEstimateRequest + (*ResolveProductShippingEstimateResult)(nil), // 122: productv1.ResolveProductShippingEstimateResult + (*ResolveProductShippingEstimateResponse)(nil), // 123: productv1.ResolveProductShippingEstimateResponse + (*ResolveProductRecommendedCategoryArgs)(nil), // 124: productv1.ResolveProductRecommendedCategoryArgs + (*ResolveProductRecommendedCategoryContext)(nil), // 125: productv1.ResolveProductRecommendedCategoryContext + (*ResolveProductRecommendedCategoryRequest)(nil), // 126: productv1.ResolveProductRecommendedCategoryRequest + (*ResolveProductRecommendedCategoryResult)(nil), // 127: productv1.ResolveProductRecommendedCategoryResult + (*ResolveProductRecommendedCategoryResponse)(nil), // 128: productv1.ResolveProductRecommendedCategoryResponse + (*ResolveProductMascotRecommendationArgs)(nil), // 129: productv1.ResolveProductMascotRecommendationArgs + (*ResolveProductMascotRecommendationContext)(nil), // 130: productv1.ResolveProductMascotRecommendationContext + (*ResolveProductMascotRecommendationRequest)(nil), // 131: productv1.ResolveProductMascotRecommendationRequest + (*ResolveProductMascotRecommendationResult)(nil), // 132: productv1.ResolveProductMascotRecommendationResult + (*ResolveProductMascotRecommendationResponse)(nil), // 133: productv1.ResolveProductMascotRecommendationResponse + (*ResolveProductStockStatusArgs)(nil), // 134: productv1.ResolveProductStockStatusArgs + (*ResolveProductStockStatusContext)(nil), // 135: productv1.ResolveProductStockStatusContext + (*ResolveProductStockStatusRequest)(nil), // 136: productv1.ResolveProductStockStatusRequest + (*ResolveProductStockStatusResult)(nil), // 137: productv1.ResolveProductStockStatusResult + (*ResolveProductStockStatusResponse)(nil), // 138: productv1.ResolveProductStockStatusResponse + (*ResolveProductProductDetailsArgs)(nil), // 139: productv1.ResolveProductProductDetailsArgs + (*ResolveProductProductDetailsContext)(nil), // 140: productv1.ResolveProductProductDetailsContext + (*ResolveProductProductDetailsRequest)(nil), // 141: productv1.ResolveProductProductDetailsRequest + (*ResolveProductProductDetailsResult)(nil), // 142: productv1.ResolveProductProductDetailsResult + (*ResolveProductProductDetailsResponse)(nil), // 143: productv1.ResolveProductProductDetailsResponse + (*ResolveCategoryProductCountArgs)(nil), // 144: productv1.ResolveCategoryProductCountArgs + (*ResolveCategoryProductCountContext)(nil), // 145: productv1.ResolveCategoryProductCountContext + (*ResolveCategoryProductCountRequest)(nil), // 146: productv1.ResolveCategoryProductCountRequest + (*ResolveCategoryProductCountResult)(nil), // 147: productv1.ResolveCategoryProductCountResult + (*ResolveCategoryProductCountResponse)(nil), // 148: productv1.ResolveCategoryProductCountResponse + (*ResolveCategoryPopularityScoreArgs)(nil), // 149: productv1.ResolveCategoryPopularityScoreArgs + (*ResolveCategoryPopularityScoreContext)(nil), // 150: productv1.ResolveCategoryPopularityScoreContext + (*ResolveCategoryPopularityScoreRequest)(nil), // 151: productv1.ResolveCategoryPopularityScoreRequest + (*ResolveCategoryPopularityScoreResult)(nil), // 152: productv1.ResolveCategoryPopularityScoreResult + (*ResolveCategoryPopularityScoreResponse)(nil), // 153: productv1.ResolveCategoryPopularityScoreResponse + (*ResolveCategoryCategoryMetricsArgs)(nil), // 154: productv1.ResolveCategoryCategoryMetricsArgs + (*ResolveCategoryCategoryMetricsContext)(nil), // 155: productv1.ResolveCategoryCategoryMetricsContext + (*ResolveCategoryCategoryMetricsRequest)(nil), // 156: productv1.ResolveCategoryCategoryMetricsRequest + (*ResolveCategoryCategoryMetricsResult)(nil), // 157: productv1.ResolveCategoryCategoryMetricsResult + (*ResolveCategoryCategoryMetricsResponse)(nil), // 158: productv1.ResolveCategoryCategoryMetricsResponse + (*ResolveCategoryMascotArgs)(nil), // 159: productv1.ResolveCategoryMascotArgs + (*ResolveCategoryMascotContext)(nil), // 160: productv1.ResolveCategoryMascotContext + (*ResolveCategoryMascotRequest)(nil), // 161: productv1.ResolveCategoryMascotRequest + (*ResolveCategoryMascotResult)(nil), // 162: productv1.ResolveCategoryMascotResult + (*ResolveCategoryMascotResponse)(nil), // 163: productv1.ResolveCategoryMascotResponse + (*ResolveCategoryCategoryStatusArgs)(nil), // 164: productv1.ResolveCategoryCategoryStatusArgs + (*ResolveCategoryCategoryStatusContext)(nil), // 165: productv1.ResolveCategoryCategoryStatusContext + (*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 + (*ActionSuccess)(nil), // 225: productv1.ActionSuccess + (*ActionError)(nil), // 226: productv1.ActionError + (*TestDetails)(nil), // 227: productv1.TestDetails + (*CategoryInput)(nil), // 228: productv1.CategoryInput + (*ProductCountFilter)(nil), // 229: productv1.ProductCountFilter + (*SubcategoryItemFilter)(nil), // 230: productv1.SubcategoryItemFilter + (*ShippingEstimateInput)(nil), // 231: productv1.ShippingEstimateInput + (*ListOfAuthorFilter_List)(nil), // 232: productv1.ListOfAuthorFilter.List + (*ListOfAuthorInput_List)(nil), // 233: productv1.ListOfAuthorInput.List + (*ListOfBlogPost_List)(nil), // 234: productv1.ListOfBlogPost.List + (*ListOfBlogPostFilter_List)(nil), // 235: productv1.ListOfBlogPostFilter.List + (*ListOfBlogPostInput_List)(nil), // 236: productv1.ListOfBlogPostInput.List + (*ListOfBoolean_List)(nil), // 237: productv1.ListOfBoolean.List + (*ListOfCategory_List)(nil), // 238: productv1.ListOfCategory.List + (*ListOfCategoryInput_List)(nil), // 239: productv1.ListOfCategoryInput.List + (*ListOfFloat_List)(nil), // 240: productv1.ListOfFloat.List + (*ListOfListOfCategory_List)(nil), // 241: productv1.ListOfListOfCategory.List + (*ListOfListOfCategoryInput_List)(nil), // 242: productv1.ListOfListOfCategoryInput.List + (*ListOfListOfString_List)(nil), // 243: productv1.ListOfListOfString.List + (*ListOfListOfUser_List)(nil), // 244: productv1.ListOfListOfUser.List + (*ListOfListOfUserInput_List)(nil), // 245: productv1.ListOfListOfUserInput.List + (*ListOfOrderLine_List)(nil), // 246: productv1.ListOfOrderLine.List + (*ListOfProduct_List)(nil), // 247: productv1.ListOfProduct.List + (*ListOfString_List)(nil), // 248: productv1.ListOfString.List + (*ListOfSubcategory_List)(nil), // 249: productv1.ListOfSubcategory.List + (*ListOfUser_List)(nil), // 250: productv1.ListOfUser.List + (*ListOfUserInput_List)(nil), // 251: productv1.ListOfUserInput.List + (*wrapperspb.Int32Value)(nil), // 252: google.protobuf.Int32Value + (*wrapperspb.StringValue)(nil), // 253: google.protobuf.StringValue + (*wrapperspb.DoubleValue)(nil), // 254: google.protobuf.DoubleValue + (*wrapperspb.BoolValue)(nil), // 255: google.protobuf.BoolValue } var file_product_proto_depIdxs = []int32{ - 190, // 0: productv1.ListOfAuthorFilter.list:type_name -> productv1.ListOfAuthorFilter.List - 191, // 1: productv1.ListOfAuthorInput.list:type_name -> productv1.ListOfAuthorInput.List - 192, // 2: productv1.ListOfBlogPost.list:type_name -> productv1.ListOfBlogPost.List - 193, // 3: productv1.ListOfBlogPostFilter.list:type_name -> productv1.ListOfBlogPostFilter.List - 194, // 4: productv1.ListOfBlogPostInput.list:type_name -> productv1.ListOfBlogPostInput.List - 195, // 5: productv1.ListOfBoolean.list:type_name -> productv1.ListOfBoolean.List - 196, // 6: productv1.ListOfCategory.list:type_name -> productv1.ListOfCategory.List - 197, // 7: productv1.ListOfCategoryInput.list:type_name -> productv1.ListOfCategoryInput.List - 198, // 8: productv1.ListOfFloat.list:type_name -> productv1.ListOfFloat.List - 199, // 9: productv1.ListOfListOfCategory.list:type_name -> productv1.ListOfListOfCategory.List - 200, // 10: productv1.ListOfListOfCategoryInput.list:type_name -> productv1.ListOfListOfCategoryInput.List - 201, // 11: productv1.ListOfListOfString.list:type_name -> productv1.ListOfListOfString.List - 202, // 12: productv1.ListOfListOfUser.list:type_name -> productv1.ListOfListOfUser.List - 203, // 13: productv1.ListOfListOfUserInput.list:type_name -> productv1.ListOfListOfUserInput.List - 204, // 14: productv1.ListOfOrderLine.list:type_name -> productv1.ListOfOrderLine.List - 205, // 15: productv1.ListOfProduct.list:type_name -> productv1.ListOfProduct.List - 206, // 16: productv1.ListOfString.list:type_name -> productv1.ListOfString.List - 207, // 17: productv1.ListOfSubcategory.list:type_name -> productv1.ListOfSubcategory.List - 208, // 18: productv1.ListOfUser.list:type_name -> productv1.ListOfUser.List - 209, // 19: productv1.ListOfUserInput.list:type_name -> productv1.ListOfUserInput.List + 232, // 0: productv1.ListOfAuthorFilter.list:type_name -> productv1.ListOfAuthorFilter.List + 233, // 1: productv1.ListOfAuthorInput.list:type_name -> productv1.ListOfAuthorInput.List + 234, // 2: productv1.ListOfBlogPost.list:type_name -> productv1.ListOfBlogPost.List + 235, // 3: productv1.ListOfBlogPostFilter.list:type_name -> productv1.ListOfBlogPostFilter.List + 236, // 4: productv1.ListOfBlogPostInput.list:type_name -> productv1.ListOfBlogPostInput.List + 237, // 5: productv1.ListOfBoolean.list:type_name -> productv1.ListOfBoolean.List + 238, // 6: productv1.ListOfCategory.list:type_name -> productv1.ListOfCategory.List + 239, // 7: productv1.ListOfCategoryInput.list:type_name -> productv1.ListOfCategoryInput.List + 240, // 8: productv1.ListOfFloat.list:type_name -> productv1.ListOfFloat.List + 241, // 9: productv1.ListOfListOfCategory.list:type_name -> productv1.ListOfListOfCategory.List + 242, // 10: productv1.ListOfListOfCategoryInput.list:type_name -> productv1.ListOfListOfCategoryInput.List + 243, // 11: productv1.ListOfListOfString.list:type_name -> productv1.ListOfListOfString.List + 244, // 12: productv1.ListOfListOfUser.list:type_name -> productv1.ListOfListOfUser.List + 245, // 13: productv1.ListOfListOfUserInput.list:type_name -> productv1.ListOfListOfUserInput.List + 246, // 14: productv1.ListOfOrderLine.list:type_name -> productv1.ListOfOrderLine.List + 247, // 15: productv1.ListOfProduct.list:type_name -> productv1.ListOfProduct.List + 248, // 16: productv1.ListOfString.list:type_name -> productv1.ListOfString.List + 249, // 17: productv1.ListOfSubcategory.list:type_name -> productv1.ListOfSubcategory.List + 250, // 18: productv1.ListOfUser.list:type_name -> productv1.ListOfUser.List + 251, // 19: productv1.ListOfUserInput.list:type_name -> productv1.ListOfUserInput.List 22, // 20: productv1.LookupProductByIdRequest.keys:type_name -> productv1.LookupProductByIdRequestKey - 145, // 21: productv1.LookupProductByIdResponse.result:type_name -> productv1.Product + 184, // 21: productv1.LookupProductByIdResponse.result:type_name -> productv1.Product 25, // 22: productv1.LookupStorageByIdRequest.keys:type_name -> productv1.LookupStorageByIdRequestKey - 146, // 23: productv1.LookupStorageByIdResponse.result:type_name -> productv1.Storage + 185, // 23: productv1.LookupStorageByIdResponse.result:type_name -> productv1.Storage 28, // 24: productv1.LookupWarehouseByIdRequest.keys:type_name -> productv1.LookupWarehouseByIdRequestKey - 147, // 25: productv1.LookupWarehouseByIdResponse.result:type_name -> productv1.Warehouse - 148, // 26: productv1.QueryUsersResponse.users:type_name -> productv1.User - 148, // 27: productv1.QueryUserResponse.user:type_name -> productv1.User - 149, // 28: productv1.QueryNestedTypeResponse.nested_type:type_name -> productv1.NestedTypeA - 150, // 29: productv1.QueryRecursiveTypeResponse.recursive_type:type_name -> productv1.RecursiveType - 151, // 30: productv1.QueryTypeFilterWithArgumentsResponse.type_filter_with_arguments:type_name -> productv1.TypeWithMultipleFilterFields - 152, // 31: productv1.QueryTypeWithMultipleFilterFieldsRequest.filter:type_name -> productv1.FilterTypeInput - 151, // 32: productv1.QueryTypeWithMultipleFilterFieldsResponse.type_with_multiple_filter_fields:type_name -> productv1.TypeWithMultipleFilterFields - 153, // 33: productv1.QueryComplexFilterTypeRequest.filter:type_name -> productv1.ComplexFilterTypeInput - 154, // 34: productv1.QueryComplexFilterTypeResponse.complex_filter_type:type_name -> productv1.TypeWithComplexFilterInput - 155, // 35: productv1.QueryCalculateTotalsRequest.orders:type_name -> productv1.OrderInput - 156, // 36: productv1.QueryCalculateTotalsResponse.calculate_totals:type_name -> productv1.Order - 157, // 37: productv1.QueryCategoriesResponse.categories:type_name -> productv1.Category + 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 0, // 38: productv1.QueryCategoriesByKindRequest.kind:type_name -> productv1.CategoryKind - 157, // 39: productv1.QueryCategoriesByKindResponse.categories_by_kind:type_name -> productv1.Category + 196, // 39: productv1.QueryCategoriesByKindResponse.categories_by_kind:type_name -> productv1.Category 0, // 40: productv1.QueryCategoriesByKindsRequest.kinds:type_name -> productv1.CategoryKind - 157, // 41: productv1.QueryCategoriesByKindsResponse.categories_by_kinds:type_name -> productv1.Category - 158, // 42: productv1.QueryFilterCategoriesRequest.filter:type_name -> productv1.CategoryFilter - 157, // 43: productv1.QueryFilterCategoriesResponse.filter_categories:type_name -> productv1.Category - 159, // 44: productv1.QueryRandomPetResponse.random_pet:type_name -> productv1.Animal - 159, // 45: productv1.QueryAllPetsResponse.all_pets:type_name -> productv1.Animal - 160, // 46: productv1.QuerySearchRequest.input:type_name -> productv1.SearchInput - 161, // 47: productv1.QuerySearchResponse.search:type_name -> productv1.SearchResult - 161, // 48: productv1.QueryRandomSearchResultResponse.random_search_result:type_name -> productv1.SearchResult - 162, // 49: productv1.QueryNullableFieldsTypeResponse.nullable_fields_type:type_name -> productv1.NullableFieldsType - 162, // 50: productv1.QueryNullableFieldsTypeByIdResponse.nullable_fields_type_by_id:type_name -> productv1.NullableFieldsType - 163, // 51: productv1.QueryNullableFieldsTypeWithFilterRequest.filter:type_name -> productv1.NullableFieldsFilter - 162, // 52: productv1.QueryNullableFieldsTypeWithFilterResponse.nullable_fields_type_with_filter:type_name -> productv1.NullableFieldsType - 162, // 53: productv1.QueryAllNullableFieldsTypesResponse.all_nullable_fields_types:type_name -> productv1.NullableFieldsType - 164, // 54: productv1.QueryBlogPostResponse.blog_post:type_name -> productv1.BlogPost - 164, // 55: productv1.QueryBlogPostByIdResponse.blog_post_by_id:type_name -> productv1.BlogPost - 165, // 56: productv1.QueryBlogPostsWithFilterRequest.filter:type_name -> productv1.BlogPostFilter - 164, // 57: productv1.QueryBlogPostsWithFilterResponse.blog_posts_with_filter:type_name -> productv1.BlogPost - 164, // 58: productv1.QueryAllBlogPostsResponse.all_blog_posts:type_name -> productv1.BlogPost - 166, // 59: productv1.QueryAuthorResponse.author:type_name -> productv1.Author - 166, // 60: productv1.QueryAuthorByIdResponse.author_by_id:type_name -> productv1.Author - 167, // 61: productv1.QueryAuthorsWithFilterRequest.filter:type_name -> productv1.AuthorFilter - 166, // 62: productv1.QueryAuthorsWithFilterResponse.authors_with_filter:type_name -> productv1.Author - 166, // 63: productv1.QueryAllAuthorsResponse.all_authors:type_name -> productv1.Author + 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 2, // 64: productv1.QueryBulkSearchAuthorsRequest.filters:type_name -> productv1.ListOfAuthorFilter - 166, // 65: productv1.QueryBulkSearchAuthorsResponse.bulk_search_authors:type_name -> productv1.Author + 205, // 65: productv1.QueryBulkSearchAuthorsResponse.bulk_search_authors:type_name -> productv1.Author 5, // 66: productv1.QueryBulkSearchBlogPostsRequest.filters:type_name -> productv1.ListOfBlogPostFilter - 164, // 67: productv1.QueryBulkSearchBlogPostsResponse.bulk_search_blog_posts:type_name -> productv1.BlogPost - 168, // 68: productv1.MutationCreateUserRequest.input:type_name -> productv1.UserInput - 148, // 69: productv1.MutationCreateUserResponse.create_user:type_name -> productv1.User - 169, // 70: productv1.MutationPerformActionRequest.input:type_name -> productv1.ActionInput - 170, // 71: productv1.MutationPerformActionResponse.perform_action:type_name -> productv1.ActionResult - 171, // 72: productv1.MutationCreateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput - 162, // 73: productv1.MutationCreateNullableFieldsTypeResponse.create_nullable_fields_type:type_name -> productv1.NullableFieldsType - 171, // 74: productv1.MutationUpdateNullableFieldsTypeRequest.input:type_name -> productv1.NullableFieldsInput - 162, // 75: productv1.MutationUpdateNullableFieldsTypeResponse.update_nullable_fields_type:type_name -> productv1.NullableFieldsType - 172, // 76: productv1.MutationCreateBlogPostRequest.input:type_name -> productv1.BlogPostInput - 164, // 77: productv1.MutationCreateBlogPostResponse.create_blog_post:type_name -> productv1.BlogPost - 172, // 78: productv1.MutationUpdateBlogPostRequest.input:type_name -> productv1.BlogPostInput - 164, // 79: productv1.MutationUpdateBlogPostResponse.update_blog_post:type_name -> productv1.BlogPost - 173, // 80: productv1.MutationCreateAuthorRequest.input:type_name -> productv1.AuthorInput - 166, // 81: productv1.MutationCreateAuthorResponse.create_author:type_name -> productv1.Author - 173, // 82: productv1.MutationUpdateAuthorRequest.input:type_name -> productv1.AuthorInput - 166, // 83: productv1.MutationUpdateAuthorResponse.update_author:type_name -> productv1.Author - 3, // 84: productv1.MutationBulkCreateAuthorsRequest.authors:type_name -> productv1.ListOfAuthorInput - 166, // 85: productv1.MutationBulkCreateAuthorsResponse.bulk_create_authors:type_name -> productv1.Author - 3, // 86: productv1.MutationBulkUpdateAuthorsRequest.authors:type_name -> productv1.ListOfAuthorInput - 166, // 87: productv1.MutationBulkUpdateAuthorsResponse.bulk_update_authors:type_name -> productv1.Author - 6, // 88: productv1.MutationBulkCreateBlogPostsRequest.blog_posts:type_name -> productv1.ListOfBlogPostInput - 164, // 89: productv1.MutationBulkCreateBlogPostsResponse.bulk_create_blog_posts:type_name -> productv1.BlogPost - 6, // 90: productv1.MutationBulkUpdateBlogPostsRequest.blog_posts:type_name -> productv1.ListOfBlogPostInput - 164, // 91: productv1.MutationBulkUpdateBlogPostsResponse.bulk_update_blog_posts:type_name -> productv1.BlogPost - 189, // 92: productv1.ResolveProductShippingEstimateArgs.input:type_name -> productv1.ShippingEstimateInput - 116, // 93: productv1.ResolveProductShippingEstimateRequest.context:type_name -> productv1.ResolveProductShippingEstimateContext - 115, // 94: productv1.ResolveProductShippingEstimateRequest.field_args:type_name -> productv1.ResolveProductShippingEstimateArgs - 118, // 95: productv1.ResolveProductShippingEstimateResponse.result:type_name -> productv1.ResolveProductShippingEstimateResult - 121, // 96: productv1.ResolveProductRecommendedCategoryRequest.context:type_name -> productv1.ResolveProductRecommendedCategoryContext - 120, // 97: productv1.ResolveProductRecommendedCategoryRequest.field_args:type_name -> productv1.ResolveProductRecommendedCategoryArgs - 157, // 98: productv1.ResolveProductRecommendedCategoryResult.recommended_category:type_name -> productv1.Category - 123, // 99: productv1.ResolveProductRecommendedCategoryResponse.result:type_name -> productv1.ResolveProductRecommendedCategoryResult - 187, // 100: productv1.ResolveCategoryProductCountArgs.filters:type_name -> productv1.ProductCountFilter - 126, // 101: productv1.ResolveCategoryProductCountRequest.context:type_name -> productv1.ResolveCategoryProductCountContext - 125, // 102: productv1.ResolveCategoryProductCountRequest.field_args:type_name -> productv1.ResolveCategoryProductCountArgs - 128, // 103: productv1.ResolveCategoryProductCountResponse.result:type_name -> productv1.ResolveCategoryProductCountResult - 210, // 104: productv1.ResolveCategoryPopularityScoreArgs.threshold:type_name -> google.protobuf.Int32Value - 131, // 105: productv1.ResolveCategoryPopularityScoreRequest.context:type_name -> productv1.ResolveCategoryPopularityScoreContext - 130, // 106: productv1.ResolveCategoryPopularityScoreRequest.field_args:type_name -> productv1.ResolveCategoryPopularityScoreArgs - 210, // 107: productv1.ResolveCategoryPopularityScoreResult.popularity_score:type_name -> google.protobuf.Int32Value - 133, // 108: productv1.ResolveCategoryPopularityScoreResponse.result:type_name -> productv1.ResolveCategoryPopularityScoreResult - 136, // 109: productv1.ResolveCategoryCategoryMetricsRequest.context:type_name -> productv1.ResolveCategoryCategoryMetricsContext - 135, // 110: productv1.ResolveCategoryCategoryMetricsRequest.field_args:type_name -> productv1.ResolveCategoryCategoryMetricsArgs - 181, // 111: productv1.ResolveCategoryCategoryMetricsResult.category_metrics:type_name -> productv1.CategoryMetrics - 138, // 112: productv1.ResolveCategoryCategoryMetricsResponse.result:type_name -> productv1.ResolveCategoryCategoryMetricsResult - 188, // 113: productv1.ResolveSubcategoryItemCountArgs.filters:type_name -> productv1.SubcategoryItemFilter - 141, // 114: productv1.ResolveSubcategoryItemCountRequest.context:type_name -> productv1.ResolveSubcategoryItemCountContext - 140, // 115: productv1.ResolveSubcategoryItemCountRequest.field_args:type_name -> productv1.ResolveSubcategoryItemCountArgs - 143, // 116: productv1.ResolveSubcategoryItemCountResponse.result:type_name -> productv1.ResolveSubcategoryItemCountResult - 174, // 117: productv1.NestedTypeA.b:type_name -> productv1.NestedTypeB - 150, // 118: productv1.RecursiveType.recursive_type:type_name -> productv1.RecursiveType - 176, // 119: productv1.ComplexFilterTypeInput.filter:type_name -> productv1.FilterType - 178, // 120: productv1.OrderInput.lines:type_name -> productv1.OrderLineInput - 16, // 121: productv1.Order.order_lines:type_name -> productv1.ListOfOrderLine - 0, // 122: productv1.Category.kind:type_name -> productv1.CategoryKind - 19, // 123: productv1.Category.subcategories:type_name -> productv1.ListOfSubcategory - 0, // 124: productv1.CategoryFilter.category:type_name -> productv1.CategoryKind - 177, // 125: productv1.CategoryFilter.pagination:type_name -> productv1.Pagination - 182, // 126: productv1.Animal.cat:type_name -> productv1.Cat - 183, // 127: productv1.Animal.dog:type_name -> productv1.Dog - 210, // 128: productv1.SearchInput.limit:type_name -> google.protobuf.Int32Value - 145, // 129: productv1.SearchResult.product:type_name -> productv1.Product - 148, // 130: productv1.SearchResult.user:type_name -> productv1.User - 157, // 131: productv1.SearchResult.category:type_name -> productv1.Category - 211, // 132: productv1.NullableFieldsType.optional_string:type_name -> google.protobuf.StringValue - 210, // 133: productv1.NullableFieldsType.optional_int:type_name -> google.protobuf.Int32Value - 212, // 134: productv1.NullableFieldsType.optional_float:type_name -> google.protobuf.DoubleValue - 213, // 135: productv1.NullableFieldsType.optional_boolean:type_name -> google.protobuf.BoolValue - 211, // 136: productv1.NullableFieldsFilter.name:type_name -> google.protobuf.StringValue - 211, // 137: productv1.NullableFieldsFilter.optional_string:type_name -> google.protobuf.StringValue - 213, // 138: productv1.NullableFieldsFilter.include_nulls:type_name -> google.protobuf.BoolValue - 18, // 139: productv1.BlogPost.optional_tags:type_name -> productv1.ListOfString - 18, // 140: productv1.BlogPost.keywords:type_name -> productv1.ListOfString - 10, // 141: productv1.BlogPost.ratings:type_name -> productv1.ListOfFloat - 7, // 142: productv1.BlogPost.is_published:type_name -> productv1.ListOfBoolean - 13, // 143: productv1.BlogPost.tag_groups:type_name -> productv1.ListOfListOfString - 13, // 144: productv1.BlogPost.related_topics:type_name -> productv1.ListOfListOfString - 13, // 145: productv1.BlogPost.comment_threads:type_name -> productv1.ListOfListOfString - 13, // 146: productv1.BlogPost.suggestions:type_name -> productv1.ListOfListOfString - 157, // 147: productv1.BlogPost.related_categories:type_name -> productv1.Category - 148, // 148: productv1.BlogPost.contributors:type_name -> productv1.User - 17, // 149: productv1.BlogPost.mentioned_products:type_name -> productv1.ListOfProduct - 20, // 150: productv1.BlogPost.mentioned_users:type_name -> productv1.ListOfUser - 11, // 151: productv1.BlogPost.category_groups:type_name -> productv1.ListOfListOfCategory - 14, // 152: productv1.BlogPost.contributor_teams:type_name -> productv1.ListOfListOfUser - 211, // 153: productv1.BlogPostFilter.title:type_name -> google.protobuf.StringValue - 213, // 154: productv1.BlogPostFilter.has_categories:type_name -> google.protobuf.BoolValue - 210, // 155: productv1.BlogPostFilter.min_tags:type_name -> google.protobuf.Int32Value - 211, // 156: productv1.Author.email:type_name -> google.protobuf.StringValue - 18, // 157: productv1.Author.social_links:type_name -> productv1.ListOfString - 13, // 158: productv1.Author.teams_by_project:type_name -> productv1.ListOfListOfString - 13, // 159: productv1.Author.collaborations:type_name -> productv1.ListOfListOfString - 4, // 160: productv1.Author.written_posts:type_name -> productv1.ListOfBlogPost - 157, // 161: productv1.Author.favorite_categories:type_name -> productv1.Category - 20, // 162: productv1.Author.related_authors:type_name -> productv1.ListOfUser - 17, // 163: productv1.Author.product_reviews:type_name -> productv1.ListOfProduct - 14, // 164: productv1.Author.author_groups:type_name -> productv1.ListOfListOfUser - 11, // 165: productv1.Author.category_preferences:type_name -> productv1.ListOfListOfCategory - 14, // 166: productv1.Author.project_teams:type_name -> productv1.ListOfListOfUser - 211, // 167: productv1.AuthorFilter.name:type_name -> google.protobuf.StringValue - 213, // 168: productv1.AuthorFilter.has_teams:type_name -> google.protobuf.BoolValue - 210, // 169: productv1.AuthorFilter.skill_count:type_name -> google.protobuf.Int32Value - 184, // 170: productv1.ActionResult.action_success:type_name -> productv1.ActionSuccess - 185, // 171: productv1.ActionResult.action_error:type_name -> productv1.ActionError - 211, // 172: productv1.NullableFieldsInput.optional_string:type_name -> google.protobuf.StringValue - 210, // 173: productv1.NullableFieldsInput.optional_int:type_name -> google.protobuf.Int32Value - 212, // 174: productv1.NullableFieldsInput.optional_float:type_name -> google.protobuf.DoubleValue - 213, // 175: productv1.NullableFieldsInput.optional_boolean:type_name -> google.protobuf.BoolValue - 18, // 176: productv1.BlogPostInput.optional_tags:type_name -> productv1.ListOfString - 18, // 177: productv1.BlogPostInput.keywords:type_name -> productv1.ListOfString - 10, // 178: productv1.BlogPostInput.ratings:type_name -> productv1.ListOfFloat - 7, // 179: productv1.BlogPostInput.is_published:type_name -> productv1.ListOfBoolean - 13, // 180: productv1.BlogPostInput.tag_groups:type_name -> productv1.ListOfListOfString - 13, // 181: productv1.BlogPostInput.related_topics:type_name -> productv1.ListOfListOfString - 13, // 182: productv1.BlogPostInput.comment_threads:type_name -> productv1.ListOfListOfString - 13, // 183: productv1.BlogPostInput.suggestions:type_name -> productv1.ListOfListOfString - 9, // 184: productv1.BlogPostInput.related_categories:type_name -> productv1.ListOfCategoryInput - 21, // 185: productv1.BlogPostInput.contributors:type_name -> productv1.ListOfUserInput - 12, // 186: productv1.BlogPostInput.category_groups:type_name -> productv1.ListOfListOfCategoryInput - 211, // 187: productv1.AuthorInput.email:type_name -> google.protobuf.StringValue - 18, // 188: productv1.AuthorInput.social_links:type_name -> productv1.ListOfString - 13, // 189: productv1.AuthorInput.teams_by_project:type_name -> productv1.ListOfListOfString - 13, // 190: productv1.AuthorInput.collaborations:type_name -> productv1.ListOfListOfString - 186, // 191: productv1.AuthorInput.favorite_categories:type_name -> productv1.CategoryInput - 15, // 192: productv1.AuthorInput.author_groups:type_name -> productv1.ListOfListOfUserInput - 15, // 193: productv1.AuthorInput.project_teams:type_name -> productv1.ListOfListOfUserInput - 175, // 194: productv1.NestedTypeB.c:type_name -> productv1.NestedTypeC - 177, // 195: productv1.FilterType.pagination:type_name -> productv1.Pagination - 18, // 196: productv1.OrderLineInput.modifiers:type_name -> productv1.ListOfString - 18, // 197: productv1.OrderLine.modifiers:type_name -> productv1.ListOfString - 211, // 198: productv1.Subcategory.description:type_name -> google.protobuf.StringValue - 0, // 199: productv1.CategoryInput.kind:type_name -> productv1.CategoryKind - 212, // 200: productv1.ProductCountFilter.min_price:type_name -> google.protobuf.DoubleValue - 212, // 201: productv1.ProductCountFilter.max_price:type_name -> google.protobuf.DoubleValue - 213, // 202: productv1.ProductCountFilter.in_stock:type_name -> google.protobuf.BoolValue - 211, // 203: productv1.ProductCountFilter.search_term:type_name -> google.protobuf.StringValue - 212, // 204: productv1.SubcategoryItemFilter.min_price:type_name -> google.protobuf.DoubleValue - 212, // 205: productv1.SubcategoryItemFilter.max_price:type_name -> google.protobuf.DoubleValue - 213, // 206: productv1.SubcategoryItemFilter.in_stock:type_name -> google.protobuf.BoolValue - 213, // 207: productv1.SubcategoryItemFilter.is_active:type_name -> google.protobuf.BoolValue - 211, // 208: productv1.SubcategoryItemFilter.search_term:type_name -> google.protobuf.StringValue - 1, // 209: productv1.ShippingEstimateInput.destination:type_name -> productv1.ShippingDestination - 213, // 210: productv1.ShippingEstimateInput.expedited:type_name -> google.protobuf.BoolValue - 167, // 211: productv1.ListOfAuthorFilter.List.items:type_name -> productv1.AuthorFilter - 173, // 212: productv1.ListOfAuthorInput.List.items:type_name -> productv1.AuthorInput - 164, // 213: productv1.ListOfBlogPost.List.items:type_name -> productv1.BlogPost - 165, // 214: productv1.ListOfBlogPostFilter.List.items:type_name -> productv1.BlogPostFilter - 172, // 215: productv1.ListOfBlogPostInput.List.items:type_name -> productv1.BlogPostInput - 157, // 216: productv1.ListOfCategory.List.items:type_name -> productv1.Category - 186, // 217: productv1.ListOfCategoryInput.List.items:type_name -> productv1.CategoryInput - 8, // 218: productv1.ListOfListOfCategory.List.items:type_name -> productv1.ListOfCategory - 9, // 219: productv1.ListOfListOfCategoryInput.List.items:type_name -> productv1.ListOfCategoryInput - 18, // 220: productv1.ListOfListOfString.List.items:type_name -> productv1.ListOfString - 20, // 221: productv1.ListOfListOfUser.List.items:type_name -> productv1.ListOfUser - 21, // 222: productv1.ListOfListOfUserInput.List.items:type_name -> productv1.ListOfUserInput - 179, // 223: productv1.ListOfOrderLine.List.items:type_name -> productv1.OrderLine - 145, // 224: productv1.ListOfProduct.List.items:type_name -> productv1.Product - 180, // 225: productv1.ListOfSubcategory.List.items:type_name -> productv1.Subcategory - 148, // 226: productv1.ListOfUser.List.items:type_name -> productv1.User - 168, // 227: productv1.ListOfUserInput.List.items:type_name -> productv1.UserInput - 23, // 228: productv1.ProductService.LookupProductById:input_type -> productv1.LookupProductByIdRequest - 26, // 229: productv1.ProductService.LookupStorageById:input_type -> productv1.LookupStorageByIdRequest - 29, // 230: productv1.ProductService.LookupWarehouseById:input_type -> productv1.LookupWarehouseByIdRequest - 107, // 231: productv1.ProductService.MutationBulkCreateAuthors:input_type -> productv1.MutationBulkCreateAuthorsRequest - 111, // 232: productv1.ProductService.MutationBulkCreateBlogPosts:input_type -> productv1.MutationBulkCreateBlogPostsRequest - 109, // 233: productv1.ProductService.MutationBulkUpdateAuthors:input_type -> productv1.MutationBulkUpdateAuthorsRequest - 113, // 234: productv1.ProductService.MutationBulkUpdateBlogPosts:input_type -> productv1.MutationBulkUpdateBlogPostsRequest - 103, // 235: productv1.ProductService.MutationCreateAuthor:input_type -> productv1.MutationCreateAuthorRequest - 99, // 236: productv1.ProductService.MutationCreateBlogPost:input_type -> productv1.MutationCreateBlogPostRequest - 95, // 237: productv1.ProductService.MutationCreateNullableFieldsType:input_type -> productv1.MutationCreateNullableFieldsTypeRequest - 91, // 238: productv1.ProductService.MutationCreateUser:input_type -> productv1.MutationCreateUserRequest - 93, // 239: productv1.ProductService.MutationPerformAction:input_type -> productv1.MutationPerformActionRequest - 105, // 240: productv1.ProductService.MutationUpdateAuthor:input_type -> productv1.MutationUpdateAuthorRequest - 101, // 241: productv1.ProductService.MutationUpdateBlogPost:input_type -> productv1.MutationUpdateBlogPostRequest - 97, // 242: productv1.ProductService.MutationUpdateNullableFieldsType:input_type -> productv1.MutationUpdateNullableFieldsTypeRequest - 85, // 243: productv1.ProductService.QueryAllAuthors:input_type -> productv1.QueryAllAuthorsRequest - 77, // 244: productv1.ProductService.QueryAllBlogPosts:input_type -> productv1.QueryAllBlogPostsRequest - 69, // 245: productv1.ProductService.QueryAllNullableFieldsTypes:input_type -> productv1.QueryAllNullableFieldsTypesRequest - 57, // 246: productv1.ProductService.QueryAllPets:input_type -> productv1.QueryAllPetsRequest - 79, // 247: productv1.ProductService.QueryAuthor:input_type -> productv1.QueryAuthorRequest - 81, // 248: productv1.ProductService.QueryAuthorById:input_type -> productv1.QueryAuthorByIdRequest - 83, // 249: productv1.ProductService.QueryAuthorsWithFilter:input_type -> productv1.QueryAuthorsWithFilterRequest - 71, // 250: productv1.ProductService.QueryBlogPost:input_type -> productv1.QueryBlogPostRequest - 73, // 251: productv1.ProductService.QueryBlogPostById:input_type -> productv1.QueryBlogPostByIdRequest - 75, // 252: productv1.ProductService.QueryBlogPostsWithFilter:input_type -> productv1.QueryBlogPostsWithFilterRequest - 87, // 253: productv1.ProductService.QueryBulkSearchAuthors:input_type -> productv1.QueryBulkSearchAuthorsRequest - 89, // 254: productv1.ProductService.QueryBulkSearchBlogPosts:input_type -> productv1.QueryBulkSearchBlogPostsRequest - 45, // 255: productv1.ProductService.QueryCalculateTotals:input_type -> productv1.QueryCalculateTotalsRequest - 47, // 256: productv1.ProductService.QueryCategories:input_type -> productv1.QueryCategoriesRequest - 49, // 257: productv1.ProductService.QueryCategoriesByKind:input_type -> productv1.QueryCategoriesByKindRequest - 51, // 258: productv1.ProductService.QueryCategoriesByKinds:input_type -> productv1.QueryCategoriesByKindsRequest - 43, // 259: productv1.ProductService.QueryComplexFilterType:input_type -> productv1.QueryComplexFilterTypeRequest - 53, // 260: productv1.ProductService.QueryFilterCategories:input_type -> productv1.QueryFilterCategoriesRequest - 35, // 261: productv1.ProductService.QueryNestedType:input_type -> productv1.QueryNestedTypeRequest - 63, // 262: productv1.ProductService.QueryNullableFieldsType:input_type -> productv1.QueryNullableFieldsTypeRequest - 65, // 263: productv1.ProductService.QueryNullableFieldsTypeById:input_type -> productv1.QueryNullableFieldsTypeByIdRequest - 67, // 264: productv1.ProductService.QueryNullableFieldsTypeWithFilter:input_type -> productv1.QueryNullableFieldsTypeWithFilterRequest - 55, // 265: productv1.ProductService.QueryRandomPet:input_type -> productv1.QueryRandomPetRequest - 61, // 266: productv1.ProductService.QueryRandomSearchResult:input_type -> productv1.QueryRandomSearchResultRequest - 37, // 267: productv1.ProductService.QueryRecursiveType:input_type -> productv1.QueryRecursiveTypeRequest - 59, // 268: productv1.ProductService.QuerySearch:input_type -> productv1.QuerySearchRequest - 39, // 269: productv1.ProductService.QueryTypeFilterWithArguments:input_type -> productv1.QueryTypeFilterWithArgumentsRequest - 41, // 270: productv1.ProductService.QueryTypeWithMultipleFilterFields:input_type -> productv1.QueryTypeWithMultipleFilterFieldsRequest - 33, // 271: productv1.ProductService.QueryUser:input_type -> productv1.QueryUserRequest - 31, // 272: productv1.ProductService.QueryUsers:input_type -> productv1.QueryUsersRequest - 137, // 273: productv1.ProductService.ResolveCategoryCategoryMetrics:input_type -> productv1.ResolveCategoryCategoryMetricsRequest - 132, // 274: productv1.ProductService.ResolveCategoryPopularityScore:input_type -> productv1.ResolveCategoryPopularityScoreRequest - 127, // 275: productv1.ProductService.ResolveCategoryProductCount:input_type -> productv1.ResolveCategoryProductCountRequest - 122, // 276: productv1.ProductService.ResolveProductRecommendedCategory:input_type -> productv1.ResolveProductRecommendedCategoryRequest - 117, // 277: productv1.ProductService.ResolveProductShippingEstimate:input_type -> productv1.ResolveProductShippingEstimateRequest - 142, // 278: productv1.ProductService.ResolveSubcategoryItemCount:input_type -> productv1.ResolveSubcategoryItemCountRequest - 24, // 279: productv1.ProductService.LookupProductById:output_type -> productv1.LookupProductByIdResponse - 27, // 280: productv1.ProductService.LookupStorageById:output_type -> productv1.LookupStorageByIdResponse - 30, // 281: productv1.ProductService.LookupWarehouseById:output_type -> productv1.LookupWarehouseByIdResponse - 108, // 282: productv1.ProductService.MutationBulkCreateAuthors:output_type -> productv1.MutationBulkCreateAuthorsResponse - 112, // 283: productv1.ProductService.MutationBulkCreateBlogPosts:output_type -> productv1.MutationBulkCreateBlogPostsResponse - 110, // 284: productv1.ProductService.MutationBulkUpdateAuthors:output_type -> productv1.MutationBulkUpdateAuthorsResponse - 114, // 285: productv1.ProductService.MutationBulkUpdateBlogPosts:output_type -> productv1.MutationBulkUpdateBlogPostsResponse - 104, // 286: productv1.ProductService.MutationCreateAuthor:output_type -> productv1.MutationCreateAuthorResponse - 100, // 287: productv1.ProductService.MutationCreateBlogPost:output_type -> productv1.MutationCreateBlogPostResponse - 96, // 288: productv1.ProductService.MutationCreateNullableFieldsType:output_type -> productv1.MutationCreateNullableFieldsTypeResponse - 92, // 289: productv1.ProductService.MutationCreateUser:output_type -> productv1.MutationCreateUserResponse - 94, // 290: productv1.ProductService.MutationPerformAction:output_type -> productv1.MutationPerformActionResponse - 106, // 291: productv1.ProductService.MutationUpdateAuthor:output_type -> productv1.MutationUpdateAuthorResponse - 102, // 292: productv1.ProductService.MutationUpdateBlogPost:output_type -> productv1.MutationUpdateBlogPostResponse - 98, // 293: productv1.ProductService.MutationUpdateNullableFieldsType:output_type -> productv1.MutationUpdateNullableFieldsTypeResponse - 86, // 294: productv1.ProductService.QueryAllAuthors:output_type -> productv1.QueryAllAuthorsResponse - 78, // 295: productv1.ProductService.QueryAllBlogPosts:output_type -> productv1.QueryAllBlogPostsResponse - 70, // 296: productv1.ProductService.QueryAllNullableFieldsTypes:output_type -> productv1.QueryAllNullableFieldsTypesResponse - 58, // 297: productv1.ProductService.QueryAllPets:output_type -> productv1.QueryAllPetsResponse - 80, // 298: productv1.ProductService.QueryAuthor:output_type -> productv1.QueryAuthorResponse - 82, // 299: productv1.ProductService.QueryAuthorById:output_type -> productv1.QueryAuthorByIdResponse - 84, // 300: productv1.ProductService.QueryAuthorsWithFilter:output_type -> productv1.QueryAuthorsWithFilterResponse - 72, // 301: productv1.ProductService.QueryBlogPost:output_type -> productv1.QueryBlogPostResponse - 74, // 302: productv1.ProductService.QueryBlogPostById:output_type -> productv1.QueryBlogPostByIdResponse - 76, // 303: productv1.ProductService.QueryBlogPostsWithFilter:output_type -> productv1.QueryBlogPostsWithFilterResponse - 88, // 304: productv1.ProductService.QueryBulkSearchAuthors:output_type -> productv1.QueryBulkSearchAuthorsResponse - 90, // 305: productv1.ProductService.QueryBulkSearchBlogPosts:output_type -> productv1.QueryBulkSearchBlogPostsResponse - 46, // 306: productv1.ProductService.QueryCalculateTotals:output_type -> productv1.QueryCalculateTotalsResponse - 48, // 307: productv1.ProductService.QueryCategories:output_type -> productv1.QueryCategoriesResponse - 50, // 308: productv1.ProductService.QueryCategoriesByKind:output_type -> productv1.QueryCategoriesByKindResponse - 52, // 309: productv1.ProductService.QueryCategoriesByKinds:output_type -> productv1.QueryCategoriesByKindsResponse - 44, // 310: productv1.ProductService.QueryComplexFilterType:output_type -> productv1.QueryComplexFilterTypeResponse - 54, // 311: productv1.ProductService.QueryFilterCategories:output_type -> productv1.QueryFilterCategoriesResponse - 36, // 312: productv1.ProductService.QueryNestedType:output_type -> productv1.QueryNestedTypeResponse - 64, // 313: productv1.ProductService.QueryNullableFieldsType:output_type -> productv1.QueryNullableFieldsTypeResponse - 66, // 314: productv1.ProductService.QueryNullableFieldsTypeById:output_type -> productv1.QueryNullableFieldsTypeByIdResponse - 68, // 315: productv1.ProductService.QueryNullableFieldsTypeWithFilter:output_type -> productv1.QueryNullableFieldsTypeWithFilterResponse - 56, // 316: productv1.ProductService.QueryRandomPet:output_type -> productv1.QueryRandomPetResponse - 62, // 317: productv1.ProductService.QueryRandomSearchResult:output_type -> productv1.QueryRandomSearchResultResponse - 38, // 318: productv1.ProductService.QueryRecursiveType:output_type -> productv1.QueryRecursiveTypeResponse - 60, // 319: productv1.ProductService.QuerySearch:output_type -> productv1.QuerySearchResponse - 40, // 320: productv1.ProductService.QueryTypeFilterWithArguments:output_type -> productv1.QueryTypeFilterWithArgumentsResponse - 42, // 321: productv1.ProductService.QueryTypeWithMultipleFilterFields:output_type -> productv1.QueryTypeWithMultipleFilterFieldsResponse - 34, // 322: productv1.ProductService.QueryUser:output_type -> productv1.QueryUserResponse - 32, // 323: productv1.ProductService.QueryUsers:output_type -> productv1.QueryUsersResponse - 139, // 324: productv1.ProductService.ResolveCategoryCategoryMetrics:output_type -> productv1.ResolveCategoryCategoryMetricsResponse - 134, // 325: productv1.ProductService.ResolveCategoryPopularityScore:output_type -> productv1.ResolveCategoryPopularityScoreResponse - 129, // 326: productv1.ProductService.ResolveCategoryProductCount:output_type -> productv1.ResolveCategoryProductCountResponse - 124, // 327: productv1.ProductService.ResolveProductRecommendedCategory:output_type -> productv1.ResolveProductRecommendedCategoryResponse - 119, // 328: productv1.ProductService.ResolveProductShippingEstimate:output_type -> productv1.ResolveProductShippingEstimateResponse - 144, // 329: productv1.ProductService.ResolveSubcategoryItemCount:output_type -> productv1.ResolveSubcategoryItemCountResponse - 279, // [279:330] is the sub-list for method output_type - 228, // [228:279] is the sub-list for method input_type - 228, // [228:228] is the sub-list for extension type_name - 228, // [228:228] is the sub-list for extension extendee - 0, // [0:228] is the sub-list for field type_name + 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 + 3, // 86: productv1.MutationBulkCreateAuthorsRequest.authors:type_name -> productv1.ListOfAuthorInput + 205, // 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 + 6, // 90: productv1.MutationBulkCreateBlogPostsRequest.blog_posts:type_name -> productv1.ListOfBlogPostInput + 203, // 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 + 231, // 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 + 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 + 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 + 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 + 142, // 113: productv1.ResolveProductProductDetailsResponse.result:type_name -> productv1.ResolveProductProductDetailsResult + 229, // 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 + 252, // 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 + 252, // 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 + 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 + 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 + 167, // 135: productv1.ResolveCategoryCategoryStatusResponse.result:type_name -> productv1.ResolveCategoryCategoryStatusResult + 230, // 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 + 227, // 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 + 252, // 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 + 253, // 162: productv1.NullableFieldsType.optional_string:type_name -> google.protobuf.StringValue + 252, // 163: productv1.NullableFieldsType.optional_int:type_name -> google.protobuf.Int32Value + 254, // 164: productv1.NullableFieldsType.optional_float:type_name -> google.protobuf.DoubleValue + 255, // 165: productv1.NullableFieldsType.optional_boolean:type_name -> google.protobuf.BoolValue + 253, // 166: productv1.NullableFieldsFilter.name:type_name -> google.protobuf.StringValue + 253, // 167: productv1.NullableFieldsFilter.optional_string:type_name -> google.protobuf.StringValue + 255, // 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 + 253, // 183: productv1.BlogPostFilter.title:type_name -> google.protobuf.StringValue + 255, // 184: productv1.BlogPostFilter.has_categories:type_name -> google.protobuf.BoolValue + 252, // 185: productv1.BlogPostFilter.min_tags:type_name -> google.protobuf.Int32Value + 253, // 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 + 253, // 197: productv1.AuthorFilter.name:type_name -> google.protobuf.StringValue + 255, // 198: productv1.AuthorFilter.has_teams:type_name -> google.protobuf.BoolValue + 252, // 199: productv1.AuthorFilter.skill_count:type_name -> google.protobuf.Int32Value + 253, // 200: productv1.TestContainer.description:type_name -> google.protobuf.StringValue + 225, // 201: productv1.ActionResult.action_success:type_name -> productv1.ActionSuccess + 226, // 202: productv1.ActionResult.action_error:type_name -> productv1.ActionError + 253, // 203: productv1.NullableFieldsInput.optional_string:type_name -> google.protobuf.StringValue + 252, // 204: productv1.NullableFieldsInput.optional_int:type_name -> google.protobuf.Int32Value + 254, // 205: productv1.NullableFieldsInput.optional_float:type_name -> google.protobuf.DoubleValue + 255, // 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 + 253, // 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 + 228, // 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 + 253, // 231: productv1.Subcategory.description:type_name -> google.protobuf.StringValue + 196, // 232: productv1.CategoryMetrics.related_category:type_name -> productv1.Category + 198, // 233: productv1.TestDetails.pet:type_name -> productv1.Animal + 210, // 234: productv1.TestDetails.status:type_name -> productv1.ActionResult + 0, // 235: productv1.CategoryInput.kind:type_name -> productv1.CategoryKind + 254, // 236: productv1.ProductCountFilter.min_price:type_name -> google.protobuf.DoubleValue + 254, // 237: productv1.ProductCountFilter.max_price:type_name -> google.protobuf.DoubleValue + 255, // 238: productv1.ProductCountFilter.in_stock:type_name -> google.protobuf.BoolValue + 253, // 239: productv1.ProductCountFilter.search_term:type_name -> google.protobuf.StringValue + 254, // 240: productv1.SubcategoryItemFilter.min_price:type_name -> google.protobuf.DoubleValue + 254, // 241: productv1.SubcategoryItemFilter.max_price:type_name -> google.protobuf.DoubleValue + 255, // 242: productv1.SubcategoryItemFilter.in_stock:type_name -> google.protobuf.BoolValue + 255, // 243: productv1.SubcategoryItemFilter.is_active:type_name -> google.protobuf.BoolValue + 253, // 244: productv1.SubcategoryItemFilter.search_term:type_name -> google.protobuf.StringValue + 1, // 245: productv1.ShippingEstimateInput.destination:type_name -> productv1.ShippingDestination + 255, // 246: productv1.ShippingEstimateInput.expedited:type_name -> google.protobuf.BoolValue + 206, // 247: productv1.ListOfAuthorFilter.List.items:type_name -> productv1.AuthorFilter + 213, // 248: productv1.ListOfAuthorInput.List.items:type_name -> productv1.AuthorInput + 203, // 249: productv1.ListOfBlogPost.List.items:type_name -> productv1.BlogPost + 204, // 250: productv1.ListOfBlogPostFilter.List.items:type_name -> productv1.BlogPostFilter + 212, // 251: productv1.ListOfBlogPostInput.List.items:type_name -> productv1.BlogPostInput + 196, // 252: productv1.ListOfCategory.List.items:type_name -> productv1.Category + 228, // 253: productv1.ListOfCategoryInput.List.items:type_name -> productv1.CategoryInput + 8, // 254: productv1.ListOfListOfCategory.List.items:type_name -> productv1.ListOfCategory + 9, // 255: productv1.ListOfListOfCategoryInput.List.items:type_name -> productv1.ListOfCategoryInput + 18, // 256: productv1.ListOfListOfString.List.items:type_name -> productv1.ListOfString + 20, // 257: productv1.ListOfListOfUser.List.items:type_name -> productv1.ListOfUser + 21, // 258: productv1.ListOfListOfUserInput.List.items:type_name -> productv1.ListOfUserInput + 220, // 259: productv1.ListOfOrderLine.List.items:type_name -> productv1.OrderLine + 184, // 260: productv1.ListOfProduct.List.items:type_name -> productv1.Product + 221, // 261: productv1.ListOfSubcategory.List.items:type_name -> productv1.Subcategory + 187, // 262: productv1.ListOfUser.List.items:type_name -> productv1.User + 208, // 263: productv1.ListOfUserInput.List.items:type_name -> productv1.UserInput + 23, // 264: productv1.ProductService.LookupProductById:input_type -> productv1.LookupProductByIdRequest + 26, // 265: productv1.ProductService.LookupStorageById:input_type -> productv1.LookupStorageByIdRequest + 29, // 266: productv1.ProductService.LookupWarehouseById:input_type -> productv1.LookupWarehouseByIdRequest + 111, // 267: productv1.ProductService.MutationBulkCreateAuthors:input_type -> productv1.MutationBulkCreateAuthorsRequest + 115, // 268: productv1.ProductService.MutationBulkCreateBlogPosts:input_type -> productv1.MutationBulkCreateBlogPostsRequest + 113, // 269: productv1.ProductService.MutationBulkUpdateAuthors:input_type -> productv1.MutationBulkUpdateAuthorsRequest + 117, // 270: productv1.ProductService.MutationBulkUpdateBlogPosts:input_type -> productv1.MutationBulkUpdateBlogPostsRequest + 107, // 271: productv1.ProductService.MutationCreateAuthor:input_type -> productv1.MutationCreateAuthorRequest + 103, // 272: productv1.ProductService.MutationCreateBlogPost:input_type -> productv1.MutationCreateBlogPostRequest + 99, // 273: productv1.ProductService.MutationCreateNullableFieldsType:input_type -> productv1.MutationCreateNullableFieldsTypeRequest + 95, // 274: productv1.ProductService.MutationCreateUser:input_type -> productv1.MutationCreateUserRequest + 97, // 275: productv1.ProductService.MutationPerformAction:input_type -> productv1.MutationPerformActionRequest + 109, // 276: productv1.ProductService.MutationUpdateAuthor:input_type -> productv1.MutationUpdateAuthorRequest + 105, // 277: productv1.ProductService.MutationUpdateBlogPost:input_type -> productv1.MutationUpdateBlogPostRequest + 101, // 278: productv1.ProductService.MutationUpdateNullableFieldsType:input_type -> productv1.MutationUpdateNullableFieldsTypeRequest + 85, // 279: productv1.ProductService.QueryAllAuthors:input_type -> productv1.QueryAllAuthorsRequest + 77, // 280: productv1.ProductService.QueryAllBlogPosts:input_type -> productv1.QueryAllBlogPostsRequest + 69, // 281: productv1.ProductService.QueryAllNullableFieldsTypes:input_type -> productv1.QueryAllNullableFieldsTypesRequest + 57, // 282: productv1.ProductService.QueryAllPets:input_type -> productv1.QueryAllPetsRequest + 79, // 283: productv1.ProductService.QueryAuthor:input_type -> productv1.QueryAuthorRequest + 81, // 284: productv1.ProductService.QueryAuthorById:input_type -> productv1.QueryAuthorByIdRequest + 83, // 285: productv1.ProductService.QueryAuthorsWithFilter:input_type -> productv1.QueryAuthorsWithFilterRequest + 71, // 286: productv1.ProductService.QueryBlogPost:input_type -> productv1.QueryBlogPostRequest + 73, // 287: productv1.ProductService.QueryBlogPostById:input_type -> productv1.QueryBlogPostByIdRequest + 75, // 288: productv1.ProductService.QueryBlogPostsWithFilter:input_type -> productv1.QueryBlogPostsWithFilterRequest + 87, // 289: productv1.ProductService.QueryBulkSearchAuthors:input_type -> productv1.QueryBulkSearchAuthorsRequest + 89, // 290: productv1.ProductService.QueryBulkSearchBlogPosts:input_type -> productv1.QueryBulkSearchBlogPostsRequest + 45, // 291: productv1.ProductService.QueryCalculateTotals:input_type -> productv1.QueryCalculateTotalsRequest + 47, // 292: productv1.ProductService.QueryCategories:input_type -> productv1.QueryCategoriesRequest + 49, // 293: productv1.ProductService.QueryCategoriesByKind:input_type -> productv1.QueryCategoriesByKindRequest + 51, // 294: productv1.ProductService.QueryCategoriesByKinds:input_type -> productv1.QueryCategoriesByKindsRequest + 43, // 295: productv1.ProductService.QueryComplexFilterType:input_type -> productv1.QueryComplexFilterTypeRequest + 53, // 296: productv1.ProductService.QueryFilterCategories:input_type -> productv1.QueryFilterCategoriesRequest + 35, // 297: productv1.ProductService.QueryNestedType:input_type -> productv1.QueryNestedTypeRequest + 63, // 298: productv1.ProductService.QueryNullableFieldsType:input_type -> productv1.QueryNullableFieldsTypeRequest + 65, // 299: productv1.ProductService.QueryNullableFieldsTypeById:input_type -> productv1.QueryNullableFieldsTypeByIdRequest + 67, // 300: productv1.ProductService.QueryNullableFieldsTypeWithFilter:input_type -> productv1.QueryNullableFieldsTypeWithFilterRequest + 55, // 301: productv1.ProductService.QueryRandomPet:input_type -> productv1.QueryRandomPetRequest + 61, // 302: productv1.ProductService.QueryRandomSearchResult:input_type -> productv1.QueryRandomSearchResultRequest + 37, // 303: productv1.ProductService.QueryRecursiveType:input_type -> productv1.QueryRecursiveTypeRequest + 59, // 304: productv1.ProductService.QuerySearch:input_type -> productv1.QuerySearchRequest + 91, // 305: productv1.ProductService.QueryTestContainer:input_type -> productv1.QueryTestContainerRequest + 93, // 306: productv1.ProductService.QueryTestContainers:input_type -> productv1.QueryTestContainersRequest + 39, // 307: productv1.ProductService.QueryTypeFilterWithArguments:input_type -> productv1.QueryTypeFilterWithArgumentsRequest + 41, // 308: productv1.ProductService.QueryTypeWithMultipleFilterFields:input_type -> productv1.QueryTypeWithMultipleFilterFieldsRequest + 33, // 309: productv1.ProductService.QueryUser:input_type -> productv1.QueryUserRequest + 31, // 310: productv1.ProductService.QueryUsers:input_type -> productv1.QueryUsersRequest + 156, // 311: productv1.ProductService.ResolveCategoryCategoryMetrics:input_type -> productv1.ResolveCategoryCategoryMetricsRequest + 166, // 312: productv1.ProductService.ResolveCategoryCategoryStatus:input_type -> productv1.ResolveCategoryCategoryStatusRequest + 161, // 313: productv1.ProductService.ResolveCategoryMascot:input_type -> productv1.ResolveCategoryMascotRequest + 176, // 314: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:input_type -> productv1.ResolveCategoryMetricsNormalizedScoreRequest + 151, // 315: productv1.ProductService.ResolveCategoryPopularityScore:input_type -> productv1.ResolveCategoryPopularityScoreRequest + 146, // 316: productv1.ProductService.ResolveCategoryProductCount:input_type -> productv1.ResolveCategoryProductCountRequest + 131, // 317: productv1.ProductService.ResolveProductMascotRecommendation:input_type -> productv1.ResolveProductMascotRecommendationRequest + 141, // 318: productv1.ProductService.ResolveProductProductDetails:input_type -> productv1.ResolveProductProductDetailsRequest + 126, // 319: productv1.ProductService.ResolveProductRecommendedCategory:input_type -> productv1.ResolveProductRecommendedCategoryRequest + 121, // 320: productv1.ProductService.ResolveProductShippingEstimate:input_type -> productv1.ResolveProductShippingEstimateRequest + 136, // 321: productv1.ProductService.ResolveProductStockStatus:input_type -> productv1.ResolveProductStockStatusRequest + 171, // 322: productv1.ProductService.ResolveSubcategoryItemCount:input_type -> productv1.ResolveSubcategoryItemCountRequest + 181, // 323: productv1.ProductService.ResolveTestContainerDetails:input_type -> productv1.ResolveTestContainerDetailsRequest + 24, // 324: productv1.ProductService.LookupProductById:output_type -> productv1.LookupProductByIdResponse + 27, // 325: productv1.ProductService.LookupStorageById:output_type -> productv1.LookupStorageByIdResponse + 30, // 326: productv1.ProductService.LookupWarehouseById:output_type -> productv1.LookupWarehouseByIdResponse + 112, // 327: productv1.ProductService.MutationBulkCreateAuthors:output_type -> productv1.MutationBulkCreateAuthorsResponse + 116, // 328: productv1.ProductService.MutationBulkCreateBlogPosts:output_type -> productv1.MutationBulkCreateBlogPostsResponse + 114, // 329: productv1.ProductService.MutationBulkUpdateAuthors:output_type -> productv1.MutationBulkUpdateAuthorsResponse + 118, // 330: productv1.ProductService.MutationBulkUpdateBlogPosts:output_type -> productv1.MutationBulkUpdateBlogPostsResponse + 108, // 331: productv1.ProductService.MutationCreateAuthor:output_type -> productv1.MutationCreateAuthorResponse + 104, // 332: productv1.ProductService.MutationCreateBlogPost:output_type -> productv1.MutationCreateBlogPostResponse + 100, // 333: productv1.ProductService.MutationCreateNullableFieldsType:output_type -> productv1.MutationCreateNullableFieldsTypeResponse + 96, // 334: productv1.ProductService.MutationCreateUser:output_type -> productv1.MutationCreateUserResponse + 98, // 335: productv1.ProductService.MutationPerformAction:output_type -> productv1.MutationPerformActionResponse + 110, // 336: productv1.ProductService.MutationUpdateAuthor:output_type -> productv1.MutationUpdateAuthorResponse + 106, // 337: productv1.ProductService.MutationUpdateBlogPost:output_type -> productv1.MutationUpdateBlogPostResponse + 102, // 338: productv1.ProductService.MutationUpdateNullableFieldsType:output_type -> productv1.MutationUpdateNullableFieldsTypeResponse + 86, // 339: productv1.ProductService.QueryAllAuthors:output_type -> productv1.QueryAllAuthorsResponse + 78, // 340: productv1.ProductService.QueryAllBlogPosts:output_type -> productv1.QueryAllBlogPostsResponse + 70, // 341: productv1.ProductService.QueryAllNullableFieldsTypes:output_type -> productv1.QueryAllNullableFieldsTypesResponse + 58, // 342: productv1.ProductService.QueryAllPets:output_type -> productv1.QueryAllPetsResponse + 80, // 343: productv1.ProductService.QueryAuthor:output_type -> productv1.QueryAuthorResponse + 82, // 344: productv1.ProductService.QueryAuthorById:output_type -> productv1.QueryAuthorByIdResponse + 84, // 345: productv1.ProductService.QueryAuthorsWithFilter:output_type -> productv1.QueryAuthorsWithFilterResponse + 72, // 346: productv1.ProductService.QueryBlogPost:output_type -> productv1.QueryBlogPostResponse + 74, // 347: productv1.ProductService.QueryBlogPostById:output_type -> productv1.QueryBlogPostByIdResponse + 76, // 348: productv1.ProductService.QueryBlogPostsWithFilter:output_type -> productv1.QueryBlogPostsWithFilterResponse + 88, // 349: productv1.ProductService.QueryBulkSearchAuthors:output_type -> productv1.QueryBulkSearchAuthorsResponse + 90, // 350: productv1.ProductService.QueryBulkSearchBlogPosts:output_type -> productv1.QueryBulkSearchBlogPostsResponse + 46, // 351: productv1.ProductService.QueryCalculateTotals:output_type -> productv1.QueryCalculateTotalsResponse + 48, // 352: productv1.ProductService.QueryCategories:output_type -> productv1.QueryCategoriesResponse + 50, // 353: productv1.ProductService.QueryCategoriesByKind:output_type -> productv1.QueryCategoriesByKindResponse + 52, // 354: productv1.ProductService.QueryCategoriesByKinds:output_type -> productv1.QueryCategoriesByKindsResponse + 44, // 355: productv1.ProductService.QueryComplexFilterType:output_type -> productv1.QueryComplexFilterTypeResponse + 54, // 356: productv1.ProductService.QueryFilterCategories:output_type -> productv1.QueryFilterCategoriesResponse + 36, // 357: productv1.ProductService.QueryNestedType:output_type -> productv1.QueryNestedTypeResponse + 64, // 358: productv1.ProductService.QueryNullableFieldsType:output_type -> productv1.QueryNullableFieldsTypeResponse + 66, // 359: productv1.ProductService.QueryNullableFieldsTypeById:output_type -> productv1.QueryNullableFieldsTypeByIdResponse + 68, // 360: productv1.ProductService.QueryNullableFieldsTypeWithFilter:output_type -> productv1.QueryNullableFieldsTypeWithFilterResponse + 56, // 361: productv1.ProductService.QueryRandomPet:output_type -> productv1.QueryRandomPetResponse + 62, // 362: productv1.ProductService.QueryRandomSearchResult:output_type -> productv1.QueryRandomSearchResultResponse + 38, // 363: productv1.ProductService.QueryRecursiveType:output_type -> productv1.QueryRecursiveTypeResponse + 60, // 364: productv1.ProductService.QuerySearch:output_type -> productv1.QuerySearchResponse + 92, // 365: productv1.ProductService.QueryTestContainer:output_type -> productv1.QueryTestContainerResponse + 94, // 366: productv1.ProductService.QueryTestContainers:output_type -> productv1.QueryTestContainersResponse + 40, // 367: productv1.ProductService.QueryTypeFilterWithArguments:output_type -> productv1.QueryTypeFilterWithArgumentsResponse + 42, // 368: productv1.ProductService.QueryTypeWithMultipleFilterFields:output_type -> productv1.QueryTypeWithMultipleFilterFieldsResponse + 34, // 369: productv1.ProductService.QueryUser:output_type -> productv1.QueryUserResponse + 32, // 370: productv1.ProductService.QueryUsers:output_type -> productv1.QueryUsersResponse + 158, // 371: productv1.ProductService.ResolveCategoryCategoryMetrics:output_type -> productv1.ResolveCategoryCategoryMetricsResponse + 168, // 372: productv1.ProductService.ResolveCategoryCategoryStatus:output_type -> productv1.ResolveCategoryCategoryStatusResponse + 163, // 373: productv1.ProductService.ResolveCategoryMascot:output_type -> productv1.ResolveCategoryMascotResponse + 178, // 374: productv1.ProductService.ResolveCategoryMetricsNormalizedScore:output_type -> productv1.ResolveCategoryMetricsNormalizedScoreResponse + 153, // 375: productv1.ProductService.ResolveCategoryPopularityScore:output_type -> productv1.ResolveCategoryPopularityScoreResponse + 148, // 376: productv1.ProductService.ResolveCategoryProductCount:output_type -> productv1.ResolveCategoryProductCountResponse + 133, // 377: productv1.ProductService.ResolveProductMascotRecommendation:output_type -> productv1.ResolveProductMascotRecommendationResponse + 143, // 378: productv1.ProductService.ResolveProductProductDetails:output_type -> productv1.ResolveProductProductDetailsResponse + 128, // 379: productv1.ProductService.ResolveProductRecommendedCategory:output_type -> productv1.ResolveProductRecommendedCategoryResponse + 123, // 380: productv1.ProductService.ResolveProductShippingEstimate:output_type -> productv1.ResolveProductShippingEstimateResponse + 138, // 381: productv1.ProductService.ResolveProductStockStatus:output_type -> productv1.ResolveProductStockStatusResponse + 173, // 382: productv1.ProductService.ResolveSubcategoryItemCount:output_type -> productv1.ResolveSubcategoryItemCountResponse + 183, // 383: productv1.ProductService.ResolveTestContainerDetails:output_type -> productv1.ResolveTestContainerDetailsResponse + 324, // [324:384] is the sub-list for method output_type + 264, // [264:324] is the sub-list for method input_type + 264, // [264:264] is the sub-list for extension type_name + 264, // [264:264] is the sub-list for extension extendee + 0, // [0:264] is the sub-list for field type_name } func init() { file_product_proto_init() } @@ -11968,16 +14257,16 @@ func file_product_proto_init() { if File_product_proto != nil { return } - file_product_proto_msgTypes[157].OneofWrappers = []any{ + file_product_proto_msgTypes[196].OneofWrappers = []any{ (*Animal_Cat)(nil), (*Animal_Dog)(nil), } - file_product_proto_msgTypes[159].OneofWrappers = []any{ + file_product_proto_msgTypes[198].OneofWrappers = []any{ (*SearchResult_Product)(nil), (*SearchResult_User)(nil), (*SearchResult_Category)(nil), } - file_product_proto_msgTypes[168].OneofWrappers = []any{ + file_product_proto_msgTypes[208].OneofWrappers = []any{ (*ActionResult_ActionSuccess)(nil), (*ActionResult_ActionError)(nil), } @@ -11987,7 +14276,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: 208, + NumMessages: 250, 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 9f856d858..3439376c1 100644 --- a/v2/pkg/grpctest/productv1/product_grpc.pb.go +++ b/v2/pkg/grpctest/productv1/product_grpc.pb.go @@ -19,57 +19,66 @@ import ( const _ = grpc.SupportPackageIsVersion9 const ( - ProductService_LookupProductById_FullMethodName = "/productv1.ProductService/LookupProductById" - ProductService_LookupStorageById_FullMethodName = "/productv1.ProductService/LookupStorageById" - ProductService_LookupWarehouseById_FullMethodName = "/productv1.ProductService/LookupWarehouseById" - ProductService_MutationBulkCreateAuthors_FullMethodName = "/productv1.ProductService/MutationBulkCreateAuthors" - ProductService_MutationBulkCreateBlogPosts_FullMethodName = "/productv1.ProductService/MutationBulkCreateBlogPosts" - ProductService_MutationBulkUpdateAuthors_FullMethodName = "/productv1.ProductService/MutationBulkUpdateAuthors" - ProductService_MutationBulkUpdateBlogPosts_FullMethodName = "/productv1.ProductService/MutationBulkUpdateBlogPosts" - ProductService_MutationCreateAuthor_FullMethodName = "/productv1.ProductService/MutationCreateAuthor" - ProductService_MutationCreateBlogPost_FullMethodName = "/productv1.ProductService/MutationCreateBlogPost" - ProductService_MutationCreateNullableFieldsType_FullMethodName = "/productv1.ProductService/MutationCreateNullableFieldsType" - ProductService_MutationCreateUser_FullMethodName = "/productv1.ProductService/MutationCreateUser" - ProductService_MutationPerformAction_FullMethodName = "/productv1.ProductService/MutationPerformAction" - ProductService_MutationUpdateAuthor_FullMethodName = "/productv1.ProductService/MutationUpdateAuthor" - ProductService_MutationUpdateBlogPost_FullMethodName = "/productv1.ProductService/MutationUpdateBlogPost" - ProductService_MutationUpdateNullableFieldsType_FullMethodName = "/productv1.ProductService/MutationUpdateNullableFieldsType" - ProductService_QueryAllAuthors_FullMethodName = "/productv1.ProductService/QueryAllAuthors" - ProductService_QueryAllBlogPosts_FullMethodName = "/productv1.ProductService/QueryAllBlogPosts" - ProductService_QueryAllNullableFieldsTypes_FullMethodName = "/productv1.ProductService/QueryAllNullableFieldsTypes" - ProductService_QueryAllPets_FullMethodName = "/productv1.ProductService/QueryAllPets" - ProductService_QueryAuthor_FullMethodName = "/productv1.ProductService/QueryAuthor" - ProductService_QueryAuthorById_FullMethodName = "/productv1.ProductService/QueryAuthorById" - ProductService_QueryAuthorsWithFilter_FullMethodName = "/productv1.ProductService/QueryAuthorsWithFilter" - ProductService_QueryBlogPost_FullMethodName = "/productv1.ProductService/QueryBlogPost" - ProductService_QueryBlogPostById_FullMethodName = "/productv1.ProductService/QueryBlogPostById" - ProductService_QueryBlogPostsWithFilter_FullMethodName = "/productv1.ProductService/QueryBlogPostsWithFilter" - ProductService_QueryBulkSearchAuthors_FullMethodName = "/productv1.ProductService/QueryBulkSearchAuthors" - ProductService_QueryBulkSearchBlogPosts_FullMethodName = "/productv1.ProductService/QueryBulkSearchBlogPosts" - ProductService_QueryCalculateTotals_FullMethodName = "/productv1.ProductService/QueryCalculateTotals" - ProductService_QueryCategories_FullMethodName = "/productv1.ProductService/QueryCategories" - ProductService_QueryCategoriesByKind_FullMethodName = "/productv1.ProductService/QueryCategoriesByKind" - ProductService_QueryCategoriesByKinds_FullMethodName = "/productv1.ProductService/QueryCategoriesByKinds" - ProductService_QueryComplexFilterType_FullMethodName = "/productv1.ProductService/QueryComplexFilterType" - ProductService_QueryFilterCategories_FullMethodName = "/productv1.ProductService/QueryFilterCategories" - ProductService_QueryNestedType_FullMethodName = "/productv1.ProductService/QueryNestedType" - ProductService_QueryNullableFieldsType_FullMethodName = "/productv1.ProductService/QueryNullableFieldsType" - ProductService_QueryNullableFieldsTypeById_FullMethodName = "/productv1.ProductService/QueryNullableFieldsTypeById" - ProductService_QueryNullableFieldsTypeWithFilter_FullMethodName = "/productv1.ProductService/QueryNullableFieldsTypeWithFilter" - ProductService_QueryRandomPet_FullMethodName = "/productv1.ProductService/QueryRandomPet" - ProductService_QueryRandomSearchResult_FullMethodName = "/productv1.ProductService/QueryRandomSearchResult" - ProductService_QueryRecursiveType_FullMethodName = "/productv1.ProductService/QueryRecursiveType" - ProductService_QuerySearch_FullMethodName = "/productv1.ProductService/QuerySearch" - ProductService_QueryTypeFilterWithArguments_FullMethodName = "/productv1.ProductService/QueryTypeFilterWithArguments" - ProductService_QueryTypeWithMultipleFilterFields_FullMethodName = "/productv1.ProductService/QueryTypeWithMultipleFilterFields" - ProductService_QueryUser_FullMethodName = "/productv1.ProductService/QueryUser" - ProductService_QueryUsers_FullMethodName = "/productv1.ProductService/QueryUsers" - ProductService_ResolveCategoryCategoryMetrics_FullMethodName = "/productv1.ProductService/ResolveCategoryCategoryMetrics" - ProductService_ResolveCategoryPopularityScore_FullMethodName = "/productv1.ProductService/ResolveCategoryPopularityScore" - ProductService_ResolveCategoryProductCount_FullMethodName = "/productv1.ProductService/ResolveCategoryProductCount" - ProductService_ResolveProductRecommendedCategory_FullMethodName = "/productv1.ProductService/ResolveProductRecommendedCategory" - ProductService_ResolveProductShippingEstimate_FullMethodName = "/productv1.ProductService/ResolveProductShippingEstimate" - ProductService_ResolveSubcategoryItemCount_FullMethodName = "/productv1.ProductService/ResolveSubcategoryItemCount" + ProductService_LookupProductById_FullMethodName = "/productv1.ProductService/LookupProductById" + ProductService_LookupStorageById_FullMethodName = "/productv1.ProductService/LookupStorageById" + ProductService_LookupWarehouseById_FullMethodName = "/productv1.ProductService/LookupWarehouseById" + ProductService_MutationBulkCreateAuthors_FullMethodName = "/productv1.ProductService/MutationBulkCreateAuthors" + ProductService_MutationBulkCreateBlogPosts_FullMethodName = "/productv1.ProductService/MutationBulkCreateBlogPosts" + ProductService_MutationBulkUpdateAuthors_FullMethodName = "/productv1.ProductService/MutationBulkUpdateAuthors" + ProductService_MutationBulkUpdateBlogPosts_FullMethodName = "/productv1.ProductService/MutationBulkUpdateBlogPosts" + ProductService_MutationCreateAuthor_FullMethodName = "/productv1.ProductService/MutationCreateAuthor" + ProductService_MutationCreateBlogPost_FullMethodName = "/productv1.ProductService/MutationCreateBlogPost" + ProductService_MutationCreateNullableFieldsType_FullMethodName = "/productv1.ProductService/MutationCreateNullableFieldsType" + ProductService_MutationCreateUser_FullMethodName = "/productv1.ProductService/MutationCreateUser" + ProductService_MutationPerformAction_FullMethodName = "/productv1.ProductService/MutationPerformAction" + ProductService_MutationUpdateAuthor_FullMethodName = "/productv1.ProductService/MutationUpdateAuthor" + ProductService_MutationUpdateBlogPost_FullMethodName = "/productv1.ProductService/MutationUpdateBlogPost" + ProductService_MutationUpdateNullableFieldsType_FullMethodName = "/productv1.ProductService/MutationUpdateNullableFieldsType" + ProductService_QueryAllAuthors_FullMethodName = "/productv1.ProductService/QueryAllAuthors" + ProductService_QueryAllBlogPosts_FullMethodName = "/productv1.ProductService/QueryAllBlogPosts" + ProductService_QueryAllNullableFieldsTypes_FullMethodName = "/productv1.ProductService/QueryAllNullableFieldsTypes" + ProductService_QueryAllPets_FullMethodName = "/productv1.ProductService/QueryAllPets" + ProductService_QueryAuthor_FullMethodName = "/productv1.ProductService/QueryAuthor" + ProductService_QueryAuthorById_FullMethodName = "/productv1.ProductService/QueryAuthorById" + ProductService_QueryAuthorsWithFilter_FullMethodName = "/productv1.ProductService/QueryAuthorsWithFilter" + ProductService_QueryBlogPost_FullMethodName = "/productv1.ProductService/QueryBlogPost" + ProductService_QueryBlogPostById_FullMethodName = "/productv1.ProductService/QueryBlogPostById" + ProductService_QueryBlogPostsWithFilter_FullMethodName = "/productv1.ProductService/QueryBlogPostsWithFilter" + ProductService_QueryBulkSearchAuthors_FullMethodName = "/productv1.ProductService/QueryBulkSearchAuthors" + ProductService_QueryBulkSearchBlogPosts_FullMethodName = "/productv1.ProductService/QueryBulkSearchBlogPosts" + ProductService_QueryCalculateTotals_FullMethodName = "/productv1.ProductService/QueryCalculateTotals" + ProductService_QueryCategories_FullMethodName = "/productv1.ProductService/QueryCategories" + ProductService_QueryCategoriesByKind_FullMethodName = "/productv1.ProductService/QueryCategoriesByKind" + ProductService_QueryCategoriesByKinds_FullMethodName = "/productv1.ProductService/QueryCategoriesByKinds" + ProductService_QueryComplexFilterType_FullMethodName = "/productv1.ProductService/QueryComplexFilterType" + ProductService_QueryFilterCategories_FullMethodName = "/productv1.ProductService/QueryFilterCategories" + ProductService_QueryNestedType_FullMethodName = "/productv1.ProductService/QueryNestedType" + ProductService_QueryNullableFieldsType_FullMethodName = "/productv1.ProductService/QueryNullableFieldsType" + ProductService_QueryNullableFieldsTypeById_FullMethodName = "/productv1.ProductService/QueryNullableFieldsTypeById" + ProductService_QueryNullableFieldsTypeWithFilter_FullMethodName = "/productv1.ProductService/QueryNullableFieldsTypeWithFilter" + ProductService_QueryRandomPet_FullMethodName = "/productv1.ProductService/QueryRandomPet" + ProductService_QueryRandomSearchResult_FullMethodName = "/productv1.ProductService/QueryRandomSearchResult" + ProductService_QueryRecursiveType_FullMethodName = "/productv1.ProductService/QueryRecursiveType" + ProductService_QuerySearch_FullMethodName = "/productv1.ProductService/QuerySearch" + ProductService_QueryTestContainer_FullMethodName = "/productv1.ProductService/QueryTestContainer" + ProductService_QueryTestContainers_FullMethodName = "/productv1.ProductService/QueryTestContainers" + ProductService_QueryTypeFilterWithArguments_FullMethodName = "/productv1.ProductService/QueryTypeFilterWithArguments" + ProductService_QueryTypeWithMultipleFilterFields_FullMethodName = "/productv1.ProductService/QueryTypeWithMultipleFilterFields" + ProductService_QueryUser_FullMethodName = "/productv1.ProductService/QueryUser" + ProductService_QueryUsers_FullMethodName = "/productv1.ProductService/QueryUsers" + ProductService_ResolveCategoryCategoryMetrics_FullMethodName = "/productv1.ProductService/ResolveCategoryCategoryMetrics" + ProductService_ResolveCategoryCategoryStatus_FullMethodName = "/productv1.ProductService/ResolveCategoryCategoryStatus" + ProductService_ResolveCategoryMascot_FullMethodName = "/productv1.ProductService/ResolveCategoryMascot" + ProductService_ResolveCategoryMetricsNormalizedScore_FullMethodName = "/productv1.ProductService/ResolveCategoryMetricsNormalizedScore" + ProductService_ResolveCategoryPopularityScore_FullMethodName = "/productv1.ProductService/ResolveCategoryPopularityScore" + ProductService_ResolveCategoryProductCount_FullMethodName = "/productv1.ProductService/ResolveCategoryProductCount" + ProductService_ResolveProductMascotRecommendation_FullMethodName = "/productv1.ProductService/ResolveProductMascotRecommendation" + ProductService_ResolveProductProductDetails_FullMethodName = "/productv1.ProductService/ResolveProductProductDetails" + ProductService_ResolveProductRecommendedCategory_FullMethodName = "/productv1.ProductService/ResolveProductRecommendedCategory" + ProductService_ResolveProductShippingEstimate_FullMethodName = "/productv1.ProductService/ResolveProductShippingEstimate" + ProductService_ResolveProductStockStatus_FullMethodName = "/productv1.ProductService/ResolveProductStockStatus" + ProductService_ResolveSubcategoryItemCount_FullMethodName = "/productv1.ProductService/ResolveSubcategoryItemCount" + ProductService_ResolveTestContainerDetails_FullMethodName = "/productv1.ProductService/ResolveTestContainerDetails" ) // ProductServiceClient is the client API for ProductService service. @@ -122,16 +131,25 @@ type ProductServiceClient interface { QueryRandomSearchResult(ctx context.Context, in *QueryRandomSearchResultRequest, opts ...grpc.CallOption) (*QueryRandomSearchResultResponse, error) QueryRecursiveType(ctx context.Context, in *QueryRecursiveTypeRequest, opts ...grpc.CallOption) (*QueryRecursiveTypeResponse, error) QuerySearch(ctx context.Context, in *QuerySearchRequest, opts ...grpc.CallOption) (*QuerySearchResponse, error) + QueryTestContainer(ctx context.Context, in *QueryTestContainerRequest, opts ...grpc.CallOption) (*QueryTestContainerResponse, error) + QueryTestContainers(ctx context.Context, in *QueryTestContainersRequest, opts ...grpc.CallOption) (*QueryTestContainersResponse, error) QueryTypeFilterWithArguments(ctx context.Context, in *QueryTypeFilterWithArgumentsRequest, opts ...grpc.CallOption) (*QueryTypeFilterWithArgumentsResponse, error) QueryTypeWithMultipleFilterFields(ctx context.Context, in *QueryTypeWithMultipleFilterFieldsRequest, opts ...grpc.CallOption) (*QueryTypeWithMultipleFilterFieldsResponse, error) QueryUser(ctx context.Context, in *QueryUserRequest, opts ...grpc.CallOption) (*QueryUserResponse, error) 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) + ResolveCategoryMascot(ctx context.Context, in *ResolveCategoryMascotRequest, opts ...grpc.CallOption) (*ResolveCategoryMascotResponse, error) + ResolveCategoryMetricsNormalizedScore(ctx context.Context, in *ResolveCategoryMetricsNormalizedScoreRequest, opts ...grpc.CallOption) (*ResolveCategoryMetricsNormalizedScoreResponse, 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) + ResolveProductProductDetails(ctx context.Context, in *ResolveProductProductDetailsRequest, opts ...grpc.CallOption) (*ResolveProductProductDetailsResponse, error) ResolveProductRecommendedCategory(ctx context.Context, in *ResolveProductRecommendedCategoryRequest, opts ...grpc.CallOption) (*ResolveProductRecommendedCategoryResponse, error) ResolveProductShippingEstimate(ctx context.Context, in *ResolveProductShippingEstimateRequest, opts ...grpc.CallOption) (*ResolveProductShippingEstimateResponse, error) + ResolveProductStockStatus(ctx context.Context, in *ResolveProductStockStatusRequest, opts ...grpc.CallOption) (*ResolveProductStockStatusResponse, error) ResolveSubcategoryItemCount(ctx context.Context, in *ResolveSubcategoryItemCountRequest, opts ...grpc.CallOption) (*ResolveSubcategoryItemCountResponse, error) + ResolveTestContainerDetails(ctx context.Context, in *ResolveTestContainerDetailsRequest, opts ...grpc.CallOption) (*ResolveTestContainerDetailsResponse, error) } type productServiceClient struct { @@ -552,6 +570,26 @@ func (c *productServiceClient) QuerySearch(ctx context.Context, in *QuerySearchR return out, nil } +func (c *productServiceClient) QueryTestContainer(ctx context.Context, in *QueryTestContainerRequest, opts ...grpc.CallOption) (*QueryTestContainerResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(QueryTestContainerResponse) + err := c.cc.Invoke(ctx, ProductService_QueryTestContainer_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *productServiceClient) QueryTestContainers(ctx context.Context, in *QueryTestContainersRequest, opts ...grpc.CallOption) (*QueryTestContainersResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(QueryTestContainersResponse) + err := c.cc.Invoke(ctx, ProductService_QueryTestContainers_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) QueryTypeFilterWithArguments(ctx context.Context, in *QueryTypeFilterWithArgumentsRequest, opts ...grpc.CallOption) (*QueryTypeFilterWithArgumentsResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(QueryTypeFilterWithArgumentsResponse) @@ -602,6 +640,36 @@ func (c *productServiceClient) ResolveCategoryCategoryMetrics(ctx context.Contex return out, nil } +func (c *productServiceClient) ResolveCategoryCategoryStatus(ctx context.Context, in *ResolveCategoryCategoryStatusRequest, opts ...grpc.CallOption) (*ResolveCategoryCategoryStatusResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ResolveCategoryCategoryStatusResponse) + err := c.cc.Invoke(ctx, ProductService_ResolveCategoryCategoryStatus_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) + err := c.cc.Invoke(ctx, ProductService_ResolveCategoryMascot_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *productServiceClient) ResolveCategoryMetricsNormalizedScore(ctx context.Context, in *ResolveCategoryMetricsNormalizedScoreRequest, opts ...grpc.CallOption) (*ResolveCategoryMetricsNormalizedScoreResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ResolveCategoryMetricsNormalizedScoreResponse) + err := c.cc.Invoke(ctx, ProductService_ResolveCategoryMetricsNormalizedScore_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) @@ -622,6 +690,26 @@ func (c *productServiceClient) ResolveCategoryProductCount(ctx context.Context, return out, nil } +func (c *productServiceClient) ResolveProductMascotRecommendation(ctx context.Context, in *ResolveProductMascotRecommendationRequest, opts ...grpc.CallOption) (*ResolveProductMascotRecommendationResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ResolveProductMascotRecommendationResponse) + err := c.cc.Invoke(ctx, ProductService_ResolveProductMascotRecommendation_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *productServiceClient) ResolveProductProductDetails(ctx context.Context, in *ResolveProductProductDetailsRequest, opts ...grpc.CallOption) (*ResolveProductProductDetailsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ResolveProductProductDetailsResponse) + err := c.cc.Invoke(ctx, ProductService_ResolveProductProductDetails_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) ResolveProductRecommendedCategory(ctx context.Context, in *ResolveProductRecommendedCategoryRequest, opts ...grpc.CallOption) (*ResolveProductRecommendedCategoryResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ResolveProductRecommendedCategoryResponse) @@ -642,6 +730,16 @@ func (c *productServiceClient) ResolveProductShippingEstimate(ctx context.Contex return out, nil } +func (c *productServiceClient) ResolveProductStockStatus(ctx context.Context, in *ResolveProductStockStatusRequest, opts ...grpc.CallOption) (*ResolveProductStockStatusResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ResolveProductStockStatusResponse) + err := c.cc.Invoke(ctx, ProductService_ResolveProductStockStatus_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *productServiceClient) ResolveSubcategoryItemCount(ctx context.Context, in *ResolveSubcategoryItemCountRequest, opts ...grpc.CallOption) (*ResolveSubcategoryItemCountResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ResolveSubcategoryItemCountResponse) @@ -652,6 +750,16 @@ func (c *productServiceClient) ResolveSubcategoryItemCount(ctx context.Context, return out, nil } +func (c *productServiceClient) ResolveTestContainerDetails(ctx context.Context, in *ResolveTestContainerDetailsRequest, opts ...grpc.CallOption) (*ResolveTestContainerDetailsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ResolveTestContainerDetailsResponse) + err := c.cc.Invoke(ctx, ProductService_ResolveTestContainerDetails_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + // ProductServiceServer is the server API for ProductService service. // All implementations must embed UnimplementedProductServiceServer // for forward compatibility. @@ -702,16 +810,25 @@ type ProductServiceServer interface { QueryRandomSearchResult(context.Context, *QueryRandomSearchResultRequest) (*QueryRandomSearchResultResponse, error) QueryRecursiveType(context.Context, *QueryRecursiveTypeRequest) (*QueryRecursiveTypeResponse, error) QuerySearch(context.Context, *QuerySearchRequest) (*QuerySearchResponse, error) + QueryTestContainer(context.Context, *QueryTestContainerRequest) (*QueryTestContainerResponse, error) + QueryTestContainers(context.Context, *QueryTestContainersRequest) (*QueryTestContainersResponse, error) QueryTypeFilterWithArguments(context.Context, *QueryTypeFilterWithArgumentsRequest) (*QueryTypeFilterWithArgumentsResponse, error) QueryTypeWithMultipleFilterFields(context.Context, *QueryTypeWithMultipleFilterFieldsRequest) (*QueryTypeWithMultipleFilterFieldsResponse, error) QueryUser(context.Context, *QueryUserRequest) (*QueryUserResponse, error) QueryUsers(context.Context, *QueryUsersRequest) (*QueryUsersResponse, error) ResolveCategoryCategoryMetrics(context.Context, *ResolveCategoryCategoryMetricsRequest) (*ResolveCategoryCategoryMetricsResponse, error) + ResolveCategoryCategoryStatus(context.Context, *ResolveCategoryCategoryStatusRequest) (*ResolveCategoryCategoryStatusResponse, error) + ResolveCategoryMascot(context.Context, *ResolveCategoryMascotRequest) (*ResolveCategoryMascotResponse, error) + ResolveCategoryMetricsNormalizedScore(context.Context, *ResolveCategoryMetricsNormalizedScoreRequest) (*ResolveCategoryMetricsNormalizedScoreResponse, error) ResolveCategoryPopularityScore(context.Context, *ResolveCategoryPopularityScoreRequest) (*ResolveCategoryPopularityScoreResponse, error) ResolveCategoryProductCount(context.Context, *ResolveCategoryProductCountRequest) (*ResolveCategoryProductCountResponse, error) + ResolveProductMascotRecommendation(context.Context, *ResolveProductMascotRecommendationRequest) (*ResolveProductMascotRecommendationResponse, error) + ResolveProductProductDetails(context.Context, *ResolveProductProductDetailsRequest) (*ResolveProductProductDetailsResponse, error) ResolveProductRecommendedCategory(context.Context, *ResolveProductRecommendedCategoryRequest) (*ResolveProductRecommendedCategoryResponse, error) ResolveProductShippingEstimate(context.Context, *ResolveProductShippingEstimateRequest) (*ResolveProductShippingEstimateResponse, error) + ResolveProductStockStatus(context.Context, *ResolveProductStockStatusRequest) (*ResolveProductStockStatusResponse, error) ResolveSubcategoryItemCount(context.Context, *ResolveSubcategoryItemCountRequest) (*ResolveSubcategoryItemCountResponse, error) + ResolveTestContainerDetails(context.Context, *ResolveTestContainerDetailsRequest) (*ResolveTestContainerDetailsResponse, error) mustEmbedUnimplementedProductServiceServer() } @@ -845,6 +962,12 @@ func (UnimplementedProductServiceServer) QueryRecursiveType(context.Context, *Qu func (UnimplementedProductServiceServer) QuerySearch(context.Context, *QuerySearchRequest) (*QuerySearchResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method QuerySearch not implemented") } +func (UnimplementedProductServiceServer) QueryTestContainer(context.Context, *QueryTestContainerRequest) (*QueryTestContainerResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method QueryTestContainer not implemented") +} +func (UnimplementedProductServiceServer) QueryTestContainers(context.Context, *QueryTestContainersRequest) (*QueryTestContainersResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method QueryTestContainers not implemented") +} func (UnimplementedProductServiceServer) QueryTypeFilterWithArguments(context.Context, *QueryTypeFilterWithArgumentsRequest) (*QueryTypeFilterWithArgumentsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method QueryTypeFilterWithArguments not implemented") } @@ -860,21 +983,42 @@ func (UnimplementedProductServiceServer) QueryUsers(context.Context, *QueryUsers func (UnimplementedProductServiceServer) ResolveCategoryCategoryMetrics(context.Context, *ResolveCategoryCategoryMetricsRequest) (*ResolveCategoryCategoryMetricsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ResolveCategoryCategoryMetrics not implemented") } +func (UnimplementedProductServiceServer) ResolveCategoryCategoryStatus(context.Context, *ResolveCategoryCategoryStatusRequest) (*ResolveCategoryCategoryStatusResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ResolveCategoryCategoryStatus not implemented") +} +func (UnimplementedProductServiceServer) ResolveCategoryMascot(context.Context, *ResolveCategoryMascotRequest) (*ResolveCategoryMascotResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ResolveCategoryMascot not implemented") +} +func (UnimplementedProductServiceServer) ResolveCategoryMetricsNormalizedScore(context.Context, *ResolveCategoryMetricsNormalizedScoreRequest) (*ResolveCategoryMetricsNormalizedScoreResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ResolveCategoryMetricsNormalizedScore not implemented") +} func (UnimplementedProductServiceServer) ResolveCategoryPopularityScore(context.Context, *ResolveCategoryPopularityScoreRequest) (*ResolveCategoryPopularityScoreResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ResolveCategoryPopularityScore not implemented") } func (UnimplementedProductServiceServer) ResolveCategoryProductCount(context.Context, *ResolveCategoryProductCountRequest) (*ResolveCategoryProductCountResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ResolveCategoryProductCount not implemented") } +func (UnimplementedProductServiceServer) ResolveProductMascotRecommendation(context.Context, *ResolveProductMascotRecommendationRequest) (*ResolveProductMascotRecommendationResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ResolveProductMascotRecommendation not implemented") +} +func (UnimplementedProductServiceServer) ResolveProductProductDetails(context.Context, *ResolveProductProductDetailsRequest) (*ResolveProductProductDetailsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ResolveProductProductDetails not implemented") +} func (UnimplementedProductServiceServer) ResolveProductRecommendedCategory(context.Context, *ResolveProductRecommendedCategoryRequest) (*ResolveProductRecommendedCategoryResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ResolveProductRecommendedCategory not implemented") } func (UnimplementedProductServiceServer) ResolveProductShippingEstimate(context.Context, *ResolveProductShippingEstimateRequest) (*ResolveProductShippingEstimateResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ResolveProductShippingEstimate not implemented") } +func (UnimplementedProductServiceServer) ResolveProductStockStatus(context.Context, *ResolveProductStockStatusRequest) (*ResolveProductStockStatusResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ResolveProductStockStatus not implemented") +} func (UnimplementedProductServiceServer) ResolveSubcategoryItemCount(context.Context, *ResolveSubcategoryItemCountRequest) (*ResolveSubcategoryItemCountResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ResolveSubcategoryItemCount not implemented") } +func (UnimplementedProductServiceServer) ResolveTestContainerDetails(context.Context, *ResolveTestContainerDetailsRequest) (*ResolveTestContainerDetailsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ResolveTestContainerDetails not implemented") +} func (UnimplementedProductServiceServer) mustEmbedUnimplementedProductServiceServer() {} func (UnimplementedProductServiceServer) testEmbeddedByValue() {} @@ -1634,6 +1778,42 @@ func _ProductService_QuerySearch_Handler(srv interface{}, ctx context.Context, d return interceptor(ctx, in, info, handler) } +func _ProductService_QueryTestContainer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryTestContainerRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).QueryTestContainer(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_QueryTestContainer_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).QueryTestContainer(ctx, req.(*QueryTestContainerRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ProductService_QueryTestContainers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryTestContainersRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).QueryTestContainers(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_QueryTestContainers_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).QueryTestContainers(ctx, req.(*QueryTestContainersRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_QueryTypeFilterWithArguments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryTypeFilterWithArgumentsRequest) if err := dec(in); err != nil { @@ -1724,6 +1904,60 @@ func _ProductService_ResolveCategoryCategoryMetrics_Handler(srv interface{}, ctx return interceptor(ctx, in, info, handler) } +func _ProductService_ResolveCategoryCategoryStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResolveCategoryCategoryStatusRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).ResolveCategoryCategoryStatus(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_ResolveCategoryCategoryStatus_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).ResolveCategoryCategoryStatus(ctx, req.(*ResolveCategoryCategoryStatusRequest)) + } + 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 { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).ResolveCategoryMascot(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_ResolveCategoryMascot_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).ResolveCategoryMascot(ctx, req.(*ResolveCategoryMascotRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ProductService_ResolveCategoryMetricsNormalizedScore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResolveCategoryMetricsNormalizedScoreRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).ResolveCategoryMetricsNormalizedScore(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_ResolveCategoryMetricsNormalizedScore_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).ResolveCategoryMetricsNormalizedScore(ctx, req.(*ResolveCategoryMetricsNormalizedScoreRequest)) + } + 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 { @@ -1760,6 +1994,42 @@ func _ProductService_ResolveCategoryProductCount_Handler(srv interface{}, ctx co return interceptor(ctx, in, info, handler) } +func _ProductService_ResolveProductMascotRecommendation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResolveProductMascotRecommendationRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).ResolveProductMascotRecommendation(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_ResolveProductMascotRecommendation_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).ResolveProductMascotRecommendation(ctx, req.(*ResolveProductMascotRecommendationRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ProductService_ResolveProductProductDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResolveProductProductDetailsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).ResolveProductProductDetails(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_ResolveProductProductDetails_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).ResolveProductProductDetails(ctx, req.(*ResolveProductProductDetailsRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_ResolveProductRecommendedCategory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ResolveProductRecommendedCategoryRequest) if err := dec(in); err != nil { @@ -1796,6 +2066,24 @@ func _ProductService_ResolveProductShippingEstimate_Handler(srv interface{}, ctx return interceptor(ctx, in, info, handler) } +func _ProductService_ResolveProductStockStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResolveProductStockStatusRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).ResolveProductStockStatus(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_ResolveProductStockStatus_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).ResolveProductStockStatus(ctx, req.(*ResolveProductStockStatusRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ProductService_ResolveSubcategoryItemCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ResolveSubcategoryItemCountRequest) if err := dec(in); err != nil { @@ -1814,6 +2102,24 @@ func _ProductService_ResolveSubcategoryItemCount_Handler(srv interface{}, ctx co return interceptor(ctx, in, info, handler) } +func _ProductService_ResolveTestContainerDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResolveTestContainerDetailsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProductServiceServer).ResolveTestContainerDetails(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ProductService_ResolveTestContainerDetails_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProductServiceServer).ResolveTestContainerDetails(ctx, req.(*ResolveTestContainerDetailsRequest)) + } + return interceptor(ctx, in, info, handler) +} + // ProductService_ServiceDesc is the grpc.ServiceDesc for ProductService service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) @@ -1985,6 +2291,14 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "QuerySearch", Handler: _ProductService_QuerySearch_Handler, }, + { + MethodName: "QueryTestContainer", + Handler: _ProductService_QueryTestContainer_Handler, + }, + { + MethodName: "QueryTestContainers", + Handler: _ProductService_QueryTestContainers_Handler, + }, { MethodName: "QueryTypeFilterWithArguments", Handler: _ProductService_QueryTypeFilterWithArguments_Handler, @@ -2005,6 +2319,18 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "ResolveCategoryCategoryMetrics", Handler: _ProductService_ResolveCategoryCategoryMetrics_Handler, }, + { + MethodName: "ResolveCategoryCategoryStatus", + Handler: _ProductService_ResolveCategoryCategoryStatus_Handler, + }, + { + MethodName: "ResolveCategoryMascot", + Handler: _ProductService_ResolveCategoryMascot_Handler, + }, + { + MethodName: "ResolveCategoryMetricsNormalizedScore", + Handler: _ProductService_ResolveCategoryMetricsNormalizedScore_Handler, + }, { MethodName: "ResolveCategoryPopularityScore", Handler: _ProductService_ResolveCategoryPopularityScore_Handler, @@ -2013,6 +2339,14 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "ResolveCategoryProductCount", Handler: _ProductService_ResolveCategoryProductCount_Handler, }, + { + MethodName: "ResolveProductMascotRecommendation", + Handler: _ProductService_ResolveProductMascotRecommendation_Handler, + }, + { + MethodName: "ResolveProductProductDetails", + Handler: _ProductService_ResolveProductProductDetails_Handler, + }, { MethodName: "ResolveProductRecommendedCategory", Handler: _ProductService_ResolveProductRecommendedCategory_Handler, @@ -2021,10 +2355,18 @@ var ProductService_ServiceDesc = grpc.ServiceDesc{ MethodName: "ResolveProductShippingEstimate", Handler: _ProductService_ResolveProductShippingEstimate_Handler, }, + { + MethodName: "ResolveProductStockStatus", + Handler: _ProductService_ResolveProductStockStatus_Handler, + }, { MethodName: "ResolveSubcategoryItemCount", Handler: _ProductService_ResolveSubcategoryItemCount_Handler, }, + { + MethodName: "ResolveTestContainerDetails", + Handler: _ProductService_ResolveTestContainerDetails_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "product.proto", diff --git a/v2/pkg/grpctest/testdata/products.graphqls b/v2/pkg/grpctest/testdata/products.graphqls index d2b6007d5..f054de862 100644 --- a/v2/pkg/grpctest/testdata/products.graphqls +++ b/v2/pkg/grpctest/testdata/products.graphqls @@ -5,6 +5,16 @@ type Product @key(fields: "id") { price: Float! shippingEstimate(input: ShippingEstimateInput!): Float! @connect__fieldResolver(context: "id price") recommendedCategory(maxPrice: Int!): Category @connect__fieldResolver(context: "id name price") + mascotRecommendation(includeDetails: Boolean!): Animal @connect__fieldResolver(context: "id name") + stockStatus(checkAvailability: Boolean!): ActionResult! @connect__fieldResolver(context: "id name price") + productDetails(includeExtended: Boolean!): ProductDetails @connect__fieldResolver(context: "id name price") +} + +type ProductDetails { + id: ID! + description: String! + reviewSummary: ActionResult! + recommendedPet: Animal! } type Storage @key(fields: "id") { @@ -118,6 +128,8 @@ type Category { subcategories: [Subcategory!] popularityScore(threshold: Int): Int @connect__fieldResolver(context: "id") 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") } type Subcategory { @@ -134,6 +146,9 @@ type CategoryMetrics { value: Float! timestamp: String! categoryId: ID! + normalizedScore(baseline: Float!): Float! @connect__fieldResolver(context: "id value metricType") + # This will currently not generate a resolver as it is missing arguments. + relatedCategory: Category @connect__fieldResolver(context: "categoryId") } enum CategoryKind { @@ -181,6 +196,21 @@ type ActionError { code: String! } +# Test container type for testing field resolvers with interface and union returns +type TestContainer { + id: ID! + name: String! + description: String + details(includeExtended: Boolean!): TestDetails @connect__fieldResolver(context: "id name") +} + +type TestDetails { + id: ID! + summary: String! + pet: Animal! + status: ActionResult! +} + # Input types for union operations input SearchInput { query: String! @@ -413,6 +443,10 @@ type Query { # Bulk search operations for blog posts bulkSearchBlogPosts(filters: [BlogPostFilter!]): [BlogPost!]! + + # Test container queries (testing field resolvers with interface and union returns) + testContainer(id: ID!): TestContainer! + testContainers: [TestContainer!]! } input UserInput {