alepha 0.14.3 → 0.15.0

package/src/server/compress/providers/ServerCompressProvider.ts

@@ -136,12 +136,71 @@ export class ServerCompressProvider {
 
     if (typeof body === "object" && body instanceof ReadableStream) {
       this.setHeaders(response, encoding);
-      response.body = Readable.fromWeb(body).pipe(
-        compressor.stream({ params }),
+      // For streaming responses, use flush mode to avoid buffering
+      response.body = this.createFlushingCompressStream(
+        body,
+        compressor.stream,
+        encoding,
+        params,
       );
     }
   }
 
+  /**
+   * Create a compressed stream that flushes after each chunk.
+   * This is essential for streaming SSR - ensures each chunk is sent immediately.
+   */
+  protected createFlushingCompressStream(
+    input: ReadableStream,
+    createCompressor: (options?: any) => Transform,
+    encoding: string,
+    params: Record<number, any>,
+  ): ReadableStream<Uint8Array> {
+    const compressor = createCompressor({
+      params,
+      flush: zlib.constants.Z_SYNC_FLUSH,
+    });
+    const reader = Readable.fromWeb(input);
+
+    return new ReadableStream<Uint8Array>({
+      start(controller) {
+        compressor.on("data", (chunk: Buffer) => {
+          controller.enqueue(new Uint8Array(chunk));
+        });
+
+        compressor.on("end", () => {
+          controller.close();
+        });
+
+        compressor.on("error", (err) => {
+          controller.error(err);
+        });
+
+        reader.on("data", (chunk: Buffer) => {
+          compressor.write(chunk);
+          // Force flush after each chunk for streaming
+          // Cast to any because flush() exists on zlib streams but not in Transform type
+          const zlibStream = compressor as any;
+          if (encoding === "gzip") {
+            zlibStream.flush(zlib.constants.Z_SYNC_FLUSH);
+          } else if (encoding === "br") {
+            zlibStream.flush(zlib.constants.BROTLI_OPERATION_FLUSH);
+          } else if (encoding === "zstd") {
+            zlibStream.flush();
+          }
+        });
+
+        reader.on("end", () => {
+          compressor.end();
+        });
+
+        reader.on("error", (err) => {
+          controller.error(err);
+        });
+      },
+    });
+  }
+
   protected getParams(
     encoding: keyof typeof ServerCompressProvider.compressors,
   ): Record<number, any> {

package/src/server/cookies/providers/ServerCookiesProvider.ts

@@ -48,7 +48,7 @@ export class ServerCookiesProvider {
 
   public readonly onRequest = $hook({
     on: "server:onRequest",
-    handler: async ({ request }) => {
+    handler: ({ request }) => {
       request.cookies = {
         req: this.cookieParser.parseRequestCookies(
           request.headers.cookie ?? "",
@@ -60,7 +60,7 @@ export class ServerCookiesProvider {
 
   public readonly onAction = $hook({
     on: "action:onRequest",
-    handler: async ({ request }) => {
+    handler: ({ request }) => {
       request.cookies = {
         req: this.cookieParser.parseRequestCookies(
           request.headers.cookie ?? "",
@@ -72,7 +72,7 @@ export class ServerCookiesProvider {
 
   public readonly onSend = $hook({
     on: "server:onSend",
-    handler: async ({ request }) => {
+    handler: ({ request }) => {
       if (request.cookies && Object.keys(request.cookies.res).length > 0) {
         const setCookieHeaders = this.cookieParser.serializeResponseCookies(
           request.cookies.res,

package/src/server/core/helpers/ServerReply.ts

@@ -12,9 +12,9 @@ export class ServerReply {
   public body?: any;
 
   /**
-   * Redirect to a given URL with optional status code (default 302).
+   * Redirect to a given URL with optional status code (default 301).
    */
-  public redirect(url: string, status: number = 302): void {
+  public redirect(url: string, status: number = 301): void {
     this.status = status;
     this.headers.location = url;
   }

package/src/server/core/providers/NodeHttpServerProvider.ts

@@ -44,13 +44,32 @@ export class NodeHttpServerProvider extends ServerProvider {
     return `http://${this.env.SERVER_HOST}:${this.env.SERVER_PORT}`;
   }
 
+  // Pre-bound error handler to avoid function allocation per request
+  protected readonly handleRequestError = (
+    res: import("node:http").ServerResponse,
+    err: Error,
+  ) => {
+    this.log.error("Error handling request", err);
+    res.statusCode = 500;
+    res.end("Internal Server Error");
+  };
+
+  // P3: Pre-allocated event object to avoid { req, res } allocation per request
+  // Safe because handleNodeRequest completes before the next request reuses this object
+  protected readonly nodeRequestEvent = {
+    req: null as unknown as IncomingMessage,
+    res: null as unknown as ServerResponse,
+  };
+
   public readonly server = this.createHttpServer((req, res) => {
-    this.log.trace(`Incoming Node.js message -> ${req.url}`);
-    this.handleNodeRequest({ req, res }).catch((err) => {
-      this.log.error("Error handling request", err);
-      res.statusCode = 500;
-      res.end("Internal Server Error");
-    });
+    // Reuse pre-allocated event object instead of creating { req, res } per request
+    const ev = this.nodeRequestEvent;
+    ev.req = req;
+    ev.res = res;
+    // Note: handleNodeRequest returns a promise that resolves after response is sent
+    this.handleNodeRequest(ev).catch((err) =>
+      this.handleRequestError(res, err),
+    );
   });
 
   public readonly start = $hook({

package/src/server/core/providers/ServerBodyParserProvider.ts

@@ -24,7 +24,7 @@ export class ServerBodyParserProvider {
 
   public readonly onRequest = $hook({
     on: "server:onRequest",
-    handler: async ({ route, request }) => {
+    handler: ({ route, request }) => {
       if (request.body) {
         return; // already parsed
       }
@@ -46,28 +46,24 @@ export class ServerBodyParserProvider {
       }
 
       if (route.schema?.body) {
-        try {
-          const body = await this.parse(
-            stream,
-            request.headers,
-            route.schema.body,
-          );
-          if (body) {
-            request.body = body;
-          }
-        } catch (error) {
-          if (error instanceof HttpError) {
-            throw error;
-          }
-
-          throw new HttpError(
-            {
-              status: 400,
-              message: "Failed to parse request body",
-            },
-            error,
-          );
-        }
+        return this.parse(stream, request.headers, route.schema.body)
+          .then((body) => {
+            if (body) {
+              request.body = body;
+            }
+          })
+          .catch((error) => {
+            if (error instanceof HttpError) {
+              throw error;
+            }
+            throw new HttpError(
+              {
+                status: 400,
+                message: "Failed to parse request body",
+              },
+              error,
+            );
+          });
       }
     },
   });

package/src/server/core/providers/ServerLoggerProvider.ts

@@ -9,24 +9,26 @@ export class ServerLoggerProvider {
     on: "server:onRequest",
     priority: "first",
     handler: ({ route, request }) => {
-      if (!route.silent) {
-        request.metadata.now = Date.now();
-
-        const data: Record<string, string> = {
-          method: request.method,
-          path: request.url.pathname,
-        };
-
-        if (this.alepha.isProduction()) {
-          data.agent = request.headers["user-agent"];
-          const ip = request.ip;
-          if (ip) {
-            data.ip = ip;
-          }
-        }
+      if (route.silent) {
+        return;
+      }
+
+      request.metadata.now = Date.now();
+
+      const data: Record<string, string> = {
+        method: request.method,
+        path: request.url.pathname,
+      };
 
-        this.log.info("Incoming request", data);
+      if (this.alepha.isProduction()) {
+        data.agent = request.headers["user-agent"];
+        const ip = request.ip;
+        if (ip) {
+          data.ip = ip;
+        }
       }
+
+      this.log.info("Incoming request", data);
     },
   });
 
@@ -42,10 +44,12 @@ export class ServerLoggerProvider {
     on: "server:onResponse",
     priority: "last",
     handler: ({ route, request, response }) => {
-      if (!route.silent) {
-        const ms = Date.now() - request.metadata.now;
-        this.log.info("Request completed", { status: response.status, ms });
+      if (route.silent) {
+        return;
       }
+
+      const ms = Date.now() - request.metadata.now;
+      this.log.info("Request completed", { status: response.status, ms });
     },
   });
 }

package/src/server/core/providers/ServerProvider.ts

@@ -11,6 +11,21 @@ import type {
 } from "../interfaces/ServerRequest.ts";
 import { ServerRouterProvider } from "./ServerRouterProvider.ts";
 
+// ============================================================================
+// Performance Constants
+// ============================================================================
+
+// Note: We cannot use frozen/shared empty objects here because downstream code
+// may mutate params/query (e.g., validation, React page rendering)
+
+// Header constants for fast property access
+const HEADER_X_FORWARDED_PROTO = "x-forwarded-proto";
+const HEADER_HOST = "host";
+
+// Protocol prefixes
+const PROTO_HTTPS = "https://";
+const PROTO_HTTP = "http://";
+
 /**
  * Base server provider to handle incoming requests and route them.
  *
@@ -26,7 +41,117 @@ export class ServerProvider {
 
   protected readonly internalServerErrorMessage = "Internal Server Error";
 
+  // Pre-allocated error response to avoid object creation per failed request
+  protected readonly internalErrorResponse = Object.freeze({
+    status: 500,
+    headers: Object.freeze({ "content-type": "text/plain" }),
+    body: this.internalServerErrorMessage,
+  });
+
+  // Pre-bound error handler to avoid function allocation per request
+  protected readonly handleInternalError = () => this.internalErrorResponse;
+
+  // ============================================================================
+  // P1: URL Base Cache - cache protocol+host per unique host header
+  // Avoids string concatenation on every request
+  // ============================================================================
+  protected readonly urlBaseCache = new Map<string, string>();
+
+  /**
+   * Get cached URL base (protocol + host) for a given host header.
+   * Caches the result to avoid repeated string concatenation.
+   */
+  protected getUrlBase(headers: Record<string, string>): string {
+    const host = headers[HEADER_HOST];
+    let base = this.urlBaseCache.get(host);
+    if (!base) {
+      const proto =
+        headers[HEADER_X_FORWARDED_PROTO] === "https"
+          ? PROTO_HTTPS
+          : PROTO_HTTP;
+      base = proto + host;
+      // Limit cache size to prevent memory leaks from many unique hosts
+      if (this.urlBaseCache.size < 100) {
+        this.urlBaseCache.set(host, base);
+      }
+    }
+    return base;
+  }
+
+  // ============================================================================
+  // P0: Manual Query String Parser - faster than URLSearchParams
+  // Parses query string without creating URL object
+  // ============================================================================
+
+  /**
+   * Parse query string manually - faster than new URL() + URLSearchParams.
+   * Returns empty object if no query string.
+   */
+  protected parseQueryString(rawUrl: string): Record<string, string> {
+    const qIndex = rawUrl.indexOf("?");
+    if (qIndex === -1) {
+      return {};
+    }
+
+    const qs = rawUrl.slice(qIndex + 1);
+    if (!qs) {
+      return {};
+    }
+
+    const query: Record<string, string> = {};
+    let start = 0;
+    let eqIdx = -1;
+
+    for (let i = 0; i <= qs.length; i++) {
+      const char = i < qs.length ? qs.charCodeAt(i) : 38; // '&' at end
+
+      if (char === 61) {
+        // '='
+        eqIdx = i;
+      } else if (char === 38) {
+        // '&'
+        if (eqIdx !== -1 && eqIdx > start) {
+          const key = qs.slice(start, eqIdx);
+          const value = qs.slice(eqIdx + 1, i);
+          // Only decode if necessary (contains % or +)
+          query[this.fastDecode(key)] = this.fastDecode(value);
+        }
+        start = i + 1;
+        eqIdx = -1;
+      }
+    }
+
+    return query;
+  }
+
+  /**
+   * Fast decode - only calls decodeURIComponent if needed.
+   */
+  protected fastDecode(str: string): string {
+    // Fast path: no encoding needed
+    if (str.indexOf("%") === -1 && str.indexOf("+") === -1) {
+      return str;
+    }
+    // Replace + with space before decoding
+    try {
+      return decodeURIComponent(str.replace(/\+/g, " "));
+    } catch {
+      return str;
+    }
+  }
+
+  /**
+   * Extract pathname from URL without creating URL object.
+   */
+  protected getPathname(rawUrl: string): string {
+    const qIndex = rawUrl.indexOf("?");
+    return qIndex === -1 ? rawUrl : rawUrl.slice(0, qIndex);
+  }
+
   public get hostname(): string {
+    if (this.alepha.isViteDev()) {
+      return `http://localhost:${this.alepha.env.SERVER_PORT}`;
+    }
     return ""; // no hostname in serverless mode
   }
 
@@ -51,15 +176,16 @@ export class ServerProvider {
   /**
    * Handle Node.js HTTP request event.
    *
-   * Technically, we just convert Node.js request to Web Standard Request.
+   * Optimized to avoid expensive URL parsing when possible.
    */
   public async handleNodeRequest(
     nodeRequestEvent: NodeRequestEvent,
   ): Promise<void> {
     const { req, res } = nodeRequestEvent;
-    const { route, params } = this.router.match(`/${req.method}${req.url}`);
+    const rawUrl = req.url!;
+    const { route, params } = this.router.match(`/${req.method}${rawUrl}`);
 
-    if (this.isViteNotFound(req.url, route, params)) {
+    if (this.isViteNotFound(rawUrl, route, params)) {
       return;
     }
 
@@ -72,11 +198,16 @@ export class ServerProvider {
     }
 
     const headers = (req.headers ?? {}) as Record<string, string>;
-    const proto = headers["x-forwarded-proto"] === "https" ? "https" : "http";
-    const url = new URL(`${proto}://${headers.host}${req.url}`);
-    const query = Object.fromEntries(url.searchParams.entries());
     const method = (req.method?.toUpperCase() ?? "GET") as RouteMethod;
 
+    // P0: Use manual query parsing - much faster than new URL() + URLSearchParams
+    const query = this.parseQueryString(rawUrl);
+
+    // P1: Use cached URL base - avoids string concat on every request
+    // Create URL object (still needed for downstream code that uses url.pathname, etc.)
+    const urlBase = this.getUrlBase(headers);
+    const url = new URL(rawUrl, urlBase);
+
     const request: ServerRequestData = {
       method,
       url,
@@ -86,13 +217,9 @@ export class ServerProvider {
       raw: { node: nodeRequestEvent },
     };
 
-    const response = await route.handler(request).catch(() => {
-      return {
-        status: 500,
-        headers: { "content-type": "text/plain" },
-        body: this.internalServerErrorMessage,
-      };
-    });
+    const response = await route
+      .handler(request)
+      .catch(this.handleInternalError);
 
     // empty body - just send status & headers
     if (!response.body) {
@@ -116,9 +243,16 @@ export class ServerProvider {
     // if response.body is web stream
     if (response.body instanceof ReadableStream) {
       res.writeHead(response.status, response.headers);
+      // Flush headers immediately and disable Nagle's algorithm for streaming
+      res.flushHeaders();
+      res.socket?.setNoDelay(true);
       try {
         for await (const chunk of response.body) {
-          res.write(chunk);
+          const canContinue = res.write(chunk);
+          // If the internal buffer is full, wait for it to drain
+          if (!canContinue) {
+            await new Promise<void>((resolve) => res.once("drain", resolve));
+          }
         }
       } catch (error) {
         this.log.error("Error piping proxy response stream", error);
@@ -165,7 +299,10 @@ export class ServerProvider {
       headers[key] = value;
     });
 
-    const query = Object.fromEntries(url.searchParams.entries());
+    // Optimize: only parse query params if there are any
+    const query = url.search
+      ? Object.fromEntries(url.searchParams.entries())
+      : {};
     const method = (req.method.toUpperCase() ?? "GET") as RouteMethod;
     const request: ServerRequestData = {
       method,
@@ -176,13 +313,9 @@ export class ServerProvider {
       raw: { web: ev },
     };
 
-    const response = await route.handler(request).catch(() => {
-      return {
-        status: 500,
-        headers: { "content-type": "text/plain" },
-        body: this.internalServerErrorMessage,
-      };
-    });
+    const response = await route
+      .handler(request)
+      .catch(this.handleInternalError);
 
     // empty body - just send status & headers
     if (!response.body) {