@getstrata/bootstrap 2.1.0 → 2.2.1

package/dist/entries/web/routing.js

@@ -56,8 +56,12 @@ import {
   CORE_CACHE_TOKEN,
   CORE_CONFIG_TOKEN,
   CORE_EVENT_BUS_TOKEN,
+  CORE_HTTP_CLEANUP_TOKEN,
   CORE_POLICY_GATE_TOKEN,
+  CORE_PUBLIC_TENANCY_TOKEN,
   CORE_QUEUE_TOKEN,
+  CORE_TENANT_RESOLVER_TOKEN,
+  CORE_THROTTLE_QUOTA_POLICY_TOKEN,
   CORE_TOKEN_SERVICE_TOKEN
 } from "@getstrata/core/contracts/serviceTokens";
 var APP_PORT_CONFIG_KEY = "app.port";
@@ -123,8 +127,39 @@ function resolveRegisterRateLimit() {
 // ../../src/bootstrap/httpKernel.ts
 class HttpKernel {
   dependencies;
+  ownedThrottles = new Set;
+  disposed = false;
   constructor(dependencies) {
     this.dependencies = dependencies;
+    if (dependencies.container.has(CORE_HTTP_CLEANUP_TOKEN)) {
+      dependencies.container.resolve(CORE_HTTP_CLEANUP_TOKEN)(() => this.dispose());
+    }
+  }
+  dispose() {
+    this.disposed = true;
+    const owned = [...this.ownedThrottles];
+    this.ownedThrottles.clear();
+    const errors = [];
+    for (const throttle of owned.reverse()) {
+      try {
+        throttle.dispose();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length)
+      throw new AggregateError(errors, "HTTP throttle cleanup failed.");
+  }
+  ownThrottle(throttle) {
+    if (this.disposed) {
+      if ("dispose" in throttle && typeof throttle.dispose === "function")
+        throttle.dispose();
+      throw new Error("HTTP kernel is disposed.");
+    }
+    if ("dispose" in throttle && typeof throttle.dispose === "function") {
+      this.ownedThrottles.add(throttle);
+    }
+    return throttle;
   }
   globalMiddleware(errorFormat = "json") {
     const auth = this.dependencies.container.resolve(CORE_AUTH_TOKEN);
@@ -139,7 +174,10 @@ class HttpKernel {
       errorFormat === "json" ? createJsonErrorMiddleware() : createWebErrorMiddleware(),
       createAuthMiddleware(auth),
       createMembershipMiddleware(),
-      createTenantMiddleware()
+      createTenantMiddleware({
+        publicTenancy: this.dependencies.container.has(CORE_PUBLIC_TENANCY_TOKEN) ? this.dependencies.container.resolve(CORE_PUBLIC_TENANCY_TOKEN) : undefined,
+        resolveTenant: this.dependencies.container.has(CORE_TENANT_RESOLVER_TOKEN) ? this.dependencies.container.resolve(CORE_TENANT_RESOLVER_TOKEN) : undefined
+      })
     ];
   }
   group(name) {
@@ -154,25 +192,28 @@ class HttpKernel {
         if (!this.dependencies.container.has(CORE_CONFIG_TOKEN)) {
           return [csrf];
         }
+        const quotaPolicy = this.dependencies.container.has(CORE_THROTTLE_QUOTA_POLICY_TOKEN) ? this.dependencies.container.resolve(CORE_THROTTLE_QUOTA_POLICY_TOKEN) : undefined;
         const config = this.dependencies.container.resolve(CORE_CONFIG_TOKEN);
         const redisUrl = config.get(REDIS_URL_CONFIG_KEY)?.trim() ?? "";
         if (!redisUrl) {
           const maxAttempts = Number(process.env.RATE_LIMIT_PER_MINUTE ?? "120");
           return [
-            createMemoryThrottleMiddleware({
+            this.ownThrottle(createMemoryThrottleMiddleware({
               maxAttempts: Number.isFinite(maxAttempts) ? maxAttempts : 120,
-              decaySeconds: 60
-            }),
+              decaySeconds: 60,
+              quotaPolicy
+            })),
             csrf
           ];
         }
         const maxAttempts = Number(process.env.RATE_LIMIT_PER_MINUTE ?? "120");
         return [
-          createThrottleMiddleware({
+          this.ownThrottle(createThrottleMiddleware({
             redisUrl,
             maxAttempts: Number.isFinite(maxAttempts) ? maxAttempts : 120,
-            decaySeconds: 60
-          }),
+            decaySeconds: 60,
+            quotaPolicy
+          })),
           csrf
         ];
       }
@@ -209,8 +250,8 @@ class HttpKernel {
       return handler(request);
     });
   }
-  wrapWebPublicRead(handler) {
-    if (isPublicReadsEnabled()) {
+  wrapWebPublicRead(handler, options = {}) {
+    if (options.allowAnonymous ?? isPublicReadsEnabled()) {
       return this.wrapWeb(handler);
     }
     return this.wrapWebAuthenticated(handler);
@@ -256,8 +297,8 @@ class HttpKernel {
     const middleware = [...this.group("authenticated"), ...this.verifiedMiddleware()];
     return withMiddleware(...middleware)(handler);
   }
-  wrapPublicRead(handler) {
-    if (isPublicReadsEnabled()) {
+  wrapPublicRead(handler, options = {}) {
+    if (options.allowAnonymous ?? isPublicReadsEnabled()) {
       return handler;
     }
     return this.wrapAuthenticated(handler);
@@ -302,25 +343,25 @@ class HttpKernel {
     const memoryKeyPrefix = scope === "login" ? "login-throttle:" : "register-throttle:";
     const redisUrl = this.dependencies.container.has(CORE_CONFIG_TOKEN) ? this.dependencies.container.resolve(CORE_CONFIG_TOKEN).get(REDIS_URL_CONFIG_KEY)?.trim() ?? "" : "";
     if (scope === "login") {
-      return withMiddleware(createLoginThrottleMiddleware({
+      return withMiddleware(this.ownThrottle(createLoginThrottleMiddleware({
         ...redisUrl ? { redisUrl } : {},
         maxAttempts: rateLimit.maxAttempts,
         decaySeconds: rateLimit.decaySeconds
-      }))(handler);
+      })))(handler);
     }
     if (redisUrl) {
-      return withMiddleware(createThrottleMiddleware({
+      return withMiddleware(this.ownThrottle(createThrottleMiddleware({
         redisUrl,
         maxAttempts: rateLimit.maxAttempts,
         decaySeconds: rateLimit.decaySeconds,
         keyPrefix: memoryKeyPrefix
-      }))(handler);
+      })))(handler);
     }
-    return withMiddleware(createMemoryThrottleMiddleware({
+    return withMiddleware(this.ownThrottle(createMemoryThrottleMiddleware({
       maxAttempts: rateLimit.maxAttempts,
       decaySeconds: rateLimit.decaySeconds,
       keyPrefix: memoryKeyPrefix
-    }))(handler);
+    })))(handler);
   }
 }
 function createHttpKernel(dependencies) {

package/dist/entries/web/server.js

@@ -1,5 +1,6 @@
 // @bun
 // ../../src/bootstrap/web/server.ts
+import { resolveMaxBodyBytes } from "@getstrata/core/http/bodySizeLimitMiddleware";
 import { createCorsMiddleware } from "@getstrata/core/http/corsMiddleware";
 import { currentRequestMeta, runWithRequestMeta } from "@getstrata/core/http/requestMetaContext";
 import { assertUrlPathUnderRoot } from "@getstrata/core/security/safePath";
@@ -11,29 +12,33 @@ function socketAddress(server, request) {
 async function missingHtmlResponse() {
   return notFoundHtmlResponse();
 }
-function wrapRouteHandler(handler, path) {
+function wrapRouteHandler(handler, path, onRequest, track = (work) => work()) {
   return async (request, server) => {
-    return await runWithRequestMeta({
+    return await track(async () => await runWithRequestMeta({
       ...currentRequestMeta(),
       request,
       routeTemplate: path,
       ipAddress: socketAddress(server, request),
+      peerAddress: socketAddress(server, request),
       userAgent: request.headers.get("user-agent")
     }, async () => {
+      const intercepted = await onRequest?.(request, server);
+      if (intercepted instanceof Response)
+        return intercepted;
       const response = await handler(request);
       return response ?? await missingHtmlResponse();
-    });
+    }));
   };
 }
-function convertAppRoutesToBunRoutes(routes, cors = {}) {
+function convertAppRoutesToBunRoutes(routes, cors = {}, onRequest, track) {
   const bunRoutes = {};
   const middleware = createCorsMiddleware(cors);
   const preflight = (request) => middleware(request, async () => new Response(null, { status: 405 }));
   for (const [path, handler] of Object.entries(routes)) {
     if (typeof handler === "function") {
       bunRoutes[path] = {
-        GET: wrapRouteHandler(handler, path),
-        OPTIONS: wrapRouteHandler(preflight, path)
+        GET: wrapRouteHandler(handler, path, onRequest, track),
+        OPTIONS: wrapRouteHandler(preflight, path, onRequest, track)
       };
       continue;
     }
@@ -43,10 +48,10 @@ function convertAppRoutesToBunRoutes(routes, cors = {}) {
         if (typeof methodHandler !== "function") {
           continue;
         }
-        methods[method.toUpperCase()] = wrapRouteHandler(methodHandler, path);
+        methods[method.toUpperCase()] = wrapRouteHandler(methodHandler, path, onRequest, track);
       }
       if (Object.keys(methods).length > 0) {
-        methods.OPTIONS ??= wrapRouteHandler(preflight, path);
+        methods.OPTIONS ??= wrapRouteHandler(preflight, path, onRequest, track);
         bunRoutes[path] = methods;
       }
     }
@@ -54,19 +59,48 @@ function convertAppRoutesToBunRoutes(routes, cors = {}) {
   return bunRoutes;
 }
 function createWebServer(options) {
+  if (options.lifecycle?.isShuttingDown)
+    throw new Error("Cannot start HTTP during shutdown.");
+  const onRequest = (request, server) => {
+    if (options.lifecycle?.isShuttingDown)
+      return new Response("Service Unavailable", { status: 503 });
+    return options.onRequest?.(request, server);
+  };
+  for (const field of ["fetch", "routes", "port", "unix"])
+    if (options.native && field in options.native)
+      throw new TypeError(`native.${field} is owned by createWebServer.`);
+  const maxRequestBodySize = options.native?.maxRequestBodySize ?? resolveMaxBodyBytes();
+  if (!Number.isSafeInteger(maxRequestBodySize) || maxRequestBodySize <= 0)
+    throw new RangeError("maxRequestBodySize must be a positive safe integer.");
+  const active = new Set;
+  const track = (work) => {
+    if (!options.lifecycle)
+      return work();
+    const running = work();
+    active.add(running);
+    return running.finally(() => {
+      active.delete(running);
+    });
+  };
   const publicDir = options.publicDir ?? "./public";
-  const bunRoutes = options.routes ? convertAppRoutesToBunRoutes(options.routes, options.cors) : undefined;
-  return Bun.serve({
+  const bunRoutes = options.routes ? convertAppRoutesToBunRoutes(options.routes, options.cors, onRequest, track) : undefined;
+  const { websocket, ...native } = options.native ?? {};
+  const configuration = {
+    ...native,
+    maxRequestBodySize,
     port: options.port,
     ...bunRoutes ? { routes: bunRoutes } : {},
     async fetch(request, server) {
-      return await runWithRequestMeta({
+      return await track(async () => await runWithRequestMeta({
         ...currentRequestMeta(),
         request,
         ipAddress: socketAddress(server, request),
+        peerAddress: socketAddress(server, request),
         userAgent: request.headers.get("user-agent")
       }, async () => {
-        await options.onRequest?.(request);
+        const intercepted = await onRequest(request, server);
+        if (intercepted instanceof Response)
+          return intercepted;
         const url = new URL(request.url);
         if (url.pathname.startsWith("/assets/")) {
           try {
@@ -80,13 +114,36 @@ function createWebServer(options) {
           }
         }
         if (options.handle) {
-          const response = await options.handle(request);
+          const response = await options.handle(request, server);
+          if (response === undefined && websocket)
+            return;
           return response ?? await missingHtmlResponse();
         }
         return await missingHtmlResponse();
-      });
+      }));
+    }
+  };
+  const server = websocket ? Bun.serve({ ...configuration, websocket }) : Bun.serve({
+    ...configuration,
+    async fetch(request, server) {
+      return await configuration.fetch(request, server) ?? await missingHtmlResponse();
     }
   });
+  if (options.lifecycle) {
+    const lifecycle = options.lifecycle;
+    const name = `http:${crypto.randomUUID()}`;
+    let draining;
+    lifecycle.register(`${name}:stop`, () => {
+      draining ??= server.stop(false);
+      draining.catch(() => {});
+    }, "stop");
+    lifecycle.register(`${name}:drain`, async () => {
+      await draining;
+      await Promise.allSettled([...active]);
+    }, "drain");
+    lifecycle.register(`${name}:force`, () => server.stop(true), "force");
+  }
+  return server;
 }
 export {
   convertAppRoutesToBunRoutes,