alepha 0.15.0 → 0.15.2

package/src/server/core/primitives/$action.ts

@@ -20,6 +20,7 @@ import type {
   ServerRequest,
   ServerResponseBody,
   ServerRoute,
+  TRequestBody,
 } from "../interfaces/ServerRequest.ts";
 import { ServerProvider } from "../providers/ServerProvider.ts";
 import { ServerRouterProvider } from "../providers/ServerRouterProvider.ts";
@@ -445,7 +446,9 @@ export type ClientRequestEntry<
 };
 
 export type ClientRequestEntryContainer<TConfig extends RequestConfigSchema> = {
-  body: TConfig["body"] extends TObject ? Static<TConfig["body"]> : undefined;
+  body: TConfig["body"] extends TRequestBody
+    ? Static<TConfig["body"]>
+    : undefined;
 
   params: TConfig["params"] extends TObject
     ? Static<TConfig["params"]>
@@ -453,11 +456,11 @@ export type ClientRequestEntryContainer<TConfig extends RequestConfigSchema> = {
 
   headers?: TConfig["headers"] extends TObject
     ? Static<TConfig["headers"]>
-    : undefined;
+    : Record<string, string>;
 
   query?: TConfig["query"] extends TObject
     ? Partial<Static<TConfig["query"]>>
-    : undefined;
+    : Record<string, string>;
 };
 
 export interface ClientRequestOptions extends FetchOptions {
@@ -465,6 +468,8 @@ export interface ClientRequestOptions extends FetchOptions {
    * Standard request fetch options.
    */
   request?: RequestInit;
+
+  query?: Record<string, string | number | boolean>;
 }
 
 export type ClientRequestResponse<TConfig extends RequestConfigSchema> =

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

@@ -107,7 +107,7 @@ export class BunHttpServerProvider extends ServerProvider {
         },
       });
 
-      this.log.info(`Server listening on ${this.hostname}`);
+      this.log.info(`Server listening on ${this.hostname}/`);
     } catch (err) {
       this.log.error("Failed to start Bun server", err);
       throw err;

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

@@ -0,0 +1,125 @@
+import { Alepha } from "alepha";
+import { afterEach, describe, expect, test } from "vitest";
+import { NodeHttpServerProvider } from "./NodeHttpServerProvider.ts";
+
+describe("NodeHttpServerProvider", () => {
+  describe("graceful shutdown", () => {
+    let alepha: Alepha;
+    let server: NodeHttpServerProvider;
+
+    afterEach(async () => {
+      await alepha?.stop().catch(() => {});
+    });
+
+    test("dev mode: destroys connections immediately on close", async () => {
+      alepha = Alepha.create({ env: { NODE_ENV: "development" } });
+      alepha.with(NodeHttpServerProvider);
+
+      await alepha.start();
+      server = alepha.inject(NodeHttpServerProvider);
+
+      // Make a request to establish connection
+      await fetch(`${server.hostname}/`);
+
+      const startTime = Date.now();
+      await alepha.stop();
+      const elapsed = Date.now() - startTime;
+
+      // Should close instantly (under 100ms)
+      expect(elapsed).toBeLessThan(100);
+      expect(server.getConnectionsCount()).toBe(0);
+    });
+
+    test("production mode: waits for connections then closes", async () => {
+      alepha = Alepha.create({ env: { NODE_ENV: "production" } });
+      alepha.with(NodeHttpServerProvider);
+
+      await alepha.start();
+      server = alepha.inject(NodeHttpServerProvider);
+      server.options.shutdownTimeout = 500;
+
+      // Make a request to establish keep-alive connection
+      await fetch(`${server.hostname}/`);
+
+      const startTime = Date.now();
+      await alepha.stop();
+      const elapsed = Date.now() - startTime;
+
+      // In production, should not be instant (waits for graceful close or timeout)
+      // But should complete within timeout
+      expect(elapsed).toBeLessThan(server.options.shutdownTimeout + 100);
+      expect(server.getConnectionsCount()).toBe(0);
+    });
+
+    test("production mode: forces close after timeout", async () => {
+      alepha = Alepha.create({ env: { NODE_ENV: "production" } });
+      alepha.with(NodeHttpServerProvider);
+
+      await alepha.start();
+      server = alepha.inject(NodeHttpServerProvider);
+      server.options.shutdownTimeout = 50;
+
+      // Make a request to establish connection
+      await fetch(`${server.hostname}/`);
+
+      const startTime = Date.now();
+      await alepha.stop();
+      const elapsed = Date.now() - startTime;
+
+      // Should close around timeout
+      expect(elapsed).toBeLessThan(200);
+      expect(server.getConnectionsCount()).toBe(0);
+    });
+
+    test("connections are tracked and cleared", async () => {
+      alepha = Alepha.create({ env: { NODE_ENV: "development" } });
+      alepha.with(NodeHttpServerProvider);
+
+      await alepha.start();
+      server = alepha.inject(NodeHttpServerProvider);
+
+      // Make multiple requests
+      await fetch(`${server.hostname}/`);
+      await fetch(`${server.hostname}/`);
+
+      await alepha.stop();
+
+      // All connections cleared after stop
+      expect(server.getConnectionsCount()).toBe(0);
+    });
+
+    test("rejects new requests during shutdown", async () => {
+      alepha = Alepha.create({ env: { NODE_ENV: "production" } });
+      alepha.with(NodeHttpServerProvider);
+
+      await alepha.start();
+      server = alepha.inject(NodeHttpServerProvider);
+      server.options.shutdownTimeout = 500;
+
+      // Establish a connection to keep server busy
+      await fetch(`${server.hostname}/`);
+
+      // Start shutdown (don't await yet)
+      const stopPromise = alepha.stop();
+
+      // Give server.close() time to be called
+      await new Promise((r) => setTimeout(r, 10));
+
+      // New request should fail (server no longer accepting connections)
+      let error: Error | null = null;
+      try {
+        await fetch(`${server.hostname}/`, {
+          signal: AbortSignal.timeout(100),
+        });
+      } catch (e) {
+        error = e as Error;
+      }
+
+      // Should get a connection error (ECONNREFUSED or similar)
+      expect(error).not.toBeNull();
+
+      // Wait for shutdown to complete
+      await stopPromise;
+    });
+  });
+});

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

@@ -4,6 +4,7 @@ import {
   type Server,
   type ServerResponse,
 } from "node:http";
+import type { Socket } from "node:net";
 import { $env, $hook, $inject, Alepha, type Static, t } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
 import { $logger } from "alepha/logger";
@@ -34,6 +35,30 @@ export class NodeHttpServerProvider extends ServerProvider {
   protected readonly env = $env(envSchema);
   protected readonly router = $inject(ServerRouterProvider);
 
+  /**
+   * Track active connections for fast shutdown.
+   */
+  protected readonly connections = new Set<Socket>();
+
+  /**
+   * Get number of active connections.
+   */
+  public getConnectionsCount(): number {
+    return this.connections.size;
+  }
+
+  /**
+   * Server options.
+   */
+  public readonly options = {
+    /**
+     * Graceful shutdown timeout in ms.
+     * After this, remaining connections are forcefully closed.
+     * @default 30000
+     */
+    shutdownTimeout: 10000,
+  };
+
   public get hostname(): string {
     if (this.server.listening) {
       const address = this.server.address();
@@ -45,10 +70,7 @@ export class NodeHttpServerProvider extends ServerProvider {
   }
 
   // Pre-bound error handler to avoid function allocation per request
-  protected readonly handleRequestError = (
-    res: import("node:http").ServerResponse,
-    err: Error,
-  ) => {
+  protected readonly handleRequestError = (res: ServerResponse, err: Error) => {
     this.log.error("Error handling request", err);
     res.statusCode = 500;
     res.end("Internal Server Error");
@@ -83,25 +105,27 @@ export class NodeHttpServerProvider extends ServerProvider {
   protected createHttpServer(
     func: (req: IncomingMessage, res: ServerResponse) => void,
   ): Server {
-    return createServer(
+    const server = createServer(
       {
         // nov 25 - keep connections alive for better performance, cuz we http/1.1 by default
         keepAlive: this.alepha.isProduction(),
       },
       func,
     );
+
+    // Track connections for fast shutdown
+    server.on("connection", (socket) => {
+      this.connections.add(socket);
+      socket.on("close", () => this.connections.delete(socket));
+    });
+
+    return server;
   }
 
   protected readonly stop = $hook({
     on: "stop",
     handler: async () => {
-      if (this.alepha.isProduction()) {
-        await this.close();
-        return;
-      }
-
-      // do not await in development & test
-      this.close().catch(() => {});
+      await this.close();
     },
   });
 
@@ -115,7 +139,7 @@ export class NodeHttpServerProvider extends ServerProvider {
 
     await new Promise<void>((resolve, reject) => {
       this.server?.listen(port, this.env.SERVER_HOST, () => {
-        this.log.info(`Server listening on ${this.hostname}`);
+        this.log.info(`Server listening on ${this.hostname}/`);
         resolve();
       });
 
@@ -126,18 +150,49 @@ export class NodeHttpServerProvider extends ServerProvider {
   }
 
   protected async close() {
-    const promise = new Promise<void>((resolve, reject) => {
-      this.server?.close((err) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve();
-        }
-      });
+    // Dev/Test: instant shutdown (destroy connections immediately)
+    // Production: graceful shutdown (wait for requests to complete, then close)
+    if (!this.alepha.isProduction()) {
+      this.destroyAllConnections();
+    }
+
+    // Stop accepting new connections
+    const closePromise = new Promise<void>((resolve, reject) => {
+      this.server?.close((err) => (err ? reject(err) : resolve()));
     });
 
-    await Promise.race([this.dateTimeProvider.wait(2000), promise]);
+    if (this.alepha.isProduction() && this.connections.size > 0) {
+      // In production, wait for connections with timeout
+      const timeout = this.options.shutdownTimeout;
+
+      // Set up timeout to force-close connections
+      const timeoutId = setTimeout(() => {
+        if (this.connections.size > 0) {
+          this.log.warn(
+            `Shutdown timeout (${timeout}ms) reached, forcing ${this.connections.size} connections to close`,
+          );
+          // Destroy sockets - this triggers 'close' events which eventually resolves closePromise
+          for (const socket of this.connections) {
+            socket.destroy();
+          }
+        }
+      }, timeout);
+
+      // Wait for server to fully close (all connections closed)
+      await closePromise;
+      clearTimeout(timeoutId);
+      this.connections.clear();
+    } else {
+      await closePromise;
+    }
 
     this.log.info("Server closed");
   }
+
+  protected destroyAllConnections() {
+    for (const socket of this.connections) {
+      socket.destroy();
+    }
+    this.connections.clear();
+  }
 }

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

@@ -9,7 +9,7 @@ export class ServerLoggerProvider {
     on: "server:onRequest",
     priority: "first",
     handler: ({ route, request }) => {
-      if (route.silent) {
+      if (route.silent || request.metadata.vite) {
         return;
       }
 
@@ -44,7 +44,7 @@ export class ServerLoggerProvider {
     on: "server:onResponse",
     priority: "last",
     handler: ({ route, request, response }) => {
-      if (route.silent) {
+      if (route.silent || request.metadata.vite) {
         return;
       }
 

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

@@ -140,14 +140,6 @@ export class ServerProvider {
     }
   }
 
-  /**
-   * 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}`;
@@ -185,11 +177,11 @@ export class ServerProvider {
     const rawUrl = req.url!;
     const { route, params } = this.router.match(`/${req.method}${rawUrl}`);
 
-    if (this.isViteNotFound(rawUrl, route, params)) {
-      return;
-    }
-
     if (!route) {
+      // Skip if response was already sent (e.g., by Vite middleware)
+      if (res.headersSent) {
+        return;
+      }
       // if no route is found, return basic 404
       // note: you should not use this in production, use a custom 404 page instead by adding a route /*
       res.writeHead(404, { "content-type": "text/plain" });
@@ -221,6 +213,11 @@ export class ServerProvider {
       .handler(request)
       .catch(this.handleInternalError);
 
+    // Skip if response was already sent (e.g., by Vite middleware)
+    if (res.headersSent) {
+      return;
+    }
+
     // empty body - just send status & headers
     if (!response.body) {
       res.writeHead(response.status, response.headers).end();