@hyperspan/framework 1.0.0-alpha.10 → 1.0.0-alpha.12

package/package.json

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

package/src/index.ts

@@ -1,2 +1,2 @@
-export { createConfig, createContext, createRoute, createServer, getRunnableRoute, StreamResponse, IS_PROD, HTTPException } from './server';
+export { createConfig, createContext, createRoute, createServer, getRunnableRoute, StreamResponse, IS_PROD, HTTPResponseException } from './server';
 export type { Hyperspan } from './types';

package/src/server.test.ts

@@ -113,7 +113,7 @@ test('createContext() can get and set cookies', () => {
   expect(setCookieHeader).toBeTruthy();
   expect(setCookieHeader).toContain('newCookie=newValue');
 
-  // Test setting a cookie with options (this will overwrite the previous Set-Cookie header)
+  // Test setting a cookie with options (this should NOT overwrite the previous Set-Cookie header)
   context.res.cookies.set('secureCookie', 'secureValue', {
     httpOnly: true,
     secure: true,
@@ -125,13 +125,7 @@ test('createContext() can get and set cookies', () => {
   setCookieHeader = context.res.headers.get('Set-Cookie');
   expect(setCookieHeader).toBeTruthy();
   expect(setCookieHeader).toContain('secureCookie=secureValue');
-  expect(setCookieHeader).toContain('HttpOnly');
-  expect(setCookieHeader).toContain('Secure');
-  expect(setCookieHeader).toContain('SameSite=Strict');
-  expect(setCookieHeader).toContain('Max-Age=3600');
-
-  // Verify the previous cookie was overwritten
-  expect(setCookieHeader).not.toContain('newCookie=newValue');
+  expect(setCookieHeader).toContain('newCookie=newValue');
 
   // Test deleting a cookie
   context.res.cookies.delete('sessionId');

package/src/server.ts

@@ -5,12 +5,15 @@ import { parsePath } from './utils';
 import { Cookies } from './cookies';
 
 import type { Hyperspan as HS } from './types';
+import { RequestOptions } from 'node:http';
 
 export const IS_PROD = process.env.NODE_ENV === 'production';
 
-export class HTTPException extends Error {
-  constructor(public status: number, message?: string) {
-    super(message);
+export class HTTPResponseException extends Error {
+  public _response?: Response;
+  constructor(body: string | undefined, options?: ResponseInit) {
+    super(body);
+    this._response = new Response(body, options);
   }
 }
 
@@ -36,7 +39,15 @@ export function createContext(req: Request, route?: HS.Route): HS.Context {
   const headers = new Headers(req.headers);
   const path = route?._path() || '/';
   // @ts-ignore - Bun will put 'params' on the Request object even though it's not standardized
-  const params: HS.RouteParamsParser<path> = req?.params || {};
+  const params: HS.RouteParamsParser<path> & Record<string, string | undefined> = Object.assign({}, req?.params || {}, route?._config.params || {});
+
+  // Replace catch-all param with the value from the URL path
+  const catchAllParam = Object.keys(params).find(key => key.startsWith('...'));
+  if (catchAllParam && path.includes('/*')) {
+    const catchAllValue = url.pathname.split(path.replace('/*', '/')).pop();
+    params[catchAllParam.replace('...', '')] = catchAllValue;
+    delete params[catchAllParam];
+  }
 
   const merge = (response: Response) => {
     // Convert headers to plain objects and merge (response headers override context headers)
@@ -74,12 +85,12 @@ export function createContext(req: Request, route?: HS.Route): HS.Context {
       cookies: new Cookies(req, headers),
       headers,
       raw: new Response(),
-      html: (html: string, options?: { status?: number; headers?: Headers | Record<string, string> }) => merge(new Response(html, { ...options, headers: { 'Content-Type': 'text/html; charset=UTF-8', ...options?.headers } })),
-      json: (json: any, options?: { status?: number; headers?: Headers | Record<string, string> }) => merge(new Response(JSON.stringify(json), { ...options, headers: { 'Content-Type': 'application/json', ...options?.headers } })),
-      text: (text: string, options?: { status?: number; headers?: Headers | Record<string, string> }) => merge(new Response(text, { ...options, headers: { 'Content-Type': 'text/plain; charset=UTF-8', ...options?.headers } })),
-      redirect: (url: string, options?: { status?: number; headers?: Headers | Record<string, string> }) => merge(new Response(null, { status: 302, headers: { Location: url, ...options?.headers } })),
-      error: (error: Error, options?: { status?: number; headers?: Headers | Record<string, string> }) => merge(new Response(error.message, { status: 500, ...options })),
-      notFound: (options?: { status?: number; headers?: Headers | Record<string, string> }) => merge(new Response('Not Found', { status: 404, ...options })),
+      html: (html: string, options?: ResponseInit) => merge(new Response(html, { ...options, headers: { 'Content-Type': 'text/html; charset=UTF-8', ...options?.headers } })),
+      json: (json: any, options?: ResponseInit) => merge(new Response(JSON.stringify(json), { ...options, headers: { 'Content-Type': 'application/json', ...options?.headers } })),
+      text: (text: string, options?: ResponseInit) => merge(new Response(text, { ...options, headers: { 'Content-Type': 'text/plain; charset=UTF-8', ...options?.headers } })),
+      redirect: (url: string, options?: ResponseInit) => merge(new Response(null, { status: 302, headers: { Location: url, ...options?.headers } })),
+      error: (error: Error, options?: ResponseInit) => merge(new Response(error.message, { status: 500, ...options })),
+      notFound: (options?: ResponseInit) => merge(new Response('Not Found', { status: 404, ...options })),
       merge,
     },
   };
@@ -398,8 +409,8 @@ async function showErrorReponse(
   const message = err.message || 'Internal Server Error';
 
   // Send correct status code if HTTPException
-  if (err instanceof HTTPException) {
-    status = err.status;
+  if (err instanceof HTTPResponseException) {
+    status = err._response?.status ?? 500;
   }
 
   const stack = !IS_PROD && err.stack ? err.stack.split('\n').slice(1).join('\n') : '';

package/src/types.ts

@@ -49,37 +49,37 @@ export namespace Hyperspan {
     delete: (name: string) => void;
   }
 
+  export type HSRequest = {
+    url: URL;
+    raw: Request;
+    method: string; // Always uppercase
+    headers: Headers; // Case-insensitive
+    query: URLSearchParams;
+    cookies: Hyperspan.Cookies;
+    text: () => Promise<string>;
+    json<T = unknown>(): Promise<T>;
+    formData(): Promise<FormData>;
+    urlencoded(): Promise<URLSearchParams>;
+  };
+
+  export type HSResponse = {
+    cookies: Hyperspan.Cookies;
+    headers: Headers; // Headers to merge with final outgoing response
+    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;
+    raw: Response;
+  };
+
   export interface Context {
     vars: Record<string, any>;
-    route: {
-      path: string;
-      params: Record<string, string>;
-      cssImports?: string[];
-    }
-    req: {
-      url: URL;
-      raw: Request;
-      method: string; // Always uppercase
-      headers: Headers; // Case-insensitive
-      query: URLSearchParams;
-      cookies: Hyperspan.Cookies;
-      text: () => Promise<string>;
-      json<T = unknown>(): Promise<T>;
-      formData(): Promise<FormData>;
-      urlencoded(): Promise<URLSearchParams>;
-    };
-    res: {
-      cookies: Hyperspan.Cookies;
-      headers: Headers; // Headers to merge with final outgoing response
-      html: (html: string, options?: { status?: number; headers?: Record<string, string> }) => Response
-      json: (json: any, options?: { status?: number; headers?: Record<string, string> }) => Response;
-      text: (text: string, options?: { status?: number; headers?: Record<string, string> }) => Response;
-      redirect: (url: string, options?: { status?: number; headers?: Record<string, string> }) => Response;
-      error: (error: Error, options?: { status?: number; headers?: Record<string, string> }) => Response;
-      notFound: (options?: { status?: number; headers?: Record<string, string> }) => Response;
-      merge: (response: Response) => Response;
-      raw: Response;
-    };
+    route: RouteConfig;
+    req: HSRequest;
+    res: HSResponse;
   };
 
   export type ClientIslandOptions = {
@@ -90,6 +90,7 @@ export namespace Hyperspan {
   export type RouteConfig = {
     name?: string;
     path?: string;
+    params?: Record<string, string | undefined>;
     cssImports?: string[];
   };
   export type RouteHandler = (context: Hyperspan.Context) => unknown;

package/src/utils.test.ts

@@ -149,13 +149,13 @@ describe('parsePath', () => {
   test('parsePath handles catch-all param with spread', () => {
     const result = parsePath('users/[...slug]');
     expect(result.path).toBe('/users/*');
-    expect(result.params).toEqual(['slug']);
+    expect(result.params).toEqual(['...slug']);
   });
 
   test('parsePath handles catch-all param at root', () => {
     const result = parsePath('[...slug]');
     expect(result.path).toBe('/*');
-    expect(result.params).toEqual(['slug']);
+    expect(result.params).toEqual(['...slug']);
   });
 
   test('parsePath preserves param names in path but converts format', () => {

package/src/utils.ts

@@ -33,7 +33,7 @@ export function parsePath(urlPath: string): { path: string, params: string[] } {
   // Dynamic params
   if (ROUTE_SEGMENT_REGEX.test(urlPath)) {
     urlPath = urlPath.replace(ROUTE_SEGMENT_REGEX, (match: string) => {
-      const paramName = match.replace(/[^a-zA-Z_\.]+/g, '').replace('...', '');
+      const paramName = match.replace(/[^a-zA-Z_\.]+/g, '');
       params.push(paramName);
 
       if (match.includes('...')) {