rouzer 1.0.0-beta.15 → 1.0.0-beta.17

package/dist/client/index.d.ts

@@ -1,5 +1,7 @@
-import type { Promisable, RouteRequest } from '../types.js';
-export declare function createClient(config: {
+import { Route } from '../route.js';
+import type { InferRouteResponse, Promisable, RouteArgs, RouteRequest, RouteSchema } from '../types.js';
+export type RouzerClient<TRoutes extends Record<string, Route> = Record<string, never>> = ReturnType<typeof createClient<TRoutes>>;
+export declare function createClient<TRoutes extends Record<string, Route> = Record<string, never>>(config: {
     /**
      * Base URL to use for all requests.
      */
@@ -8,12 +10,21 @@ export declare function createClient(config: {
      * Default headers to send with every request.
      */
     headers?: Record<string, string>;
+    /**
+     * Pass in routes to attach them as methods on the client.
+     * @example
+     * ```ts
+     * const client = createClient({ baseURL: '/api/', routes: { helloRoute } })
+     * client.helloRoute.GET({ path: { name: 'world' } })
+     * ```
+     */
+    routes?: TRoutes;
     /**
      * Custom handler for non-200 response to a `.json()` request. By default, the
      * response is always parsed as JSON, regardless of the HTTP status code.
      */
     onJsonError?: (response: Response) => Promisable<Response>;
-}): {
+}): { [K in keyof TRoutes]: TRoutes[K]["methods"] extends infer TMethods ? { [M in keyof TMethods]: RouteRequestFunction<Extract<TMethods[M], RouteSchema>>; } : never; } & {
     config: {
         /**
          * Base URL to use for all requests.
@@ -23,14 +34,27 @@ export declare function createClient(config: {
          * Default headers to send with every request.
          */
         headers?: Record<string, string> | undefined;
+        /**
+         * Pass in routes to attach them as methods on the client.
+         * @example
+         * ```ts
+         * const client = createClient({ baseURL: '/api/', routes: { helloRoute } })
+         * client.helloRoute.GET({ path: { name: 'world' } })
+         * ```
+         */
+        routes?: TRoutes | undefined;
         /**
          * Custom handler for non-200 response to a `.json()` request. By default, the
          * response is always parsed as JSON, regardless of the HTTP status code.
          */
         onJsonError?: ((response: Response) => Promisable<Response>) | undefined;
     };
-    request<T extends RouteRequest>({ path: pathBuilder, method, args: { path, query, body, headers }, route, }: T): Promise<Response & {
+    request: <T extends RouteRequest>({ path: pathBuilder, method, args: { path, query, body, headers }, schema, }: T) => Promise<Response & {
         json(): Promise<T["$result"]>;
     }>;
-    json<T extends RouteRequest>(request: T): Promise<T["$result"]>;
+    json: <T extends RouteRequest>(props: T) => Promise<T["$result"]>;
 };
+type RouteRequestFunction<T extends RouteSchema> = (args: RouteArgs<T>) => Promise<T extends {
+    response: any;
+} ? InferRouteResponse<T> : Response>;
+export {};

package/dist/client/index.js

@@ -1,55 +1,69 @@
-import { shake } from '../common.js';
+import { mapValues, shake } from '../common.js';
 export function createClient(config) {
     const baseURL = config.baseURL.replace(/\/$/, '');
+    async function request({ path: pathBuilder, method, args: { path, query, body, headers }, schema, }) {
+        if (schema.path) {
+            path = schema.path.parse(path);
+        }
+        let url;
+        const href = pathBuilder.href(path);
+        if (href[0] === '/') {
+            url = new URL(baseURL);
+            url.pathname += pathBuilder.href(path);
+        }
+        else {
+            url = new URL(href);
+        }
+        if (schema.query) {
+            query = schema.query.parse(query ?? {});
+            url.search = new URLSearchParams(query).toString();
+        }
+        else if (query) {
+            throw new Error('Unexpected query parameters');
+        }
+        if (schema.body) {
+            body = schema.body.parse(body !== undefined ? body : {});
+        }
+        else if (body !== undefined) {
+            throw new Error('Unexpected body');
+        }
+        if (config.headers || headers) {
+            headers = {
+                ...config.headers,
+                ...(headers && shake(headers)),
+            };
+        }
+        if (schema.headers) {
+            headers = schema.headers.parse(headers);
+        }
+        return fetch(url, {
+            method,
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+            headers: headers,
+        });
+    }
+    async function json(props) {
+        const response = await request(props);
+        if (!response.ok && config.onJsonError) {
+            return config.onJsonError(response);
+        }
+        return response.json();
+    }
     return {
+        ...(config.routes
+            ? mapValues(config.routes, route => connectRoute(route, request, json))
+            : null),
         config,
-        request({ path: pathBuilder, method, args: { path, query, body, headers }, route, }) {
-            if (route.path) {
-                path = route.path.parse(path);
-            }
-            let url;
-            const href = pathBuilder.href(path);
-            if (href[0] === '/') {
-                url = new URL(baseURL);
-                url.pathname += pathBuilder.href(path);
-            }
-            else {
-                url = new URL(href);
-            }
-            if (route.query) {
-                query = route.query.parse(query ?? {});
-                url.search = new URLSearchParams(query).toString();
-            }
-            else if (query) {
-                throw new Error('Unexpected query parameters');
-            }
-            if (route.body) {
-                body = route.body.parse(body !== undefined ? body : {});
-            }
-            else if (body !== undefined) {
-                throw new Error('Unexpected body');
-            }
-            if (config.headers || headers) {
-                headers = {
-                    ...config.headers,
-                    ...(headers && shake(headers)),
-                };
-            }
-            if (route.headers) {
-                headers = route.headers.parse(headers);
-            }
-            return fetch(url, {
-                method,
-                body: body !== undefined ? JSON.stringify(body) : undefined,
-                headers: headers,
-            });
-        },
-        async json(request) {
-            const response = await this.request(request);
-            if (!response.ok && config.onJsonError) {
-                return config.onJsonError(response);
-            }
-            return response.json();
-        },
+        request,
+        json,
+    };
+}
+function connectRoute(route, request, json) {
+    return {
+        ...route,
+        ...mapValues(route.methods, (schema, key) => {
+            const fetch = schema.response ? json : request;
+            return (args) => fetch(route[key](args));
+        }),
     };
 }

package/dist/route.d.ts

@@ -1,7 +1,10 @@
 import { RoutePattern } from '@remix-run/route-pattern';
-import type { MutationMethod, QueryMethod, RouteFunction, RouteMethods, Unchecked } from './types.js';
+import type { RouteFunction, RouteSchema, RouteSchemaMap, Unchecked } from './types.js';
 export declare function $type<T>(): Unchecked<T>;
-export declare function route<P extends string, T extends RouteMethods>(pattern: P, methods: T): {
+export type Route<P extends string = string, T extends RouteSchemaMap = RouteSchemaMap> = {
     path: RoutePattern<P>;
     methods: T;
-} & { [K in keyof T]: RouteFunction<Extract<T[K], MutationMethod | QueryMethod>>; };
+} & {
+    [K in keyof T]: RouteFunction<Extract<T[K], RouteSchema>>;
+};
+export declare function route<P extends string, T extends RouteSchemaMap>(pattern: P, methods: T): Route<P, T>;

package/dist/route.js

@@ -5,14 +5,17 @@ export function $type() {
 }
 export function route(pattern, methods) {
     const path = new RoutePattern(pattern);
-    const createFetch = (method, route) => (args) => {
+    const createFetch = (method, schema) => (args) => {
         return {
-            route,
+            schema,
             path,
             method,
             args,
             $result: undefined,
         };
     };
-    return Object.assign({ path, methods }, mapEntries(methods, (method, route) => [method, createFetch(method, route)]));
+    return Object.assign({ path, methods }, mapEntries(methods, (method, schema) => [
+        method,
+        createFetch(method, schema),
+    ]));
 }

package/dist/server/router.d.ts

@@ -1,7 +1,7 @@
 import { type Params } from '@remix-run/route-pattern';
 import { chain, MiddlewareChain, type HattipContext, type MiddlewareContext } from 'alien-middleware';
 import * as z from 'zod/mini';
-import type { InferRouteResponse, MutationMethod, Promisable, QueryMethod, Routes } from '../types.js';
+import type { InferRouteResponse, MutationRouteSchema, Promisable, QueryRouteSchema, Routes } from '../types.js';
 export { chain };
 type EmptyMiddlewareChain<TPlatform = unknown> = MiddlewareChain<{
     initial: {
@@ -82,18 +82,26 @@ interface CreateRouterConfig<TRoutes extends Routes, TMiddleware extends Middlew
     routes: TRoutes;
     middlewares?: TMiddleware;
 }
-export declare function createRouter<TRoutes extends Routes, TMiddleware extends MiddlewareChain = EmptyMiddlewareChain>(config: CreateRouterConfig<TRoutes, TMiddleware>): (handlers: { [K in keyof TRoutes]: { [M in keyof TRoutes[K]["methods"]]: TRoutes[K]["methods"][M] extends infer T ? T extends TRoutes[K]["methods"][M] ? T extends QueryMethod ? (context: MiddlewareContext<TMiddleware> & {
+export declare function createRouter<TRoutes extends Routes, TMiddleware extends MiddlewareChain = EmptyMiddlewareChain>(config: CreateRouterConfig<TRoutes, TMiddleware>): (handlers: { [K in keyof TRoutes]: { [M in keyof TRoutes[K]["methods"]]: TRoutes[K]["methods"][M] extends infer T ? T extends TRoutes[K]["methods"][M] ? T extends QueryRouteSchema ? (context: MiddlewareContext<TMiddleware> & {
     path: T extends {
         path: any;
     } ? z.infer<T["path"]> : Params<TRoutes[K]["path"]["source"]>;
-    query: z.infer<T["query"]>;
-    headers: z.infer<T["headers"]>;
-}) => Promisable<Response | InferRouteResponse<T>> : T extends MutationMethod ? (context: MiddlewareContext<TMiddleware> & {
+    query: T extends {
+        query: any;
+    } ? z.infer<T["query"]> : undefined;
+    headers: T extends {
+        headers: any;
+    } ? z.infer<T["headers"]> : undefined;
+}) => Promisable<Response | InferRouteResponse<T>> : T extends MutationRouteSchema ? (context: MiddlewareContext<TMiddleware> & {
     path: T extends {
         path: any;
     } ? z.infer<T["path"]> : Params<TRoutes[K]["path"]["source"]>;
-    body: z.infer<T["body"]>;
-    headers: z.infer<T["headers"]>;
+    body: T extends {
+        body: any;
+    } ? z.infer<T["body"]> : undefined;
+    headers: T extends {
+        headers: any;
+    } ? z.infer<T["headers"]> : undefined;
 }) => Promisable<Response | InferRouteResponse<T>> : never : never : never; }; }) => import("alien-middleware").ApplyMiddleware<TMiddleware, (context: HattipContext<TMiddleware extends MiddlewareChain<infer T extends {
     initial: {
         env: object;

package/dist/server/router.js

@@ -1,7 +1,7 @@
 import { RoutePattern } from '@remix-run/route-pattern';
 import { chain, } from 'alien-middleware';
-import { mapValues } from '../common.js';
 import * as z from 'zod/mini';
+import { mapValues } from '../common.js';
 export { chain };
 export function createRouter(config) {
     const keys = Object.keys(config.routes);

package/dist/types.d.ts

@@ -4,31 +4,33 @@ export type Promisable<T> = T | Promise<T>;
 export type Unchecked<T> = {
     __unchecked__: T;
 };
-export type QueryMethod = {
+export type QueryRouteSchema = {
     path?: z.ZodMiniObject<any>;
     query?: z.ZodMiniObject<any>;
     body?: never;
     headers?: z.ZodMiniObject<any>;
-    response: Unchecked<any>;
+    response?: Unchecked<any>;
 };
-export type MutationMethod = {
+export type MutationRouteSchema = {
     path?: z.ZodMiniObject<any>;
     query?: never;
     body?: z.ZodMiniType<any, any>;
     headers?: z.ZodMiniObject<any>;
     response?: Unchecked<any>;
 };
-export type RouteMethods = {
-    GET?: QueryMethod;
-    POST?: MutationMethod;
-    PUT?: MutationMethod;
-    PATCH?: MutationMethod;
-    DELETE?: MutationMethod;
+export type RouteSchemaMap = {
+    GET?: QueryRouteSchema;
+    POST?: MutationRouteSchema;
+    PUT?: MutationRouteSchema;
+    PATCH?: MutationRouteSchema;
+    DELETE?: MutationRouteSchema;
 };
+export type Method = string & keyof RouteSchemaMap;
+export type RouteSchema = QueryRouteSchema | MutationRouteSchema;
 export type Routes = {
     [key: string]: {
         path: RoutePattern;
-        methods: RouteMethods;
+        methods: RouteSchemaMap;
     };
 };
 declare class Any {
@@ -41,23 +43,23 @@ type PathArgs<T> = T extends {
 } : {
     path: TParams;
 } : unknown : unknown;
-type QueryArgs<T> = T extends QueryMethod & {
+type QueryArgs<T> = T extends QueryRouteSchema & {
     query: infer TQuery;
 } ? {} extends z.infer<TQuery> ? {
     query?: z.infer<TQuery>;
 } : {
     query: z.infer<TQuery>;
 } : unknown;
-type MutationArgs<T> = T extends MutationMethod & {
+type MutationArgs<T> = T extends MutationRouteSchema ? T extends {
     body: infer TBody;
 } ? {} extends z.infer<TBody> ? {
     body?: z.infer<TBody>;
 } : {
     body: z.infer<TBody>;
+} : {
+    body?: unknown;
 } : unknown;
-export type RouteArgs<T extends QueryMethod | MutationMethod = any> = ([
-    T
-] extends [Any] ? {
+export type RouteArgs<T extends RouteSchema = any> = ([T] extends [Any] ? {
     query?: any;
     body?: any;
     path?: any;
@@ -65,7 +67,7 @@ export type RouteArgs<T extends QueryMethod | MutationMethod = any> = ([
     headers?: Record<string, string | undefined>;
 };
 export type RouteRequest<TResult = any> = {
-    route: QueryMethod | MutationMethod;
+    schema: RouteSchema;
     path: RoutePattern;
     method: string;
     args: RouteArgs;
@@ -74,10 +76,10 @@ export type RouteRequest<TResult = any> = {
 export type RouteResponse<TResult = any> = Response & {
     json(): Promise<TResult>;
 };
-export type InferRouteResponse<T extends QueryMethod | MutationMethod> = T extends {
+export type InferRouteResponse<T extends RouteSchema> = T extends {
     response: Unchecked<infer TResponse>;
 } ? TResponse : void;
-export type RouteFunction<T extends QueryMethod | MutationMethod> = {
+export type RouteFunction<T extends RouteSchema> = {
     (args: RouteArgs<T>): RouteRequest<InferRouteResponse<T>>;
     $args: RouteArgs<T>;
     $response: InferRouteResponse<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rouzer",
-  "version": "1.0.0-beta.15",
+  "version": "1.0.0-beta.17",
   "type": "module",
   "exports": {
     ".": {

package/readme.md

@@ -85,7 +85,11 @@ export const handler = createRouter({
   middlewares,
   basePath: 'api/',
   cors: {
-    allowOrigins: ['example.net', 'https://*.example.com', '*://localhost:3000'],
+    allowOrigins: [
+      'example.net',
+      'https://*.example.com',
+      '*://localhost:3000',
+    ],
   },
   debug: process.env.NODE_ENV === 'development',
 })({
@@ -125,6 +129,30 @@ const response = await client.request(
 const { message } = await response.json()
 ```
 
+Optionally pass your routes map to `createClient` to get per-route methods on the client:
+
+```ts
+import * as routes from './routes'
+
+const client = createClient({
+  baseURL: '/api/',
+  routes,
+})
+```
+
+Routes that define a `response` type will call `client.json()` under the hood and return the parsed value; routes without one return the raw `Response`:
+
+```ts
+// helloRoute has a response schema, so you get the parsed payload
+const { message } = await client.helloRoute.GET({
+  path: { name: 'world' },
+})
+
+// imagine pingRoute has no response schema; you get a Response object
+const pingResponse = await client.pingRoute.GET({})
+const pingText = await pingResponse.text()
+```
+
 ## Add an endpoint
 
 1. Declare it in `routes.ts` with `route(...)` and `zod/mini` schemas.