@gravito/echo 3.0.1 → 3.1.1

package/dist/core/src/engine/FastContext.d.ts

@@ -6,6 +6,7 @@
  *
  * @module @gravito/core/engine
  */
+import { RequestScopeManager } from '../Container/RequestScopeManager';
 import type { FastRequest, FastContext as IFastContext } from './types';
 /**
  * Lazy-parsed request wrapper
@@ -17,17 +18,23 @@ declare class FastRequestImpl implements FastRequest {
     private _request;
     private _params;
     private _path;
+    private _routePattern?;
     private _url;
     private _query;
     private _headers;
     private _cachedJson;
     private _jsonParsed;
+    private _cachedText;
+    private _textParsed;
+    private _cachedFormData;
+    private _formDataParsed;
+    private _cachedQueries;
     private _ctx;
     constructor(ctx: FastContext);
     /**
      * Initialize for new request
      */
-    init(request: Request, params?: Record<string, string>, path?: string): this;
+    init(request: Request, params?: Record<string, string>, path?: string, routePattern?: string): this;
     /**
      * Reset for pooling
      */
@@ -36,6 +43,7 @@ declare class FastRequestImpl implements FastRequest {
     get url(): string;
     get method(): string;
     get path(): string;
+    get routePattern(): string | undefined;
     param(name: string): string | undefined;
     params(): Record<string, string>;
     private getUrl;
@@ -58,12 +66,13 @@ export declare class FastContext implements IFastContext {
     readonly req: FastRequestImpl;
     private _headers;
     _isReleased: boolean;
+    private _requestScope;
     /**
      * Initialize context for a new request
      *
      * This is called when acquiring from the pool.
      */
-    init(request: Request, params?: Record<string, string>, path?: string): this;
+    init(request: Request, params?: Record<string, string>, path?: string, routePattern?: string): this;
     /**
      * Reset context for pooling (Cleanup)
      *
@@ -92,6 +101,22 @@ export declare class FastContext implements IFastContext {
     private _store;
     get<T>(key: string): T;
     set(key: string, value: any): void;
+    /**
+     * Get the request-scoped service manager for this request.
+     *
+     * @returns The RequestScopeManager for this request.
+     * @throws Error if called before init() or after reset().
+     */
+    requestScope(): RequestScopeManager;
+    /**
+     * Resolve a request-scoped service (convenience method).
+     *
+     * @template T - The service type.
+     * @param key - The service key for caching.
+     * @param factory - Factory function to create the service.
+     * @returns The cached or newly created service instance.
+     */
+    scoped<T>(key: string | symbol, factory: () => T): T;
     route: (name: string, params?: any, query?: any) => string;
     get native(): this;
 }

package/dist/core/src/engine/Gravito.d.ts

@@ -25,7 +25,6 @@ export declare class Gravito {
     staticRoutes: Map<string, RouteMetadata>;
     private isPureStaticApp;
     private compiledDynamicRoutes;
-    private middlewareVersion;
     /**
      * Create a new Gravito instance
      *
@@ -97,7 +96,7 @@ export declare class Gravito {
     /**
      * Handle an incoming request
      */
-    fetch: (request: Request) => Response | Promise<Response>;
+    fetch: (request: Request) => Promise<Response>;
     /**
      * Handle routes with middleware (async path)
      */

package/dist/core/src/engine/MinimalContext.d.ts

@@ -11,6 +11,7 @@
  *
  * @module @gravito/core/engine
  */
+import { RequestScopeManager } from '../Container/RequestScopeManager';
 import type { FastRequest, FastContext as IFastContext } from './types';
 /**
  * Minimal request wrapper
@@ -19,11 +20,17 @@ declare class MinimalRequest implements FastRequest {
     private readonly _request;
     private readonly _params;
     private readonly _path;
+    private readonly _routePattern?;
     private _searchParams;
-    constructor(_request: Request, _params: Record<string, string>, _path: string);
+    private _cachedQueries;
+    private _cachedJsonPromise;
+    private _cachedTextPromise;
+    private _cachedFormDataPromise;
+    constructor(_request: Request, _params: Record<string, string>, _path: string, _routePattern?: string | undefined);
     get url(): string;
     get method(): string;
     get path(): string;
+    get routePattern(): string | undefined;
     param(name: string): string | undefined;
     params(): Record<string, string>;
     /**
@@ -51,7 +58,8 @@ declare class MinimalRequest implements FastRequest {
 export declare class MinimalContext implements IFastContext {
     readonly req: MinimalRequest;
     private _resHeaders;
-    constructor(request: Request, params: Record<string, string>, path: string);
+    private _requestScope;
+    constructor(request: Request, params: Record<string, string>, path: string, routePattern?: string);
     private getHeaders;
     json<T>(data: T, status?: number): Response;
     text(text: string, status?: number): Response;
@@ -69,6 +77,21 @@ export declare class MinimalContext implements IFastContext {
     forward(target: string, _options?: any): Promise<Response>;
     get<T>(_key: string): T;
     set(_key: string, _value: any): void;
+    /**
+     * Get the request-scoped service manager for this request.
+     *
+     * @returns The RequestScopeManager for this request.
+     */
+    requestScope(): RequestScopeManager;
+    /**
+     * Resolve a request-scoped service (convenience method).
+     *
+     * @template T - The service type.
+     * @param key - The service key for caching.
+     * @param factory - Factory function to create the service.
+     * @returns The cached or newly created service instance.
+     */
+    scoped<T>(key: string | symbol, factory: () => T): T;
     route: (name: string, params?: any, query?: any) => string;
     get native(): this;
     init(_request: Request, _params?: Record<string, string>, _path?: string): this;

package/dist/core/src/engine/types.d.ts

@@ -32,11 +32,14 @@ export interface FastContext {
     /** 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): this;
+    init(request: Request, params?: Record<string, string>, path?: string, routePattern?: string): this;
     /** Internal cleanup for pooling */
     reset(): void;
 }
@@ -50,6 +53,11 @@ export interface FastRequest {
     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 */

package/dist/core/src/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/core/src/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;
+}