switch to import V5 api

api/config.yaml

@@ -0,0 +1,155 @@
+output: api.gen.go
+package: api
+output-options:
+  skip-prune: true
+  user-templates:
+    client-with-responses.tmpl: |
+      // ClientWithResponses builds on ClientInterface to offer response payloads
+      type ClientWithResponses struct {
+          ClientInterface
+          OkOnNon200 bool
+      }
+
+      // StatusFailureError is the error returned if the response was a non-success code.
+      type StatusFailureError struct {
+        Resp *http.Response
+        Err  error
+      }
+
+      func (s StatusFailureError)Error() string {
+        if s.Err != nil {
+          return s.Err.Error()
+        }
+        return fmt.Sprintf("got non success response code: %d", s.Resp.StatusCode )
+      }
+
+      // NewClientWithResponses creates a new ClientWithResponses, which wraps
+      // Client with return type handling
+      func NewClientWithResponses(server string, OkOnNon200 bool, opts ...ClientOption) (*ClientWithResponses, error) {
+          client, err := NewClient(server, opts...)
+          if err != nil {
+              return nil, err
+          }
+          return &ClientWithResponses{
+            ClientInterface: client,
+            OkOnNon200: OkOnNon200,
+          }, nil
+      }
+
+      // WithBaseURL overrides the baseURL.
+      func WithBaseURL(baseURL string) ClientOption {
+        return func(c *Client) error {
+          newBaseURL, err := url.Parse(baseURL)
+          if err != nil {
+            return err
+          }
+          c.Server = newBaseURL.String()
+          return nil
+        }
+      }
+
+      // ClientWithResponsesInterface is the interface specification for the client with responses above.
+      type ClientWithResponsesInterface interface {
+      {{range . -}}
+      {{$hasParams := .RequiresParamObject -}}
+      {{$pathParams := .PathParams -}}
+      {{$opid := .OperationId -}}
+          // {{$opid}} request{{if .HasBody}} with any body{{end}}
+          {{$opid}}{{if .HasBody}}WithBody{{end}}WithResponse(ctx context.Context{{genParamArgs .PathParams}}{{if .RequiresParamObject}}, params *{{$opid}}Params{{end}}{{if .HasBody}}, contentType string, body io.Reader{{end}}, reqEditors... RequestEditorFn) (*{{genResponseTypeName $opid}}, error)
+      {{range .Bodies}}
+          {{if .IsSupportedByClient -}}
+              {{$opid}}{{.Suffix}}WithResponse(ctx context.Context{{genParamArgs $pathParams}}{{if $hasParams}}, params *{{$opid}}Params{{end}}, body {{$opid}}{{.NameTag}}RequestBody, reqEditors... RequestEditorFn) (*{{genResponseTypeName $opid}}, error)
+          {{end -}}
+      {{end}}{{/* range .Bodies */}}
+      {{end}}{{/* range . $opid := .OperationId */}}
+      }
+
+      {{range .}}{{$opid := .OperationId}}{{$op := .}}
+      type {{genResponseTypeName $opid | ucFirst}} struct {
+          Body         []byte
+        HTTPResponse *http.Response
+          {{- range getResponseTypeDefinitions .}}
+          {{.TypeName}} *{{.Schema.TypeDecl}}
+          {{- end}}
+      }
+
+      // Status returns HTTPResponse.Status
+      func (r {{genResponseTypeName $opid | ucFirst}}) Status() string {
+          if r.HTTPResponse != nil {
+              return r.HTTPResponse.Status
+          }
+          return http.StatusText(0)
+      }
+
+      // StatusCode returns HTTPResponse.StatusCode
+      func (r {{genResponseTypeName $opid | ucFirst}}) StatusCode() int {
+          if r.HTTPResponse != nil {
+              return r.HTTPResponse.StatusCode
+          }
+          return 0
+      }
+      {{end}}
+
+
+      {{range .}}
+      {{$opid := .OperationId -}}
+      {{/* Generate client methods (with responses)*/}}
+
+      // {{$opid}}{{if .HasBody}}WithBody{{end}}WithResponse request{{if .HasBody}} with arbitrary body{{end}} returning *{{genResponseTypeName $opid}}
+      func (c *ClientWithResponses) {{$opid}}{{if .HasBody}}WithBody{{end}}WithResponse(ctx context.Context{{genParamArgs .PathParams}}{{if .RequiresParamObject}}, params *{{$opid}}Params{{end}}{{if .HasBody}}, contentType string, body io.Reader{{end}}, reqEditors... RequestEditorFn) (*{{genResponseTypeName $opid}}, error){
+          rsp, err := c.{{$opid}}{{if .HasBody}}WithBody{{end}}(ctx{{genParamNames .PathParams}}{{if .RequiresParamObject}}, params{{end}}{{if .HasBody}}, contentType, body{{end}}, reqEditors...)
+          if err != nil {
+              return nil, err
+          }
+          r,err := Parse{{genResponseTypeName $opid | ucFirst}}(rsp)
+          if !c.OkOnNon200 && (r != nil && r.StatusCode() >= 400)  {
+            return r, StatusFailureError{Resp: rsp, Err: err}
+          }
+          return r,err
+      }
+
+      {{$hasParams := .RequiresParamObject -}}
+      {{$pathParams := .PathParams -}}
+      {{$bodyRequired := .BodyRequired -}}
+      {{range .Bodies}}
+      {{if .IsSupportedByClient -}}
+      func (c *ClientWithResponses) {{$opid}}{{.Suffix}}WithResponse(ctx context.Context{{genParamArgs $pathParams}}{{if $hasParams}}, params *{{$opid}}Params{{end}}, body {{$opid}}{{.NameTag}}RequestBody, reqEditors... RequestEditorFn) (*{{genResponseTypeName $opid}}, error) {
+          rsp, err := c.{{$opid}}{{.Suffix}}(ctx{{genParamNames $pathParams}}{{if $hasParams}}, params{{end}}, body, reqEditors...)
+          if err != nil {
+              return nil, err
+          }
+          r,err := Parse{{genResponseTypeName $opid | ucFirst}}(rsp)
+          if !c.OkOnNon200 && (r != nil && r.StatusCode() >= 400)  {
+            return r, StatusFailureError{Resp: rsp, Err: err}
+          }
+          return r,err
+      }
+      {{end}}
+      {{end}}
+
+      {{end}}{{/* operations */}}
+
+      {{/* Generate parse functions for responses*/}}
+      {{range .}}{{$opid := .OperationId}}
+
+      // Parse{{genResponseTypeName $opid | ucFirst}} parses an HTTP response from a {{$opid}}WithResponse call
+      func Parse{{genResponseTypeName $opid | ucFirst}}(rsp *http.Response) (*{{genResponseTypeName $opid}}, error) {
+          bodyBytes, err := io.ReadAll(rsp.Body)
+          defer func() { _ = rsp.Body.Close() }()
+          if err != nil {
+              return nil, err
+          }
+
+          response := {{genResponsePayload $opid}}
+
+          {{genResponseUnmarshal .}}
+
+          return response, nil
+      }
+      {{end}}{{/* range . $opid := .OperationId */}}
+generate:
+  client: true
+  strict-server: true
+  echo-server: true
+  models: true
+  embedded-spec: true

api/doc.go

@@ -1,5 +1,36 @@
 package api
 
-//go:generate go run github.com/deepmap/oapi-codegen/cmd/oapi-codegen --config=config.types.yaml tiltify.openapi.yaml
-//go:generate go run github.com/deepmap/oapi-codegen/cmd/oapi-codegen --config=config.server.yaml tiltify.openapi.yaml
-//go:generate go run github.com/deepmap/oapi-codegen/cmd/oapi-codegen --config=config.client.yaml tiltify.openapi.yaml
+//go:generate go run github.com/deepmap/oapi-codegen/cmd/oapi-codegen --config=config.yaml openapi.yaml
+//generate API code.
+
+//go:generate go run github.com/vektra/mockery/[email protected] --name ClientWithResponsesInterface --output ../mocks --with-expecter --filename api.gen.go --structname Api
+//generate client interface mocks
+
+//go:generate go run github.com/twitchtv/circuitgen --name ClientWithResponsesInterface --pkg ./ --debug --out ./circuit.gen.go --alias ClientWithResponsesCircuit --circuit-major-version 3
+//generate circuits for interface
+
+/*
+func GenerateREPLACEMEClient(
+	server string,
+	subjectString string,
+	client api.HttpRequestDoer,
+	manager *circuit.Manager,
+	conf api.CircuitWrapperClientWithResponsesCircuitConfig,
+) (api.ClientWithResponsesInterface, error) {
+	e, err := api.NewClientWithResponses(server, api.ClientOption(func(cl *api.Client) error {
+		cl.RequestEditors = []api.RequestEditorFn{
+			func(ctx context.Context, req *http.Request) error {
+				req.Header.Add("subject-uuid", subjectString)
+				return nil
+			},
+		}
+		cl.Client = client
+		return nil
+	}))
+	if err != nil {
+		return nil, err
+	}
+
+	return api.NewCircuitWrapperClientWithResponsesCircuit(manager, e, conf)
+}
+*/