rouzer 1.0.0-beta.9 → 1.1.0

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,25 @@ 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>;
-}): {
+    /**
+     * Custom fetch implementation to use for requests.
+     */
+    fetch?: typeof globalThis.fetch;
+}): { [K in keyof TRoutes]: TRoutes[K]["methods"] extends infer TMethods ? { [M in keyof TMethods]: RouteFunction<Extract<TMethods[M], RouteSchema>, TRoutes[K]["path"]["source"]>; } : never; } & {
     config: {
         /**
          * Base URL to use for all requests.
@@ -23,14 +38,35 @@ 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;
+        /**
+         * Custom fetch implementation to use for requests.
+         */
+        fetch?: typeof globalThis.fetch | 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"]>;
 };
+/**
+ * This function sends a request to a route of the same name. Such a function is
+ * accessible by setting the `routes` option when creating a Rouzer client,
+ * where it will exist as a method on the client.
+ */
+export type RouteFunction<T extends RouteSchema, P extends string> = (...p: RouteArgs<T, P> extends infer TArgs ? {} extends TArgs ? [args?: TArgs] : [args: TArgs] : never) => Promise<T extends {
+    response: any;
+} ? InferRouteResponse<T> : Response>;

package/dist/client/index.js

@@ -1,55 +1,79 @@
-import { shake } from '../common.js';
+import { mapValues, shake } from '../common.js';
 export function createClient(config) {
-    const baseURL = config.baseURL.replace(/\/$/, '');
-    return {
-        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');
+    const baseURL = config.baseURL.replace(/\/?$/, '/');
+    const defaultHeaders = config.headers && shake(config.headers);
+    const fetch = config.fetch ?? globalThis.fetch;
+    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 += href.slice(1);
+        }
+        else {
+            url = new URL(href);
+        }
+        if (schema.query) {
+            query = schema.query.parse(query ?? {});
+            url.search = new URLSearchParams(shake(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 (headers) {
+            headers = shake(headers);
+            if (defaultHeaders) {
+                headers = { ...defaultHeaders, ...headers };
             }
-            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) {
+        }
+        if (schema.headers) {
+            headers = schema.headers.parse(headers);
+        }
+        return fetch(url, {
+            method,
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+            headers: (headers ?? defaultHeaders),
+        });
+    }
+    async function json(props) {
+        const response = await request(props);
+        if (!response.ok) {
+            if (config.onJsonError) {
                 return config.onJsonError(response);
             }
-            return response.json();
-        },
+            const error = new Error(`Request to ${props.method} ${props.path.href(props.args.path)} failed with status ${response.status}`);
+            const contentType = response.headers.get('content-type');
+            if (contentType?.includes('application/json')) {
+                Object.assign(error, await response.json());
+            }
+            throw error;
+        }
+        return response.json();
+    }
+    return {
+        ...(config.routes
+            ? mapValues(config.routes, route => connectRoute(route, request, json))
+            : null),
+        config,
+        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,13 @@
 import { RoutePattern } from '@remix-run/route-pattern';
-import type { MutationMethod, QueryMethod, RouteFunction, RouteMethods, Unchecked } from './types.js';
+import type { RouteRequestFactory, 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 declare namespace $type {
+    var symbol: symbol;
+}
+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]: RouteRequestFactory<Extract<T[K], RouteSchema>, P>;
+};
+export declare function route<P extends string, T extends RouteSchemaMap>(pattern: P, methods: T): Route<P, T>;

package/dist/route.js

@@ -1,18 +1,22 @@
 import { RoutePattern } from '@remix-run/route-pattern';
 import { mapEntries } from './common.js';
 export function $type() {
-    return null;
+    return $type.symbol;
 }
+$type.symbol = Symbol();
 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,20 +1,8 @@
-import type { AdapterRequestContext } from '@hattip/core';
-import { type Params } from '@remix-run/route-pattern';
-import { chain, MiddlewareChain, type MiddlewareContext } from 'alien-middleware';
-import * as z from 'zod/mini';
-import type { InferRouteResponse, MutationMethod, Promisable, QueryMethod, Routes } from '../types.js';
+import type { HattipHandler } from '@hattip/core';
+import { ApplyMiddleware, chain, ExtractMiddleware, MiddlewareChain, MiddlewareTypes } from 'alien-middleware';
+import type { Routes } from '../types.js';
+import type { RouteRequestHandlerMap } from './types.js';
 export { chain };
-type EmptyMiddlewareChain<TPlatform = unknown> = MiddlewareChain<{
-    initial: {
-        env: {};
-        properties: {};
-    };
-    current: {
-        env: {};
-        properties: {};
-    };
-    platform: TPlatform;
-}>;
 export type RouterConfig = {
     /**
      * Base path to prepend to all routes.
@@ -24,33 +12,6 @@ export type RouterConfig = {
      * ```
      */
     basePath?: string;
-    /**
-     * Routes to match.
-     * @example
-     * ```ts
-     * // This namespace contains your `route()` declarations.
-     * // Pass it to the `createRouter` function.
-     * import * as routes from './routes'
-     *
-     * createRouter({ routes })({
-     *   // your route handlers...
-     * })
-     * ```
-     */
-    routes: Routes;
-    /**
-     * Middleware to apply to all routes.
-     * @see https://github.com/alien-rpc/alien-middleware#quick-start
-     * @example
-     * ```ts
-     * middlewares: chain().use(ctx => {
-     *   return {
-     *     db: postgres(ctx.env('POSTGRES_URL')),
-     *   }
-     * }),
-     * ```
-     */
-    middlewares?: MiddlewareChain;
     /**
      * Enable debugging features.
      * - When a handler throws an error, include its message in the response body.
@@ -67,37 +28,30 @@ export type RouterConfig = {
     cors?: {
         /**
          * If defined, requests must have an `Origin` header that is in this list.
+         *
+         * Origins may contain wildcards for protocol and subdomain. The protocol is
+         * optional and defaults to `https`.
+         *
+         * @example
+         * ```ts
+         * allowOrigins: ['example.net', 'https://*.example.com', '*://localhost:3000']
+         * ```
          */
         allowOrigins?: string[];
     };
 };
-interface CreateRouterConfig<TRoutes extends Routes, TMiddleware extends MiddlewareChain> extends RouterConfig {
-    routes: TRoutes;
-    middlewares?: TMiddleware;
+export interface Router<T extends MiddlewareTypes = any> extends HattipHandler<T['platform']>, MiddlewareChain<T> {
+    /**
+     * Clone this router and add the given middleware to the end of the chain.
+     *
+     * @returns a new `Router` instance.
+     */
+    use<const TMiddleware extends ExtractMiddleware<this>>(middleware: TMiddleware): Router<ApplyMiddleware<this, TMiddleware>>;
+    /**
+     * Clone this router and add the given routes and handlers to the chain.
+     *
+     * @returns a new `Router` instance.
+     */
+    use<TRoutes extends Routes>(routes: TRoutes, handlers: RouteRequestHandlerMap<TRoutes, this>): Router<T>;
 }
-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> & {
-    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> & {
-    path: T extends {
-        path: any;
-    } ? z.infer<T["path"]> : Params<TRoutes[K]["path"]["source"]>;
-    body: z.infer<T["body"]>;
-    headers: z.infer<T["headers"]>;
-}) => Promisable<Response | InferRouteResponse<T>> : never : never : never; }; }) => import("alien-middleware").ApplyMiddleware<TMiddleware, (context: AdapterRequestContext<TMiddleware extends MiddlewareChain<infer T extends {
-    initial: {
-        env: object;
-        properties: object;
-    };
-    current: {
-        env: object;
-        properties: object;
-    };
-    platform: unknown;
-}> ? T["platform"] : never> & {
-    url?: URL | undefined;
-    path?: {} | undefined;
-}) => Promise<Response | undefined>>;
+export declare function createRouter<TEnv extends object = {}, TProperties extends object = {}, TPlatform = unknown>(config?: RouterConfig): Router<MiddlewareTypes<TEnv, TProperties, TPlatform>>;

package/dist/server/router.js

@@ -1,86 +1,114 @@
 import { RoutePattern } from '@remix-run/route-pattern';
-import { chain, } from 'alien-middleware';
-import { mapValues } from '../common.js';
+import { chain, MiddlewareChain, } from 'alien-middleware';
 import * as z from 'zod/mini';
+import { mapValues } from '../common.js';
 export { chain };
-export function createRouter(config) {
-    const keys = Object.keys(config.routes);
-    const middlewares = config.middlewares ?? chain();
-    const basePath = config.basePath?.replace(/\/?$/, '/');
-    const patterns = mapValues(config.routes, ({ path }) => basePath ? new RoutePattern(path.source.replace(/^\/?/, basePath)) : path);
-    return (handlers) => middlewares.use(async function (context) {
-        const request = context.request;
-        const url = (context.url ??= new URL(request.url));
-        let method = request.method.toUpperCase();
-        let isPreflight = false;
-        if (method === 'OPTIONS') {
-            method = request.headers.get('Access-Control-Request-Method') ?? 'GET';
-            isPreflight = true;
-        }
-        for (let i = 0; i < keys.length; i++) {
-            const route = config.routes[keys[i]].methods[method];
-            if (!route) {
-                continue;
+// Internal prototype for the router instance.
+class RouterObject extends MiddlewareChain {
+    config;
+    basePath;
+    allowOrigins;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.basePath = config.basePath?.replace(/\/?$/, '/');
+        this.allowOrigins = config.cors?.allowOrigins?.map(createOriginPattern);
+    }
+    use(...args) {
+        const handler = args.length === 1 ? super.use(args[0]) : this.useRoutes(...args);
+        Object.setPrototypeOf(handler, this);
+        return handler;
+    }
+    /** @internal */
+    useRoutes(routes, handlers) {
+        const { config, basePath, allowOrigins } = this;
+        const keys = Object.keys(routes);
+        const patterns = mapValues(routes, ({ path }) => basePath ? new RoutePattern(path.source.replace(/^\/?/, basePath)) : path);
+        return super.use(async function (context) {
+            const request = context.request;
+            const origin = request.headers.get('Origin');
+            if (origin &&
+                allowOrigins &&
+                !allowOrigins.some(pattern => pattern.test(origin))) {
+                return new Response(null, { status: 403 });
             }
-            const match = patterns[keys[i]].match(url);
-            if (!match) {
-                continue;
+            const url = (context.url ??= new URL(request.url));
+            let method = request.method.toUpperCase();
+            let isPreflight = false;
+            if (method === 'OPTIONS') {
+                method = request.headers.get('Access-Control-Request-Method') ?? 'GET';
+                isPreflight = true;
             }
-            const handler = handlers[keys[i]][method];
-            if (!handler) {
-                if (config.debug) {
-                    throw new Error(`Handler not found for route: ${keys[i]} ${method}`);
+            for (let i = 0; i < keys.length; i++) {
+                const { methods } = routes[keys[i]];
+                const route = methods[method] || methods.ALL;
+                if (!route) {
+                    continue;
                 }
-                continue;
-            }
-            if (isPreflight) {
-                const origin = request.headers.get('Origin');
-                const allowed = config.cors?.allowOrigins;
-                if (allowed && !(origin && allowed.includes(origin))) {
-                    return new Response(null, { status: 403 });
+                const match = patterns[keys[i]].match(url);
+                if (!match) {
+                    continue;
                 }
-                return new Response(null, {
-                    headers: {
-                        'Access-Control-Allow-Origin': origin ?? '*',
-                        'Access-Control-Allow-Methods': method,
-                        'Access-Control-Allow-Headers': request.headers.get('Access-Control-Request-Headers') ?? '',
-                    },
-                });
-            }
-            if (route.path) {
-                const error = parsePathParams(context, enableStringParsing(route.path), match.params);
-                if (error) {
-                    return httpClientError(error, 'Invalid path parameter', config);
+                const routeHandler = handlers[keys[i]][method];
+                if (!routeHandler) {
+                    if (config.debug) {
+                        throw new Error(`Handler not found for route: ${keys[i]} ${method}`);
+                    }
+                    continue;
                 }
-            }
-            else {
-                context.path = match.params;
-            }
-            if (route.headers) {
-                const error = parseHeaders(context, enableStringParsing(route.headers));
-                if (error) {
-                    return httpClientError(error, 'Invalid request headers', config);
+                if (isPreflight) {
+                    return new Response(null, {
+                        headers: {
+                            'Access-Control-Allow-Origin': origin ?? '*',
+                            'Access-Control-Allow-Methods': method,
+                            'Access-Control-Allow-Headers': request.headers.get('Access-Control-Request-Headers') ?? '',
+                        },
+                    });
                 }
-            }
-            if (route.query) {
-                const error = parseQueryString(context, enableStringParsing(route.query));
-                if (error) {
-                    return httpClientError(error, 'Invalid query string', config);
+                if (origin) {
+                    context.setHeader('Access-Control-Allow-Origin', origin);
                 }
-            }
-            if (route.body) {
-                const error = await parseRequestBody(context, route.body);
-                if (error) {
-                    return httpClientError(error, 'Invalid request body', config);
+                if (route.path) {
+                    const error = parsePathParams(context, enableStringParsing(route.path), match.params);
+                    if (error) {
+                        return httpClientError(error, 'Invalid path parameter', config);
+                    }
                 }
+                else {
+                    context.path = match.params;
+                }
+                if (route.headers) {
+                    const error = parseHeaders(context, enableStringParsing(route.headers));
+                    if (error) {
+                        return httpClientError(error, 'Invalid request headers', config);
+                    }
+                }
+                if (route.query) {
+                    const error = parseQueryString(context, enableStringParsing(route.query));
+                    if (error) {
+                        return httpClientError(error, 'Invalid query string', config);
+                    }
+                }
+                if (route.body) {
+                    const error = await parseRequestBody(context, route.body);
+                    if (error) {
+                        return httpClientError(error, 'Invalid request body', config);
+                    }
+                }
+                const result = await routeHandler(context);
+                if (result instanceof Response) {
+                    return result;
+                }
+                return Response.json(result);
             }
-            const result = await handler(context);
-            if (result instanceof Response) {
-                return result;
-            }
-            return Response.json(result);
-        }
-    });
+        });
+    }
+}
+export function createRouter(config = {}) {
+    const router = new RouterObject(config);
+    const handler = router.toHandler();
+    Object.setPrototypeOf(handler, router);
+    return handler;
 }
 function httpClientError(error, message, config) {
     return Response.json({
@@ -128,6 +156,10 @@ const seen = new WeakMap();
  * value as a number or boolean.
  */
 function enableStringParsing(schema) {
+    if (schema.type === 'optional') {
+        const { def } = schema;
+        return z.optional(enableStringParsing(def.innerType));
+    }
     if (schema.type === 'number') {
         return z.pipe(z.transform(Number), schema);
     }
@@ -135,19 +167,43 @@ function enableStringParsing(schema) {
         return z.pipe(z.transform(toBooleanStrict), schema);
     }
     if (schema.type === 'object') {
-        const cached = seen.get(schema);
-        if (cached) {
-            return cached;
+        const cachedSchema = seen.get(schema);
+        if (cachedSchema) {
+            return cachedSchema;
         }
-        const modified = z.object(mapValues(schema.def.shape, enableStringParsing));
-        seen.set(schema, modified);
-        return modified;
+        const { def } = schema;
+        const newSchema = z.object(mapValues(def.shape, enableStringParsing));
+        seen.set(schema, newSchema);
+        return newSchema;
     }
     if (schema.type === 'array') {
-        return z.array(enableStringParsing(schema.def.element));
+        const { def } = schema;
+        return z.array(enableStringParsing(def.element));
     }
     return schema;
 }
 function toBooleanStrict(value) {
     return value === 'true' || (value === 'false' ? false : value);
 }
+class ExactPattern {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    test(input) {
+        return input === this.value;
+    }
+}
+function createOriginPattern(origin) {
+    if (!origin.includes('//')) {
+        origin = `https://${origin}`;
+    }
+    if (origin.includes('*')) {
+        return new RegExp(`^${origin
+            .replace(/\./g, '\\.')
+            .replace(/\*:/g, '[^:]+:') // Wildcard protocol
+            .replace(/\*\./g, '([^/]+\\.)?') // Wildcard subdomain
+        }$`);
+    }
+    return new ExactPattern(origin);
+}

package/dist/server/types.d.ts

@@ -0,0 +1,33 @@
+import type { Params } from '@remix-run/route-pattern';
+import type { AnyMiddlewareChain, MiddlewareChain, MiddlewareContext } from 'alien-middleware';
+import type * as z from 'zod/mini';
+import type { InferRouteResponse, MutationRouteSchema, Promisable, QueryRouteSchema, Routes } from '../types.js';
+type RequestContext<TMiddleware extends AnyMiddlewareChain> = MiddlewareContext<TMiddleware>;
+type RouteRequestHandler<TMiddleware extends AnyMiddlewareChain, TArgs extends object, TResult> = (context: RequestContext<TMiddleware> & TArgs) => Promisable<TResult | Response>;
+type InferRouteRequestHandler<TMiddleware extends AnyMiddlewareChain, T, P extends string> = T extends QueryRouteSchema ? RouteRequestHandler<TMiddleware, {
+    path: T extends {
+        path: any;
+    } ? z.infer<T['path']> : Params<P>;
+    query: T extends {
+        query: any;
+    } ? z.infer<T['query']> : undefined;
+    headers: T extends {
+        headers: any;
+    } ? z.infer<T['headers']> : undefined;
+}, InferRouteResponse<T>> : T extends MutationRouteSchema ? RouteRequestHandler<TMiddleware, {
+    path: T extends {
+        path: any;
+    } ? z.infer<T['path']> : Params<P>;
+    body: T extends {
+        body: any;
+    } ? z.infer<T['body']> : undefined;
+    headers: T extends {
+        headers: any;
+    } ? z.infer<T['headers']> : undefined;
+}, InferRouteResponse<T>> : never;
+export type RouteRequestHandlerMap<TRoutes extends Routes = Routes, TMiddleware extends AnyMiddlewareChain = MiddlewareChain> = {
+    [K in keyof TRoutes]: {
+        [M in keyof TRoutes[K]['methods']]: InferRouteRequestHandler<TMiddleware, TRoutes[K]['methods'][M], TRoutes[K]['path']['source']>;
+    };
+};
+export {};

package/dist/server/types.js

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

package/dist/types.d.ts

@@ -4,68 +4,81 @@ 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>;
+    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;
+    ALL?: {
+        path?: z.ZodMiniObject<any>;
+        query?: z.ZodMiniObject<any>;
+        body?: never;
+        headers?: z.ZodMiniObject<any>;
+        response?: never;
+    };
 };
+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 {
     private isAny;
 }
-type PathArgs<T> = T extends {
-    path: infer TPath extends string;
-} ? Params<TPath> extends infer TParams ? {} extends TParams ? {
+type PathArgs<T, P extends string> = T extends {
+    path: infer TPath;
+} ? {} extends z.infer<TPath> ? {
+    path?: z.infer<TPath>;
+} : {
+    path: z.infer<TPath>;
+} : Params<P> extends infer TParams ? {} extends TParams ? {
     path?: TParams;
 } : {
     path: TParams;
-} : unknown : unknown;
-type QueryArgs<T> = T extends QueryMethod & {
+} : unknown;
+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, P extends string = string> = ([T] extends [Any] ? {
     query?: any;
     body?: any;
     path?: any;
-} : QueryArgs<T> & MutationArgs<T> & PathArgs<T>) & Omit<RequestInit, 'method' | 'body' | 'headers'> & {
+} : QueryArgs<T> & MutationArgs<T> & PathArgs<T, P>) & Omit<RequestInit, 'method' | 'body' | 'headers'> & {
     headers?: Record<string, string | undefined>;
 };
 export type RouteRequest<TResult = any> = {
-    route: QueryMethod | MutationMethod;
+    schema: RouteSchema;
     path: RoutePattern;
     method: string;
     args: RouteArgs;
@@ -74,12 +87,12 @@ 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> = {
-    (args: RouteArgs<T>): RouteRequest<InferRouteResponse<T>>;
-    $args: RouteArgs<T>;
+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>>;
+    $args: RouteArgs<T, P>;
     $response: InferRouteResponse<T>;
 };
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rouzer",
-  "version": "1.0.0-beta.9",
+  "version": "1.1.0",
   "type": "module",
   "exports": {
     ".": {
@@ -13,16 +13,21 @@
   },
   "devDependencies": {
     "@alloc/prettier-config": "^1.0.0",
+    "@hattip/adapter-test": "^0.0.49",
+    "@types/node": "^25.0.3",
     "@typescript/native-preview": "7.0.0-dev.20251208.1",
     "prettier": "^3.7.4",
+    "rouzer": "link:.",
     "tsc-lint": "^0.1.9",
     "typescript": "^5.9.3",
+    "vite": "^7.3.0",
+    "vitest": "^4.0.16",
     "zod": "^4.1.13"
   },
   "dependencies": {
     "@hattip/core": "^0.0.49",
     "@remix-run/route-pattern": "^0.15.3",
-    "alien-middleware": "^0.10.2"
+    "alien-middleware": "^0.11.3"
   },
   "prettier": "@alloc/prettier-config",
   "license": "MIT",
@@ -35,6 +40,7 @@
     "!*.tsbuildinfo"
   ],
   "scripts": {
-    "build": "tsgo -b tsconfig.json"
+    "build": "tsgo -b tsconfig.json",
+    "test": "vitest run"
   }
 }

package/readme.md

@@ -26,8 +26,6 @@ export const helloRoute = route('hello/:name', {
     response: $type<{ message: string }>(),
   },
 })
-
-export const routes = { helloRoute }
 ```
 
 The following request parts can be validated with Zod:
@@ -39,6 +37,17 @@ The following request parts can be validated with Zod:
 
 Zod validation happens on both the server and client.
 
+## Route URL patterns
+
+Rouzer uses `@remix-run/route-pattern` for matching and generation. Patterns can include:
+
+- Pathname-only patterns like `blog/:slug` (default).
+- Full URLs with protocol/hostname/port like `https://:store.shopify.com/orders`.
+- Dynamic segments with `:param` names (valid JS identifiers), including multiple params in one segment like `v:major.:minor`.
+- Optional segments wrapped in parentheses, which can be nested like `api(/v:major(.:minor))`.
+- Wildcards with `*name` (captured) or `*` (uncaptured) for multi-segment paths like `assets/*path` or `files/*`.
+- Query matching with `?` to require parameters or exact values like `search?q` or `search?q=routing`.
+
 ## Server router
 
 ```ts
@@ -53,10 +62,35 @@ const middlewares = chain().use(ctx => {
 })
 
 export const handler = createRouter({
-  routes,
-  middlewares,
   debug: process.env.NODE_ENV === 'development',
-})({
+})
+  .use(middlewares)
+  .use(routes, {
+    helloRoute: {
+      GET(ctx) {
+        const message = `Hello, ${ctx.path.name}${
+          ctx.query.excited ? '!' : '.'
+        }`
+        return { message }
+      },
+    },
+  })
+```
+
+## Router options
+
+```ts
+export const handler = createRouter({
+  basePath: 'api/',
+  cors: {
+    allowOrigins: [
+      'example.net',
+      'https://*.example.com',
+      '*://localhost:3000',
+    ],
+  },
+  debug: process.env.NODE_ENV === 'development',
+}).use(routes, {
   helloRoute: {
     GET(ctx) {
       const message = `Hello, ${ctx.path.name}${ctx.query.excited ? '!' : '.'}`
@@ -66,6 +100,13 @@ export const handler = createRouter({
 })
 ```
 
+- `basePath` is prepended to every route (leading/trailing slashes are trimmed).
+- CORS preflight (`OPTIONS`) is handled automatically for matched routes.
+- `cors.allowOrigins` restricts preflight requests to a list of origins (default is to allow any origin).
+  - Wildcards are supported for protocol and subdomain; the protocol is optional and defaults to `https`.
+- If you rely on `Cookie` or `Authorization` request headers, you must set
+  `Access-Control-Allow-Credentials` in your handler.
+
 ## Client wrapper
 
 ```ts
@@ -86,8 +127,50 @@ const response = await client.request(
 const { message } = await response.json()
 ```
 
+### Custom fetch
+
+You can also pass a custom fetch implementation:
+
+```ts
+const client = createClient({
+  baseURL: '/api/',
+  fetch: myFetch,
+})
+```
+
+### Shorthand route methods
+
+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, // <–– Pass the routes
+})
+
+// Shorthand methods now available:
+await client.fooRoute.GET()
+// …same as the longhand:
+await client.json(routes.fooRoute.GET())
+```
+
+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.
-2. Implement the handler in your router assembly with `createRouter(…)({ ... })`.
+1. Declare it in `routes.ts` with `route(…)` and `zod/mini` schemas.
+2. Implement the handler in your router assembly with `createRouter(…).use(routes, { … })`.
 3. Call it from the client with the generated helper via `client.json` or `client.request`.