@gravito/core 1.6.1 → 2.0.1

package/dist/engine/types.d.ts

@@ -0,0 +1,149 @@
+/**
+ * @fileoverview Gravito Core Engine Types
+ *
+ * Minimal, high-performance types for the standalone engine.
+ * These are intentionally simpler than the full framework types.
+ *
+ * @module @gravito/core/engine
+ */
+import type { HttpMethod } from '../http/types';
+/**
+ * FastContext - The pooled request context
+ */
+export interface FastContext {
+    /** Request accessor */
+    readonly req: FastRequest;
+    /** Response helpers */
+    json<T>(data: T, status?: number): Response;
+    text(text: string, status?: number): Response;
+    html(html: string, status?: number): Response;
+    redirect(url: string, status?: 301 | 302 | 303 | 307 | 308): Response;
+    body(data: BodyInit | null, status?: number): Response;
+    stream(stream: ReadableStream, status?: number): Response;
+    notFound(message?: string): Response;
+    forbidden(message?: string): Response;
+    unauthorized(message?: string): Response;
+    badRequest(message?: string): Response;
+    forward(target: string, options?: any): Promise<Response>;
+    escape(html: string): string;
+    /** Header management */
+    header(name: string): string | undefined;
+    header(name: string, value: string): void;
+    status(code: number): void;
+    /** Context Variables */
+    get<T>(key: string): T;
+    set(key: string, value: any): void;
+    /** Request Scope Management */
+    requestScope(): any;
+    scoped<T>(key: string | symbol, factory: () => T): T;
+    /** Lifecycle helpers */
+    route: (name: string, params?: any, query?: any) => string;
+    readonly native: any;
+    /** Internal initialization for pooling */
+    init(request: Request, params?: Record<string, string>, path?: string, routePattern?: string): this;
+    /** Internal cleanup for pooling */
+    reset(): void;
+}
+/**
+ * FastRequest - Minimal request interface
+ */
+export interface FastRequest {
+    /** Full URL */
+    readonly url: string;
+    /** HTTP method */
+    readonly method: string;
+    /** Path without query */
+    readonly path: string;
+    /**
+     * Route pattern (e.g., /users/:id) for metrics labeling
+     * Prevents high cardinality issues in monitoring systems
+     */
+    readonly routePattern?: string;
+    /** Get route parameter */
+    param(name: string): string | undefined;
+    /** Get all route parameters */
+    params(): Record<string, string>;
+    /** Get query parameter */
+    query(name: string): string | undefined;
+    /** Get all query parameters */
+    queries(): Record<string, string | string[]>;
+    /** Get header */
+    header(name: string): string | undefined;
+    /** Get all headers */
+    headers(): Record<string, string>;
+    /** Get all cookies (Native Bun 1.39+ / Lazy Parsed) */
+    readonly cookies: Record<string, string>;
+    /** Parse JSON body */
+    json<T = unknown>(): Promise<T>;
+    /** Parse text body */
+    text(): Promise<string>;
+    /** Parse form data */
+    formData(): Promise<FormData>;
+    /** Raw Request object */
+    readonly raw: Request;
+}
+/**
+ * Route handler function
+ */
+export type Handler = (ctx: FastContext) => Response | Promise<Response>;
+/**
+ * Middleware function
+ */
+export type Middleware = (ctx: FastContext, next: () => Promise<Response | undefined>) => Response | undefined | Promise<Response | undefined>;
+/**
+ * Error handler function
+ */
+export type ErrorHandler = (error: Error, ctx: FastContext) => Response | Promise<Response>;
+/**
+ * Not found handler function
+ */
+export type NotFoundHandler = (ctx: FastContext) => Response | Promise<Response>;
+/**
+ * Route metadata for middleware management
+ */
+export interface RouteMetadata {
+    handler: Handler;
+    middleware: Middleware[];
+    compiled?: CompiledHandler;
+    useMinimal?: boolean;
+    compiledVersion?: number;
+}
+/**
+ * Compiled handler function
+ */
+export type CompiledHandler = (ctx: FastContext) => Promise<Response>;
+/**
+ * Route match result from router
+ */
+export interface RouteMatch {
+    /** Matched handler */
+    handler: Handler | null;
+    /** Extracted route parameters */
+    params: Record<string, string>;
+    /** Middleware to execute */
+    middleware: Middleware[];
+    /** Optional stable route pattern for caching */
+    routePattern?: string;
+}
+/**
+ * Internal route node
+ */
+export interface RouteNode {
+    method: HttpMethod;
+    path: string;
+    handler: Handler;
+    middleware: Middleware[];
+}
+/**
+ * Engine configuration options
+ */
+export interface EngineOptions {
+    /** Context pool size (default: 256) */
+    poolSize?: number;
+    /** Enable route compilation optimization (default: true) */
+    enableAOT?: boolean;
+    /** Custom error handler */
+    onError?: ErrorHandler;
+    /** Custom 404 handler */
+    onNotFound?: NotFoundHandler;
+}

package/dist/error-handling/RequestScopeErrorContext.d.ts

@@ -0,0 +1,126 @@
+/**
+ * RequestScope-Aware Error Handling
+ *
+ * Integrates RequestScope lifecycle with error handling to provide:
+ * - Error context with request-scoped resources
+ * - Automatic cleanup of scoped services on error
+ * - Request tracing and diagnostics
+ * - Resource leak detection
+ */
+import type { RequestScopeManager } from '../Container/RequestScopeManager';
+import type { RequestScopeMetrics } from '../Container/RequestScopeMetrics';
+import type { GravitoContext } from '../http/types';
+/**
+ * Extended error context with RequestScope information
+ *
+ * Provides error handlers access to request-scoped resources
+ * for proper resource cleanup and error diagnostics.
+ */
+export interface RequestScopeErrorContext {
+    /**
+     * The original error that was thrown
+     */
+    error: unknown;
+    /**
+     * HTTP context where error occurred
+     */
+    context: GravitoContext;
+    /**
+     * RequestScope manager for this request
+     * Allows error handlers to access or clean up scoped resources
+     */
+    scope?: RequestScopeManager;
+    /**
+     * Metrics about the request scope state
+     * Useful for diagnostics and understanding resource usage
+     */
+    scopeMetrics?: RequestScopeMetrics;
+    /**
+     * Number of scoped services at time of error
+     * High numbers might indicate resource leaks
+     */
+    scopeSize?: number;
+    /**
+     * Request processing time in milliseconds
+     * Useful for timeout errors
+     */
+    duration?: number;
+    /**
+     * Additional diagnostic information
+     */
+    diagnostics?: {
+        servicesCleanedUp?: string[];
+        cleanupErrors?: Array<{
+            service: string;
+            error: unknown;
+        }>;
+        peakMemoryMb?: number;
+    };
+}
+/**
+ * Error that occurred during RequestScope cleanup
+ *
+ * Wraps original error with cleanup context for proper error reporting
+ */
+export declare class RequestScopeCleanupError extends Error {
+    originalError: unknown;
+    cleanupErrors: Array<{
+        service: string;
+        error: unknown;
+    }>;
+    constructor(message: string, originalError: unknown, cleanupErrors: Array<{
+        service: string;
+        error: unknown;
+    }>);
+}
+/**
+ * Helper to extract RequestScope context from GravitoContext
+ *
+ * @param ctx - Gravito context
+ * @returns RequestScope error context with available information
+ */
+export declare function extractRequestScopeErrorContext(ctx: GravitoContext, error: unknown): RequestScopeErrorContext;
+/**
+ * Cleanup scoped services safely during error handling
+ *
+ * Ensures all scoped services are cleaned up even if some fail,
+ * and collects cleanup errors for diagnostics.
+ *
+ * @param scope - RequestScope manager
+ * @returns Array of cleanup errors if any occurred
+ */
+export declare function cleanupRequestScopeOnError(scope?: RequestScopeManager): Promise<Array<{
+    service: string;
+    error: unknown;
+}>>;
+/**
+ * Safe error handler wrapper that manages RequestScope cleanup
+ *
+ * Ensures scoped services are properly cleaned up before returning error response.
+ * Use this to wrap error handlers to make them RequestScope-aware.
+ *
+ * @example
+ * ```typescript
+ * const errorHandler = withRequestScopeCleanup(async (ctx, error) => {
+ *   // Handle error...
+ *   return ctx.json({ error: error.message }, 500)
+ * })
+ *
+ * // In your app:
+ * try {
+ *   // Handle request...
+ * } catch (error) {
+ *   return errorHandler(ctx, error)
+ * }
+ * ```
+ */
+export declare function withRequestScopeCleanup<T extends (ctx: GravitoContext, error: unknown) => Promise<Response>>(handler: T): T;
+/**
+ * Detect potential resource leaks in RequestScope
+ *
+ * Returns diagnostic information about suspicious resource usage patterns
+ */
+export declare function detectRequestScopeLeaks(context: RequestScopeErrorContext): {
+    potentialLeaks: boolean;
+    warnings: string[];
+};

package/dist/events/BackpressureManager.d.ts

@@ -0,0 +1,215 @@
+/**
+ * @gravito/core - Event System Backpressure Management
+ *
+ * Implements a backpressure management system to prevent high-priority events
+ * from starving low-priority events when the queue is under resource constraints.
+ *
+ * 背壓管理器：在資源受限時進行智慧型流量控制，防止優先級飢餓。
+ *
+ * FS-103 增強：
+ * - 多優先級隊列深度監控
+ * - 背壓反饋迴路支持
+ * - 智能 DLQ 路由決策
+ */
+import type { DeadLetterDecision, MultiPriorityQueueDepth } from './types';
+/**
+ * 背壓狀態枚舉。
+ *
+ * 狀態轉換：Normal → Warning → Critical → Overflow
+ * 恢復方向：遲滯設計（需降至觸發閾值的 80%）
+ *
+ * @public
+ */
+export declare enum BackpressureState {
+    /** 正常運作，無背壓 */
+    NORMAL = "NORMAL",
+    /** 警告狀態，開始限制低優先級事件 */
+    WARNING = "WARNING",
+    /** 危急狀態，僅允許高優先級事件 */
+    CRITICAL = "CRITICAL",
+    /** 溢位狀態，全部拒絕 */
+    OVERFLOW = "OVERFLOW"
+}
+/**
+ * 背壓配置選項。
+ *
+ * @public
+ */
+export interface BackpressureConfig {
+    /** 是否啟用背壓管理器（預設 true） */
+    enabled?: boolean;
+    /** 總隊列深度限制（預設無限） */
+    maxQueueSize?: number;
+    /** 分優先級隊列深度限制 */
+    maxSizeByPriority?: {
+        critical?: number;
+        high?: number;
+        normal?: number;
+        low?: number;
+    };
+    /** 每秒最大入隊速率（events/sec，預設無限） */
+    maxEnqueueRate?: number;
+    /** 速率限制滑動視窗大小（ms，預設 1000） */
+    rateLimitWindowMs?: number;
+    /** 背壓狀態閾值（佔 maxQueueSize 的百分比） */
+    thresholds?: {
+        /** WARNING 觸發百分比（預設 0.6 = 60%） */
+        warning?: number;
+        /** CRITICAL 觸發百分比（預設 0.85 = 85%） */
+        critical?: number;
+        /** OVERFLOW 觸發百分比（預設 1.0 = 100%） */
+        overflow?: number;
+    };
+    /** 被拒絕事件的處理策略（預設 'drop-with-callback'） */
+    rejectionPolicy?: 'throw' | 'drop-silent' | 'drop-with-callback';
+    /** 當 rejectionPolicy 為 'drop-with-callback' 時的回呼 */
+    onRejected?: (eventName: string, priority: string, reason: string) => void;
+    /** 背壓狀態變更回呼 */
+    onStateChange?: (from: BackpressureState, to: BackpressureState) => void;
+    /** 低優先級事件在 WARNING 狀態下的延遲入隊時間（ms，預設 100） */
+    lowPriorityDelayMs?: number;
+    /** 是否啟用優先級反轉防護（預設 true） */
+    enableStarvationProtection?: boolean;
+    /** 低優先級事件最大等待時間，超過則提升優先級（ms，預設 5000） */
+    starvationTimeoutMs?: number;
+    /** 當進入 OVERFLOW 狀態時，是否將被拒絕事件路由到 DLQ（預設 false） */
+    dlqOnOverflow?: boolean;
+    /** OVERFLOW 時的重試策略（預設 'dlq-only'） */
+    overflowRetryStrategy?: 'immediate' | 'delayed' | 'dlq-only';
+    /** OVERFLOW 延遲重試的基礎延遲時間（ms，預設 5000） */
+    overflowRetryDelayMs?: number;
+}
+/**
+ * 背壓決策結果。
+ *
+ * @public
+ */
+export interface BackpressureDecision {
+    /** 是否允許入隊 */
+    allowed: boolean;
+    /** 拒絕原因（若不允許） */
+    reason?: string;
+    /** 是否需要延遲入隊 */
+    delayed?: boolean;
+    /** 延遲時間（ms） */
+    delayMs?: number;
+    /** 建議降級後的優先級（若降級） */
+    degradedPriority?: 'high' | 'normal' | 'low';
+    /** 是否是由於 OVERFLOW 狀態被拒絕 */
+    isOverflow?: boolean;
+    /** OVERFLOW 時的重試策略建議（'immediate'、'delayed'、'dlq-only'） */
+    retryStrategy?: 'immediate' | 'delayed' | 'dlq-only';
+}
+/**
+ * 背壓指標快照。
+ *
+ * @public
+ */
+export interface BackpressureMetricsSnapshot {
+    state: BackpressureState;
+    totalDepth: number;
+    depthByPriority: {
+        critical: number;
+        high: number;
+        normal: number;
+        low: number;
+    };
+    enqueueRate: number;
+    rejectedCount: number;
+    degradedCount: number;
+    stateTransitions: number;
+    dlqRouteCount?: number;
+    windowAdjustmentCount?: number;
+}
+/**
+ * 背壓管理器。
+ *
+ * 根據隊列深度、速率、優先級等因素，決定是否允許新事件入隊，
+ * 以及是否需要降級優先級或延遲入隊。
+ *
+ * @public
+ */
+export declare class BackpressureManager {
+    private enabled;
+    private config;
+    private onRejected?;
+    private onStateChange?;
+    private state;
+    private rejectedCount;
+    private degradedCount;
+    private stateTransitions;
+    private rateCounter;
+    private depthByPriority;
+    private windowAdjustmentHistory;
+    private dlqRouteCount;
+    constructor(config?: BackpressureConfig);
+    /**
+     * 評估是否允許新事件入隊。
+     *
+     * @param eventName 事件名稱
+     * @param priority 事件優先級
+     * @param queueDepth 當前隊列深度
+     * @param depthByPriority 分優先級隊列深度
+     * @returns 背壓決策結果
+     */
+    evaluate(eventName: string, priority: 'critical' | 'high' | 'normal' | 'low', queueDepth: number, depthByPriority: {
+        critical: number;
+        high: number;
+        normal: number;
+        low: number;
+    }): BackpressureDecision;
+    /**
+     * 獲取當前背壓狀態。
+     */
+    getState(): BackpressureState;
+    /**
+     * 獲取背壓指標快照。
+     */
+    getMetrics(): BackpressureMetricsSnapshot;
+    /**
+     * 重置背壓管理器狀態。
+     */
+    reset(): void;
+    /**
+     * 同步隊列深度（由 EventPriorityQueue 調用）。
+     * FS-103：多優先級隊列深度監控
+     */
+    updateQueueDepth(depths: MultiPriorityQueueDepth): void;
+    /**
+     * 獲取各優先級的隊列深度。
+     * FS-103：提供實時隊列深度快照
+     */
+    getQueueDepthByPriority(): MultiPriorityQueueDepth;
+    /**
+     * 獲取總隊列深度。
+     */
+    getTotalQueueDepth(): number;
+    /**
+     * 接收來自 AggregationWindow 的窗口調整通知。
+     * FS-103：背壓反饋迴路
+     */
+    notifyWindowAdjustment(oldWindowMs: number, newWindowMs: number): void;
+    /**
+     * 檢查是否可以從 CRITICAL 或更高級別降級。
+     * FS-103：自動狀態恢復機制
+     */
+    private checkStateRecovery;
+    /**
+     * 決定是否應該將事件路由到死信隊列。
+     * FS-103：智能 DLQ 路由決策
+     */
+    makeDeadLetterDecision(_eventName: string, priority: 'critical' | 'high' | 'normal' | 'low'): DeadLetterDecision;
+    /**
+     * 更新背壓狀態。
+     * 使用遲滯設計（80% 回復比例）避免邊界震盪。
+     */
+    private updateState;
+    /**
+     * 執行狀態轉換。
+     */
+    private transitionTo;
+    /**
+     * 建立決策結果並記錄拒絕。
+     */
+    private createDecision;
+}