@stacksjs/bun-router 0.0.5 → 0.0.6

package/src/router/validation-integration.ts

@@ -0,0 +1,443 @@
+/**
+ * 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

@@ -0,0 +1,233 @@
+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,
+    },
+  })
+}