From 8680832a98435cbdc930cb803aa78cc7697d363d Mon Sep 17 00:00:00 2001 From: adelnizamutdinov Date: Sun, 22 Nov 2026 10:13:26 +0300 Subject: [PATCH] Return raw bytes for binary response bodies A response whose media type is neither JSON, text, XML nor an event stream but carries a schema (e.g. OpenAPI 3.1+ `type: string` with `contentMediaType: application/octet-stream`) was declared with a typed body in TypeScript (`body: string`) while the implementation returned no body, so generated clients failed strict `tsc`. Go converted the bytes to the schema type, which fails to compile for non-string schemas. Classify such responses as binary in clientgen. TypeScript now reads them with `response.blob()` and types them as `Blob`, matching binary multipart parts; Go stores the bytes as `[]byte`, matching Rust `Vec` and Dart `List`. Add a binary-response fixture with Go and TypeScript goldens, and refresh the private TypeScript golden, whose octet-stream 400 response had the same inconsistency. --- README.md | 5 + internal/clientgen/client.go | 7 + internal/goemit/client.go | 8 +- internal/goemit/goemit.go | 5 +- internal/goemit/templates/client.go.gotmpl | 5 +- internal/tsemit/templates/api.ts.gotmpl | 2 + internal/tsemit/tsemit.go | 11 +- moon.yml | 2 + oasmith_test.go | 16 + testdata/fixtures/binary-response.yaml | 24 + testdata/golden/binary-response-go/client.go | 536 ++++++++++++++++++ testdata/golden/binary-response-go/models.go | 3 + .../golden/binary-response-typescript/api.ts | 208 +++++++ .../binary-response-typescript/types.ts | 2 + testdata/golden/private-typescript/api.ts | 141 +++-- 15 files changed, 912 insertions(+), 63 deletions(-) create mode 100644 testdata/fixtures/binary-response.yaml create mode 100644 testdata/golden/binary-response-go/client.go create mode 100644 testdata/golden/binary-response-go/models.go create mode 100644 testdata/golden/binary-response-typescript/api.ts create mode 100644 testdata/golden/binary-response-typescript/types.ts diff --git a/README.md b/README.md index 3b79484..a067435 100644 --- a/README.md +++ b/README.md @@ -90,6 +90,11 @@ Binary multipart parts are `Blob` values; their media types must match the content types declared by the corresponding prefix encoding. Unsupported request-body shapes fail generation. +Response bodies with a schema under a media type that is neither JSON, text, +XML nor an event stream are raw bytes, such as `type: string` with +`contentMediaType: application/octet-stream`. Clients return them unparsed: +`Blob` in TypeScript, `[]byte` in Go, `Vec` in Rust and `List` in Dart. + ## OpenTelemetry trace propagation Generated clients leave OpenTelemetry dependencies and SDK setup to the diff --git a/internal/clientgen/client.go b/internal/clientgen/client.go index f5723a2..8fe3b0a 100644 --- a/internal/clientgen/client.go +++ b/internal/clientgen/client.go @@ -84,6 +84,13 @@ func (response Response) Text() bool { response.MediaType == "application/xml" || strings.HasSuffix(response.MediaType, "+xml")) } +// Binary reports whether the response body is raw bytes: it has a schema but is +// neither a JSON, text, nor server-sent event representation. OpenAPI 3.1+ +// describes such bodies as `type: string` with `contentMediaType`. +func (response Response) Binary() bool { + return response.HasBody() && !response.SSE && !response.JSON() && !response.Text() +} + // Analyze normalizes and validates every operation used by generated clients. func Analyze(doc *openapi.Document) ([]Operation, error) { routes := doc.Operations() diff --git a/internal/goemit/client.go b/internal/goemit/client.go index 22dd6bb..9d35e03 100644 --- a/internal/goemit/client.go +++ b/internal/goemit/client.go @@ -76,6 +76,7 @@ type goResponseData struct { Body bool JSON bool Text bool + Binary bool SSE bool ReconnectableSSE bool } @@ -197,13 +198,18 @@ func (e *emitter) operationResponses(analyzed []clientgen.Response) ([]goRespons responses := make([]goResponseData, 0, len(analyzed)) var bodylessStatuses []string for _, response := range analyzed { + responseType := binaryType + if !response.Binary() { + responseType = e.goType(response.Schema) + } responseData := goResponseData{ Status: response.Status, FieldName: fmt.Sprintf("Status%d", response.Status), - Type: e.goType(response.Schema), + Type: responseType, Body: response.HasBody(), JSON: response.JSON(), Text: response.Text(), + Binary: response.Binary(), SSE: response.SSE, ReconnectableSSE: response.SSE, } diff --git a/internal/goemit/goemit.go b/internal/goemit/goemit.go index d778b7c..eb03297 100644 --- a/internal/goemit/goemit.go +++ b/internal/goemit/goemit.go @@ -22,7 +22,10 @@ type Options struct { Strict bool } -const goInt32 = "int32" +const ( + goInt32 = "int32" + binaryType = "[]byte" +) type emitter struct{ strict bool } diff --git a/internal/goemit/templates/client.go.gotmpl b/internal/goemit/templates/client.go.gotmpl index b5cdc1a..9beab15 100644 --- a/internal/goemit/templates/client.go.gotmpl +++ b/internal/goemit/templates/client.go.gotmpl @@ -842,9 +842,10 @@ func (c *Client) {{.ID}}(ctx context.Context{{if .HasParams}}, params {{.ParamsT if len(rawBody) > maxDecodedBodyBytes { return nil, fmt.Errorf("read {{$operation.ID}} status {{.Status}} response: body exceeds %d bytes", maxDecodedBodyBytes) } - decoded := {{.Type}}(rawBody) +{{if .Binary}} result.{{.FieldName}} = &rawBody +{{else}} decoded := {{.Type}}(rawBody) result.{{.FieldName}} = &decoded - return result, nil +{{end}} return result, nil {{end}}{{end}}{{end}}{{if .BodylessStatuses}} case {{.BodylessStatuses}}: _ = res.Body.Close() return result, nil diff --git a/internal/tsemit/templates/api.ts.gotmpl b/internal/tsemit/templates/api.ts.gotmpl index 83336c7..de809c6 100644 --- a/internal/tsemit/templates/api.ts.gotmpl +++ b/internal/tsemit/templates/api.ts.gotmpl @@ -745,6 +745,8 @@ async function runInterceptors( return { status: {{.Status}}, body, raw: response }; {{else if .Text}} const body: {{.Type}} = await response.text(); return { status: {{.Status}}, body, raw: response }; +{{else if .Binary}} const body: {{.Type}} = await response.blob(); + return { status: {{.Status}}, body, raw: response }; {{else}} return { status: {{.Status}}, raw: response }; {{end}} } {{end}} throw new ResponseError(response, `Unexpected response status ${response.status}`); diff --git a/internal/tsemit/tsemit.go b/internal/tsemit/tsemit.go index f934e8e..76d7283 100644 --- a/internal/tsemit/tsemit.go +++ b/internal/tsemit/tsemit.go @@ -303,6 +303,7 @@ type opResponse struct { SSE bool JSON bool Text bool + Binary bool } func modelImports(doc *openapi.Document, operations []clientgen.Operation) []string { @@ -444,7 +445,7 @@ func multipartBodyTemplateData(analyzed *clientgen.MultipartBody) *tsMultipartBo func multipartPartType(part clientgen.MultipartPart) string { if part.Binary { - return "Blob" + return binaryType } return tsType(part.Schema) } @@ -452,13 +453,18 @@ func multipartPartType(part clientgen.MultipartPart) string { func operationResponses(analyzed []clientgen.Response) []opResponse { responses := make([]opResponse, 0, len(analyzed)) for _, response := range analyzed { + responseType := tsType(response.Schema) + if response.Binary() { + responseType = binaryType + } responses = append(responses, opResponse{ Status: response.Status, - Type: tsType(response.Schema), + Type: responseType, Body: response.HasBody(), SSE: response.SSE, JSON: response.JSON(), Text: response.Text(), + Binary: response.Binary(), }) } return responses @@ -536,6 +542,7 @@ const ( nullType = "null" jsonBodyName = "body" rawBodyParam = "rawBody" + binaryType = "Blob" ) func tsType(schema *openapi.Schema) string { diff --git a/moon.yml b/moon.yml index 07f8267..67f2c7c 100644 --- a/moon.yml +++ b/moon.yml @@ -19,6 +19,8 @@ tasks: go run ./cmd/oasmith --openapi testdata/fixtures/public-client.yaml --mode client --lang go --out testdata/golden/public-client-go go run ./cmd/oasmith --openapi testdata/fixtures/private.yaml --mode client --lang typescript --out testdata/golden/private-typescript go run ./cmd/oasmith --openapi testdata/fixtures/config.yaml --mode client --lang typescript --out testdata/golden/config-typescript + go run ./cmd/oasmith --openapi testdata/fixtures/binary-response.yaml --mode client --lang go --out testdata/golden/binary-response-go + go run ./cmd/oasmith --openapi testdata/fixtures/binary-response.yaml --mode client --lang typescript --out testdata/golden/binary-response-typescript options: cache: false runInCI: false diff --git a/oasmith_test.go b/oasmith_test.go index e7718a4..1c58fc8 100644 --- a/oasmith_test.go +++ b/oasmith_test.go @@ -155,6 +155,22 @@ func TestGoldenFixtures(t *testing.T) { return tsemit.Emit(doc, tsemit.Options{OutDir: outDir}) }, }, + { + name: "binary-response-go", + fixture: "binary-response.yaml", + golden: "binary-response-go", + emit: func(doc *openapi.Document, outDir string, sourcePath string) error { + return goemit.EmitClient(doc, goemit.Options{OutDir: outDir, SourcePath: sourcePath}) + }, + }, + { + name: "binary-response-typescript", + fixture: "binary-response.yaml", + golden: "binary-response-typescript", + emit: func(doc *openapi.Document, outDir string, _ string) error { + return tsemit.Emit(doc, tsemit.Options{OutDir: outDir}) + }, + }, } { t.Run(testCase.name, func(t *testing.T) { t.Parallel() diff --git a/testdata/fixtures/binary-response.yaml b/testdata/fixtures/binary-response.yaml new file mode 100644 index 0000000..dd8bc51 --- /dev/null +++ b/testdata/fixtures/binary-response.yaml @@ -0,0 +1,24 @@ +openapi: 3.2.0 +info: + title: Binary response fixture + version: "1" +paths: + /files/{key}: + get: + operationId: getFile + parameters: + - name: key + in: path + required: true + schema: + type: string + responses: + "200": + description: File bytes. + content: + application/octet-stream: + schema: + type: string + contentMediaType: application/octet-stream + "404": + description: No file with that key. diff --git a/testdata/golden/binary-response-go/client.go b/testdata/golden/binary-response-go/client.go new file mode 100644 index 0000000..61b78c6 --- /dev/null +++ b/testdata/golden/binary-response-go/client.go @@ -0,0 +1,536 @@ +// Code generated by OASmith. DO NOT EDIT. + +package binaryresponse + +import ( + "bufio" + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "net/url" + "strings" + "sync" + "time" +) + +const ( + maxDecodedBodyBytes = 4 << 20 + maxDiagnosticBodyBytes = 64 << 10 + maxSSEEventBytes = 4 << 20 + defaultResponseTimeout = 30 * time.Second + defaultSSEIdleTimeout = 60 * time.Second + defaultSSEMaxRetries = 5 + defaultSSEReconnectBaseDelay = 200 * time.Millisecond + maxSSERetries = 100 +) + +type HTTPClient interface { + Do(*http.Request) (*http.Response, error) +} + +type HTTPClientFunc func(*http.Request) (*http.Response, error) + +func (f HTTPClientFunc) Do(req *http.Request) (*http.Response, error) { + return f(req) +} + +// RequestEditorFn mutates a request immediately before transport execution. +// The context is the operation context, including its response timeout. +type RequestEditorFn func(context.Context, *http.Request) error + +type Option func(*ClientOptions) + +type ClientOptions struct { + BaseURL string + httpClient HTTPClient + requestEditors []RequestEditorFn + responseTimeout time.Duration + sseIdleTimeout time.Duration + sseMaxRetries int + sseReconnectBaseDelay time.Duration + sseReconnectOnStreamEnd bool +} + +// WithHTTPClient replaces the default http.DefaultClient without mutating a +// caller-owned http.Client. +func WithHTTPClient(client HTTPClient) Option { + return func(options *ClientOptions) { + options.httpClient = client + } +} + +// WithRequestEditorFn appends a client-level request editor. Editors run in +// registration order and must be safe for concurrent use when Client is shared. +func WithRequestEditorFn(editor RequestEditorFn) Option { + return func(options *ClientOptions) { + options.requestEditors = append(options.requestEditors, editor) + } +} + +// WithResponseTimeout bounds response headers and, for ordinary responses, +// reading and decoding the response body. For SSE it only bounds connection +// establishment. Zero disables the timeout. +func WithResponseTimeout(timeout time.Duration) Option { + return func(options *ClientOptions) { + options.responseTimeout = timeout + } +} + +// WithSSEIdleTimeout bounds silence between SSE chunks. Every received chunk, +// including a heartbeat comment, resets it. Zero disables the timeout. +func WithSSEIdleTimeout(timeout time.Duration) Option { + return func(options *ClientOptions) { + options.sseIdleTimeout = timeout + } +} + +// WithSSEMaxRetries bounds consecutive reconnect failures for generated GET +// event streams. Zero disables reconnect attempts; the hard cap is 100. +func WithSSEMaxRetries(retries int) Option { + return func(options *ClientOptions) { + options.sseMaxRetries = retries + } +} + +// WithSSEReconnectBaseDelay configures the first reconnect backoff. +func WithSSEReconnectBaseDelay(delay time.Duration) Option { + return func(options *ClientOptions) { + options.sseReconnectBaseDelay = delay + } +} + +// WithSSEReconnectOnStreamEnd controls whether a clean EOF reconnects a +// generated event stream. It defaults to true for compatibility with streams +// that use EOF as a transient disconnect; terminal-aware proxies can disable it. +func WithSSEReconnectOnStreamEnd(reconnect bool) Option { + return func(options *ClientOptions) { + options.sseReconnectOnStreamEnd = reconnect + } +} + +type Client struct { + baseURL string + httpClient HTTPClient + requestEditors []RequestEditorFn + responseTimeout time.Duration + sseIdleTimeout time.Duration + sseMaxRetries int + sseReconnectBaseDelay time.Duration + sseReconnectOnStreamEnd bool +} + +func NewClient(config ClientOptions, options ...Option) (*Client, error) { + configuredBaseURL := strings.TrimSpace(config.BaseURL) + if configuredBaseURL == "" { + return nil, fmt.Errorf("base URL must not be empty: %q", config.BaseURL) + } + parsed, err := url.Parse(configuredBaseURL) + if err != nil { + return nil, fmt.Errorf("parse base URL %q: %w", config.BaseURL, err) + } + if parsed.Scheme == "" || parsed.Host == "" { + return nil, fmt.Errorf("base URL %q must include scheme and host", config.BaseURL) + } + config.httpClient = http.DefaultClient + config.responseTimeout = defaultResponseTimeout + config.sseIdleTimeout = defaultSSEIdleTimeout + config.sseMaxRetries = defaultSSEMaxRetries + config.sseReconnectBaseDelay = defaultSSEReconnectBaseDelay + config.sseReconnectOnStreamEnd = true + for _, option := range options { + if option == nil { + return nil, fmt.Errorf("client option must not be nil") + } + option(&config) + } + if config.httpClient == nil { + return nil, fmt.Errorf("HTTP client must not be nil") + } + if config.responseTimeout < 0 { + return nil, fmt.Errorf("response timeout must not be negative") + } + if config.sseIdleTimeout < 0 { + return nil, fmt.Errorf("SSE idle timeout must not be negative") + } + if config.sseMaxRetries < 0 || config.sseMaxRetries > maxSSERetries { + return nil, fmt.Errorf("SSE max retries must be between 0 and %d", maxSSERetries) + } + if config.sseReconnectBaseDelay < 0 { + return nil, fmt.Errorf("SSE reconnect base delay must not be negative") + } + for index, editor := range config.requestEditors { + if editor == nil { + return nil, fmt.Errorf("request editor at index %d must not be nil", index) + } + } + return &Client{ + baseURL: strings.TrimRight(parsed.String(), "/"), + httpClient: config.httpClient, + requestEditors: append([]RequestEditorFn(nil), config.requestEditors...), + responseTimeout: config.responseTimeout, + sseIdleTimeout: config.sseIdleTimeout, + sseMaxRetries: config.sseMaxRetries, + sseReconnectBaseDelay: config.sseReconnectBaseDelay, + sseReconnectOnStreamEnd: config.sseReconnectOnStreamEnd, + }, nil +} + +func (c *Client) do(ctx context.Context, request *http.Request) (*http.Response, error) { + for index, editor := range c.requestEditors { + if err := editor(ctx, request); err != nil { + return nil, fmt.Errorf("request editor at index %d: %w", index, err) + } + } + // Keep caller cancellation and response timeout authoritative even if an + // editor replaces the request value or its context. + request = request.Clone(ctx) + return c.httpClient.Do(request) +} + +type ResponseTimeoutError struct { + Duration time.Duration +} + +func (err *ResponseTimeoutError) Error() string { + return fmt.Sprintf("response timed out after %s", err.Duration) +} + +func (err *ResponseTimeoutError) Timeout() bool { return true } + +type responseLifecycle struct { + cancel context.CancelCauseFunc + timer *time.Timer + closeOnce sync.Once +} + +func (c *Client) responseContext(parent context.Context) (context.Context, *responseLifecycle) { + ctx, cancel := context.WithCancelCause(parent) + lifecycle := &responseLifecycle{cancel: cancel} + if c.responseTimeout > 0 { + lifecycle.timer = time.AfterFunc(c.responseTimeout, func() { + cancel(&ResponseTimeoutError{Duration: c.responseTimeout}) + }) + } + return ctx, lifecycle +} + +func (lifecycle *responseLifecycle) stopTimeout() { + if lifecycle.timer != nil { + lifecycle.timer.Stop() + } +} + +func (lifecycle *responseLifecycle) close() { + lifecycle.closeOnce.Do(func() { + lifecycle.stopTimeout() + lifecycle.cancel(context.Canceled) + }) +} + +type UnexpectedStatusError struct { + Method string + URL string + StatusCode int + Body string +} + +func (err *UnexpectedStatusError) Error() string { + if err.Body == "" { + return fmt.Sprintf("%s %s returned unexpected HTTP status %d", err.Method, err.URL, err.StatusCode) + } + return fmt.Sprintf("%s %s returned unexpected HTTP status %d: %s", err.Method, err.URL, err.StatusCode, err.Body) +} + +type GetFileParams struct { + Key string +} + +type GetFileResponse struct { + StatusCode int + Raw *http.Response + Status200 *[]byte +} + +func (c *Client) NewGetFileRequest(ctx context.Context, params GetFileParams) (*http.Request, error) { + if ctx == nil { + return nil, fmt.Errorf("build GetFile request: context must not be nil") + } + if params.Key == "" { + return nil, fmt.Errorf("build GetFile request: required parameter key is empty") + } + path := "/files/{key}" + + path = strings.ReplaceAll(path, "{key}", url.PathEscape(fmt.Sprint(params.Key))) + endpoint, err := url.Parse(c.baseURL + path) + if err != nil { + return nil, fmt.Errorf("build GetFile URL: %w", err) + } + req, err := http.NewRequestWithContext(ctx, "GET", endpoint.String(), nil) + if err != nil { + return nil, fmt.Errorf("build GetFile request: %w", err) + } + req.Header.Set("Accept", "*/*") + return req, nil +} + +func (c *Client) GetFile(ctx context.Context, params GetFileParams) (*GetFileResponse, error) { + + req, err := c.NewGetFileRequest(ctx, params) + if err != nil { + return nil, err + } + responseCtx, lifecycle := c.responseContext(ctx) + req = req.Clone(responseCtx) + keepLifecycle := false + defer func() { + if !keepLifecycle { + lifecycle.close() + } + }() + res, err := c.do(responseCtx, req) + if err != nil { + return nil, fmt.Errorf("execute GetFile request: %w", err) + } + if res == nil { + return nil, fmt.Errorf("execute GetFile request: HTTP client returned nil response") + } + + result := &GetFileResponse{StatusCode: res.StatusCode, Raw: res} + switch res.StatusCode { + case 200: + rawBody, err := io.ReadAll(io.LimitReader(res.Body, maxDecodedBodyBytes+1)) + _ = res.Body.Close() + if err != nil { + return nil, fmt.Errorf("read GetFile status 200 response: %w", err) + } + if len(rawBody) > maxDecodedBodyBytes { + return nil, fmt.Errorf("read GetFile status 200 response: body exceeds %d bytes", maxDecodedBodyBytes) + } + result.Status200 = &rawBody + return result, nil + case 404: + _ = res.Body.Close() + return result, nil + default: + rawBody, readErr := io.ReadAll(io.LimitReader(res.Body, maxDiagnosticBodyBytes)) + _ = res.Body.Close() + if readErr != nil { + return nil, fmt.Errorf("read unexpected GetFile response status %d: %w", res.StatusCode, readErr) + } + return nil, &UnexpectedStatusError{ + Method: req.Method, + URL: req.URL.String(), + StatusCode: res.StatusCode, + Body: strings.TrimSpace(string(rawBody)), + } + } +} + +type SSEIdleTimeoutError struct { + Duration time.Duration +} + +func (err *SSEIdleTimeoutError) Error() string { + return fmt.Sprintf("SSE stream was idle for %s", err.Duration) +} + +func (err *SSEIdleTimeoutError) Timeout() bool { return true } + +type idleTimeoutBody struct { + body io.ReadCloser + duration time.Duration + onTimeout func() + + mu sync.Mutex + timer *time.Timer + timedOut bool + closed bool + closeOnce sync.Once + closeErr error +} + +func newIdleTimeoutBody(body io.ReadCloser, duration time.Duration, onTimeout func()) io.ReadCloser { + if duration == 0 { + return body + } + wrapped := &idleTimeoutBody{ + body: body, + duration: duration, + onTimeout: onTimeout, + } + wrapped.timer = time.AfterFunc(duration, wrapped.expire) + return wrapped +} + +func (body *idleTimeoutBody) expire() { + body.mu.Lock() + if body.closed { + body.mu.Unlock() + return + } + body.timedOut = true + body.mu.Unlock() + if body.onTimeout != nil { + body.onTimeout() + } + _ = body.body.Close() +} + +func (body *idleTimeoutBody) Read(buffer []byte) (int, error) { + read, err := body.body.Read(buffer) + body.mu.Lock() + if read > 0 && !body.timedOut && !body.closed { + body.timer.Reset(body.duration) + } + timedOut := body.timedOut + body.mu.Unlock() + if timedOut && err != nil { + return read, &SSEIdleTimeoutError{Duration: body.duration} + } + return read, err +} + +func (body *idleTimeoutBody) Close() error { + body.closeOnce.Do(func() { + body.mu.Lock() + body.closed = true + body.timer.Stop() + body.mu.Unlock() + body.closeErr = body.body.Close() + }) + return body.closeErr +} + +type SSEStream[T any] struct { + body io.ReadCloser + scanner *bufio.Scanner + closeOnce sync.Once + nextMu sync.Mutex + data []string + currentEvent string + lastEvent string + finished bool + closeErr error + cleanup func() +} + +func NewSSEStream[T any](body io.ReadCloser) *SSEStream[T] { + return newSSEStream[T](body, defaultSSEIdleTimeout, nil) +} + +func newSSEStream[T any](body io.ReadCloser, idleTimeout time.Duration, cleanup func()) *SSEStream[T] { + body = newIdleTimeoutBody(body, idleTimeout, cleanup) + return newSSEStreamWithoutIdle[T](body, cleanup) +} + +func newReconnectingSSEStream[T any](body io.ReadCloser, cleanup func()) *SSEStream[T] { + return newSSEStreamWithoutIdle[T](body, cleanup) +} + +func newSSEStreamWithoutIdle[T any](body io.ReadCloser, cleanup func()) *SSEStream[T] { + scanner := bufio.NewScanner(body) + scanner.Buffer(make([]byte, 64<<10), maxSSEEventBytes) + return &SSEStream[T]{body: body, scanner: scanner, cleanup: cleanup} +} + +// EventName returns the event field associated with the item most recently +// returned by Next. An omitted event field produces an empty string. +func (stream *SSEStream[T]) EventName() string { + stream.nextMu.Lock() + defer stream.nextMu.Unlock() + return stream.lastEvent +} + +// Next returns one decoded SSE data payload without buffering the full stream. +// The boolean is false after clean EOF. Close ends consumption early. +func (stream *SSEStream[T]) Next(ctx context.Context) (T, bool, error) { + stream.nextMu.Lock() + defer stream.nextMu.Unlock() + + var zero T + if stream.finished { + return zero, false, nil + } + if err := ctx.Err(); err != nil { + _ = stream.Close() + return zero, false, err + } + wake := make(chan struct{}) + go func() { + select { + case <-ctx.Done(): + _ = stream.Close() + case <-wake: + } + }() + defer close(wake) + + for stream.scanner.Scan() { + line := stream.scanner.Text() + if line == "" { + decoded, ok, err := stream.decodeEvent() + if ok || err != nil { + return decoded, ok, err + } + continue + } + if strings.HasPrefix(line, ":") { + continue + } + field, value, found := strings.Cut(line, ":") + if !found { + value = "" + } + value = strings.TrimPrefix(value, " ") + switch field { + case "data": + stream.data = append(stream.data, value) + case "event": + stream.currentEvent = value + } + } + if err := ctx.Err(); err != nil { + stream.finished = true + _ = stream.Close() + return zero, false, err + } + if err := stream.scanner.Err(); err != nil { + stream.finished = true + _ = stream.Close() + return zero, false, fmt.Errorf("read SSE stream: %w", err) + } + stream.finished = true + decoded, ok, err := stream.decodeEvent() + _ = stream.Close() + return decoded, ok, err +} + +func (stream *SSEStream[T]) decodeEvent() (T, bool, error) { + var zero T + payload := strings.Join(stream.data, "\n") + stream.data = nil + stream.lastEvent = stream.currentEvent + stream.currentEvent = "" + if strings.TrimSpace(payload) == "" { + return zero, false, nil + } + var decoded T + if err := json.Unmarshal([]byte(payload), &decoded); err != nil { + stream.finished = true + _ = stream.Close() + return zero, false, fmt.Errorf("decode SSE JSON event: %w", err) + } + return decoded, true, nil +} + +func (stream *SSEStream[T]) Close() error { + stream.closeOnce.Do(func() { + stream.closeErr = stream.body.Close() + if stream.cleanup != nil { + stream.cleanup() + } + }) + return stream.closeErr +} diff --git a/testdata/golden/binary-response-go/models.go b/testdata/golden/binary-response-go/models.go new file mode 100644 index 0000000..aa013a6 --- /dev/null +++ b/testdata/golden/binary-response-go/models.go @@ -0,0 +1,3 @@ +// Code generated by OASmith. DO NOT EDIT. + +package binaryresponse diff --git a/testdata/golden/binary-response-typescript/api.ts b/testdata/golden/binary-response-typescript/api.ts new file mode 100644 index 0000000..4c5ff91 --- /dev/null +++ b/testdata/golden/binary-response-typescript/api.ts @@ -0,0 +1,208 @@ +// Code generated by OASmith. DO NOT EDIT. + + +export type FetchInterceptor = (chain: FetchInterceptorChain) => Promise; + +export type FetchInterceptorChain = { + request: Request; + proceed(request?: Request): Promise; +}; + +export type ClientOptions = { + baseURL: string; + fetch?: typeof globalThis.fetch; + interceptors?: FetchInterceptor[]; + responseTimeoutMs?: number; + sseIdleTimeoutMs?: number; + sseMaxRetries?: number; + sseReconnectBaseDelayMs?: number; + sseReconnectOnStreamEnd?: boolean; +}; + +const defaultResponseTimeoutMs = 30_000; + + +export class RequiredError extends Error { + constructor(public field: string, msg?: string) { + super(msg); + this.name = 'RequiredError'; + } +} + +export class ResponseError extends Error { + constructor(public response: Response, msg?: string) { + super(msg ?? 'Response returned ' + String(response.status)); + this.name = 'ResponseError'; + } +} + +type ResponseTimeout = { + signal: AbortSignal; + stop(): void; +}; + +const activeResponseTimeoutControllers = new Set(); +const activeResponseTimeoutRequests = new Set(); + +function configuredTimeout( + options: ClientOptions, + name: 'responseTimeoutMs' | 'sseIdleTimeoutMs', + defaultValue: number, +): number | undefined { + const value = Object.prototype.hasOwnProperty.call(options, name) + ? options[name] + : defaultValue; + if (value === undefined || value === 0) { + return undefined; + } + if (!Number.isFinite(value) || value < 0) { + throw new RangeError(`${name} must be a finite non-negative number`); + } + return value; +} + + + +function responseTimeout(signal: AbortSignal, timeoutMs: number | undefined): ResponseTimeout { + if (timeoutMs === undefined) { + return { signal, stop() {} }; + } + const controller = new AbortController(); + activeResponseTimeoutControllers.add(controller); + function abortFromCaller(): void { + controller.abort(signal.reason); + } + if (signal.aborted) { + abortFromCaller(); + } else { + signal.addEventListener('abort', abortFromCaller, { once: true }); + } + const timer = setTimeout(() => { + const error = new Error(`Response timed out after ${timeoutMs}ms`); + error.name = 'TimeoutError'; + controller.abort(error); + }, timeoutMs); + return { + signal: controller.signal, + stop(): void { + clearTimeout(timer); + signal.removeEventListener('abort', abortFromCaller); + activeResponseTimeoutControllers.delete(controller); + }, + }; +} + + +async function runInterceptors( + request: Request, + interceptors: FetchInterceptor[], + fetch: typeof globalThis.fetch, +): Promise { + async function dispatch(index: number, nextRequest: Request): Promise { + const interceptor = interceptors[index]; + if (!interceptor) { + return await fetch(nextRequest); + } + return await interceptor({ + request: nextRequest, + proceed(requestOverride?: Request): Promise { + return dispatch(index + 1, requestOverride ?? nextRequest); + }, + }); + } + return await dispatch(0, request); +} + +export interface GetFileRequest { + key: string; +} + +export class DefaultApi { + private baseURL: string; + private fetch: typeof globalThis.fetch; + private interceptors: FetchInterceptor[]; + private responseTimeoutMs: number | undefined; + + + constructor(options: ClientOptions) { + this.baseURL = options.baseURL; + this.fetch = options.fetch ?? globalThis.fetch; + this.interceptors = options.interceptors ?? []; + this.responseTimeoutMs = configuredTimeout( + options, + 'responseTimeoutMs', + defaultResponseTimeoutMs, + ); + + } + + private async request( + request: Request, + initOverrides?: RequestInit, + ): Promise<{ response: Response; timeout: ResponseTimeout; request: Request }> { + const callerSignal = initOverrides?.signal ?? request.signal; + const timeout = responseTimeout(callerSignal, this.responseTimeoutMs); + const finalRequest = new Request(request, { + ...initOverrides, + signal: timeout.signal, + }); + activeResponseTimeoutRequests.add(finalRequest); + const timedRequest = { + signal: timeout.signal, + stop(): void { + activeResponseTimeoutRequests.delete(finalRequest); + timeout.stop(); + }, + }; + try { + return { + response: await runInterceptors(finalRequest, this.interceptors, this.fetch), + timeout: timedRequest, + request: finalRequest, + }; + } catch (error) { + timedRequest.stop(); + throw error; + } + } + + + getFileRequest(requestParameters: GetFileRequest): Request { + if (requestParameters['key'] === null || requestParameters['key'] === undefined) { + throw new RequiredError('key', 'Required parameter "key" was null or undefined when calling getFile().'); + } + + const headerParameters: Record = {}; + return new Request(this.baseURL + `/files/${encodeURIComponent(requestParameters['key'])}`, { + method: 'GET', + headers: headerParameters, + + }); + } + + async getFileResult(requestParameters: GetFileRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: Blob; raw: Response } | { status: 404; raw: Response }> { + const timedResponse = await this.request(this.getFileRequest(requestParameters), initOverrides); + + const response = timedResponse.response; + try { + if (response.status === 200) { + const body: Blob = await response.blob(); + return { status: 200, body, raw: response }; + } + if (response.status === 404) { + return { status: 404, raw: response }; + } + throw new ResponseError(response, `Unexpected response status ${response.status}`); + } finally { + timedResponse.timeout.stop(); + } + } + + async getFile(key: string, initOverrides?: RequestInit): Promise { + const response = await this.getFileResult({ key }, initOverrides); + if (response.status === 200) { + return response.body; + } + throw new ResponseError(response.raw); + } +} diff --git a/testdata/golden/binary-response-typescript/types.ts b/testdata/golden/binary-response-typescript/types.ts new file mode 100644 index 0000000..308fe35 --- /dev/null +++ b/testdata/golden/binary-response-typescript/types.ts @@ -0,0 +1,2 @@ +// Code generated by OASmith. DO NOT EDIT. + diff --git a/testdata/golden/private-typescript/api.ts b/testdata/golden/private-typescript/api.ts index 7e87cd7..7730b4c 100644 --- a/testdata/golden/private-typescript/api.ts +++ b/testdata/golden/private-typescript/api.ts @@ -39,7 +39,6 @@ import type { UpdateShow, UploadSessionID, User, - ValidationErr, } from './types.ts'; export type FetchInterceptor = (chain: FetchInterceptorChain) => Promise; @@ -784,7 +783,7 @@ export class DefaultApi { }); } - async verifyEmailResult(requestParameters: VerifyEmailRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: Session; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response }> { + async verifyEmailResult(requestParameters: VerifyEmailRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: Session; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response }> { const timedResponse = await this.request(this.verifyEmailRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -794,7 +793,8 @@ export class DefaultApi { return { status: 201, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -828,7 +828,7 @@ export class DefaultApi { }); } - async createGoogleSignupSessionResult(requestParameters: CreateGoogleSignupSessionRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: Session; raw: Response } | { status: 400; body: ValidationErr; raw: Response }> { + async createGoogleSignupSessionResult(requestParameters: CreateGoogleSignupSessionRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: Session; raw: Response } | { status: 400; body: Blob; raw: Response }> { const timedResponse = await this.request(this.createGoogleSignupSessionRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -838,7 +838,8 @@ export class DefaultApi { return { status: 201, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } throw new ResponseError(response, `Unexpected response status ${response.status}`); } finally { @@ -869,7 +870,7 @@ export class DefaultApi { }); } - async createPasswordLoginSessionResult(requestParameters: CreatePasswordLoginSessionRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: Session; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response } | { status: 403; raw: Response }> { + async createPasswordLoginSessionResult(requestParameters: CreatePasswordLoginSessionRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: Session; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response } | { status: 403; raw: Response }> { const timedResponse = await this.request(this.createPasswordLoginSessionRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -879,7 +880,8 @@ export class DefaultApi { return { status: 201, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -916,7 +918,7 @@ export class DefaultApi { }); } - async confirmPasswordResetResult(requestParameters: ConfirmPasswordResetRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: Session; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response }> { + async confirmPasswordResetResult(requestParameters: ConfirmPasswordResetRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: Session; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response }> { const timedResponse = await this.request(this.confirmPasswordResetRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -926,7 +928,8 @@ export class DefaultApi { return { status: 201, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -960,7 +963,7 @@ export class DefaultApi { }); } - async requestPasswordResetResult(requestParameters: RequestPasswordResetRequest, initOverrides?: RequestInit): Promise<{ status: 202; raw: Response } | { status: 400; body: ValidationErr; raw: Response }> { + async requestPasswordResetResult(requestParameters: RequestPasswordResetRequest, initOverrides?: RequestInit): Promise<{ status: 202; raw: Response } | { status: 400; body: Blob; raw: Response }> { const timedResponse = await this.request(this.requestPasswordResetRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -969,7 +972,8 @@ export class DefaultApi { return { status: 202, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } throw new ResponseError(response, `Unexpected response status ${response.status}`); } finally { @@ -1000,7 +1004,7 @@ export class DefaultApi { }); } - async createPasswordSignupSessionResult(requestParameters: CreatePasswordSignupSessionRequest, initOverrides?: RequestInit): Promise<{ status: 202; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 409; raw: Response }> { + async createPasswordSignupSessionResult(requestParameters: CreatePasswordSignupSessionRequest, initOverrides?: RequestInit): Promise<{ status: 202; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 409; raw: Response }> { const timedResponse = await this.request(this.createPasswordSignupSessionRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -1009,7 +1013,8 @@ export class DefaultApi { return { status: 202, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 409) { return { status: 409, raw: response }; @@ -1037,7 +1042,7 @@ export class DefaultApi { }); } - async whoamiResult(initOverrides?: RequestInit): Promise<{ status: 200; body: User; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response }> { + async whoamiResult(initOverrides?: RequestInit): Promise<{ status: 200; body: User; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response }> { const timedResponse = await this.request(this.whoamiRequest(), initOverrides); const response = timedResponse.response; @@ -1047,7 +1052,8 @@ export class DefaultApi { return { status: 200, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1075,7 +1081,7 @@ export class DefaultApi { }); } - async listAPIKeysResult(initOverrides?: RequestInit): Promise<{ status: 200; body: readonly ListedAPIKey[]; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response }> { + async listAPIKeysResult(initOverrides?: RequestInit): Promise<{ status: 200; body: readonly ListedAPIKey[]; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response }> { const timedResponse = await this.request(this.listAPIKeysRequest(), initOverrides); const response = timedResponse.response; @@ -1085,7 +1091,8 @@ export class DefaultApi { return { status: 200, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1119,7 +1126,7 @@ export class DefaultApi { }); } - async createAPIKeyResult(requestParameters: CreateAPIKeyRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: CreatedAPIKey; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response }> { + async createAPIKeyResult(requestParameters: CreateAPIKeyRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: CreatedAPIKey; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response }> { const timedResponse = await this.request(this.createAPIKeyRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -1129,7 +1136,8 @@ export class DefaultApi { return { status: 201, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1157,7 +1165,7 @@ export class DefaultApi { }); } - async appShellResult(initOverrides?: RequestInit): Promise<{ status: 200; body: AppShellData; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response }> { + async appShellResult(initOverrides?: RequestInit): Promise<{ status: 200; body: AppShellData; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response }> { const timedResponse = await this.request(this.appShellRequest(), initOverrides); const response = timedResponse.response; @@ -1167,7 +1175,8 @@ export class DefaultApi { return { status: 200, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1195,7 +1204,7 @@ export class DefaultApi { }); } - async defaultTeamResult(initOverrides?: RequestInit): Promise<{ status: 200; body: Team; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response } | { status: 404; raw: Response }> { + async defaultTeamResult(initOverrides?: RequestInit): Promise<{ status: 200; body: Team; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response } | { status: 404; raw: Response }> { const timedResponse = await this.request(this.defaultTeamRequest(), initOverrides); const response = timedResponse.response; @@ -1205,7 +1214,8 @@ export class DefaultApi { return { status: 200, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1240,7 +1250,7 @@ export class DefaultApi { }); } - async showPageResult(requestParameters: ShowPageRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: ShowPage; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response } | { status: 404; raw: Response }> { + async showPageResult(requestParameters: ShowPageRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: ShowPage; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response } | { status: 404; raw: Response }> { const timedResponse = await this.request(this.showPageRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -1250,7 +1260,8 @@ export class DefaultApi { return { status: 200, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1285,7 +1296,7 @@ export class DefaultApi { }); } - async showsPageResult(requestParameters: ShowsPageRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: ShowsPage; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response } | { status: 404; raw: Response }> { + async showsPageResult(requestParameters: ShowsPageRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: ShowsPage; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response } | { status: 404; raw: Response }> { const timedResponse = await this.request(this.showsPageRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -1295,7 +1306,8 @@ export class DefaultApi { return { status: 200, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1332,7 +1344,7 @@ export class DefaultApi { }); } - async createTeamResult(requestParameters: CreateTeamRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: Team; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response }> { + async createTeamResult(requestParameters: CreateTeamRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: Team; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response }> { const timedResponse = await this.request(this.createTeamRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -1342,7 +1354,8 @@ export class DefaultApi { return { status: 201, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1380,7 +1393,7 @@ export class DefaultApi { }); } - async createImageUploadPresignResult(requestParameters: CreateImageUploadPresignRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: CreatedImageUploadPresign; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response } | { status: 404; raw: Response }> { + async createImageUploadPresignResult(requestParameters: CreateImageUploadPresignRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: CreatedImageUploadPresign; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response } | { status: 404; raw: Response }> { const timedResponse = await this.request(this.createImageUploadPresignRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -1390,7 +1403,8 @@ export class DefaultApi { return { status: 201, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1431,7 +1445,7 @@ export class DefaultApi { }); } - async createMediaMultipartUploadResult(requestParameters: CreateMediaMultipartUploadRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: CreatedMediaMultipartUpload; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response } | { status: 404; raw: Response }> { + async createMediaMultipartUploadResult(requestParameters: CreateMediaMultipartUploadRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: CreatedMediaMultipartUpload; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response } | { status: 404; raw: Response }> { const timedResponse = await this.request(this.createMediaMultipartUploadRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -1441,7 +1455,8 @@ export class DefaultApi { return { status: 201, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1482,7 +1497,7 @@ export class DefaultApi { }); } - async createMediaUploadPresignResult(requestParameters: CreateMediaUploadPresignRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: CreatedMediaUploadPresign; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response } | { status: 404; raw: Response }> { + async createMediaUploadPresignResult(requestParameters: CreateMediaUploadPresignRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: CreatedMediaUploadPresign; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response } | { status: 404; raw: Response }> { const timedResponse = await this.request(this.createMediaUploadPresignRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -1492,7 +1507,8 @@ export class DefaultApi { return { status: 201, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1537,7 +1553,7 @@ export class DefaultApi { }); } - async completeMediaMultipartUploadResult(requestParameters: CompleteMediaMultipartUploadRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: CompletedMediaMultipartUpload; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response } | { status: 404; raw: Response }> { + async completeMediaMultipartUploadResult(requestParameters: CompleteMediaMultipartUploadRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: CompletedMediaMultipartUpload; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response } | { status: 404; raw: Response }> { const timedResponse = await this.request(this.completeMediaMultipartUploadRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -1547,7 +1563,8 @@ export class DefaultApi { return { status: 200, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1592,7 +1609,7 @@ export class DefaultApi { }); } - async presignMediaUploadPartsResult(requestParameters: PresignMediaUploadPartsRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: PresignedMediaUploadParts; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response } | { status: 404; raw: Response }> { + async presignMediaUploadPartsResult(requestParameters: PresignMediaUploadPartsRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: PresignedMediaUploadParts; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response } | { status: 404; raw: Response }> { const timedResponse = await this.request(this.presignMediaUploadPartsRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -1602,7 +1619,8 @@ export class DefaultApi { return { status: 201, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1637,7 +1655,7 @@ export class DefaultApi { }); } - async listShowsResult(requestParameters: ListShowsRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: readonly Show[]; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response }> { + async listShowsResult(requestParameters: ListShowsRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: readonly Show[]; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response }> { const timedResponse = await this.request(this.listShowsRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -1647,7 +1665,8 @@ export class DefaultApi { return { status: 200, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1685,7 +1704,7 @@ export class DefaultApi { }); } - async createShowResult(requestParameters: CreateShowRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: Show; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response } | { status: 403; raw: Response } | { status: 409; raw: Response }> { + async createShowResult(requestParameters: CreateShowRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: Show; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response } | { status: 403; raw: Response } | { status: 409; raw: Response }> { const timedResponse = await this.request(this.createShowRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -1695,7 +1714,8 @@ export class DefaultApi { return { status: 201, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1743,7 +1763,7 @@ export class DefaultApi { }); } - async updateShowResult(requestParameters: UpdateShowRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: Show; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response }> { + async updateShowResult(requestParameters: UpdateShowRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: Show; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response }> { const timedResponse = await this.request(this.updateShowRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -1753,7 +1773,8 @@ export class DefaultApi { return { status: 200, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1789,7 +1810,7 @@ export class DefaultApi { }); } - async listEpisodesResult(requestParameters: ListEpisodesRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: readonly Episode[]; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response }> { + async listEpisodesResult(requestParameters: ListEpisodesRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: readonly Episode[]; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response }> { const timedResponse = await this.request(this.listEpisodesRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -1799,7 +1820,8 @@ export class DefaultApi { return { status: 200, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1841,7 +1863,7 @@ export class DefaultApi { }); } - async createEpisodeResult(requestParameters: CreateEpisodeRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: Episode; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response }> { + async createEpisodeResult(requestParameters: CreateEpisodeRequest, initOverrides?: RequestInit): Promise<{ status: 201; body: Episode; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response }> { const timedResponse = await this.request(this.createEpisodeRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -1851,7 +1873,8 @@ export class DefaultApi { return { status: 201, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1897,7 +1920,7 @@ export class DefaultApi { }); } - async updateEpisodeResult(requestParameters: UpdateEpisodeRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: Episode; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response }> { + async updateEpisodeResult(requestParameters: UpdateEpisodeRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: Episode; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response }> { const timedResponse = await this.request(this.updateEpisodeRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -1907,7 +1930,8 @@ export class DefaultApi { return { status: 200, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -1948,7 +1972,7 @@ export class DefaultApi { }); } - async episodeProcessingEventsResult(requestParameters: EpisodeProcessingEventsRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: AsyncIterable; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 401; raw: Response } | { status: 403; raw: Response } | { status: 404; raw: Response }> { + async episodeProcessingEventsResult(requestParameters: EpisodeProcessingEventsRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: AsyncIterable; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 401; raw: Response } | { status: 403; raw: Response } | { status: 404; raw: Response }> { const sseResponse = await this.sseRequest(this.episodeProcessingEventsRequest(requestParameters), initOverrides); const timedResponse = sseResponse.attempt; let keepSSE = false; @@ -1978,7 +2002,8 @@ export class DefaultApi { return { status: 200, body: parseEventStream(raw, undefined), raw }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 401) { return { status: 401, raw: response }; @@ -2016,7 +2041,7 @@ export class DefaultApi { }); } - async listTestEmailsResult(initOverrides?: RequestInit): Promise<{ status: 200; body: readonly TestEmail[]; raw: Response } | { status: 400; body: ValidationErr; raw: Response } | { status: 404; raw: Response }> { + async listTestEmailsResult(initOverrides?: RequestInit): Promise<{ status: 200; body: readonly TestEmail[]; raw: Response } | { status: 400; body: Blob; raw: Response } | { status: 404; raw: Response }> { const timedResponse = await this.request(this.listTestEmailsRequest(), initOverrides); const response = timedResponse.response; @@ -2026,7 +2051,8 @@ export class DefaultApi { return { status: 200, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } if (response.status === 404) { return { status: 404, raw: response }; @@ -2058,7 +2084,7 @@ export class DefaultApi { }); } - async renderShowRSSFeedResult(requestParameters: RenderShowRSSFeedRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: string; raw: Response } | { status: 400; body: ValidationErr; raw: Response }> { + async renderShowRSSFeedResult(requestParameters: RenderShowRSSFeedRequest, initOverrides?: RequestInit): Promise<{ status: 200; body: string; raw: Response } | { status: 400; body: Blob; raw: Response }> { const timedResponse = await this.request(this.renderShowRSSFeedRequest(requestParameters), initOverrides); const response = timedResponse.response; @@ -2068,7 +2094,8 @@ export class DefaultApi { return { status: 200, body, raw: response }; } if (response.status === 400) { - return { status: 400, raw: response }; + const body: Blob = await response.blob(); + return { status: 400, body, raw: response }; } throw new ResponseError(response, `Unexpected response status ${response.status}`); } finally {