alepha 0.7.6 → 0.8.0

package/server.d.ts

@@ -1,37 +1,40 @@
-import * as _alepha_core5 from "@alepha/core";
-import * as _alepha_core57 from "@alepha/core";
-import * as _alepha_core61 from "@alepha/core";
-import * as _alepha_core109 from "@alepha/core";
-import * as _alepha_core43 from "@alepha/core";
-import * as _alepha_core47 from "@alepha/core";
-import * as _alepha_core49 from "@alepha/core";
-import * as _alepha_core50 from "@alepha/core";
-import * as _alepha_core54 from "@alepha/core";
-import * as _alepha_core103 from "@alepha/core";
-import * as _alepha_core3 from "@alepha/core";
-import { Alepha, Async, FileLike, KIND, KIND as KIND$1, Module, OPTIONS, Static, StreamLike, TObject, TSchema } from "@alepha/core";
-import { JwtProvider, Permission, SecurityProvider, ServiceAccountDescriptor, UserAccountToken } from "@alepha/security";
-import { DateTimeProvider, DurationLike } from "@alepha/datetime";
-import * as _alepha_cache6 from "@alepha/cache";
-import * as _alepha_retry112 from "@alepha/retry";
+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 { Readable } from "node:stream";
 import { ReadableStream } from "node:stream/web";
-import { Route, RouterProvider } from "@alepha/router";
-import { BusboyConfig } from "@fastify/busboy";
+import { Route, RouterProvider } from "alepha/router";
 import { IncomingMessage, ServerResponse as ServerResponse$1 } from "node:http";
-import * as _sinclair_typebox65 from "@sinclair/typebox";
-import * as _sinclair_typebox15 from "@sinclair/typebox";
-import * as _sinclair_typebox59 from "@sinclair/typebox";
-import * as _sinclair_typebox21 from "@sinclair/typebox";
-import * as _sinclair_typebox101 from "@sinclair/typebox";
-import * as _sinclair_typebox91 from "@sinclair/typebox";
-import * as _sinclair_typebox7 from "@sinclair/typebox";
-import * as _sinclair_typebox1 from "@sinclair/typebox";
-import * as http106 from "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";
 
 //#region src/constants/routeMethods.d.ts
 declare const routeMethods: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "CONNECT", "TRACE"];
 type RouteMethod = (typeof routeMethods)[number];
+//# sourceMappingURL=routeMethods.d.ts.map
+//#endregion
+//#region src/helpers/ServerReply.d.ts
+declare class ServerReply {
+  headers: Record<string, string> & {
+    "set-cookie"?: string[];
+  };
+  status?: number;
+  body?: any;
+  redirect(url: string, status?: number): void;
+  setStatus(status: number): void;
+  setHeader(name: string, value: string): void;
+}
+//# sourceMappingURL=ServerReply.d.ts.map
 //#endregion
 //#region src/interfaces/index.d.ts
 interface RequestConfigSchema {
@@ -79,14 +82,6 @@ type ResponseKind = "json" | "text" | "void" | "file" | "any";
 type ResponseBodyType = string | Buffer | StreamLike | undefined | null | void;
 type ServerHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
 type ServerMiddlewareHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerRequest<TConfig>) => Async<ServerResponseBody<TConfig> | undefined>;
-interface ServerReply {
-  headers: Record<string, string> & {
-    "set-cookie"?: string[];
-  };
-  status?: number;
-  body?: any;
-  redirect(url: string): void;
-}
 interface ServerResponse {
   body: string | Buffer | ArrayBuffer | Readable | ReadableStream;
   headers: Record<string, string>;
@@ -114,12 +109,12 @@ type ServerRouteSecure = boolean | {
   realms?: string[];
   organizations?: string[];
 };
+//# sourceMappingURL=index.d.ts.map
 //#endregion
 //#region src/helpers/ActionDescriptorHelper.d.ts
 declare class ActionDescriptorHelper {
-  name(options: ActionDescriptorOptions, _instance: any, key: string): string;
+  name(options: ActionDescriptorOptions, instance: any, key: string): string;
   path(options: ActionDescriptorOptions, _instance: any, key: string): string;
-  link(options: ActionDescriptorOptions, instance: any, key: string, prefix?: string): HttpClientLink;
   method(options: {
     method?: string;
     schema?: any;
@@ -133,79 +128,38 @@ declare class ActionDescriptorHelper {
   protected short(name: string): string;
   fetchLinks(_url: string): void;
 }
-//#endregion
-//#region src/schemas/apiLinksResponseSchema.d.ts
-declare const apiLinkSchema: _sinclair_typebox65.TObject<{
-  name: _sinclair_typebox65.TString;
-  path: _sinclair_typebox65.TString;
-  method: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
-  group: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
-  requestBodyType: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
-  service: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
-}>;
-declare const apiLinksResponseSchema: _sinclair_typebox65.TObject<{
-  prefix: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
-  links: _sinclair_typebox65.TArray<_sinclair_typebox65.TObject<{
-    name: _sinclair_typebox65.TString;
-    path: _sinclair_typebox65.TString;
-    method: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
-    group: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
-    requestBodyType: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
-    service: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
-  }>>;
-}>;
-type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
-type ApiLink = Static<typeof apiLinkSchema>;
+//# sourceMappingURL=ActionDescriptorHelper.d.ts.map
 //#endregion
 //#region src/services/HttpClient.d.ts
 declare class HttpClient {
-  protected readonly log: _alepha_core5.Logger;
+  protected readonly log: _alepha_core1.Logger;
   protected readonly alepha: Alepha;
   protected readonly helper: ActionDescriptorHelper;
-  readonly cache: _alepha_cache6.CacheDescriptor<HttpClientCache, any[]>;
+  readonly cache: _alepha_cache2.CacheDescriptor<HttpClientCache, any[]>;
   protected readonly pendingRequests: HttpClientPendingRequests;
-  readonly URL_LINKS = "/api/_links";
-  links?: Array<HttpClientLink>;
-  pushLink(link: HttpClientLink): void;
   clear(): Promise<void>;
-  fetch<T>(url: string, request?: RequestInit, options?: FetchRunOptions): Promise<FetchResponse<T>>;
+  fetchAction(args: FetchActionArgs): Promise<FetchResponse>;
+  fetch<T>(url: string, request?: RequestInit,
+  // standard options
+  options?: FetchOptions): Promise<FetchResponse<T>>;
   json<T = any>(url: string, options?: RequestInit): Promise<T>;
-  protected url(host: string, link: HttpClientLink, args: ServerRequestConfigEntry): string;
-  protected body(init: RequestInit, headers: Record<string, string>, link: HttpClientLink, args?: ServerRequestConfigEntry): Promise<void>;
-  protected responseData(response: Response, options: FetchRunOptions): Promise<any>;
+  protected url(host: string, action: HttpAction, args: ServerRequestConfigEntry): string;
+  protected body(init: RequestInit, headers: Record<string, string>, action: HttpAction, args?: ServerRequestConfigEntry): Promise<void>;
+  protected responseData(response: Response, options: FetchOptions): Promise<any>;
   protected isMaybeFile(response: Response): boolean;
   protected createFileLike(response: Response, defaultFileName?: string): FileLike;
-  protected pathVariables(url: string, action: HttpClientLink, args?: ServerRequestConfigEntry): string;
-  protected queryParams(url: string, action: {
+  pathVariables(url: string, action: {
+    schema?: {
+      params?: TObject;
+    };
+  }, args?: ServerRequestConfigEntry): string;
+  queryParams(url: string, action: {
     schema?: {
       query?: TObject;
     };
   }, args?: ServerRequestConfigEntry): string;
-  /**
-   * Transform a link into a fetch-request then call fetch().
-   */
-  fetchLink(args: FetchLinkArgs): Promise<FetchResponse>;
-  /**
-   * Create a proxy client.
-   * This allows to call actions as methods, e.g. `client.actionName()`.
-   */
-  of<T extends object>(scope?: ClientScope): HttpVirtualClient<T>;
-  protected getLinkByName(name: string, options?: ClientScope): Promise<HttpClientLink>;
-  /**
-   * Resolve a link by its name and call it.
-   * - If link is local, it will call the local handler.
-   * - If link is remote, it will make a fetch request to the remote server.
-   */
-  follow(name: string, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions & ClientScope): Promise<any>;
-  protected followRemote(link: HttpClientLink, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions): Promise<FetchResponse>;
-  can(name: string): boolean;
-  getLinks(force?: boolean): Promise<HttpClientLink[]>;
 }
-type HttpClientPendingRequests = Record<string, Promise<any> | undefined>;
-interface FetchFactoryAdditionalOptions {
-  host?: string | (() => string);
-}
-interface FetchRunOptions {
+interface FetchOptions {
   /**
    * Key to identify the request in the pending requests.
    */
@@ -219,26 +173,6 @@ interface FetchRunOptions {
    */
   cache?: boolean | number | DurationLike;
 }
-interface HttpClientLink extends ApiLink {
-  secured?: boolean;
-  prefix?: string;
-  host?: string;
-  service?: string;
-  schema?: RequestConfigSchema;
-  handler?: ServerHandler;
-}
-interface ClientScope {
-  group?: string;
-  service?: string;
-}
-type HttpVirtualClient<T> = { [K in keyof T as T[K] extends ActionDescriptor ? K : never]: T[K] extends ActionDescriptor<infer Schema> ? T[K] & {
-  can: () => boolean;
-  schema: Schema;
-} : never };
-interface HttpClientCache {
-  data: any;
-  etag?: string;
-}
 interface FetchResponse<T = any> {
   data: T;
   status: number;
@@ -246,15 +180,31 @@ interface FetchResponse<T = any> {
   headers: Headers;
   raw?: Response;
 }
-interface FetchLinkArgs {
-  link: HttpClientLink;
+type HttpClientPendingRequests = Record<string, Promise<any> | undefined>;
+interface HttpClientCache {
+  data: any;
+  etag?: string;
+}
+interface FetchActionArgs {
+  action: HttpAction;
   host?: string;
   config?: ServerRequestConfigEntry;
   options?: ClientRequestOptions;
 }
+interface HttpAction {
+  method?: string;
+  prefix?: string;
+  path: string;
+  schema?: {
+    params?: TObject;
+    query?: TObject;
+    body?: TSchema;
+    response?: TSchema;
+  };
+}
 //#endregion
 //#region src/descriptors/$action.d.ts
-declare const KEY$2 = "ACTION";
+declare const KEY$1 = "ACTION";
 interface ActionDescriptorOptions<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema"> {
   /**
    * Name the route.
@@ -321,7 +271,7 @@ interface ActionDescriptorOptions<TConfig extends RequestConfigSchema = RequestC
   handler?: ServerHandler<TConfig>;
 }
 interface ActionDescriptor<TConfig extends RequestConfigSchema = RequestConfigSchema> {
-  [KIND$1]: typeof KEY$2;
+  [KIND]: typeof KEY$1;
   [OPTIONS]: ActionDescriptorOptions<TConfig>;
   /**
    * Fetch or just call local route when available.
@@ -338,7 +288,7 @@ interface ActionDescriptor<TConfig extends RequestConfigSchema = RequestConfigSc
 }
 declare const $action: {
   <TConfig extends RequestConfigSchema>(options: ActionDescriptorOptions<TConfig>): ActionDescriptor<TConfig>;
-  [KIND$1]: string;
+  [KIND]: string;
 };
 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> = {
@@ -347,7 +297,7 @@ type ClientRequestEntryContainer<TConfig extends RequestConfigSchema = RequestCo
   headers?: TConfig["headers"] extends TSchema ? Static<TConfig["headers"]> : undefined;
   query?: TConfig["query"] extends TSchema ? Partial<Static<TConfig["query"]>> : undefined;
 };
-interface ClientRequestOptions extends FetchRunOptions {
+interface ClientRequestOptions extends FetchOptions {
   /**
    * Forward user from the previous request.
    * If "system", use system user. @see {ServerSecurityProvider.localSystemUser}
@@ -400,151 +350,149 @@ declare const isHttpError: (error: unknown) => error is HttpErrorLike;
 interface HttpErrorLike extends Error {
   status: number;
 }
-//#endregion
-//#region src/descriptors/$client.d.ts
-declare const $client: <T extends object>(scope?: ClientScope) => HttpVirtualClient<T>;
-//#endregion
-//#region src/descriptors/$proxy.d.ts
-type ProxyDescriptorOptions = {
-  path: string;
-  target: string;
-  disabled?: boolean;
-  beforeRequest?: (request: ServerRequest, proxyRequest: RequestInit) => Async<void>;
-  afterResponse?: (request: ServerRequest, proxyResponse: Response) => Async<void>;
-  rewrite?: (url: URL) => void;
-};
-interface ProxyDescriptor {
-  [KIND$1]: "PROXY";
-  [OPTIONS]: ProxyDescriptorOptions;
-}
-declare const $proxy: {
-  (options: ProxyDescriptorOptions): ProxyDescriptor;
-  [KIND$1]: string;
-};
-//#endregion
-//#region src/descriptors/$remote.d.ts
-declare const KEY$1 = "REMOTE";
-interface RemoteDescriptorOptions {
-  /**
-   * The URL of the remote service.
-   * You can use a function to generate the URL dynamically.
-   * You probably should use $inject(env) to get the URL from the environment.
-   *
-   * @example
-   * ```ts
-   * import { $remote } from "@alepha/server";
-   * import { $inject, t } from "@alepha/core";
-   *
-   * class App {
-   *   env = $inject(t.object({
-   *     REMOTE_URL: t.string({default: "http://localhost:3000"}),
-   *   }));
-   *   remote = $remote({
-   *     url: this.env.REMOTE_URL,
-   *   });
-   * }
-   * ```
-   */
-  url: string | (() => string);
-  /**
-   * The name of the remote service.
-   *
-   * @default Member of the class containing the remote service.
-   */
-  name?: string;
-  /**
-   * If true, all methods of the remote service will be exposed as actions in this context.
-   * > Note: Proxy will never use the service account, it just... proxies the request.
-   */
-  proxy?: boolean | Partial<ProxyDescriptorOptions & {
-    /**
-     * If true, the remote service won't be available internally, only through the proxy.
-     */
-    noInternal: boolean;
-  }>;
-  /**
-   * For communication between the server and the remote service with a security layer.
-   * This will be used for internal communication and will not be exposed to the client.
-   */
-  serviceAccount?: ServiceAccountDescriptor;
-}
-interface RemoteDescriptor {
-  [KIND$1]: typeof KEY$1;
-  [OPTIONS]: RemoteDescriptorOptions;
-}
-/**
- * $remote is a descriptor that allows you to define a remote service access.
- *
- * Use it only when you have 2 or more services that need to communicate with each other.
- *
- * All remote services can be exposed as actions, ... or not.
- *
- * You can add a service account if you want to use a security layer.
- */
-declare const $remote: {
-  (options: RemoteDescriptorOptions): RemoteDescriptor;
-  [KIND$1]: string;
-};
+//# sourceMappingURL=HttpError.d.ts.map
 //#endregion
 //#region src/descriptors/$route.d.ts
 declare const KEY = "ROUTE";
 interface RouteDescriptorOptions<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRoute<TConfig> {}
 type RouteDescriptor<TConfig extends RequestConfigSchema = RequestConfigSchema> = {
-  [KIND$1]: typeof KEY;
+  [KIND]: typeof KEY;
   [OPTIONS]: RouteDescriptorOptions<TConfig>;
 };
 declare const $route: {
   <TConfig extends RequestConfigSchema = RequestConfigSchema>(options: RouteDescriptorOptions<TConfig>): RouteDescriptor<TConfig>;
-  [KIND$1]: string;
+  [KIND]: string;
 };
 //#endregion
 //#region src/errors/BadRequestError.d.ts
 declare class BadRequestError extends HttpError {
   constructor(message?: string, cause?: unknown);
 }
+//# sourceMappingURL=BadRequestError.d.ts.map
 //#endregion
 //#region src/errors/ConflictError.d.ts
 declare class ConflictError extends HttpError {
   constructor(message?: string, cause?: unknown);
 }
+//# sourceMappingURL=ConflictError.d.ts.map
 //#endregion
 //#region src/errors/ForbiddenError.d.ts
 declare class ForbiddenError extends HttpError {
   constructor(message?: string, cause?: unknown);
 }
+//# sourceMappingURL=ForbiddenError.d.ts.map
 //#endregion
 //#region src/errors/NotFoundError.d.ts
 declare class NotFoundError extends HttpError {
   constructor(message?: string, cause?: unknown);
 }
+//# sourceMappingURL=NotFoundError.d.ts.map
 //#endregion
 //#region src/errors/UnauthorizedError.d.ts
 declare class UnauthorizedError extends HttpError {
   constructor(message?: string, cause?: unknown);
 }
+//# sourceMappingURL=UnauthorizedError.d.ts.map
 //#endregion
 //#region src/errors/ValidationError.d.ts
 declare class ValidationError extends HttpError {
   constructor(message?: string, cause?: unknown);
 }
+//# sourceMappingURL=ValidationError.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 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>;
+  }>>;
+}>;
+type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
+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;
+  }>>;
+}>;
+//# 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>;
+}>;
+type Ok = Static<typeof okSchema>;
+//# sourceMappingURL=okSchema.d.ts.map
+//#endregion
+//#region src/providers/features/ServerLoggerProvider.d.ts
+declare class ServerLoggerProvider {
+  protected readonly log: _alepha_core3.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">;
+}
+//# sourceMappingURL=ServerLoggerProvider.d.ts.map
 //#endregion
-//#region src/providers/features/ServerHealthProvider.d.ts
+//#region src/providers/features/ServerNotReadyProvider.d.ts
 /**
- * Register `/health` endpoint.
+ * On every request, this provider checks if the server is ready.
  *
- * - Provides basic health information about the server.
+ * If the server is not ready, it responds with a 503 status code and a message indicating that the server is not ready yet.
+ *
+ * The response also includes a `Retry-After` header indicating that the client should retry after 5 seconds.
  */
-declare class ServerHealthProvider {
-  protected readonly dateTimeProvider: DateTimeProvider;
+declare class ServerNotReadyProvider {
   protected readonly alepha: Alepha;
-  readonly health: RouteDescriptor<{
-    response: _sinclair_typebox15.TObject<{
-      message: _sinclair_typebox15.TString;
-      uptime: _sinclair_typebox15.TNumber;
-      date: _sinclair_typebox15.TString;
-      ready: _sinclair_typebox15.TBoolean;
-    }>;
-  }>;
+  readonly onRequest: _alepha_core7.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
+type TimingMap = Record<string, [number, number]>;
+declare class ServerTimingProvider {
+  protected readonly log: _alepha_core12.Logger;
+  protected readonly alepha: Alepha;
+  readonly onRequest: _alepha_core12.HookDescriptor<"server:onRequest">;
+  readonly onResponse: _alepha_core12.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
@@ -557,7 +505,6 @@ declare class ServerHealthProvider {
  */
 declare class ServerRouterProvider extends RouterProvider<ServerRouteWithHandler> {
   protected readonly alepha: Alepha;
-  createRequestId(): string;
   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<{
@@ -575,31 +522,51 @@ declare class ServerRouterProvider extends RouterProvider<ServerRouteWithHandler
   }, request: ServerRequestConfig): void;
   serializeResponse(route: ServerRoute, reply: ServerReply, responseKind: ResponseKind): void;
 }
+//# sourceMappingURL=ServerRouterProvider.d.ts.map
 //#endregion
-//#region src/providers/ProxyDescriptorProvider.d.ts
-declare class ProxyDescriptorProvider {
-  protected readonly log: _alepha_core57.Logger;
-  protected readonly routerProvider: ServerRouterProvider;
+//#region src/providers/platforms/ServerProvider.d.ts
+declare abstract class ServerProvider {
   protected readonly alepha: Alepha;
-  readonly configure: _alepha_core57.HookDescriptor<"configure">;
-  createProxyHandler(options: Omit<ProxyDescriptorOptions, "path">): ServerHandler;
-  proxy(options: ProxyDescriptorOptions): Promise<void>;
-  private getRawRequestBody;
+  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/ServerProvider.d.ts
-declare class ServerProvider {
-  constructor();
+//#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$2: _alepha_core61.TObject<{
-  SERVER_API_PREFIX: _sinclair_typebox59.TString;
-  SERVER_SECURITY_ENABLED: _sinclair_typebox59.TBoolean;
+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$2>> {}
+  interface Env extends Partial<Static<typeof envSchema>> {}
   interface State {
     /**
      * Real (or fake) user account, used for internal actions.
@@ -610,7 +577,7 @@ declare module "alepha" {
   }
 }
 declare class ServerActionDescriptorProvider {
-  protected readonly log: _alepha_core61.Logger;
+  protected readonly log: _alepha_core24.Logger;
   protected readonly alepha: Alepha;
   protected readonly env: {
     SERVER_API_PREFIX: string;
@@ -623,14 +590,14 @@ declare class ServerActionDescriptorProvider {
   protected readonly actions: ServerRouteAction[];
   getActions(): ServerRouteAction<RequestConfigSchema>[];
   getPrefix(): string;
-  readonly configure: _alepha_core61.HookDescriptor<"configure">;
+  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 createLocalFunction(action: ActionDescriptorOptions, permission: Permission): (config?: ServerRequestConfigEntry, options?: ClientRequestOptions) => Promise<any>;
+  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.
@@ -662,192 +629,17 @@ interface ServerRouteAction<TConfig extends RequestConfigSchema = RequestConfigS
   group: string;
   permission: Permission;
   options: ActionDescriptorOptions;
+  localHandler: LocalHandler;
 }
-//#endregion
-//#region src/providers/RemoteDescriptorProvider.d.ts
-declare class RemoteDescriptorProvider {
-  static path: {
-    apiLinks: string;
-  };
-  protected readonly alepha: Alepha;
-  protected readonly client: HttpClient;
-  protected readonly proxyProvider: ProxyDescriptorProvider;
-  protected readonly remotes: Array<ServerRemote>;
-  protected readonly log: _alepha_core109.Logger;
-  getRemotes(): ServerRemote[];
-  readonly configure: _alepha_core109.HookDescriptor<"configure">;
-  readonly start: _alepha_core109.HookDescriptor<"start">;
-  registerRemote(value: RemoteDescriptor, key: string): Promise<void>;
-  protected readonly fetchLinks: _alepha_retry112.RetryDescriptor<(opts: {
-    service: string;
-    url: string;
-    authorization?: string;
-  }) => Promise<{
-    prefix?: string | undefined;
-    links: {
-      method?: string | undefined;
-      group?: string | undefined;
-      requestBodyType?: string | undefined;
-      service?: string | undefined;
-      name: string;
-      path: string;
-    }[];
-  }>>;
-}
-//#endregion
-//#region src/providers/features/ServerLinksProvider.d.ts
-declare class ServerLinksProvider {
-  protected readonly alepha: Alepha;
-  protected readonly client: HttpClient;
-  protected readonly remoteProvider: RemoteDescriptorProvider;
-  protected readonly serverActionDescriptorProvider: ServerActionDescriptorProvider;
-  readonly links: RouteDescriptor<{
-    response: _sinclair_typebox21.TObject<{
-      prefix: _sinclair_typebox21.TOptional<_sinclair_typebox21.TString>;
-      links: _sinclair_typebox21.TArray<_sinclair_typebox21.TObject<{
-        name: _sinclair_typebox21.TString;
-        path: _sinclair_typebox21.TString;
-        method: _sinclair_typebox21.TOptional<_sinclair_typebox21.TString>;
-        group: _sinclair_typebox21.TOptional<_sinclair_typebox21.TString>;
-        requestBodyType: _sinclair_typebox21.TOptional<_sinclair_typebox21.TString>;
-        service: _sinclair_typebox21.TOptional<_sinclair_typebox21.TString>;
-      }>>;
-    }>;
-  }>;
-  readonly schema: RouteDescriptor<{
-    params: _sinclair_typebox21.TObject<{
-      name: _sinclair_typebox21.TString;
-    }>;
-    response: _sinclair_typebox21.TRecord<_sinclair_typebox21.TString, _sinclair_typebox21.TAny>;
-  }>;
-  getLinks(options: {
-    user?: UserAccountToken;
-    authorization?: string;
-  }): Promise<ApiLinksResponse>;
-}
-//#endregion
-//#region src/providers/features/ServerLoggerProvider.d.ts
-declare class ServerLoggerProvider {
-  protected readonly log: _alepha_core43.Logger;
-  protected readonly alepha: Alepha;
-  readonly onRequest: _alepha_core43.HookDescriptor<"server:onRequest">;
-  readonly onError: _alepha_core43.HookDescriptor<"server:onError">;
-  readonly onResponse: _alepha_core43.HookDescriptor<"server:onResponse">;
-}
-//#endregion
-//#region src/providers/features/ServerMultipartProvider.d.ts
-declare class ServerMultipartProvider {
-  protected readonly helper: ActionDescriptorHelper;
-  protected readonly alepha: Alepha;
-  readonly onRequest: _alepha_core47.HookDescriptor<"server:onRequest">;
-  readonly onSend: _alepha_core47.HookDescriptor<"server:onResponse">;
-  handleMultipartBodyFromNode(route: ServerRoute, stream: IncomingMessage): Promise<{
-    body: Record<string, any>;
-    cleanup: () => Promise<void>;
-  }>;
-  parseMultipart(req: IncomingMessage, config?: Omit<BusboyConfig, "headers">): Promise<MultipartResult>;
-}
-interface MultipartResult {
-  fields: Record<string, string | string[]>;
-  files: Record<string, HybridFile>;
-}
-interface HybridFile extends FileLike {
-  cleanup(): Promise<void>;
-  _state: {
-    cleanup: boolean;
-    size: number;
-    tmpPath: string;
-  };
-}
-//#endregion
-//#region src/providers/features/ServerNotReadyProvider.d.ts
-/**
- * On every request, this provider checks if the server is ready.
- *
- * If the server is not ready, it responds with a 503 status code and a message indicating that the server is not ready yet.
- *
- * The response also includes a `Retry-After` header indicating that the client should retry after 5 seconds.
- */
-declare class ServerNotReadyProvider {
-  protected readonly alepha: Alepha;
-  readonly onRequest: _alepha_core49.HookDescriptor<"server:onRequest">;
-}
-//#endregion
-//#region src/providers/features/ServerSecurityProvider.d.ts
-declare class ServerSecurityProvider {
-  protected readonly log: _alepha_core50.Logger;
-  protected readonly securityProvider: SecurityProvider;
-  protected readonly jwtProvider: JwtProvider;
-  protected readonly alepha: Alepha;
-  readonly onClientRequest: _alepha_core50.HookDescriptor<"client:onRequest">;
-  protected readonly onRequest: _alepha_core50.HookDescriptor<"server:onRequest">;
-  protected readonly onRoute: _alepha_core50.HookDescriptor<"server:onRoute">;
-}
-//#endregion
-//#region src/providers/features/ServerTimingProvider.d.ts
-type TimingMap = Record<string, [number, number]>;
-declare class ServerTimingProvider {
-  protected readonly log: _alepha_core54.Logger;
-  protected readonly alepha: Alepha;
-  readonly onRequest: _alepha_core54.HookDescriptor<"server:onRequest">;
-  readonly onResponse: _alepha_core54.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/platforms/NodeHttpServerProvider.d.ts
-declare const envSchema$1: _alepha_core103.TObject<{
-  SERVER_PORT: _sinclair_typebox101.TNumber;
-  SERVER_HOST: _sinclair_typebox101.TString;
-}>;
-declare module "alepha/core" {
-  interface Env extends Partial<Static<typeof envSchema$1>> {}
-}
-declare class NodeHttpServerProvider implements ServerProvider {
-  protected readonly alepha: Alepha;
-  protected readonly log: _alepha_core103.Logger;
-  protected readonly env: {
-    SERVER_PORT: number;
-    SERVER_HOST: string;
-  };
-  protected readonly router: ServerRouterProvider;
-  protected readonly server: http106.Server<typeof IncomingMessage, typeof ServerResponse$1>;
-  handle(req: IncomingMessage, res: ServerResponse$1): Promise<number | void>;
-  createRouterRequest(req: IncomingMessage, res: ServerResponse$1, params?: Record<string, string>): ServerRawRequest;
-  getProtocol(req: IncomingMessage): "http" | "https";
-  shouldHaveBody(method: string): boolean;
-  get hostname(): string;
-  readonly start: _alepha_core103.HookDescriptor<"start">;
-  protected readonly stop: _alepha_core103.HookDescriptor<"stop">;
-  protected listen(): Promise<void>;
-  protected close(): Promise<void>;
-}
-//#endregion
-//#region src/schemas/errorSchema.d.ts
-declare const errorSchema: _sinclair_typebox91.TObject<{
-  error: _sinclair_typebox91.TString;
-  status: _sinclair_typebox91.TNumber;
-  message: _sinclair_typebox91.TString;
-  details: _sinclair_typebox91.TOptional<_sinclair_typebox91.TString>;
-  cause: _sinclair_typebox91.TOptional<_sinclair_typebox91.TObject<{
-    name: _sinclair_typebox91.TString;
-    message: _sinclair_typebox91.TString;
-  }>>;
-}>;
-//#endregion
-//#region src/schemas/okSchema.d.ts
-declare const okSchema: _sinclair_typebox7.TObject<{
-  ok: _sinclair_typebox7.TBoolean;
-  id: _sinclair_typebox7.TOptional<_sinclair_typebox7.TUnion<[_sinclair_typebox7.TString, _sinclair_typebox7.TInteger]>>;
-  count: _sinclair_typebox7.TOptional<_sinclair_typebox7.TNumber>;
-}>;
-type Ok = Static<typeof okSchema>;
+type LocalHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (config?: ServerRequestConfigEntry<TConfig>, options?: ClientRequestOptions) => Promise<any>;
 //#endregion
 //#region src/index.d.ts
-declare module "@alepha/core" {
+declare module "alepha" {
   interface Hooks {
+    "node:request": {
+      req: IncomingMessage;
+      res: ServerResponse$1;
+    };
     "server:onRoute": {
       route: ServerRoute;
     };
@@ -870,7 +662,7 @@ declare module "@alepha/core" {
       response: ServerResponse;
     };
     "client:onRequest": {
-      route: HttpClientLink;
+      route: HttpAction;
       config: ServerRequestConfigEntry;
       options: ClientRequestOptions;
       headers: Record<string, string>;
@@ -878,30 +670,21 @@ declare module "@alepha/core" {
     };
     "client:beforeFetch": {
       url: string;
-      options: FetchRunOptions;
+      options: FetchOptions;
       request: RequestInit;
     };
     "client:onError": {
-      route?: HttpClientLink;
+      route?: HttpAction;
       error: HttpError;
     };
   }
 }
-declare const envSchema: _alepha_core3.TObject<{
-  SERVER_LINKS_ENABLED: _sinclair_typebox1.TBoolean;
-  SERVER_HEALTH_ENABLED: _sinclair_typebox1.TBoolean;
-}>;
-declare module "@alepha/core" {
-  interface Env extends Partial<Static<typeof envSchema>> {}
-}
 declare class AlephaServer implements Module {
-  protected readonly env: {
-    SERVER_LINKS_ENABLED: boolean;
-    SERVER_HEALTH_ENABLED: boolean;
-  };
   readonly name = "alepha.server";
   readonly $services: (alepha: Alepha) => void;
 }
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
-export { $action, $client, $proxy, $remote, $route, ActionDescriptor, ActionDescriptorOptions, AlephaServer, ApiLink, ApiLinksResponse, BadRequestError, ClientRequestEntry, ClientRequestEntryContainer, ClientRequestOptions, ClientRequestResponse, ClientScope, ConflictError, FetchFactoryAdditionalOptions, FetchLinkArgs, FetchResponse, FetchRunOptions, ForbiddenError, HttpClient, HttpClientLink, HttpClientPendingRequests, HttpError, HttpErrorLike, HttpVirtualClient, KIND, NodeHttpServerProvider, NotFoundError, Ok, ProxyDescriptor, ProxyDescriptorOptions, ProxyDescriptorProvider, RemoteDescriptor, RemoteDescriptorOptions, RemoteDescriptorProvider, RequestConfigSchema, ResponseBodyType, ResponseKind, RouteDescriptor, RouteDescriptorOptions, RouteMethod, ServerActionDescriptorProvider, ServerHandler, ServerHealthProvider, ServerLinksProvider, ServerLoggerProvider, ServerMiddlewareHandler, ServerMultipartProvider, 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, 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 };
 //# sourceMappingURL=index.d.ts.map