rouzer 5.1.0 → 5.1.1

package/README.md

@@ -14,6 +14,7 @@ that contract to:
 - match and validate server requests before handlers run
 - type handler context from path, query/body, headers, and middleware
 - attach typed client action functions such as `client.profiles.get(...)`
+- send JSON object request bodies or raw `BodyInit` payloads
 - parse typed JSON responses, declared error responses, and NDJSON streams
 
 Rouzer optimizes for shared TypeScript route modules over language-agnostic API
@@ -106,7 +107,8 @@ const { message } = await client.hello({
 validate flat route arguments before `fetch`; server handlers validate matched
 path, query, headers, and JSON bodies before your handler runs. Per-request
 headers, abort signals, and other `RequestInit` options are passed as a second
-client action argument.
+client action argument. Routes declared with `body: http.rawBody()` pass a
+`BodyInit` payload through to `fetch` without JSON encoding.
 
 ### Typed status responses
 
@@ -151,6 +153,34 @@ const [error, user, status] = await client.getUser({ id: '42' })
 Success entries resolve as `[null, value, status]`; declared error entries
 resolve as `[error, null, status]`.
 
+### Raw request bodies
+
+Use `http.rawBody()` when an action needs to send a `BodyInit` payload such as a
+`Blob`, `Uint8Array`, `ReadableStream`, `FormData`, or string without JSON
+encoding.
+
+```ts
+export const uploadAvatar = http.post('profiles/:id/avatar', {
+  body: http.rawBody(),
+})
+
+await client.uploadAvatar({ id: '42' }, { body: file })
+```
+
+For raw-body routes without path or query input, the generated client accepts the
+body as the first argument:
+
+```ts
+export const upload = http.post('upload', {
+  body: http.rawBody(),
+})
+
+await client.upload(file, { headers: { 'content-type': file.type } })
+```
+
+Server handlers for raw-body routes read from `ctx.request` directly with Fetch
+APIs such as `arrayBuffer()`, `blob()`, `formData()`, or `text()`.
+
 ### NDJSON response streams
 
 Use `response: ndjson.$type<T>()` for endpoints that stream

package/dist/client/index.d.ts

@@ -105,7 +105,9 @@ export type ClientTree<T extends HttpRouteTree, TPrefix extends string = ''> = {
  * union of `[null, value, status]` success entries and `[error, null, status]`
  * error entries. Actions whose schema has a plugin response marker return the
  * plugin's client result type. Actions without a response marker return the raw
- * `Response`.
+ * `Response`. Raw-body actions with no path or query input accept
+ * `(body, options)`; raw-body actions with route input accept
+ * `(input, { body, ...options })`.
  */
 export type RouteFunction<T extends RouteSchema, P extends string> = T extends {
     body: RawBodySchema;

package/dist/http.d.ts

@@ -62,6 +62,12 @@ export declare function patch<const T extends RouteSchema>(schema: T): HttpActio
 declare function deleteAction<const P extends string, const T extends RouteSchema>(path: P, schema: T): HttpAction<P, T, 'DELETE'>;
 declare function deleteAction<const T extends RouteSchema>(schema: T): HttpAction<'', T, 'DELETE'>;
 export { deleteAction as delete };
-/** Declare a request body that is passed through to `fetch` without JSON encoding. */
+/**
+ * Declare a request body that is passed through to `fetch` without JSON encoding.
+ *
+ * @remarks For routes with path or query input, pass the body as
+ * `options.body`. For raw-body routes without input, generated client actions
+ * accept the body as their first argument.
+ */
 export declare function rawBody(): RawBodySchema;
 export declare function isRawBodySchema(schema: unknown): schema is RawBodySchema;

package/dist/http.js

@@ -29,7 +29,13 @@ function deleteAction(pathOrSchema, schema) {
     return action('DELETE', pathOrSchema, schema);
 }
 export { deleteAction as delete };
-/** Declare a request body that is passed through to `fetch` without JSON encoding. */
+/**
+ * Declare a request body that is passed through to `fetch` without JSON encoding.
+ *
+ * @remarks For routes with path or query input, pass the body as
+ * `options.body`. For raw-body routes without input, generated client actions
+ * accept the body as their first argument.
+ */
 export function rawBody() {
     return { __rawBody__: Symbol('rouzer.rawBody') };
 }

package/dist/types/args.d.ts

@@ -25,10 +25,12 @@ type HeaderInput<T> = T extends {
  */
 export type RouteInput<T extends RouteSchema = any, P extends string = string> = [T] extends [Any] ? any : PathInput<T, P> & QueryInput<T> & BodyInput<T>;
 /**
- * Fetch options accepted as the second argument to a generated client action.
+ * Fetch options accepted by a generated client action.
  *
  * @remarks `headers` remains optional because required route headers may be
- * supplied by `createClient({ headers })` defaults.
+ * supplied by `createClient({ headers })` defaults. Raw-body routes with path or
+ * query input accept `body` here; raw-body routes without input accept the body
+ * as the first client action argument and these options as the second.
  */
 export type RouteFetchOptions<T extends RouteSchema = any> = Omit<RequestInit, 'method' | 'body' | 'headers'> & {
     /** Headers for this request. Undefined values are removed before `fetch`. */

package/docs/context.md

@@ -85,7 +85,7 @@ Method schemas describe the request pieces Rouzer should validate:
 | Action helper                     | Request schemas                        | Notes            |
 | --------------------------------- | -------------------------------------- | ---------------- |
 | `http.get(...)`                   | `path`, `query`, `headers`, `response` | No request body. |
-| `http.post/put/patch/delete(...)` | `path`, `body`, `headers`, `response`  | No query schema. |
+| `http.post/put/patch/delete(...)` | `path`, `body`, `headers`, `response`  | No query schema. `body` is a Zod object for JSON or `http.rawBody()` for pass-through payloads. |
 
 If you omit a `path` schema, TypeScript infers path params from the pattern and
 server handlers receive them as strings. Add a Zod `path` schema when you need
@@ -215,7 +215,9 @@ requests with an `Origin` header.
 `routes`, with action functions such as `client.profiles.get(args)`.
 Generated action functions accept a flattened first argument containing path,
 query, and JSON body fields. Per-request `RequestInit` options, including
-headers and abort signals, are passed as the optional second argument.
+headers and abort signals, are passed as the optional second argument. For
+`http.rawBody()` routes, the raw `BodyInit` payload is passed through to `fetch`
+without JSON encoding.
 
 Generated action functions include:
 
@@ -248,8 +250,8 @@ route actions named `config` remain available as `client.config(...)`.
    are needed.
 3. Create a client with the same route tree, plus matching client response
    plugins when needed.
-4. Client action calls validate `path`, `query`, `body`, and `headers` before
-   `fetch`.
+4. Client action calls validate `path`, `query`, JSON object `body`, and
+   `headers` before `fetch`. Raw bodies are passed through without validation.
 5. The router matches the request, validates the matched inputs, and calls the
    handler.
 6. Plain handler results become JSON responses, response-map helpers choose
@@ -259,7 +261,8 @@ route actions named `config` remain available as `client.config(...)`.
 On the server, `path`, `query`, and `headers` values originate as strings. Rouzer
 coerces Zod `number` schemas with `Number(value)` and Zod `boolean` schemas from
 `"true"` and `"false"`. JSON request bodies are parsed and validated without that
-string-coercion step.
+string-coercion step. Raw request bodies declared with `http.rawBody()` are not
+parsed by Rouzer.
 
 ## Common tasks
 
@@ -412,8 +415,26 @@ await client.uploadAvatar(
 )
 ```
 
-Path fields still live in the flat first argument. The raw body itself is passed
-as `body` in the second argument because it is a `RequestInit` value.
+When a raw-body route has path or query input, path/query fields still live in
+the flat first argument. The raw body itself is passed as `body` in the second
+argument because it is a `RequestInit` value.
+
+For raw-body routes without path or query input, the generated client action
+accepts the body as the first argument and fetch options as the second:
+
+```ts
+export const upload = http.post('uploads', {
+  body: http.rawBody(),
+})
+
+await client.upload(file, {
+  headers: { 'content-type': file.type },
+})
+```
+
+Server handlers for raw-body routes read from `ctx.request` directly with Fetch
+APIs such as `arrayBuffer()`, `blob()`, `formData()`, or `text()`. Rouzer does
+not parse or validate raw request bodies.
 
 ### Return custom responses
 
@@ -515,8 +536,10 @@ await client.profiles.update({ id: '42', name: 'Ada' })
   strings passed to `http.resource(...)` and action helpers.
 - Path, query, and JSON body fields are flattened into the first client action
   argument. Per-request `RequestInit` fields, such as `signal`, `credentials`,
-  and `headers`, belong in the second argument. `method` is reserved by Rouzer;
-  `body` is only accepted in the second argument for `http.rawBody()` actions.
+  and `headers`, belong in the second argument. `method` is reserved by Rouzer.
+  For `http.rawBody()` actions, `body` is accepted in the second argument when
+  the route has path or query input; raw-body actions without route input accept
+  the body as the first argument.
 - The HTTP action API has no `ALL` fallback route. Declare explicit actions for
   supported methods.
 - Rouzer does not automatically set `Access-Control-Allow-Credentials`; set it in

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rouzer",
-  "version": "5.1.0",
+  "version": "5.1.1",
   "type": "module",
   "exports": {
     ".": {