@stacksjs/bun-router 0.0.2 → 0.0.4

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@stacksjs/bun-router",
   "type": "module",
-  "version": "0.0.2",
-  "description": "A",
+  "version": "0.0.4",
+  "description": "A fast, type-safe router for Bun.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",
   "homepage": "https://github.com/stacksjs/bun-router#readme",
@@ -24,10 +24,12 @@
   ],
   "exports": {
     ".": {
+      "bun": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
     "./*": {
+      "bun": "./src/*",
       "import": "./dist/*"
     }
   },
@@ -64,18 +66,14 @@
     "prepublishOnly": "bun --bun run build && bun run compile:all && bun run zip",
     "release": "bun run changelog && bunx bumpp package.json --all",
     "test": "bun test",
-    "dev:docs": "bun --bun vitepress dev docs",
-    "build:docs": "bun --bun vitepress build docs",
-    "preview:docs": "bun --bun vitepress preview docs",
     "typecheck": "bunx --bun tsc --noEmit"
   },
   "dependencies": {
     "@stacksjs/clapp": "^0.2.0",
-    "bun-query-builder": "^0.1.10",
-    "openapi-types": "^12.1.3",
-    "ts-rate-limiter": "^0.4.0"
+    "bun-query-builder": "^0.1.13",
+    "ts-rate-limiter": "^0.4.1"
   },
   "lint-staged": {
-    "*.{js,ts}": "bunx --bun eslint . --fix"
+    "*.{js,ts}": "bunx --bun pickier . --fix"
   }
 }

package/dist/auth.d.ts

@@ -1,77 +0,0 @@
-import type { EnhancedRequest, JwtPayload } from './types';
-export type { JwtPayload };
-// Types
-export declare interface JwtVerifyOptions {
-  issuer?: string
-  audience?: string
-  subject?: string
-  algorithms?: string[]
-  expiresIn?: string | number
-  notBefore?: string | number
-  ignoreExpiration?: boolean
-  allowInvalidAsymmetricKeyTypes?: boolean
-}
-export declare interface JwtSignOptions {
-  algorithm?: 'HS256' | 'HS384' | 'HS512' | 'RS256' | 'RS384' | 'RS512' | 'ES256' | 'ES384' | 'ES512' | 'PS256' | 'PS384' | 'PS512' | 'none'
-  expiresIn?: string | number
-  notBefore?: string | number
-  audience?: string | string[]
-  issuer?: string
-  subject?: string
-  keyid?: string
-  jwtid?: string
-  noTimestamp?: boolean
-  header?: Record<string, any>
-  encoding?: string
-}
-export declare interface ApiKeyOptions {
-  source?: 'header' | 'query' | 'cookie'
-  keyName?: string
-  keyPrefix?: string
-}
-export declare interface OAuth2Config {
-  clientId: string
-  clientSecret: string
-  authorizeUrl: string
-  tokenUrl: string
-  redirectUri: string
-  scope?: string
-  state?: string
-}
-/**
- * Simple JWT implementation for signing and verifying tokens
- */
-export declare class JWT {
-  private secret: string;
-  constructor(secret: string);
-  sign(payload: Record<string, any>, options?: JwtSignOptions): string;
-  verify(token: string, options?: JwtVerifyOptions): Record<string, any> | null;
-  decode(token: string): { header: Record<string, any>, payload: Record<string, any> } | null;
-  private createSignature(data: string, secret: string, algorithm: string): string;
-  private parseTimespan(timespan: string): number;
-}
-/**
- * API Key manager to generate, validate and handle API keys
- */
-export declare class ApiKeyManager {
-  private keys: Map<string, { owner: string, scopes: string[], expiresAt?: Date }>;
-  private options: ApiKeyOptions;
-  constructor(options?: ApiKeyOptions);
-  generateKey(owner: string, scopes?: string[], expiresIn?: number): string;
-  validateKey(key: string, requiredScopes?: string[]): boolean;
-  getKeyInfo(key: string): { owner: string, scopes: string[], expiresAt?: Date } | null;
-  revokeKey(key: string): boolean;
-  extractFromRequest(req: EnhancedRequest): string | null;
-  private randomString(length: number): string;
-}
-/**
- * OAuth2 helper for authorization code flow
- */
-export declare class OAuth2Helper {
-  private config: OAuth2Config;
-  constructor(config: OAuth2Config);
-  getAuthorizationUrl(additionalParams?: Record<string, string>): string;
-  exchangeCodeForToken(code: string): Promise<Record<string, any>>;
-  refreshToken(refreshToken: string): Promise<Record<string, any>>;
-}
-export default Auth;

package/dist/cache/lru-cache.d.ts

@@ -1,88 +0,0 @@
-/**
- * Factory function to create LRU cache with common configurations
- */
-export declare const createLRUCache: {
-  /**
-   * Create a small cache for frequently accessed items
-   */
-  small: () => unknown;
-  /**
-   * Create a medium cache for general purpose use
-   */
-  medium: () => unknown;
-  /**
-   * Create a large cache for heavy caching scenarios
-   */
-  large: () => unknown;
-  /**
-   * Create a custom configured cache
-   */
-  custom: () => unknown
-};
-/**
- * High-performance LRU (Least Recently Used) cache implementation
- * Optimized for Bun runtime with configurable size limits and TTL support
- */
-export declare interface LRUCacheOptions {
-  maxSize: number
-  ttl?: number
-  onEvict?: (key: string, value: any) => void
-  allowStale?: boolean
-  updateAgeOnGet?: boolean
-}
-export declare interface CacheEntry<T = any> {
-  value: T
-  timestamp: number
-  accessCount: number
-  lastAccessed: number
-  ttl?: number
-}
-export declare interface CacheStats {
-  size: number
-  maxSize: number
-  hits: number
-  misses: number
-  evictions: number
-  hitRate: number
-  memoryUsage: number
-}
-/**
- * Node in the doubly linked list for LRU tracking
- */
-declare class LRUNode<T = any> {
-  public key: string;
-  public entry: CacheEntry<T>;
-  public prev?: LRUNode<T> | null;
-  public next?: LRUNode<T> | null;
-  constructor(key: string, entry: CacheEntry<T>, prev?: LRUNode<T> | null, next?: LRUNode<T> | null);
-}
-/**
- * High-performance LRU cache with TTL support and detailed statistics
- */
-export declare class LRUCache<T = any> {
-  private cache: any;
-  private head: LRUNode<T> | null;
-  private tail: LRUNode<T> | null;
-  private stats: any;
-  private options: LRUCacheOptions;
-  constructor(options: LRUCacheOptions);
-  get(key: string): T | undefined;
-  set(key: string, value: T, ttl?: number): void;
-  delete(key: string): boolean;
-  has(key: string): boolean;
-  clear(): void;
-  keys(): string[];
-  values(): T[];
-  getStats(): CacheStats;
-  resetStats(): void;
-  prune(): number;
-  getFrequentlyUsed(limit?: number): Array<{ key: string, value: T, accessCount: number }>;
-  resize(newMaxSize: number): void;
-  private isExpired(entry: CacheEntry<T>, now: number): boolean;
-  private moveToFront(node: LRUNode<T>): void;
-  private addToFront(node: LRUNode<T>): void;
-  private removeNode(node: LRUNode<T>): void;
-  private evictLRU(): void;
-  private estimateMemoryUsage(): number;
-  private estimateValueSize(value: any): number;
-}

package/dist/cache/middleware-memoization.d.ts

@@ -1,101 +0,0 @@
-import { LRUCache } from './lru-cache';
-import type { EnhancedRequest, MiddlewareHandler } from '../types';
-import type { LRUCacheOptions } from './lru-cache';
-/**
- * Decorator for memoizing class methods
- */
-export declare function Memoize(options?: {
-  memoizer: MiddlewareMemoizer
-  keyGenerator?: (...args: any[]) => string
-  ttl?: number
-}): MethodDecorator;
-/**
- * Factory functions for creating memoizers
- */
-export declare const createMemoizer: {
-  /**
-   * Create memoizer for development
-   */
-  development: () => any;
-  /**
-   * Create memoizer for production
-   */
-  production: () => any;
-  /**
-   * Create custom memoizer
-   */
-  custom: (options: MemoizationOptions) => any
-};
-/**
- * Middleware result memoization for expensive operations
- * Caches middleware results based on request characteristics
- */
-export declare interface MemoizationOptions extends Omit<LRUCacheOptions, 'maxSize'> {
-  maxSize: number
-  keyGenerator?: (req: EnhancedRequest) => string
-  shouldMemoize?: (req: EnhancedRequest, result: any) => boolean
-  resultSerializer?: (result: any) => any
-  resultDeserializer?: (serialized: any) => any
-}
-export declare interface MemoizedResult<T = any> {
-  value: T
-  timestamp: number
-  requestFingerprint: string
-  executionTime: number
-  hitCount: number
-}
-export declare interface MemoizationStats {
-  totalRequests: number
-  cacheHits: number
-  cacheMisses: number
-  hitRate: number
-  averageExecutionTime: number
-  totalTimeSaved: number
-  memoryUsage: number
-}
-/**
- * Middleware memoization system for caching expensive operations
- */
-export declare class MiddlewareMemoizer {
-  private cache: LRUCache<MemoizedResult>;
-  private stats: MemoizationStats;
-  private options: MemoizationOptions;
-  constructor(options: MemoizationOptions);
-  memoize<_T = any>(middleware: MiddlewareHandler, options?: {
-      name?: string
-      keyGenerator?: (req: EnhancedRequest) => string
-      shouldMemoize?: (req: EnhancedRequest, result: any) => boolean
-      ttl?: number
-    }): MiddlewareHandler;
-  memoizeFunction<TArgs extends any[], TResult>(fn: (...args: TArgs) => Promise<TResult>, options?: {
-      name?: string
-      keyGenerator?: (...args: TArgs) => string
-      shouldMemoize?: (result: TResult, ...args: TArgs) => boolean
-      ttl?: number
-    }): (...args: TArgs) => Promise<TResult>;
-  invalidate(pattern: string | RegExp): number;
-  invalidateForUser(userId: string): number;
-  invalidateByTag(tag: string): number;
-  getPopularResults(limit?: number): Array<{
-    key: string
-    hitCount: number
-    executionTime: number
-    timeSaved: number
-  }>;
-  getStats(): MemoizationStats;
-  clear(): void;
-  prune(): number;
-  private generateCacheKey(req: EnhancedRequest, middlewareName: string, customKeyGenerator?: (req: EnhancedRequest) => string): string;
-  private generateRequestFingerprint(req: EnhancedRequest): string;
-  private updateHitRate(): void;
-}
-/**
- * Common memoization patterns and utilities
- */
-export declare class MemoizationPatterns {
-  static createDatabaseMemoizer(options?: MemoizationOptions): MiddlewareMemoizer;
-  static createApiMemoizer(options?: MemoizationOptions): MiddlewareMemoizer;
-  static createAuthMemoizer(options?: MemoizationOptions): MiddlewareMemoizer;
-  static createRateLimitMemoizer(options?: MemoizationOptions): MiddlewareMemoizer;
-  static createComputationMemoizer(options?: MemoizationOptions): MiddlewareMemoizer;
-}

package/dist/cache/route-cache-warmer.d.ts

@@ -1,125 +0,0 @@
-import type { LRUCache } from './lru-cache';
-import type { StreamingCache } from './streaming-cache';
-/**
- * Factory functions for creating route cache warmers
- */
-export declare const createRouteCacheWarmer: {
-  /**
-   * Create warmer for development environment
-   */
-  development: (routeCache: LRUCache<any>, streamingCache?: StreamingCache) => any;
-  /**
-   * Create warmer for production environment
-   */
-  production: (routeCache: LRUCache<any>, streamingCache?: StreamingCache) => any;
-  /**
-   * Create warmer with custom configuration
-   */
-  custom: ( config: WarmupConfig, routeCache: LRUCache<any>, streamingCache?: StreamingCache, ) => any
-};
-/**
- * Route cache warming system for pre-populating caches with common routes
- */
-export declare interface WarmupRoute {
-  path: string
-  method: string
-  priority: number
-  frequency: number
-  params?: Record<string, string>
-  query?: Record<string, string>
-  headers?: Record<string, string>
-  warmupData?: any
-}
-export declare interface AnalyticsRoute {
-  path: string
-  method: string
-  frequency: number
-}
-export declare interface RecentRoute {
-  path: string
-  method: string
-  timestamp: number
-}
-export declare interface PrecomputeRoute {
-  path: string
-  method: string
-  computeFunction: () => Promise<any>
-  cacheKey?: string
-  ttl?: number
-}
-export declare interface UserSegment {
-  segment: string
-  commonRoutes: string[]
-  priority: number
-}
-export declare interface TimeRange {
-  start: number
-  end: number
-}
-export declare interface TimeBasedPattern {
-  timeRange: TimeRange
-  routes: string[]
-  priority: number
-}
-export declare interface GeographicPattern {
-  region: string
-  routes: string[]
-  priority: number
-}
-export declare interface IntelligentWarmupPatterns {
-  userSegments?: UserSegment[]
-  timeBasedPatterns?: TimeBasedPattern[]
-  geographicPatterns?: GeographicPattern[]
-}
-export declare interface WarmupConfig {
-  enabled: boolean
-  maxConcurrency: number
-  warmupTimeout: number
-  retryAttempts: number
-  retryDelay: number
-  scheduleInterval?: number
-  priorityThreshold: number
-}
-export declare interface WarmupStats {
-  totalRoutes: number
-  successfulWarmups: number
-  failedWarmups: number
-  averageWarmupTime: number
-  lastWarmupTime: number
-  cacheHitRateImprovement: number
-}
-/**
- * Route cache warmer for pre-populating caches with frequently accessed routes
- */
-export declare class RouteCacheWarmer {
-  private routes: WarmupRoute[];
-  private routeCache: LRUCache<any>;
-  private streamingCache?: StreamingCache;
-  private stats: WarmupStats;
-  private warmupTimer?: Timer;
-  private config: WarmupConfig;
-  constructor(config: WarmupConfig, routeCache: LRUCache<any>, streamingCache?: StreamingCache);
-  registerRoutes(routes: WarmupRoute[]): void;
-  registerRoute(route: WarmupRoute): void;
-  warmCache(options?: {
-    routes?: string[] // Specific routes to warm (by path)
-    maxRoutes?: number // Maximum number of routes to warm
-    skipLowPriority?: boolean
-  }): Promise<WarmupStats>;
-  warmFromAnalytics(analytics: {
-    topRoutes: AnalyticsRoute[]
-    recentRoutes: RecentRoute[]
-  }): Promise<void>;
-  precomputeRoutes(routes: PrecomputeRoute[]): Promise<number>;
-  intelligentWarmup(patterns: IntelligentWarmupPatterns): Promise<void>;
-  getStats(): WarmupStats;
-  resetStats(): void;
-  stop(): void;
-  private warmRoutesWithConcurrency(routes: WarmupRoute[]): Promise<{
-    successful: number
-    failed: number
-  }>;
-  private warmSingleRoute(route: WarmupRoute): Promise<void>;
-  private buildRouteUrl(route: WarmupRoute): string;
-  private schedulePeriodicWarmup(): void;
-}

package/dist/cache/sqlite-cache.d.ts

@@ -1,114 +0,0 @@
-import { Database } from 'bun:sqlite';
-/**
- * Cache middleware factory
- */
-export declare function createSQLiteCacheMiddleware(cache: SQLiteCache, options?: {
-  keyGenerator?: (request: Request) => string
-  ttl?: number
-  skipMethods?: string[]
-  skipPaths?: string[]
-  skipHeaders?: string[]
-}): void;
-/**
- * SQLite cache helpers
- */
-export declare const SQLiteCacheHelpers: {
-  /**
-   * Create session cache
-   */
-  createSessionCache: (cache: SQLiteCache) => unknown;
-  /**
-   * Create rate limiting cache
-   */
-  createRateLimitCache: (cache: SQLiteCache) => unknown;
-  /**
-   * Create query result cache
-   */
-  createQueryCache: (cache: SQLiteCache) => unknown
-};
-export declare interface SQLiteCacheConfig {
-  filename?: string
-  memory?: boolean
-  wal?: boolean
-  synchronous?: 'OFF' | 'NORMAL' | 'FULL'
-  journalMode?: 'DELETE' | 'TRUNCATE' | 'PERSIST' | 'MEMORY' | 'WAL' | 'OFF'
-  cacheSize?: number
-  pageSize?: number
-  maxSize?: number
-  defaultTTL?: number
-  cleanupInterval?: number
-  compression?: boolean
-}
-export declare interface CacheEntry {
-  key: string
-  value: string
-  expires: number
-  created: number
-  accessed: number
-  hits: number
-  size: number
-  compressed: boolean
-}
-export declare interface CacheStats {
-  totalEntries: number
-  totalSize: number
-  hitRate: number
-  missRate: number
-  evictions: number
-  compressionRatio: number
-  averageAccessTime: number
-}
-/**
- * High-performance SQLite-based cache
- */
-export declare class SQLiteCache {
-  private db: Database;
-  private config: Required<SQLiteCacheConfig>;
-  private stats: CacheStats;
-  private cleanupTimer?: Timer;
-  private preparedStatements: {
-    get: any
-    set: any
-    delete: any
-    exists: any
-    clear: any
-    cleanup: any
-    stats: any
-    touch: any
-  };
-  constructor(config?: SQLiteCacheConfig);
-  get<T = any>(key: string): T | null;
-  set<T = any>(key: string, value: T, ttl?: number): boolean;
-  delete(key: string): boolean;
-  has(key: string): boolean;
-  clear(): boolean;
-  getStats(): CacheStats;
-  keys(pattern?: string): string[];
-  mget<T = any>(keys: string[]): Record<string, T | null>;
-  mset<T = any>(entries: Record<string, T>, ttl?: number): boolean;
-  increment(key: string, delta?: number, ttl?: number): number | null;
-  decrement(key: string, delta?: number, ttl?: number): number | null;
-  setnx<T = any>(key: string, value: T, ttl?: number): boolean;
-  getdel<T = any>(key: string): T | null;
-  expire(key: string, ttl: number): boolean;
-  ttl(key: string): number;
-  cleanup(): number;
-  close(): void;
-  private initializeDatabase(): void;
-  private prepareStatements(): void;
-  private startCleanupTimer(): void;
-  private evictIfNeeded(newEntrySize: number): void;
-  private updateCacheStats(): void;
-  private updateStats(operation: 'hit' | 'miss' | 'set', responseTime: number): void;
-  private compress(value: string): string | null;
-  private decompress(value: string): string;
-}
-/**
- * SQLite cache factory
- */
-export declare class SQLiteCacheFactory {
-  static createMemoryCache(config?: Partial<SQLiteCacheConfig>): SQLiteCache;
-  static createPersistentCache(filename: string, config?: Partial<SQLiteCacheConfig>): SQLiteCache;
-  static createHighPerformanceCache(config?: Partial<SQLiteCacheConfig>): SQLiteCache;
-  static createDevelopmentCache(config?: Partial<SQLiteCacheConfig>): SQLiteCache;
-}

package/dist/cache/streaming-cache.d.ts

@@ -1,86 +0,0 @@
-import { LRUCache } from './lru-cache';
-import type { LRUCacheOptions } from './lru-cache';
-/**
- * Factory functions for creating streaming caches with common configurations
- */
-export declare const createStreamingCache: {
-  /**
-   * Create cache optimized for API responses
-   */
-  api: (maxSize: number?) => any;
-  /**
-   * Create cache optimized for static assets
-   */
-  assets: (maxSize: number?) => any;
-  /**
-   * Create cache optimized for HTML pages
-   */
-  pages: (maxSize: number?) => any;
-  /**
-   * Create custom configured streaming cache
-   */
-  custom: (options: StreamingCacheOptions) => any
-};
-/**
- * Response streaming cache for large responses
- * Optimized for handling large payloads with memory-efficient streaming
- */
-export declare interface StreamingCacheOptions extends Omit<LRUCacheOptions, 'maxSize'> {
-  maxSize: number
-  maxResponseSize: number
-  chunkSize: number
-  compressionEnabled: boolean
-  compressionThreshold: number
-}
-export declare interface CachedResponse {
-  status: number
-  statusText: string
-  headers: Record<string, string>
-  body: Uint8Array | null
-  compressed: boolean
-  originalSize: number
-  timestamp: number
-  etag?: string
-}
-export declare interface StreamingCacheStats {
-  totalResponses: number
-  totalSize: number
-  compressionRatio: number
-  averageResponseSize: number
-  largestResponse: number
-  streamingHits: number
-  streamingMisses: number
-}
-/**
- * High-performance streaming cache for large HTTP responses
- */
-export declare class StreamingCache {
-  private cache: LRUCache<CachedResponse>;
-  private stats: StreamingCacheStats;
-  private options: StreamingCacheOptions;
-  constructor(options: StreamingCacheOptions);
-  cacheResponse(key: string, response: Response, options?: {
-      ttl?: number
-      forceCache?: boolean
-      generateETag?: boolean
-    }): Promise<void>;
-  getStreamingResponse(key: string): Promise<Response | null>;
-  shouldCache(response: Response): boolean;
-  warmCache(routes: Array<{
-    key: string
-    url: string
-    method?: string
-    headers?: Record<string, string>
-  }>): Promise<number>;
-  createConditionalResponse(key: string, ifNoneMatch?: string): Response | null;
-  getStats(): StreamingCacheStats & { lruStats: any };
-  clear(): void;
-  prune(): number;
-  private createStreamingResponse(body: Uint8Array, cachedResponse: CachedResponse, headers: Headers): Response;
-  private extractHeaders(response: Response): Record<string, string>;
-  private compressData(data: Uint8Array): Promise<Uint8Array>;
-  private decompressData(data: Uint8Array): Promise<Uint8Array>;
-  private generateETag(data: Uint8Array): Promise<string>;
-  private updateStatsOnCache(originalSize: number, compressedSize: number): void;
-  private updateStatsOnEviction(cachedResponse: CachedResponse): void;
-}

package/dist/cli/colors.d.ts

@@ -1,12 +0,0 @@
-export declare const chalk: {
-  red: (text: string) => unknown;
-  green: (text: string) => unknown;
-  yellow: (text: string) => unknown;
-  blue: (text: string) => unknown;
-  cyan: (text: string) => unknown;
-  white: (text: string) => unknown;
-  gray: (text: string) => unknown;
-  bold: (text: string) => unknown;
-  dim: (text: string) => unknown;
-  hex: (_color: string) => unknown
-};

package/dist/cli/index.d.ts

@@ -1,10 +0,0 @@
-import { CLI } from '@stacksjs/clapp';
-/**
- * Create and configure the CLI
- */
-export declare function createCLI(): CLI;
-export * from './middleware';
-export * from './openapi';
-export * from './router';
-export * from './routes';
-export * from './utils';

package/dist/cli/middleware.d.ts

@@ -1,31 +0,0 @@
-/**
- * Generate TypeScript types for middleware configurations
- */
-export declare function generateMiddlewareTypes(outputPath: string): Promise<void>;
-/**
- * Generate middleware type mappings for user project
- */
-export declare function generateMiddlewareMap(directoryPath: string, outputPath: string): Promise<void>;
-/**
- * Watch for changes in the directory and regenerate middleware map
- */
-export declare function watchDirectoryForMiddleware(directoryPath: string, outputPath: string): Promise<void>;
-/**
- * Watch for changes in the middleware directory and regenerate types
- */
-export declare function watchMiddlewareDirectory(outputPath: string): Promise<void>;
-/**
- * Options for the middleware:types command
- */
-export declare interface GenerateMiddlewareTypesOptions {
-  output?: string
-  watch?: boolean
-}
-/**
- * Options for the middleware:map command
- */
-export declare interface MapMiddlewareOptions {
-  output?: string
-  dir?: string
-  watch?: boolean
-}