@gravito/core 1.6.0 → 1.6.1

package/dist/engine/index.js

@@ -226,7 +226,14 @@ var AOTRouter = class {
   dynamicRoutePatterns = /* @__PURE__ */ new Map();
   middlewareCache = /* @__PURE__ */ new Map();
   cacheMaxSize = 1e3;
-  version = 0;
+  _version = 0;
+  /**
+   * Get the current version for cache invalidation
+   * Incremented whenever middleware or routes are modified
+   */
+  get version() {
+    return this._version;
+  }
   /**
    * Register a route
    *
@@ -298,7 +305,7 @@ var AOTRouter = class {
    */
   use(...middleware) {
     this.globalMiddleware.push(...middleware);
-    this.version++;
+    this._version++;
   }
   /**
    * Add path-based middleware
@@ -315,7 +322,7 @@ var AOTRouter = class {
       const existing = this.pathMiddleware.get(pattern) ?? [];
       this.pathMiddleware.set(pattern, [...existing, ...middleware]);
     }
-    this.version++;
+    this._version++;
   }
   /**
    * Match a request to a route
@@ -377,9 +384,9 @@ var AOTRouter = class {
     if (this.globalMiddleware.length === 0 && this.pathMiddleware.size === 0 && routeMiddleware.length === 0) {
       return [];
     }
-    const cacheKey = `${path}:${routeMiddleware.length}`;
+    const cacheKey = path;
     const cached = this.middlewareCache.get(cacheKey);
-    if (cached !== void 0 && cached.version === this.version) {
+    if (cached !== void 0 && cached.version === this._version) {
       return cached.data;
     }
     const middleware = [];
@@ -400,7 +407,9 @@ var AOTRouter = class {
       middleware.push(...routeMiddleware);
     }
     if (this.middlewareCache.size < this.cacheMaxSize) {
-      this.middlewareCache.set(cacheKey, { data: middleware, version: this.version });
+      this.middlewareCache.set(cacheKey, { data: middleware, version: this._version });
+    } else if (this.middlewareCache.has(cacheKey)) {
+      this.middlewareCache.set(cacheKey, { data: middleware, version: this._version });
     }
     return middleware;
   }
@@ -488,6 +497,172 @@ var HEADERS = {
   HTML: { "Content-Type": "text/html; charset=utf-8" }
 };
 
+// src/Container/RequestScopeMetrics.ts
+var RequestScopeMetrics = class {
+  cleanupStartTime = null;
+  cleanupDuration = null;
+  scopeSize = 0;
+  servicesCleaned = 0;
+  errorsOccurred = 0;
+  /**
+   * Record start of cleanup operation
+   */
+  recordCleanupStart() {
+    this.cleanupStartTime = performance.now();
+  }
+  /**
+   * Record end of cleanup operation
+   *
+   * @param scopeSize - Number of services in the scope
+   * @param servicesCleaned - Number of services that had cleanup called
+   * @param errorsOccurred - Number of cleanup errors
+   */
+  recordCleanupEnd(scopeSize, servicesCleaned, errorsOccurred = 0) {
+    if (this.cleanupStartTime !== null) {
+      this.cleanupDuration = performance.now() - this.cleanupStartTime;
+      this.cleanupStartTime = null;
+    }
+    this.scopeSize = scopeSize;
+    this.servicesCleaned = servicesCleaned;
+    this.errorsOccurred = errorsOccurred;
+  }
+  /**
+   * Get cleanup duration in milliseconds
+   *
+   * @returns Duration in ms, or null if cleanup not completed
+   */
+  getCleanupDuration() {
+    return this.cleanupDuration;
+  }
+  /**
+   * Check if cleanup took longer than threshold (default 2ms)
+   * Useful for detecting slow cleanups
+   *
+   * @param thresholdMs - Threshold in milliseconds
+   * @returns True if cleanup exceeded threshold
+   */
+  isSlowCleanup(thresholdMs = 2) {
+    if (this.cleanupDuration === null) return false;
+    return this.cleanupDuration > thresholdMs;
+  }
+  /**
+   * Export metrics as JSON for logging/monitoring
+   */
+  toJSON() {
+    return {
+      cleanupDuration: this.cleanupDuration,
+      scopeSize: this.scopeSize,
+      servicesCleaned: this.servicesCleaned,
+      errorsOccurred: this.errorsOccurred,
+      hasErrors: this.errorsOccurred > 0,
+      isSlowCleanup: this.isSlowCleanup()
+    };
+  }
+  /**
+   * Export metrics as compact string for logging
+   */
+  toString() {
+    const duration = this.cleanupDuration ?? "pending";
+    return `cleanup: ${duration}ms, scope: ${this.scopeSize}, cleaned: ${this.servicesCleaned}, errors: ${this.errorsOccurred}`;
+  }
+};
+
+// src/Container/RequestScopeManager.ts
+var RequestScopeManager = class {
+  scoped = /* @__PURE__ */ new Map();
+  metadata = /* @__PURE__ */ new Map();
+  metrics = new RequestScopeMetrics();
+  observer = null;
+  constructor(observer) {
+    this.observer = observer || null;
+  }
+  /**
+   * Set observer for monitoring scope lifecycle
+   */
+  setObserver(observer) {
+    this.observer = observer;
+  }
+  /**
+   * Get metrics for this scope
+   */
+  getMetrics() {
+    return this.metrics;
+  }
+  /**
+   * Resolve or retrieve a request-scoped service instance.
+   *
+   * If the service already exists in this scope, returns the cached instance.
+   * Otherwise, calls the factory function to create a new instance and caches it.
+   *
+   * Automatically detects and records services with cleanup methods.
+   *
+   * @template T - The type of the service.
+   * @param key - The service key (for caching).
+   * @param factory - Factory function to create the instance if not cached.
+   * @returns The cached or newly created instance.
+   */
+  resolve(key, factory) {
+    const keyStr = String(key);
+    const isFromCache = this.scoped.has(keyStr);
+    if (!isFromCache) {
+      const instance = factory();
+      this.scoped.set(keyStr, instance);
+      if (instance && typeof instance === "object" && "cleanup" in instance) {
+        this.metadata.set(keyStr, { hasCleanup: true });
+      }
+    }
+    this.observer?.onServiceResolved?.(key, isFromCache);
+    return this.scoped.get(keyStr);
+  }
+  /**
+   * Clean up all request-scoped instances.
+   *
+   * Calls the cleanup() method on each service that has one.
+   * Silently ignores cleanup errors to prevent cascading failures.
+   * Called automatically by the Gravito engine in the request finally block.
+   *
+   * @returns Promise that resolves when all cleanup is complete.
+   */
+  async cleanup() {
+    this.metrics.recordCleanupStart();
+    this.observer?.onCleanupStart?.();
+    const errors = [];
+    let servicesCleaned = 0;
+    for (const [, instance] of this.scoped) {
+      if (instance && typeof instance === "object" && "cleanup" in instance) {
+        const fn = instance.cleanup;
+        if (typeof fn === "function") {
+          try {
+            await fn.call(instance);
+            servicesCleaned++;
+          } catch (error) {
+            errors.push(error);
+            this.observer?.onCleanupError?.(
+              error instanceof Error ? error : new Error(String(error))
+            );
+          }
+        }
+      }
+    }
+    const scopeSize = this.scoped.size;
+    this.scoped.clear();
+    this.metadata.clear();
+    this.metrics.recordCleanupEnd(scopeSize, servicesCleaned, errors.length);
+    this.observer?.onCleanupEnd?.(this.metrics);
+    if (errors.length > 0) {
+      console.error("RequestScope cleanup errors:", errors);
+    }
+  }
+  /**
+   * Get the number of services in this scope (for monitoring).
+   *
+   * @returns The count of cached services.
+   */
+  size() {
+    return this.scoped.size;
+  }
+};
+
 // src/engine/FastContext.ts
 var FastRequestImpl = class {
   _request;
@@ -499,6 +674,11 @@ var FastRequestImpl = class {
   _headers = null;
   _cachedJson = void 0;
   _jsonParsed = false;
+  _cachedText = void 0;
+  _textParsed = false;
+  _cachedFormData = void 0;
+  _formDataParsed = false;
+  _cachedQueries = null;
   // Back-reference for release check optimization
   _ctx;
   constructor(ctx) {
@@ -517,6 +697,11 @@ var FastRequestImpl = class {
     this._headers = null;
     this._cachedJson = void 0;
     this._jsonParsed = false;
+    this._cachedText = void 0;
+    this._textParsed = false;
+    this._cachedFormData = void 0;
+    this._formDataParsed = false;
+    this._cachedQueries = null;
     return this;
   }
   /**
@@ -530,6 +715,11 @@ var FastRequestImpl = class {
     this._headers = null;
     this._cachedJson = void 0;
     this._jsonParsed = false;
+    this._cachedText = void 0;
+    this._textParsed = false;
+    this._cachedFormData = void 0;
+    this._formDataParsed = false;
+    this._cachedQueries = null;
   }
   checkReleased() {
     if (this._ctx._isReleased) {
@@ -577,6 +767,9 @@ var FastRequestImpl = class {
   }
   queries() {
     this.checkReleased();
+    if (this._cachedQueries !== null) {
+      return this._cachedQueries;
+    }
     if (!this._query) {
       this._query = this.getUrl().searchParams;
     }
@@ -591,6 +784,7 @@ var FastRequestImpl = class {
         result[key] = [existing, value];
       }
     }
+    this._cachedQueries = result;
     return result;
   }
   header(name) {
@@ -617,11 +811,19 @@ var FastRequestImpl = class {
   }
   async text() {
     this.checkReleased();
-    return this._request.text();
+    if (!this._textParsed) {
+      this._cachedText = await this._request.text();
+      this._textParsed = true;
+    }
+    return this._cachedText;
   }
   async formData() {
     this.checkReleased();
-    return this._request.formData();
+    if (!this._formDataParsed) {
+      this._cachedFormData = await this._request.formData();
+      this._formDataParsed = true;
+    }
+    return this._cachedFormData;
   }
   get raw() {
     this.checkReleased();
@@ -635,6 +837,8 @@ var FastContext = class {
   // Reuse this object
   _isReleased = false;
   // Made public for internal check access
+  _requestScope = null;
+  // Request-scoped services
   /**
    * Initialize context for a new request
    *
@@ -644,6 +848,7 @@ var FastContext = class {
     this._isReleased = false;
     this.req.init(request, params, path, routePattern);
     this._headers = new Headers();
+    this._requestScope = new RequestScopeManager();
     return this;
   }
   /**
@@ -769,6 +974,32 @@ var FastContext = class {
     this._store.set(key, value);
   }
   // ─────────────────────────────────────────────────────────────────────────
+  // Request Scope Management
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * 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() {
+    if (!this._requestScope) {
+      throw new Error("RequestScope not initialized. Call init() first.");
+    }
+    return this._requestScope;
+  }
+  /**
+   * 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(key, factory) {
+    return this.requestScope().resolve(key, factory);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
   // Lifecycle helpers
   // ─────────────────────────────────────────────────────────────────────────
   route = () => "";
@@ -786,6 +1017,10 @@ var MinimalRequest = class {
     this._routePattern = _routePattern;
   }
   _searchParams = null;
+  _cachedQueries = null;
+  _cachedJsonPromise = null;
+  _cachedTextPromise = null;
+  _cachedFormDataPromise = null;
   get url() {
     return this._request.url;
   }
@@ -825,6 +1060,9 @@ var MinimalRequest = class {
     return this.getSearchParams().get(name) ?? void 0;
   }
   queries() {
+    if (this._cachedQueries !== null) {
+      return this._cachedQueries;
+    }
     const params = this.getSearchParams();
     const result = {};
     for (const [key, value] of params.entries()) {
@@ -837,6 +1075,7 @@ var MinimalRequest = class {
         result[key] = [existing, value];
       }
     }
+    this._cachedQueries = result;
     return result;
   }
   header(name) {
@@ -850,13 +1089,22 @@ var MinimalRequest = class {
     return result;
   }
   async json() {
-    return this._request.json();
+    if (this._cachedJsonPromise === null) {
+      this._cachedJsonPromise = this._request.json();
+    }
+    return this._cachedJsonPromise;
   }
   async text() {
-    return this._request.text();
+    if (this._cachedTextPromise === null) {
+      this._cachedTextPromise = this._request.text();
+    }
+    return this._cachedTextPromise;
   }
   async formData() {
-    return this._request.formData();
+    if (this._cachedFormDataPromise === null) {
+      this._cachedFormDataPromise = this._request.formData();
+    }
+    return this._cachedFormDataPromise;
   }
   get raw() {
     return this._request;
@@ -865,18 +1113,19 @@ var MinimalRequest = class {
 var MinimalContext = class {
   req;
   _resHeaders = {};
+  _requestScope;
   constructor(request, params, path, routePattern) {
     this.req = new MinimalRequest(request, params, path, routePattern);
+    this._requestScope = new RequestScopeManager();
   }
   // get req(): FastRequest {
   //   return this._req
   // }
   // Response helpers - merge custom headers with defaults
+  // Optimized: use Object.assign instead of spread to avoid shallow copy overhead
   getHeaders(contentType) {
-    return {
-      ...this._resHeaders,
-      "Content-Type": contentType
-    };
+    const headers = Object.assign({ "Content-Type": contentType }, this._resHeaders);
+    return headers;
   }
   json(data, status = 200) {
     return new Response(JSON.stringify(data), {
@@ -950,6 +1199,25 @@ var MinimalContext = class {
   }
   set(_key, _value) {
   }
+  /**
+   * Get the request-scoped service manager for this request.
+   *
+   * @returns The RequestScopeManager for this request.
+   */
+  requestScope() {
+    return this._requestScope;
+  }
+  /**
+   * 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(key, factory) {
+    return this._requestScope.resolve(key, factory);
+  }
   route = () => "";
   get native() {
     return this;
@@ -1067,18 +1335,40 @@ function compileMiddlewareChain(middleware, handler) {
   if (middleware.length === 0) {
     return handler;
   }
+  if (middleware.length === 1) {
+    const mw = middleware[0];
+    return async (ctx) => {
+      let nextCalled = false;
+      const result = await mw(ctx, async () => {
+        nextCalled = true;
+        return void 0;
+      });
+      if (result instanceof Response) {
+        return result;
+      }
+      if (nextCalled) {
+        return await handler(ctx);
+      }
+      return ctx.json({ error: "Middleware did not call next or return response" }, 500);
+    };
+  }
   let compiled = handler;
   for (let i = middleware.length - 1; i >= 0; i--) {
     const mw = middleware[i];
     const nextHandler = compiled;
     compiled = async (ctx) => {
-      let nextResult;
-      const next = async () => {
-        nextResult = await nextHandler(ctx);
-        return nextResult;
-      };
-      const result = await mw(ctx, next);
-      return result ?? nextResult;
+      let nextCalled = false;
+      const result = await mw(ctx, async () => {
+        nextCalled = true;
+        return void 0;
+      });
+      if (result instanceof Response) {
+        return result;
+      }
+      if (nextCalled) {
+        return await nextHandler(ctx);
+      }
+      return ctx.json({ error: "Middleware did not call next or return response" }, 500);
     };
   }
   return compiled;
@@ -1095,8 +1385,6 @@ var Gravito = class {
   isPureStaticApp = true;
   // Cache for precompiled dynamic routes
   compiledDynamicRoutes = /* @__PURE__ */ new Map();
-  // Version tracking for cache invalidation
-  middlewareVersion = 0;
   /**
    * Create a new Gravito instance
    *
@@ -1184,7 +1472,6 @@ var Gravito = class {
     } else {
       this.router.use(pathOrMiddleware, ...middleware);
     }
-    this.middlewareVersion++;
     this.compileRoutes();
     return this;
   }
@@ -1277,6 +1564,11 @@ var Gravito = class {
     } catch (error) {
       return await this.handleError(error, ctx);
     } finally {
+      try {
+        await ctx.requestScope().cleanup();
+      } catch (cleanupError) {
+        console.error("RequestScope cleanup failed:", cleanupError);
+      }
       this.contextPool.release(ctx);
     }
   }
@@ -1290,12 +1582,12 @@ var Gravito = class {
     }
     const cacheKey = `${method}:${match.routePattern ?? path}`;
     let entry = this.compiledDynamicRoutes.get(cacheKey);
-    if (!entry || entry.version !== this.middlewareVersion) {
+    if (!entry || entry.version !== this.router.version) {
       const compiled = compileMiddlewareChain(match.middleware, match.handler);
       if (this.compiledDynamicRoutes.size > 1e3) {
         this.compiledDynamicRoutes.clear();
       }
-      entry = { compiled, version: this.middlewareVersion };
+      entry = { compiled, version: this.router.version };
       this.compiledDynamicRoutes.set(cacheKey, entry);
     }
     const ctx = this.contextPool.acquire();
@@ -1306,6 +1598,11 @@ var Gravito = class {
       } catch (error) {
         return await this.handleError(error, ctx);
       } finally {
+        try {
+          await ctx.requestScope().cleanup();
+        } catch (cleanupError) {
+          console.error("RequestScope cleanup failed:", cleanupError);
+        }
         this.contextPool.release(ctx);
       }
     };
@@ -1364,7 +1661,7 @@ var Gravito = class {
     const hasPathMiddleware = this.router.pathMiddleware.size > 0;
     this.isPureStaticApp = !hasGlobalMiddleware && !hasPathMiddleware;
     for (const [key, route] of this.staticRoutes) {
-      if (route.compiledVersion === this.middlewareVersion) {
+      if (route.compiledVersion === this.router.version) {
         continue;
       }
       const analysis = analyzeHandler(route.handler);
@@ -1374,7 +1671,7 @@ var Gravito = class {
         const allMiddleware = this.collectMiddlewareForPath(key.split(":")[1], route.middleware);
         route.compiled = compileMiddlewareChain(allMiddleware, route.handler);
       }
-      route.compiledVersion = this.middlewareVersion;
+      route.compiledVersion = this.router.version;
     }
   }
   /**