@stacksjs/bun-router 0.0.2 → 0.0.3

package/dist/observability/index.d.ts

@@ -1,92 +0,0 @@
-import type { EnhancedRequest } from '../types';
-import type { ObservabilityConfig, ObservabilityManager } from './integration';
-/**
- * Quick setup functions for common use cases
- */
-/**
- * Initialize observability with development preset
- */
-export declare function setupDevelopmentObservability(): Promise<ObservabilityManager>;
-/**
- * Initialize observability with production preset
- */
-export declare function setupProductionObservability(): Promise<ObservabilityManager>;
-/**
- * Initialize observability with Kubernetes preset
- */
-export declare function setupKubernetesObservability(): Promise<ObservabilityManager>;
-/**
- * Initialize observability with microservices preset
- */
-export declare function setupMicroservicesObservability(): Promise<ObservabilityManager>;
-/**
- * Initialize observability from environment variables
- */
-export declare function setupObservabilityFromEnv(): Promise<ObservabilityManager>;
-/**
- * Create a complete observability middleware stack
- */
-export declare function createObservabilityStack(config?: ObservabilityConfig): Promise<{
-  middleware: (req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>
-  endpoints: Record<string, (req: EnhancedRequest) => Promise<Response>>
-  manager: ObservabilityManager
-}>;
-export {
-  type CorrelationConfig,
-  type CorrelationContext,
-  CorrelationEndpoints,
-  CorrelationHelpers,
-  CorrelationManager,
-  createCorrelationMiddleware,
-  getCorrelationManager,
-  initializeCorrelation,
-  type ServiceCall,
-} from './correlation';
-export {
-  type CustomHealthCheck,
-  DependencyChecks,
-  type DependencyConfig,
-  getHealthManager,
-  type HealthCheckConfig,
-  HealthCheckManager,
-  type HealthCheckResult,
-  HealthEndpoints,
-  type HealthStatus,
-  initializeHealthChecks,
-} from './health-checks';
-export {
-  getObservabilityManager,
-  initializeObservability,
-  type ObservabilityConfig,
-  ObservabilityIntegration,
-  ObservabilityManager,
-  ObservabilityPresets,
-  ObservabilityUtils,
-} from './integration';
-export {
-  Counter,
-  createMetricsHandler,
-  createMetricsMiddleware,
-  Gauge,
-  getMetricsRegistry,
-  Histogram,
-  type HistogramBucket,
-  initializeMetrics,
-  type MetricConfig,
-  type MetricLabels,
-  MetricsRegistry,
-  Summary,
-  type SummaryQuantile,
-} from './metrics';
-export {
-  createTracingMiddleware,
-  DistributedTracer,
-  getTracer,
-  initializeTracer,
-  type Span,
-  type SpanContext,
-  type TraceConfig,
-  type TraceData,
-  TraceHelpers,
-} from './tracing';
-export default observabilityDefault;

package/dist/observability/integration.d.ts

@@ -1,112 +0,0 @@
-import {  } from './correlation';
-import {  } from './health-checks';
-import {  } from './metrics';
-import {  } from './tracing';
-import type { CorrelationConfig } from './correlation';
-import type { EnhancedRequest } from '../types';
-import type { HealthCheckConfig } from './health-checks';
-import type { MetricConfig } from './metrics';
-import type { TraceConfig } from './tracing';
-/**
- * Initialize global observability
- */
-export declare function initializeObservability(config?: ObservabilityConfig): ObservabilityManager;
-/**
- * Get global observability manager
- */
-export declare function getObservabilityManager(): ObservabilityManager | null;
-/**
- * Observability presets for common configurations
- */
-export declare const ObservabilityPresets: {
-  /**
-   * Development preset - console logging, basic metrics
-   */
-  development: () => any;
-  /**
-   * Production preset - optimized for performance
-   */
-  production: () => any;
-  /**
-   * Kubernetes preset - optimized for k8s deployment
-   */
-  kubernetes: () => any;
-  /**
-   * Microservices preset - enhanced correlation and tracing
-   */
-  microservices: () => any;
-  /**
-   * Minimal preset - basic observability
-   */
-  minimal: () => any
-};
-/**
- * Router integration helpers
- */
-export declare const ObservabilityIntegration: {
-  /**
-   * Add observability to router
-   */
-  enhance: (router: any, config?: ObservabilityConfig) => unknown;
-  /**
-   * Create observability-enabled route builder
-   */
-  createRouteBuilder: (config?: ObservabilityConfig) => unknown
-};
-/**
- * Utility functions for observability
- */
-export declare const ObservabilityUtils: {
-  /**
-   * Create observability configuration from environment
-   */
-  fromEnvironment: () => any;
-  /**
-   * Validate observability configuration
-   */
-  validateConfig: (config: ObservabilityConfig) => any;
-  /**
-   * Get observability summary
-   */
-  getSummary: () => any
-};
-export declare interface ObservabilityConfig {
-  tracing?: TraceConfig
-  metrics?: MetricConfig
-  healthChecks?: HealthCheckConfig
-  correlation?: CorrelationConfig
-  enableTracing?: boolean
-  enableMetrics?: boolean
-  enableHealthChecks?: boolean
-  enableCorrelation?: boolean
-  endpoints?: {
-    metrics?: string
-    health?: string
-    ready?: string
-    live?: string
-    startup?: string
-    trace?: string
-    correlationStats?: string
-  }
-}
-/**
- * Observability manager - coordinates all observability features
- */
-export declare class ObservabilityManager {
-  private config: ObservabilityConfig;
-  private initialized: any;
-  constructor(config?: ObservabilityConfig);
-  initialize(): void;
-  createMiddleware(): (req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>;
-  createRouteHandlers(): Record<string, (req: EnhancedRequest) => Promise<Response>>;
-  getStatus(): {
-    initialized: boolean
-    components: {
-      tracing: boolean
-      metrics: boolean
-      healthChecks: boolean
-      correlation: boolean
-    }
-    endpoints: string[]
-  };
-}

package/dist/observability/metrics.d.ts

@@ -1,135 +0,0 @@
-/**
- * Initialize global metrics registry
- */
-export declare function initializeMetrics(config?: MetricConfig): MetricsRegistry;
-/**
- * Get global metrics registry
- */
-export declare function getMetricsRegistry(): MetricsRegistry | null;
-/**
- * Metrics middleware factory
- */
-export declare function createMetricsMiddleware(_config?: Partial<MetricConfig>): void;
-/**
- * Metrics endpoint handler
- */
-export declare function createMetricsHandler(): void;
-export declare interface MetricConfig {
-  prefix?: string
-  labels?: Record<string, string>
-  enableDefaultMetrics?: boolean
-  collectInterval?: number
-  maxHistogramBuckets?: number
-  maxSummaryAge?: number
-}
-export declare interface MetricLabels {
-
-}
-export declare interface HistogramBucket {
-  le: number
-  count: number
-}
-export declare interface SummaryQuantile {
-  quantile: number
-  value: number
-}
-/**
- * Base metric interface
- */
-export declare abstract class Metric {
-  readonly name: string;
-  readonly help: string;
-  readonly type: string;
-  readonly labels: MetricLabels;
-  constructor(name: string, help: string, type: string, labels?: MetricLabels);
-  abstract getValue(): number | string;
-  abstract reset(): void;
-  abstract toPrometheusString(): string;
-}
-/**
- * Counter metric - monotonically increasing value
- */
-export declare class Counter extends Metric {
-  private value: any;
-  private labeledCounters: any;
-  constructor(name: string, help: string, labels?: MetricLabels);
-  inc(value?: any, labels?: MetricLabels): void;
-  getValue(): number;
-  reset(): void;
-  private getLabelKey(labels: MetricLabels): string;
-  toPrometheusString(): string;
-}
-/**
- * Gauge metric - can go up and down
- */
-export declare class Gauge extends Metric {
-  private value: any;
-  private labeledGauges: any;
-  constructor(name: string, help: string, labels?: MetricLabels);
-  set(value: number, labels?: MetricLabels): void;
-  inc(value?: any, labels?: MetricLabels): void;
-  dec(value?: any, labels?: MetricLabels): void;
-  getValue(): number;
-  reset(): void;
-  private getLabelKey(labels: MetricLabels): string;
-  toPrometheusString(): string;
-}
-/**
- * Histogram metric - tracks distribution of values
- */
-export declare class Histogram extends Metric {
-  private buckets: Map<number, number>;
-  private sum: any;
-  private count: any;
-  readonly private bucketBounds: number[];
-  constructor(name: string, help: string, buckets?: number[], labels?: MetricLabels);
-  observe(value: number, _labels?: MetricLabels): void;
-  getValue(): number;
-  getCount(): number;
-  getSum(): number;
-  getBuckets(): HistogramBucket[];
-  reset(): void;
-  toPrometheusString(): string;
-}
-/**
- * Summary metric - tracks quantiles over sliding time window
- */
-export declare class Summary extends Metric {
-  private observations: Array<{ value: number, timestamp: number }>;
-  private sum: any;
-  private count: any;
-  readonly private quantiles: number[];
-  readonly private maxAge: number;
-  constructor(name: string, help: string, quantiles?: number[], maxAge?: any, labels?: MetricLabels);
-  observe(value: number, _labels?: MetricLabels): void;
-  getValue(): number;
-  getCount(): number;
-  getSum(): number;
-  getQuantiles(): SummaryQuantile[];
-  private cleanOldObservations(now: number): void;
-  reset(): void;
-  toPrometheusString(): string;
-}
-/**
- * Metrics registry
- */
-export declare class MetricsRegistry {
-  private metrics: any;
-  private config: MetricConfig;
-  private defaultMetrics: Map<string, Metric>;
-  constructor(config?: MetricConfig);
-  register(metric: Metric): void;
-  get(name: string): Metric | undefined;
-  createCounter(name: string, help: string, labels?: MetricLabels): Counter;
-  createGauge(name: string, help: string, labels?: MetricLabels): Gauge;
-  createHistogram(name: string, help: string, buckets?: number[], labels?: MetricLabels): Histogram;
-  createSummary(name: string, help: string, quantiles?: number[], maxAge?: number, labels?: MetricLabels): Summary;
-  private registerDefaultMetrics(): void;
-  private collectSystemMetrics(): void;
-  toPrometheusString(): string;
-  toJSON(): Record<string, any>;
-  reset(): void;
-  getMetricNames(): string[];
-  unregister(name: string): boolean;
-  clear(): void;
-}

package/dist/observability/tracing.d.ts

@@ -1,112 +0,0 @@
-/**
- * Initialize global tracer
- */
-export declare function initializeTracer(config: TraceConfig): DistributedTracer;
-/**
- * Get global tracer
- */
-export declare function getTracer(): DistributedTracer | null;
-/**
- * Tracing middleware factory
- */
-export declare function createTracingMiddleware(_config?: Partial<TraceConfig>): void;
-/**
- * Trace helper functions
- */
-export declare const TraceHelpers: {
-  /**
-   * Start a span within a request context
-   */
-  startSpan: (req: EnhancedRequest, operationName: string) => any;
-  /**
-   * Finish a span
-   */
-  finishSpan: (req: EnhancedRequest, span: Span) => any;
-  /**
-   * Add tags to current span
-   */
-  addTags: (req: EnhancedRequest, tags: Record<string, any>) => any;
-  /**
-   * Log to current span
-   */
-  log: (req: EnhancedRequest, fields: Record<string, any>) => any
-};
-export declare interface TraceConfig {
-  serviceName: string
-  serviceVersion?: string
-  environment?: string
-  endpoint?: string
-  headers?: Record<string, string>
-  sampleRate?: number
-  enableConsoleExporter?: boolean
-  enableJaegerExporter?: boolean
-  enableOTLPExporter?: boolean
-  jaegerEndpoint?: string
-  otlpEndpoint?: string
-  attributes?: Record<string, any>
-}
-export declare interface SpanContext {
-  traceId: string
-  spanId: string
-  parentSpanId?: string
-  flags: number
-  baggage?: Record<string, string>
-}
-export declare interface Span {
-  traceId: string
-  spanId: string
-  parentSpanId?: string
-  operationName: string
-  startTime: number
-  endTime?: number
-  duration?: number
-  tags: Record<string, any>
-  logs: Array<{
-    timestamp: number
-    fields: Record<string, any>
-  }>
-  status: 'ok' | 'error' | 'timeout'
-  statusMessage?: string
-}
-export declare interface TraceData {
-  traceId: string
-  spans: Span[]
-  startTime: number
-  endTime?: number
-  duration?: number
-  serviceName: string
-  environment: string
-}
-/**
- * Distributed tracing implementation
- */
-export declare class DistributedTracer {
-  private config: TraceConfig;
-  private activeSpans: Map<string, Span>;
-  private traces: Map<string, TraceData>;
-  private spanCounter: any;
-  constructor(config: TraceConfig);
-  generateTraceId(): string;
-  generateSpanId(): string;
-  startTrace(operationName: string, parentContext?: SpanContext): Span;
-  startChildSpan(operationName: string, parentSpan: Span): Span;
-  finishSpan(span: Span): void;
-  setSpanTags(span: Span, tags: Record<string, any>): void;
-  logToSpan(span: Span, fields: Record<string, any>): void;
-  setSpanStatus(span: Span, status: 'ok' | 'error' | 'timeout', message?: string): void;
-  extractTraceContext(headers: Headers): SpanContext | null;
-  injectTraceContext(span: Span, headers: Record<string, string>): void;
-  private parseTraceParent(traceParent: string): SpanContext | null;
-  private parseJaegerTrace(jaegerTrace: string): SpanContext | null;
-  private parseB3Trace(headers: Headers): SpanContext | null;
-  private shouldSample(): boolean;
-  private exportSpan(span: Span): void;
-  private exportToConsole(span: Span): void;
-  private exportToJaeger(span: Span): Promise<void>;
-  private exportToOTLP(span: Span): Promise<void>;
-  private hexToBytes(hex: string): Uint8Array;
-  getActiveSpans(): Span[];
-  getTrace(traceId: string): TraceData | undefined;
-  getAllTraces(): TraceData[];
-  cleanup(maxAge?: any): void;
-}

package/dist/optimization/bun-utilities.d.ts

@@ -1,106 +0,0 @@
-/**
- * Initialize global Bun optimizer
- */
-export declare function initializeBunOptimizer(config?: BunOptimizationConfig): BunOptimizer;
-/**
- * Get global Bun optimizer
- */
-export declare function getBunOptimizer(): BunOptimizer | null;
-/**
- * Bun optimization utilities
- */
-export declare const BunUtils: {
-  /**
-   * Check if running in Bun runtime
-   */
-  isBun: () => any;
-  /**
-   * Get Bun version
-   */
-  getBunVersion: () => any;
-  /**
-   * Optimize async function with Bun-specific features
-   */
-  optimizeAsync: (...args: any[]) => any
-};
-/**
- * Bun optimization factory functions
- */
-export declare const BunOptimizationFactory: {
-  /**
-   * Create development optimizer
-   */
-  createDevelopment: () => any;
-  /**
-   * Create production optimizer
-   */
-  createProduction: () => any;
-  /**
-   * Create testing optimizer
-   */
-  createTesting: () => any
-};
-export declare interface BunOptimizationConfig {
-  enableJIT?: boolean
-  enableGC?: boolean
-  memoryLimit?: number
-  cpuLimit?: number
-  enableProfiling?: boolean
-  enableTracing?: boolean
-}
-export declare interface PerformanceMetrics {
-  memoryUsage: {
-    rss: number
-    heapUsed: number
-    heapTotal: number
-    external: number
-    arrayBuffers: number
-  }
-  cpuUsage: {
-    user: number
-    system: number
-  }
-  eventLoop: {
-    delay: number
-    utilization: number
-  }
-  gc: {
-    collections: number
-    duration: number
-    freed: number
-  }
-  bunSpecific: {
-    jitCompilations: number
-    nativeCallsOptimized: number
-    fileSystemCacheHits: number
-  }
-}
-/**
- * Bun runtime optimizer
- */
-export declare class BunOptimizer {
-  private config: Required<BunOptimizationConfig>;
-  private metrics: PerformanceMetrics;
-  private gcObserver?: PerformanceObserver;
-  private performanceObserver?: PerformanceObserver;
-  constructor(config?: BunOptimizationConfig);
-  private initializeMetrics(): PerformanceMetrics;
-  private setupOptimizations(): void;
-  private enableJITOptimizations(): void;
-  private warmupCodePaths(): void;
-  private enableNativeOptimizations(): void;
-  private configureGarbageCollection(): void;
-  private setMemoryLimits(): void;
-  private setupMonitoring(): void;
-  getMetrics(): PerformanceMetrics;
-  optimizeFunction<T extends (...args: any[]) => any>(fn: T, options?: {
-    memoize?: boolean
-    warmup?: boolean
-    profile?: boolean
-  }): T;
-  createBufferOptimizer(): void;
-  createJSONOptimizer(): void;
-  createWorkerPool(workerScript: string, poolSize?: number): void;
-  generateReport(): string;
-  cleanup(): void;
-}

package/dist/query-builder-integration.d.ts

@@ -1,24 +0,0 @@
-import type { Model, QueryBuilderModelResolver } from './model-binding';
-/**
- * Create a query builder integration instance
- */
-export declare function createQueryBuilderIntegration(queryBuilder: any): QueryBuilderIntegration;
-/**
- * Helper to create a basic model resolver using the query builder
- */
-export declare function createBasicResolver<TModel extends Model>(tableName: string, options?: {
-    keyName?: string
-    transform?: (row: any) => TModel
-  }): QueryBuilderModelResolver<TModel>;
-/**
- * Integration layer for bun-query-builder with model binding
- */
-export declare class QueryBuilderIntegration {
-  private queryBuilder: any;
-  private resolvers: any;
-  constructor(queryBuilder: any);
-  registerResolver<TModel extends Model>(name: string, resolver: QueryBuilderModelResolver<TModel>): void;
-  getResolver<TModel extends Model>(name: string): QueryBuilderModelResolver<TModel> | undefined;
-  resolveModel<TModel extends Model>(name: string, id: string | number, keyName?: string, context?: Record<string, Model>): Promise<TModel | null>;
-  resolveModelOrFail<TModel extends Model>(name: string, id: string | number, keyName?: string, context?: Record<string, Model>): Promise<TModel>;
-}