@stacksjs/bun-router 0.0.17 → 0.0.19

package/src/router/group-organization.ts

@@ -1,229 +0,0 @@
-import type { ActionHandler, RouteGroup } from '../types'
-import type { Router } from './router'
-import { joinPaths } from '../utils'
-
-/**
- * Route grouping and organization extension for Router class
- */
-export function registerGroupOrganization(RouterClass: typeof Router): void {
-  Object.defineProperties(RouterClass.prototype, {
-    /**
-     * Create a route group with shared attributes
-     */
-    group: {
-      value(options: RouteGroup, callback: () => void): Router {
-        // Save the current group if there is one
-        const previousGroup = this.currentGroup
-
-        // Create a new group by merging with previous group
-        const newGroup: RouteGroup = { ...previousGroup }
-
-        // Handle prefix nesting
-        if (options.prefix && previousGroup?.prefix) {
-          newGroup.prefix = joinPaths(previousGroup.prefix, options.prefix)
-        }
-        else if (options.prefix) {
-          newGroup.prefix = options.prefix
-        }
-
-        // Merge middleware
-        if (options.middleware) {
-          newGroup.middleware = [
-            ...(previousGroup?.middleware || []),
-            ...options.middleware,
-          ]
-        }
-
-        // Set the new group
-        this.currentGroup = newGroup
-
-        // Execute the callback to register routes in this group
-        const result = callback() as unknown
-
-        // Async callbacks (e.g. `register()`'s dynamic import) register
-        // their routes after this call returns — the group must stay
-        // active until the promise settles, and callers must await.
-        if (result instanceof Promise) {
-          return result.then(
-            () => {
-              this.currentGroup = previousGroup
-              return this
-            },
-            (error: unknown) => {
-              this.currentGroup = previousGroup
-              throw error
-            },
-          ) as unknown as Router
-        }
-
-        // Restore the previous group
-        this.currentGroup = previousGroup
-
-        return this
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Create a route group with a name prefix
-     */
-    name: {
-      value(prefix: string, callback: () => void): Router {
-        // Save previous group
-        const previousGroup = this.currentGroup || {}
-
-        // Create a new group with the name prefix
-        const newGroup: RouteGroup = { ...previousGroup }
-        this.currentGroup = newGroup
-
-        // Keep track of routes before the callback
-        const routeCountBefore = this.routes.length
-
-        // Execute the callback to register routes
-        callback()
-
-        // Apply name prefix to newly added routes
-        for (let i = routeCountBefore; i < this.routes.length; i++) {
-          const route = this.routes[i]
-          if (route.name) {
-            route.name = `${prefix}.${route.name}`
-          }
-        }
-
-        // Restore previous group
-        this.currentGroup = previousGroup
-
-        return this
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Create a route group with a controller
-     */
-    controller: {
-      value(controller: string | (new () => any), callback: () => void): Router {
-        // Save previous group
-        const previousGroup = this.currentGroup || {}
-
-        // Create a new group with the controller
-        const newGroup: RouteGroup = { ...previousGroup, controller }
-        this.currentGroup = newGroup
-
-        // Execute the callback to register routes
-        callback()
-
-        // Restore previous group
-        this.currentGroup = previousGroup
-
-        return this
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Create a route group with a domain
-     */
-    domain: {
-      value(domain: string, callback: () => void): Router {
-        // Save previous domain
-        const previousDomain = this.currentDomain
-
-        // Set the new domain
-        this.currentDomain = domain
-
-        // Execute the callback to register routes
-        callback()
-
-        // Restore previous domain
-        this.currentDomain = previousDomain
-
-        return this
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Create a route group with a prefix
-     */
-    prefix: {
-      value(prefix: string, callback: () => void): Router {
-        return this.group({ prefix }, callback)
-      },
-      writable: true,
-      configurable: true,
-    },
-
-    /**
-     * Create RESTful resource routes
-     */
-    resource: {
-      value(
-        name: string,
-        handler: string | { [key: string]: ActionHandler },
-        type: 'api' | 'web' = 'api',
-      ): Router {
-        // Normalize the name to build paths
-        const pluralName = name.endsWith('s') ? name : `${name}s`
-        const singularName = name.endsWith('s') ? name.slice(0, -1) : name
-
-        // Define the routes to create
-        const routes = [
-          { name: 'index', method: 'GET', path: `/${pluralName}`, action: 'index' },
-          { name: 'create', method: 'GET', path: `/${pluralName}/create`, action: 'create' },
-          { name: 'store', method: 'POST', path: `/${pluralName}`, action: 'store' },
-          { name: 'show', method: 'GET', path: `/${pluralName}/{id}`, action: 'show' },
-          { name: 'edit', method: 'GET', path: `/${pluralName}/{id}/edit`, action: 'edit' },
-          { name: 'update', method: 'PUT', path: `/${pluralName}/{id}`, action: 'update' },
-          { name: 'destroy', method: 'DELETE', path: `/${pluralName}/{id}`, action: 'destroy' },
-        ]
-
-        // Use the name prefix for route names
-        this.name(singularName, () => {
-          for (const route of routes) {
-            let routeHandler: ActionHandler
-
-            if (typeof handler === 'string') {
-              // If handler is a string, use it as a prefix for the action
-              routeHandler = `${handler}${route.action.charAt(0).toUpperCase() + route.action.slice(1)}Action` as any
-            }
-            else {
-              // If handler is an object, get the action handler from it
-              if (handler[route.action]) {
-                routeHandler = handler[route.action]
-              }
-              else {
-                // Skip this route if no handler is defined
-                continue
-              }
-            }
-
-            // Register the route with the appropriate HTTP method
-            switch (route.method) {
-              case 'GET':
-                this.get(route.path, routeHandler, type, route.name)
-                break
-              case 'POST':
-                this.post(route.path, routeHandler, type, route.name)
-                break
-              case 'PUT':
-                this.put(route.path, routeHandler, type, route.name)
-                break
-              case 'DELETE':
-                this.delete(route.path, routeHandler, type, route.name)
-                break
-            }
-          }
-        })
-
-        return this
-      },
-      writable: true,
-      configurable: true,
-    },
-  })
-}

package/src/router/handler-resolver.ts

@@ -1,327 +0,0 @@
-/**
- * Handler Resolver
- *
- * Resolves route handlers from various formats:
- * - Functions returning Response
- * - Functions returning strings/objects (auto-wrapped)
- * - String file paths like 'UserAction.ts' or './actions/UserAction'
- * - Controller@method patterns like 'UserController@index'
- * - Class constructors with handle() method
- * - Class instances with handle() method
- */
-
-import type { EnhancedRequest, RouterConfig } from '../types'
-
-/**
- * Wraps a value in a Response object if it's not already a Response
- */
-export function wrapResponse(value: unknown): Response {
-  // Already a Response
-  if (value instanceof Response) {
-    return value
-  }
-
-  // Null or undefined - return 204 No Content
-  if (value === null || value === undefined) {
-    return new Response(null, { status: 204 })
-  }
-
-  // String - return as text/plain
-  if (typeof value === 'string') {
-    return new Response(value, {
-      headers: { 'Content-Type': 'text/plain; charset=utf-8' },
-    })
-  }
-
-  // Number or boolean - convert to string
-  if (typeof value === 'number' || typeof value === 'boolean') {
-    return new Response(String(value), {
-      headers: { 'Content-Type': 'text/plain; charset=utf-8' },
-    })
-  }
-
-  // ArrayBuffer or Uint8Array - return as binary
-  if (value instanceof ArrayBuffer || value instanceof Uint8Array) {
-    return new Response(value as any, {
-      headers: { 'Content-Type': 'application/octet-stream' },
-    })
-  }
-
-  // ReadableStream - return as stream
-  if (value instanceof ReadableStream) {
-    return new Response(value)
-  }
-
-  // Object or array - return as JSON
-  if (typeof value === 'object') {
-    return new Response(JSON.stringify(value), {
-      headers: { 'Content-Type': 'application/json; charset=utf-8' },
-    })
-  }
-
-  // Fallback - convert to string
-  return new Response(String(value), {
-    headers: { 'Content-Type': 'text/plain; charset=utf-8' },
-  })
-}
-
-/**
- * Resolves a string handler path to an imported module
- */
-async function importHandler(handlerPath: string, config: RouterConfig): Promise<unknown> {
-  const actionsPath = config.actionsPath || 'actions'
-  const controllersPath = config.controllersPath || 'controllers'
-
-  // Normalize the path - remove .ts/.js extension if present
-  const normalizedPath = handlerPath.replace(/\.(ts|js)$/, '')
-
-  // List of paths to try for importing
-  const pathsToTry: string[] = []
-
-  // Check if it's a Controller@method pattern
-  if (normalizedPath.includes('@')) {
-    const [controllerName, _methodName] = normalizedPath.split('@')
-    pathsToTry.push(
-      `${controllersPath}/${controllerName}`,
-      `${controllersPath}/${controllerName}.ts`,
-      `${controllersPath}/${controllerName}.js`,
-      `./${controllersPath}/${controllerName}`,
-      `../${controllersPath}/${controllerName}`,
-    )
-  }
-  // Check if it's an Actions/ path pattern
-  else if (normalizedPath.startsWith('Actions/') || normalizedPath.startsWith('actions/')) {
-    pathsToTry.push(
-      normalizedPath,
-      `./${normalizedPath}`,
-      `../${normalizedPath}`,
-    )
-  }
-  // Check if it's a relative path
-  else if (normalizedPath.startsWith('./') || normalizedPath.startsWith('../')) {
-    pathsToTry.push(normalizedPath)
-  }
-  // Otherwise, try various locations
-  else {
-    pathsToTry.push(
-      // Try actionsPath first
-      `${actionsPath}/${normalizedPath}`,
-      `./${actionsPath}/${normalizedPath}`,
-      `../${actionsPath}/${normalizedPath}`,
-      // Try direct import
-      normalizedPath,
-      `./${normalizedPath}`,
-      `../${normalizedPath}`,
-    )
-  }
-
-  let lastError: Error | null = null
-
-  for (const path of pathsToTry) {
-    try {
-      const module = await import(path)
-      return module
-    }
-    catch (error) {
-      lastError = error as Error
-      // Continue trying other paths
-    }
-  }
-
-  throw new Error(
-    `Failed to import handler "${handlerPath}".\n`
-    + `Tried paths: ${pathsToTry.join(', ')}\n`
-    + `Last error: ${lastError?.message || 'Unknown error'}`,
-  )
-}
-
-/**
- * Check if a value is a callable function handler
- */
-function isCallableHandler(handler: unknown): handler is (req: EnhancedRequest) => unknown {
-  return typeof handler === 'function' && !handler.prototype?.handle
-}
-
-/**
- * Resolves and executes a handler, returning a Response
- */
-export async function resolveHandler(
-  handler: unknown,
-  req: EnhancedRequest,
-  config: RouterConfig,
-): Promise<Response> {
-  // 0. If it's already a Response (static route), clone and return it directly
-  if (handler instanceof Response) {
-    return handler.clone() as Response
-  }
-
-  // 1. If it's a function (not a class with handle method), call it and wrap the result
-  if (isCallableHandler(handler)) {
-    const result = await handler(req)
-    return wrapResponse(result)
-  }
-
-  // 2. If it's a string, try to import and resolve
-  if (typeof handler === 'string') {
-    return resolveStringHandler(handler, req, config)
-  }
-
-  // 3. If it's a class constructor with handle method
-  if (
-    typeof handler === 'function'
-    && handler.prototype
-    && typeof handler.prototype.handle === 'function'
-  ) {
-    const HandlerClass = handler as new () => { handle: (req: EnhancedRequest) => unknown }
-    const instance = new HandlerClass()
-    const result = await instance.handle(req)
-    return wrapResponse(result)
-  }
-
-  // 4. If it's an object with a handle method
-  if (handler && typeof handler === 'object' && 'handle' in handler) {
-    const handlerObj = handler as { handle: (req: EnhancedRequest) => unknown }
-    if (typeof handlerObj.handle === 'function') {
-      const result = await handlerObj.handle(req)
-      return wrapResponse(result)
-    }
-  }
-
-  throw new Error(`Invalid handler type: ${typeof handler}`)
-}
-
-/**
- * Resolves a string-based handler
- */
-async function resolveStringHandler(
-  handlerPath: string,
-  req: EnhancedRequest,
-  config: RouterConfig,
-): Promise<Response> {
-  const controllersPath = config.controllersPath || 'controllers'
-
-  // Check if it's a Controller@method pattern
-  if (handlerPath.includes('@')) {
-    const [controllerName, methodName] = handlerPath.split('@')
-
-    // Import the controller
-    const pathsToTry = [
-      `${controllersPath}/${controllerName}`,
-      `./${controllersPath}/${controllerName}`,
-      `../${controllersPath}/${controllerName}`,
-      controllerName,
-      `./${controllerName}`,
-      `../${controllerName}`,
-    ]
-
-    let module: unknown = null
-    let lastError: Error | null = null
-
-    for (const path of pathsToTry) {
-      try {
-        module = await import(path)
-        break
-      }
-      catch (error) {
-        lastError = error as Error
-      }
-    }
-
-    if (!module) {
-      throw new Error(
-        `Failed to import controller "${controllerName}".\n`
-        + `Tried paths: ${pathsToTry.join(', ')}\n`
-        + `Last error: ${lastError?.message || 'Unknown error'}`,
-      )
-    }
-
-    const Controller = (module as { default?: unknown }).default || module
-
-    // Instantiate and call method
-    if (typeof Controller === 'function') {
-      const instance = new (Controller as new () => Record<string, unknown>)()
-      const method = instance[methodName]
-
-      if (typeof method !== 'function') {
-        throw new TypeError(`Method "${methodName}" not found on controller "${controllerName}"`)
-      }
-
-      const result = await (method as (req: EnhancedRequest) => unknown).call(instance, req)
-      return wrapResponse(result)
-    }
-
-    throw new Error(`Controller "${controllerName}" is not a valid class`)
-  }
-
-  // Import the action handler
-  const module = await importHandler(handlerPath, config)
-  const Handler = (module as { default?: unknown }).default || module
-
-  // If it's a function, call it
-  if (typeof Handler === 'function') {
-    // Check if it's a class with handle method
-    if (Handler.prototype && typeof Handler.prototype.handle === 'function') {
-      const instance = new (Handler as new () => { handle: (req: EnhancedRequest) => unknown })()
-      const result = await instance.handle(req)
-      return wrapResponse(result)
-    }
-
-    // It's a regular function
-    const result = await (Handler as (req: EnhancedRequest) => unknown)(req)
-    return wrapResponse(result)
-  }
-
-  // If it's an object with handle method
-  if (Handler && typeof Handler === 'object' && 'handle' in Handler) {
-    const handlerObj = Handler as { handle: (req: EnhancedRequest) => unknown }
-    if (typeof handlerObj.handle === 'function') {
-      const result = await handlerObj.handle(req)
-      return wrapResponse(result)
-    }
-  }
-
-  throw new Error(`Handler "${handlerPath}" does not export a valid handler function or class`)
-}
-
-/**
- * Creates a handler resolver bound to a specific config
- */
-export function createHandlerResolver(config: RouterConfig): (handler: unknown, req: EnhancedRequest) => Promise<Response> {
-  return (handler: unknown, req: EnhancedRequest) => resolveHandler(handler, req, config)
-}
-
-/**
- * Precompile the dispatch branch for a handler whose shape never changes
- * (a registered route's handler). `resolveHandler` re-sniffs the handler
- * type — instanceof / typeof / prototype checks — on every request; this
- * resolves the branch once and returns a specialized invoker for the
- * per-request hot path.
- */
-export function createHandlerInvoker(
-  handler: unknown,
-  config: RouterConfig,
-): (req: EnhancedRequest) => Promise<Response> {
-  // Static Response routes
-  if (handler instanceof Response) {
-    return async () => handler.clone() as Response
-  }
-
-  // Plain function handlers (the common case)
-  if (isCallableHandler(handler)) {
-    return async (req: EnhancedRequest) => wrapResponse(await handler(req))
-  }
-
-  // Class constructors with a handle() method
-  if (
-    typeof handler === 'function'
-    && handler.prototype
-    && typeof handler.prototype.handle === 'function'
-  ) {
-    const HandlerClass = handler as new () => { handle: (req: EnhancedRequest) => unknown }
-    return async (req: EnhancedRequest) => wrapResponse(await new HandlerClass().handle(req))
-  }
-
-  // Strings (action paths, Controller@method) and anything exotic keep
-  // the full resolution flow
-  return (req: EnhancedRequest) => resolveHandler(handler, req, config)
-}