@stacksjs/bun-router 0.0.5 → 0.0.7

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

@@ -0,0 +1,209 @@
+/**
+ * SQLite Embedded Caching
+ *
+ * High-performance embedded caching using Bun's SQLite integration
+ */
+export 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 interface CacheEntry {
+    key: string;
+    value: string;
+    expires: number;
+    created: number;
+    accessed: number;
+    hits: number;
+    size: number;
+    compressed: boolean;
+}
+export 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;
+    private config;
+    private stats;
+    private cleanupTimer?;
+    private preparedStatements;
+    constructor(config?: SQLiteCacheConfig);
+    /**
+     * Get value from cache
+     */
+    get<T = any>(key: string): T | null;
+    /**
+     * Set value in cache
+     */
+    set<T = any>(key: string, value: T, ttl?: number): boolean;
+    /**
+     * Delete value from cache
+     */
+    delete(key: string): boolean;
+    /**
+     * Check if key exists in cache
+     */
+    has(key: string): boolean;
+    /**
+     * Clear all cache entries
+     */
+    clear(): boolean;
+    /**
+     * Get cache statistics
+     */
+    getStats(): CacheStats;
+    /**
+     * Get all keys matching pattern
+     */
+    keys(pattern?: string): string[];
+    /**
+     * Get multiple values at once
+     */
+    mget<T = any>(keys: string[]): Record<string, T | null>;
+    /**
+     * Set multiple values at once
+     */
+    mset<T = any>(entries: Record<string, T>, ttl?: number): boolean;
+    /**
+     * Increment numeric value
+     */
+    increment(key: string, delta?: number, ttl?: number): number | null;
+    /**
+     * Decrement numeric value
+     */
+    decrement(key: string, delta?: number, ttl?: number): number | null;
+    /**
+     * Set value only if key doesn't exist
+     */
+    setnx<T = any>(key: string, value: T, ttl?: number): boolean;
+    /**
+     * Get and delete value atomically
+     */
+    getdel<T = any>(key: string): T | null;
+    /**
+     * Update TTL for existing key
+     */
+    expire(key: string, ttl: number): boolean;
+    /**
+     * Get TTL for key
+     */
+    ttl(key: string): number;
+    /**
+     * Cleanup expired entries
+     */
+    cleanup(): number;
+    /**
+     * Close database connection
+     */
+    close(): void;
+    /**
+     * Initialize SQLite database
+     */
+    private initializeDatabase;
+    /**
+     * Prepare SQL statements
+     */
+    private prepareStatements;
+    /**
+     * Start cleanup timer
+     */
+    private startCleanupTimer;
+    /**
+     * Evict entries if cache is too large
+     */
+    private evictIfNeeded;
+    /**
+     * Update cache statistics
+     */
+    private updateCacheStats;
+    /**
+     * Update operation statistics
+     */
+    private updateStats;
+    /**
+     * Compress string value
+     */
+    private compress;
+    /**
+     * Decompress string value
+     */
+    private decompress;
+}
+/**
+ * SQLite cache factory
+ */
+export declare class SQLiteCacheFactory {
+    /**
+     * Create in-memory cache
+     */
+    static createMemoryCache(config?: Partial<SQLiteCacheConfig>): SQLiteCache;
+    /**
+     * Create persistent cache
+     */
+    static createPersistentCache(filename: string, config?: Partial<SQLiteCacheConfig>): SQLiteCache;
+    /**
+     * Create high-performance cache
+     */
+    static createHighPerformanceCache(config?: Partial<SQLiteCacheConfig>): SQLiteCache;
+    /**
+     * Create development cache with debugging
+     */
+    static createDevelopmentCache(config?: Partial<SQLiteCacheConfig>): SQLiteCache;
+}
+/**
+ * Cache middleware factory
+ */
+export declare function createSQLiteCacheMiddleware(cache: SQLiteCache, options?: {
+    keyGenerator?: (request: Request) => string;
+    ttl?: number;
+    skipMethods?: string[];
+    skipPaths?: string[];
+    skipHeaders?: string[];
+}): (request: Request, next: () => Promise<Response>) => Promise<Response>;
+/**
+ * SQLite cache helpers
+ */
+export declare const SQLiteCacheHelpers: {
+    /**
+     * Create session cache
+     */
+    createSessionCache: (cache: SQLiteCache) => {
+        get: (sessionId: string) => any;
+        set: (sessionId: string, data: any, ttl?: number) => void;
+        delete: (sessionId: string) => boolean;
+        touch: (sessionId: string, ttl?: number) => boolean;
+    };
+    /**
+     * Create rate limiting cache
+     */
+    createRateLimitCache: (cache: SQLiteCache) => {
+        increment: (key: string, window?: number) => number;
+        get: (key: string) => number;
+        reset: (key: string) => boolean;
+    };
+    /**
+     * Create query result cache
+     */
+    createQueryCache: (cache: SQLiteCache) => {
+        get: (query: string, params: any[]) => any;
+        set: (query: string, params: any[], result: any, ttl?: number) => void;
+        invalidate: (pattern: string) => void;
+    };
+};

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

@@ -0,0 +1,132 @@
+import type { LRUCacheOptions } from './lru-cache';
+/**
+ * Response streaming cache for large responses
+ * Optimized for handling large payloads with memory-efficient streaming
+ */
+export interface StreamingCacheOptions extends Omit<LRUCacheOptions, 'maxSize'> {
+    maxSize: number;
+    maxResponseSize: number;
+    chunkSize: number;
+    compressionEnabled: boolean;
+    compressionThreshold: number;
+}
+export interface CachedResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: Uint8Array | null;
+    compressed: boolean;
+    originalSize: number;
+    timestamp: number;
+    etag?: string;
+}
+export 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 options;
+    private cache;
+    private stats;
+    constructor(options: StreamingCacheOptions);
+    /**
+     * Cache a response with streaming support
+     */
+    cacheResponse(key: string, response: Response, options?: {
+        ttl?: number;
+        forceCache?: boolean;
+        generateETag?: boolean;
+    }): Promise<void>;
+    /**
+     * Get cached response as a streaming response
+     */
+    getStreamingResponse(key: string): Promise<Response | null>;
+    /**
+     * Check if response should be cached based on headers and size
+     */
+    shouldCache(response: Response): boolean;
+    /**
+     * Warm cache with common routes
+     */
+    warmCache(routes: Array<{
+        key: string;
+        url: string;
+        method?: string;
+        headers?: Record<string, string>;
+    }>): Promise<number>;
+    /**
+     * Create conditional response based on ETag
+     */
+    createConditionalResponse(key: string, ifNoneMatch?: string): Response | null;
+    /**
+     * Get cache statistics
+     */
+    getStats(): StreamingCacheStats & {
+        lruStats: any;
+    };
+    /**
+     * Clear cache and reset statistics
+     */
+    clear(): void;
+    /**
+     * Prune expired entries
+     */
+    prune(): number;
+    /**
+     * Create streaming response for large payloads
+     */
+    private createStreamingResponse;
+    /**
+     * Extract headers from response (excluding hop-by-hop headers)
+     */
+    private extractHeaders;
+    /**
+     * Compress data using gzip
+     */
+    private compressData;
+    /**
+     * Decompress data using gzip
+     */
+    private decompressData;
+    /**
+     * Generate ETag for response body
+     */
+    private generateETag;
+    /**
+     * Update statistics when caching a response
+     */
+    private updateStatsOnCache;
+    /**
+     * Update statistics when evicting a response
+     */
+    private updateStatsOnEviction;
+}
+/**
+ * Factory functions for creating streaming caches with common configurations
+ */
+export declare const createStreamingCache: {
+    /**
+     * Create cache optimized for API responses
+     */
+    api: (maxSize?: number) => StreamingCache;
+    /**
+     * Create cache optimized for static assets
+     */
+    assets: (maxSize?: number) => StreamingCache;
+    /**
+     * Create cache optimized for HTML pages
+     */
+    pages: (maxSize?: number) => StreamingCache;
+    /**
+     * Create custom configured streaming cache
+     */
+    custom: (options: StreamingCacheOptions) => StreamingCache;
+};

package/dist/cli/colors.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Simple color utility for CLI output without external dependencies
+ */
+export declare const chalk: {
+    red: (text: string) => string;
+    green: (text: string) => string;
+    yellow: (text: string) => string;
+    blue: (text: string) => string;
+    cyan: (text: string) => string;
+    white: (text: string) => string;
+    gray: (text: string) => string;
+    bold: (text: string) => string;
+    dim: (text: string) => string;
+    hex: (_color: string) => (text: string) => string;
+};

package/dist/cli/index.d.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,31 @@
+/**
+ * Options for the middleware:types command
+ */
+export interface GenerateMiddlewareTypesOptions {
+    output?: string;
+    watch?: boolean;
+}
+/**
+ * Options for the middleware:map command
+ */
+export interface MapMiddlewareOptions {
+    output?: string;
+    dir?: string;
+    watch?: boolean;
+}
+/**
+ * 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>;

package/dist/cli/openapi.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Options for the openapi command
+ */
+export interface OpenAPIOptions {
+    output?: string;
+    title?: string;
+    version?: string;
+    description?: string;
+    basePath?: string;
+    servers?: string;
+    tags?: boolean;
+    security?: boolean;
+}
+/**
+ * Generate OpenAPI specification for API routes
+ */
+export declare function generateOpenAPISpec(options: OpenAPIOptions): Promise<void>;

package/dist/cli/router.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Options for the router:types command
+ */
+export interface GenerateRouterTypesOptions {
+    output?: string;
+    watch?: boolean;
+}
+/**
+ * Generate TypeScript types for router extensions
+ */
+export declare function generateRouterTypes(outputPath: string): Promise<void>;
+/**
+ * Watch for changes in router files and regenerate types
+ */
+export declare function watchRouterFiles(outputPath: string): Promise<void>;

package/dist/cli/routes.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Options for the route:list command
+ */
+export interface RouteListOptions {
+    verbose?: boolean;
+    extraVerbose?: boolean;
+    path?: string;
+    exceptVendor?: boolean;
+    onlyVendor?: boolean;
+}
+/**
+ * Options for the route:types command
+ */
+export interface GenerateRouteTypesOptions {
+    output?: string;
+    watch?: boolean;
+}
+/**
+ * Display all registered routes in a formatted table
+ */
+export declare function displayRoutes(options: RouteListOptions): Promise<void>;
+/**
+ * Generate TypeScript types for route names
+ */
+export declare function generateRouteTypes(outputPath: string): Promise<void>;
+/**
+ * Watch for changes in the routes directory and regenerate types
+ */
+export declare function watchRoutesDirectory(outputPath: string): Promise<void>;

package/dist/cli/utils.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Formats console output with consistent styling
+ */
+export declare const format: {
+    success: (message: string) => string;
+    info: (message: string) => string;
+    warning: (message: string) => string;
+    error: (message: string) => string;
+    dim: (message: string) => string;
+    bold: (message: string) => string;
+};
+/**
+ * Logger for CLI commands with consistent styling
+ */
+export declare const logger: {
+    success: (message: string) => void;
+    info: (message: string) => void;
+    warning: (message: string) => void;
+    error: (message: string) => void;
+    debug: (message: string) => void;
+};
+/**
+ * Load router instance from the application
+ */
+export declare function loadRouter(): Promise<any>;
+/**
+ * Setup a debounced file watcher
+ */
+export declare function setupDebouncedWatcher(_callback: () => Promise<void>, _debounceTime?: number): {
+    timeoutId: NodeJS.Timeout | null;
+};
+/**
+ * Utility to get method color for console output
+ */
+export declare function getMethodColor(method: string): string;
+/**
+ * Pad a string to a specified length
+ */
+export declare function padString(str: string, length: number): string;
+/**
+ * Check router health and configuration
+ */
+export declare function checkRouterHealth(options: {
+    verbose?: boolean;
+}): Promise<void>;
+/**
+ * Test routes by making HTTP requests
+ */
+export declare function testRoutes(options: {
+    baseUrl?: string;
+    filter?: string;
+    method?: string;
+    timeout?: number;
+}): Promise<void>;
+/**
+ * Debug route matching for a specific path
+ */
+export declare function debugRoute(path: string, options: {
+    method?: string;
+    verbose?: boolean;
+}): Promise<void>;
+/**
+ * Clear route caches
+ */
+export declare function clearCaches(options: {
+    stats?: boolean;
+}): Promise<void>;
+/**
+ * Validate route definitions and configuration
+ */
+export declare function validateRoutes(options: {
+    strict?: boolean;
+    fix?: boolean;
+}): Promise<void>;

package/dist/cli.d.ts

@@ -1 +1 @@
-
+export {};

package/dist/cli.js

@@ -1879,7 +1879,7 @@ var prefix = getPrefix();
 var color18 = __toESM(require_picocolors(), 1);
 var import_picocolors19 = __toESM(require_picocolors(), 1);
 // package.json
-var version = "0.0.5";
+var version = "0.0.7";
 
 // src/cli/middleware.ts
 import fs from "fs/promises";

package/dist/config.d.ts

@@ -0,0 +1,7 @@
+import type { RouterConfig } from './types';
+/**
+ * Default configuration for the router
+ */
+export declare const defaultConfig: RouterConfig;
+export declare function getConfig(): Promise<RouterConfig>;
+export declare const config: RouterConfig;