rouzer 1.2.2 → 1.3.0

package/dist/server/router.js

@@ -29,10 +29,24 @@ class RouterObject extends MiddlewareChain {
         return handler;
     }
     /** @internal */
-    useRoutes(routes, handlers) {
+    useRoutes(routeSchemas, handlers) {
         const { config, basePath } = this;
-        const keys = Object.keys(routes);
-        const patterns = mapValues(routes, ({ path }) => basePath ? new RoutePattern(path.source.replace(/^\/?/, basePath)) : path);
+        const routes = Object.entries(routeSchemas).map(([name, route]) => ({
+            name,
+            path: basePath
+                ? new RoutePattern(route.path.source.replace(/^\/?/, basePath))
+                : route.path,
+            methods: mapValues(route.methods, (schema, method) => {
+                const handler = handlers[name][method];
+                if (!handler && config.debug) {
+                    console.error(`Handler missing for route: ${method} ${name}`);
+                }
+                return {
+                    schema,
+                    handler,
+                };
+            }),
+        }));
         return super.use(async function (context) {
             const request = context.request;
             const origin = request.headers.get('Origin');
@@ -45,21 +59,27 @@ class RouterObject extends MiddlewareChain {
                     request.headers.get('Access-Control-Request-Method')?.toUpperCase() ??
                         'GET';
             }
-            for (let i = 0; i < keys.length; i++) {
-                const { methods } = routes[keys[i]];
-                const route = methods[method] || methods.ALL;
-                if (!route) {
+            for (const route of routes) {
+                const props = route.methods[method] ?? route.methods.ALL;
+                if (!props) {
                     continue;
                 }
-                const match = patterns[keys[i]].match(url);
-                if (!match) {
+                const { schema, handler } = props;
+                if (!handler) {
                     continue;
                 }
-                const routeHandler = handlers[keys[i]][method];
-                if (!routeHandler) {
+                const match = route.path.match(url);
+                if (!match) {
                     continue;
                 }
                 if (isPreflight) {
+                    const optionsHandler = handlers[route.name].OPTIONS;
+                    if (optionsHandler) {
+                        const response = await optionsHandler(context);
+                        if (response) {
+                            return response;
+                        }
+                    }
                     return new Response(null, {
                         headers: {
                             'Access-Control-Allow-Origin': origin ?? '',
@@ -71,8 +91,8 @@ class RouterObject extends MiddlewareChain {
                 if (origin) {
                     context.setHeader('Access-Control-Allow-Origin', origin);
                 }
-                if (route.path) {
-                    const error = parsePathParams(context, enableStringParsing(route.path), match.params);
+                if (schema.path) {
+                    const error = parsePathParams(context, enableStringParsing(schema.path), match.params);
                     if (error) {
                         return httpClientError(error, 'Invalid path parameter', config);
                     }
@@ -80,25 +100,25 @@ class RouterObject extends MiddlewareChain {
                 else {
                     context.path = match.params;
                 }
-                if (route.headers) {
-                    const error = parseHeaders(context, enableStringParsing(route.headers));
+                if (schema.headers) {
+                    const error = parseHeaders(context, enableStringParsing(schema.headers));
                     if (error) {
                         return httpClientError(error, 'Invalid request headers', config);
                     }
                 }
-                if (route.query) {
-                    const error = parseQueryString(context, enableStringParsing(route.query));
+                if (schema.query) {
+                    const error = parseQueryString(context, enableStringParsing(schema.query));
                     if (error) {
                         return httpClientError(error, 'Invalid query string', config);
                     }
                 }
-                if (route.body) {
-                    const error = await parseRequestBody(context, route.body);
+                if (schema.body) {
+                    const error = await parseRequestBody(context, schema.body);
                     if (error) {
                         return httpClientError(error, 'Invalid request body', config);
                     }
                 }
-                const result = await routeHandler(context);
+                const result = await handler(context);
                 if (result instanceof Response) {
                     return result;
                 }

package/dist/server/types.d.ts

@@ -28,6 +28,8 @@ type InferRouteRequestHandler<TMiddleware extends AnyMiddlewareChain, T, P exten
 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']>;
+    } & {
+        OPTIONS?: RouteRequestHandler<TMiddleware, {}, void>;
     };
 };
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rouzer",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "type": "module",
   "exports": {
     ".": {