@stacksjs/bun-router 0.0.12 → 0.0.14

package/src/router/validation-integration.ts

@@ -1,443 +0,0 @@
-/**
- * Router Validation Integration
- *
- * Integration layer for validation and macros with the router.
- * Provides RouteBuilder and FluentRouter for building routes with validation support.
- */
-
-import type { EnhancedRequest, MiddlewareHandler, NextFunction, RouteHandler } from '../types'
-import type { ValidationRules, ValidatorConfig } from '../validation/validator'
-import { RequestWithMacros } from '../request/macros'
-import { ResponseWithMacros } from '../response/macros'
-import { createValidationMiddleware } from '../validation/validator'
-
-/**
- * Route builder with validation support
- */
-export class RouteBuilder {
-  private validationRules?: ValidationRules
-  private validatorConfig?: ValidatorConfig
-
-  constructor(
-    private method: string,
-    private path: string,
-    private handler: RouteHandler,
-  ) {}
-
-  /**
-   * Add validation to the route
-   */
-  validate(rules: ValidationRules, config?: ValidatorConfig): this {
-    this.validationRules = rules
-    this.validatorConfig = config
-    return this
-  }
-
-  /**
-   * Build the route with middleware
-   */
-  build(): { method: string, path: string, handler: RouteHandler, middleware?: MiddlewareHandler[] } {
-    const middleware: MiddlewareHandler[] = []
-
-    // Add validation middleware if rules are provided
-    if (this.validationRules) {
-      middleware.push(createValidationMiddleware(this.validationRules, this.validatorConfig))
-    }
-
-    // Add request macro middleware
-    middleware.push(async (req: EnhancedRequest, next: NextFunction) => {
-      // Apply request macros
-      RequestWithMacros.applyMacros(req)
-      const result = await next()
-      return result || new Response('Not Found', { status: 404 })
-    })
-
-    return {
-      method: this.method,
-      path: this.path,
-      handler: this.handler,
-      middleware: middleware.length > 0 ? middleware : undefined,
-    }
-  }
-}
-
-/**
- * Fluent router for enhanced routing functionality
- */
-export class FluentRouter {
-  private routes: Array<{
-    method: string
-    path: string
-    handler: RouteHandler
-    middleware?: MiddlewareHandler[]
-  }> = []
-
-  /**
-   * Create GET route
-   */
-  get(path: string, handler: RouteHandler): RouteBuilder {
-    return new RouteBuilder('GET', path, handler)
-  }
-
-  /**
-   * Create POST route
-   */
-  post(path: string, handler: RouteHandler): RouteBuilder {
-    return new RouteBuilder('POST', path, handler)
-  }
-
-  /**
-   * Create PUT route
-   */
-  put(path: string, handler: RouteHandler): RouteBuilder {
-    return new RouteBuilder('PUT', path, handler)
-  }
-
-  /**
-   * Create PATCH route
-   */
-  patch(path: string, handler: RouteHandler): RouteBuilder {
-    return new RouteBuilder('PATCH', path, handler)
-  }
-
-  /**
-   * Create DELETE route
-   */
-  delete(path: string, handler: RouteHandler): RouteBuilder {
-    return new RouteBuilder('DELETE', path, handler)
-  }
-
-  /**
-   * Register a built route
-   */
-  register(routeBuilder: RouteBuilder): void {
-    const route = routeBuilder.build()
-    this.routes.push(route)
-  }
-
-  /**
-   * Get all registered routes
-   */
-  getRoutes(): Array<{
-    method: string
-    path: string
-    handler: RouteHandler
-    middleware?: MiddlewareHandler[]
-  }> {
-    return this.routes
-  }
-}
-
-/**
- * Router middleware factory for request/response enhancements
- */
-export function createEnhancementMiddleware() {
-  return async (req: EnhancedRequest, next: () => Promise<Response>): Promise<Response> => {
-    // Apply request macros
-    RequestWithMacros.applyMacros(req)
-
-    // Add start time for age calculation
-    ;(req as any).startTime = Date.now()
-
-    return await next()
-  }
-}
-
-/**
- * Validation middleware factory with fluent API
- */
-export class ValidationMiddlewareBuilder {
-  private rules: ValidationRules = {}
-  private config: ValidatorConfig = {}
-
-  /**
-   * Add validation rule for field
-   */
-  field(name: string, rules: string): this {
-    this.rules[name] = rules
-    return this
-  }
-
-  /**
-   * Add multiple validation rules
-   */
-  fields(rules: ValidationRules): this {
-    Object.assign(this.rules, rules)
-    return this
-  }
-
-  /**
-   * Set validator configuration
-   */
-  configure(config: ValidatorConfig): this {
-    Object.assign(this.config, config)
-    return this
-  }
-
-  /**
-   * Stop on first validation failure
-   */
-  stopOnFirstFailure(): this {
-    this.config.stopOnFirstFailure = true
-    return this
-  }
-
-  /**
-   * Set custom error messages
-   */
-  messages(messages: Record<string, string>): this {
-    this.config.customMessages = messages
-    return this
-  }
-
-  /**
-   * Set custom field attributes
-   */
-  attributes(attributes: Record<string, string>): this {
-    this.config.customAttributes = attributes
-    return this
-  }
-
-  /**
-   * Build the validation middleware
-   */
-  build(): MiddlewareHandler {
-    return createValidationMiddleware(this.rules, this.config)
-  }
-}
-
-/**
- * Factory function to create validation middleware builder
- */
-export function validate(): ValidationMiddlewareBuilder {
-  return new ValidationMiddlewareBuilder()
-}
-
-/** Resource handlers configuration */
-export interface ResourceHandlers {
-  index?: RouteHandler
-  show?: RouteHandler
-  store?: RouteHandler
-  update?: RouteHandler
-  destroy?: RouteHandler
-}
-
-/** Resource validation configuration */
-export interface ResourceValidation {
-  store?: ValidationRules
-  update?: ValidationRules
-}
-
-/**
- * Route helper functions
- */
-export const RouteHelpers: {
-  validated: (method: string, path: string, handler: RouteHandler, rules: ValidationRules, config?: ValidatorConfig) => RouteBuilder
-  apiRoute: (method: string, path: string, handler: RouteHandler, rules?: ValidationRules) => RouteBuilder
-  resourceRoute: (basePath: string, handlers: ResourceHandlers, validation?: ResourceValidation) => RouteBuilder[]
-} = {
-  /**
-   * Create validated route
-   */
-  validated: (
-    method: string,
-    path: string,
-    handler: RouteHandler,
-    rules: ValidationRules,
-    config?: ValidatorConfig,
-  ): RouteBuilder => {
-    const builder = new RouteBuilder(method, path, handler)
-    return builder.validate(rules, config)
-  },
-
-  /**
-   * Create API route with JSON validation
-   */
-  apiRoute: (
-    method: string,
-    path: string,
-    handler: RouteHandler,
-    rules?: ValidationRules,
-  ): RouteBuilder => {
-    const builder = new RouteBuilder(method, path, async (req): Promise<Response> => {
-      // Ensure request expects JSON
-      if (!req.expectsJson()) {
-        return ResponseWithMacros.callMacro('error', 'API endpoint requires JSON Accept header', undefined, 406)
-      }
-
-      return await handler(req)
-    })
-
-    if (rules) {
-      builder.validate(rules)
-    }
-
-    return builder
-  },
-
-  /**
-   * Create resource route with validation
-   */
-  resourceRoute: (
-    basePath: string,
-    handlers: ResourceHandlers,
-    validation?: ResourceValidation,
-  ): RouteBuilder[] => {
-    const routes: RouteBuilder[] = []
-
-    if (handlers.index) {
-      routes.push(new RouteBuilder('GET', basePath, handlers.index))
-    }
-
-    if (handlers.show) {
-      routes.push(new RouteBuilder('GET', `${basePath}/{id}`, handlers.show))
-    }
-
-    if (handlers.store) {
-      const builder = new RouteBuilder('POST', basePath, handlers.store)
-      if (validation?.store) {
-        builder.validate(validation.store)
-      }
-      routes.push(builder)
-    }
-
-    if (handlers.update) {
-      const builder = new RouteBuilder('PUT', `${basePath}/{id}`, handlers.update)
-      if (validation?.update) {
-        builder.validate(validation.update)
-      }
-      routes.push(builder)
-    }
-
-    if (handlers.destroy) {
-      routes.push(new RouteBuilder('DELETE', `${basePath}/{id}`, handlers.destroy))
-    }
-
-    return routes
-  },
-}
-
-/**
- * Fluent router factory
- */
-export function createFluentRouter(): FluentRouter {
-  return new FluentRouter()
-}
-
-/**
- * Middleware composition helpers
- */
-export const MiddlewareHelpers = {
-  /**
-   * Compose multiple middleware into one
-   */
-  compose: (...middleware: MiddlewareHandler[]): MiddlewareHandler => {
-    return async (req: EnhancedRequest, next: NextFunction): Promise<Response | null> => {
-      let index = 0
-
-      const dispatch = async (): Promise<Response | null> => {
-        if (index >= middleware.length) {
-          return await next()
-        }
-
-        const currentMiddleware = middleware[index++]
-        return await currentMiddleware(req, dispatch)
-      }
-
-      return await dispatch()
-    }
-  },
-
-  /**
-   * Create conditional middleware
-   */
-  when: (
-    condition: (req: EnhancedRequest) => boolean,
-    middleware: MiddlewareHandler,
-  ): MiddlewareHandler => {
-    return async (req: EnhancedRequest, next: NextFunction): Promise<Response | null> => {
-      if (condition(req)) {
-        return await middleware(req, next)
-      }
-      return await next()
-    }
-  },
-
-  /**
-   * Create middleware that runs unless condition is met
-   */
-  unless: (
-    condition: (req: EnhancedRequest) => boolean,
-    middleware: MiddlewareHandler,
-  ): MiddlewareHandler => {
-    return MiddlewareHelpers.when(req => !condition(req), middleware)
-  },
-
-  /**
-   * Create middleware group
-   */
-  group: (middleware: MiddlewareHandler[]): MiddlewareHandler => {
-    return MiddlewareHelpers.compose(...middleware)
-  },
-}
-
-/** Enhancement middleware type */
-export type EnhancementMiddleware = (req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>
-
-/**
- * Request/Response enhancement presets
- */
-export const EnhancementPresets: {
-  api: () => EnhancementMiddleware[]
-  web: () => EnhancementMiddleware[]
-  validation: (rules: ValidationRules, config?: ValidatorConfig) => EnhancementMiddleware[]
-} = {
-  /**
-   * API preset with JSON validation and response macros
-   */
-  api: (): EnhancementMiddleware[] => [
-    createEnhancementMiddleware(),
-    async (req: EnhancedRequest, next: () => Promise<Response>): Promise<Response> => {
-      try {
-        const response = await next()
-
-        // Add API headers
-        const headers = new Headers(response.headers)
-        headers.set('X-API-Version', '1.0')
-        headers.set('X-Response-Time', new Date().toISOString())
-
-        return new Response(response.body, {
-          status: response.status,
-          statusText: response.statusText,
-          headers,
-        })
-      }
-      catch (error) {
-        console.error(error)
-        // Return JSON error response
-        return ResponseWithMacros.callMacro('error', 'Internal server error', undefined, 500)
-      }
-    },
-  ],
-
-  /**
-   * Web preset with request enhancements and CSRF protection
-   */
-  web: (): EnhancementMiddleware[] => [
-    createEnhancementMiddleware(),
-    async (req: EnhancedRequest, next: () => Promise<Response>): Promise<Response> => {
-      // Add web-specific enhancements
-      ;(req as any).session = {} // Placeholder for session
-
-      return await next()
-    },
-  ],
-
-  /**
-   * Validation preset with comprehensive validation
-   */
-  validation: (rules: ValidationRules, config?: ValidatorConfig): EnhancementMiddleware[] => [
-    createEnhancementMiddleware(),
-    createValidationMiddleware(rules, config) as EnhancementMiddleware,
-  ],
-}

package/src/router/view-rendering.ts

@@ -1,233 +0,0 @@
-import type { ActionHandler, EnhancedRequest, RouterConfig } from '../types'
-import type { Router } from './router'
-import { join } from 'node:path'
-import { processHtmlTemplate, resolveViewPath, injectQueryPreservationScript } from '../utils'
-
-/**
- * View rendering extension for Router class
- */
-export function registerViewRendering(RouterClass: typeof Router): void {
-  Object.defineProperties(RouterClass.prototype, {
-    /**
-     * Render a view with data
-     */
-    renderView: {
-      async value(
-        view: string,
-        data: Record<string, any> = {},
-        options: { layout?: string } = {},
-      ): Promise<string> {
-        const viewsConfig = this.config.views || {
-          viewsPath: 'resources/views',
-          extensions: ['.html', '.stx'],
-          cache: Bun.env.NODE_ENV === 'production',
-          engine: 'auto',
-        }
-
-        // Check cache first if enabled
-        const cacheKey = `${view}:${options.layout || ''}`
-        if (viewsConfig.cache && this.templateCache.has(cacheKey)) {
-          return this.processTemplate(this.templateCache.get(cacheKey)!, data, viewsConfig)
-        }
-
-        // Resolve the view path
-        const viewPath = await resolveViewPath(view, viewsConfig.viewsPath, viewsConfig.extensions)
-        if (!viewPath) {
-          throw new Error(`View '${view}' not found`)
-        }
-
-        // Read the view file
-        let viewContent = await Bun.file(viewPath).text()
-
-        // Apply layout if specified or if a default layout is configured
-        const layoutName = options.layout || viewsConfig.defaultLayout
-        if (layoutName) {
-          const layoutPath = await resolveViewPath(
-            join('layouts', layoutName),
-            viewsConfig.viewsPath,
-            viewsConfig.extensions,
-          )
-
-          if (!layoutPath) {
-            throw new Error(`Layout '${layoutName}' not found`)
-          }
-
-          const layoutContent = await Bun.file(layoutPath).text()
-          // Replace {{content}} placeholder with the view content
-          viewContent = layoutContent.replace(/\{\{\s*content\s*\}\}/g, viewContent)
-        }
-
-        // Cache the template if caching is enabled
-        if (viewsConfig.cache) {
-          this.templateCache.set(cacheKey, viewContent)
-        }
-
-        // Process the template with data
-        return this.processTemplate(viewContent, data, viewsConfig)
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Process a template with data
-     */
-    processTemplate: {
-      async value(
-        template: string,
-        data: Record<string, any>,
-        viewConfig: RouterConfig['views'],
-      ): Promise<string> {
-        // Choose template engine based on configuration
-        const engine = viewConfig?.engine || 'auto'
-
-        if (engine === 'custom' && viewConfig?.customRenderer) {
-          return viewConfig.customRenderer(template, data, {})
-        }
-
-        // Default to simple template processing
-        let processedTemplate = processHtmlTemplate(template, data)
-
-        // Apply minification if configured
-        if (viewConfig?.minify?.enabled) {
-          try {
-            const _minifyOptions = viewConfig.minify.options || {
-              removeComments: true,
-              collapseWhitespace: true,
-              minifyJS: true,
-              minifyCSS: true,
-            }
-
-            // In a real implementation, you would use a library like html-minifier
-            // This is just a placeholder
-            processedTemplate = processedTemplate
-              .replace(/\s+/g, ' ')
-              .replace(/<!--[\s\S]*?-->/g, '')
-          }
-          catch (err) {
-            console.error('Error minifying HTML:', err)
-          }
-        }
-
-        return processedTemplate
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Register a view route
-     */
-    view: {
-      value(
-        path: string,
-        viewOrData: string | Record<string, any>,
-        dataOrOptions: Record<string, any> | { layout?: string, status?: number, headers?: Record<string, string> } = {},
-        optionsOrType: { layout?: string, status?: number, headers?: Record<string, string> } | 'web' | 'api' = {},
-        typeOrName: 'web' | 'api' | string = 'web',
-        name?: string,
-      ): Router {
-        let view: string
-        let data: Record<string, any> = {}
-        let options: { layout?: string, status?: number, headers?: Record<string, string> } = {}
-        let type: 'web' | 'api' = 'web'
-        let routeName: string | undefined
-
-        // Parse the flexible parameters
-        if (typeof viewOrData === 'string') {
-          view = viewOrData
-
-          if (typeof dataOrOptions === 'object' && !Array.isArray(dataOrOptions)) {
-            // If dataOrOptions has layout, status, or headers, it's options
-            if ('layout' in dataOrOptions || 'status' in dataOrOptions || 'headers' in dataOrOptions) {
-              options = dataOrOptions as { layout?: string, status?: number, headers?: Record<string, string> }
-            }
-            else {
-              // Otherwise it's data
-              data = dataOrOptions
-            }
-          }
-
-          if (typeof optionsOrType === 'object') {
-            options = { ...options, ...optionsOrType }
-          }
-          else if (typeof optionsOrType === 'string') {
-            type = optionsOrType as 'web' | 'api'
-          }
-
-          if (typeof typeOrName === 'string') {
-            if (typeOrName === 'web' || typeOrName === 'api') {
-              type = typeOrName
-            }
-            else {
-              routeName = typeOrName
-            }
-          }
-
-          if (name) {
-            routeName = name
-          }
-        }
-        else {
-          // viewOrData is actually data
-          data = viewOrData
-
-          if (typeof dataOrOptions === 'string') {
-            view = dataOrOptions
-          }
-          else {
-            throw new TypeError('View name must be a string')
-          }
-
-          if (typeof optionsOrType === 'object') {
-            options = optionsOrType
-          }
-          else if (typeof optionsOrType === 'string') {
-            if (optionsOrType === 'web' || optionsOrType === 'api') {
-              type = optionsOrType
-            }
-            else {
-              view = optionsOrType
-              type = 'web'
-            }
-          }
-        }
-
-        // Create the route handler
-        const handler: ActionHandler = async (_req: EnhancedRequest) => {
-          let renderedView = await this.renderView(view, data, {
-            layout: options.layout,
-          })
-
-          // Inject query preservation script if configured
-          const queryPreservationConfig = this.config?.queryPreservation
-          if (queryPreservationConfig?.enabled !== false && queryPreservationConfig?.preserve?.length) {
-            renderedView = injectQueryPreservationScript(renderedView, queryPreservationConfig)
-          }
-
-          const headers = new Headers()
-          headers.set('Content-Type', 'text/html; charset=utf-8')
-
-          // Add custom headers if provided
-          if (options.headers) {
-            for (const [key, value] of Object.entries(options.headers)) {
-              headers.set(key, value)
-            }
-          }
-
-          return new Response(renderedView, {
-            status: options.status || 200,
-            headers,
-          })
-        }
-
-        // Register the route
-        this.get(path, handler, type, routeName)
-
-        return this
-      },
-      writable: true,
-      configurable: true,
-    },
-  })
-}