bxo 0.0.5-dev.65 → 0.0.5-dev.67

package/src/utils/index.ts

@@ -1,448 +0,0 @@
-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 (only supports Record<number, schema> format)
-export function validateResponse(
-  responseConfig: ResponseConfig | undefined, 
-  data: any, 
-  status: number = 200
-): any {
-  if (!responseConfig) return data;
-
-  // Get the schema for the specific status code
-  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;
-}
-
-// Helper function to parse form keys with nested object and array notation (Axios-compatible)
-function parseFormKey(key: string): { 
-  baseKey: string; 
-  path: string[]; 
-  isArray: boolean; 
-  isJson: boolean;
-  hasIndexes: boolean;
-} {
-  // Check for special endings like "{}" for JSON serialization FIRST
-  if (key.endsWith('{}')) {
-    const actualBaseKey = key.slice(0, -2);
-    return { baseKey: actualBaseKey, path: [], isArray: false, isJson: true, hasIndexes: false };
-  }
-  
-  const bracketMatch = key.match(/^([^\[]+)(\[.*\])*$/);
-  if (!bracketMatch) {
-    return { baseKey: key, path: [], isArray: false, isJson: false, hasIndexes: false };
-  }
-  
-  const baseKey = bracketMatch[1];
-  if (!baseKey) {
-    return { baseKey: key, path: [], isArray: false, isJson: false, hasIndexes: false };
-  }
-  
-  const bracketPart = key.slice(baseKey.length);
-  
-  if (!bracketPart) {
-    return { baseKey, path: [], isArray: false, isJson: false, hasIndexes: false };
-  }
-  
-  // Check for special endings like "{}" for JSON serialization
-  if (baseKey.endsWith('{}')) {
-    const actualBaseKey = baseKey.slice(0, -2);
-    return { baseKey: actualBaseKey, path: [], isArray: false, isJson: true, hasIndexes: false };
-  }
-  
-  // If no bracket part, return simple key
-  if (!bracketPart) {
-    return { baseKey, path: [], isArray: false, isJson: false, hasIndexes: false };
-  }
-  
-  // Check if this is an array notation (e.g., "recordIds[]")
-  if (bracketPart === '[]') {
-    return { baseKey, path: [], isArray: true, isJson: false, hasIndexes: false };
-  }
-  
-  // Extract all bracket contents
-  const path: string[] = [];
-  const bracketRegex = /\[([^\]]*)\]/g;
-  let match;
-  let hasIndexes = false;
-  
-  while ((match = bracketRegex.exec(bracketPart)) !== null) {
-    if (match[1] !== undefined) {
-      path.push(match[1]);
-      // Check if this is a numeric index
-      if (/^\d+$/.test(match[1])) {
-        hasIndexes = true;
-      }
-    }
-  }
-  
-  // Check if the last path element is empty (indicating array without indexes)
-  const isArray = path.length > 0 && path[path.length - 1] === '';
-  
-  return { baseKey, path, isArray, isJson: false, hasIndexes };
-}
-
-// Helper function to set nested value in object (Axios-compatible)
-function setNestedValue(obj: any, baseKey: string, path: string[], value: any, isArray: boolean = false): void {
-  if (!(baseKey in obj)) {
-    obj[baseKey] = isArray ? [] : {};
-  }
-  
-  let current = obj[baseKey];
-  
-  // Navigate to the parent of the target location
-  for (let i = 0; i < path.length - 1; i++) {
-    const key = path[i];
-    if (key && (!(key in current) || typeof current[key] !== 'object')) {
-      // Check if next key is numeric (array index)
-      const nextKey = path[i + 1];
-      const isNextKeyNumeric = nextKey && /^\d+$/.test(nextKey);
-      current[key] = isNextKeyNumeric ? [] : {};
-    }
-    if (key) {
-      current = current[key];
-    }
-  }
-  
-  // Set the final value
-  const lastKey = path[path.length - 1];
-  if (lastKey) {
-    if (/^\d+$/.test(lastKey)) {
-      // Numeric key - treat as array index
-      const index = parseInt(lastKey, 10);
-      if (Array.isArray(current)) {
-        current[index] = value;
-      } else {
-        // Convert to array if needed
-        const newArray = [];
-        newArray[index] = value;
-        current[lastKey] = newArray;
-      }
-    } else {
-      current[lastKey] = value;
-    }
-  }
-}
-
-// 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
-    const formBody: Record<string, any> = {};
-    
-    for (const [key, value] of formData.entries()) {
-      // Parse the key to handle nested objects and arrays (Axios-compatible)
-      const parsedKey = parseFormKey(key);
-      
-      if (parsedKey.isJson) {
-        // Handle JSON serialization (e.g., "obj{}")
-        if (typeof value === 'string') {
-          try {
-            formBody[parsedKey.baseKey] = JSON.parse(value);
-          } catch {
-            formBody[parsedKey.baseKey] = value;
-          }
-        } else {
-          formBody[parsedKey.baseKey] = value;
-        }
-      } else if (parsedKey.isArray) {
-        // Handle array notation like "recordIds[]"
-        if (parsedKey.baseKey in formBody) {
-          if (Array.isArray(formBody[parsedKey.baseKey])) {
-            formBody[parsedKey.baseKey].push(value);
-          } else {
-            formBody[parsedKey.baseKey] = [formBody[parsedKey.baseKey], value];
-          }
-        } else {
-          formBody[parsedKey.baseKey] = [value];
-        }
-      } else if (parsedKey.path.length > 0) {
-        // Handle nested object notation like "test[new]", "test[hi][hi]", "arr[0]", "users[0][name]"
-        setNestedValue(formBody, parsedKey.baseKey, parsedKey.path, value, parsedKey.hasIndexes);
-      } else {
-        // Handle regular form fields - check if this key already exists
-        if (key in formBody) {
-          // If key already exists, convert to array or append to existing array
-          if (Array.isArray(formBody[key])) {
-            formBody[key].push(value);
-          } else {
-            formBody[key] = [formBody[key], value];
-          }
-        } else {
-          // First occurrence of this key
-          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;
-  });
-}
-
-// Special cases for HTTP headers that need specific casing
-const HEADER_CASING_SPECIAL_CASES: Record<string, string> = {
-  'www-authenticate': 'WWW-Authenticate',
-  'content-md5': 'Content-MD5',
-  'dnt': 'DNT',
-  'etag': 'ETag',
-  'te': 'TE',
-  'trailer': 'Trailer',
-  'transfer-encoding': 'Transfer-Encoding',
-  'upgrade': 'Upgrade',
-  'x-forwarded-for': 'X-Forwarded-For',
-  'x-forwarded-proto': 'X-Forwarded-Proto',
-  'x-forwarded-host': 'X-Forwarded-Host',
-  'x-real-ip': 'X-Real-IP',
-  'x-requested-with': 'X-Requested-With',
-  'x-csrf-token': 'X-CSRF-Token',
-  'x-frame-options': 'X-Frame-Options',
-  'x-content-type-options': 'X-Content-Type-Options',
-  'x-xss-protection': 'X-XSS-Protection',
-  'strict-transport-security': 'Strict-Transport-Security',
-  'content-security-policy': 'Content-Security-Policy',
-  'referrer-policy': 'Referrer-Policy',
-  'permissions-policy': 'Permissions-Policy'
-};
-
-// Helper function to normalize header casing while preserving special cases
-function normalizeHeaderCase(headerKey: string): string {
-  const lowerKey = headerKey.toLowerCase();
-  return HEADER_CASING_SPECIAL_CASES[lowerKey] || headerKey;
-}
-
-// Helper function to convert Headers object back to plain object while preserving casing
-export function headersToPlainObject(headers: Headers): Record<string, string> {
-  const result: Record<string, string> = {};
-  headers.forEach((value, key) => {
-    // Preserve the original casing from the Headers object
-    result[key] = value;
-  });
-  return result;
-}
-
-// Merge headers with cookies
-export function mergeHeadersWithCookies(
-  headers: Record<string, string>, 
-  cookies: InternalCookie[]
-): Headers {
-  const newHeaders = new Headers();
-  
-  // Add regular headers with proper casing
-  Object.entries(headers).forEach(([key, value]) => {
-    const normalizedKey = normalizeHeaderCase(key);
-    newHeaders.set(normalizedKey, value);
-  });
-  
-  // Add Set-Cookie headers
-  const cookieHeaders = cookiesToHeaders(cookies);
-  cookieHeaders.forEach(cookieHeader => {
-    newHeaders.append('Set-Cookie', cookieHeader);
-  });
-  
-  return newHeaders;
-}
-
-// Alternative function that returns headers with preserved casing
-export function mergeHeadersWithCookiesPreserveCasing(
-  headers: Record<string, string>, 
-  cookies: InternalCookie[]
-): Record<string, string> {
-  const result: Record<string, string> = { ...headers };
-  
-  // Apply special casing rules
-  Object.keys(result).forEach(key => {
-    const normalizedKey = normalizeHeaderCase(key);
-    if (normalizedKey !== key) {
-      result[normalizedKey] = result[key] || '';
-      delete result[key];
-    }
-  });
-  
-  // Add Set-Cookie headers
-  if (cookies.length > 0) {
-    const cookieHeaders = cookiesToHeaders(cookies);
-    // Set-Cookie headers should be separate entries, not joined
-    cookieHeaders.forEach((cookieHeader, index) => {
-      const key = index === 0 ? 'Set-Cookie' : `Set-Cookie-${index + 1}`;
-      result[key] = cookieHeader;
-    });
-  }
-  
-  return result;
-}
-
-// 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 File {
-  return value instanceof File;
-}
-
-// Extract File object from upload value
-export function getFileFromUpload(value: any): File | null {
-  return isFileUpload(value) ? value : 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.type || 'application/octet-stream',
-      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;
-    }
-  }
-  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;
-}