alepha 0.15.0 → 0.15.1

package/dist/server/core/index.d.ts

@@ -1,13 +1,13 @@
 import * as alepha19 from "alepha";
 import { Alepha, AlephaError, Async, CompiledEventExecutor, FileLike, Hooks, KIND, Primitive, Static, StreamLike, TArray, TFile, TObject, TRecord, TSchema, TStream, TString, TVoid } from "alepha";
-import * as alepha_logger4 from "alepha/logger";
+import * as alepha_logger6 from "alepha/logger";
 import { Readable } from "node:stream";
 import { DateTimeProvider, DurationLike } from "alepha/datetime";
 import { ReadableStream } from "node:stream/web";
 import { Route, RouterProvider } from "alepha/router";
 import * as alepha_cache0 from "alepha/cache";
-import * as node_http0 from "node:http";
 import { IncomingMessage, Server, ServerResponse as ServerResponse$1 } from "node:http";
+import { Socket } from "node:net";
 
 //#region ../../src/server/core/schemas/errorSchema.d.ts
 declare const errorSchema: alepha19.TObject<{
@@ -59,20 +59,20 @@ declare class ServerReply {
   status?: number;
   body?: any;
   /**
-       * Redirect to a given URL with optional status code (default 301).
-       */
+   * Redirect to a given URL with optional status code (default 301).
+   */
   redirect(url: string, status?: number): void;
   /**
-       * Set the response status code.
-       */
+   * Set the response status code.
+   */
   setStatus(status: number): this;
   /**
-       * Set a response header.
-       */
+   * Set a response header.
+   */
   setHeader(name: string, value: string): this;
   /**
-       * Set the response body.
-       */
+   * Set the response body.
+   */
   setBody(body: any): this;
 }
 //#endregion
@@ -111,73 +111,73 @@ interface ServerRequestConfig<TConfig extends RequestConfigSchema = RequestConfi
 type ServerRequestConfigEntry<TConfig extends RequestConfigSchema = RequestConfigSchema> = Partial<ServerRequestConfig<TConfig>>;
 interface ServerRequest<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRequestConfig<TConfig> {
   /**
-       * HTTP method used for this request.
-       */
+   * HTTP method used for this request.
+   */
   method: RouteMethod;
   /**
-       * Full request URL.
-       */
+   * Full request URL.
+   */
   url: URL;
   /**
-       * Unique request ID assigned to this request.
-       */
+   * Unique request ID assigned to this request.
+   */
   requestId: string;
   /**
-       * Client IP address.
-       * Will parse `X-Forwarded-For` header if present.
-       */
+   * Client IP address.
+   * Will parse `X-Forwarded-For` header if present.
+   */
   ip?: string;
   /**
-       * Value of the `Host` header sent by the client.
-       */
+   * Value of the `Host` header sent by the client.
+   */
   host?: string;
   /**
-       * Browser user agent information.
-       * Information are not guaranteed to be accurate. Use with caution.
-       *
-       * @see {@link UserAgentParser}
-       */
+   * Browser user agent information.
+   * Information are not guaranteed to be accurate. Use with caution.
+   *
+   * @see {@link UserAgentParser}
+   */
   userAgent: UserAgentInfo;
   /**
-       * Arbitrary metadata attached to the request. Can be used by middlewares to store information.
-       */
+   * Arbitrary metadata attached to the request. Can be used by middlewares to store information.
+   */
   metadata: Record<string, any>;
   /**
-       * Reply object to be used to send response.
-       */
+   * Reply object to be used to send response.
+   */
   reply: ServerReply;
   /**
-       * The raw underlying request object (Web Request).
-       */
+   * The raw underlying request object (Web Request).
+   */
   raw: ServerRawRequest;
 }
 interface ServerRoute<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Route {
   /**
-       * Handler function for this route.
-       */
+   * Handler function for this route.
+   */
   handler: ServerHandler<TConfig>;
   /**
-       * HTTP method for this route.
-       */
+   * HTTP method for this route.
+   */
   method?: RouteMethod;
   /**
-       * Request/response schema for this route.
-       *
-       * Request schema contains:
-       * - body, for POST/PUT/PATCH requests
-       * - params, for URL parameters (e.g. /user/:id)
-       * - query, for URL query parameters (e.g. /user?id=123)
-       * - headers, for HTTP headers
-       *
-       * Response schema contains:
-       * - response
-       *
-       * Response schema is used to validate and serialize the response sent by the handler.
-       */
+   * Request/response schema for this route.
+   *
+   * Request schema contains:
+   * - body, for POST/PUT/PATCH requests
+   * - params, for URL parameters (e.g. /user/:id)
+   * - query, for URL query parameters (e.g. /user?id=123)
+   * - headers, for HTTP headers
+   *
+   * Response schema contains:
+   * - response
+   *
+   * Response schema is used to validate and serialize the response sent by the handler.
+   */
   schema?: TConfig;
   /**
-       * @see ServerLoggerProvider
-       */
+   * @see ServerLoggerProvider
+   */
   silent?: boolean;
 }
 type ServerResponseBody<TConfig extends RequestConfigSchema = RequestConfigSchema> = TConfig["response"] extends TResponseBody ? Static<TConfig["response"]> : ResponseBodyType;
@@ -227,7 +227,7 @@ declare class ServerRequestParser {
 //#region ../../src/server/core/providers/ServerTimingProvider.d.ts
 type TimingMap = Record<string, [number, number]>;
 declare class ServerTimingProvider {
-  protected readonly log: alepha_logger4.Logger;
+  protected readonly log: alepha_logger6.Logger;
   protected readonly alepha: Alepha;
   options: {
     prefix: string;
@@ -251,7 +251,7 @@ declare class ServerTimingProvider {
  * - $page => React route (for React SSR)
  */
 declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
-  protected readonly log: alepha_logger4.Logger;
+  protected readonly log: alepha_logger6.Logger;
   protected readonly alepha: Alepha;
   protected readonly routes: ServerRoute[];
   protected readonly serverTimingProvider: ServerTimingProvider;
@@ -269,39 +269,39 @@ declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
   protected readonly processRequestBound: () => Promise<any>;
   protected readonly queryKeysCache: WeakMap<object, string[]>;
   /**
-       * Get cached keys for a query schema, computing them lazily on first access.
-       */
+   * Get cached keys for a query schema, computing them lazily on first access.
+   */
   protected getQuerySchemaKeys(schema: {
     properties: object;
   }): string[];
   /**
-       * Compile event executors for optimal performance.
-       * Called lazily on first request after all hooks are registered.
-       */
+   * Compile event executors for optimal performance.
+   * Called lazily on first request after all hooks are registered.
+   */
   protected compileEvents(): void;
   /**
-       * Get all registered routes, optionally filtered by a pattern.
-       *
-       * Pattern accept simple wildcard '*' at the end.
-       * Example: '/api/*' will match all routes starting with '/api/' but '/api/' will match only that exact route.
-       */
+   * Get all registered routes, optionally filtered by a pattern.
+   *
+   * Pattern accept simple wildcard '*' at the end.
+   * Example: '/api/*' will match all routes starting with '/api/' but '/api/' will match only that exact route.
+   */
   getRoutes(pattern?: string): ServerRoute[];
   /**
-       * Create a new server route.
-       */
+   * Create a new server route.
+   */
   createRoute<TConfig extends RequestConfigSchema = RequestConfigSchema>(route: ServerRoute<TConfig>): void;
   /**
-       * Get or generate a context ID from request headers.
-       */
+   * Get or generate a context ID from request headers.
+   */
   protected getContextId(headers: Record<string, string>): string;
   /**
-       * Process an incoming request through the full lifecycle:
-       * - onRequest hooks
-       * - route handler
-       * - onSend hooks
-       * - response serialization
-       * - onResponse hooks
-       */
+   * Process an incoming request through the full lifecycle:
+   * - onRequest hooks
+   * - route handler
+   * - onSend hooks
+   * - response serialization
+   * - onResponse hooks
+   */
   protected processRequest(request: ServerRequest, route: ServerRoute, responseKind: ResponseKind): Promise<{
     status: number;
     headers: Record<string, string> & {
@@ -310,24 +310,24 @@ declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
     body: any;
   }>;
   /**
-       * Run the route handler with request validation and response serialization.
-       */
+   * Run the route handler with request validation and response serialization.
+   */
   protected runRouteHandler(route: ServerRoute, request: ServerRequest, responseKind: ResponseKind): Promise<void>;
   /**
-       * Transform reply body based on response kind and route schema.
-       */
+   * Transform reply body based on response kind and route schema.
+   */
   serializeResponse(route: ServerRoute, reply: ServerReply, responseKind: ResponseKind): void;
   /**
-       * Determine response type based on route schema.
-       */
+   * Determine response type based on route schema.
+   */
   protected getResponseType(schema?: RequestConfigSchema): ResponseKind;
   /**
-       * When an error occurs during request processing, this method is called.
-       */
+   * When an error occurs during request processing, this method is called.
+   */
   protected errorHandler(route: ServerRoute, request: ServerRequest, error: Error): Promise<void>;
   /**
-       * Validate incoming request against route schema.
-       */
+   * Validate incoming request against route schema.
+   */
   validateRequest(route: {
     schema?: RequestConfigSchema;
   }, request: ServerRequestConfig): void;
@@ -342,7 +342,7 @@ declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
  * ServerProvider supports both Node.js HTTP requests and Web (Fetch API) requests.
  */
 declare class ServerProvider {
-  protected readonly log: alepha_logger4.Logger;
+  protected readonly log: alepha_logger6.Logger;
   protected readonly alepha: Alepha;
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly router: ServerRouterProvider;
@@ -363,51 +363,47 @@ declare class ServerProvider {
   }>;
   protected readonly urlBaseCache: Map<string, string>;
   /**
-       * Get cached URL base (protocol + host) for a given host header.
-       * Caches the result to avoid repeated string concatenation.
-       */
+   * 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;
   /**
-       * Parse query string manually - faster than new URL() + URLSearchParams.
-       * Returns empty object if no query string.
-       */
+   * Parse query string manually - faster than new URL() + URLSearchParams.
+   * Returns empty object if no query string.
+   */
   protected parseQueryString(rawUrl: string): Record<string, string>;
   /**
-       * Fast decode - only calls decodeURIComponent if needed.
-       */
+   * Fast decode - only calls decodeURIComponent if needed.
+   */
   protected fastDecode(str: string): string;
-  /**
-       * Extract pathname from URL without creating URL object.
-       */
-  protected getPathname(rawUrl: string): string;
   get hostname(): string;
   /**
-       * When a Node.js HTTP request is received from outside. (Vercel, AWS Lambda, etc.)
-       */
+   * When a Node.js HTTP request is received from outside. (Vercel, AWS Lambda, etc.)
+   */
   protected readonly onNodeRequest: alepha19.HookPrimitive<"node:request">;
   /**
-       * When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
-       */
+   * When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
+   */
   protected readonly onWebRequest: alepha19.HookPrimitive<"web:request">;
   /**
-       * Handle Node.js HTTP request event.
-       *
-       * Optimized to avoid expensive URL parsing when possible.
-       */
+   * Handle Node.js HTTP request event.
+   *
+   * Optimized to avoid expensive URL parsing when possible.
+   */
   handleNodeRequest(nodeRequestEvent: NodeRequestEvent): Promise<void>;
   /**
-       * Handle Web (Fetch API) request event.
-       */
+   * Handle Web (Fetch API) request event.
+   */
   handleWebRequest(ev: WebRequestEvent): Promise<void>;
   /**
-       * Helper for Vite development mode to let Vite handle (or not) 404.
-       */
+   * Helper for Vite development mode to let Vite handle (or not) 404.
+   */
   protected isViteNotFound(url?: string, route?: Route, params?: Record<string, string>): boolean;
 }
 //#endregion
 //#region ../../src/server/core/services/HttpClient.d.ts
 declare class HttpClient {
-  protected readonly log: alepha_logger4.Logger;
+  protected readonly log: alepha_logger6.Logger;
   protected readonly alepha: Alepha;
   readonly cache: alepha_cache0.CachePrimitiveFn<HttpClientCache, any[]>;
   protected readonly pendingRequests: HttpClientPendingRequests;
@@ -431,18 +427,18 @@ declare class HttpClient {
 }
 interface FetchOptions<T extends TSchema = TSchema> {
   /**
-       * Key to identify the request in the pending requests.
-       */
+   * Key to identify the request in the pending requests.
+   */
   key?: string;
   /**
-       * The schema to validate the response against.
-       */
+   * The schema to validate the response against.
+   */
   schema?: {
     response?: T;
   };
   /**
-       * Built-in cache options.
-       */
+   * Built-in cache options.
+   */
   localCache?: boolean | number | DurationLike;
 }
 type RequestInitWithOptions<T extends TSchema = TSchema> = RequestInit & FetchOptions<T>;
@@ -558,72 +554,72 @@ declare const $action: {
 };
 interface ActionPrimitiveOptions<TConfig extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
   /**
-       * Name of the action.
-       *
-       * - It will be used to generate the route path if `path` is not provided.
-       * - It will be used to generate the permission name if `security` is enabled.
-       */
+   * Name of the action.
+   *
+   * - It will be used to generate the route path if `path` is not provided.
+   * - It will be used to generate the permission name if `security` is enabled.
+   */
   name?: string;
   /**
-       * Group actions together.
-       *
-       * - If not provided, the service name containing the route will be used.
-       * - It will be used as Tag for documentation purposes.
-       * - It will be used for permission name generation if `security` is enabled.
-       *
-       * @example
-       * ```ts
-       * // group = "MyController"
-       * class MyController {
-       * 	hello = $action({ handler: () => "Hello World" });
-       * }
-       *
-       * // group = "users"
-       * class MyOtherController {
-       *   group = "users";
-       *   a1 = $action({ handler: () => "Action 1", group: this.group });
-       *   a2 = $action({ handler: () => "Action 2", group: this.group });
-       * }
-       * ```
-       */
+   * Group actions together.
+   *
+   * - If not provided, the service name containing the route will be used.
+   * - It will be used as Tag for documentation purposes.
+   * - It will be used for permission name generation if `security` is enabled.
+   *
+   * @example
+   * ```ts
+   * // group = "MyController"
+   * class MyController {
+   * 	hello = $action({ handler: () => "Hello World" });
+   * }
+   *
+   * // group = "users"
+   * class MyOtherController {
+   *   group = "users";
+   *   a1 = $action({ handler: () => "Action 1", group: this.group });
+   *   a2 = $action({ handler: () => "Action 2", group: this.group });
+   * }
+   * ```
+   */
   group?: string;
   /**
-       * Pathname of the route. If not provided, property key is used.
-       */
+   * Pathname of the route. If not provided, property key is used.
+   */
   path?: string;
   /**
-       * The route method.
-       *
-       * - If not provided, it will be set to "GET" by default.
-       * - If not provider and a body is provided, it will be set to "POST".
-       *
-       * Wildcard methods are not supported for now. (e.g. "ALL", "ANY", etc.)
-       */
+   * The route method.
+   *
+   * - If not provided, it will be set to "GET" by default.
+   * - If not provider and a body is provided, it will be set to "POST".
+   *
+   * Wildcard methods are not supported for now. (e.g. "ALL", "ANY", etc.)
+   */
   method?: RouteMethod;
   /**
-       * The config schema of the route.
-       * - body: The request body schema.
-       * - params: Path variables schema.
-       * - query: The request query-params schema.
-       * - response: The response schema.
-       */
+   * The config schema of the route.
+   * - body: The request body schema.
+   * - params: Path variables schema.
+   * - query: The request query-params schema.
+   * - response: The response schema.
+   */
   schema?: TConfig;
   /**
-       * A short description of the action. Used for documentation purposes.
-       */
+   * A short description of the action. Used for documentation purposes.
+   */
   description?: string;
   /**
-       * Disable the route. Useful with env variables do disable one specific route.
-       * Route won't be available in the API but can still be called locally!
-       */
+   * Disable the route. Useful with env variables do disable one specific route.
+   * Route won't be available in the API but can still be called locally!
+   */
   disabled?: boolean;
   /**
-       * Main route handler. This is where the route logic is implemented.
-       */
+   * Main route handler. This is where the route logic is implemented.
+   */
   handler: ServerActionHandler<TConfig>;
 }
 declare class ActionPrimitive<TConfig extends RequestConfigSchema> extends Primitive<ActionPrimitiveOptions<TConfig>> {
-  protected readonly log: alepha_logger4.Logger;
+  protected readonly log: alepha_logger6.Logger;
   protected readonly env: {
     SERVER_API_PREFIX: string;
   };
@@ -634,33 +630,33 @@ declare class ActionPrimitive<TConfig extends RequestConfigSchema> extends Primi
   get prefix(): string;
   get route(): ServerRoute;
   /**
-       * Returns the name of the action.
-       */
+   * Returns the name of the action.
+   */
   get name(): string;
   /**
-       * Returns the group of the action. (e.g. "orders", "admin", etc.)
-       */
+   * Returns the group of the action. (e.g. "orders", "admin", etc.)
+   */
   get group(): string;
   /**
-       * Returns the HTTP method of the action.
-       */
+   * Returns the HTTP method of the action.
+   */
   get method(): RouteMethod;
   /**
-       * Returns the path of the action.
-       *
-       * Path is prefixed by `/api` by default.
-       */
+   * Returns the path of the action.
+   *
+   * Path is prefixed by `/api` by default.
+   */
   get path(): string;
   get schema(): TConfig | undefined;
   getBodyContentType(): string | undefined;
   /**
-       * Call the action handler directly.
-       * There is no HTTP layer involved.
-       */
+   * Call the action handler directly.
+   * There is no HTTP layer involved.
+   */
   run(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
   /**
-       * Works like `run`, but always fetches (http request) the route.
-       */
+   * Works like `run`, but always fetches (http request) the route.
+   */
   fetch(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
 }
 interface ActionPrimitiveFn<TConfig extends RequestConfigSchema> extends ActionPrimitive<TConfig> {
@@ -675,8 +671,8 @@ type ClientRequestEntryContainer<TConfig extends RequestConfigSchema> = {
 };
 interface ClientRequestOptions extends FetchOptions {
   /**
-       * Standard request fetch options.
-       */
+   * Standard request fetch options.
+   */
   request?: RequestInit;
 }
 type ClientRequestResponse<TConfig extends RequestConfigSchema> = TConfig["response"] extends TSchema ? Static<TConfig["response"]> : any;
@@ -771,7 +767,7 @@ declare module "alepha" {
 declare class BunHttpServerProvider extends ServerProvider {
   protected readonly alepha: Alepha;
   protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly log: alepha_logger4.Logger;
+  protected readonly log: alepha_logger6.Logger;
   protected readonly env: {
     SERVER_PORT: number;
     SERVER_HOST: string;
@@ -796,14 +792,27 @@ declare module "alepha" {
 declare class NodeHttpServerProvider extends ServerProvider {
   protected readonly alepha: Alepha;
   protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly log: alepha_logger4.Logger;
+  protected readonly log: alepha_logger6.Logger;
   protected readonly env: {
     SERVER_PORT: number;
     SERVER_HOST: string;
   };
   protected readonly router: ServerRouterProvider;
+  /** Track active connections for fast shutdown */
+  protected readonly connections: Set<Socket>;
+  /** Get number of active connections */
+  getConnectionsCount(): number;
+  /** Server options */
+  readonly options: {
+    /**
+     * Graceful shutdown timeout in ms.
+     * After this, remaining connections are forcefully closed.
+     * @default 30000
+     */
+    shutdownTimeout: number;
+  };
   get hostname(): string;
-  protected readonly handleRequestError: (res: node_http0.ServerResponse, err: Error) => void;
+  protected readonly handleRequestError: (res: ServerResponse$1, err: Error) => void;
   protected readonly nodeRequestEvent: {
     req: IncomingMessage;
     res: ServerResponse$1;
@@ -814,11 +823,12 @@ declare class NodeHttpServerProvider extends ServerProvider {
   protected readonly stop: alepha19.HookPrimitive<"stop">;
   protected listen(): Promise<void>;
   protected close(): Promise<void>;
+  protected destroyAllConnections(): void;
 }
 //#endregion
 //#region ../../src/server/core/providers/ServerLoggerProvider.d.ts
 declare class ServerLoggerProvider {
-  protected readonly log: alepha_logger4.Logger;
+  protected readonly log: alepha_logger6.Logger;
   protected readonly alepha: Alepha;
   readonly onRequest: alepha19.HookPrimitive<"server:onRequest">;
   readonly onError: alepha19.HookPrimitive<"server:onError">;