rouzer 1.0.0-beta.6 → 1.0.0-beta.7

package/dist/route.d.ts

@@ -1,8 +1,8 @@
 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): {
+export declare function route<P extends string, T extends RouteMethods>(path: P, methods: T): {
     path: P;
     pathPattern: RoutePattern<string>;
-    routes: T;
-} & { [K in keyof T]: RouteFunction<Extract<T[K], MutationRoute | QueryRoute>>; };
+    methods: T;
+} & { [K in keyof T]: RouteFunction<Extract<T[K], MutationMethod | QueryMethod>>; };

package/dist/route.js

@@ -3,7 +3,7 @@ import { mapEntries } from './common.js';
 export function $type() {
     return null;
 }
-export function route(path, routes) {
+export function route(path, methods) {
     const pathPattern = new RoutePattern(path);
     const createFetch = (method, route) => (args) => {
         return {
@@ -14,5 +14,5 @@ export function route(path, routes) {
             $result: undefined,
         };
     };
-    return Object.assign({ path, pathPattern, routes }, mapEntries(routes, (method, route) => [method, createFetch(method, route)]));
+    return Object.assign({ path, pathPattern, 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, RouteMethods } from '../types.js';
 export { chain };
 type EmptyMiddlewareChain<TPlatform = unknown> = MiddlewareChain<{
     initial: {
@@ -15,28 +15,69 @@ type EmptyMiddlewareChain<TPlatform = unknown> = MiddlewareChain<{
     };
     platform: TPlatform;
 }>;
-export type RouterConfig<TRoutes extends Record<string, {
-    path: string;
-    routes: Routes;
-}> = any, TMiddleware extends MiddlewareChain = any> = {
-    routes: TRoutes;
-    middlewares?: TMiddleware;
+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: Record<string, {
+        path: string;
+        methods: RouteMethods;
+    }>;
+    /**
+     * 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: {
+    methods: RouteMethods;
+}>, TMiddleware extends MiddlewareChain = EmptyMiddlewareChain>(config: 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> & {
+}): (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"]>;
     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"]>;

package/dist/server/router.js

@@ -6,13 +6,16 @@ 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, basePath
+        ? ({ path }) => new RoutePattern(`${basePath}/${path}`)
+        : ({ path }) => new RoutePattern(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,26 @@ 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 Routes = {
-    GET?: QueryRoute;
-    POST?: MutationRoute;
-    PUT?: MutationRoute;
-    PATCH?: MutationRoute;
-    DELETE?: MutationRoute;
+export type RouteMethods = {
+    GET?: QueryMethod;
+    POST?: MutationMethod;
+    PUT?: MutationMethod;
+    PATCH?: MutationMethod;
+    DELETE?: MutationMethod;
 };
 declare class Any {
     private isAny;
@@ -35,21 +35,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,7 +59,7 @@ export type RouteArgs<T extends QueryRoute | MutationRoute = any> = ([
     headers?: Record<string, string | undefined>;
 };
 export type RouteRequest<TResult = any> = {
-    route: QueryRoute | MutationRoute;
+    route: QueryMethod | MutationMethod;
     pathPattern: RoutePattern;
     method: string;
     args: RouteArgs;
@@ -68,10 +68,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.7",
   "type": "module",
   "exports": {
     ".": {