bxo 0.0.5-dev.51 → 0.0.5-dev.53

package/src/utils/response-handler.ts

@@ -0,0 +1,216 @@
+import type { Context, InternalCookie } from '../types';
+import { validateResponse, mergeHeadersWithCookies } from './index';
+
+// Process and format the response from a route handler
+export function processResponse(
+  response: any,
+  ctx: Context,
+  internalCookies: InternalCookie[],
+  enableValidation: boolean,
+  routeConfig?: any
+): Response {
+  // If the handler did not return a response, but a redirect was configured via ctx.set,
+  // automatically create a redirect Response so users can call ctx.redirect(...) or set headers without returning.
+  const hasImplicitRedirectIntent = !!ctx.set.redirect
+    || (typeof ctx.set.status === 'number' && ctx.set.status >= 300 && ctx.set.status < 400);
+  
+  if ((response === undefined || response === null) && hasImplicitRedirectIntent) {
+    const locationFromHeaders = ctx.set.headers && Object.entries(ctx.set.headers).find(([k]) => k.toLowerCase() === 'location')?.[1];
+    const location = ctx.set.redirect?.location || locationFromHeaders;
+    if (location) {
+      // Build headers, ensuring Location is present
+      let responseHeaders: Record<string, string> = ctx.set.headers ? { ...ctx.set.headers } : {};
+      if (!Object.keys(responseHeaders).some(k => k.toLowerCase() === 'location')) {
+        responseHeaders['Location'] = location;
+      }
+      // Determine status precedence: redirect.status > set.status > 302
+      const status = ctx.set.redirect?.status ?? ctx.set.status ?? 302;
+
+      // Handle cookies if any are set
+      if (internalCookies.length > 0) {
+        const headers = mergeHeadersWithCookies(responseHeaders, internalCookies);
+        const finalHeaders: Record<string, string> = {};
+        headers.forEach((value, key) => {
+          finalHeaders[key] = value;
+        });
+        responseHeaders = finalHeaders;
+      }
+
+      return new Response(null, {
+        status,
+        headers: responseHeaders
+      });
+    }
+  }
+
+  // Validate response against schema if provided
+  if (enableValidation && routeConfig?.response && !(response instanceof Response)) {
+    try {
+      const status = ctx.set.status || 200;
+      response = validateResponse(routeConfig.response, response, status);
+    } catch (validationError) {
+      // Response validation failed
+      let validationDetails = undefined;
+      if (validationError instanceof Error) {
+        if ('errors' in validationError && Array.isArray(validationError.errors)) {
+          validationDetails = validationError.errors;
+        } else if ('issues' in validationError && Array.isArray(validationError.issues)) {
+          validationDetails = validationError.issues;
+        }
+      }
+
+      const errorMessage = validationDetails && validationDetails.length > 0
+        ? `Validation failed for ${validationDetails.length} field(s)`
+        : 'Validation failed';
+
+      return new Response(JSON.stringify({
+        error: errorMessage,
+        details: validationDetails
+      }), {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' }
+      });
+    }
+  }
+
+  // Convert response to Response object
+  if (response instanceof Response) {
+    // If there are headers set via ctx.set.headers, merge them with the Response headers
+    if (ctx.set.headers && Object.keys(ctx.set.headers).length > 0) {
+      const newHeaders = mergeHeadersWithCookies(ctx.set.headers, internalCookies);
+
+      // Create new Response with merged headers
+      return new Response(response.body, {
+        status: ctx.set.status || response.status,
+        statusText: response.statusText,
+        headers: newHeaders
+      });
+    }
+
+    return response;
+  }
+
+  // Handle File response (like Elysia)
+  if (response instanceof File || (typeof Bun !== 'undefined' && response instanceof Bun.file('').constructor)) {
+    const file = response as File;
+    const responseInit: ResponseInit = {
+      status: ctx.set.status || 200,
+      headers: {
+        'Content-Type': file.type || 'application/octet-stream',
+        'Content-Length': file.size.toString(),
+        ...ctx.set.headers
+      }
+    };
+    return new Response(file, responseInit);
+  }
+
+  // Handle Bun.file() response
+  if (typeof response === 'object' && response && 'stream' in response && 'size' in response) {
+    const bunFile = response as any;
+    const responseInit: ResponseInit = {
+      status: ctx.set.status || 200,
+      headers: {
+        'Content-Type': bunFile.type || 'application/octet-stream',
+        'Content-Length': bunFile.size?.toString() || '',
+        ...ctx.set.headers,
+        ...(bunFile.headers || {}) // Support custom headers from file helper
+      }
+    };
+    return new Response(bunFile, responseInit);
+  }
+
+  // Prepare headers with cookies
+  let responseHeaders = ctx.set.headers ? { ...ctx.set.headers } : {};
+
+  // Handle cookies if any are set
+  if (internalCookies.length > 0) {
+    const headers = mergeHeadersWithCookies(responseHeaders, internalCookies);
+
+    if (typeof response === 'string') {
+      headers.set('Content-Type', 'text/plain');
+      return new Response(response, {
+        status: ctx.set.status || 200,
+        headers: headers
+      });
+    }
+
+    headers.set('Content-Type', 'application/json');
+    return new Response(JSON.stringify(response), {
+      status: ctx.set.status || 200,
+      headers: headers
+    });
+  }
+
+  // If no cookies, use the original responseHeaders
+  const responseInit: ResponseInit = {
+    status: ctx.set.status || 200,
+    headers: responseHeaders
+  };
+
+  if (typeof response === 'string') {
+    return new Response(response, {
+      ...responseInit,
+      headers: {
+        'Content-Type': 'text/plain',
+        ...responseInit.headers
+      }
+    });
+  }
+
+  return new Response(JSON.stringify(response), {
+    ...responseInit,
+    headers: {
+      'Content-Type': 'application/json',
+      ...responseInit.headers
+    }
+  });
+}
+
+// Create error response
+export function createErrorResponse(
+  error: Error | string,
+  status: number = 500,
+  details?: any
+): Response {
+  const errorMessage = error instanceof Error ? error.message : error;
+  const response = {
+    error: errorMessage,
+    ...(details && { details })
+  };
+  
+  return new Response(JSON.stringify(response), {
+    status,
+    headers: { 'Content-Type': 'application/json' }
+  });
+}
+
+// Create validation error response
+export function createValidationErrorResponse(
+  validationError: any,
+  status: number = 400
+): Response {
+  let validationDetails = undefined;
+  
+  // Handle Error objects
+  if (validationError instanceof Error) {
+    if ('errors' in validationError && Array.isArray(validationError.errors)) {
+      validationDetails = validationError.errors;
+    } else if ('issues' in validationError && Array.isArray(validationError.issues)) {
+      validationDetails = validationError.issues;
+    }
+  }
+  // Handle plain objects with errors or issues properties
+  else if (validationError && typeof validationError === 'object') {
+    if ('errors' in validationError && Array.isArray(validationError.errors)) {
+      validationDetails = validationError.errors;
+    } else if ('issues' in validationError && Array.isArray(validationError.issues)) {
+      validationDetails = validationError.issues;
+    }
+  }
+
+  const errorMessage = validationDetails && validationDetails.length > 0
+    ? `Validation failed for ${validationDetails.length} field(s)`
+    : 'Validation failed';
+
+  return createErrorResponse(errorMessage, status, validationDetails);
+}

package/src/utils/route-matcher.ts

@@ -0,0 +1,191 @@
+import type { Route, WSRoute } from '../types';
+
+// Route matching utility for HTTP routes
+export function matchRoute(
+  method: string, 
+  pathname: string, 
+  routes: Route[]
+): { route: Route; params: Record<string, string> } | null {
+  for (const route of routes) {
+    if (route.method !== method) continue;
+
+    const routeSegments = route.path.split('/').filter(Boolean);
+    const pathSegments = pathname.split('/').filter(Boolean);
+
+    const params: Record<string, string> = {};
+    let isMatch = true;
+
+    // Check for wildcards in the route
+    const hasWildcards = routeSegments.some(segment => segment === '*' || segment === '**');
+
+    // Handle routes with wildcards
+    if (hasWildcards) {
+      isMatch = matchRouteWithWildcards(routeSegments, pathSegments, params);
+    } else {
+      // Exact matching for routes without wildcards
+      if (routeSegments.length !== pathSegments.length) {
+        continue;
+      }
+
+      for (let i = 0; i < routeSegments.length; i++) {
+        const routeSegment = routeSegments[i];
+        const pathSegment = pathSegments[i];
+
+        if (routeSegment.startsWith(':')) {
+          const paramName = routeSegment.slice(1);
+          params[paramName] = pathSegment;
+        } else if (routeSegment !== pathSegment) {
+          isMatch = false;
+          break;
+        }
+      }
+    }
+
+    if (isMatch) {
+      return { route, params };
+    }
+  }
+
+  return null;
+}
+
+// Helper function to match routes with wildcards
+function matchRouteWithWildcards(
+  routeSegments: string[],
+  pathSegments: string[],
+  params: Record<string, string>
+): boolean {
+  let routeIndex = 0;
+  let pathIndex = 0;
+  let wildcardCount = 0;
+
+  while (routeIndex < routeSegments.length && pathIndex < pathSegments.length) {
+    const routeSegment = routeSegments[routeIndex];
+    const pathSegment = pathSegments[pathIndex];
+
+    if (routeSegment === '**') {
+      // Double wildcard - find the next non-wildcard segment
+      let nextNonWildcardIndex = routeIndex + 1;
+      while (nextNonWildcardIndex < routeSegments.length &&
+        (routeSegments[nextNonWildcardIndex] === '*' || routeSegments[nextNonWildcardIndex] === '**')) {
+        nextNonWildcardIndex++;
+      }
+
+      if (nextNonWildcardIndex >= routeSegments.length) {
+        // Double wildcard at the end - capture everything remaining
+        const remainingPath = pathSegments.slice(pathIndex).join('/');
+        params[`**${wildcardCount}`] = remainingPath;
+        return true;
+      }
+
+      // Find the next matching segment in the path
+      const nextRouteSegment = routeSegments[nextNonWildcardIndex];
+      let foundMatch = false;
+
+      for (let j = pathIndex; j < pathSegments.length; j++) {
+        const currentPathSegment = pathSegments[j];
+
+        if (nextRouteSegment.startsWith(':')) {
+          // Param segment - always matches
+          const matchedPath = pathSegments.slice(pathIndex, j).join('/');
+          params[`**${wildcardCount}`] = matchedPath;
+          pathIndex = j;
+          routeIndex = nextNonWildcardIndex;
+          foundMatch = true;
+          break;
+        } else if (nextRouteSegment === '*') {
+          // Single wildcard - always matches
+          const matchedPath = pathSegments.slice(pathIndex, j).join('/');
+          params[`**${wildcardCount}`] = matchedPath;
+          pathIndex = j;
+          routeIndex = nextNonWildcardIndex;
+          foundMatch = true;
+          break;
+        } else if (nextRouteSegment === currentPathSegment) {
+          // Exact match
+          const matchedPath = pathSegments.slice(pathIndex, j).join('/');
+          params[`**${wildcardCount}`] = matchedPath;
+          pathIndex = j;
+          routeIndex = nextNonWildcardIndex;
+          foundMatch = true;
+          break;
+        }
+      }
+
+      if (!foundMatch) {
+        return false;
+      }
+
+      wildcardCount++;
+      continue;
+    } else if (routeSegment === '*') {
+      // Single wildcard - capture one segment
+      params[`*${wildcardCount}`] = pathSegment;
+      wildcardCount++;
+      routeIndex++;
+      pathIndex++;
+    } else if (routeSegment.startsWith(':')) {
+      // Parameter segment
+      const paramName = routeSegment.slice(1);
+      params[paramName] = pathSegment;
+      routeIndex++;
+      pathIndex++;
+    } else if (routeSegment === pathSegment) {
+      // Exact match
+      routeIndex++;
+      pathIndex++;
+    } else {
+      // No match
+      return false;
+    }
+  }
+
+  // Check if we've processed all route segments
+  return routeIndex >= routeSegments.length && pathIndex >= pathSegments.length;
+}
+
+// WebSocket route matching utility
+export function matchWSRoute(
+  pathname: string, 
+  routes: WSRoute[]
+): { route: WSRoute; params: Record<string, string> } | null {
+  for (const route of routes) {
+    const routeSegments = route.path.split('/').filter(Boolean);
+    const pathSegments = pathname.split('/').filter(Boolean);
+
+    const params: Record<string, string> = {};
+    let isMatch = true;
+
+    // Check for wildcards in the route
+    const hasWildcards = routeSegments.some(segment => segment === '*' || segment === '**');
+
+    // Handle routes with wildcards
+    if (hasWildcards) {
+      isMatch = matchRouteWithWildcards(routeSegments, pathSegments, params);
+    } else {
+      // Exact matching for routes without wildcards
+      if (routeSegments.length !== pathSegments.length) {
+        continue;
+      }
+
+      for (let i = 0; i < routeSegments.length; i++) {
+        const routeSegment = routeSegments[i];
+        const pathSegment = pathSegments[i];
+
+        if (routeSegment.startsWith(':')) {
+          const paramName = routeSegment.slice(1);
+          params[paramName] = pathSegment;
+        } else if (routeSegment !== pathSegment) {
+          isMatch = false;
+          break;
+        }
+      }
+    }
+
+    if (isMatch) {
+      return { route, params };
+    }
+  }
+
+  return null;
+}