alepha 0.8.1 → 0.9.1

package/server.d.ts

@@ -1,22 +1,21 @@
 import * as _alepha_core1 from "alepha";
-import * as _alepha_core3 from "alepha";
-import * as _alepha_core7 from "alepha";
-import * as _alepha_core8 from "alepha";
-import * as _alepha_core12 from "alepha";
-import * as _alepha_core15 from "alepha";
-import * as _alepha_core24 from "alepha";
-import { Alepha, Async, FileLike, KIND, Module, OPTIONS, Static, StreamLike, TObject, TSchema } from "alepha";
-import { JwtProvider, Permission, SecurityProvider, ServiceAccountDescriptor, UserAccountToken } from "alepha/security";
-import * as _alepha_cache2 from "alepha/cache";
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core2 from "alepha";
+import * as _alepha_core9 from "alepha";
+import * as _alepha_core13 from "alepha";
+import * as _alepha_core14 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha, Async, Descriptor, FileLike, KIND, Static, StreamLike, TObject, TSchema } from "alepha";
 import { Readable } from "node:stream";
 import { ReadableStream } from "node:stream/web";
 import { Route, RouterProvider } from "alepha/router";
+import * as _alepha_cache0 from "alepha/cache";
 import { IncomingMessage, ServerResponse as ServerResponse$1 } from "node:http";
-import { DurationLike } from "alepha/datetime";
-import * as _sinclair_typebox38 from "@sinclair/typebox";
-import * as _sinclair_typebox64 from "@sinclair/typebox";
-import * as _sinclair_typebox30 from "@sinclair/typebox";
-import * as http20 from "http";
+import { DateTimeProvider, DurationLike } from "alepha/datetime";
+import * as _sinclair_typebox0 from "@sinclair/typebox";
+import * as _sinclair_typebox33 from "@sinclair/typebox";
+import * as _sinclair_typebox25 from "@sinclair/typebox";
+import * as http0 from "http";
 
 //#region src/constants/routeMethods.d.ts
 declare const routeMethods: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "CONNECT", "TRACE"];
@@ -36,7 +35,7 @@ declare class ServerReply {
 }
 //# sourceMappingURL=ServerReply.d.ts.map
 //#endregion
-//#region src/interfaces/index.d.ts
+//#region src/interfaces/ServerRequest.d.ts
 interface RequestConfigSchema {
   body?: TSchema;
   params?: TObject;
@@ -62,20 +61,15 @@ interface ServerRequest<TConfig extends RequestConfigSchema = RequestConfigSchem
       res: ServerResponse$1;
     };
   };
-  user: UserAccountToken;
 }
 interface ServerRoute<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Route {
-  method?: RouteMethod;
   handler: ServerHandler<TConfig>;
+  method?: RouteMethod;
   schema?: TConfig;
   /**
    * @see ServerLoggerProvider
    */
   silent?: boolean;
-  /**
-   * @see ServerSecurityProvider
-   */
-  secure?: ServerRouteSecure;
 }
 type ServerResponseBody<TConfig extends RequestConfigSchema = RequestConfigSchema> = TConfig["response"] extends TSchema ? Static<TConfig["response"]> : ResponseBodyType;
 type ResponseKind = "json" | "text" | "void" | "file" | "any";
@@ -87,7 +81,7 @@ interface ServerResponse {
   headers: Record<string, string>;
   status: number;
 }
-interface ServerRouteWithHandler extends Route {
+interface ServerRouteMatcher extends Route {
   handler: (request: ServerRawRequest) => Promise<ServerResponse>;
 }
 interface ServerRawRequest {
@@ -103,39 +97,53 @@ interface ServerRawRequest {
     };
   };
 }
-type ServerRouteSecure = boolean | {
-  permissions?: string[];
-  roles?: string[];
-  realms?: string[];
-  organizations?: string[];
-};
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=ServerRequest.d.ts.map
+//#endregion
+//#region src/providers/ServerProvider.d.ts
+declare abstract class ServerProvider {
+  protected readonly alepha: Alepha;
+  abstract get hostname(): string;
+  protected isViteNotFound(url?: string, route?: Route, params?: Record<string, string>): boolean;
+}
+//# sourceMappingURL=ServerProvider.d.ts.map
+
 //#endregion
-//#region src/helpers/ActionDescriptorHelper.d.ts
-declare class ActionDescriptorHelper {
-  name(options: ActionDescriptorOptions, instance: any, key: string): string;
-  path(options: ActionDescriptorOptions, _instance: any, key: string): string;
-  method(options: {
-    method?: string;
-    schema?: any;
-  }): RouteMethod;
-  permission(options: ActionDescriptorOptions, instance: any, key: string): Permission;
-  group(options: ActionDescriptorOptions, instance: any): string;
-  isMultipart(options: {
+//#region src/providers/ServerRouterProvider.d.ts
+/**
+ * Main router for all routes on the server side.
+ *
+ * - $route => generic route
+ * - $action => action route (for API calls)
+ * - $page => React route (for SSR)
+ */
+declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
+  protected readonly alepha: Alepha;
+  protected readonly routes: ServerRoute[];
+  getRoutes(): ServerRoute[];
+  createRoute<TConfig extends RequestConfigSchema = RequestConfigSchema>(route: ServerRoute<TConfig>): void;
+  onRequest(route: ServerRoute, rawRequest: ServerRawRequest, responseKind: ResponseKind): Promise<ServerResponse>;
+  protected processRequest(request: ServerRequest, route: ServerRoute, responseKind: ResponseKind): Promise<{
+    status: number;
+    headers: Record<string, string> & {
+      "set-cookie"?: string[];
+    };
+    body: any;
+  }>;
+  protected runRouteHandler(route: ServerRoute, request: ServerRequest, responseKind: ResponseKind): Promise<void>;
+  protected getResponseType(schema?: RequestConfigSchema): ResponseKind;
+  protected errorHandler(route: ServerRoute, request: ServerRequest, error: Error): Promise<void>;
+  validateRequest(route: {
     schema?: RequestConfigSchema;
-  }): boolean;
-  bodyContentType(options: ActionDescriptorOptions): string | undefined;
-  protected short(name: string): string;
-  fetchLinks(_url: string): void;
+  }, request: ServerRequestConfig): void;
+  serializeResponse(route: ServerRoute, reply: ServerReply, responseKind: ResponseKind): void;
 }
-//# sourceMappingURL=ActionDescriptorHelper.d.ts.map
+//# sourceMappingURL=ServerRouterProvider.d.ts.map
 //#endregion
 //#region src/services/HttpClient.d.ts
 declare class HttpClient {
   protected readonly log: _alepha_core1.Logger;
   protected readonly alepha: Alepha;
-  protected readonly helper: ActionDescriptorHelper;
-  readonly cache: _alepha_cache2.CacheDescriptor<HttpClientCache, any[]>;
+  readonly cache: _alepha_cache0.CacheDescriptorFn<HttpClientCache, any[]>;
   protected readonly pendingRequests: HttpClientPendingRequests;
   clear(): Promise<void>;
   fetchAction(args: FetchActionArgs): Promise<FetchResponse>;
@@ -204,43 +212,69 @@ interface HttpAction {
 }
 //#endregion
 //#region src/descriptors/$action.d.ts
-declare const KEY$1 = "ACTION";
+/**
+ * Create an action endpoint.
+ *
+ * By default, all actions are prefixed by `/api`.
+ * If `name` is not provided, the action will be named after the property key.
+ * If `path` is not provided, the action will be named after the function name.
+ *
+ * @example
+ * ```ts
+ * class MyController {
+ *   hello = $action({
+ *     handler: () => "Hello World",
+ *   })
+ * }
+ * // GET /api/hello -> "Hello World"
+ * ```
+ */
 declare const $action: {
   <TConfig extends RequestConfigSchema>(options: ActionDescriptorOptions<TConfig>): ActionDescriptor<TConfig>;
-  [KIND]: string;
+  [KIND]: typeof ActionDescriptor;
 };
-interface ActionDescriptorOptions<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema"> {
+interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
   /**
-   * Name the route.
+   * 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;
   /**
-   * Namespace of the route, used for grouping.
+   * Group actions together.
    *
-   * @default Class name containing the route.
-   */
-  group?: string;
-  /**
-   * If false, disabled the security check for this route.
+   * - 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" });
+   * }
    *
-   * @default true when SecurityModule is enabled, false otherwise.
-   * @deprecated
+   * // group = "users"
+   * class MyOtherController {
+   *   group = "users";
+   *   a1 = $action({ handler: () => "Action 1", group: this.group });
+   *   a2 = $action({ handler: () => "Action 2", group: this.group });
+   * }
+   * ```
    */
-  security?: boolean;
+  group?: string;
   /**
-   * Pathname of the route.
+   * Pathname of the route. If not provided, property key is used.
    */
   path?: string;
-  /**
-   * Inherit options from another route.
-   */
-  use?: {
-    [OPTIONS]: ActionDescriptorOptions<TConfig>;
-  };
   /**
    * The route method.
    *
-   * @default "GET" or "POST" when schema body is defined.
+   * - 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;
   /**
@@ -252,66 +286,87 @@ interface ActionDescriptorOptions<TConfig extends RequestConfigSchema = RequestC
    */
   schema?: TConfig;
   /**
-   * Short description of the route.
-   */
-  summary?: string;
-  /**
-   * Long description of the route.
+   * 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!
    */
   disabled?: boolean;
-  /**
-   * Mark the route as private.
-   * - It won't be exposed in the API documentation.
-   * - It won't be exposed in _links.
-   */
-  internal?: boolean;
   /**
    * Main route handler. This is where the route logic is implemented.
    */
-  handler?: ServerHandler<TConfig>;
+  handler: ServerActionHandler<TConfig>;
 }
-interface ActionDescriptor<TConfig extends RequestConfigSchema = RequestConfigSchema> {
-  [KIND]: typeof KEY$1;
-  [OPTIONS]: ActionDescriptorOptions<TConfig>;
+declare class ActionDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<ActionDescriptorOptions<TConfig>> {
+  protected readonly log: _alepha_core0$1.Logger;
+  protected readonly env: {
+    SERVER_API_PREFIX: string;
+  };
+  protected readonly httpClient: HttpClient;
+  protected readonly serverProvider: ServerProvider;
+  protected readonly serverRouterProvider: ServerRouterProvider;
+  protected onInit(): void;
+  get prefix(): string;
+  get route(): ServerRoute;
+  /**
+   * Returns the name of the action.
+   */
+  get name(): string;
   /**
-   * Fetch or just call local route when available.
+   * Returns the group of the action. (e.g. "orders", "admin", etc.)
    */
-  (config?: ClientRequestEntry<TConfig>, opts?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
+  get group(): string;
   /**
-   * Just fetch the route. Skip any local route.
+   * Returns the HTTP method of the action.
+   */
+  get method(): RouteMethod;
+  /**
+   * Returns the path of the action.
+   *
+   * Path is prefixed by `/api` by default.
    */
-  fetch: (config?: ClientRequestEntry<TConfig>, opts?: ClientRequestOptions) => Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
+  get path(): string;
+  get schema(): TConfig | undefined;
+  getBodyContentType(): string | undefined;
   /**
-   * Name of the permission required to access this route.
+   * Call the action handler directly.
+   * There is no HTTP layer involved.
    */
-  permission: () => string;
+  run(config: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
+  /**
+   * Works like `run`, but always fetches (http request) the route.
+   */
+  fetch(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
 }
-type ClientRequestEntry<TConfig extends RequestConfigSchema = RequestConfigSchema, T = ClientRequestEntryContainer<TConfig>> = { [K in keyof T as T[K] extends undefined ? never : K]: T[K] };
-type ClientRequestEntryContainer<TConfig extends RequestConfigSchema = RequestConfigSchema> = {
+type ClientRequestEntry<TConfig extends RequestConfigSchema, T = ClientRequestEntryContainer<TConfig>> = { [K in keyof T as T[K] extends undefined ? never : K]: T[K] };
+type ClientRequestEntryContainer<TConfig extends RequestConfigSchema> = {
   body: TConfig["body"] extends TSchema ? Static<TConfig["body"]> : undefined;
   params: TConfig["params"] extends TSchema ? Static<TConfig["params"]> : undefined;
   headers?: TConfig["headers"] extends TSchema ? Static<TConfig["headers"]> : undefined;
   query?: TConfig["query"] extends TSchema ? Partial<Static<TConfig["query"]>> : undefined;
 };
 interface ClientRequestOptions extends FetchOptions {
-  /**
-   * Forward user from the previous request.
-   * If "system", use system user. @see {ServerSecurityProvider.localSystemUser}
-   * If "context", use the user from the current context (e.g. request).
-   *
-   * @default "system" is provided, else "context" is used.
-   */
-  user?: UserAccountToken | "system" | "context";
   /**
    * Standard request fetch options.
    */
   request?: RequestInit;
 }
 type ClientRequestResponse<TConfig extends RequestConfigSchema> = TConfig["response"] extends TSchema ? Static<TConfig["response"]> : any;
+/**
+ * Specific handler for server actions.
+ */
+type ServerActionHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerActionRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
+/**
+ * Server Action Request Interface
+ *
+ * Can be extended with module augmentation to add custom properties (like `user` in Server Security).
+ *
+ * This is NOT Server Request, but a specific type for actions.
+ */
+interface ServerActionRequest<TConfig extends RequestConfigSchema> extends ServerRequest<TConfig> {}
+//# sourceMappingURL=$action.d.ts.map
 //#endregion
 //#region src/errors/HttpError.d.ts
 declare class HttpError extends Error {
@@ -353,16 +408,24 @@ interface HttpErrorLike extends Error {
 //# sourceMappingURL=HttpError.d.ts.map
 //#endregion
 //#region src/descriptors/$route.d.ts
-declare const KEY = "ROUTE";
+/**
+ * Create a basic endpoint.
+ *
+ * It's a low level descriptor. You probably want to use `$action` instead.
+ *
+ * @see {@link $action}
+ * @see {@link $page}
+ */
 declare const $route: {
-  <TConfig extends RequestConfigSchema = RequestConfigSchema>(options: RouteDescriptorOptions<TConfig>): RouteDescriptor<TConfig>;
-  [KIND]: string;
+  <TConfig extends RequestConfigSchema>(options: RouteDescriptorOptions<TConfig>): RouteDescriptor<TConfig>;
+  [KIND]: typeof RouteDescriptor;
 };
 interface RouteDescriptorOptions<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRoute<TConfig> {}
-type RouteDescriptor<TConfig extends RequestConfigSchema = RequestConfigSchema> = {
-  [KIND]: typeof KEY;
-  [OPTIONS]: RouteDescriptorOptions<TConfig>;
-};
+declare class RouteDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<RouteDescriptorOptions<TConfig>> {
+  protected readonly serverRouterProvider: ServerRouterProvider;
+  protected onInit(): void;
+}
+//# sourceMappingURL=$route.d.ts.map
 //#endregion
 //#region src/errors/BadRequestError.d.ts
 declare class BadRequestError extends HttpError {
@@ -400,24 +463,30 @@ declare class ValidationError extends HttpError {
 }
 //# sourceMappingURL=ValidationError.d.ts.map
 //#endregion
+//#region src/helpers/isMultipart.d.ts
+declare const isMultipart: (options: {
+  schema?: RequestConfigSchema;
+}) => boolean;
+//# sourceMappingURL=isMultipart.d.ts.map
+//#endregion
 //#region src/schemas/apiLinksResponseSchema.d.ts
-declare const apiLinkSchema: _sinclair_typebox38.TObject<{
-  name: _sinclair_typebox38.TString;
-  path: _sinclair_typebox38.TString;
-  method: _sinclair_typebox38.TOptional<_sinclair_typebox38.TString>;
-  group: _sinclair_typebox38.TOptional<_sinclair_typebox38.TString>;
-  requestBodyType: _sinclair_typebox38.TOptional<_sinclair_typebox38.TString>;
-  service: _sinclair_typebox38.TOptional<_sinclair_typebox38.TString>;
+declare const apiLinkSchema: _sinclair_typebox0.TObject<{
+  name: _sinclair_typebox0.TString;
+  path: _sinclair_typebox0.TString;
+  method: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+  group: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+  requestBodyType: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+  service: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
 }>;
-declare const apiLinksResponseSchema: _sinclair_typebox38.TObject<{
-  prefix: _sinclair_typebox38.TOptional<_sinclair_typebox38.TString>;
-  links: _sinclair_typebox38.TArray<_sinclair_typebox38.TObject<{
-    name: _sinclair_typebox38.TString;
-    path: _sinclair_typebox38.TString;
-    method: _sinclair_typebox38.TOptional<_sinclair_typebox38.TString>;
-    group: _sinclair_typebox38.TOptional<_sinclair_typebox38.TString>;
-    requestBodyType: _sinclair_typebox38.TOptional<_sinclair_typebox38.TString>;
-    service: _sinclair_typebox38.TOptional<_sinclair_typebox38.TString>;
+declare const apiLinksResponseSchema: _sinclair_typebox0.TObject<{
+  prefix: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+  links: _sinclair_typebox0.TArray<_sinclair_typebox0.TObject<{
+    name: _sinclair_typebox0.TString;
+    path: _sinclair_typebox0.TString;
+    method: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+    group: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+    requestBodyType: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+    service: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
   }>>;
 }>;
 type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
@@ -425,38 +494,67 @@ type ApiLink = Static<typeof apiLinkSchema>;
 //# sourceMappingURL=apiLinksResponseSchema.d.ts.map
 //#endregion
 //#region src/schemas/errorSchema.d.ts
-declare const errorSchema: _sinclair_typebox64.TObject<{
-  error: _sinclair_typebox64.TString;
-  status: _sinclair_typebox64.TNumber;
-  message: _sinclair_typebox64.TString;
-  details: _sinclair_typebox64.TOptional<_sinclair_typebox64.TString>;
-  cause: _sinclair_typebox64.TOptional<_sinclair_typebox64.TObject<{
-    name: _sinclair_typebox64.TString;
-    message: _sinclair_typebox64.TString;
+declare const errorSchema: _sinclair_typebox33.TObject<{
+  error: _sinclair_typebox33.TString;
+  status: _sinclair_typebox33.TNumber;
+  message: _sinclair_typebox33.TString;
+  details: _sinclair_typebox33.TOptional<_sinclair_typebox33.TString>;
+  cause: _sinclair_typebox33.TOptional<_sinclair_typebox33.TObject<{
+    name: _sinclair_typebox33.TString;
+    message: _sinclair_typebox33.TString;
   }>>;
 }>;
 //# sourceMappingURL=errorSchema.d.ts.map
 //#endregion
 //#region src/schemas/okSchema.d.ts
-declare const okSchema: _sinclair_typebox30.TObject<{
-  ok: _sinclair_typebox30.TBoolean;
-  id: _sinclair_typebox30.TOptional<_sinclair_typebox30.TUnion<[_sinclair_typebox30.TString, _sinclair_typebox30.TInteger]>>;
-  count: _sinclair_typebox30.TOptional<_sinclair_typebox30.TNumber>;
+declare const okSchema: _sinclair_typebox25.TObject<{
+  ok: _sinclair_typebox25.TBoolean;
+  id: _sinclair_typebox25.TOptional<_sinclair_typebox25.TUnion<[_sinclair_typebox25.TString, _sinclair_typebox25.TInteger]>>;
+  count: _sinclair_typebox25.TOptional<_sinclair_typebox25.TNumber>;
 }>;
 type Ok = Static<typeof okSchema>;
 //# sourceMappingURL=okSchema.d.ts.map
 //#endregion
-//#region src/providers/features/ServerLoggerProvider.d.ts
+//#region src/providers/NodeHttpServerProvider.d.ts
+declare const envSchema: _alepha_core2.TObject<{
+  SERVER_PORT: _alepha_core2.TNumber;
+  SERVER_HOST: _alepha_core2.TString;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema>> {}
+}
+declare class NodeHttpServerProvider extends ServerProvider {
+  protected readonly alepha: Alepha;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly log: _alepha_core2.Logger;
+  protected readonly env: {
+    SERVER_PORT: number;
+    SERVER_HOST: string;
+  };
+  protected readonly router: ServerRouterProvider;
+  protected readonly server: http0.Server<typeof IncomingMessage, typeof ServerResponse$1>;
+  protected readonly onNodeRequest: _alepha_core2.HookDescriptor<"node:request">;
+  handle(req: IncomingMessage, res: ServerResponse$1): Promise<void>;
+  createRouterRequest(req: IncomingMessage, res: ServerResponse$1, params?: Record<string, string>): ServerRawRequest;
+  getProtocol(req: IncomingMessage): "http" | "https";
+  get hostname(): string;
+  readonly start: _alepha_core2.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core2.HookDescriptor<"stop">;
+  protected listen(): Promise<void>;
+  protected close(): Promise<void>;
+}
+//#endregion
+//#region src/providers/ServerLoggerProvider.d.ts
 declare class ServerLoggerProvider {
-  protected readonly log: _alepha_core3.Logger;
+  protected readonly log: _alepha_core9.Logger;
   protected readonly alepha: Alepha;
-  readonly onRequest: _alepha_core3.HookDescriptor<"server:onRequest">;
-  readonly onError: _alepha_core3.HookDescriptor<"server:onError">;
-  readonly onResponse: _alepha_core3.HookDescriptor<"server:onResponse">;
+  readonly onRequest: _alepha_core9.HookDescriptor<"server:onRequest">;
+  readonly onError: _alepha_core9.HookDescriptor<"server:onError">;
+  readonly onResponse: _alepha_core9.HookDescriptor<"server:onResponse">;
 }
 //# sourceMappingURL=ServerLoggerProvider.d.ts.map
 //#endregion
-//#region src/providers/features/ServerNotReadyProvider.d.ts
+//#region src/providers/ServerNotReadyProvider.d.ts
 /**
  * On every request, this provider checks if the server is ready.
  *
@@ -466,182 +564,30 @@ declare class ServerLoggerProvider {
  */
 declare class ServerNotReadyProvider {
   protected readonly alepha: Alepha;
-  readonly onRequest: _alepha_core7.HookDescriptor<"server:onRequest">;
+  readonly onRequest: _alepha_core13.HookDescriptor<"server:onRequest">;
 }
 //# sourceMappingURL=ServerNotReadyProvider.d.ts.map
 //#endregion
-//#region src/providers/features/ServerSecurityProvider.d.ts
-declare class ServerSecurityProvider {
-  protected readonly log: _alepha_core8.Logger;
-  protected readonly securityProvider: SecurityProvider;
-  protected readonly jwtProvider: JwtProvider;
-  protected readonly alepha: Alepha;
-  readonly onClientRequest: _alepha_core8.HookDescriptor<"client:onRequest">;
-  protected readonly onRequest: _alepha_core8.HookDescriptor<"server:onRequest">;
-  protected readonly onRoute: _alepha_core8.HookDescriptor<"server:onRoute">;
-}
-//# sourceMappingURL=ServerSecurityProvider.d.ts.map
-//#endregion
-//#region src/providers/features/ServerTimingProvider.d.ts
+//#region src/providers/ServerTimingProvider.d.ts
 type TimingMap = Record<string, [number, number]>;
 declare class ServerTimingProvider {
-  protected readonly log: _alepha_core12.Logger;
+  protected readonly log: _alepha_core14.Logger;
   protected readonly alepha: Alepha;
-  readonly onRequest: _alepha_core12.HookDescriptor<"server:onRequest">;
-  readonly onResponse: _alepha_core12.HookDescriptor<"server:onResponse">;
+  readonly onRequest: _alepha_core14.HookDescriptor<"server:onRequest">;
+  readonly onResponse: _alepha_core14.HookDescriptor<"server:onResponse">;
   protected get handlerName(): string;
   beginTiming(name: string): void;
   endTiming(name: string): void;
   protected setDuration(name: string, timing: TimingMap): void;
 }
 //#endregion
-//#region src/providers/ServerRouterProvider.d.ts
-/**
- * Main router for all routes on the server side.
- *
- * - $route => generic route
- * - $action => action route (for API calls)
- * - $page => React route (for SSR)
- */
-declare class ServerRouterProvider extends RouterProvider<ServerRouteWithHandler> {
-  protected readonly alepha: Alepha;
-  route<TConfig extends RequestConfigSchema = RequestConfigSchema>(route: ServerRoute<TConfig>): Promise<void>;
-  onRequest(route: ServerRoute, rawRequest: ServerRawRequest, responseKind: ResponseKind): Promise<ServerResponse>;
-  protected processRequest(request: ServerRequest, route: ServerRoute, responseKind: ResponseKind): Promise<{
-    status: number;
-    headers: Record<string, string> & {
-      "set-cookie"?: string[];
-    };
-    body: any;
-  }>;
-  protected runRouteHandler(route: ServerRoute, request: ServerRequest, responseKind: ResponseKind): Promise<void>;
-  protected getResponseType(schema?: RequestConfigSchema): ResponseKind;
-  protected errorHandler(route: ServerRoute, request: ServerRequest, error: Error): Promise<void>;
-  validateRequest(route: {
-    schema?: RequestConfigSchema;
-  }, request: ServerRequestConfig): void;
-  serializeResponse(route: ServerRoute, reply: ServerReply, responseKind: ResponseKind): void;
-}
-//# sourceMappingURL=ServerRouterProvider.d.ts.map
-//#endregion
-//#region src/providers/platforms/ServerProvider.d.ts
-declare abstract class ServerProvider {
-  protected readonly alepha: Alepha;
-  abstract get hostname(): string;
-  protected isViteNotFound(url?: string, route?: Route, params?: Record<string, string>): boolean;
-}
-//# sourceMappingURL=ServerProvider.d.ts.map
-//#endregion
-//#region src/providers/platforms/NodeHttpServerProvider.d.ts
-declare const envSchema$1: _alepha_core15.TObject<{
-  SERVER_PORT: _alepha_core15.TNumber;
-  SERVER_HOST: _alepha_core15.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$1>> {}
-}
-declare class NodeHttpServerProvider extends ServerProvider {
-  protected readonly alepha: Alepha;
-  protected readonly log: _alepha_core15.Logger;
-  protected readonly env: {
-    SERVER_PORT: number;
-    SERVER_HOST: string;
-  };
-  protected readonly router: ServerRouterProvider;
-  protected readonly server: http20.Server<typeof IncomingMessage, typeof ServerResponse$1>;
-  protected readonly onNodeRequest: _alepha_core15.HookDescriptor<"node:request">;
-  handle(req: IncomingMessage, res: ServerResponse$1): Promise<void>;
-  createRouterRequest(req: IncomingMessage, res: ServerResponse$1, params?: Record<string, string>): ServerRawRequest;
-  getProtocol(req: IncomingMessage): "http" | "https";
-  get hostname(): string;
-  readonly start: _alepha_core15.HookDescriptor<"start">;
-  protected readonly stop: _alepha_core15.HookDescriptor<"stop">;
-  protected listen(): Promise<void>;
-  protected close(): Promise<void>;
-}
-//#endregion
-//#region src/providers/ServerActionDescriptorProvider.d.ts
-declare const envSchema: _alepha_core24.TObject<{
-  SERVER_API_PREFIX: _alepha_core24.TString;
-  SERVER_SECURITY_ENABLED: _alepha_core24.TBoolean;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema>> {}
-  interface State {
-    /**
-     * Real (or fake) user account, used for internal actions.
-     * If you define this, you assume that all actions are executed by this user by default.
-     * And to force a different user, you need to pass it explicitly in the options.
-     */
-    "ServerSecurityProvider.localSystemUser"?: UserAccountToken;
-  }
-}
-declare class ServerActionDescriptorProvider {
-  protected readonly log: _alepha_core24.Logger;
-  protected readonly alepha: Alepha;
-  protected readonly env: {
-    SERVER_API_PREFIX: string;
-    SERVER_SECURITY_ENABLED: boolean;
-  };
-  protected readonly client: HttpClient;
-  protected readonly serverProvider: ServerProvider;
-  protected readonly helper: ActionDescriptorHelper;
-  protected readonly routerProvider: ServerRouterProvider;
-  protected readonly actions: ServerRouteAction[];
-  getActions(): ServerRouteAction<RequestConfigSchema>[];
-  getPrefix(): string;
-  readonly configure: _alepha_core24.HookDescriptor<"configure">;
-  registerAction(value: ActionDescriptor, key: string, instance: any, prefix?: string): Promise<void>;
-  /**
-   * Check a mock function for the specified route.
-   *
-   * This is mostly used for testing purposes.
-   */
-  protected createLocalHandler(action: ActionDescriptorOptions, permission: Permission): (config?: ServerRequestConfigEntry, options?: ClientRequestOptions) => Promise<any>;
-  /**
-   * Get the user account token for a local action call.
-   * It will check the options, context, and system user.
-   */
-  protected getUserFromLocalFunctionContext(options: {
-    user?: UserAccountToken | "system" | "context";
-  }, permission: Permission, isRouteSecure: boolean): UserAccountToken | undefined;
-}
-declare const isServerAction: (value: any) => value is ServerRouteAction;
-interface ServerRemote {
-  url: string;
-  name: string;
-  proxy: boolean;
-  internal: boolean;
-  links: (args: {
-    authorization?: string;
-  }) => Promise<ApiLinksResponse>;
-  schema: (args: {
-    name: string;
-    authorization?: string;
-  }) => Promise<any>;
-  serviceAccount?: ServiceAccountDescriptor;
-  prefix: string;
-}
-interface ServerRouteAction<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRoute<TConfig> {
-  prefix: string;
-  method: RouteMethod;
-  name: string;
-  group: string;
-  permission: Permission;
-  options: ActionDescriptorOptions;
-  localHandler: LocalHandler;
-}
-type LocalHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (config?: ServerRequestConfigEntry<TConfig>, options?: ClientRequestOptions) => Promise<any>;
-//#endregion
 //#region src/index.d.ts
 declare module "alepha" {
   interface Hooks {
-    "node:request": {
-      req: IncomingMessage;
-      res: ServerResponse$1;
-    };
-    "server:onRoute": {
-      route: ServerRoute;
+    "action:onRequest": {
+      action: ActionDescriptor<RequestConfigSchema>;
+      request: ServerRequest;
+      options: ClientRequestOptions;
     };
     "server:onRequest": {
       route: ServerRoute;
@@ -677,6 +623,10 @@ declare module "alepha" {
       route?: HttpAction;
       error: HttpError;
     };
+    "node:request": {
+      req: IncomingMessage;
+      res: ServerResponse$1;
+    };
   }
 }
 /**
@@ -686,158 +636,13 @@ declare module "alepha" {
  * on class properties. It provides automatic request/response handling, schema validation, middleware support,
  * and seamless integration with other Alepha modules for a complete backend solution.
  *
- * **Key Features:**
- * - Declarative route definition with `$route` descriptor
- * - API action handlers with `$action` descriptor
- * - Schema validation for requests and responses
- * - Automatic body parsing and response formatting
- * - Built-in middleware system and error handling
- * - Type-safe request parameters and response data
- * - Integration with authentication and security modules
- *
- * **Basic Routing:**
- * ```ts
- * import { Alepha, run, t } from "alepha";
- * import { AlephaServer, $route } from "alepha/server";
- *
- * class ApiRoutes {
- *   // Simple GET route
- *   getUsers = $route({
- *     path: "/api/users",
- *     method: "GET",
- *     handler: async () => {
- *       const users = await getAllUsers();
- *       return Response.json(users);
- *     },
- *   });
- *
- *   // POST route with body validation
- *   createUser = $route({
- *     path: "/api/users",
- *     method: "POST",
- *     schema: {
- *       body: t.object({
- *         name: t.string(),
- *         email: t.string(),
- *       }),
- *     },
- *     handler: async ({ body }) => {
- *       const user = await createUser(body);
- *       return Response.json(user, { status: 201 });
- *     },
- *   });
- *
- *   // Dynamic route with parameters
- *   getUserById = $route({
- *     path: "/api/users/:id",
- *     method: "GET",
- *     schema: {
- *       params: t.object({
- *         id: t.string(),
- *       }),
- *     },
- *     handler: async ({ params }) => {
- *       const user = await findUserById(params.id);
- *       if (!user) {
- *         return new Response("User not found", { status: 404 });
- *       }
- *       return Response.json(user);
- *     },
- *   });
- * }
- *
- * const alepha = Alepha.create()
- *   .with(AlephaServer)
- *   .with(ApiRoutes);
- *
- * run(alepha);
- * ```
- *
- * **Action Descriptors:**
- * ```ts
- * import { $action } from "alepha/server";
- *
- * class UserController {
- *   // Reusable business logic action
- *   getUserProfile = $action({
- *     schema: {
- *       params: t.object({
- *         userId: t.string(),
- *       }),
- *       response: t.object({
- *         id: t.string(),
- *         name: t.string(),
- *         email: t.string(),
- *       }),
- *     },
- *     handler: async ({ params }) => {
- *       const user = await getUserById(params.userId);
- *       return {
- *         id: user.id,
- *         name: user.name,
- *         email: user.email,
- *       };
- *     },
- *   });
- *
- *   // Route that uses the action
- *   profileRoute = $route({
- *     path: "/api/profile/:userId",
- *     method: "GET",
- *     handler: async ({ params }) => {
- *       const profile = await this.getUserProfile({ params });
- *       return Response.json(profile);
- *     },
- *   });
- * }
- * ```
- *
- * **Middleware and Error Handling:**
- * ```ts
- * class AppServer {
- *   // Global middleware
- *   middleware = $route({
- *     path: "*",
- *     method: "*",
- *     handler: async ({ request, next }) => {
- *       console.log(`${request.method} ${request.url}`);
- *       try {
- *         return await next();
- *       } catch (error) {
- *         console.error("Request failed:", error);
- *         return Response.json({ error: "Internal Server Error" }, { status: 500 });
- *       }
- *     },
- *   });
- *
- *   // CORS preflight handling
- *   corsPrelight = $route({
- *     path: "*",
- *     method: "OPTIONS",
- *     handler: async () => {
- *       return new Response(null, {
- *         status: 200,
- *         headers: {
- *           "Access-Control-Allow-Origin": "*",
- *           "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE",
- *           "Access-Control-Allow-Headers": "Content-Type, Authorization",
- *         },
- *       });
- *     },
- *   });
- * }
- * ```
- *
  * @see {@link $route}
  * @see {@link $action}
  * @module alepha.server
  */
-declare class AlephaServer implements Module {
-  readonly name = "alepha.server";
-  readonly $services: (alepha: Alepha) => void;
-}
+declare const AlephaServer: _alepha_core0.ModuleDescriptor;
 //# sourceMappingURL=index.d.ts.map
 
 //#endregion
-export { $action, $route, ActionDescriptor, ActionDescriptorHelper, ActionDescriptorOptions, AlephaServer, ApiLink, ApiLinksResponse, BadRequestError, ClientRequestEntry, ClientRequestEntryContainer, ClientRequestOptions, ClientRequestResponse, ConflictError, FetchActionArgs, FetchOptions, FetchResponse, ForbiddenError, HttpAction, HttpClient, HttpClientPendingRequests, HttpError, HttpErrorLike, LocalHandler, NodeHttpServerProvider, NotFoundError, Ok, RequestConfigSchema, ResponseBodyType, ResponseKind, RouteDescriptor, RouteDescriptorOptions, RouteMethod, ServerActionDescriptorProvider, ServerHandler, ServerLoggerProvider, ServerMiddlewareHandler, ServerNotReadyProvider, ServerProvider, ServerRawRequest, ServerRemote, ServerReply, ServerRequest, ServerRequestConfig, ServerRequestConfigEntry, ServerResponse, ServerResponseBody, ServerRoute, ServerRouteAction, ServerRouteSecure, ServerRouteWithHandler, ServerRouterProvider, ServerSecurityProvider, ServerTimingProvider, UnauthorizedError, ValidationError, apiLinkSchema, apiLinksResponseSchema, errorNameByStatus, errorSchema, isHttpError, isServerAction, okSchema, routeMethods };
+export { $action, $route, ActionDescriptor, ActionDescriptorOptions, AlephaServer, ApiLink, ApiLinksResponse, BadRequestError, ClientRequestEntry, ClientRequestEntryContainer, ClientRequestOptions, ClientRequestResponse, ConflictError, FetchActionArgs, FetchOptions, FetchResponse, ForbiddenError, HttpAction, HttpClient, HttpClientPendingRequests, HttpError, HttpErrorLike, NodeHttpServerProvider, NotFoundError, Ok, RequestConfigSchema, ResponseBodyType, ResponseKind, RouteDescriptor, RouteDescriptorOptions, RouteMethod, ServerActionHandler, ServerActionRequest, ServerHandler, ServerLoggerProvider, ServerMiddlewareHandler, ServerNotReadyProvider, ServerProvider, ServerRawRequest, ServerReply, ServerRequest, ServerRequestConfig, ServerRequestConfigEntry, ServerResponse, ServerResponseBody, ServerRoute, ServerRouteMatcher, ServerRouterProvider, ServerTimingProvider, UnauthorizedError, ValidationError, apiLinkSchema, apiLinksResponseSchema, errorNameByStatus, errorSchema, isHttpError, isMultipart, okSchema, routeMethods };
 //# sourceMappingURL=index.d.ts.map