bxo 0.0.5-dev.50 → 0.0.5-dev.52

package/src/index.ts

@@ -0,0 +1,54 @@
+// Main BXO class
+export { default as BXO } from './core/bxo';
+
+// Export Zod for convenience
+export { z } from 'zod';
+
+// Export helper functions
+export { error, file, redirect, createCookieOptions } from './utils/helpers';
+
+// Export utility functions
+export {
+  parseQuery,
+  parseHeaders,
+  parseCookies,
+  validateData,
+  validateResponse,
+  parseRequestBody,
+  cookiesToHeaders,
+  mergeHeadersWithCookies,
+  createRedirectResponse,
+  isFileUpload,
+  getFileFromUpload,
+  getFileInfo,
+  saveUploadedFile,
+  getFileUploads,
+  getFormFields
+} from './utils';
+
+// Export route matching utilities
+export { matchRoute, matchWSRoute } from './utils/route-matcher';
+
+// Export context factory utilities
+export { createContext, createOptionsContext, getInternalCookies } from './utils/context-factory';
+
+// Export response handler utilities
+export { processResponse, createErrorResponse, createValidationErrorResponse } from './utils/response-handler';
+
+// Export types for external use
+export type {
+  RouteConfig,
+  RouteDetail,
+  Handler,
+  WebSocketHandler,
+  WSRoute,
+  CookieOptions,
+  BXOOptions,
+  Plugin,
+  Context,
+  FileUpload,
+  FormData
+} from './types';
+
+// Re-export everything from the main BXO class for backward compatibility
+export { default } from './core/bxo';

package/src/types/index.ts

@@ -0,0 +1,170 @@
+import { z } from 'zod';
+
+// Type utilities for extracting types from Zod schemas
+export type InferZodType<T> = T extends z.ZodType<infer U> ? U : never;
+
+// Response configuration types
+export type ResponseSchema = z.ZodSchema<any>;
+export type StatusResponseSchema = Record<number, ResponseSchema>;
+export type ResponseConfig = ResponseSchema | StatusResponseSchema;
+
+// Type utility to extract response type from response config
+export type InferResponseType<T> = T extends ResponseSchema
+  ? InferZodType<T>
+  : T extends StatusResponseSchema
+  ? { [K in keyof T]: InferZodType<T[K]> }[number]
+  : never;
+
+// Cookie options interface for setting cookies
+export interface CookieOptions {
+  domain?: string;
+  path?: string;
+  expires?: Date;
+  maxAge?: number;
+  secure?: boolean;
+  httpOnly?: boolean;
+  sameSite?: 'Strict' | 'Lax' | 'None';
+}
+
+// OpenAPI detail information
+export interface RouteDetail {
+  summary?: string;
+  description?: string;
+  tags?: string[];
+  operationId?: string;
+  deprecated?: boolean;
+  produces?: string[];
+  consumes?: string[];
+  [key: string]: any; // Allow additional OpenAPI properties
+}
+
+// Configuration interface for route handlers
+export interface RouteConfig {
+  params?: z.ZodSchema<any>;
+  query?: z.ZodSchema<any>;
+  body?: z.ZodSchema<any>;
+  headers?: z.ZodSchema<any>;
+  cookies?: z.ZodSchema<any>;
+  response?: ResponseConfig;
+  detail?: RouteDetail;
+}
+
+// Helper type to extract status codes from response config
+export type StatusCodes<T> = T extends Record<number, any> ? keyof T : never;
+
+// Context type that's fully typed based on the route configuration
+export type Context<TConfig extends RouteConfig = {}> = {
+  params: TConfig['params'] extends z.ZodSchema<any> ? InferZodType<TConfig['params']> : Record<string, string>;
+  query: TConfig['query'] extends z.ZodSchema<any> ? InferZodType<TConfig['query']> : Record<string, string | undefined>;
+  body: TConfig['body'] extends z.ZodSchema<any> ? InferZodType<TConfig['body']> : unknown;
+  headers: TConfig['headers'] extends z.ZodSchema<any> ? InferZodType<TConfig['headers']> : Record<string, string>;
+  cookies: TConfig['cookies'] extends z.ZodSchema<any> ? InferZodType<TConfig['cookies']> : Record<string, string>;
+  path: string;
+  request: Request;
+  set: {
+    status: number;
+    headers: Record<string, string>;
+    cookies: (name: string, value: string, options?: CookieOptions) => void;
+    redirect?: { location: string; status?: number };
+  };
+  status: <T extends number>(
+    code: TConfig['response'] extends StatusResponseSchema
+      ? StatusCodes<TConfig['response']> | number
+      : T,
+    data?: TConfig['response'] extends StatusResponseSchema
+      ? T extends keyof TConfig['response']
+      ? InferZodType<TConfig['response'][T]>
+      : any
+      : TConfig['response'] extends ResponseSchema
+      ? InferZodType<TConfig['response']>
+      : any
+  ) => TConfig['response'] extends StatusResponseSchema
+    ? T extends keyof TConfig['response']
+    ? InferZodType<TConfig['response'][T]>
+    : any
+    : TConfig['response'] extends ResponseSchema
+    ? InferZodType<TConfig['response']>
+    : any;
+  redirect: (location: string, status?: number) => Response;
+  clearRedirect: () => void;
+  [key: string]: any;
+};
+
+// Internal cookie storage interface
+export interface InternalCookie {
+  name: string;
+  value: string;
+  domain?: string;
+  path?: string;
+  expires?: Date;
+  maxAge?: number;
+  secure?: boolean;
+  httpOnly?: boolean;
+  sameSite?: 'Strict' | 'Lax' | 'None';
+}
+
+// Handler function type with proper response typing
+export type Handler<TConfig extends RouteConfig = {}, EC = {}> = (
+  ctx: Context<TConfig> & EC
+) => Promise<InferResponseType<TConfig['response']> | any> | InferResponseType<TConfig['response']> | any;
+
+// Route definition
+export interface Route {
+  method: string;
+  path: string;
+  handler: Handler<any>;
+  config?: RouteConfig;
+}
+
+// WebSocket handler interface
+export interface WebSocketHandler {
+  onOpen?: (ws: any) => void;
+  onMessage?: (ws: any, message: string | Buffer) => void;
+  onClose?: (ws: any, code?: number, reason?: string) => void;
+  onError?: (ws: any, error: Error) => void;
+}
+
+// WebSocket route definition
+export interface WSRoute {
+  path: string;
+  handler: WebSocketHandler;
+}
+
+// Lifecycle hooks
+export interface LifecycleHooks {
+  onBeforeStart?: (instance: any) => Promise<void> | void;
+  onAfterStart?: (instance: any) => Promise<void> | void;
+  onBeforeStop?: (instance: any) => Promise<void> | void;
+  onAfterStop?: (instance: any) => Promise<void> | void;
+  onRequest?: (ctx: Context, instance: any) => Promise<void> | void;
+  onResponse?: (ctx: Context, response: any, instance: any) => Promise<any> | any;
+  onError?: (ctx: Context, error: Error, instance: any) => Promise<any> | any;
+}
+
+// BXO options interface
+export interface BXOOptions {
+  enableValidation?: boolean;
+}
+
+// Plugin interface for middleware-style plugins
+export interface Plugin {
+  name?: string;
+  onRequest?: (ctx: Context) => Promise<Response | void> | Response | void;
+  onResponse?: (ctx: Context, response: any) => Promise<any> | any;
+  onError?: (ctx: Context, error: Error) => Promise<any> | any;
+}
+
+// File upload types
+export interface FileUpload {
+  type: 'file';
+  name: string;
+  size: number;
+  lastModified: number;
+  file: File;
+  filename: string;
+  mimetype: string;
+}
+
+export interface FormData {
+  [key: string]: string | FileUpload;
+}

package/src/utils/context-factory.ts

@@ -0,0 +1,158 @@
+import type { Context, RouteConfig, InternalCookie, CookieOptions } from '../types';
+import { validateData } from './index';
+
+// Create a context object with validation
+export function createContext<TConfig extends RouteConfig = {}>(
+  params: Record<string, string>,
+  query: Record<string, string | undefined>,
+  body: any,
+  headers: Record<string, string>,
+  cookies: Record<string, string>,
+  pathname: string,
+  request: Request,
+  config: RouteConfig | undefined,
+  enableValidation: boolean
+): Context<TConfig> {
+  // Create internal cookie storage
+  const internalCookies: InternalCookie[] = [];
+
+  // Create context with validation
+  const ctx: Context<TConfig> = {
+    params: enableValidation && config?.params ? validateData(config.params, params) : params,
+    query: enableValidation && config?.query ? validateData(config.query, query) : query,
+    body: enableValidation && config?.body ? validateData(config.body, body) : body,
+    headers: enableValidation && config?.headers ? validateData(config.headers, headers) : headers,
+    cookies: enableValidation && config?.cookies ? validateData(config.cookies, cookies) : cookies,
+    path: pathname,
+    request,
+    set: {
+      status: 200,
+      headers: {},
+      cookies: (name: string, value: string, options?: CookieOptions) => {
+        internalCookies.push({
+          name,
+          value,
+          domain: options?.domain,
+          path: options?.path,
+          expires: options?.expires,
+          maxAge: options?.maxAge,
+          secure: options?.secure,
+          httpOnly: options?.httpOnly,
+          sameSite: options?.sameSite
+        });
+      }
+    },
+    status: ((code: number, data?: any) => {
+      ctx.set.status = code;
+      return data;
+    }) as any,
+    redirect: ((location: string, status: number = 302) => {
+      // Record redirect intent only; avoid mutating generic status/headers so it can be canceled later
+      ctx.set.redirect = { location, status };
+
+      // Prepare headers for immediate Response return without persisting to ctx.set.headers
+      const responseHeaders = new Headers();
+      responseHeaders.set('Location', location);
+
+      // Add any additional headers from ctx.set.headers
+      if (ctx.set.headers) {
+        Object.entries(ctx.set.headers).forEach(([key, value]) => {
+          responseHeaders.set(key, value);
+        });
+      }
+
+      // Handle cookies if any are set on context
+      if (internalCookies.length > 0) {
+        const cookieHeaders = internalCookies.map(cookie => {
+          let cookieString = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`;
+          if (cookie.domain) cookieString += `; Domain=${cookie.domain}`;
+          if (cookie.path) cookieString += `; Path=${cookie.path}`;
+          if (cookie.expires) cookieString += `; Expires=${cookie.expires.toUTCString()}`;
+          if (cookie.maxAge) cookieString += `; Max-Age=${cookie.maxAge}`;
+          if (cookie.secure) cookieString += `; Secure`;
+          if (cookie.httpOnly) cookieString += `; HttpOnly`;
+          if (cookie.sameSite) cookieString += `; SameSite=${cookie.sameSite}`;
+          return cookieString;
+        });
+        // Set multiple Set-Cookie headers properly
+        cookieHeaders.forEach(cookieHeader => {
+          responseHeaders.append('Set-Cookie', cookieHeader);
+        });
+      }
+
+      return new Response(null, {
+        status,
+        headers: responseHeaders
+      });
+    }) as any,
+    clearRedirect: (() => {
+      // Clear explicit redirect intent
+      delete ctx.set.redirect;
+      // Remove any Location header if present
+      if (ctx.set.headers) {
+        for (const key of Object.keys(ctx.set.headers)) {
+          if (key.toLowerCase() === 'location') {
+            delete ctx.set.headers[key];
+          }
+        }
+      }
+      // Reset status if it is a redirect
+      if (typeof ctx.set.status === 'number' && ctx.set.status >= 300 && ctx.set.status < 400) {
+        ctx.set.status = 200;
+      }
+    }) as any
+  };
+
+  // Store internal cookies for later use
+  (ctx as any)._internalCookies = internalCookies;
+
+  return ctx;
+}
+
+// Get internal cookies from context
+export function getInternalCookies(ctx: Context): InternalCookie[] {
+  return (ctx as any)._internalCookies || [];
+}
+
+// Create a minimal context for OPTIONS requests
+export function createOptionsContext(
+  pathname: string,
+  request: Request,
+  headers: Record<string, string>
+): Context {
+  return {
+    params: {},
+    query: {},
+    body: {},
+    headers,
+    cookies: {},
+    path: pathname,
+    request,
+    set: {
+      status: 200,
+      headers: {},
+      cookies: (name: string, value: string, options?: CookieOptions) => {
+        // This is a placeholder for setting cookies.
+        // In a real Bun.serve context, you'd use Bun.serve's cookie handling.
+        // For now, we'll just log it or throw an error if not Bun.serve.
+        console.warn(`Setting cookie '${name}' with value '${value}' via ctx.set.cookies is not directly supported by Bun.serve. Use Bun.serve's cookie handling.`);
+      },
+      redirect: undefined
+    },
+    status: ((code: number, data?: any) => {
+      return data;
+    }) as any,
+    redirect: ((location: string, status: number = 302) => {
+      const responseHeaders: Record<string, string> = {
+        Location: location
+      };
+      return new Response(null, {
+        status,
+        headers: responseHeaders
+      });
+    }) as any,
+    clearRedirect: (() => {
+      // No-op for options context
+    }) as any
+  };
+}

package/src/utils/helpers.ts

@@ -0,0 +1,40 @@
+import type { CookieOptions } from '../types';
+
+// Error helper function
+export const error = (error: Error | string, status: number = 500) => {
+  return new Response(JSON.stringify({ error: error instanceof Error ? error.message : error }), { 
+    status,
+    headers: { 'Content-Type': 'application/json' }
+  });
+};
+
+// File helper function (like Elysia)
+export const file = (path: string, options?: { type?: string; headers?: Record<string, string> }) => {
+  const bunFile = Bun.file(path);
+
+  if (options?.type || options?.headers) {
+    // Create a wrapper to override the MIME type and/or headers
+    return {
+      ...bunFile,
+      type: options.type || bunFile.type,
+      headers: options.headers
+    };
+  }
+
+  return bunFile;
+};
+
+// Redirect helper function (like Elysia)
+export const redirect = (location: string, status: number = 302) => {
+  return new Response(null, {
+    status,
+    headers: { Location: location }
+  });
+};
+
+// Helper function to create cookie options
+export const createCookieOptions = (
+  options: CookieOptions = {}
+): CookieOptions => ({
+  ...options
+});

package/src/utils/index.ts

@@ -0,0 +1,258 @@
+import { z } from 'zod';
+import type { ResponseConfig, InternalCookie, CookieOptions } from '../types';
+
+// Parse query string
+export function parseQuery(searchParams: URLSearchParams): Record<string, string | undefined> {
+  const query: Record<string, string | undefined> = {};
+  searchParams.forEach((value, key) => {
+    query[key] = value;
+  });
+  return query;
+}
+
+// Parse headers
+export function parseHeaders(headers: Headers): Record<string, string> {
+  const headerObj: Record<string, string> = {};
+  headers.forEach((value, key) => {
+    headerObj[key] = value;
+  });
+  return headerObj;
+}
+
+// Parse cookies from Cookie header
+export function parseCookies(cookieHeader: string | null): Record<string, string> {
+  const cookies: Record<string, string> = {};
+
+  if (!cookieHeader) return cookies;
+
+  const cookiePairs = cookieHeader.split(';');
+  for (const pair of cookiePairs) {
+    const [name, value] = pair.trim().split('=');
+    if (name && value) {
+      cookies[decodeURIComponent(name)] = decodeURIComponent(value);
+    }
+  }
+
+  return cookies;
+}
+
+// Validate data against Zod schema
+export function validateData<T>(schema: z.ZodSchema<T> | undefined, data: any): T {
+  if (!schema) return data;
+  return schema.parse(data);
+}
+
+// Validate response against response config (supports both simple and status-based schemas)
+export function validateResponse(
+  responseConfig: ResponseConfig | undefined, 
+  data: any, 
+  status: number = 200
+): any {
+  if (!responseConfig) return data;
+
+  // If it's a simple schema (not status-based)
+  if ('parse' in responseConfig && typeof responseConfig.parse === 'function') {
+    return responseConfig.parse(data);
+  }
+
+  // If it's a status-based schema
+  if (typeof responseConfig === 'object' && !('parse' in responseConfig)) {
+    const statusSchema = responseConfig[status];
+    if (statusSchema) {
+      return statusSchema.parse(data);
+    }
+
+    // If no specific status schema found, try to find a fallback
+    // Common fallback statuses: 200, 201, 400, 500
+    const fallbackStatuses = [200, 201, 400, 500];
+    for (const fallbackStatus of fallbackStatuses) {
+      if (responseConfig[fallbackStatus]) {
+        return responseConfig[fallbackStatus]?.parse(data);
+      }
+    }
+
+    // If no schema found for the status, return data as-is
+    return data;
+  }
+
+  return data;
+}
+
+// Parse request body based on content type
+export async function parseRequestBody(request: Request): Promise<any> {
+  const contentType = request.headers.get('content-type');
+  
+  if (contentType?.includes('application/json')) {
+    try {
+      return await request.json();
+    } catch {
+      return {};
+    }
+  } else if (contentType?.includes('multipart/form-data') || contentType?.includes('application/x-www-form-urlencoded')) {
+    const formData = await request.formData();
+    // Convert FormData to a structured object that preserves file information
+    const formBody: Record<string, any> = {};
+    
+    for (const [key, value] of formData.entries()) {
+      if (value instanceof File) {
+        // Handle file uploads
+        formBody[key] = {
+          type: 'file',
+          name: value.name,
+          size: value.size,
+          lastModified: value.lastModified,
+          file: value, // Keep the actual File object for access
+          // Add convenience properties
+          filename: value.name,
+          mimetype: value.type || 'application/octet-stream'
+        };
+      } else {
+        // Handle regular form fields
+        formBody[key] = value;
+      }
+    }
+    
+    return formBody;
+  } else {
+    // Try to parse as JSON if it looks like JSON, otherwise treat as text
+    const textBody = await request.text();
+    try {
+      // Check if the text looks like JSON
+      if (textBody.trim().startsWith('{') || textBody.trim().startsWith('[')) {
+        return JSON.parse(textBody);
+      } else {
+        return textBody;
+      }
+    } catch {
+      return textBody;
+    }
+  }
+}
+
+// Convert internal cookies to Set-Cookie header strings
+export function cookiesToHeaders(cookies: InternalCookie[]): string[] {
+  return cookies.map(cookie => {
+    let cookieString = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`;
+    if (cookie.domain) cookieString += `; Domain=${cookie.domain}`;
+    if (cookie.path) cookieString += `; Path=${cookie.path}`;
+    if (cookie.expires) cookieString += `; Expires=${cookie.expires.toUTCString()}`;
+    if (cookie.maxAge) cookieString += `; Max-Age=${cookie.maxAge}`;
+    if (cookie.secure) cookieString += `; Secure`;
+    if (cookie.httpOnly) cookieString += `; HttpOnly`;
+    if (cookie.sameSite) cookieString += `; SameSite=${cookie.sameSite}`;
+    return cookieString;
+  });
+}
+
+// Merge headers with cookies
+export function mergeHeadersWithCookies(
+  headers: Record<string, string>, 
+  cookies: InternalCookie[]
+): Headers {
+  const newHeaders = new Headers();
+  
+  // Add regular headers
+  Object.entries(headers).forEach(([key, value]) => {
+    newHeaders.set(key, value);
+  });
+  
+  // Add Set-Cookie headers
+  const cookieHeaders = cookiesToHeaders(cookies);
+  cookieHeaders.forEach(cookieHeader => {
+    newHeaders.append('Set-Cookie', cookieHeader);
+  });
+  
+  return newHeaders;
+}
+
+// Create a redirect response
+export function createRedirectResponse(
+  location: string, 
+  status: number = 302, 
+  headers: Record<string, string> = {}
+): Response {
+  const responseHeaders = new Headers();
+  responseHeaders.set('Location', location);
+  
+  // Add additional headers
+  Object.entries(headers).forEach(([key, value]) => {
+    responseHeaders.set(key, value);
+  });
+  
+  return new Response(null, {
+    status,
+    headers: responseHeaders
+  });
+}
+
+// Check if a value is a file upload
+export function isFileUpload(value: any): value is {
+  type: 'file';
+  file: File;
+  name: string;
+  size: number;
+  lastModified: number;
+  filename: string;
+  mimetype: string;
+} {
+  return value && typeof value === 'object' && value.type === 'file' && value.file instanceof File;
+}
+
+// Extract File object from upload value
+export function getFileFromUpload(value: any): File | null {
+  return isFileUpload(value) ? value.file : null;
+}
+
+// Get file metadata without the File object
+export function getFileInfo(value: any): { name: string; size: number; mimetype: string; lastModified: number } | null {
+  if (isFileUpload(value)) {
+    return {
+      name: value.name,
+      size: value.size,
+      mimetype: value.mimetype,
+      lastModified: value.lastModified
+    };
+  }
+  return null;
+}
+
+// Save uploaded file to disk
+export async function saveUploadedFile(
+  uploadValue: any, 
+  destinationPath: string
+): Promise<boolean> {
+  const file = getFileFromUpload(uploadValue);
+  if (!file) return false;
+  
+  try {
+    const arrayBuffer = await file.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    await Bun.write(destinationPath, buffer);
+    return true;
+  } catch (error) {
+    console.error('Error saving file:', error);
+    return false;
+  }
+}
+
+// Get all file uploads from form data
+export function getFileUploads(formData: Record<string, any>): Record<string, File> {
+  const files: Record<string, File> = {};
+  for (const [key, value] of Object.entries(formData)) {
+    if (isFileUpload(value)) {
+      files[key] = value.file;
+    }
+  }
+  return files;
+}
+
+// Get all non-file fields from form data
+export function getFormFields(formData: Record<string, any>): Record<string, string> {
+  const fields: Record<string, string> = {};
+  for (const [key, value] of Object.entries(formData)) {
+    if (!isFileUpload(value)) {
+      fields[key] = String(value);
+    }
+  }
+  return fields;
+}