@hyperspan/framework 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperspan/framework",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Hyperspan Web Framework",
   "main": "src/server.ts",
   "types": "src/server.ts",

package/src/actions.test.ts

@@ -2,7 +2,6 @@ import { test, expect, describe } from 'bun:test';
 import { createAction } from './actions';
 import { html, render, type HSHtml } from '@hyperspan/html';
 import { createContext } from './server';
-import type { Hyperspan as HS } from './types';
 import * as z from 'zod/v4';
 
 describe('createAction', () => {

package/src/server.test.ts

@@ -67,6 +67,34 @@ test('server returns a route with a POST request', async () => {
   expect(await response.text()).toBe('<h1>POST /users</h1>');
 });
 
+test('server returns a route with a ALL request', async () => {
+  const server = await createServer({
+    appDir: './app',
+    publicDir: './public',
+    plugins: [],
+  });
+
+  server.all('/users', (context: HS.Context) => {
+    return context.res.html('<h1>ALL /users</h1>');
+  });
+
+  const route = server._routes.find((route: HS.Route) => route._path() === '/users' && route._methods().includes('*')) as HS.Route;
+
+  // GET request
+  let request = new Request('http://localhost:3000/users', { method: 'GET' });
+  let response = await route.fetch(request);
+  expect(response).toBeInstanceOf(Response);
+  expect(response.status).toBe(200);
+  expect(await response.text()).toBe('<h1>ALL /users</h1>');
+
+  // POST request
+  request = new Request('http://localhost:3000/users', { method: 'POST' });
+  response = await route.fetch(request);
+  expect(response).toBeInstanceOf(Response);
+  expect(response.status).toBe(200);
+  expect(await response.text()).toBe('<h1>ALL /users</h1>');
+});
+
 test('returns 405 when route path matches but HTTP method does not', async () => {
   const server = await createServer({
     appDir: './app',
@@ -144,7 +172,7 @@ test('createContext() can get and set cookies', () => {
   }
 });
 
-test('createContext() merge() function preserves custom headers when using response methods', () => {
+test('createContext() merge() function preserves custom headers when using response methods', async () => {
   // Create a request
   const request = new Request('http://localhost:3000/');
 
@@ -157,7 +185,7 @@ test('createContext() merge() function preserves custom headers when using respo
   context.res.headers.set('Authorization', 'Bearer token123');
 
   // Use html() method which should merge headers
-  const response = context.res.html('<h1>Test</h1>');
+  const response = await context.res.html('<h1>Test</h1>');
 
   // Verify the response has both the custom headers and the Content-Type header
   expect(response.headers.get('X-Custom-Header')).toBe('custom-value');
@@ -169,7 +197,7 @@ test('createContext() merge() function preserves custom headers when using respo
   expect(response.status).toBe(200);
 });
 
-test('createContext() merge() function preserves custom headers with json() method', () => {
+test('createContext() merge() function preserves custom headers with json() method', async () => {
   const request = new Request('http://localhost:3000/');
   const context = createContext(request);
 
@@ -178,7 +206,7 @@ test('createContext() merge() function preserves custom headers with json() meth
   context.res.headers.set('X-Request-ID', 'req-123');
 
   // Use json() method
-  const response = context.res.json({ message: 'Hello' });
+  const response = await context.res.json({ message: 'Hello' });
 
   // Verify headers are merged
   expect(response.headers.get('X-API-Version')).toBe('v1');
@@ -186,7 +214,7 @@ test('createContext() merge() function preserves custom headers with json() meth
   expect(response.headers.get('Content-Type')).toBe('application/json');
 });
 
-test('createContext() merge() function allows response headers to override context headers', () => {
+test('createContext() merge() function allows response headers to override context headers', async () => {
   const request = new Request('http://localhost:3000/');
   const context = createContext(request);
 
@@ -194,7 +222,7 @@ test('createContext() merge() function allows response headers to override conte
   context.res.headers.set('X-Header', 'context-value');
 
   // Use html() with options that include the same header (should override)
-  const response = context.res.html('<h1>Test</h1>', {
+  const response = await context.res.html('<h1>Test</h1>', {
     headers: {
       'X-Header': 'response-value',
     },

package/src/server.ts

@@ -64,14 +64,14 @@ export function createContext(req: Request, route?: HS.Route): HS.Context {
   // Status override for the response. Will use if set. (e.g. c.res.status = 400)
   let status: number | undefined = undefined;
 
-  const merge = (response: Response) => {
+  const merge = async (response: Response) => {
     // Convert headers to plain objects and merge (response headers override context headers)
     const mergedHeaders = {
       ...Object.fromEntries(headers.entries()),
       ...Object.fromEntries(response.headers.entries()),
     };
 
-    return new Response(response.body, {
+    return new Response(await response.text(), {
       status: context.res.status ?? response.status,
       headers: mergedHeaders,
     });
@@ -184,6 +184,14 @@ export function createRoute(config: Partial<HS.RouteConfig> = {}): HS.Route {
       _middleware['OPTIONS'] = handlerOptions?.middleware || [];
       return api;
     },
+    /**
+     * Add a ALL route handler (typically to handle all HTTP methods)
+     */
+    all(handler: HS.RouteHandler, handlerOptions?: HS.RouteHandlerOptions) {
+      _handlers['*'] = handler;
+      _middleware['*'] = handlerOptions?.middleware || [];
+      return api;
+    },
     /**
      * Set a custom error handler for this route to fall back to if the route handler throws an error
      */
@@ -192,7 +200,15 @@ export function createRoute(config: Partial<HS.RouteConfig> = {}): HS.Route {
       return api;
     },
     /**
-     * Add middleware specific to this route
+     * Add a middleware function to this route (for all HTTP methods) (non-destructive)
+     */
+    use(middleware: HS.MiddlewareFunction) {
+      _middleware['*'].push(middleware);
+      return api;
+    },
+    /**
+     * Set the complete middleware stack for this route (for all HTTP methods) (destructive)
+     * NOTE: This will override the middleware stack for this route
      */
     middleware(middleware: Array<HS.MiddlewareFunction>) {
       _middleware['*'] = middleware;
@@ -231,7 +247,7 @@ export function createRoute(config: Partial<HS.RouteConfig> = {}): HS.Route {
           );
         }
 
-        const handler = method === 'HEAD' ? _handlers['GET'] : _handlers[method];
+        const handler = (method === 'HEAD' ? _handlers['GET'] : _handlers[method]) ?? _handlers['*'];
 
         if (!handler) {
           return context.res.error(new Error('Method not allowed'), { status: 405 });
@@ -332,6 +348,12 @@ export async function createServer(config: HS.Config = {} as HS.Config): Promise
       _routes.push(route);
       return route;
     },
+    all(path: string, handler: HS.RouteHandler, handlerOptions?: HS.RouteHandlerOptions) {
+      const route = createRoute().all(handler, handlerOptions);
+      route._config.path = path;
+      _routes.push(route);
+      return route;
+    },
   };
 
   return api;

package/src/types.ts

@@ -16,6 +16,7 @@ export namespace Hyperspan {
     patch: (path: string, handler: Hyperspan.RouteHandler, handlerOptions?: Hyperspan.RouteHandlerOptions) => Hyperspan.Route;
     delete: (path: string, handler: Hyperspan.RouteHandler, handlerOptions?: Hyperspan.RouteHandlerOptions) => Hyperspan.Route;
     options: (path: string, handler: Hyperspan.RouteHandler, handlerOptions?: Hyperspan.RouteHandlerOptions) => Hyperspan.Route;
+    all: (path: string, handler: Hyperspan.RouteHandler, handlerOptions?: Hyperspan.RouteHandlerOptions) => Hyperspan.Route;
   };
 
   export type Plugin = (config: Hyperspan.Config) => Promise<void> | void;
@@ -69,13 +70,13 @@ export namespace Hyperspan {
     cookies: Hyperspan.Cookies;
     headers: Headers; // Headers to merge with final outgoing response
     status: number | undefined;
-    html: (html: string, options?: ResponseInit) => Response
-    json: (json: any, options?: ResponseInit) => Response;
-    text: (text: string, options?: ResponseInit) => Response;
-    redirect: (url: string, options?: ResponseInit) => Response;
-    error: (error: Error, options?: ResponseInit) => Response;
-    notFound: (options?: ResponseInit) => Response;
-    merge: (response: Response) => Response;
+    html: (html: string, options?: ResponseInit) => Promise<Response>;
+    json: (json: any, options?: ResponseInit) => Promise<Response>;
+    text: (text: string, options?: ResponseInit) => Promise<Response>;
+    redirect: (url: string, options?: ResponseInit) => Promise<Response>;
+    error: (error: Error, options?: ResponseInit) => Promise<Response>;
+    notFound: (options?: ResponseInit) => Promise<Response>;
+    merge: (response: Response) => Promise<Response>;
   };
 
   export interface Context {
@@ -145,7 +146,9 @@ export namespace Hyperspan {
     patch: (handler: Hyperspan.RouteHandler, handlerOptions?: Hyperspan.RouteHandlerOptions) => Hyperspan.Route;
     delete: (handler: Hyperspan.RouteHandler, handlerOptions?: Hyperspan.RouteHandlerOptions) => Hyperspan.Route;
     options: (handler: Hyperspan.RouteHandler, handlerOptions?: Hyperspan.RouteHandlerOptions) => Hyperspan.Route;
+    all: (handler: Hyperspan.RouteHandler, handlerOptions?: Hyperspan.RouteHandlerOptions) => Hyperspan.Route;
     errorHandler: (handler: Hyperspan.ErrorHandler) => Hyperspan.Route;
+    use: (middleware: Hyperspan.MiddlewareFunction) => Hyperspan.Route;
     middleware: (middleware: Array<Hyperspan.MiddlewareFunction>) => Hyperspan.Route;
     fetch: (request: Request) => Promise<Response>;
   };