Fix generated client transport shape (#137)

* fix generated client transport shape

* test(runtime): align Pydantic serialization tests with new transport shape

PR #137 unifies request body construction through the new ClientRequest
DTO: bodies are JSON-encoded to bytes once and passed to httpx as
`content=<bytes>` regardless of whether the input was a Pydantic model
or a plain dict. The two json_data tests in test_pydantic_serialization
were still asserting the old `json={...}` kwarg shape, so they failed
in CI.

Update both tests (sync + async) to verify the new contract:

- `json` kwarg is never present
- `content` round-trips back to the expected dict via json.loads
- Content-Type: application/json is set on the request headers

* address review feedback: simpler transport DTOs

Per @avkonst's review on PR #137, plus a couple of related cleanups:

- Drop the `Client` prefix from transport DTO names across all three
  languages: `Client{Request,Headers,Response}` -> `{Request,Headers,Response}`.
  The transport interfaces stay `Client` / `AsyncClient` (they are
  clients); only the data shapes lose the prefix.
- Drop the `method` field from `Request` (TS, Rust, Python) and from
  the runtime _make_request / _make_sse_request signatures and the
  generated client method bodies. Every reflectapi endpoint is POST by
  design, so transports hardcode it; carrying "POST" through every
  call and DTO was dead surface.
- TS SSE switch back to native `new TextDecoderStream()`. The custom
  `__text_decoder_stream` was a TS-variance workaround, not a runtime
  improvement. A single `as unknown as ReadableWritablePair<string, Uint8Array>`
  cast bridges the BufferSource/Uint8Array variance mismatch in lib.dom.
- TS `__read_response_body` now defers to the platform via
  `new (globalThis as any).Response(body).text()` instead of the manual
  reader+decoder loop. One line, well-tested, no chunk-boundary debate.

Reviewed and rejected:
- The Codex P2 "avoid serializing absent body as null" — false positive.
  The empty-body path produces `b""` and the `if request.body:` guard
  at the dispatch site already skips the content kwarg.

Carved out as a follow-up:
- Andrey's `?? "{}"` fallback question: stop sending a body for
  endpoints with no input type. Touches the wire protocol on both
  client and server, so it's its own PR.

Author: hardbyte

Cargo.lock

@@ -514,7 +514,6 @@ async def check(
 
         params: dict[str, Any] = {}
         return await self._client._make_request(
-            "POST",
             path,
             params=params if params else None,
             response_model=None,
@@ -541,7 +540,6 @@ def cdc_events(
 
         params: dict[str, Any] = {}
         return self._client._make_sse_request(
-            "POST",
             path,
             params=params if params else None,
             headers_model=headers,
@@ -566,7 +564,6 @@ async def create(
 
         params: dict[str, Any] = {}
         return await self._client._make_request(
-            "POST",
             path,
             params=params if params else None,
             json_model=data,
@@ -602,7 +599,6 @@ async def delete(
 
         params: dict[str, Any] = {}
         return await self._client._make_request(
-            "POST",
             path,
             params=params if params else None,
             json_model=data,
@@ -624,7 +620,6 @@ async def get_first(
 
         params: dict[str, Any] = {}
         return await self._client._make_request(
-            "POST",
             path,
             params=params if params else None,
             headers_model=headers,
@@ -651,7 +646,6 @@ async def list(
 
         params: dict[str, Any] = {}
         return await self._client._make_request(
-            "POST",
             path,
             params=params if params else None,
             json_model=data,
@@ -677,7 +671,6 @@ async def remove(
 
         params: dict[str, Any] = {}
         return await self._client._make_request(
-            "POST",
             path,
             params=params if params else None,
             json_model=data,
@@ -703,7 +696,6 @@ async def update(
 
         params: dict[str, Any] = {}
         return await self._client._make_request(
-            "POST",
             path,
             params=params if params else None,
             json_model=data,
@@ -746,7 +738,6 @@ def check(
 
         params: dict[str, Any] = {}
         return self._client._make_request(
-            "POST",
             path,
             params=params if params else None,
             response_model=None,
@@ -773,7 +764,6 @@ def cdc_events(
 
         params: dict[str, Any] = {}
         return self._client._make_sse_request(
-            "POST",
             path,
             params=params if params else None,
             headers_model=headers,
@@ -798,7 +788,6 @@ def create(
 
         params: dict[str, Any] = {}
         return self._client._make_request(
-            "POST",
             path,
             params=params if params else None,
             json_model=data,
@@ -834,7 +823,6 @@ def delete(
 
         params: dict[str, Any] = {}
         return self._client._make_request(
-            "POST",
             path,
             params=params if params else None,
             json_model=data,
@@ -856,7 +844,6 @@ def get_first(
 
         params: dict[str, Any] = {}
         return self._client._make_request(
-            "POST",
             path,
             params=params if params else None,
             headers_model=headers,
@@ -883,7 +870,6 @@ def list(
 
         params: dict[str, Any] = {}
         return self._client._make_request(
-            "POST",
             path,
             params=params if params else None,
             json_model=data,
@@ -909,7 +895,6 @@ def remove(
 
         params: dict[str, Any] = {}
         return self._client._make_request(
-            "POST",
             path,
             params=params if params else None,
             json_model=data,
@@ -935,7 +920,6 @@ def update(
 
         params: dict[str, Any] = {}
         return self._client._make_request(
-            "POST",
             path,
             params=params if params else None,
             json_model=data,

reflectapi-demo/clients/python/generated.py

@@ -12,16 +12,33 @@ export interface RequestOptions {
   signal?: AbortSignal;
 }
 
+// Transport DTOs. Method is intentionally absent: every reflectapi
+// endpoint is POST by design, so transports hardcode it; if that ever
+// changes it's a wire-protocol break and clients regenerate.
+export interface Request {
+  path: string;
+  headers: Record<string, string>;
+  body: Uint8Array;
+  signal?: AbortSignal;
+}
+
+export interface Headers {
+  get(name: string): string | null;
+}
+
+export interface Response {
+  status: number;
+  headers: Headers;
+  body: ReadableStream<Uint8Array> | null;
+}
+
 export interface Client {
-  request(
-    path: string,
-    body: string,
-    headers: Record<string, string>,
-    options?: RequestOptions,
-  ): Promise<Response>;
+  request(request: Request): Promise<Response>;
 }
 
-export type NullToEmptyObject<T> = T extends null ? {} : T;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+export type NullToEmptyObject<T> =
+  IsAny<T> extends true ? unknown : T extends null ? {} : T;
 
 export type AsyncResult<T, E> = Promise<Result<T, Err<E>>>;
 
@@ -190,9 +207,14 @@ export function __request<I, H, O, E>(
     }
   }
   return client
-    .request(path, JSON.stringify(input), hdrs, options)
+    .request({
+      path,
+      headers: hdrs,
+      body: new TextEncoder().encode(JSON.stringify(input) ?? "{}"),
+      signal: options?.signal,
+    })
     .then(async (response) => {
-      const response_body = await response.text();
+      const response_body = await __read_response_body(response);
       if (response.status >= 200 && response.status < 300) {
         try {
           return new Result<O, Err<E>>({ ok: JSON.parse(response_body) as O });
@@ -245,22 +267,37 @@ export async function __stream_request<I, H, O, E>(
     }
   }
   try {
-    const response = await client.request(
+    const response = await client.request({
       path,
-      JSON.stringify(input),
-      hdrs,
-      options,
-    );
+      headers: hdrs,
+      body: new TextEncoder().encode(JSON.stringify(input) ?? "{}"),
+      signal: options?.signal,
+    });
     if (response.status >= 200 && response.status < 300) {
+      const contentType = response.headers.get("content-type") || "";
+      if (!contentType.toLowerCase().includes("text/event-stream")) {
+        return new Result<AsyncIterable<O>, Err<E>>({
+          err: new Err({
+            other_err: `expected text/event-stream response, got ${contentType || "missing content-type"}`,
+          }),
+        });
+      }
+      if (!response.body || typeof response.body.pipeThrough !== "function") {
+        return new Result<AsyncIterable<O>, Err<E>>({
+          err: new Err({
+            other_err: "expected response body to be a WHATWG ReadableStream",
+          }),
+        });
+      }
       const stream = __sse_to_async_iterable<O>(response, options);
       return new Result<AsyncIterable<O>, Err<E>>({ ok: stream });
     } else if (response.status >= 500) {
-      const body = await response.text();
+      const body = await __read_response_body(response);
       return new Result<AsyncIterable<O>, Err<E>>({
         err: new Err({ other_err: `[${response.status}] ${body}` }),
       });
     } else {
-      const body = await response.text();
+      const body = await __read_response_body(response);
       try {
         return new Result<AsyncIterable<O>, Err<E>>({
           err: new Err({ application_err: JSON.parse(body) as E }),
@@ -284,16 +321,31 @@ async function* __sse_to_async_iterable<O>(
 ): AsyncIterable<O> {
   const body = response.body;
   if (!body) return;
+  // Native TextDecoderStream handles cross-chunk multi-byte sequences.
+  // The cast bridges a TS variance mismatch: TextDecoderStream is typed
+  // `TransformStream<BufferSource, string>` while pipeThrough demands
+  // exact `Uint8Array` writable. The runtime behaviour is correct.
   const reader = body
-    .pipeThrough(new TextDecoderStream())
+    .pipeThrough(
+      new TextDecoderStream() as unknown as ReadableWritablePair<
+        string,
+        Uint8Array
+      >,
+    )
     .pipeThrough(new __EventSourceParserStream())
     .getReader();
   try {
     while (true) {
       if (options?.signal?.aborted) break;
       const { done, value } = await reader.read();
       if (done) break;
-      yield JSON.parse(value.data) as O;
+      try {
+        yield JSON.parse(value.data) as O;
+      } catch (e) {
+        throw new Error(
+          `SSE parse error: ${e instanceof Error ? e.message : String(e)} (raw: ${value.data})`,
+        );
+      }
     }
   } catch (e) {
     if (!options?.signal?.aborted) throw e;
@@ -302,20 +354,22 @@ async function* __sse_to_async_iterable<O>(
   }
 }
 
+async function __read_response_body(response: Response): Promise<string> {
+  if (!response.body) return "";
+  // Hand decoding to the platform; new (global) Response wraps any
+  // ReadableStream<Uint8Array> and exposes the well-tested .text() path.
+  return await new (globalThis as any).Response(response.body).text();
+}
+
 class ClientInstance {
   constructor(private base: string) {}
 
-  public request(
-    path: string,
-    body: string,
-    headers: Record<string, string>,
-    options?: RequestOptions,
-  ): Promise<Response> {
-    return (globalThis as any).fetch(`${this.base}${path}`, {
+  public request(request: Request): Promise<Response> {
+    return (globalThis as any).fetch(`${this.base}${request.path}`, {
       method: "POST",
-      headers: headers,
-      body: body,
-      signal: options?.signal,
+      headers: request.headers,
+      body: request.body,
+      signal: request.signal,
     });
   }
 }

reflectapi-demo/clients/typescript/generated.ts

@@ -14,9 +14,9 @@
     "node-fetch": "2"
   },
   "devDependencies": {
-    "@types/node": "20.11.30",
+    "@types/node": "^24.10.1",
     "@types/node-fetch": "2",
-    "typescript": "5.4.3",
+    "typescript": "^5.9.3",
     "tslib": "2.6.2"
   }
 }