rouzer 3.2.0 → 4.0.0

package/README.md

@@ -2,6 +2,7 @@
 
 Rouzer lets you declare an HTTP route tree once and share its TypeScript types
 and Zod validation between a Hattip-compatible server and a typed fetch client.
+The client is always created from that route tree.
 
 ## What it does
 
@@ -45,7 +46,7 @@ Consider something else if:
 - Zod v4 or newer
 - a Hattip adapter when using `createRouter(...)`
 - a Fetch API implementation when using `createClient(...)`
-- an absolute `baseURL` for generated client URLs
+- an absolute `baseURL` and shared `routes` tree for generated client URLs
 
 ## Installation
 
@@ -101,9 +102,9 @@ const { message } = await client.hello({
 })
 ```
 
-`handler` can be mounted with any Hattip adapter. Client action calls validate
-route arguments before `fetch`; server handlers validate matched path, query,
-headers, and JSON bodies before your handler runs.
+`handler` can be mounted with any Hattip adapter. Generated client action calls
+validate route arguments before `fetch`; server handlers validate matched path,
+query, headers, and JSON bodies before your handler runs.
 
 ### Typed status responses
 

package/dist/client/index.d.ts

@@ -2,7 +2,6 @@ import { Promisable } from '../common.js';
 import type { HttpAction, HttpResource, HttpRouteTree } from '../http.js';
 import { type ClientResponsePlugin } from '../response.js';
 import type { RouteArgs } from '../types/args.js';
-import type { RouteRequest } from '../types/request.js';
 import type { InferRouteResponse } from '../types/response.js';
 import type { RouteSchema } from '../types/schema.js';
 /** Client type inferred from an HTTP route tree passed to `createClient`. */
@@ -10,9 +9,8 @@ export type RouzerClient<TRoutes extends HttpRouteTree = Record<string, never>>
 /**
  * Create a typed fetch client for an HTTP route tree.
  *
- * @remarks The returned client always includes `request(...)` for raw responses
- * and `json(...)` for parsed JSON. Passing `routes` also mirrors the resource
- * tree and attaches direct action functions such as `client.users.list(...)`.
+ * @remarks The returned client mirrors the resource tree and attaches direct
+ * action functions such as `client.users.list(...)`.
  */
 export declare function createClient<TRoutes extends HttpRouteTree = Record<string, never>>(config: {
     /**
@@ -38,22 +36,22 @@ export declare function createClient<TRoutes extends HttpRouteTree = Record<stri
      * await client.users.list({ query: { page: 1 } })
      * ```
      */
-    routes?: TRoutes;
+    routes: TRoutes;
     /** Response codec plugins used by generated action functions. */
     plugins?: readonly ClientResponsePlugin[];
     /**
-     * Custom handler for non-2xx responses from `.json()` and generated response
-     * helpers.
+     * Custom handler for non-2xx responses from generated client action
+     * functions.
      *
-     * @remarks When provided, the return value is returned from the response
-     * helper as-is; Rouzer does not automatically parse a `Response` returned by
-     * this hook.
+     * @remarks When provided, the return value is returned from the client action
+     * as-is; Rouzer does not automatically parse a `Response` returned by this
+     * hook.
      */
     onJsonError?: (response: Response) => Promisable<unknown>;
     /** Custom `fetch` implementation to use for requests. */
     fetch?: typeof globalThis.fetch;
 }): ClientTree<TRoutes, ""> & {
-    config: {
+    clientConfig: {
         /**
          * Absolute base URL used for generated request URLs.
          *
@@ -77,25 +75,21 @@ export declare function createClient<TRoutes extends HttpRouteTree = Record<stri
          * await client.users.list({ query: { page: 1 } })
          * ```
          */
-        routes?: TRoutes;
+        routes: TRoutes;
         /** Response codec plugins used by generated action functions. */
         plugins?: readonly ClientResponsePlugin[];
         /**
-         * Custom handler for non-2xx responses from `.json()` and generated response
-         * helpers.
+         * Custom handler for non-2xx responses from generated client action
+         * functions.
          *
-         * @remarks When provided, the return value is returned from the response
-         * helper as-is; Rouzer does not automatically parse a `Response` returned by
-         * this hook.
+         * @remarks When provided, the return value is returned from the client action
+         * as-is; Rouzer does not automatically parse a `Response` returned by this
+         * hook.
          */
         onJsonError?: (response: Response) => Promisable<unknown>;
         /** Custom `fetch` implementation to use for requests. */
         fetch?: typeof globalThis.fetch;
     };
-    request: <T extends RouteRequest>({ path: pathBuilder, method, args, schema, }: T) => Promise<Response & {
-        json(): Promise<T['$result']>;
-    }>;
-    json: <T extends RouteRequest>(props: T) => Promise<T['$result']>;
 };
 type Join<A extends string, B extends string> = A extends '' ? B : B extends '' ? A : `${A}/${B}`;
 /** Client object shape produced from an HTTP route tree. */

package/dist/client/index.js

@@ -6,18 +6,15 @@ import { getResponseMapPluginIds, isErrorMarker, isResponseMap, } from '../respo
 /**
  * Create a typed fetch client for an HTTP route tree.
  *
- * @remarks The returned client always includes `request(...)` for raw responses
- * and `json(...)` for parsed JSON. Passing `routes` also mirrors the resource
- * tree and attaches direct action functions such as `client.users.list(...)`.
+ * @remarks The returned client mirrors the resource tree and attaches direct
+ * action functions such as `client.users.list(...)`.
  */
 export function createClient(config) {
     const baseURL = config.baseURL.replace(/\/?$/, '/');
     const defaultHeaders = config.headers && shake(config.headers);
     const fetch = config.fetch ?? globalThis.fetch;
     const responsePlugins = createResponsePluginMap(config.plugins, 'client response');
-    if (config.routes) {
-        validateClientResponsePlugins(config.routes, responsePlugins);
-    }
+    validateClientResponsePlugins(config.routes, responsePlugins);
     async function request({ path: pathBuilder, method, args, schema, }) {
         let { path, query, body, headers, ...init } = args;
         if (schema.path) {
@@ -61,13 +58,6 @@ export function createClient(config) {
             headers: (headers ?? defaultHeaders),
         });
     }
-    async function json(props) {
-        const response = await request(props);
-        if (!response.ok) {
-            return handleResponseError(response, props);
-        }
-        return response.json();
-    }
     async function response(props) {
         const httpResponse = await request(props);
         const responseSchema = props.schema.response;
@@ -127,12 +117,8 @@ export function createClient(config) {
         throw error;
     }
     return {
-        ...(config.routes
-            ? connectTree(config.routes, '', request, response)
-            : null),
-        config,
-        request,
-        json,
+        ...connectTree(config.routes, '', request, response),
+        clientConfig: config,
     };
 }
 function connectTree(tree, prefix, request, response) {

package/dist/http.d.ts

@@ -1,5 +1,4 @@
 import { RoutePattern } from '@remix-run/route-pattern';
-import type { RouteRequestFactory } from './types/request.js';
 import type { RouteSchema } from './types/schema.js';
 /** HTTP methods supported by Rouzer action declarations. */
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
@@ -18,8 +17,6 @@ export type HttpAction<P extends string = string, T extends RouteSchema = RouteS
     method: M;
     /** Request validation and optional response type schema. */
     schema: T;
-    /** Low-level request descriptor factory for this action. */
-    request: RouteRequestFactory<T, P>;
 };
 /**
  * Path-scoped namespace in an HTTP route tree.

package/dist/http.js

@@ -34,12 +34,5 @@ function action(method, pathOrSchema, schema) {
         ? RoutePattern.parse(pathOrSchema)
         : undefined;
     schema ??= typeof pathOrSchema === 'string' ? {} : pathOrSchema;
-    const request = ((args = {}) => ({
-        schema,
-        path: path ?? RoutePattern.parse(''),
-        method,
-        args,
-        $result: undefined,
-    }));
-    return { kind: 'action', path, method, schema, request };
+    return { kind: 'action', path, method, schema };
 }

package/dist/response.d.ts

@@ -1,5 +1,7 @@
 import type { Promisable } from './common.js';
-import type { RouteRequest } from './types/request.js';
+import type { RoutePattern } from '@remix-run/route-pattern';
+import type { RouteArgs } from './types/args.js';
+import type { RouteSchema } from './types/schema.js';
 /** Runtime key carried by response plugin markers. */
 export declare const responsePluginMarker: unique symbol;
 /**
@@ -24,9 +26,16 @@ export type ClientResponsePlugin = {
     /** Decode a successful `Response` into the client action result. */
     decode(response: Response, context: {
         marker: ResponsePluginMarker<any, any>;
-        request: RouteRequest;
+        request: ClientResponsePluginRequest;
     }): Promisable<unknown>;
 };
+/** Request metadata passed to client response plugins. */
+export type ClientResponsePluginRequest = {
+    schema: RouteSchema;
+    path: RoutePattern;
+    method: string;
+    args: RouteArgs;
+};
 /** Router-side response plugin used by `createRouter({ plugins })`. */
 export type RouterResponsePlugin = {
     /** Stable response codec id matched against route response markers. */

package/dist/types/args.d.ts

@@ -32,7 +32,7 @@ type MutationArgs<T> = T extends MutationRouteSchema ? T extends {
     body?: unknown;
 } : unknown;
 /**
- * Arguments accepted by a client action function or low-level request factory.
+ * Arguments accepted by a generated client action function.
  *
  * @remarks The type is derived from an action schema and route pattern. `path`,
  * `query`, `body`, and `headers` are validated by the client before `fetch` when

package/dist/types/index.d.ts

@@ -1,7 +1,6 @@
 export type * from './args.js';
 export type * from './handler.js';
 export type * from './infer.js';
-export type * from './request.js';
 export type * from './response.js';
 export type * from './schema.js';
 export type * from './server.js';

package/dist/types/infer.d.ts

@@ -1,19 +1,14 @@
 import type * as z from 'zod';
 import type { MutationRouteSchema, RouteSchema } from './schema.js';
-import type { RouteRequestFactory } from './request.js';
 type InferRouteSchemaBody<TSchema> = TSchema extends MutationRouteSchema ? TSchema extends {
     body: infer TBody;
 } ? z.infer<TBody> : unknown : never;
-type InferRouteArgsBody<TArgs> = TArgs extends {
-    body?: infer TBody;
-} ? TBody : never;
 /**
- * Infer the request body type from an action schema or request factory.
+ * Infer the request body type from an action schema.
  *
  * @remarks HTTP action schemas can be inspected with
- * `InferRouteBody<typeof action.schema>`. Request factories for mutation actions
- * infer their `body` argument type. Schemas without a body schema infer
+ * `InferRouteBody<typeof action.schema>`. Schemas without a body schema infer
  * `unknown`.
  */
-export type InferRouteBody<T> = T extends RouteRequestFactory<any, any> ? InferRouteArgsBody<T['$args']> : T extends RouteSchema ? InferRouteSchemaBody<T> : never;
+export type InferRouteBody<T> = T extends RouteSchema ? InferRouteSchemaBody<T> : never;
 export {};

package/docs/context.md

@@ -211,18 +211,16 @@ requests with an `Origin` header.
 
 ### Client
 
-`createClient({ baseURL, routes })` creates:
-
-- `client.request(action.request(args))` for a raw `Response` when the action
-  request factory contains the full path you want to call
-- `client.json(action.request(args))` for parsed JSON and default non-2xx
-  throwing
-- response-map support for generated client action functions, returning
-  `[error, value, status]` tuples for declared statuses
-- response plugin support for generated client action functions, such as
-  `ndjson.clientPlugin` for NDJSON response streams
-- a client tree that mirrors `routes`, with action functions such as
-  `client.profiles.get(args)` when `routes` is supplied
+`createClient({ baseURL, routes })` creates a client tree that mirrors
+`routes`, with action functions such as `client.profiles.get(args)`.
+Generated action functions include:
+
+- raw `Response` results for actions without a response schema
+- parsed JSON and default non-2xx throwing for `$type<T>()` responses
+- response-map support, returning `[error, value, status]` tuples for declared
+  statuses
+- response plugin support, such as `ndjson.clientPlugin` for NDJSON response
+  streams
 
 Prefer an absolute `baseURL` for generated client URLs:
 
@@ -235,7 +233,8 @@ const client = createClient({
 
 Default headers can be supplied with `headers`, per-request headers are merged on
 top, and a custom `fetch` implementation can be supplied for tests or non-browser
-runtimes.
+runtimes. The returned client exposes the original options as `clientConfig`, so
+route actions named `config` remain available as `client.config(...)`.
 
 ## Lifecycle
 
@@ -260,9 +259,9 @@ string-coercion step.
 
 ## Common tasks
 
-### Choose a client call style
+### Call client actions
 
-Use client action functions for normal application calls:
+Use generated client action functions for application calls:
 
 ```ts
 await client.profiles.get({ path: { id: '42' } })
@@ -272,29 +271,6 @@ await client.profiles.update({
 })
 ```
 
-Use longhand calls when you need to choose response handling explicitly. The
-action request factory must include the full path you want to call, so this style
-is most convenient for top-level actions:
-
-```ts
-export const getProfile = http.get('profiles/:id', {
-  response: $type<Profile>(),
-})
-export const routes = { getProfile }
-
-const response = await client.request(
-  routes.getProfile.request({ path: { id: '42' } })
-)
-
-const json = await client.json(
-  routes.getProfile.request({ path: { id: '42' } })
-)
-```
-
-Response maps and response plugins are applied by generated client action
-functions. For longhand calls to mapped or plugin-backed routes, use
-`client.request(...)` for the raw `Response` and decode the response yourself.
-
 ### Handle declared error responses
 
 Use `$error<T>()` inside a response map when an error status is part of the route
@@ -420,7 +396,7 @@ custom headers. Return a plain value for the default `Response.json(value)` path
 
 ### Customize JSON errors
 
-By default, `client.json(...)` and generated client action functions throw for
+By default, generated client action functions throw for
 non-2xx responses that are not declared in a response map. If the response body
 is JSON, its properties are copied onto the thrown `Error`.
 
@@ -484,7 +460,7 @@ await client.profiles.update({
 - Export route trees from a small shared module and import that module on both
   server and client.
 - Use `rouzer/http` actions for routes that are registered with
-  `createRouter().use(...)` or `createClient({ routes })`.
+  `createRouter().use(...)` or the required `createClient({ routes })` option.
 - Add Zod schemas when you need runtime guarantees; rely on inferred path params
   only when string params are sufficient.
 - Use `response: $type<T>()` for JSON endpoints that should have typed client
@@ -513,11 +489,10 @@ await client.profiles.update({
 - Pathname route patterns expect an absolute client `baseURL`.
 - Resource and action keys are API names only; paths come from the pattern
   strings passed to `http.resource(...)` and action helpers.
-- Nested action `.request(...)` factories do not include parent resource paths;
-  prefer client action functions for nested resources.
 - Extra `RequestInit` fields in route args, such as `signal` or `credentials`,
-  are forwarded by `createClient`; `method`, `body`, and `headers` are reserved
-  for Rouzer's action metadata and validated call arguments.
+  are forwarded by `createClient`; `method` and `body` are reserved for Rouzer's
+  action metadata and validated call arguments. Use route args or client defaults
+  for request headers.
 - 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": "3.2.0",
+  "version": "4.0.0",
   "type": "module",
   "exports": {
     ".": {

package/dist/types/request.d.ts

@@ -1,35 +0,0 @@
-import type { RoutePattern } from '@remix-run/route-pattern';
-import type { RouteArgs } from './args.js';
-import type { InferRouteResponse } from './response.js';
-import type { RouteSchema } from './schema.js';
-/**
- * Request descriptor produced by an HTTP action request factory.
- *
- * @remarks Pass this object to `client.request(...)` for a raw `Response` or
- * `client.json(...)` for parsed JSON handling.
- */
-export type RouteRequest<TResult = any> = {
-    /** Method schema used for client-side validation. */
-    schema: RouteSchema;
-    /** Parsed route pattern used to generate the request URL. */
-    path: RoutePattern;
-    /** HTTP method to send. */
-    method: string;
-    /** Validated route arguments and request options. */
-    args: RouteArgs;
-    /** Phantom result type consumed by `client.json(...)`. */
-    $result: TResult;
-};
-/**
- * Callable factory attached to an HTTP action.
- *
- * @remarks Calling a factory validates no data by itself; it creates a typed
- * `RouteRequest` descriptor for `createClient` to validate and send.
- */
-export type RouteRequestFactory<T extends RouteSchema, P extends string> = {
-    (...p: RouteArgs<T, P> extends infer TArgs ? {} extends TArgs ? [args?: TArgs] : [args: TArgs] : never): RouteRequest<InferRouteResponse<T>>;
-    /** Inferred argument type for this request factory. */
-    $args: RouteArgs<T, P>;
-    /** Inferred response type for this request factory. */
-    $response: InferRouteResponse<T>;
-};

package/dist/types/request.js

@@ -1 +0,0 @@
-export {};