refactor(ogenreflect): rename Operation to RuntimeOperation

Author: tdakkota

gen/_template/ogenreflect.tmpl

@@ -33,7 +33,7 @@ type api struct {
 {{ with $ops := $.Operations }}
 type paths struct {
 {{- range $op := $ops }}
-	{{ $op.Name }} ogenreflect.Operation
+	{{ $op.Name }} ogenreflect.RuntimeOperation
 {{- end }}
 }
 
@@ -42,7 +42,7 @@ func getPaths() paths {
 }
 
 // FindByName finds operation by ogen name.
-func (p paths) FindByName(name string) (op ogenreflect.Operation, _ bool) {
+func (p paths) FindByName(name string) (op ogenreflect.RuntimeOperation, _ bool) {
 	switch name {
 	{{- range $op := $ops }}
 	case {{ quote $op.Name }}:
@@ -54,7 +54,7 @@ func (p paths) FindByName(name string) (op ogenreflect.Operation, _ bool) {
 }
 
 // FindByOperationID finds operation by operationId.
-func (p paths) FindByOperationID(operationID string) (op ogenreflect.Operation, _ bool) {
+func (p paths) FindByOperationID(operationID string) (op ogenreflect.RuntimeOperation, _ bool) {
 	switch operationID {
 	{{- range $op := $ops }}{{- with $id := $op.Spec.OperationID }}
 	case {{ quote $id }}:
@@ -69,7 +69,7 @@ func (p paths) FindByOperationID(operationID string) (op ogenreflect.Operation,
 {{ with $ops := $.Webhooks }}
 type webhooks struct {
 {{- range $op := $ops }}
-	{{ $op.Name }} ogenreflect.Operation
+	{{ $op.Name }} ogenreflect.RuntimeOperation
 {{- end }}
 }
 
@@ -78,7 +78,7 @@ func getWebhooks() webhooks {
 }
 
 // FindByName finds operation by ogen name.
-func (w webhooks) FindByName(name string) (op ogenreflect.Operation, _ bool) {
+func (w webhooks) FindByName(name string) (op ogenreflect.RuntimeOperation, _ bool) {
 	switch name {
 	{{- range $op := $ops }}
 	case {{ quote $op.Name }}:
@@ -90,7 +90,7 @@ func (w webhooks) FindByName(name string) (op ogenreflect.Operation, _ bool) {
 }
 
 // FindByOperationID finds operation by operationId.
-func (w webhooks) FindByOperationID(operationID string) (op ogenreflect.Operation, _ bool) {
+func (w webhooks) FindByOperationID(operationID string) (op ogenreflect.RuntimeOperation, _ bool) {
 	switch operationID {
 	{{- range $op := $ops }}{{- with $id := $op.Spec.OperationID }}
 	case {{ quote $id }}:
@@ -106,7 +106,7 @@ func (w webhooks) FindByOperationID(operationID string) (op ogenreflect.Operatio
 
 {{ define "ogenreflect/operation" -}}
 {{- /*gotype: github.com/ogen-go/ogen/gen/ir.Operation*/ -}}{{ $op := $ -}}
-ogenreflect.Operation{
+ogenreflect.RuntimeOperation{
 	Name: {{ quote $op.Name }},
 	ID: {{ quote $op.Spec.OperationID }},
 	Types: ogenreflect.OperationTypes{
@@ -129,21 +129,20 @@ ogenreflect.Operation{
 		},
         {{- end }}
 		{{- with $p := $op.Params }}
-		Params: ogenreflect.ParameterMap[ogenreflect.ParameterType]{
+		Params: ogenreflect.ParametersType{
+			StructType: reflect.TypeOf(new({{ $op.Name }}Params)).Elem(),
+			Map: ogenreflect.ParameterMap[ogenreflect.ParameterType]{
 			{{- range $param := $p }}
-			{Name: {{ quote $param.Spec.Name }}, In: {{ quote $param.Spec.In }}}: {
-				Type: reflect.TypeOf(new({{ $param.Type.Go }})).Elem(),
-				Name: {{ quote $param.Spec.Name }},
-				In: {{ quote $param.Spec.In }},
-				Style: {{ quote $param.Spec.Style }},
-				Explode: {{ $param.Spec.Explode }},
-				Required: {{ $param.Spec.Required }},
-			},
+				{
+					Name: {{ quote $param.Spec.Name }},
+					In: {{ quote $param.Spec.In }},
+				}: {{ template "ogenreflect/parameter" $param -}},
 			{{- end }}
+			},
 		},
         {{- end }}
 		{{- with $resp := $op.Responses }}
-		Response: ogenreflect.ResponseType{
+		Responses: ogenreflect.ResponsesType{
 			Type: reflect.TypeOf(new({{ $resp.Type.Go }})).Elem(),
 			{{- if not $resp.Type.IsInterface }}
 			Implementations: nil,
@@ -154,15 +153,15 @@ ogenreflect.Operation{
 				{{- end }}
 			},
 			{{- end }}
-			PatternMap: map[string]ogenreflect.Contents{
+			PatternMap: map[string]ogenreflect.ResponseType{
 			{{- range $code, $resp := $resp.StatusCode }}
-				{{ print $code | quote }}: {{ template "ogenreflect/contents" $resp.Contents -}},
+				{{ print $code | quote }}: {{ template "ogenreflect/response" $resp -}},
 			{{- end }}
 			{{- range $idx, $resp := $resp.Pattern }}{{- if $resp }}
-				{{ printf "%dXX" (add $idx 1) | quote }}: {{ template "ogenreflect/contents" $resp.Contents -}},
+				{{ printf "%dXX" (add $idx 1) | quote }}: {{ template "ogenreflect/response" $resp -}},
 			{{- end }}{{- end }}
 			{{- with $resp := $resp.Default }}
-				"default": {{ template "ogenreflect/contents" $resp.Contents -}},
+				"default": {{ template "ogenreflect/response" $resp -}},
 			{{- end }}
 			},
 		},
@@ -171,6 +170,30 @@ ogenreflect.Operation{
 }
 {{- end }}
 
+{{ define "ogenreflect/response" -}}
+{{- /*gotype: github.com/ogen-go/ogen/gen/ir.Response*/ -}}{{ $resp := $ -}}
+ogenreflect.ResponseType{
+	Headers: map[string]ogenreflect.ParameterType{
+	{{- range $header := $resp.Headers }}
+		{{ quote $header.Spec.Name }}: {{ template "ogenreflect/parameter" $header -}},
+	{{- end }}
+	},
+	Contents: {{ template "ogenreflect/contents" $resp.Contents -}},
+}
+{{- end }}
+
+{{ define "ogenreflect/parameter" -}}
+{{- /*gotype: github.com/ogen-go/ogen/gen/ir.Parameter*/ -}}{{ $param := $ -}}
+ogenreflect.ParameterType{
+	Type: reflect.TypeOf(new({{ $param.Type.Go }})).Elem(),
+	Name: {{ quote $param.Spec.Name }},
+	In: {{ quote $param.Spec.In }},
+	Style: {{ quote $param.Spec.Style }},
+	Explode: {{ $param.Spec.Explode }},
+	Required: {{ $param.Spec.Required }},
+}
+{{- end }}
+
 {{ define "ogenreflect/contents" -}}
 ogenreflect.Contents{
 	{{- range $ct, $media := $ }}

middleware/middleware.go

@@ -27,7 +27,7 @@ type Request struct {
 	// Deprecated: use Op instead.
 	OperationID string
 	// Op contains the operation information.
-	Op ogenreflect.Operation
+	Op ogenreflect.RuntimeOperation
 	// Body is the operation request body. May be nil, if the operation has not body.
 	Body any
 	// Params is the operation parameters.

ogenerrors/ogenerrors.go

@@ -21,7 +21,7 @@ type Error interface {
 	// Deprecated: use Op instead.
 	OperationID() string
 	// Op returns operation info.
-	Op() ogenreflect.Operation
+	Op() ogenreflect.RuntimeOperation
 	// Code returns HTTP code to respond.
 	Code() int
 
@@ -48,11 +48,11 @@ type OperationContext struct {
 	// Deprecated: use Operation instead.
 	ID string
 	// Operation defines operation info.
-	Operation ogenreflect.Operation
+	Operation ogenreflect.RuntimeOperation
 }
 
 // Op returns operation info.
-func (d OperationContext) Op() ogenreflect.Operation {
+func (d OperationContext) Op() ogenreflect.RuntimeOperation {
 	return d.Operation
 }
 

ogenreflect/params.go renamed to ogenreflect/parameter_map.go

@@ -5,8 +5,8 @@ import (
 	"strconv"
 )
 
-// Operation stores the operation information.
-type Operation struct {
+// RuntimeOperation stores the operation information.
+type RuntimeOperation struct {
 	// Name is the ogen operation name. It is guaranteed to be unique and not empty.
 	Name string
 	// ID is the spec operation ID, if any.
@@ -19,10 +19,10 @@ type Operation struct {
 type OperationTypes struct {
 	// Request is the operation request type.
 	Request RequestType
-	// Params stores the operation parameters types by name.
-	Params ParameterMap[ParameterType]
-	// Response is the operation response type.
-	Response ResponseType
+	// Params stores the operation parameters types.
+	Params ParametersType
+	// Responses stores the operation responses types.
+	Responses ResponsesType
 }
 
 // IsRequest checks if the type is the operation request type.
@@ -45,7 +45,7 @@ func (t OperationTypes) IsRequest(v any) bool {
 
 // IsParam checks if the type is the operation param type.
 func (t OperationTypes) IsParam(v any) bool {
-	for _, impl := range t.Params {
+	for _, impl := range t.Params.Map {
 		if reflect.TypeOf(v) == impl.Type {
 			return true
 		}
@@ -55,7 +55,7 @@ func (t OperationTypes) IsParam(v any) bool {
 
 // IsResponse checks if the type is the operation response type.
 func (t OperationTypes) IsResponse(v any) bool {
-	r := t.Response
+	r := t.Responses
 	if len(r.Implementations) == 0 {
 		return reflect.TypeOf(v) == r.Type
 	}
@@ -100,8 +100,18 @@ type ParameterType struct {
 	Required bool
 }
 
-// ResponseType holds the response type information.
-type ResponseType struct {
+// ParametersType holds the parameters type information.
+type ParametersType struct {
+	// StructType is the parameters struct type.
+	//
+	// StructType is nil if the operation has no parameters.
+	StructType reflect.Type
+	// Map stores the operation parameters types.
+	Map ParameterMap[ParameterType]
+}
+
+// ResponsesType holds the response type information.
+type ResponsesType struct {
 	// Type is the response type.
 	//
 	// If operation defines multiple content types, Type is the interface type, implemented
@@ -114,32 +124,43 @@ type ResponseType struct {
 	// PatternMap stores the response contents by pattern.
 	//
 	// If element is empty, the response has no content for the pattern.
-	PatternMap map[string]Contents
+	PatternMap map[string]ResponseType
 }
 
-// FindContents returns the matching contents for the given status code.
-func (r ResponseType) FindContents(code int) (Contents, bool) {
-	c, ok := r.PatternMap[strconv.Itoa(code)]
+// FindResponse returns the matching contents for the given status code.
+func (r ResponsesType) FindResponse(code int) (rt ResponseType, ok bool) {
+	if code < 100 || code > 599 {
+		return rt, false
+	}
+	rt, ok = r.PatternMap[strconv.Itoa(code)]
 	if ok {
-		return c, true
+		return rt, true
 	}
 	switch code / 100 {
 	case 1:
-		c, ok = r.PatternMap["1XX"]
+		rt, ok = r.PatternMap["1XX"]
 	case 2:
-		c, ok = r.PatternMap["2XX"]
+		rt, ok = r.PatternMap["2XX"]
 	case 3:
-		c, ok = r.PatternMap["3XX"]
+		rt, ok = r.PatternMap["3XX"]
 	case 4:
-		c, ok = r.PatternMap["4XX"]
+		rt, ok = r.PatternMap["4XX"]
 	case 5:
-		c, ok = r.PatternMap["5XX"]
+		rt, ok = r.PatternMap["5XX"]
 	}
 	if ok {
-		return c, true
+		return rt, true
 	}
-	c, ok = r.PatternMap["default"]
-	return c, ok
+	rt, ok = r.PatternMap["default"]
+	return rt, ok
+}
+
+// ResponseType is the response type.
+type ResponseType struct {
+	// Headers stores the response headers.
+	Headers map[string]ParameterType
+	// Contents stores the response contents.
+	Contents Contents
 }
 
 // Contents is the request or response contents.

ogenreflect/operation.go renamed to ogenreflect/runtime_operation.go

@@ -60,7 +60,7 @@ func TestOperationTypes(t *testing.T) {
 				a := require.New(t)
 
 				ot := OperationTypes{
-					Response: ResponseType{
+					Responses: ResponsesType{
 						Type:            tt.typ,
 						Implementations: tt.impl,
 					},
@@ -75,12 +75,14 @@ func TestOperationTypes(t *testing.T) {
 	})
 	t.Run("IsParam", func(t *testing.T) {
 		ot := OperationTypes{
-			Params: ParameterMap[ParameterType]{
-				{"cache", "query"}: {
-					Type: typBool,
-				},
-				{"id", "path"}: {
-					Type: typInt64,
+			Params: ParametersType{
+				Map: ParameterMap[ParameterType]{
+					{"cache", "query"}: {
+						Type: typBool,
+					},
+					{"id", "path"}: {
+						Type: typInt64,
+					},
 				},
 			},
 		}
@@ -93,43 +95,52 @@ func TestOperationTypes(t *testing.T) {
 	})
 }
 
-func TestResponseType_FindContents(t *testing.T) {
-	a := Contents{"application/json": nil}
-	b := Contents{"text/html": nil}
-	c := Contents{}
+func TestResponseType_FindResponse(t *testing.T) {
+	a := ResponseType{
+		Contents: Contents{
+			"application/json": nil,
+		},
+	}
+	b := ResponseType{
+		Contents: Contents{
+			"text/html": nil,
+		},
+	}
+	c := ResponseType{}
 
 	tests := []struct {
-		patterns map[string]Contents
+		patterns map[string]ResponseType
 		code     int
-		want     Contents
+		want     ResponseType
 		wantOk   bool
 	}{
 		// Exact match.
-		{map[string]Contents{"200": a}, 200, a, true},
-		{map[string]Contents{"200": a, "201": b}, 200, a, true},
+		{map[string]ResponseType{"200": a}, 200, a, true},
+		{map[string]ResponseType{"200": a, "201": b}, 200, a, true},
 
 		// Pattern.
-		{map[string]Contents{"2XX": a}, 200, a, true},
-		{map[string]Contents{"2XX": a}, 201, a, true},
+		{map[string]ResponseType{"2XX": a}, 200, a, true},
+		{map[string]ResponseType{"2XX": a}, 201, a, true},
 
 		// Combined.
-		{map[string]Contents{"200": a, "2XX": b, "default": c}, 200, a, true},
-		{map[string]Contents{"200": a, "2XX": b, "default": c}, 201, b, true},
-		{map[string]Contents{"200": a, "2XX": b, "default": c}, 500, c, true},
+		{map[string]ResponseType{"200": a, "2XX": b, "default": c}, 200, a, true},
+		{map[string]ResponseType{"200": a, "2XX": b, "default": c}, 201, b, true},
+		{map[string]ResponseType{"200": a, "2XX": b, "default": c}, 500, c, true},
 
 		// No match.
-		{nil, 0, nil, false},
-		{map[string]Contents{"200": a}, 201, nil, false},
+		{nil, 0, ResponseType{}, false},
+		{nil, 200, ResponseType{}, false},
+		{map[string]ResponseType{"200": a}, 201, ResponseType{}, false},
 	}
 	for i, tt := range tests {
 		tt := tt
 		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
 			a := require.New(t)
 
-			rtyp := ResponseType{
+			rtyp := ResponsesType{
 				PatternMap: tt.patterns,
 			}
-			got, gotOk := rtyp.FindContents(tt.code)
+			got, gotOk := rtyp.FindResponse(tt.code)
 			if !tt.wantOk {
 				a.False(gotOk)
 				return