rouzer 1.0.0-beta.6 → 1.0.0-beta.8

package/dist/client/index.d.ts

@@ -29,7 +29,7 @@ export declare function createClient(config: {
          */
         onJsonError?: (response: Response) => Promisable<Response>;
     };
-    request<T extends RouteRequest>({ pathPattern, method, args: { path, query, body, headers }, route, }: T): Promise<Response & {
+    request<T extends RouteRequest>({ path: pathBuilder, method, args: { path, query, body, headers }, route, }: T): Promise<Response & {
         json(): Promise<T["$result"]>;
     }>;
     json<T extends RouteRequest>(request: T): Promise<T["$result"]>;

package/dist/client/index.js

@@ -3,12 +3,19 @@ export function createClient(config) {
     const baseURL = config.baseURL.replace(/\/$/, '');
     return {
         config,
-        request({ pathPattern, method, args: { path, query, body, headers }, route, }) {
+        request({ path: pathBuilder, method, args: { path, query, body, headers }, route, }) {
             if (route.path) {
                 path = route.path.parse(path);
             }
-            const url = new URL(baseURL);
-            url.pathname += pathPattern.href(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();

package/dist/route.d.ts

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

package/dist/route.js

@@ -3,16 +3,16 @@ import { mapEntries } from './common.js';
 export function $type() {
     return null;
 }
-export function route(path, routes) {
-    const pathPattern = new RoutePattern(path);
+export function route(pattern, methods) {
+    const path = new RoutePattern(pattern);
     const createFetch = (method, route) => (args) => {
         return {
             route,
-            pathPattern,
+            path,
             method,
             args,
             $result: undefined,
         };
     };
-    return Object.assign({ path, pathPattern, routes }, mapEntries(routes, (method, route) => [method, createFetch(method, route)]));
+    return Object.assign({ path, methods }, mapEntries(methods, (method, route) => [method, createFetch(method, route)]));
 }

package/dist/server/router.d.ts

@@ -2,7 +2,7 @@ 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, MutationRoute, Promisable, QueryRoute, Routes } from '../types.js';
+import type { InferRouteResponse, MutationMethod, Promisable, QueryMethod, Routes } from '../types.js';
 export { chain };
 type EmptyMiddlewareChain<TPlatform = unknown> = MiddlewareChain<{
     initial: {
@@ -15,31 +15,67 @@ type EmptyMiddlewareChain<TPlatform = unknown> = MiddlewareChain<{
     };
     platform: TPlatform;
 }>;
-export type RouterConfig<TRoutes extends Record<string, {
-    path: string;
+export type RouterConfig = {
+    /**
+     * Base path to prepend to all routes.
+     * @example
+     * ```ts
+     * basePath: 'api/',
+     * ```
+     */
+    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;
-}> = any, TMiddleware extends MiddlewareChain = any> = {
-    routes: TRoutes;
-    middlewares?: TMiddleware;
+    /**
+     * 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.
+     * - Throw an error if a handler is not found for a route.
+     * @example
+     * ```ts
+     * debug: process.env.NODE_ENV !== 'production',
+     * ```
+     */
     debug?: boolean;
 };
-export declare function createRouter<TRoutes extends Record<string, {
-    path: string;
-    routes: Routes;
-}>, TMiddleware extends MiddlewareChain = EmptyMiddlewareChain>(config: {
+interface CreateRouterConfig<TRoutes extends Routes, TMiddleware extends MiddlewareChain> extends RouterConfig {
     routes: TRoutes;
     middlewares?: TMiddleware;
-    debug?: boolean;
-}): (handlers: { [K in keyof TRoutes]: { [M in keyof TRoutes[K]["routes"]]: TRoutes[K]["routes"][M] extends infer T ? T extends TRoutes[K]["routes"][M] ? T extends QueryRoute ? (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 QueryMethod ? (context: MiddlewareContext<TMiddleware> & {
     path: T extends {
         path: any;
-    } ? z.infer<T["path"]> : Params<TRoutes[K]["path"]>;
+    } ? 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 MutationRoute ? (context: MiddlewareContext<TMiddleware> & {
+}) => Promisable<Response | InferRouteResponse<T>> : T extends MutationMethod ? (context: MiddlewareContext<TMiddleware> & {
     path: T extends {
         path: any;
-    } ? z.infer<T["path"]> : Params<TRoutes[K]["path"]>;
+    } ? 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 {

package/dist/server/router.js

@@ -6,13 +6,14 @@ export { chain };
 export function createRouter(config) {
     const keys = Object.keys(config.routes);
     const middlewares = config.middlewares ?? chain();
-    const patterns = mapValues(config.routes, ({ path }) => new RoutePattern(path));
+    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 method = request.method.toUpperCase();
         const url = (context.url ??= new URL(request.url));
         for (let i = 0; i < keys.length; i++) {
-            const route = config.routes[keys[i]].routes[method];
+            const route = config.routes[keys[i]].methods[method];
             if (!route) {
                 continue;
             }

package/dist/types.d.ts

@@ -4,26 +4,32 @@ export type Promisable<T> = T | Promise<T>;
 export type Unchecked<T> = {
     __unchecked__: T;
 };
-export type QueryRoute = {
+export type QueryMethod = {
     path?: z.ZodMiniObject<any>;
     query?: z.ZodMiniObject<any>;
     body?: never;
     headers?: z.ZodMiniObject<any>;
     response: Unchecked<any>;
 };
-export type MutationRoute = {
+export type MutationMethod = {
     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 Routes = {
-    GET?: QueryRoute;
-    POST?: MutationRoute;
-    PUT?: MutationRoute;
-    PATCH?: MutationRoute;
-    DELETE?: MutationRoute;
+    [key: string]: {
+        path: RoutePattern;
+        methods: RouteMethods;
+    };
 };
 declare class Any {
     private isAny;
@@ -35,21 +41,21 @@ type PathArgs<T> = T extends {
 } : {
     path: TParams;
 } : unknown : unknown;
-type QueryArgs<T> = T extends QueryRoute & {
+type QueryArgs<T> = T extends QueryMethod & {
     query: infer TQuery;
 } ? {} extends z.infer<TQuery> ? {
     query?: z.infer<TQuery>;
 } : {
     query: z.infer<TQuery>;
 } : unknown;
-type MutationArgs<T> = T extends MutationRoute & {
+type MutationArgs<T> = T extends MutationMethod & {
     body: infer TBody;
 } ? {} extends z.infer<TBody> ? {
     body?: z.infer<TBody>;
 } : {
     body: z.infer<TBody>;
 } : unknown;
-export type RouteArgs<T extends QueryRoute | MutationRoute = any> = ([
+export type RouteArgs<T extends QueryMethod | MutationMethod = any> = ([
     T
 ] extends [Any] ? {
     query?: any;
@@ -59,8 +65,8 @@ export type RouteArgs<T extends QueryRoute | MutationRoute = any> = ([
     headers?: Record<string, string | undefined>;
 };
 export type RouteRequest<TResult = any> = {
-    route: QueryRoute | MutationRoute;
-    pathPattern: RoutePattern;
+    route: QueryMethod | MutationMethod;
+    path: RoutePattern;
     method: string;
     args: RouteArgs;
     $result: TResult;
@@ -68,10 +74,10 @@ export type RouteRequest<TResult = any> = {
 export type RouteResponse<TResult = any> = Response & {
     json(): Promise<TResult>;
 };
-export type InferRouteResponse<T extends QueryRoute | MutationRoute> = T extends {
+export type InferRouteResponse<T extends QueryMethod | MutationMethod> = T extends {
     response: Unchecked<infer TResponse>;
 } ? TResponse : void;
-export type RouteFunction<T extends QueryRoute | MutationRoute> = {
+export type RouteFunction<T extends QueryMethod | MutationMethod> = {
     (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.6",
+  "version": "1.0.0-beta.8",
   "type": "module",
   "exports": {
     ".": {