From 4ca89d020afc6117a4cb897b976df2f889b1504f Mon Sep 17 00:00:00 2001 From: Masaaki Goshima Date: Mon, 15 Jan 2024 16:01:22 +0900 Subject: [PATCH] rename MessageResolver to VariableDefinition --- generator/code_generator.go | 444 +++++++++------------- generator/templates/error_handler.go.tmpl | 4 +- generator/templates/eval.go.tmpl | 151 ++++++++ generator/templates/resolver.go.tmpl | 151 -------- generator/templates/server.go.tmpl | 48 +-- generator/templates/validation.go.tmpl | 16 +- internal/testutil/builder.go | 44 +-- internal/testutil/cmpopt.go | 5 +- resolver/format.go | 50 +-- resolver/format_test.go | 2 +- resolver/graph.go | 36 +- resolver/message.go | 61 ++- resolver/message_resolver.go | 20 +- resolver/resolver.go | 6 +- resolver/resolver_test.go | 268 ++++++------- resolver/types.go | 153 ++++---- 16 files changed, 692 insertions(+), 767 deletions(-) create mode 100644 generator/templates/eval.go.tmpl delete mode 100644 generator/templates/resolver.go.tmpl diff --git a/generator/code_generator.go b/generator/code_generator.go index 7e544f85..b0aa6569 100644 --- a/generator/code_generator.go +++ b/generator/code_generator.go @@ -153,47 +153,51 @@ func newTypeDeclares(file *resolver.File, msgs []*resolver.Message) []*Type { } genMsg := &Message{Message: msg} - for _, group := range genMsg.MessageResolvers() { - for _, msgResolver := range group.Resolvers() { - if def := msgResolver.VariableDefinition; def != nil && def.Used { - switch { - case def.Expr.By != nil: - fieldName := util.ToPublicGoVariable(def.Name) - if typ.HasField(fieldName) { - continue - } - typ.Fields = append(typ.Fields, &Field{ - Name: fieldName, - Type: toTypeText(file, def.Expr.Type), - }) - case def.Expr.Call != nil: - fieldName := util.ToPublicGoVariable(def.Name) - if typ.HasField(fieldName) { - continue - } - typ.Fields = append(typ.Fields, &Field{ - Name: fieldName, - Type: toTypeText(file, def.Expr.Type), - }) - case def.Expr.Message != nil: - fieldName := util.ToPublicGoVariable(def.Name) - if typ.HasField(fieldName) { - continue - } - typ.Fields = append(typ.Fields, &Field{ - Name: fieldName, - Type: toTypeText(file, def.Expr.Type), - }) - case def.Expr.Map != nil: - fieldName := util.ToPublicGoVariable(def.Name) - if typ.HasField(fieldName) { - continue - } - typ.Fields = append(typ.Fields, &Field{ - Name: fieldName, - Type: toTypeText(file, def.Expr.Type), - }) + for _, group := range genMsg.VariableDefinitionGroups() { + for _, def := range group.VariableDefinitions() { + if def == nil { + continue + } + if !def.Used { + continue + } + switch { + case def.Expr.By != nil: + fieldName := util.ToPublicGoVariable(def.Name) + if typ.HasField(fieldName) { + continue + } + typ.Fields = append(typ.Fields, &Field{ + Name: fieldName, + Type: toTypeText(file, def.Expr.Type), + }) + case def.Expr.Call != nil: + fieldName := util.ToPublicGoVariable(def.Name) + if typ.HasField(fieldName) { + continue + } + typ.Fields = append(typ.Fields, &Field{ + Name: fieldName, + Type: toTypeText(file, def.Expr.Type), + }) + case def.Expr.Message != nil: + fieldName := util.ToPublicGoVariable(def.Name) + if typ.HasField(fieldName) { + continue + } + typ.Fields = append(typ.Fields, &Field{ + Name: fieldName, + Type: toTypeText(file, def.Expr.Type), + }) + case def.Expr.Map != nil: + fieldName := util.ToPublicGoVariable(def.Name) + if typ.HasField(fieldName) { + continue } + typ.Fields = append(typ.Fields, &Field{ + Name: fieldName, + Type: toTypeText(file, def.Expr.Type), + }) } } } @@ -1088,23 +1092,23 @@ func (m *Message) LogValueReturnType() string { return fullMessageName(m.Message) } -func (m *Message) MessageResolvers() []*MessageResolverGroup { +func (m *Message) VariableDefinitionGroups() []*VariableDefinitionGroup { if m.Rule == nil { return nil } - var groups []*MessageResolverGroup - for _, group := range m.Rule.Resolvers { - groups = append(groups, &MessageResolverGroup{ - Service: m.Service, - Message: m, - MessageResolverGroup: group, + var groups []*VariableDefinitionGroup + for _, group := range m.Rule.VariableDefinitionGroups { + groups = append(groups, &VariableDefinitionGroup{ + Service: m.Service, + Message: m, + VariableDefinitionGroup: group, }) } return groups } func (m *Message) IsDeclVariables() bool { - return m.HasCELValue() || m.Rule != nil && len(m.Rule.Resolvers) != 0 + return m.HasCELValue() || m.Rule != nil && len(m.Rule.VariableDefinitionGroups) != 0 } type DeclVariable struct { @@ -1120,13 +1124,14 @@ func (m *Message) DeclVariables() []*DeclVariable { return nil } valueMap := map[string]*DeclVariable{} - for _, group := range m.Message.MessageResolvers() { - for _, r := range group.Resolvers() { - if varDef := r.VariableDefinition; varDef != nil { - valueMap[varDef.Name] = &DeclVariable{ - Name: varDef.Name, - Type: toTypeText(m.Service.File, varDef.Expr.Type), - } + for _, group := range m.Message.VariableDefinitionGroups() { + for _, def := range group.VariableDefinitions() { + if def == nil { + continue + } + valueMap[def.Name] = &DeclVariable{ + Name: def.Name, + Type: toTypeText(m.Service.File, def.Expr.Type), } } } @@ -1190,16 +1195,16 @@ type OneofField struct { FieldOneofRule *resolver.FieldOneofRule } -func (oneof *OneofField) MessageResolvers() []*MessageResolverGroup { +func (oneof *OneofField) VariableDefinitionGroups() []*VariableDefinitionGroup { if oneof.FieldOneofRule == nil { return nil } - var groups []*MessageResolverGroup - for _, group := range oneof.FieldOneofRule.Resolvers { - groups = append(groups, &MessageResolverGroup{ - Service: oneof.Message.Service, - Message: oneof.Message, - MessageResolverGroup: group, + var groups []*VariableDefinitionGroup + for _, group := range oneof.FieldOneofRule.VariableDefinitionGroups { + groups = append(groups, &VariableDefinitionGroup{ + Service: oneof.Message.Service, + Message: oneof.Message, + VariableDefinitionGroup: group, }) } return groups @@ -1467,13 +1472,12 @@ func (f *CastField) ToOneof() *CastOneof { func (m *Message) CustomResolverArguments() []*Argument { args := []*Argument{} argNameMap := make(map[string]struct{}) - for _, group := range m.MessageResolvers() { - for _, msgResolver := range group.Resolvers() { - varDef := msgResolver.VariableDefinition - if varDef == nil || !varDef.Used { + for _, group := range m.VariableDefinitionGroups() { + for _, def := range group.VariableDefinitions() { + if def == nil || !def.Used { continue } - name := varDef.Name + name := def.Name if _, exists := argNameMap[name]; exists { continue } @@ -1696,157 +1700,130 @@ func (m *Message) oneofValueToReturnField(oneof *resolver.Oneof) *ReturnField { } } -type MessageResolverGroup struct { +type VariableDefinitionGroup struct { Service *resolver.Service Message *Message - resolver.MessageResolverGroup + resolver.VariableDefinitionGroup } -func (g *MessageResolverGroup) IsConcurrent() bool { - return g.Type() == resolver.ConcurrentMessageResolverGroupType +func (g *VariableDefinitionGroup) IsConcurrent() bool { + return g.Type() == resolver.ConcurrentVariableDefinitionGroupType } -func (g *MessageResolverGroup) ExistsStart() bool { - rg, ok := g.MessageResolverGroup.(*resolver.SequentialMessageResolverGroup) +func (g *VariableDefinitionGroup) ExistsStart() bool { + rg, ok := g.VariableDefinitionGroup.(*resolver.SequentialVariableDefinitionGroup) if !ok { return false } return rg.Start != nil } -func (g *MessageResolverGroup) ExistsEnd() bool { - switch rg := g.MessageResolverGroup.(type) { - case *resolver.SequentialMessageResolverGroup: +func (g *VariableDefinitionGroup) ExistsEnd() bool { + switch rg := g.VariableDefinitionGroup.(type) { + case *resolver.SequentialVariableDefinitionGroup: return rg.End != nil - case *resolver.ConcurrentMessageResolverGroup: + case *resolver.ConcurrentVariableDefinitionGroup: return rg.End != nil } return false } -func (g *MessageResolverGroup) Starts() []*MessageResolverGroup { - rg, ok := g.MessageResolverGroup.(*resolver.ConcurrentMessageResolverGroup) +func (g *VariableDefinitionGroup) Starts() []*VariableDefinitionGroup { + rg, ok := g.VariableDefinitionGroup.(*resolver.ConcurrentVariableDefinitionGroup) if !ok { return nil } - var starts []*MessageResolverGroup + var starts []*VariableDefinitionGroup for _, start := range rg.Starts { - starts = append(starts, &MessageResolverGroup{ - Service: g.Service, - Message: g.Message, - MessageResolverGroup: start, + starts = append(starts, &VariableDefinitionGroup{ + Service: g.Service, + Message: g.Message, + VariableDefinitionGroup: start, }) } return starts } -func (g *MessageResolverGroup) Start() *MessageResolverGroup { - rg, ok := g.MessageResolverGroup.(*resolver.SequentialMessageResolverGroup) +func (g *VariableDefinitionGroup) Start() *VariableDefinitionGroup { + rg, ok := g.VariableDefinitionGroup.(*resolver.SequentialVariableDefinitionGroup) if !ok { return nil } - return &MessageResolverGroup{ - Service: g.Service, - Message: g.Message, - MessageResolverGroup: rg.Start, + return &VariableDefinitionGroup{ + Service: g.Service, + Message: g.Message, + VariableDefinitionGroup: rg.Start, } } -func (g *MessageResolverGroup) End() *MessageResolver { - switch rg := g.MessageResolverGroup.(type) { - case *resolver.SequentialMessageResolverGroup: - return &MessageResolver{ - Service: g.Service, - Message: g.Message, - MessageResolver: rg.End, +func (g *VariableDefinitionGroup) End() *VariableDefinition { + switch rg := g.VariableDefinitionGroup.(type) { + case *resolver.SequentialVariableDefinitionGroup: + return &VariableDefinition{ + Service: g.Service, + Message: g.Message, + VariableDefinition: rg.End, } - case *resolver.ConcurrentMessageResolverGroup: - return &MessageResolver{ - Service: g.Service, - Message: g.Message, - MessageResolver: rg.End, + case *resolver.ConcurrentVariableDefinitionGroup: + return &VariableDefinition{ + Service: g.Service, + Message: g.Message, + VariableDefinition: rg.End, } } return nil } -type MessageResolver struct { +type VariableDefinition struct { Service *resolver.Service Message *Message - *resolver.MessageResolver + *resolver.VariableDefinition } -func (r *MessageResolver) Key() string { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - return r.VariableDefinition.Name +func (d *VariableDefinition) Key() string { + return d.VariableDefinition.Name } -func (r *MessageResolver) UseIf() bool { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - return r.VariableDefinition.If != nil +func (d *VariableDefinition) UseIf() bool { + return d.VariableDefinition.If != nil } -func (r *MessageResolver) If() string { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - return r.VariableDefinition.If.Expr +func (d *VariableDefinition) If() string { + return d.VariableDefinition.If.Expr } -func (r *MessageResolver) UseTimeout() bool { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - expr := r.VariableDefinition.Expr +func (d *VariableDefinition) UseTimeout() bool { + expr := d.VariableDefinition.Expr return expr.Call != nil && expr.Call.Timeout != nil } -func (r *MessageResolver) UseRetry() bool { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - expr := r.VariableDefinition.Expr +func (d *VariableDefinition) UseRetry() bool { + expr := d.VariableDefinition.Expr return expr.Call != nil && expr.Call.Retry != nil } -func (r *MessageResolver) Retry() *resolver.RetryPolicy { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - return r.VariableDefinition.Expr.Call.Retry +func (d *VariableDefinition) Retry() *resolver.RetryPolicy { + return d.VariableDefinition.Expr.Call.Retry } -func (r *MessageResolver) MethodFQDN() string { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - expr := r.VariableDefinition.Expr +func (d *VariableDefinition) MethodFQDN() string { + expr := d.VariableDefinition.Expr if expr.Call != nil { return expr.Call.Method.FQDN() } return "" } -func (r *MessageResolver) Timeout() string { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - expr := r.VariableDefinition.Expr +func (d *VariableDefinition) Timeout() string { + expr := d.VariableDefinition.Expr if expr.Call != nil { return fmt.Sprintf("%[1]d/* %[1]s */", *expr.Call.Timeout) } return "" } -func (r *MessageResolver) UseArgs() bool { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - expr := r.VariableDefinition.Expr +func (d *VariableDefinition) UseArgs() bool { + expr := d.VariableDefinition.Expr switch { case expr.By != nil: return false @@ -1856,11 +1833,8 @@ func (r *MessageResolver) UseArgs() bool { return true } -func (r *MessageResolver) Caller() string { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - expr := r.VariableDefinition.Expr +func (d *VariableDefinition) Caller() string { + expr := d.VariableDefinition.Expr switch { case expr.Call != nil: method := expr.Call.Method @@ -1877,49 +1851,37 @@ func (r *MessageResolver) Caller() string { return "" } -func (r *MessageResolver) HasErrorHandler() bool { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - return r.VariableDefinition.Expr.Call != nil +func (d *VariableDefinition) HasErrorHandler() bool { + return d.VariableDefinition.Expr.Call != nil } -func (r *MessageResolver) ServiceName() string { - return r.Service.Name +func (d *VariableDefinition) ServiceName() string { + return d.Service.Name } -func (r *MessageResolver) DependentMethodName() string { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - method := r.VariableDefinition.Expr.Call.Method +func (d *VariableDefinition) DependentMethodName() string { + method := d.VariableDefinition.Expr.Call.Method return fmt.Sprintf("%s_%s", fullServiceName(method.Service), method.Name) } -func (r *MessageResolver) RequestType() string { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - expr := r.VariableDefinition.Expr +func (d *VariableDefinition) RequestType() string { + expr := d.VariableDefinition.Expr switch { case expr.Call != nil: - request := r.VariableDefinition.Expr.Call.Request + request := expr.Call.Request return fmt.Sprintf("%s.%s", request.Type.GoPackage().Name, request.Type.Name, ) case expr.Message != nil: msgName := fullMessageName(expr.Message.Message) - return fmt.Sprintf("%sArgument[*%sDependentClientSet]", msgName, r.Service.Name) + return fmt.Sprintf("%sArgument[*%sDependentClientSet]", msgName, d.Service.Name) } return "" } -func (r *MessageResolver) ReturnType() string { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - expr := r.VariableDefinition.Expr +func (d *VariableDefinition) ReturnType() string { + expr := d.VariableDefinition.Expr switch { case expr.Call != nil: response := expr.Call.Method.Response @@ -1933,73 +1895,52 @@ func (r *MessageResolver) ReturnType() string { return "" } -func (r *MessageResolver) UseResponseVariable() bool { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - return r.VariableDefinition.Used +func (d *VariableDefinition) UseResponseVariable() bool { + return d.VariableDefinition.Used } -func (r *MessageResolver) IsBy() bool { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - return r.VariableDefinition.Expr.By != nil +func (d *VariableDefinition) IsBy() bool { + return d.VariableDefinition.Expr.By != nil } -func (r *MessageResolver) IsMap() bool { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - return r.VariableDefinition.Expr.Map != nil +func (d *VariableDefinition) IsMap() bool { + return d.VariableDefinition.Expr.Map != nil } -func (r *MessageResolver) MapResolver() *MapResolver { +func (d *VariableDefinition) MapResolver() *MapResolver { return &MapResolver{ - File: r.Service.File, - Service: r.Service, - MapExpr: r.VariableDefinition.Expr.Map, + File: d.Service.File, + Service: d.Service, + MapExpr: d.VariableDefinition.Expr.Map, } } -func (r *MessageResolver) IsValidation() bool { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - return r.VariableDefinition.Expr.Validation != nil +func (d *VariableDefinition) IsValidation() bool { + return d.VariableDefinition.Expr.Validation != nil } -func (r *MessageResolver) By() *resolver.CELValue { - return r.VariableDefinition.Expr.By +func (d *VariableDefinition) By() *resolver.CELValue { + return d.VariableDefinition.Expr.By } -func (r *MessageResolver) ZeroValue() string { - return toMakeZeroValue(r.Service.File, r.VariableDefinition.Expr.Type) +func (d *VariableDefinition) ZeroValue() string { + return toMakeZeroValue(d.Service.File, d.VariableDefinition.Expr.Type) } -func (r *MessageResolver) ProtoComment() string { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } +func (d *VariableDefinition) ProtoComment() string { opt := &resolver.ProtoFormatOption{ Prefix: "", IndentSpaceNum: 2, } - return r.VariableDefinition.ProtoFormat(opt) + return d.VariableDefinition.ProtoFormat(opt) } -func (r *MessageResolver) Type() string { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - return toTypeText(r.Service.File, r.VariableDefinition.Expr.Type) +func (d *VariableDefinition) Type() string { + return toTypeText(d.Service.File, d.VariableDefinition.Expr.Type) } -func (r *MessageResolver) CELType() string { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - return toCELNativeType(r.VariableDefinition.Expr.Type) +func (d *VariableDefinition) CELType() string { + return toCELNativeType(d.VariableDefinition.Expr.Type) } type ResponseVariable struct { @@ -2008,19 +1949,15 @@ type ResponseVariable struct { CELType string } -func (r *MessageResolver) ResponseVariable() *ResponseVariable { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - - if !r.VariableDefinition.Used { +func (d *VariableDefinition) ResponseVariable() *ResponseVariable { + if !d.VariableDefinition.Used { return nil } return &ResponseVariable{ - Name: toUserDefinedVariable(r.VariableDefinition.Name), - CELExpr: r.VariableDefinition.Name, - CELType: toCELNativeType(r.VariableDefinition.Expr.Type), + Name: toUserDefinedVariable(d.VariableDefinition.Name), + CELExpr: d.VariableDefinition.Name, + CELType: toCELNativeType(d.VariableDefinition.Expr.Type), } } @@ -2167,16 +2104,16 @@ type ValidationErrorDetail struct { PreconditionFailures []*PreconditionFailure BadRequests []*BadRequest LocalizedMessages []*LocalizedMessage - Resolvers []resolver.MessageResolverGroup + DefinitionGroups []resolver.VariableDefinitionGroup } -func (d *ValidationErrorDetail) MessageResolvers() []*MessageResolverGroup { - var groups []*MessageResolverGroup - for _, group := range d.Resolvers { - groups = append(groups, &MessageResolverGroup{ - Service: d.Service, - Message: d.Message, - MessageResolverGroup: group, +func (d *ValidationErrorDetail) VariableDefinitionGroups() []*VariableDefinitionGroup { + var groups []*VariableDefinitionGroup + for _, group := range d.DefinitionGroups { + groups = append(groups, &VariableDefinitionGroup{ + Service: d.Service, + Message: d.Message, + VariableDefinitionGroup: group, }) } return groups @@ -2206,13 +2143,9 @@ type LocalizedMessage struct { Message string } -func (r *MessageResolver) MessageValidation() *ValidationRule { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - - validationName := r.VariableDefinition.Name - validationError := r.VariableDefinition.Expr.Validation.Error +func (d *VariableDefinition) MessageValidation() *ValidationRule { + validationName := d.Name + validationError := d.Expr.Validation.Error vr := &ValidationRule{ Name: validationName, Error: &ValidationError{ @@ -2221,16 +2154,16 @@ func (r *MessageResolver) MessageValidation() *ValidationRule { Details: make([]*ValidationErrorDetail, 0, len(validationError.Details)), }, } - if r := validationError.If; r != nil { - vr.Error.If = r.Expr + if cond := validationError.If; cond != nil { + vr.Error.If = cond.Expr } for _, detail := range validationError.Details { ved := &ValidationErrorDetail{ - Service: r.Service, - Message: r.Message, - If: detail.If.Expr, - Messages: detail.Messages, - Resolvers: detail.Resolvers, + Service: d.Service, + Message: d.Message, + If: detail.If.Expr, + Messages: detail.Messages, + DefinitionGroups: detail.VariableDefinitionGroups, } for _, failure := range detail.PreconditionFailures { vs := make([]*PreconditionFailureViolation, 0, len(failure.Violations)) @@ -2278,11 +2211,8 @@ type Argument struct { Type string } -func (r *MessageResolver) Arguments() []*Argument { - if r.VariableDefinition == nil { - panic("unspecified variable definition") - } - return arguments(r.Service.File, r.VariableDefinition.Expr) +func (d *VariableDefinition) Arguments() []*Argument { + return arguments(d.Service.File, d.Expr) } func toValue(file *resolver.File, typ *resolver.Type, value *resolver.Value) string { diff --git a/generator/templates/error_handler.go.tmpl b/generator/templates/error_handler.go.tmpl index eec2719b..e55953cf 100644 --- a/generator/templates/error_handler.go.tmpl +++ b/generator/templates/error_handler.go.tmpl @@ -1,6 +1,6 @@ {{- define "errorHandler" }} -{{- if .Resolver.HasErrorHandler }} -if err := s.errorHandler({{ .Ctx }}, {{ .Resolver.ServiceName }}_DependentMethod_{{ .Resolver.DependentMethodName }}, err); err != nil { +{{- if .Definition.HasErrorHandler }} +if err := s.errorHandler({{ .Ctx }}, {{ .Definition.ServiceName }}_DependentMethod_{{ .Definition.DependentMethodName }}, err); err != nil { grpcfed.RecordErrorToSpan({{ .Ctx }}, err) return nil, err } diff --git a/generator/templates/eval.go.tmpl b/generator/templates/eval.go.tmpl new file mode 100644 index 00000000..a1fda846 --- /dev/null +++ b/generator/templates/eval.go.tmpl @@ -0,0 +1,151 @@ +{{- define "evalDef" -}} +{{- if .Definition.IsMap -}} +{{- $mapResolver := .Definition.MapResolver -}} +grpcfed.EvalDefMap({{ .Ctx }}, value, grpcfed.DefMap[{{ .Definition.Type }}, {{ $mapResolver.IteratorSourceType }}, *localValueType]{ + {{- if .Definition.UseIf }} + If: "{{ .Definition.If }}", + {{- end }} + Name: "{{ .Definition.Key }}", + Type: {{ .Definition.CELType }}, + Setter: func(value *localValueType, v {{ .Definition.Type }}) { value.vars.{{ .Definition.Key }} = v }, + IteratorName: "{{ $mapResolver.IteratorName }}", + IteratorType: {{ $mapResolver.IteratorCELType }}, + IteratorSource: {{ $mapResolver.IteratorSource }}, + Iterator: func(ctx context.Context, value *grpcfed.MapIteratorValue) (any, error) { + {{- if $mapResolver.IsBy }} + {{- $by := $mapResolver.MapExpr.Expr.By }} + return grpcfed.EvalCEL(ctx, value, "{{ $by.Expr }}", reflect.TypeOf({{ $mapResolver.IteratorZeroValue }})) + {{- else if $mapResolver.IsMessage }} + {{- $arguments := $mapResolver.Arguments }} + args := &{{ $mapResolver.RequestType }}{ + {{- range $arguments }} + {{- if not .CEL }} + {{ .Name }}: {{ .Value }}, {{ .ProtoComment }} + {{- end }} + {{- end }} + } + {{- range $arguments }} + {{- if .CEL }} + {{ .ProtoComment }} + if err := grpcfed.SetCELValue(ctx, value, "{{ .CEL.Expr }}", func(v {{ .Type }}){ + {{- if ne (len .InlineFields) 0 }} + {{- range .InlineFields }} + args.{{ .Name }} = {{ .Value }} + {{- end }} + {{- else }} + args.{{ .Name }} = {{ .Value }} + {{- end }} + }); err != nil { + return nil, err + } + {{- end }} + {{- end }} + return s.{{ $mapResolver.Caller }}(ctx, args) + {{- end }} + }, +}) +{{- else -}} +grpcfed.EvalDef({{ .Ctx }}, value, grpcfed.Def[{{ .Definition.Type }}, *localValueType]{ + {{- if .Definition.UseIf }} + If: "{{ .Definition.If }}", + {{- end }} + Name: "{{ .Definition.Key }}", + Type: {{ .Definition.CELType }}, + Setter: func(value *localValueType, v {{ .Definition.Type }}) { value.vars.{{ .Definition.Key }} = v }, + {{- if .Definition.IsBy }} + By: "{{ .Definition.By.Expr }}", + {{- else if .Definition.IsValidation }} + Validation: func(ctx context.Context, value *localValueType) error { + {{- template "messageValidation" .Definition.MessageValidation }} + }, + {{- else }} + Message: func(ctx context.Context, value *localValueType) (any, error) { + {{- $arguments := .Definition.Arguments }} + {{- if .Definition.UseArgs }} + args := &{{ .Definition.RequestType }}{ + {{- range $arguments }} + {{- if not .CEL }} + {{ .Name }}: {{ .Value }}, {{ .ProtoComment }} + {{- end }} + {{- end }} + } + {{- end }} + {{- range $arguments }} + {{- if .CEL }} + {{ .ProtoComment }} + if err := grpcfed.SetCELValue(ctx, value, "{{ .CEL.Expr }}", func(v {{ .Type }}){ + {{- if ne (len .InlineFields) 0 }} + {{- range .InlineFields }} + args.{{ .Name }} = {{ .Value }} + {{- end }} + {{- else }} + args.{{ .Name }} = {{ .Value }} + {{- end }} + }); err != nil { + return nil, err + } + {{- end }} + {{- end }} + {{- if .Definition.UseTimeout }} + return grpcfed.WithTimeout[{{ .Definition.ReturnType }}](ctx, "{{ .Definition.MethodFQDN }}", {{ .Definition.Timeout }}, func(ctx context.Context) (*{{ .Definition.ReturnType }}, error) { + {{- if .Definition.UseRetry }} + {{- template "retry" (map "Retry" .Definition.Retry) }} + return grpcfed.WithRetry[{{ .Definition.ReturnType }}](b, func() (*{{ .Definition.ReturnType }}, error) { + return s.{{ .Definition.Caller }}(ctx, args) + }) + {{- else }} + return s.{{ .Definition.Caller }}(ctx, args) + {{- end }} + }) + {{- else if .Definition.UseRetry }} + {{- template "retry" (map "Retry" .Definition.Retry) }} + return grpcfed.WithRetry[{{ .Definition.ReturnType }}](b, func() (*{{ .Definition.ReturnType }}, error) { + return s.{{ .Definition.Caller }}(ctx, args) + }) + {{- else }} + return s.{{ .Definition.Caller }}(ctx, args) + {{- end }} + }, + {{- end }} +}) +{{- end }} +{{- end }} + +{{- define "evalMessageDef" }} +// This section's codes are generated by the following proto definition. +/* +{{ .Definition.ProtoComment }} +*/ +if err := {{- template "evalDef" (map "Ctx" .Ctx "Definition" .Definition) -}}; err != nil { + {{- template "errorHandler" (map "Ctx" .Ctx "Definition" .Definition) }} +} +{{- end }} + +{{- define "evalDefGroup" }} +{{- if .Definition.IsConcurrent }} +eg, {{ printf "ctx%d" .Level }} := errgroup.WithContext({{ parentCtx .Level }}) +{{- range .Definition.Starts }} +grpcfed.GoWithRecover(eg, func() (any, error) { + {{- template "evalDefGroup" (map "Level" (add $.Level 1) "Definition" .) }} + return nil, nil +}) +{{- end }} +if err := eg.Wait(); err != nil { + return nil, err +} +{{- if .Definition.ExistsEnd }} +{{ template "evalMessageDef" (map "Ctx" (parentCtx .Level) "Definition" .Definition.End) }} +{{- end }} + +{{- else }} + +{{- if .Definition.ExistsStart }} +{{ template "evalDefGroup" (map "Level" .Level "Definition" .Definition.Start) }} +{{- end }} + +{{- if .Definition.ExistsEnd }} +{{ template "evalMessageDef" (map "Ctx" (parentCtx .Level) "Definition" .Definition.End) }} +{{- end }} + +{{- end }} +{{- end }} diff --git a/generator/templates/resolver.go.tmpl b/generator/templates/resolver.go.tmpl deleted file mode 100644 index 2a5e3a4c..00000000 --- a/generator/templates/resolver.go.tmpl +++ /dev/null @@ -1,151 +0,0 @@ -{{- define "callResolver" -}} -{{- if .Resolver.IsMap -}} -{{- $mapResolver := .Resolver.MapResolver -}} -grpcfed.EvalDefMap({{ .Ctx }}, value, grpcfed.DefMap[{{ .Resolver.Type }}, {{ $mapResolver.IteratorSourceType }}, *localValueType]{ - {{- if .Resolver.UseIf }} - If: "{{ .Resolver.If }}", - {{- end }} - Name: "{{ .Resolver.Key }}", - Type: {{ .Resolver.CELType }}, - Setter: func(value *localValueType, v {{ .Resolver.Type }}) { value.vars.{{ .Resolver.Key }} = v }, - IteratorName: "{{ $mapResolver.IteratorName }}", - IteratorType: {{ $mapResolver.IteratorCELType }}, - IteratorSource: {{ $mapResolver.IteratorSource }}, - Iterator: func(ctx context.Context, value *grpcfed.MapIteratorValue) (any, error) { - {{- if $mapResolver.IsBy }} - {{- $by := $mapResolver.MapExpr.Expr.By }} - return grpcfed.EvalCEL(ctx, value, "{{ $by.Expr }}", reflect.TypeOf({{ $mapResolver.IteratorZeroValue }})) - {{- else if $mapResolver.IsMessage }} - {{- $arguments := $mapResolver.Arguments }} - args := &{{ $mapResolver.RequestType }}{ - {{- range $arguments }} - {{- if not .CEL }} - {{ .Name }}: {{ .Value }}, {{ .ProtoComment }} - {{- end }} - {{- end }} - } - {{- range $arguments }} - {{- if .CEL }} - {{ .ProtoComment }} - if err := grpcfed.SetCELValue(ctx, value, "{{ .CEL.Expr }}", func(v {{ .Type }}){ - {{- if ne (len .InlineFields) 0 }} - {{- range .InlineFields }} - args.{{ .Name }} = {{ .Value }} - {{- end }} - {{- else }} - args.{{ .Name }} = {{ .Value }} - {{- end }} - }); err != nil { - return nil, err - } - {{- end }} - {{- end }} - return s.{{ $mapResolver.Caller }}(ctx, args) - {{- end }} - }, -}) -{{- else -}} -grpcfed.EvalDef({{ .Ctx }}, value, grpcfed.Def[{{ .Resolver.Type }}, *localValueType]{ - {{- if .Resolver.UseIf }} - If: "{{ .Resolver.If }}", - {{- end }} - Name: "{{ .Resolver.Key }}", - Type: {{ .Resolver.CELType }}, - Setter: func(value *localValueType, v {{ .Resolver.Type }}) { value.vars.{{ .Resolver.Key }} = v }, - {{- if .Resolver.IsBy }} - By: "{{ .Resolver.By.Expr }}", - {{- else if .Resolver.IsValidation }} - Validation: func(ctx context.Context, value *localValueType) error { - {{- template "messageValidation" .Resolver.MessageValidation }} - }, - {{- else }} - Message: func(ctx context.Context, value *localValueType) (any, error) { - {{- $arguments := .Resolver.Arguments }} - {{- if .Resolver.UseArgs }} - args := &{{ .Resolver.RequestType }}{ - {{- range $arguments }} - {{- if not .CEL }} - {{ .Name }}: {{ .Value }}, {{ .ProtoComment }} - {{- end }} - {{- end }} - } - {{- end }} - {{- range $arguments }} - {{- if .CEL }} - {{ .ProtoComment }} - if err := grpcfed.SetCELValue(ctx, value, "{{ .CEL.Expr }}", func(v {{ .Type }}){ - {{- if ne (len .InlineFields) 0 }} - {{- range .InlineFields }} - args.{{ .Name }} = {{ .Value }} - {{- end }} - {{- else }} - args.{{ .Name }} = {{ .Value }} - {{- end }} - }); err != nil { - return nil, err - } - {{- end }} - {{- end }} - {{- if .Resolver.UseTimeout }} - return grpcfed.WithTimeout[{{ .Resolver.ReturnType }}](ctx, "{{ .Resolver.MethodFQDN }}", {{ .Resolver.Timeout }}, func(ctx context.Context) (*{{ .Resolver.ReturnType }}, error) { - {{- if .Resolver.UseRetry }} - {{- template "retry" (map "Retry" .Resolver.Retry) }} - return grpcfed.WithRetry[{{ .Resolver.ReturnType }}](b, func() (*{{ .Resolver.ReturnType }}, error) { - return s.{{ .Resolver.Caller }}(ctx, args) - }) - {{- else }} - return s.{{ .Resolver.Caller }}(ctx, args) - {{- end }} - }) - {{- else if .Resolver.UseRetry }} - {{- template "retry" (map "Retry" .Resolver.Retry) }} - return grpcfed.WithRetry[{{ .Resolver.ReturnType }}](b, func() (*{{ .Resolver.ReturnType }}, error) { - return s.{{ .Resolver.Caller }}(ctx, args) - }) - {{- else }} - return s.{{ .Resolver.Caller }}(ctx, args) - {{- end }} - }, - {{- end }} -}) -{{- end }} -{{- end }} - -{{- define "messageResolver" }} -// This section's codes are generated by the following proto definition. -/* -{{ .Resolver.ProtoComment }} -*/ -if err := {{- template "callResolver" (map "Ctx" .Ctx "Resolver" .Resolver) -}}; err != nil { - {{- template "errorHandler" (map "Ctx" .Ctx "Resolver" .Resolver) }} -} -{{- end }} - -{{- define "resolverGroup" }} -{{- if .Resolver.IsConcurrent }} -eg, {{ printf "ctx%d" .Level }} := errgroup.WithContext({{ parentCtx .Level }}) -{{- range .Resolver.Starts }} -grpcfed.GoWithRecover(eg, func() (any, error) { - {{- template "resolverGroup" (map "Level" (add $.Level 1) "Resolver" .) }} - return nil, nil -}) -{{- end }} -if err := eg.Wait(); err != nil { - return nil, err -} -{{- if .Resolver.ExistsEnd }} -{{ template "messageResolver" (map "Ctx" (parentCtx .Level) "Resolver" .Resolver.End) }} -{{- end }} - -{{- else }} - -{{- if .Resolver.ExistsStart }} -{{ template "resolverGroup" (map "Level" .Level "Resolver" .Resolver.Start) }} -{{- end }} - -{{- if .Resolver.ExistsEnd }} -{{ template "messageResolver" (map "Ctx" (parentCtx .Level) "Resolver" .Resolver.End) }} -{{- end }} - -{{- end }} -{{- end }} diff --git a/generator/templates/server.go.tmpl b/generator/templates/server.go.tmpl index 5136dc0b..15ccbffd 100644 --- a/generator/templates/server.go.tmpl +++ b/generator/templates/server.go.tmpl @@ -285,21 +285,21 @@ func (s *{{ $serviceName }}) {{ .ResolverName }}(ctx context.Context, req *{{ .R /* {{ $depGraph }}*/ {{- end }} - {{- $msgResolvers := .MessageResolvers }} - {{- $msgResolversLen := len $msgResolvers }} - {{- if eq $msgResolversLen 1 }} - {{- template "resolverGroup" (map "Level" 1 "Resolver" (index $msgResolvers 0)) }} + {{- $defGroups := .VariableDefinitionGroups }} + {{- $defGroupsLen := len $defGroups }} + {{- if eq $defGroupsLen 1 }} + {{- template "evalDefGroup" (map "Level" 1 "Definition" (index $defGroups 0)) }} {{- else }} - {{- if $msgResolvers }} + {{- if $defGroups }} eg, ctx1 := errgroup.WithContext(ctx) {{- end }} - {{ range $msgResolvers }} + {{ range $defGroups }} grpcfed.GoWithRecover(eg, func() (any, error) { - {{- template "resolverGroup" (map "Level" 2 "Resolver" .) }} + {{- template "evalDefGroup" (map "Level" 2 "Definition" .) }} return nil, nil }) {{ end }} - {{- if $msgResolvers }} + {{- if $defGroups }} if err := eg.Wait(); err != nil { return nil, err } @@ -366,21 +366,21 @@ func (s *{{ $serviceName }}) {{ .ResolverName }}(ctx context.Context, req *{{ .R switch { {{- range $oneofFields }} case {{ .Condition }}: - {{- $oneofMsgResolvers := .MessageResolvers }} - {{- $oneofMsgResolversLen := len $oneofMsgResolvers }} - {{- if eq $oneofMsgResolversLen 1 }} - {{- template "resolverGroup" (map "Level" 1 "Resolver" (index $oneofMsgResolvers 0)) }} + {{- $oneofDefGroups := .VariableDefinitionGroups }} + {{- $oneofDefGroupsLen := len $oneofDefGroups }} + {{- if eq $oneofDefGroupsLen 1 }} + {{- template "evalDefGroup" (map "Level" 1 "Definition" (index $oneofDefGroups 0)) }} {{- else }} - {{- if $oneofMsgResolvers }} + {{- if $oneofDefGroups }} eg, ctx1 := errgroup.WithContext(ctx) {{- end }} - {{ range $oneofMsgResolvers }} + {{ range $oneofDefGroups }} grpcfed.GoWithRecover(eg, func() (any, error) { - {{- template "resolverGroup" (map "Level" 2 "Resolver" .) }} + {{- template "evalDefGroup" (map "Level" 2 "Definition" .) }} return nil, nil }) {{ end }} - {{- if $oneofMsgResolvers }} + {{- if $oneofDefGroups }} if err := eg.Wait(); err != nil { return nil, err } @@ -399,21 +399,21 @@ func (s *{{ $serviceName }}) {{ .ResolverName }}(ctx context.Context, req *{{ .R {{- end }} {{- if $defaultOneofField }} default: - {{- $oneofMsgResolvers := $defaultOneofField.MessageResolvers }} - {{- $oneofMsgResolversLen := len $oneofMsgResolvers }} - {{- if eq $oneofMsgResolversLen 1 }} - {{- template "resolverGroup" (map "Level" 1 "Resolver" (index $oneofMsgResolvers 0)) }} + {{- $oneofDefGroups := $defaultOneofField.VariableDefinitionGroups }} + {{- $oneofDefGroupsLen := len $oneofDefGroups }} + {{- if eq $oneofDefGroupsLen 1 }} + {{- template "evalDefGroup" (map "Level" 1 "Definition" (index $oneofDefGroups 0)) }} {{- else }} - {{- if $oneofMsgResolvers }} + {{- if $oneofDefGroups }} eg, ctx1 := errgroup.WithContext(ctx) {{- end }} - {{ range $oneofMsgResolvers }} + {{ range $oneofDefGroups }} grpcfed.GoWithRecover(eg, func() (any, error) { - {{- template "resolverGroup" (map "Level" 2 "Resolver" .) }} + {{- template "evalDefGroup" (map "Level" 2 "Definition" .) }} return nil, nil }) {{ end }} - {{- if $oneofMsgResolvers }} + {{- if $oneofDefGroups }} if err := eg.Wait(); err != nil { return nil, err } diff --git a/generator/templates/validation.go.tmpl b/generator/templates/validation.go.tmpl index 8e8d00a3..bd943c0b 100644 --- a/generator/templates/validation.go.tmpl +++ b/generator/templates/validation.go.tmpl @@ -40,24 +40,24 @@ return nil {{- end }} {{- define "detailMessages" }} -{{- $msgResolvers := .MessageResolvers }} -{{- $msgResolversLen := len $msgResolvers }} -{{- if gt $msgResolversLen 0 }} +{{- $defGroups := .VariableDefinitionGroups }} +{{- $defGroupsLen := len $defGroups }} +{{- if gt $defGroupsLen 0 }} func(){ _, err := func() (any, error) { - {{- if eq $msgResolversLen 1 }} - {{- template "resolverGroup" (map "Level" 1 "Resolver" (index $msgResolvers 0)) }} + {{- if eq $defGroupsLen 1 }} + {{- template "evalDefGroup" (map "Level" 1 "Definition" (index $defGroups 0)) }} {{- else }} {{- if . }} eg, ctx1 := errgroup.WithContext(ctx) {{- end }} - {{- range $msgResolvers }} + {{- range $defGroups }} grpcfed.GoWithRecover(eg, func() (any, error) { - {{- template "resolverGroup" (map "Level" 2 "Resolver" .) }} + {{- template "evalDefGroup" (map "Level" 2 "Definition" .) }} return nil, nil }) {{- end }} - {{- if $msgResolvers }} + {{- if $defGroups }} if err := eg.Wait(); err != nil { return nil, err } diff --git a/internal/testutil/builder.go b/internal/testutil/builder.go index a8814b11..fb47b91f 100644 --- a/internal/testutil/builder.go +++ b/internal/testutil/builder.go @@ -581,8 +581,8 @@ func (b *MessageRuleBuilder) SetDependencyGraph(graph *resolver.MessageDependenc return b } -func (b *MessageRuleBuilder) AddResolver(group resolver.MessageResolverGroup) *MessageRuleBuilder { - b.rule.Resolvers = append(b.rule.Resolvers, group) +func (b *MessageRuleBuilder) AddVariableDefinitionGroup(group resolver.VariableDefinitionGroup) *MessageRuleBuilder { + b.rule.VariableDefinitionGroups = append(b.rule.VariableDefinitionGroups, group) return b } @@ -617,6 +617,10 @@ func (b *MessageRuleBuilder) Build(t *testing.T) *resolver.MessageRule { return b.rule } +func NewVariableDefinition(name string) *resolver.VariableDefinition { + return &resolver.VariableDefinition{Name: name} +} + type VariableDefinitionBuilder struct { def *resolver.VariableDefinition } @@ -906,48 +910,44 @@ func (b *ValidationExprBuilder) Build(t *testing.T) *resolver.ValidationExpr { return b.expr } -func NewMessageResolver(name string) *resolver.MessageResolver { - return &resolver.MessageResolver{Name: name} -} - -type MessageResolverGroupBuilder struct { - starts []resolver.MessageResolverGroup - end *resolver.MessageResolver +type VariableDefinitionGroupBuilder struct { + starts []resolver.VariableDefinitionGroup + end *resolver.VariableDefinition } -func NewMessageResolverGroupByName(name string) *resolver.SequentialMessageResolverGroup { - return &resolver.SequentialMessageResolverGroup{ - End: &resolver.MessageResolver{Name: name}, +func NewVariableDefinitionGroupByName(name string) *resolver.SequentialVariableDefinitionGroup { + return &resolver.SequentialVariableDefinitionGroup{ + End: &resolver.VariableDefinition{Name: name}, } } -func NewMessageResolverGroupBuilder() *MessageResolverGroupBuilder { - return &MessageResolverGroupBuilder{} +func NewVariableDefinitionGroupBuilder() *VariableDefinitionGroupBuilder { + return &VariableDefinitionGroupBuilder{} } -func (b *MessageResolverGroupBuilder) AddStart(start resolver.MessageResolverGroup) *MessageResolverGroupBuilder { +func (b *VariableDefinitionGroupBuilder) AddStart(start resolver.VariableDefinitionGroup) *VariableDefinitionGroupBuilder { b.starts = append(b.starts, start) return b } -func (b *MessageResolverGroupBuilder) SetEnd(end *resolver.MessageResolver) *MessageResolverGroupBuilder { +func (b *VariableDefinitionGroupBuilder) SetEnd(end *resolver.VariableDefinition) *VariableDefinitionGroupBuilder { b.end = end return b } -func (b *MessageResolverGroupBuilder) Build(t *testing.T) resolver.MessageResolverGroup { +func (b *VariableDefinitionGroupBuilder) Build(t *testing.T) resolver.VariableDefinitionGroup { t.Helper() if len(b.starts) > 1 { - return &resolver.ConcurrentMessageResolverGroup{ + return &resolver.ConcurrentVariableDefinitionGroup{ Starts: b.starts, End: b.end, } } - var start resolver.MessageResolverGroup + var start resolver.VariableDefinitionGroup if len(b.starts) == 1 { start = b.starts[0] } - return &resolver.SequentialMessageResolverGroup{ + return &resolver.SequentialVariableDefinitionGroup{ Start: start, End: b.end, } @@ -1391,8 +1391,8 @@ func (b *FieldOneofRuleBuilder) SetDependencyGraph(graph *resolver.MessageDepend return b } -func (b *FieldOneofRuleBuilder) AddResolver(group resolver.MessageResolverGroup) *FieldOneofRuleBuilder { - b.rule.Resolvers = append(b.rule.Resolvers, group) +func (b *FieldOneofRuleBuilder) AddVariableDefinitionGroup(group resolver.VariableDefinitionGroup) *FieldOneofRuleBuilder { + b.rule.VariableDefinitionGroups = append(b.rule.VariableDefinitionGroups, group) return b } diff --git a/internal/testutil/cmpopt.go b/internal/testutil/cmpopt.go index 1bc6c338..bdba7689 100644 --- a/internal/testutil/cmpopt.go +++ b/internal/testutil/cmpopt.go @@ -16,13 +16,14 @@ func ResolverCmpOpts() []cmp.Option { cmpopts.IgnoreFields(resolver.Enum{}, "File", "Message.Rule"), cmpopts.IgnoreFields(resolver.EnumValue{}, "Enum"), cmpopts.IgnoreFields(resolver.EnumRule{}, "Alias.Rule"), - cmpopts.IgnoreFields(resolver.MessageResolver{}, "VariableDefinition"), cmpopts.IgnoreFields(resolver.MessageRule{}, "Alias.Rule"), cmpopts.IgnoreFields(resolver.MessageDependencyGraph{}, "MessageRule", "FieldOneofRule", "Roots"), + cmpopts.IgnoreFields(resolver.SequentialVariableDefinitionGroup{}, "End.Idx", "End.Owner", "End.If", "End.AutoBind", "End.Used", "End.Expr"), + cmpopts.IgnoreFields(resolver.ConcurrentVariableDefinitionGroup{}, "End.Idx", "End.Owner", "End.If", "End.AutoBind", "End.Used", "End.Expr"), cmpopts.IgnoreFields(resolver.MessageDependencyGraphNode{}, "BaseMessage", "VariableDefinition", "Parent", "ParentMap", "Children", "ChildrenMap", "Message.Rule"), cmpopts.IgnoreFields(resolver.AllMessageDependencyGraph{}), cmpopts.IgnoreFields(resolver.AllMessageDependencyGraphNode{}, "Parent", "Children", "Message.Rule"), - cmpopts.IgnoreFields(resolver.ValidationErrorDetail{}, "DependencyGraph", "Resolvers"), + cmpopts.IgnoreFields(resolver.ValidationErrorDetail{}, "DependencyGraph", "VariableDefinitionGroups"), cmpopts.IgnoreFields(resolver.AutoBindField{}, "VariableDefinition"), cmpopts.IgnoreFields(resolver.Type{}, "Message.Rule", "Enum.Rule", "OneofField"), cmpopts.IgnoreFields(resolver.Oneof{}, "Message"), diff --git a/resolver/format.go b/resolver/format.go index a886a390..ee0e4b07 100644 --- a/resolver/format.go +++ b/resolver/format.go @@ -601,8 +601,8 @@ func (c *ConstValue) ProtoFormat(opt *ProtoFormatOption) string { return "" } -func DependencyGraphTreeFormat(groups []MessageResolverGroup) string { - ctx := newMessageResolverGroupTreeFormatContext() +func DependencyGraphTreeFormat(groups []VariableDefinitionGroup) string { + ctx := newVariableDefinitionGroupTreeFormatContext() for _, group := range groups { group.setTextMaxLength(ctx.withNextDepth()) } @@ -626,33 +626,33 @@ func DependencyGraphTreeFormat(groups []MessageResolverGroup) string { return ret } -func (g *SequentialMessageResolverGroup) treeFormat(ctx *messageResolverGroupTreeFormatContext) string { +func (g *SequentialVariableDefinitionGroup) treeFormat(ctx *variableDefinitionGroupTreeFormatContext) string { var ( ret string ) if g.Start != nil { - ret += treeFormatByMessageResolverGroup(ctx, g.Start, true) + ret += treeFormatByVariableDefinitionGroup(ctx, g.Start, true) } if g.End != nil { - ret += treeFormatByMessageResolver(ctx, g.End) + ret += treeFormatByVariableDefinition(ctx, g.End) } return ret } -func (g *ConcurrentMessageResolverGroup) treeFormat(ctx *messageResolverGroupTreeFormatContext) string { +func (g *ConcurrentVariableDefinitionGroup) treeFormat(ctx *variableDefinitionGroupTreeFormatContext) string { var ( ret string ) for i := 0; i < len(g.Starts); i++ { - ret += treeFormatByMessageResolverGroup(ctx, g.Starts[i], i == 0) + ret += treeFormatByVariableDefinitionGroup(ctx, g.Starts[i], i == 0) } if g.End != nil { - ret += treeFormatByMessageResolver(ctx, g.End) + ret += treeFormatByVariableDefinition(ctx, g.End) } return ret } -func treeFormatByMessageResolverGroup(ctx *messageResolverGroupTreeFormatContext, g MessageResolverGroup, isFirst bool) string { +func treeFormatByVariableDefinitionGroup(ctx *variableDefinitionGroupTreeFormatContext, g VariableDefinitionGroup, isFirst bool) string { if !isFirst { ctx = ctx.withLineDepth() } @@ -677,13 +677,13 @@ func treeFormatByMessageResolverGroup(ctx *messageResolverGroupTreeFormatContext return text } -func treeFormatByMessageResolver(ctx *messageResolverGroupTreeFormatContext, r *MessageResolver) string { +func treeFormatByVariableDefinition(ctx *variableDefinitionGroupTreeFormatContext, def *VariableDefinition) string { format := fmt.Sprintf("%%%ds", ctx.currentMaxLength()) prefix := strings.Repeat(" ", ctx.currentIndent()) - return prefix + fmt.Sprintf(format, r.Name) + return prefix + fmt.Sprintf(format, def.Name) } -func (g *SequentialMessageResolverGroup) setTextMaxLength(ctx *messageResolverGroupTreeFormatContext) { +func (g *SequentialVariableDefinitionGroup) setTextMaxLength(ctx *variableDefinitionGroupTreeFormatContext) { if g.Start != nil { g.Start.setTextMaxLength(ctx.withNextDepth()) } @@ -696,7 +696,7 @@ func (g *SequentialMessageResolverGroup) setTextMaxLength(ctx *messageResolverGr } } -func (g *ConcurrentMessageResolverGroup) setTextMaxLength(ctx *messageResolverGroupTreeFormatContext) { +func (g *ConcurrentVariableDefinitionGroup) setTextMaxLength(ctx *variableDefinitionGroupTreeFormatContext) { for _, start := range g.Starts { start.setTextMaxLength(ctx.withNextDepth()) } @@ -709,8 +709,8 @@ func (g *ConcurrentMessageResolverGroup) setTextMaxLength(ctx *messageResolverGr } } -func newMessageResolverGroupTreeFormatContext() *messageResolverGroupTreeFormatContext { - return &messageResolverGroupTreeFormatContext{ +func newVariableDefinitionGroupTreeFormatContext() *variableDefinitionGroupTreeFormatContext { + return &variableDefinitionGroupTreeFormatContext{ depthToMaxLength: map[int]int{0: 0}, depthToIndent: make(map[int]int), lineDepth: make(map[int]struct{}), @@ -719,7 +719,7 @@ func newMessageResolverGroupTreeFormatContext() *messageResolverGroupTreeFormatC const lineSpace = 2 -func (c *messageResolverGroupTreeFormatContext) setupIndent() { +func (c *variableDefinitionGroupTreeFormatContext) setupIndent() { maxDepth := c.maxDepth() for depth := range c.depthToMaxLength { diff := maxDepth - depth @@ -727,7 +727,7 @@ func (c *messageResolverGroupTreeFormatContext) setupIndent() { } } -func (c *messageResolverGroupTreeFormatContext) getTotalMaxLength(depth int) int { +func (c *variableDefinitionGroupTreeFormatContext) getTotalMaxLength(depth int) int { length, exists := c.depthToMaxLength[depth] if !exists { return 0 @@ -736,13 +736,13 @@ func (c *messageResolverGroupTreeFormatContext) getTotalMaxLength(depth int) int } // withLineDepth clone context after adding '│' character's depth position. -func (c *messageResolverGroupTreeFormatContext) withLineDepth() *messageResolverGroupTreeFormatContext { +func (c *variableDefinitionGroupTreeFormatContext) withLineDepth() *variableDefinitionGroupTreeFormatContext { lineDepth := make(map[int]struct{}) for depth := range c.lineDepth { lineDepth[depth] = struct{}{} } lineDepth[c.depth] = struct{}{} - return &messageResolverGroupTreeFormatContext{ + return &variableDefinitionGroupTreeFormatContext{ depth: c.depth, depthToMaxLength: c.depthToMaxLength, depthToIndent: c.depthToIndent, @@ -751,8 +751,8 @@ func (c *messageResolverGroupTreeFormatContext) withLineDepth() *messageResolver } // withNextDepth clone context after incrementing the depth. -func (c *messageResolverGroupTreeFormatContext) withNextDepth() *messageResolverGroupTreeFormatContext { - return &messageResolverGroupTreeFormatContext{ +func (c *variableDefinitionGroupTreeFormatContext) withNextDepth() *variableDefinitionGroupTreeFormatContext { + return &variableDefinitionGroupTreeFormatContext{ depth: c.depth + 1, depthToMaxLength: c.depthToMaxLength, depthToIndent: c.depthToIndent, @@ -761,7 +761,7 @@ func (c *messageResolverGroupTreeFormatContext) withNextDepth() *messageResolver } // maxDepth return max depth number for current tree. -func (c *messageResolverGroupTreeFormatContext) maxDepth() int { +func (c *variableDefinitionGroupTreeFormatContext) maxDepth() int { var max int for depth := range c.depthToMaxLength { if max < depth { @@ -772,7 +772,7 @@ func (c *messageResolverGroupTreeFormatContext) maxDepth() int { } // lineIndents returns all '│' character's indent position. -func (c *messageResolverGroupTreeFormatContext) lineIndents() []int { +func (c *variableDefinitionGroupTreeFormatContext) lineIndents() []int { indents := []int{} for depth := range c.lineDepth { indents = append(indents, c.depthToIndent[depth]) @@ -782,11 +782,11 @@ func (c *messageResolverGroupTreeFormatContext) lineIndents() []int { } // currentIndent return indent at current depth. -func (c *messageResolverGroupTreeFormatContext) currentIndent() int { +func (c *variableDefinitionGroupTreeFormatContext) currentIndent() int { return c.depthToIndent[c.depth] } // currentMaxLength return max name length at current depth. -func (c *messageResolverGroupTreeFormatContext) currentMaxLength() int { +func (c *variableDefinitionGroupTreeFormatContext) currentMaxLength() int { return c.depthToMaxLength[c.depth] } diff --git a/resolver/format_test.go b/resolver/format_test.go index c2dc22d0..51eebf90 100644 --- a/resolver/format_test.go +++ b/resolver/format_test.go @@ -585,7 +585,7 @@ ab ─┤ if !exists { t.Fatalf("failed to find message from %s", msgName) } - got := resolver.DependencyGraphTreeFormat(msg.Rule.Resolvers) + got := resolver.DependencyGraphTreeFormat(msg.Rule.VariableDefinitionGroups) if diff := cmp.Diff(got, expected); diff != "" { t.Errorf("(-got, +want)\n%s", diff) } diff --git a/resolver/graph.go b/resolver/graph.go index a39e8f21..7ef770a1 100644 --- a/resolver/graph.go +++ b/resolver/graph.go @@ -216,10 +216,10 @@ type MessageDependencyGraph struct { Roots []*MessageDependencyGraphNode } -func (g *MessageDependencyGraph) MessageResolverGroups(ctx *context) []MessageResolverGroup { - var groups []MessageResolverGroup +func (g *MessageDependencyGraph) VariableDefinitionGroups(ctx *context) []VariableDefinitionGroup { + var groups []VariableDefinitionGroup for _, child := range g.uniqueChildren() { - if group := g.createMessageResolverGroup(ctx, child); group != nil { + if group := g.createVariableDefinitionGroup(ctx, child); group != nil { groups = append(groups, group) } } @@ -254,38 +254,38 @@ func (g *MessageDependencyGraph) children(nodes []*MessageDependencyGraphNode) [ return children } -func (g *MessageDependencyGraph) createMessageResolverGroup(ctx *context, node *MessageDependencyGraphNode) MessageResolverGroup { +func (g *MessageDependencyGraph) createVariableDefinitionGroup(ctx *context, node *MessageDependencyGraphNode) VariableDefinitionGroup { if node == nil { return nil } if len(node.Parent) == 0 { - return &SequentialMessageResolverGroup{End: g.createMessageResolver(ctx, node)} + return &SequentialVariableDefinitionGroup{End: g.createVariableDefinition(ctx, node)} } if len(node.Parent) == 1 { - return &SequentialMessageResolverGroup{ - Start: g.createMessageResolverGroup(ctx, node.Parent[0]), - End: g.createMessageResolver(ctx, node), + return &SequentialVariableDefinitionGroup{ + Start: g.createVariableDefinitionGroup(ctx, node.Parent[0]), + End: g.createVariableDefinition(ctx, node), } } - rg := new(ConcurrentMessageResolverGroup) + rg := new(ConcurrentVariableDefinitionGroup) sort.Slice(node.Parent, func(i, j int) bool { return node.Parent[i].FQDN() < node.Parent[j].FQDN() }) for _, parent := range node.Parent { - if group := g.createMessageResolverGroup(ctx, parent); group != nil { + if group := g.createVariableDefinitionGroup(ctx, parent); group != nil { rg.Starts = append(rg.Starts, group) } } - rg.End = g.createMessageResolver(ctx, node) + rg.End = g.createVariableDefinition(ctx, node) return rg } -func (g *MessageDependencyGraph) createMessageResolver(ctx *context, node *MessageDependencyGraphNode) *MessageResolver { +func (g *MessageDependencyGraph) createVariableDefinition(ctx *context, node *MessageDependencyGraphNode) *VariableDefinition { if g.MessageRule != nil { - return g.createMessageResolverByNode(ctx, node) + return g.createVariableDefinitionByNode(ctx, node) } if g.FieldOneofRule != nil { - return g.createMessageResolverByFieldOneofRule(ctx, node, g.FieldOneofRule) + return g.createVariableDefinitionByFieldOneofRule(ctx, node, g.FieldOneofRule) } ctx.addError( ErrWithLocation( @@ -296,9 +296,9 @@ func (g *MessageDependencyGraph) createMessageResolver(ctx *context, node *Messa return nil } -func (g *MessageDependencyGraph) createMessageResolverByNode(ctx *context, node *MessageDependencyGraphNode) *MessageResolver { +func (g *MessageDependencyGraph) createVariableDefinitionByNode(ctx *context, node *MessageDependencyGraphNode) *VariableDefinition { if varDef := node.VariableDefinition; varDef != nil { - return &MessageResolver{Name: varDef.Name, VariableDefinition: varDef} + return varDef } ctx.addError( ErrWithLocation( @@ -309,9 +309,9 @@ func (g *MessageDependencyGraph) createMessageResolverByNode(ctx *context, node return nil } -func (g *MessageDependencyGraph) createMessageResolverByFieldOneofRule(ctx *context, node *MessageDependencyGraphNode, rule *FieldOneofRule) *MessageResolver { +func (g *MessageDependencyGraph) createVariableDefinitionByFieldOneofRule(ctx *context, node *MessageDependencyGraphNode, rule *FieldOneofRule) *VariableDefinition { for _, def := range rule.VariableDefinitions { - return &MessageResolver{Name: def.Name, VariableDefinition: def} + return def } ctx.addError( ErrWithLocation( diff --git a/resolver/message.go b/resolver/message.go index 6e1492aa..2e91385a 100644 --- a/resolver/message.go +++ b/resolver/message.go @@ -74,7 +74,7 @@ func (m *Message) HasResolvers() bool { if m.Rule == nil { return false } - if len(m.Rule.Resolvers) != 0 { + if len(m.Rule.VariableDefinitionGroups) != 0 { return true } if len(m.Rule.VariableDefinitions) != 0 { @@ -87,19 +87,19 @@ func (m *Message) HasResolvers() bool { if field.Rule.Oneof == nil { continue } - if len(field.Rule.Oneof.Resolvers) != 0 { + if len(field.Rule.Oneof.VariableDefinitionGroups) != 0 { return true } } return false } -func (m *Message) MessageResolvers() []MessageResolverGroup { +func (m *Message) VariableDefinitionGroups() []VariableDefinitionGroup { if m.Rule == nil { return nil } - ret := m.Rule.Resolvers + ret := m.Rule.VariableDefinitionGroups for _, def := range m.Rule.VariableDefinitions { if def.Expr == nil { continue @@ -108,7 +108,7 @@ func (m *Message) MessageResolvers() []MessageResolverGroup { continue } for _, detail := range def.Expr.Validation.Error.Details { - ret = append(ret, detail.Resolvers...) + ret = append(ret, detail.VariableDefinitionGroups...) } } for _, field := range m.Fields { @@ -118,7 +118,7 @@ func (m *Message) MessageResolvers() []MessageResolverGroup { if field.Rule.Oneof == nil { continue } - ret = append(ret, field.Rule.Oneof.Resolvers...) + ret = append(ret, field.Rule.Oneof.VariableDefinitionGroups...) } return ret } @@ -304,7 +304,7 @@ func (m *Message) DependencyGraphTreeFormat() string { if m.Rule == nil { return "" } - return DependencyGraphTreeFormat(m.Rule.Resolvers) + return DependencyGraphTreeFormat(m.Rule.VariableDefinitionGroups) } func (m *Message) TypeConversionDecls() []*TypeConversionDecl { @@ -350,17 +350,17 @@ func (m *Message) CustomResolvers() []*CustomResolver { }) } } - for _, group := range m.Rule.Resolvers { - for _, resolver := range group.Resolvers() { - ret = append(ret, m.customResolvers(resolver)...) + for _, group := range m.Rule.VariableDefinitionGroups { + for _, def := range group.VariableDefinitions() { + ret = append(ret, m.customResolvers(def)...) } } return ret } -func (m *Message) customResolvers(resolver *MessageResolver) []*CustomResolver { +func (m *Message) customResolvers(def *VariableDefinition) []*CustomResolver { var ret []*CustomResolver - if def := resolver.VariableDefinition; def != nil { + if def != nil { for _, expr := range def.MessageExprs() { if expr.Message == nil { continue @@ -420,15 +420,15 @@ func (m *Message) DependServices() []*Service { return nil } - return m.dependServices(make(map[*MessageResolver]struct{})) + return m.dependServices(make(map[*VariableDefinition]struct{})) } -func (m *Message) dependServices(msgResolverMap map[*MessageResolver]struct{}) []*Service { +func (m *Message) dependServices(defMap map[*VariableDefinition]struct{}) []*Service { var svcs []*Service if m.Rule != nil { - for _, group := range m.Rule.Resolvers { - for _, resolver := range group.Resolvers() { - svcs = append(svcs, dependServicesByResolver(resolver, msgResolverMap)...) + for _, group := range m.Rule.VariableDefinitionGroups { + for _, def := range group.VariableDefinitions() { + svcs = append(svcs, dependServicesByDefinition(def, defMap)...) } } for _, def := range m.Rule.VariableDefinitions { @@ -439,9 +439,9 @@ func (m *Message) dependServices(msgResolverMap map[*MessageResolver]struct{}) [ continue } for _, detail := range def.Expr.Validation.Error.Details { - for _, group := range detail.Resolvers { - for _, resolver := range group.Resolvers() { - svcs = append(svcs, dependServicesByResolver(resolver, msgResolverMap)...) + for _, group := range detail.VariableDefinitionGroups { + for _, def := range group.VariableDefinitions() { + svcs = append(svcs, dependServicesByDefinition(def, defMap)...) } } } @@ -454,27 +454,26 @@ func (m *Message) dependServices(msgResolverMap map[*MessageResolver]struct{}) [ if field.Rule.Oneof == nil { continue } - for _, group := range field.Rule.Oneof.Resolvers { - for _, resolver := range group.Resolvers() { - svcs = append(svcs, dependServicesByResolver(resolver, msgResolverMap)...) + for _, group := range field.Rule.Oneof.VariableDefinitionGroups { + for _, def := range group.VariableDefinitions() { + svcs = append(svcs, dependServicesByDefinition(def, defMap)...) } } } return svcs } -func dependServicesByResolver(resolver *MessageResolver, msgResolverMap map[*MessageResolver]struct{}) []*Service { - if _, found := msgResolverMap[resolver]; found { +func dependServicesByDefinition(def *VariableDefinition, defMap map[*VariableDefinition]struct{}) []*Service { + if _, found := defMap[def]; found { return nil } - msgResolverMap[resolver] = struct{}{} + defMap[def] = struct{}{} - varDef := resolver.VariableDefinition - if varDef == nil { + if def == nil { return nil } - expr := varDef.Expr + expr := def.Expr if expr == nil { return nil } @@ -482,9 +481,9 @@ func dependServicesByResolver(resolver *MessageResolver, msgResolverMap map[*Mes return []*Service{expr.Call.Method.Service} } var ret []*Service - for _, msgExpr := range varDef.MessageExprs() { + for _, msgExpr := range def.MessageExprs() { if msgExpr.Message != nil { - ret = append(ret, msgExpr.Message.dependServices(msgResolverMap)...) + ret = append(ret, msgExpr.Message.dependServices(defMap)...) } } return ret diff --git a/resolver/message_resolver.go b/resolver/message_resolver.go index 5ff8c504..aa326a57 100644 --- a/resolver/message_resolver.go +++ b/resolver/message_resolver.go @@ -1,19 +1,19 @@ package resolver -func (g *SequentialMessageResolverGroup) Resolvers() []*MessageResolver { - var resolvers []*MessageResolver +func (g *SequentialVariableDefinitionGroup) VariableDefinitions() VariableDefinitions { + var defs VariableDefinitions if g.Start != nil { - resolvers = append(resolvers, g.Start.Resolvers()...) + defs = append(defs, g.Start.VariableDefinitions()...) } - resolvers = append(resolvers, g.End) - return resolvers + defs = append(defs, g.End) + return defs } -func (g *ConcurrentMessageResolverGroup) Resolvers() []*MessageResolver { - var resolvers []*MessageResolver +func (g *ConcurrentVariableDefinitionGroup) VariableDefinitions() VariableDefinitions { + var defs VariableDefinitions for _, start := range g.Starts { - resolvers = append(resolvers, start.Resolvers()...) + defs = append(defs, start.VariableDefinitions()...) } - resolvers = append(resolvers, g.End) - return resolvers + defs = append(defs, g.End) + return defs } diff --git a/resolver/resolver.go b/resolver/resolver.go index f2205715..c840a262 100644 --- a/resolver/resolver.go +++ b/resolver/resolver.go @@ -2938,7 +2938,7 @@ func (r *Resolver) resolveMessageDependencies(ctx *context, files []*File) { } if graph := CreateMessageDependencyGraph(ctx, msg); graph != nil { msg.Rule.DependencyGraph = graph - msg.Rule.Resolvers = graph.MessageResolverGroups(ctx) + msg.Rule.VariableDefinitionGroups = graph.VariableDefinitionGroups(ctx) } for defIdx, def := range msg.Rule.VariableDefinitions { if def.Expr == nil { @@ -2952,7 +2952,7 @@ func (r *Resolver) resolveMessageDependencies(ctx *context, files []*File) { ctx := ctx.withErrDetailIndex(detIdx) if graph := CreateMessageDependencyGraphByValidationErrorDetailMessages(msg, detail.Messages); graph != nil { detail.DependencyGraph = graph - detail.Resolvers = graph.MessageResolverGroups(ctx) + detail.VariableDefinitionGroups = graph.VariableDefinitionGroups(ctx) } } } @@ -2965,7 +2965,7 @@ func (r *Resolver) resolveMessageDependencies(ctx *context, files []*File) { } if graph := CreateMessageDependencyGraphByFieldOneof(ctx, msg, field); graph != nil { field.Rule.Oneof.DependencyGraph = graph - field.Rule.Oneof.Resolvers = graph.MessageResolverGroups(ctx) + field.Rule.Oneof.VariableDefinitionGroups = graph.VariableDefinitionGroups(ctx) } } } diff --git a/resolver/resolver_test.go b/resolver/resolver_test.go index 67e7670c..78a10626 100644 --- a/resolver/resolver_test.go +++ b/resolver/resolver_test.go @@ -191,10 +191,10 @@ func TestSimpleAggregation(t *testing.T) { testutil.NewDependencyGraphBuilder(). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("res")). - SetEnd(testutil.NewMessageResolver("user")). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("res")). + SetEnd(testutil.NewVariableDefinition("user")). Build(t), ). Build(t), @@ -299,19 +299,19 @@ func TestSimpleAggregation(t *testing.T) { Add(ref.Message(t, "org.post", "GetPostResponse"), ref.Message(t, "org.federation", "User")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("m")). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("m")). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). AddStart( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("res")). - SetEnd(testutil.NewMessageResolver("post")). + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("res")). + SetEnd(testutil.NewVariableDefinition("post")). Build(t), ). - SetEnd(testutil.NewMessageResolver("user")). + SetEnd(testutil.NewVariableDefinition("user")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("z")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("z")). Build(t), ). Build(t), @@ -372,8 +372,8 @@ func TestSimpleAggregation(t *testing.T) { Add(ref.Message(t, "org.federation", "Post")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("post")). - AddResolver(testutil.NewMessageResolverGroupByName("uuid")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("post")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("uuid")). Build(t), ). Build(t), @@ -591,14 +591,14 @@ func TestCreatePost(t *testing.T) { Add(ref.Message(t, "org.federation", "CreatePost")). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("cp")). - SetEnd(testutil.NewMessageResolver("res")). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("cp")). + SetEnd(testutil.NewVariableDefinition("res")). Build(t), ). - SetEnd(testutil.NewMessageResolver("p")). + SetEnd(testutil.NewVariableDefinition("p")). Build(t), ). Build(t), @@ -794,10 +794,10 @@ func TestCustomResolver(t *testing.T) { Add(ref.Message(t, "org.user", "GetUserResponse")). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("res")). - SetEnd(testutil.NewMessageResolver("u")). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("res")). + SetEnd(testutil.NewVariableDefinition("u")). Build(t), ). Build(t), @@ -862,14 +862,14 @@ func TestCustomResolver(t *testing.T) { Add(ref.Message(t, "org.post", "GetPostResponse"), ref.Message(t, "org.federation", "User")). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("res")). - SetEnd(testutil.NewMessageResolver("post")). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("res")). + SetEnd(testutil.NewVariableDefinition("post")). Build(t), ). - SetEnd(testutil.NewMessageResolver("user")). + SetEnd(testutil.NewVariableDefinition("user")). Build(t), ). Build(t), @@ -920,7 +920,7 @@ func TestCustomResolver(t *testing.T) { Add(ref.Message(t, "org.federation", "Post")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("post")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("post")). Build(t), ). Build(t), @@ -1053,8 +1053,8 @@ func TestAsync(t *testing.T) { Add(ref.Message(t, "org.federation", "AB")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("aa")). - AddResolver(testutil.NewMessageResolverGroupByName("ab")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("aa")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("ab")). Build(t), ). Build(t), @@ -1317,50 +1317,50 @@ func TestAsync(t *testing.T) { Add(ref.Message(t, "org.federation", "I")). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). AddStart( - testutil.NewMessageResolverGroupBuilder(). + testutil.NewVariableDefinitionGroupBuilder(). AddStart( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("a")). - SetEnd(testutil.NewMessageResolver("c")). + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("a")). + SetEnd(testutil.NewVariableDefinition("c")). Build(t), ). AddStart( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("b")). - SetEnd(testutil.NewMessageResolver("d")). + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("b")). + SetEnd(testutil.NewVariableDefinition("d")). Build(t), ). - SetEnd(testutil.NewMessageResolver("e")). + SetEnd(testutil.NewVariableDefinition("e")). Build(t), ). AddStart( - testutil.NewMessageResolverGroupBuilder(). + testutil.NewVariableDefinitionGroupBuilder(). AddStart( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("a")). - SetEnd(testutil.NewMessageResolver("c")). + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("a")). + SetEnd(testutil.NewVariableDefinition("c")). Build(t), ). AddStart( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("b")). - SetEnd(testutil.NewMessageResolver("d")). + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("b")). + SetEnd(testutil.NewVariableDefinition("d")). Build(t), ). - SetEnd(testutil.NewMessageResolver("f")). + SetEnd(testutil.NewVariableDefinition("f")). Build(t), ). - AddStart(testutil.NewMessageResolverGroupByName("g")). - SetEnd(testutil.NewMessageResolver("h")). + AddStart(testutil.NewVariableDefinitionGroupByName("g")). + SetEnd(testutil.NewVariableDefinition("h")). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("i")). - SetEnd(testutil.NewMessageResolver("j")). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("i")). + SetEnd(testutil.NewVariableDefinition("j")). Build(t), ). Build(t), @@ -1503,10 +1503,10 @@ func TestAlias(t *testing.T) { Add(ref.Message(t, "org.post", "GetPostResponse")). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("res")). - SetEnd(testutil.NewMessageResolver("post")). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("res")). + SetEnd(testutil.NewVariableDefinition("post")). Build(t), ). Build(t), @@ -1557,7 +1557,7 @@ func TestAlias(t *testing.T) { Add(ref.Message(t, "org.federation", "Post")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("post")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("post")). Build(t), ). Build(t), @@ -1683,13 +1683,13 @@ func TestAutobind(t *testing.T) { Add(ref.Message(t, "org.post", "GetPostResponse")). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("res")). - SetEnd(testutil.NewMessageResolver("_def1")). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("res")). + SetEnd(testutil.NewVariableDefinition("_def1")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("_def2")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("_def2")). Build(t), ). Build(t), @@ -1734,7 +1734,7 @@ func TestAutobind(t *testing.T) { Add(ref.Message(t, "org.federation", "Post")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("_def0")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("_def0")). Build(t), ). Build(t), @@ -2379,13 +2379,13 @@ func TestConstValue(t *testing.T) { Add(ref.Message(t, "org.federation", "Content")). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("res")). - SetEnd(testutil.NewMessageResolver("content")). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("res")). + SetEnd(testutil.NewVariableDefinition("content")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("content2")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("content2")). Build(t), ). Build(t), @@ -2491,7 +2491,7 @@ func TestMultiUser(t *testing.T) { Add(ref.Message(t, "org.federation", "Sub")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("_def0")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("_def0")). Build(t), ). Build(t), @@ -2549,11 +2549,11 @@ func TestMultiUser(t *testing.T) { Add(ref.Message(t, "org.user", "GetUserResponse")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("_def2")). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("res")). - SetEnd(testutil.NewMessageResolver("user")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("_def2")). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("res")). + SetEnd(testutil.NewVariableDefinition("user")). Build(t), ). Build(t), @@ -2637,16 +2637,16 @@ func TestMultiUser(t *testing.T) { Add(ref.Message(t, "org.federation", "UserID")). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("uid")). - SetEnd(testutil.NewMessageResolver("user")). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("uid")). + SetEnd(testutil.NewVariableDefinition("user")). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("uid")). - SetEnd(testutil.NewMessageResolver("user2")). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("uid")). + SetEnd(testutil.NewVariableDefinition("user2")). Build(t), ). Build(t), @@ -2745,7 +2745,7 @@ func TestOneof(t *testing.T) { Add(ref.Message(t, "org.user", "GetUserResponse")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("_def0")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("_def0")). Build(t), ). Build(t), @@ -2780,7 +2780,7 @@ func TestOneof(t *testing.T) { Add(ref.Message(t, "org.federation", "User")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("ua")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("ua")). Build(t), ). Build(t), @@ -2813,7 +2813,7 @@ func TestOneof(t *testing.T) { Add(ref.Message(t, "org.federation", "User")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("ub")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("ub")). Build(t), ). Build(t), @@ -2846,7 +2846,7 @@ func TestOneof(t *testing.T) { Add(ref.Message(t, "org.federation", "User")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("uc")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("uc")). Build(t), ). Build(t), @@ -2871,7 +2871,7 @@ func TestOneof(t *testing.T) { Add(ref.Message(t, "org.federation", "M")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("m")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("m")). Build(t), ). Build(t), @@ -2915,7 +2915,7 @@ func TestOneof(t *testing.T) { Add(ref.Message(t, "org.federation", "UserSelection")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("sel")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("sel")). Build(t), ). Build(t), @@ -3137,16 +3137,16 @@ func TestValidation(t *testing.T) { Add(ref.Message(t, "org.federation", "Post")). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("post")). - SetEnd(testutil.NewMessageResolver("_def1")). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("post")). + SetEnd(testutil.NewVariableDefinition("_def1")). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("post")). - SetEnd(testutil.NewMessageResolver("_def2")). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("post")). + SetEnd(testutil.NewVariableDefinition("_def2")). Build(t), ). Build(t), @@ -3241,10 +3241,10 @@ func TestMap(t *testing.T) { testutil.NewDependencyGraphBuilder(). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("res")). - SetEnd(testutil.NewMessageResolver("user")). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("res")). + SetEnd(testutil.NewVariableDefinition("user")). Build(t), ). Build(t), @@ -3359,26 +3359,26 @@ func TestMap(t *testing.T) { Add(ref.Message(t, "org.post", "GetPostsResponse"), ref.Message(t, "org.federation", "User")). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). AddStart( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("res")). - SetEnd(testutil.NewMessageResolver("posts")). + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("res")). + SetEnd(testutil.NewVariableDefinition("posts")). Build(t), ). - SetEnd(testutil.NewMessageResolver("ids")). + SetEnd(testutil.NewVariableDefinition("ids")). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). AddStart( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("res")). - SetEnd(testutil.NewMessageResolver("posts")). + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("res")). + SetEnd(testutil.NewVariableDefinition("posts")). Build(t), ). - SetEnd(testutil.NewMessageResolver("users")). + SetEnd(testutil.NewVariableDefinition("users")). Build(t), ). Build(t), @@ -3426,7 +3426,7 @@ func TestMap(t *testing.T) { Add(ref.Message(t, "org.federation", "Posts")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("posts")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("posts")). Build(t), ). Build(t), @@ -3617,36 +3617,36 @@ func TestCondition(t *testing.T) { Add(ref.Message(t, "org.post", "GetPostResponse"), ref.Message(t, "org.federation", "User")). Build(t), ). - AddResolver( - testutil.NewMessageResolverGroupBuilder(). + AddVariableDefinitionGroup( + testutil.NewVariableDefinitionGroupBuilder(). AddStart( - testutil.NewMessageResolverGroupBuilder(). + testutil.NewVariableDefinitionGroupBuilder(). AddStart( - testutil.NewMessageResolverGroupBuilder(). + testutil.NewVariableDefinitionGroupBuilder(). AddStart( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("res")). - SetEnd(testutil.NewMessageResolver("post")). + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("res")). + SetEnd(testutil.NewVariableDefinition("post")). Build(t), ). - SetEnd(testutil.NewMessageResolver("posts")). + SetEnd(testutil.NewVariableDefinition("posts")). Build(t), ). AddStart( - testutil.NewMessageResolverGroupBuilder(). + testutil.NewVariableDefinitionGroupBuilder(). AddStart( - testutil.NewMessageResolverGroupBuilder(). - AddStart(testutil.NewMessageResolverGroupByName("res")). - SetEnd(testutil.NewMessageResolver("post")). + testutil.NewVariableDefinitionGroupBuilder(). + AddStart(testutil.NewVariableDefinitionGroupByName("res")). + SetEnd(testutil.NewVariableDefinition("post")). Build(t), ). - SetEnd(testutil.NewMessageResolver("user")). + SetEnd(testutil.NewVariableDefinition("user")). Build(t), ). - SetEnd(testutil.NewMessageResolver("users")). + SetEnd(testutil.NewVariableDefinition("users")). Build(t), ). - SetEnd(testutil.NewMessageResolver("_def5")). + SetEnd(testutil.NewVariableDefinition("_def5")). Build(t), ). Build(t), @@ -3694,7 +3694,7 @@ func TestCondition(t *testing.T) { Add(ref.Message(t, "org.federation", "Post")). Build(t), ). - AddResolver(testutil.NewMessageResolverGroupByName("post")). + AddVariableDefinitionGroup(testutil.NewVariableDefinitionGroupByName("post")). Build(t), ). Build(t), diff --git a/resolver/types.go b/resolver/types.go index 5803ade6..eb99c89e 100644 --- a/resolver/types.go +++ b/resolver/types.go @@ -99,12 +99,12 @@ type EnumValueRule struct { } type MessageRule struct { - MessageArgument *Message - DependencyGraph *MessageDependencyGraph - Resolvers []MessageResolverGroup - CustomResolver bool - Alias *Message - VariableDefinitions VariableDefinitions + MessageArgument *Message + DependencyGraph *MessageDependencyGraph + CustomResolver bool + Alias *Message + VariableDefinitions VariableDefinitions + VariableDefinitionGroups []VariableDefinitionGroup } type VariableDefinition struct { @@ -117,8 +117,63 @@ type VariableDefinition struct { Expr *VariableExpr } +type VariableDefinitionOwnerType int + +const ( + VariableDefinitionOwnerUnknown VariableDefinitionOwnerType = 0 + VariableDefinitionOwnerMessage VariableDefinitionOwnerType = 1 + VariableDefinitionOwnerOneofField VariableDefinitionOwnerType = 2 + VariableDefinitionOwnerValidationErrorDetailMessage VariableDefinitionOwnerType = 3 +) + +type VariableDefinitionOwner struct { + Type VariableDefinitionOwnerType + Message *Message + Field *Field + ValidationErrorIndexes *ValidationErrorIndexes +} + type VariableDefinitions []*VariableDefinition +type VariableDefinitionGroupType string + +const ( + SequentialVariableDefinitionGroupType VariableDefinitionGroupType = "sequential" + ConcurrentVariableDefinitionGroupType VariableDefinitionGroupType = "concurrent" +) + +type VariableDefinitionGroup interface { + Type() VariableDefinitionGroupType + VariableDefinitions() VariableDefinitions + treeFormat(*variableDefinitionGroupTreeFormatContext) string + setTextMaxLength(*variableDefinitionGroupTreeFormatContext) +} + +type variableDefinitionGroupTreeFormatContext struct { + depth int + depthToMaxLength map[int]int + depthToIndent map[int]int + lineDepth map[int]struct{} +} + +type SequentialVariableDefinitionGroup struct { + Start VariableDefinitionGroup + End *VariableDefinition +} + +func (g *SequentialVariableDefinitionGroup) Type() VariableDefinitionGroupType { + return SequentialVariableDefinitionGroupType +} + +type ConcurrentVariableDefinitionGroup struct { + Starts []VariableDefinitionGroup + End *VariableDefinition +} + +func (g *ConcurrentVariableDefinitionGroup) Type() VariableDefinitionGroupType { + return ConcurrentVariableDefinitionGroupType +} + type VariableExpr struct { Type *Type By *CELValue @@ -160,50 +215,6 @@ type ValidationExpr struct { Error *ValidationError } -type MessageResolverGroupType string - -const ( - SequentialMessageResolverGroupType MessageResolverGroupType = "sequential" - ConcurrentMessageResolverGroupType MessageResolverGroupType = "concurrent" -) - -type MessageResolverGroup interface { - Type() MessageResolverGroupType - Resolvers() []*MessageResolver - treeFormat(*messageResolverGroupTreeFormatContext) string - setTextMaxLength(*messageResolverGroupTreeFormatContext) -} - -type messageResolverGroupTreeFormatContext struct { - depth int - depthToMaxLength map[int]int - depthToIndent map[int]int - lineDepth map[int]struct{} -} - -type SequentialMessageResolverGroup struct { - Start MessageResolverGroup - End *MessageResolver -} - -func (g *SequentialMessageResolverGroup) Type() MessageResolverGroupType { - return SequentialMessageResolverGroupType -} - -type ConcurrentMessageResolverGroup struct { - Starts []MessageResolverGroup - End *MessageResolver -} - -func (g *ConcurrentMessageResolverGroup) Type() MessageResolverGroupType { - return ConcurrentMessageResolverGroupType -} - -type MessageResolver struct { - Name string - VariableDefinition *VariableDefinition -} - type MessageValidations []*ValidationRule type ValidationRule struct { @@ -221,13 +232,13 @@ type ValidationError struct { type ValidationErrorDetails []*ValidationErrorDetail type ValidationErrorDetail struct { - If *CELValue - Messages VariableDefinitions - PreconditionFailures []*PreconditionFailure - BadRequests []*BadRequest - LocalizedMessages []*LocalizedMessage - DependencyGraph *MessageDependencyGraph - Resolvers []MessageResolverGroup + If *CELValue + Messages VariableDefinitions + PreconditionFailures []*PreconditionFailure + BadRequests []*BadRequest + LocalizedMessages []*LocalizedMessage + DependencyGraph *MessageDependencyGraph + VariableDefinitionGroups []VariableDefinitionGroup } type PreconditionFailure struct { @@ -298,12 +309,12 @@ type FieldRule struct { // FieldOneofRule represents grpc.federation.field.oneof. type FieldOneofRule struct { - If *CELValue - Default bool - VariableDefinitions VariableDefinitions - By *CELValue - DependencyGraph *MessageDependencyGraph - Resolvers []MessageResolverGroup + If *CELValue + Default bool + By *CELValue + DependencyGraph *MessageDependencyGraph + VariableDefinitions VariableDefinitions + VariableDefinitionGroups []VariableDefinitionGroup } type Type struct { @@ -402,22 +413,6 @@ type Request struct { Type *Message } -type VariableDefinitionOwnerType int - -const ( - VariableDefinitionOwnerUnknown VariableDefinitionOwnerType = 0 - VariableDefinitionOwnerMessage VariableDefinitionOwnerType = 1 - VariableDefinitionOwnerOneofField VariableDefinitionOwnerType = 2 - VariableDefinitionOwnerValidationErrorDetailMessage VariableDefinitionOwnerType = 3 -) - -type VariableDefinitionOwner struct { - Type VariableDefinitionOwnerType - Message *Message - Field *Field - ValidationErrorIndexes *ValidationErrorIndexes -} - type ValidationErrorIndexes struct { DefIdx int ErrDetailIdx int