@stacksjs/bun-router 0.0.17 → 0.0.18

package/src/request/enhanced-request.ts

@@ -1,876 +0,0 @@
-/**
- * Enhanced Request Methods
- *
- * Implements fluent request methods with full TypeScript support
- */
-
-import type {
-  EnhancedRequest,
-  InputValue,
-  RequestInput,
-  ValidatedData,
-} from '../types'
-import { Validator } from '../validation/validator'
-
-// ============================================================================
-// Types
-// ============================================================================
-
-/**
- * Validation rules type
- */
-export type ValidationRules = Record<string, string | ValidationRule[]>
-
-/**
- * Validation rule interface
- */
-export interface ValidationRule {
-  name: string
-  validate: (value: unknown, parameters: string[], field: string, data: Record<string, unknown>) => Promise<boolean> | boolean
-  message: string | ((_field: string, _parameters: string[]) => string)
-}
-
-/**
- * Safe validated data wrapper
- */
-export interface SafeData<T extends Record<string, unknown> = Record<string, unknown>> {
-  only: <K extends keyof T>(keys: K[]) => Pick<T, K>
-  except: <K extends keyof T>(keys: K[]) => Omit<T, K>
-  merge: <U extends Record<string, unknown>>(data: U) => T & U
-  all: () => T
-  has: (key: keyof T) => boolean
-  get: <K extends keyof T>(key: K) => T[K]
-}
-
-/**
- * Collection interface for array data
- */
-export interface Collection<T> {
-  items: T[]
-  count: () => number
-  first: () => T | undefined
-  last: () => T | undefined
-  map: <U>(fn: (item: T, index: number) => U) => Collection<U>
-  filter: (fn: (item: T, index: number) => boolean) => Collection<T>
-  find: (fn: (item: T, index: number) => boolean) => T | undefined
-  reduce: <U>(fn: (acc: U, item: T, index: number) => U, initial: U) => U
-  forEach: (fn: (item: T, index: number) => void) => void
-  toArray: () => T[]
-  isEmpty: () => boolean
-  isNotEmpty: () => boolean
-  pluck: <K extends keyof T>(key: K) => Collection<T[K]>
-  unique: () => Collection<T>
-  sortBy: <K extends keyof T>(key: K, direction?: 'asc' | 'desc') => Collection<T>
-  groupBy: <K extends keyof T>(key: K) => Map<T[K], Collection<T>>
-  chunk: (size: number) => Collection<Collection<T>>
-  take: (count: number) => Collection<T>
-  skip: (count: number) => Collection<T>
-  reverse: () => Collection<T>
-  sum: (key?: keyof T) => number
-  avg: (key?: keyof T) => number
-  min: (key?: keyof T) => T | undefined
-  max: (key?: keyof T) => T | undefined
-}
-
-// ============================================================================
-// Collection Implementation
-// ============================================================================
-
-/**
- * Collection class for array manipulation
- */
-export class CollectionImpl<T> implements Collection<T> {
-  items: T[]
-
-  constructor(items: T[]) {
-    this.items = [...items]
-  }
-
-  count(): number {
-    return this.items.length
-  }
-
-  first(): T | undefined {
-    return this.items[0]
-  }
-
-  last(): T | undefined {
-    return this.items[this.items.length - 1]
-  }
-
-  map<U>(fn: (item: T, index: number) => U): Collection<U> {
-    return new CollectionImpl(this.items.map(fn))
-  }
-
-  filter(fn: (item: T, index: number) => boolean): Collection<T> {
-    return new CollectionImpl(this.items.filter(fn))
-  }
-
-  find(fn: (item: T, index: number) => boolean): T | undefined {
-    return this.items.find(fn)
-  }
-
-  reduce<U>(fn: (acc: U, item: T, index: number) => U, initial: U): U {
-    return this.items.reduce(fn, initial)
-  }
-
-  forEach(fn: (item: T, index: number) => void): void {
-    this.items.forEach(fn)
-  }
-
-  toArray(): T[] {
-    return [...this.items]
-  }
-
-  isEmpty(): boolean {
-    return this.items.length === 0
-  }
-
-  isNotEmpty(): boolean {
-    return this.items.length > 0
-  }
-
-  pluck<K extends keyof T>(key: K): Collection<T[K]> {
-    return new CollectionImpl(this.items.map(item => item[key]))
-  }
-
-  unique(): Collection<T> {
-    return new CollectionImpl([...new Set(this.items)])
-  }
-
-  sortBy<K extends keyof T>(key: K, direction: 'asc' | 'desc' = 'asc'): Collection<T> {
-    const sorted = [...this.items].sort((a, b) => {
-      const aVal = a[key]
-      const bVal = b[key]
-      if (aVal < bVal)
-        return direction === 'asc' ? -1 : 1
-      if (aVal > bVal)
-        return direction === 'asc' ? 1 : -1
-      return 0
-    })
-    return new CollectionImpl(sorted)
-  }
-
-  groupBy<K extends keyof T>(key: K): Map<T[K], Collection<T>> {
-    const groups = new Map<T[K], T[]>()
-    for (const item of this.items) {
-      const groupKey = item[key]
-      if (!groups.has(groupKey)) {
-        groups.set(groupKey, [])
-      }
-      groups.get(groupKey)!.push(item)
-    }
-    const result = new Map<T[K], Collection<T>>()
-    for (const [k, v] of groups) {
-      result.set(k, new CollectionImpl(v))
-    }
-    return result
-  }
-
-  chunk(size: number): Collection<Collection<T>> {
-    const chunks: Collection<T>[] = []
-    for (let i = 0; i < this.items.length; i += size) {
-      chunks.push(new CollectionImpl(this.items.slice(i, i + size)))
-    }
-    return new CollectionImpl(chunks)
-  }
-
-  take(count: number): Collection<T> {
-    return new CollectionImpl(this.items.slice(0, count))
-  }
-
-  skip(count: number): Collection<T> {
-    return new CollectionImpl(this.items.slice(count))
-  }
-
-  reverse(): Collection<T> {
-    return new CollectionImpl([...this.items].reverse())
-  }
-
-  sum(key?: keyof T): number {
-    if (key) {
-      return this.items.reduce((acc, item) => acc + (Number(item[key]) || 0), 0)
-    }
-    return this.items.reduce((acc, item) => acc + (Number(item) || 0), 0)
-  }
-
-  avg(key?: keyof T): number {
-    if (this.items.length === 0)
-      return 0
-    return this.sum(key) / this.items.length
-  }
-
-  min(key?: keyof T): T | undefined {
-    if (this.items.length === 0)
-      return undefined
-    if (key) {
-      return this.items.reduce((min, item) =>
-        item[key] < min[key] ? item : min,
-      )
-    }
-    return this.items.reduce((min, item) => (item < min ? item : min))
-  }
-
-  max(key?: keyof T): T | undefined {
-    if (this.items.length === 0)
-      return undefined
-    if (key) {
-      return this.items.reduce((max, item) =>
-        item[key] > max[key] ? item : max,
-      )
-    }
-    return this.items.reduce((max, item) => (item > max ? item : max))
-  }
-}
-
-// ============================================================================
-// Safe Data Implementation
-// ============================================================================
-
-/**
- * Create a safe data wrapper
- */
-export function createSafeData<T extends Record<string, unknown>>(data: T): SafeData<T> {
-  return {
-    only: <K extends keyof T>(keys: K[]): Pick<T, K> => {
-      const result = {} as Pick<T, K>
-      for (const key of keys) {
-        if (key in data) {
-          result[key] = data[key]
-        }
-      }
-      return result
-    },
-
-    except: <K extends keyof T>(keys: K[]): Omit<T, K> => {
-      const result = { ...data }
-      for (const key of keys) {
-        delete result[key]
-      }
-      return result as Omit<T, K>
-    },
-
-    // eslint-disable-next-line pickier/no-unused-vars
-    merge: <U extends Record<string, unknown>>(mergeData: U): T & U => {
-      return { ...data, ...mergeData }
-    },
-
-    all: (): T => ({ ...data }),
-
-    has: (key: keyof T): boolean => key in data,
-
-    get: <K extends keyof T>(key: K): T[K] => data[key],
-  }
-}
-
-// ============================================================================
-// Enhanced Request Methods
-// ============================================================================
-
-/**
- * Enhanced request methods interface
- */
-export interface EnhancedRequestMethods {
-  /**
-   * Validate the request data
-   */
-  validate: <T extends Record<string, unknown> = Record<string, unknown>>(
-    rules: ValidationRules,
-    messages?: Record<string, string>,
-  ) => Promise<T>
-
-  /**
-   * Get validated data as typed object
-   */
-  getValidated: <T extends Record<string, unknown> = Record<string, unknown>>() => T
-
-  /**
-   * Get safe validated data wrapper
-   */
-  safe: <T extends Record<string, unknown> = Record<string, unknown>>() => SafeData<T>
-
-  /**
-   * Execute callback when input has a value
-   */
-  whenHas: <T>(
-    key: string,
-    callback: (value: T) => void,
-    defaultCallback?: () => void,
-  ) => void
-
-  /**
-   * Execute callback when input is filled (not empty)
-   */
-  whenFilled: <T>(
-    key: string,
-    callback: (value: T) => void,
-    defaultCallback?: () => void,
-  ) => void
-
-  /**
-   * Parse date input
-   */
-  date: (key: string, format?: string) => Date | null
-
-  /**
-   * Parse enum input
-   */
-  enum: <T extends Record<string, string | number>>(
-    key: string,
-    enumType: T,
-  ) => T[keyof T] | null
-
-  /**
-   * Get input as collection
-   */
-  collect: <T = unknown>(key: string) => Collection<T>
-
-  /**
-   * Get all input keys
-   */
-  keys: () => string[]
-
-  /**
-   * Get input with type casting
-   */
-  string: (key: string, defaultValue?: string) => string
-  integer: (key: string, defaultValue?: number) => number
-  float: (key: string, defaultValue?: number) => number
-  boolean: (key: string, defaultValue?: boolean) => boolean
-
-  /**
-   * Check if input matches a value
-   */
-  isValue: (key: string, value: unknown) => boolean
-
-  /**
-   * Get old input (for form repopulation)
-   */
-  old: <T = unknown>(key: string, defaultValue?: T) => T
-
-  /**
-   * Flash input to session for form repopulation
-   */
-  flashInput: (keys?: string[]) => void
-
-  /**
-   * Flash only specific keys
-   */
-  flashInputOnly: (keys: string[]) => void
-
-  /**
-   * Flash except specific keys
-   */
-  flashInputExcept: (keys: string[]) => void
-
-  /**
-   * Get input as array
-   */
-  array: <T = unknown>(key: string) => T[]
-
-  /**
-   * Get input value from any source (query, body, params)
-   * Laravel-style request.get()
-   */
-  get: <T = unknown>(key: string, defaultValue?: T) => T
-
-  /**
-   * Get all input data
-   */
-  all: () => RequestInput
-
-  /**
-   * Get only specified keys
-   */
-  only: <T extends Record<string, unknown> = Record<string, unknown>>(keys: string[]) => T
-
-  /**
-   * Get all except specified keys
-   */
-  except: <T extends Record<string, unknown> = Record<string, unknown>>(keys: string[]) => T
-
-  /**
-   * Check if input has a key
-   */
-  has: (key: string | string[]) => boolean
-
-  /**
-   * Check if input has any of the keys
-   */
-  hasAny: (keys: string[]) => boolean
-
-  /**
-   * Check if input is filled (not empty)
-   */
-  filled: (key: string | string[]) => boolean
-
-  /**
-   * Check if input is missing
-   */
-  missing: (key: string | string[]) => boolean
-
-  /**
-   * Merge additional data into input
-   */
-  merge: (data: Record<string, unknown>) => void
-
-  /**
-   * Get input value or fail
-   */
-  input: <T = unknown>(key: string, defaultValue?: T) => T
-}
-
-// ============================================================================
-// Request Enhancement
-// ============================================================================
-
-/**
- * Enhance request with additional methods
- */
-export function enhanceRequestWithMethods(request: EnhancedRequest): EnhancedRequest & EnhancedRequestMethods {
-  const enhanced = request as EnhancedRequest & EnhancedRequestMethods & {
-    _validatedData?: ValidatedData
-    _oldInput?: RequestInput
-  }
-
-  // Merged input (query + JSON body + form body + route params).
-  // Memoized: many of the helpers below call this several times per
-  // request, and the merge result only changes when a body is parsed
-  // later — so the cache keys off the body object identities.
-  let cachedInput: RequestInput | null = null
-  let cachedJsonBody: unknown
-  let cachedFormBody: unknown
-
-  const getAllInput = (): RequestInput => {
-    if (cachedInput
-      && cachedJsonBody === request.jsonBody
-      && cachedFormBody === request.formBody) {
-      return cachedInput
-    }
-
-    const input: RequestInput = {}
-
-    // Query parameters
-    if (request.query) {
-      for (const [key, value] of Object.entries(request.query)) {
-        input[key] = value as InputValue
-      }
-    }
-
-    // JSON body
-    if (request.jsonBody) {
-      for (const [key, value] of Object.entries(request.jsonBody as Record<string, unknown>)) {
-        input[key] = value as InputValue
-      }
-    }
-
-    // Form body
-    if (request.formBody) {
-      for (const [key, value] of Object.entries(request.formBody)) {
-        input[key] = value as InputValue
-      }
-    }
-
-    // Route params
-    if (request.params) {
-      for (const [key, value] of Object.entries(request.params)) {
-        input[key] = value
-      }
-    }
-
-    cachedInput = input
-    cachedJsonBody = request.jsonBody
-    cachedFormBody = request.formBody
-    return input
-  }
-
-  /**
-   * Validate the request
-   */
-  enhanced.validate = async <T extends Record<string, unknown>>(
-    rules: ValidationRules,
-    messages?: Record<string, string>,
-  ): Promise<T> => {
-    const input = getAllInput()
-    const validator = new Validator({
-      customMessages: messages,
-    })
-
-    const errors = await validator.validate(input as Record<string, unknown>, rules as Record<string, string>)
-
-    if (Object.keys(errors).length > 0) {
-      const error = new Error('Validation failed') as Error & { errors: Record<string, string[]> }
-      error.errors = errors
-      throw error
-    }
-
-    enhanced._validatedData = input as ValidatedData
-    return input as T
-  }
-
-  /**
-   * Get validated data as typed object
-   */
-  enhanced.getValidated = <T extends Record<string, unknown>>(): T => {
-    return (enhanced._validatedData || {}) as T
-  }
-
-  /**
-   * Get safe validated data wrapper
-   */
-  enhanced.safe = <T extends Record<string, unknown>>(): SafeData<T> => {
-    return createSafeData(enhanced.getValidated<T>())
-  }
-
-  /**
-   * Execute callback when input has a value
-   */
-  enhanced.whenHas = <T>(
-    key: string,
-    callback: (value: T) => void,
-    defaultCallback?: () => void,
-  ): void => {
-    const input = getAllInput()
-    if (key in input && input[key] !== undefined) {
-      callback(input[key] as T)
-    }
-    else if (defaultCallback) {
-      defaultCallback()
-    }
-  }
-
-  /**
-   * Execute callback when input is filled
-   */
-  enhanced.whenFilled = <T>(
-    key: string,
-    callback: (value: T) => void,
-    defaultCallback?: () => void,
-  ): void => {
-    const input = getAllInput()
-    const value = input[key]
-    const isFilled = value !== undefined
-      && value !== null
-      && value !== ''
-      && !(Array.isArray(value) && value.length === 0)
-
-    if (isFilled) {
-      callback(value as T)
-    }
-    else if (defaultCallback) {
-      defaultCallback()
-    }
-  }
-
-  /**
-   * Parse date input
-   */
-  enhanced.date = (key: string, _format?: string): Date | null => {
-    const input = getAllInput()
-    const value = input[key]
-
-    if (!value)
-      return null
-
-    const date = new Date(String(value))
-    return Number.isNaN(date.getTime()) ? null : date
-  }
-
-  /**
-   * Parse enum input
-   */
-  enhanced.enum = <T extends Record<string, string | number>>(
-    key: string,
-    enumType: T,
-  ): T[keyof T] | null => {
-    const input = getAllInput()
-    const value = input[key]
-
-    if (value === undefined || value === null)
-      return null
-
-    const enumValues = Object.values(enumType)
-    if (enumValues.includes(value as T[keyof T])) {
-      return value as T[keyof T]
-    }
-
-    // Try to match by key
-    const stringValue = String(value)
-    if (stringValue in enumType) {
-      return enumType[stringValue as keyof T]
-    }
-
-    return null
-  }
-
-  /**
-   * Get input as collection
-   */
-  enhanced.collect = <T = unknown>(key: string): Collection<T> => {
-    const input = getAllInput()
-    const value = input[key]
-
-    if (Array.isArray(value)) {
-      return new CollectionImpl(value as T[])
-    }
-
-    return new CollectionImpl(value ? [value as T] : [])
-  }
-
-  /**
-   * Get all input keys
-   */
-  enhanced.keys = (): string[] => {
-    return Object.keys(getAllInput())
-  }
-
-  /**
-   * Get string input
-   */
-  enhanced.string = (key: string, defaultValue: string = ''): string => {
-    const input = getAllInput()
-    const value = input[key]
-    return value !== undefined && value !== null ? String(value) : defaultValue
-  }
-
-  /**
-   * Get integer input
-   */
-  enhanced.integer = (key: string, defaultValue: number = 0): number => {
-    const input = getAllInput()
-    const value = input[key]
-    const parsed = Number.parseInt(String(value), 10)
-    return Number.isNaN(parsed) ? defaultValue : parsed
-  }
-
-  /**
-   * Get float input
-   */
-  enhanced.float = (key: string, defaultValue: number = 0): number => {
-    const input = getAllInput()
-    const value = input[key]
-    const parsed = Number.parseFloat(String(value))
-    return Number.isNaN(parsed) ? defaultValue : parsed
-  }
-
-  /**
-   * Get boolean input
-   */
-  enhanced.boolean = (key: string, defaultValue: boolean = false): boolean => {
-    const input = getAllInput()
-    const value = input[key]
-
-    if (value === undefined || value === null)
-      return defaultValue
-    if (typeof value === 'boolean')
-      return value
-    if (value === 'true' || value === '1' || value === 1)
-      return true
-    if (value === 'false' || value === '0' || value === 0)
-      return false
-
-    return defaultValue
-  }
-
-  /**
-   * Check if input matches a value
-   */
-  enhanced.isValue = (key: string, value: unknown): boolean => {
-    const input = getAllInput()
-    return input[key] === value
-  }
-
-  /**
-   * Get old input
-   */
-  enhanced.old = <T = unknown>(key: string, defaultValue?: T): T => {
-    const oldInput = enhanced._oldInput || {}
-    return (oldInput[key] as T) ?? (defaultValue as T)
-  }
-
-  /**
-   * Flash input to session for form repopulation
-   */
-  enhanced.flashInput = (keys?: string[]): void => {
-    const input = getAllInput()
-    if (keys) {
-      const filtered: RequestInput = {}
-      for (const key of keys) {
-        if (key in input) {
-          filtered[key] = input[key]
-        }
-      }
-      enhanced._oldInput = filtered
-    }
-    else {
-      enhanced._oldInput = input
-    }
-  }
-
-  /**
-   * Flash only specific keys
-   */
-  enhanced.flashInputOnly = (keys: string[]): void => {
-    enhanced.flashInput(keys)
-  }
-
-  /**
-   * Flash except specific keys
-   */
-  enhanced.flashInputExcept = (keys: string[]): void => {
-    const input = getAllInput()
-    const filtered: RequestInput = {}
-    for (const [key, value] of Object.entries(input)) {
-      if (!keys.includes(key)) {
-        filtered[key] = value
-      }
-    }
-    enhanced._oldInput = filtered
-  }
-
-  /**
-   * Get input as array
-   */
-  enhanced.array = <T = unknown>(key: string): T[] => {
-    const input = getAllInput()
-    const value = input[key]
-
-    if (Array.isArray(value)) {
-      return value as T[]
-    }
-
-    return value !== undefined && value !== null ? [value as T] : []
-  }
-
-  /**
-   * Get input value from any source (query, body, params) - Laravel style
-   */
-  enhanced.get = <T = unknown>(key: string, defaultValue?: T): T => {
-    const input = getAllInput()
-    const value = input[key]
-    return (value !== undefined ? value : defaultValue) as T
-  }
-
-  /**
-   * Get all input data
-   */
-  enhanced.all = (): RequestInput => {
-    return getAllInput()
-  }
-
-  /**
-   * Get only specified keys
-   */
-  enhanced.only = <T extends Record<string, unknown> = Record<string, unknown>>(keys: string[]): T => {
-    const input = getAllInput()
-    const result = {} as T
-    for (const key of keys) {
-      if (key in input) {
-        (result as Record<string, unknown>)[key] = input[key]
-      }
-    }
-    return result
-  }
-
-  /**
-   * Get all except specified keys
-   */
-  enhanced.except = <T extends Record<string, unknown> = Record<string, unknown>>(keys: string[]): T => {
-    const input = getAllInput()
-    const result = { ...input } as T
-    for (const key of keys) {
-      delete (result as Record<string, unknown>)[key]
-    }
-    return result
-  }
-
-  /**
-   * Check if input has a key (or all keys if array)
-   */
-  enhanced.has = (key: string | string[]): boolean => {
-    const input = getAllInput()
-    if (Array.isArray(key)) {
-      return key.every(k => k in input && input[k] !== undefined)
-    }
-    return key in input && input[key] !== undefined
-  }
-
-  /**
-   * Check if input has any of the keys
-   */
-  enhanced.hasAny = (keys: string[]): boolean => {
-    const input = getAllInput()
-    return keys.some(k => k in input && input[k] !== undefined)
-  }
-
-  /**
-   * Check if input is filled (not empty)
-   */
-  enhanced.filled = (key: string | string[]): boolean => {
-    const input = getAllInput()
-    const isFilled = (k: string): boolean => {
-      const value = input[k]
-      return value !== undefined
-        && value !== null
-        && value !== ''
-        && !(Array.isArray(value) && value.length === 0)
-    }
-
-    if (Array.isArray(key)) {
-      return key.every(isFilled)
-    }
-    return isFilled(key)
-  }
-
-  /**
-   * Check if input is missing
-   */
-  enhanced.missing = (key: string | string[]): boolean => {
-    const input = getAllInput()
-    if (Array.isArray(key)) {
-      return key.every(k => !(k in input) || input[k] === undefined)
-    }
-    return !(key in input) || input[key] === undefined
-  }
-
-  /**
-   * Merge additional data into input
-   */
-  enhanced.merge = (data: Record<string, unknown>): void => {
-    if (request.jsonBody && typeof request.jsonBody === 'object') {
-      Object.assign(request.jsonBody, data)
-    }
-    else {
-      (request as any).jsonBody = data
-    }
-    // In-place mutation doesn't change jsonBody's identity, so drop the
-    // memoized merge explicitly
-    cachedInput = null
-  }
-
-  /**
-   * Get input value - alias for get() for Laravel compatibility
-   */
-  enhanced.input = <T = unknown>(key: string, defaultValue?: T): T => {
-    return enhanced.get(key, defaultValue)
-  }
-
-  return enhanced
-}
-
-// ============================================================================
-// Middleware for Request Enhancement
-// ============================================================================
-
-/**
- * Middleware to enhance request with additional methods
- */
-export function enhancedRequestMiddleware() {
-  return async (req: EnhancedRequest, next: () => Promise<Response | null>): Promise<Response | null> => {
-    enhanceRequestWithMethods(req)
-    return next()
-  }
-}
-
-// Note: Collection interface and CollectionImpl class are already exported above
-// enhanceRequestWithMethods is already exported above