@stacksjs/bun-router 0.0.16 → 0.0.18

package/src/request/macros.ts

@@ -1,688 +0,0 @@
-/**
- * Request/Response Enhancements - Request Macros
- *
- * Laravel-style request macros for enhanced request functionality
- */
-
-import type { EnhancedRequest } from '../types'
-
-export interface RequestMacro {
-  name: string
-  handler: (this: EnhancedRequest, ...args: any[]) => any
-}
-
-/**
- * Request macro registry
- */
-class RequestMacroRegistry {
-  private macros: Map<string, RequestMacro> = new Map()
-
-  /**
-   * Register a request macro
-   */
-  register(name: string, handler: (this: EnhancedRequest, ...args: any[]) => any): void {
-    this.macros.set(name, { name, handler })
-  }
-
-  /**
-   * Get a registered macro
-   */
-  get(name: string): RequestMacro | undefined {
-    return this.macros.get(name)
-  }
-
-  /**
-   * Check if macro exists
-   */
-  has(name: string): boolean {
-    return this.macros.has(name)
-  }
-
-  /**
-   * Get all registered macros
-   */
-  all(): RequestMacro[] {
-    return Array.from(this.macros.values())
-  }
-
-  /**
-   * Remove a macro
-   */
-  remove(name: string): boolean {
-    return this.macros.delete(name)
-  }
-
-  /**
-   * Clear all macros
-   */
-  clear(): void {
-    this.macros.clear()
-  }
-}
-
-/**
- * Global request macro registry
- */
-export const requestMacroRegistry: RequestMacroRegistry = new RequestMacroRegistry()
-
-/**
- * Request class with macro support
- */
-export class RequestWithMacros {
-  /**
-   * Register a request macro
-   */
-  static macro(name: string, handler: (this: EnhancedRequest, ...args: any[]) => any): void {
-    requestMacroRegistry.register(name, handler)
-  }
-
-  /**
-   * Apply macros to a request object
-   */
-  static applyMacros(request: EnhancedRequest): EnhancedRequest {
-    const macros = requestMacroRegistry.all()
-
-    macros.forEach((macro) => {
-      ;(request as any)[macro.name] = macro.handler.bind(request)
-    })
-
-    return request
-  }
-
-  /**
-   * Check if macro exists
-   */
-  static hasMacro(name: string): boolean {
-    return requestMacroRegistry.has(name)
-  }
-}
-
-/**
- * Built-in request macros
- */
-export const BuiltInRequestMacros = {
-  /**
-   * Check if request wants JSON response
-   */
-  wantsJson(this: EnhancedRequest): boolean {
-    const accept = this.headers.get('accept') || ''
-    return accept.includes('application/json') || accept.includes('json')
-  },
-
-  /**
-   * Check if request wants HTML response
-   */
-  wantsHtml(this: EnhancedRequest): boolean {
-    const accept = this.headers.get('accept') || ''
-    return accept.includes('text/html') || accept.includes('html')
-  },
-
-  /**
-   * Check if request wants XML response
-   */
-  wantsXml(this: EnhancedRequest): boolean {
-    const accept = this.headers.get('accept') || ''
-    return accept.includes('application/xml') || accept.includes('xml')
-  },
-
-  /**
-   * Check if request expects JSON response
-   */
-  expectsJson(this: EnhancedRequest): boolean {
-    return this.wantsJson() || this.isAjax() || this.isPjax()
-  },
-
-  /**
-   * Check if request is AJAX
-   */
-  isAjax(this: EnhancedRequest): boolean {
-    return this.headers.get('x-requested-with') === 'XMLHttpRequest'
-  },
-
-  /**
-   * Check if request is PJAX
-   */
-  isPjax(this: EnhancedRequest): boolean {
-    return this.headers.get('x-pjax') === 'true'
-  },
-
-  /**
-   * Check if request is from mobile device
-   */
-  isMobile(this: EnhancedRequest): boolean {
-    const userAgent = this.headers.get('user-agent') || ''
-    const mobileRegex = /Mobile|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i
-    return mobileRegex.test(userAgent)
-  },
-
-  /**
-   * Check if request is from bot/crawler
-   */
-  isBot(this: EnhancedRequest): boolean {
-    const userAgent = this.headers.get('user-agent') || ''
-    const botRegex = /bot|crawler|spider|crawling/i
-    return botRegex.test(userAgent)
-  },
-
-  /**
-   * Check if request is secure (HTTPS)
-   */
-  isSecure(this: EnhancedRequest): boolean {
-    return this.url.startsWith('https://')
-      || this.headers.get('x-forwarded-proto') === 'https'
-      || this.headers.get('x-forwarded-ssl') === 'on'
-  },
-
-  /**
-   * Get client IP address
-   */
-  ip(this: EnhancedRequest): string {
-    return this.headers.get('x-forwarded-for')?.split(',')[0]?.trim()
-      || this.headers.get('x-real-ip')
-      || this.headers.get('cf-connecting-ip')
-      || this.headers.get('x-client-ip')
-      || 'unknown'
-  },
-
-  /**
-   * Get all client IPs (including proxies)
-   */
-  ips(this: EnhancedRequest): string[] {
-    const forwardedFor = this.headers.get('x-forwarded-for')
-    if (forwardedFor) {
-      return forwardedFor.split(',').map(ip => ip.trim())
-    }
-    return [BuiltInRequestMacros.ip.call(this)]
-  },
-
-  /**
-   * Get user agent
-   */
-  userAgent(this: EnhancedRequest): string {
-    return this.headers.get('user-agent') || ''
-  },
-
-  /**
-   * Get referer URL
-   */
-  referer(this: EnhancedRequest): string | null {
-    return this.headers.get('referer') || this.headers.get('referrer') || null
-  },
-
-  /**
-   * Get authorization header
-   */
-  bearerToken(this: EnhancedRequest): string | null {
-    const auth = this.headers.get('authorization')
-    if (auth && auth.startsWith('Bearer ')) {
-      return auth.substring(7)
-    }
-    return null
-  },
-
-  /**
-   * Get basic auth credentials
-   */
-  basicAuth(this: EnhancedRequest): { username: string, password: string } | null {
-    const auth = this.headers.get('authorization')
-    if (auth && auth.startsWith('Basic ')) {
-      try {
-        const decoded = atob(auth.substring(6))
-        const [username, password] = decoded.split(':')
-        return { username, password }
-      }
-      catch {
-        return null
-      }
-    }
-    return null
-  },
-
-  /**
-   * Check if request has specific header
-   */
-  hasHeader(this: EnhancedRequest, name: string): boolean {
-    return this.headers.has(name.toLowerCase())
-  },
-
-  /**
-   * Get header value with default
-   */
-  header(this: EnhancedRequest, name: string, defaultValue?: string): string | null {
-    return this.headers.get(name.toLowerCase()) || defaultValue || null
-  },
-
-  /**
-   * Get all headers as object
-   */
-  allHeaders(this: EnhancedRequest): Record<string, string> {
-    const headers: Record<string, string> = {}
-    this.headers.forEach((value, key) => {
-      headers[key] = value
-    })
-    return headers
-  },
-
-  /**
-   * Get input value from query, body, or params
-   */
-  input(this: EnhancedRequest, key: string, defaultValue?: any): any {
-    // Check validated data first
-    if (this.validated && key in this.validated) {
-      return this.validated[key]
-    }
-
-    // Check query parameters
-    if (this.query && key in this.query) {
-      return this.query[key]
-    }
-
-    // Check route parameters
-    if (this.params && key in this.params) {
-      return this.params[key]
-    }
-
-    // Check JSON body
-    if (this.jsonBody && typeof this.jsonBody === 'object' && key in this.jsonBody) {
-      return (this.jsonBody as Record<string, unknown>)[key]
-    }
-
-    // Check form body
-    if (this.formBody && typeof this.formBody === 'object' && key in this.formBody) {
-      return (this.formBody as Record<string, unknown>)[key]
-    }
-
-    return defaultValue
-  },
-
-  /**
-   * Get all input data
-   */
-  all(this: EnhancedRequest): Record<string, unknown> {
-    return {
-      ...this.params,
-      ...this.query,
-      ...(typeof this.jsonBody === 'object' && this.jsonBody !== null ? this.jsonBody : {}),
-      ...(typeof this.formBody === 'object' && this.formBody !== null ? this.formBody : {}),
-      ...(typeof this.validated === 'object' && this.validated !== null ? this.validated : {}),
-    }
-  },
-
-  /**
-   * Get only specified input keys
-   */
-  only(this: EnhancedRequest, keys: string[]): Record<string, any> {
-    const all = this.all()
-    const result: Record<string, any> = {}
-
-    keys.forEach((key) => {
-      if (key in all) {
-        result[key] = all[key]
-      }
-    })
-
-    return result
-  },
-
-  /**
-   * Get all input except specified keys
-   */
-  except(this: EnhancedRequest, keys: string[]): Record<string, any> {
-    const all = this.all()
-    const result: Record<string, any> = {}
-
-    Object.keys(all).forEach((key) => {
-      if (!keys.includes(key)) {
-        result[key] = all[key]
-      }
-    })
-
-    return result
-  },
-
-  /**
-   * Check if input has specific key
-   */
-  has(this: EnhancedRequest, key: string): boolean {
-    const all = this.all()
-    return key in all && all[key] !== undefined && all[key] !== null && all[key] !== ''
-  },
-
-  /**
-   * Check if input has any of the specified keys
-   */
-  hasAny(this: EnhancedRequest, keys: string[]): boolean {
-    return keys.some(key => this.has(key))
-  },
-
-  /**
-   * Check if input is missing specific key
-   */
-  missing(this: EnhancedRequest, key: string): boolean {
-    return !this.has(key)
-  },
-
-  /**
-   * Check if input is filled (not empty)
-   */
-  filled(this: EnhancedRequest, key: string): boolean {
-    const value = this.input(key)
-    if (value === null || value === undefined)
-      return false
-    if (typeof value === 'string')
-      return value.trim().length > 0
-    if (Array.isArray(value))
-      return value.length > 0
-    if (typeof value === 'object')
-      return Object.keys(value).length > 0
-    return true
-  },
-
-  /**
-   * Get query parameter
-   */
-  getQuery(this: EnhancedRequest, key?: string, defaultValue?: any): any {
-    if (!key)
-      return this.query || {}
-    return this.query?.[key] || defaultValue
-  },
-
-  /**
-   * Get route parameter
-   */
-  param(this: EnhancedRequest, key: string, defaultValue?: any): any {
-    return this.params?.[key] || defaultValue
-  },
-
-  /**
-   * Get cookie value
-   */
-  cookie(this: EnhancedRequest, name: string, defaultValue?: string): string | null {
-    const cookies = this.headers.get('cookie')
-    if (!cookies)
-      return defaultValue || null
-
-    const cookieArray = cookies.split(';')
-    for (const cookie of cookieArray) {
-      const [key, value] = cookie.trim().split('=')
-      if (key === name) {
-        return decodeURIComponent(value)
-      }
-    }
-
-    return defaultValue || null
-  },
-
-  /**
-   * Get all cookies
-   */
-  cookies(this: EnhancedRequest): Record<string, string> {
-    const cookies: Record<string, string> = {}
-    const cookieHeader = this.headers.get('cookie')
-
-    if (cookieHeader) {
-      cookieHeader.split(';').forEach((cookie) => {
-        const [key, value] = cookie.trim().split('=')
-        if (key && value) {
-          cookies[key] = decodeURIComponent(value)
-        }
-      })
-    }
-
-    return cookies
-  },
-
-  /**
-   * Get file from upload
-   */
-  file(this: EnhancedRequest, name: string): any {
-    return this.files?.find(f => f.fieldName === name)
-  },
-
-  /**
-   * Check if request has file upload
-   */
-  hasFile(this: EnhancedRequest, name: string): boolean {
-    return !!this.files?.find(f => f.fieldName === name)
-  },
-
-  /**
-   * Get request path without query string
-   */
-  path(this: EnhancedRequest): string {
-    return new URL(this.url).pathname
-  },
-
-  /**
-   * Get request URL
-   */
-  fullUrl(this: EnhancedRequest): string {
-    return this.url
-  },
-
-  /**
-   * Get request root URL
-   */
-  root(this: EnhancedRequest): string {
-    const url = new URL(this.url)
-    return `${url.protocol}//${url.host}`
-  },
-
-  /**
-   * Check if path matches pattern
-   */
-  is(this: EnhancedRequest, pattern: string): boolean {
-    const path = this.path()
-
-    // Convert pattern to regex
-    const regexPattern = pattern
-      .replace(/\*/g, '.*')
-      .replace(/\?/g, '.')
-
-    const regex = new RegExp(`^${regexPattern}$`)
-    return regex.test(path)
-  },
-
-  /**
-   * Get route name (if available)
-   */
-  route(this: EnhancedRequest): string | null {
-    return (this as any).routeName || null
-  },
-
-  /**
-   * Get request fingerprint for caching
-   */
-  fingerprint(this: EnhancedRequest): string {
-    const url = new URL(this.url)
-    const data = {
-      method: this.method,
-      path: url.pathname,
-      query: url.search,
-      ip: BuiltInRequestMacros.ip.call(this),
-    }
-
-    return btoa(JSON.stringify(data))
-  },
-
-  /**
-   * Get request signature for security
-   */
-  signature(this: EnhancedRequest, secret: string): string {
-    const data = `${this.method}${this.url}${BuiltInRequestMacros.ip.call(this)}${secret}`
-
-    // Simple hash function (in production, use crypto)
-    let hash = 0
-    for (let i = 0; i < data.length; i++) {
-      const char = data.charCodeAt(i)
-      hash = ((hash << 5) - hash) + char
-      hash = hash & hash // Convert to 32-bit integer
-    }
-
-    return Math.abs(hash).toString(36)
-  },
-
-  /**
-   * Merge additional data into request
-   */
-  merge(this: EnhancedRequest, data: Record<string, any>): void {
-    if (!this.validated) {
-      this.validated = {}
-    }
-    Object.assign(this.validated, data)
-  },
-
-  /**
-   * Replace request data
-   */
-  replace(this: EnhancedRequest, data: Record<string, any>): void {
-    this.validated = { ...data }
-  },
-
-  /**
-   * Get request age in milliseconds
-   */
-  age(this: EnhancedRequest): number {
-    const startTime = (this as any).startTime || Date.now()
-    return Date.now() - startTime
-  },
-
-  /**
-   * Check if request is from trusted proxy
-   */
-  isFromTrustedProxy(this: EnhancedRequest, trustedProxies: string[] = []): boolean {
-    const ip = BuiltInRequestMacros.ip.call(this)
-    return trustedProxies.includes(ip)
-  },
-
-  /**
-   * Get request content length
-   */
-  contentLength(this: EnhancedRequest): number {
-    const length = this.headers.get('content-length')
-    return length ? Number.parseInt(length, 10) : 0
-  },
-
-  /**
-   * Get request content type
-   */
-  contentType(this: EnhancedRequest): string | null {
-    return this.headers.get('content-type')
-  },
-
-  /**
-   * Check if request content type matches
-   */
-  isContentType(this: EnhancedRequest, type: string): boolean {
-    const contentType = this.contentType()
-    return contentType ? contentType.includes(type) : false
-  },
-}
-
-/**
- * Register all built-in macros
- */
-export function registerBuiltInRequestMacros(): void {
-  Object.entries(BuiltInRequestMacros).forEach(([name, handler]) => {
-    RequestWithMacros.macro(name, handler)
-  })
-}
-
-/**
- * Request macro factory functions
- */
-export const RequestMacroFactory = {
-  /**
-   * Create input validation macro
-   */
-  validateInput: (_rules: Record<string, string>) => {
-    // eslint-disable-next-line pickier/no-unused-vars
-    return function (this: EnhancedRequest): boolean {
-      // This would integrate with the validation system
-      // For now, return true as placeholder
-      return true
-    }
-  },
-
-  /**
-   * Create custom header checker macro
-   */
-  hasCustomHeader: (headerName: string) => {
-    return function (this: EnhancedRequest): boolean {
-      return this.hasHeader(headerName)
-    }
-  },
-
-  /**
-   * Create role checker macro
-   */
-  hasRole: (role: string) => {
-    return function (this: EnhancedRequest): boolean {
-      const user = (this as any).user
-      return user?.roles?.includes(role) || false
-    }
-  },
-
-  /**
-   * Create permission checker macro
-   */
-  can: (permission: string) => {
-    return function (this: EnhancedRequest): boolean {
-      const user = (this as any).user
-      return user?.permissions?.includes(permission) || false
-    }
-  },
-}
-
-/**
- * Request helper utilities
- */
-export const RequestHelpers = {
-  /**
-   * Apply macros to request
-   */
-  withMacros: (request: EnhancedRequest): EnhancedRequest => {
-    return RequestWithMacros.applyMacros(request)
-  },
-
-  /**
-   * Create request from URL and options
-   */
-  create: (url: string, options: RequestInit = {}): EnhancedRequest => {
-    const request = new Request(url, options) as EnhancedRequest
-    return RequestWithMacros.applyMacros(request)
-  },
-
-  /**
-   * Parse query string to object
-   */
-  parseQuery: (queryString: string): Record<string, string> => {
-    const params = new URLSearchParams(queryString)
-    const result: Record<string, string> = {}
-
-    params.forEach((value, key) => {
-      result[key] = value
-    })
-
-    return result
-  },
-
-  /**
-   * Parse cookies from header
-   */
-  parseCookies: (cookieHeader: string): Record<string, string> => {
-    const cookies: Record<string, string> = {}
-
-    cookieHeader.split(';').forEach((cookie) => {
-      const [key, value] = cookie.trim().split('=')
-      if (key && value) {
-        cookies[key] = decodeURIComponent(value)
-      }
-    })
-
-    return cookies
-  },
-}
-
-// Auto-register built-in macros
-registerBuiltInRequestMacros()