@stacksjs/bun-router 0.0.17 → 0.0.19

package/src/testing/test-client.ts

@@ -1,310 +0,0 @@
-import type { Router } from '../router/router'
-import type { EnhancedRequest } from '../types'
-import type { TestResponseWrapper } from './test-response'
-import type { TestClientConfig, TestRequestOptions } from './types'
-import { TestRequestBuilder } from './test-request'
-import { createTestResponse } from './test-response'
-
-/**
- * Test client for making HTTP requests to router instances
- */
-export class TestClient {
-  private router: Router
-  private config: TestClientConfig
-  private defaultHeaders: Record<string, string>
-
-  constructor(router: Router, config: TestClientConfig = {}) {
-    this.router = router
-    this.config = {
-      baseUrl: 'http://localhost:3000',
-      timeout: 5000,
-      followRedirects: true,
-      validateStatus: (status: number) => status >= 200 && status < 300,
-      ...config,
-    }
-    this.defaultHeaders = config.defaultHeaders || {}
-  }
-
-  /**
-   * Make a GET request
-   */
-  async get(path: string, options: TestRequestOptions = {}): Promise<TestResponseWrapper> {
-    return this.request('GET', path, options)
-  }
-
-  /**
-   * Make a POST request
-   */
-  async post(path: string, options: TestRequestOptions = {}): Promise<TestResponseWrapper> {
-    return this.request('POST', path, options)
-  }
-
-  /**
-   * Make a PUT request
-   */
-  async put(path: string, options: TestRequestOptions = {}): Promise<TestResponseWrapper> {
-    return this.request('PUT', path, options)
-  }
-
-  /**
-   * Make a PATCH request
-   */
-  async patch(path: string, options: TestRequestOptions = {}): Promise<TestResponseWrapper> {
-    return this.request('PATCH', path, options)
-  }
-
-  /**
-   * Make a DELETE request
-   */
-  async delete(path: string, options: TestRequestOptions = {}): Promise<TestResponseWrapper> {
-    return this.request('DELETE', path, options)
-  }
-
-  /**
-   * Make an OPTIONS request
-   */
-  async options(path: string, options: TestRequestOptions = {}): Promise<TestResponseWrapper> {
-    return this.request('OPTIONS', path, options)
-  }
-
-  /**
-   * Make a HEAD request
-   */
-  async head(path: string, options: TestRequestOptions = {}): Promise<TestResponseWrapper> {
-    return this.request('HEAD', path, options)
-  }
-
-  /**
-   * Make a request with custom method
-   */
-  async request(method: string, path: string, options: TestRequestOptions = {}): Promise<TestResponseWrapper> {
-    // Merge default headers
-    const headers = { ...this.defaultHeaders, ...options.headers }
-    const requestOptions = { ...options, headers }
-
-    // Build the test request
-    const request = new TestRequestBuilder(method, path, requestOptions).build()
-
-    try {
-      // Handle the request through the router
-      const response = await this.handleRequest(request)
-      return await createTestResponse(response)
-    }
-    catch (error) {
-      throw new Error(`Test request failed: ${error instanceof Error ? error.message : 'Unknown error'}`)
-    }
-  }
-
-  /**
-   * Handle request through the router
-   */
-  private async handleRequest(request: EnhancedRequest): Promise<Response> {
-    // Find matching route
-    const url = new URL(request.url)
-    const matchResult = this.findMatchingRoute(request.method, url.pathname)
-
-    if (!matchResult) {
-      return new Response('Not Found', { status: 404 })
-    }
-
-    const { route, params } = matchResult
-
-    // Update request with route params
-    request.params = { ...request.params, ...params }
-
-    try {
-      // Execute middleware chain
-      const response = await this.executeMiddlewareChain(request, route)
-      return response || new Response('No response', { status: 500 })
-    }
-    catch (error) {
-      return new Response(
-        JSON.stringify({ error: error instanceof Error ? error.message : 'Internal Server Error' }),
-        {
-          status: 500,
-          headers: { 'Content-Type': 'application/json' },
-        },
-      )
-    }
-  }
-
-  /**
-   * Find matching route for the request
-   */
-  private findMatchingRoute(method: string, pathname: string): { route: any, params: Record<string, string> } | null {
-    for (const route of this.router.routes) {
-      if (route.method.toLowerCase() !== method.toLowerCase()) {
-        continue
-      }
-
-      // Simple pattern matching for testing
-      const params = this.matchPath(route.path, pathname)
-      if (params !== null) {
-        return { route, params }
-      }
-    }
-    return null
-  }
-
-  /**
-   * Simple path matching with parameter extraction
-   */
-  private matchPath(pattern: string, pathname: string): Record<string, string> | null {
-    const patternParts = pattern.split('/')
-    const pathParts = pathname.split('/')
-
-    if (patternParts.length !== pathParts.length) {
-      return null
-    }
-
-    const params: Record<string, string> = {}
-
-    for (let i = 0; i < patternParts.length; i++) {
-      const patternPart = patternParts[i]
-      const pathPart = pathParts[i]
-
-      if (patternPart.startsWith(':')) {
-        // Parameter
-        const paramName = patternPart.slice(1)
-        params[paramName] = pathPart
-      }
-      else if (patternPart !== pathPart) {
-        // Literal mismatch
-        return null
-      }
-    }
-
-    return params
-  }
-
-  /**
-   * Execute middleware chain and route handler
-   */
-  private async executeMiddlewareChain(request: EnhancedRequest, route: any): Promise<Response> {
-    const middlewares = [...this.router.globalMiddleware, ...route.middleware]
-    let index = 0
-
-    const next = async (): Promise<Response | null> => {
-      if (index < middlewares.length) {
-        const middleware = middlewares[index++]
-        return await middleware(request, next)
-      }
-      else {
-        // Execute route handler
-        return await this.executeHandler(route.handler, request)
-      }
-    }
-
-    const result = await next()
-    return result || new Response('No response', { status: 500 })
-  }
-
-  /**
-   * Execute route handler
-   */
-  private async executeHandler(handler: any, request: EnhancedRequest): Promise<Response> {
-    if (typeof handler === 'function') {
-      return await handler(request)
-    }
-    else if (typeof handler === 'string') {
-      // Handle string-based handlers (would normally load from file)
-      throw new TypeError(`String handlers not supported in test environment: ${handler}`)
-    }
-    else if (typeof handler === 'object' && handler.handle) {
-      // Handle class-based handlers
-      const instance = new (handler as any)()
-      return await instance.handle(request)
-    }
-
-    throw new Error('Invalid handler type')
-  }
-
-  /**
-   * Set default headers for all requests
-   */
-  setDefaultHeaders(headers: Record<string, string>): TestClient {
-    this.defaultHeaders = { ...this.defaultHeaders, ...headers }
-    return this
-  }
-
-  /**
-   * Set authorization header for all requests
-   */
-  auth(token: string, type: 'Bearer' | 'Basic' = 'Bearer'): TestClient {
-    this.defaultHeaders.Authorization = `${type} ${token}`
-    return this
-  }
-
-  /**
-   * Set user agent for all requests
-   */
-  userAgent(userAgent: string): TestClient {
-    this.defaultHeaders['User-Agent'] = userAgent
-    return this
-  }
-
-  /**
-   * Create a new test client with additional configuration
-   */
-  withConfig(config: Partial<TestClientConfig>): TestClient {
-    return new TestClient(this.router, { ...this.config, ...config })
-  }
-
-  /**
-   * Create a new test client with additional headers
-   */
-  withHeaders(headers: Record<string, string>): TestClient {
-    return new TestClient(this.router, {
-      ...this.config,
-      defaultHeaders: { ...this.defaultHeaders, ...headers },
-    })
-  }
-
-  /**
-   * Get the router instance
-   */
-  getRouter(): Router {
-    return this.router
-  }
-
-  /**
-   * Get client configuration
-   */
-  getConfig(): TestClientConfig {
-    return { ...this.config }
-  }
-}
-
-/**
- * Create a test client for a router
- */
-export function createTestClient(router: Router, config?: TestClientConfig): TestClient {
-  return new TestClient(router, config)
-}
-
-/**
- * Test client factory with fluent API
- */
-export const testClient = {
-  /**
-   * Create a test client for a router
-   */
-  for: (router: Router, config?: TestClientConfig): TestClient => createTestClient(router, config),
-
-  /**
-   * Create a test client with specific configuration
-   */
-  withConfig: (config: TestClientConfig): (router: Router) => TestClient => (router: Router): TestClient => createTestClient(router, config),
-
-  /**
-   * Create a test client with authentication
-   */
-  withAuth: (token: string, type: 'Bearer' | 'Basic' = 'Bearer'): (router: Router) => TestClient => (router: Router): TestClient =>
-    createTestClient(router).auth(token, type),
-
-  /**
-   * Create a test client with custom headers
-   */
-  withHeaders: (headers: Record<string, string>): (router: Router) => TestClient => (router: Router): TestClient =>
-    createTestClient(router).withHeaders(headers),
-}

package/src/testing/test-request.ts

@@ -1,315 +0,0 @@
-import type { CookieAccessor, CookieOptions, EnhancedRequest, UploadedFile } from '../types'
-import type { TestFile, TestRequestOptions } from './types'
-
-/**
- * Creates a CookieAccessor from a plain Record<string, string>
- */
-function createCookieAccessor(cookies: Record<string, string>): CookieAccessor {
-  const cookieStore = { ...cookies }
-  return {
-    get: (name: string) => cookieStore[name],
-    set: (name: string, value: string, _options?: CookieOptions) => {
-      cookieStore[name] = value
-    },
-    delete: (name: string, _options?: CookieOptions) => {
-      delete cookieStore[name]
-    },
-    getAll: () => ({ ...cookieStore }),
-  }
-}
-
-/**
- * Creates a mock EnhancedRequest for testing
- */
-export class TestRequestBuilder {
-  private request: Partial<EnhancedRequest>
-  private url: URL
-
-  constructor(method: string, path: string, options: TestRequestOptions = {}) {
-    this.url = new URL(path, 'http://localhost:3000')
-
-    // Apply query parameters
-    if (options.query) {
-      Object.entries(options.query).forEach(([key, value]) => {
-        if (Array.isArray(value)) {
-          value.forEach(v => this.url.searchParams.append(key, v))
-        }
-        else {
-          this.url.searchParams.set(key, value)
-        }
-      })
-    }
-
-    this.request = {
-      method,
-      url: this.url.toString(),
-      headers: new Headers(options.headers || {}),
-      params: {},
-      query: this.parseQuery(this.url.searchParams),
-      jsonBody: undefined,
-      formBody: options.body && typeof options.body === 'object' ? options.body : undefined,
-      files: options.files ? this.convertTestFiles(options.files) : undefined,
-      session: options.session,
-      user: options.user,
-      context: options.context || {},
-      requestId: `test-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-      ip: '127.0.0.1',
-      userAgent: () => 'BunRouter-TestClient/1.0',
-      cookies: createCookieAccessor(options.cookies || {}),
-      startTime: Date.now(),
-      traceId: `trace-${Date.now()}`,
-      spanId: `span-${Date.now()}`,
-    }
-
-    // Handle body based on content type
-    this.handleBody(options.body)
-  }
-
-  private parseQuery(searchParams: URLSearchParams): Record<string, string | string[]> {
-    const query: Record<string, string | string[]> = {}
-
-    for (const [key, value] of searchParams.entries()) {
-      if (query[key]) {
-        if (Array.isArray(query[key])) {
-          (query[key] as string[]).push(value)
-        }
-        else {
-          query[key] = [query[key] as string, value]
-        }
-      }
-      else {
-        query[key] = value
-      }
-    }
-
-    return query
-  }
-
-  private convertTestFiles(testFiles: TestFile[]): UploadedFile[] {
-    return testFiles.map(file => ({
-      fieldName: file.fieldName,
-      originalName: file.filename,
-      filename: `test-${Date.now()}-${file.filename}`,
-      path: `/tmp/test-uploads/${file.filename}`,
-      size: file.content instanceof ArrayBuffer
-        ? file.content.byteLength
-        : new TextEncoder().encode(file.content.toString()).length,
-      mimetype: file.mimetype || 'application/octet-stream',
-      buffer: file.content instanceof ArrayBuffer
-        ? file.content
-        : new TextEncoder().encode(file.content.toString()).buffer as ArrayBuffer,
-    }))
-  }
-
-  private handleBody(body: any): void {
-    if (!body)
-      return
-
-    const contentType = this.request.headers?.get('content-type') || ''
-
-    if (contentType.includes('application/json') || typeof body === 'object') {
-      this.request.jsonBody = body
-      if (!this.request.headers?.has('content-type')) {
-        this.request.headers?.set('content-type', 'application/json')
-      }
-    }
-    else if (contentType.includes('application/x-www-form-urlencoded')) {
-      this.request.formBody = body
-    }
-  }
-
-  /**
-   * Set route parameters
-   */
-  params(params: Record<string, string>): TestRequestBuilder {
-    this.request.params = { ...this.request.params, ...params }
-    return this
-  }
-
-  /**
-   * Set request headers
-   */
-  headers(headers: Record<string, string>): TestRequestBuilder {
-    Object.entries(headers).forEach(([key, value]) => {
-      this.request.headers?.set(key, value)
-    })
-    return this
-  }
-
-  /**
-   * Set authorization header
-   */
-  auth(token: string, type: 'Bearer' | 'Basic' = 'Bearer'): TestRequestBuilder {
-    this.request.headers?.set('Authorization', `${type} ${token}`)
-    return this
-  }
-
-  /**
-   * Set user context
-   */
-  user(user: any): TestRequestBuilder {
-    this.request.user = user
-    return this
-  }
-
-  /**
-   * Set session data
-   */
-  session(session: any): TestRequestBuilder {
-    this.request.session = session
-    return this
-  }
-
-  /**
-   * Set cookies
-   */
-  cookies(cookies: Record<string, string>): TestRequestBuilder {
-    const existingCookies = this.request.cookies?.getAll() || {}
-    this.request.cookies = createCookieAccessor({ ...existingCookies, ...cookies })
-    return this
-  }
-
-  /**
-   * Set context data
-   */
-  context(context: Record<string, any>): TestRequestBuilder {
-    this.request.context = { ...this.request.context, ...context }
-    return this
-  }
-
-  /**
-   * Set JSON body
-   */
-  json(data: any): TestRequestBuilder {
-    this.request.jsonBody = data
-    this.request.headers?.set('content-type', 'application/json')
-    return this
-  }
-
-  /**
-   * Set form body
-   */
-  form(data: Record<string, any>): TestRequestBuilder {
-    this.request.formBody = data
-    this.request.headers?.set('content-type', 'application/x-www-form-urlencoded')
-    return this
-  }
-
-  /**
-   * Add uploaded files
-   */
-  files(files: TestFile[]): TestRequestBuilder {
-    this.request.files = this.convertTestFiles(files)
-    this.request.headers?.set('content-type', 'multipart/form-data')
-    return this
-  }
-
-  /**
-   * Set IP address
-   */
-  ip(ip: string): TestRequestBuilder {
-    this.request.ip = ip
-    return this
-  }
-
-  /**
-   * Set user agent
-   */
-  userAgent(userAgent: string): TestRequestBuilder {
-    this.request.userAgent = () => userAgent
-    this.request.headers?.set('User-Agent', userAgent)
-    return this
-  }
-
-  /**
-   * Set CSRF token
-   */
-  csrf(token: string): TestRequestBuilder {
-    this.request.csrfToken = token
-    this.request.headers?.set('X-CSRF-Token', token)
-    return this
-  }
-
-  /**
-   * Build the final request object
-   */
-  build(): EnhancedRequest {
-    // Create a proper Request object
-    const init: RequestInit = {
-      method: this.request.method,
-      headers: this.request.headers,
-    }
-
-    if (this.request.jsonBody) {
-      init.body = JSON.stringify(this.request.jsonBody)
-    }
-    else if (this.request.formBody) {
-      const formData = new FormData()
-      Object.entries(this.request.formBody).forEach(([key, value]) => {
-        formData.append(key, value as string)
-      })
-      init.body = formData
-    }
-
-    const baseRequest = new Request(this.url.toString(), init)
-
-    // Create enhanced request by copying properties to a new object
-    // We can't use Proxy due to Request immutability constraints in Bun
-    const enhancedRequest = Object.assign(baseRequest, {
-      params: this.request.params || {},
-      query: this.request.query || {},
-      jsonBody: this.request.jsonBody,
-      formBody: this.request.formBody,
-      files: this.request.files,
-      session: this.request.session,
-      user: this.request.user,
-      context: this.request.context || {},
-      requestId: this.request.requestId,
-      ip: this.request.ip,
-      userAgent: this.request.userAgent,
-      cookies: this.request.cookies || {},
-      startTime: this.request.startTime,
-      traceId: this.request.traceId,
-      spanId: this.request.spanId,
-    })
-
-    return enhancedRequest as EnhancedRequest
-  }
-}
-
-/**
- * Helper functions for creating test requests
- */
-export const testRequest = {
-  get: (path: string, options?: TestRequestOptions): TestRequestBuilder =>
-    new TestRequestBuilder('GET', path, options),
-
-  post: (path: string, options?: TestRequestOptions): TestRequestBuilder =>
-    new TestRequestBuilder('POST', path, options),
-
-  put: (path: string, options?: TestRequestOptions): TestRequestBuilder =>
-    new TestRequestBuilder('PUT', path, options),
-
-  patch: (path: string, options?: TestRequestOptions): TestRequestBuilder =>
-    new TestRequestBuilder('PATCH', path, options),
-
-  delete: (path: string, options?: TestRequestOptions): TestRequestBuilder =>
-    new TestRequestBuilder('DELETE', path, options),
-
-  options: (path: string, options?: TestRequestOptions): TestRequestBuilder =>
-    new TestRequestBuilder('OPTIONS', path, options),
-
-  head: (path: string, options?: TestRequestOptions): TestRequestBuilder =>
-    new TestRequestBuilder('HEAD', path, options),
-}
-
-/**
- * Create a mock request with minimal setup
- */
-export function createMockRequest(
-  method: string = 'GET',
-  path: string = '/',
-  options: TestRequestOptions = {},
-): EnhancedRequest {
-  return new TestRequestBuilder(method, path, options).build()
-}