alepha 0.7.7 → 0.8.1

package/server.d.ts

@@ -1,30 +1,27 @@
-import * as _alepha_core1 from "@alepha/core";
-import * as _alepha_core3 from "@alepha/core";
-import * as _alepha_core7 from "@alepha/core";
-import * as _alepha_core9 from "@alepha/core";
-import * as _alepha_core71 from "@alepha/core";
-import * as _alepha_core10 from "@alepha/core";
-import * as _alepha_core15 from "@alepha/core";
-import * as _alepha_core23 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 { BusboyConfig } from "@fastify/busboy";
-import * as _alepha_cache2 from "@alepha/cache";
+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 { Route, RouterProvider } from "alepha/router";
 import { IncomingMessage, ServerResponse as ServerResponse$1 } from "node:http";
-import { DurationLike } from "@alepha/datetime";
-import * as _sinclair_typebox13 from "@sinclair/typebox";
-import * as _sinclair_typebox37 from "@sinclair/typebox";
-import * as _sinclair_typebox21 from "@sinclair/typebox";
-import * as _sinclair_typebox27 from "@sinclair/typebox";
-import * as _sinclair_typebox63 from "@sinclair/typebox";
-import * as http18 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 {
@@ -37,6 +34,7 @@ declare class ServerReply {
   setStatus(status: number): void;
   setHeader(name: string, value: string): void;
 }
+//# sourceMappingURL=ServerReply.d.ts.map
 //#endregion
 //#region src/interfaces/index.d.ts
 interface RequestConfigSchema {
@@ -111,6 +109,7 @@ type ServerRouteSecure = boolean | {
   realms?: string[];
   organizations?: string[];
 };
+//# sourceMappingURL=index.d.ts.map
 //#endregion
 //#region src/helpers/ActionDescriptorHelper.d.ts
 declare class ActionDescriptorHelper {
@@ -129,6 +128,7 @@ declare class ActionDescriptorHelper {
   protected short(name: string): string;
   fetchLinks(_url: string): void;
 }
+//# sourceMappingURL=ActionDescriptorHelper.d.ts.map
 //#endregion
 //#region src/services/HttpClient.d.ts
 declare class HttpClient {
@@ -205,6 +205,10 @@ interface HttpAction {
 //#endregion
 //#region src/descriptors/$action.d.ts
 declare const KEY$1 = "ACTION";
+declare const $action: {
+  <TConfig extends RequestConfigSchema>(options: ActionDescriptorOptions<TConfig>): ActionDescriptor<TConfig>;
+  [KIND]: string;
+};
 interface ActionDescriptorOptions<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema"> {
   /**
    * Name the route.
@@ -271,7 +275,7 @@ interface ActionDescriptorOptions<TConfig extends RequestConfigSchema = RequestC
   handler?: ServerHandler<TConfig>;
 }
 interface ActionDescriptor<TConfig extends RequestConfigSchema = RequestConfigSchema> {
-  [KIND$1]: typeof KEY$1;
+  [KIND]: typeof KEY$1;
   [OPTIONS]: ActionDescriptorOptions<TConfig>;
   /**
    * Fetch or just call local route when available.
@@ -286,10 +290,6 @@ interface ActionDescriptor<TConfig extends RequestConfigSchema = RequestConfigSc
    */
   permission: () => string;
 }
-declare const $action: {
-  <TConfig extends RequestConfigSchema>(options: ActionDescriptorOptions<TConfig>): ActionDescriptor<TConfig>;
-  [KIND$1]: 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> = {
   body: TConfig["body"] extends TSchema ? Static<TConfig["body"]> : undefined;
@@ -350,48 +350,101 @@ declare const isHttpError: (error: unknown) => error is HttpErrorLike;
 interface HttpErrorLike extends Error {
   status: number;
 }
+//# sourceMappingURL=HttpError.d.ts.map
 //#endregion
 //#region src/descriptors/$route.d.ts
 declare const KEY = "ROUTE";
+declare const $route: {
+  <TConfig extends RequestConfigSchema = RequestConfigSchema>(options: RouteDescriptorOptions<TConfig>): RouteDescriptor<TConfig>;
+  [KIND]: string;
+};
 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;
-};
 //#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 {
@@ -401,31 +454,7 @@ declare class ServerLoggerProvider {
   readonly onError: _alepha_core3.HookDescriptor<"server:onError">;
   readonly onResponse: _alepha_core3.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_core7.HookDescriptor<"server:onRequest">;
-  readonly onSend: _alepha_core7.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;
-  };
-}
+//# sourceMappingURL=ServerLoggerProvider.d.ts.map
 //#endregion
 //#region src/providers/features/ServerNotReadyProvider.d.ts
 /**
@@ -437,27 +466,29 @@ interface HybridFile extends FileLike {
  */
 declare class ServerNotReadyProvider {
   protected readonly alepha: Alepha;
-  readonly onRequest: _alepha_core9.HookDescriptor<"server:onRequest">;
+  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_core71.Logger;
+  protected readonly log: _alepha_core8.Logger;
   protected readonly securityProvider: SecurityProvider;
   protected readonly jwtProvider: JwtProvider;
   protected readonly alepha: Alepha;
-  readonly onClientRequest: _alepha_core71.HookDescriptor<"client:onRequest">;
-  protected readonly onRequest: _alepha_core71.HookDescriptor<"server:onRequest">;
-  protected readonly onRoute: _alepha_core71.HookDescriptor<"server:onRoute">;
+  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_core10.Logger;
+  protected readonly log: _alepha_core12.Logger;
   protected readonly alepha: Alepha;
-  readonly onRequest: _alepha_core10.HookDescriptor<"server:onRequest">;
-  readonly onResponse: _alepha_core10.HookDescriptor<"server:onResponse">;
+  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;
@@ -491,22 +522,25 @@ 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/platforms/ServerProvider.d.ts
-declare class ServerProvider {
-  constructor();
-  get hostname(): string;
+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: _sinclair_typebox13.TNumber;
-  SERVER_HOST: _sinclair_typebox13.TString;
+  SERVER_PORT: _alepha_core15.TNumber;
+  SERVER_HOST: _alepha_core15.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$1>> {}
 }
-declare class NodeHttpServerProvider implements ServerProvider {
+declare class NodeHttpServerProvider extends ServerProvider {
   protected readonly alepha: Alepha;
   protected readonly log: _alepha_core15.Logger;
   protected readonly env: {
@@ -514,11 +548,11 @@ declare class NodeHttpServerProvider implements ServerProvider {
     SERVER_HOST: string;
   };
   protected readonly router: ServerRouterProvider;
-  protected readonly server: http18.Server<typeof IncomingMessage, typeof ServerResponse$1>;
-  handle(req: IncomingMessage, res: ServerResponse$1): Promise<number | void>;
+  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";
-  shouldHaveBody(method: string): boolean;
   get hostname(): string;
   readonly start: _alepha_core15.HookDescriptor<"start">;
   protected readonly stop: _alepha_core15.HookDescriptor<"stop">;
@@ -526,35 +560,12 @@ declare class NodeHttpServerProvider implements ServerProvider {
   protected close(): Promise<void>;
 }
 //#endregion
-//#region src/schemas/apiLinksResponseSchema.d.ts
-declare const apiLinkSchema: _sinclair_typebox37.TObject<{
-  name: _sinclair_typebox37.TString;
-  path: _sinclair_typebox37.TString;
-  method: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
-  group: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
-  requestBodyType: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
-  service: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
-}>;
-declare const apiLinksResponseSchema: _sinclair_typebox37.TObject<{
-  prefix: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
-  links: _sinclair_typebox37.TArray<_sinclair_typebox37.TObject<{
-    name: _sinclair_typebox37.TString;
-    path: _sinclair_typebox37.TString;
-    method: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
-    group: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
-    requestBodyType: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
-    service: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
-  }>>;
-}>;
-type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
-type ApiLink = Static<typeof apiLinkSchema>;
-//#endregion
 //#region src/providers/ServerActionDescriptorProvider.d.ts
-declare const envSchema: _alepha_core23.TObject<{
-  SERVER_API_PREFIX: _sinclair_typebox21.TString;
-  SERVER_SECURITY_ENABLED: _sinclair_typebox21.TBoolean;
+declare const envSchema: _alepha_core24.TObject<{
+  SERVER_API_PREFIX: _alepha_core24.TString;
+  SERVER_SECURITY_ENABLED: _alepha_core24.TBoolean;
 }>;
-declare module "alepha/core" {
+declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
   interface State {
     /**
@@ -566,7 +577,7 @@ declare module "alepha/core" {
   }
 }
 declare class ServerActionDescriptorProvider {
-  protected readonly log: _alepha_core23.Logger;
+  protected readonly log: _alepha_core24.Logger;
   protected readonly alepha: Alepha;
   protected readonly env: {
     SERVER_API_PREFIX: string;
@@ -579,7 +590,7 @@ declare class ServerActionDescriptorProvider {
   protected readonly actions: ServerRouteAction[];
   getActions(): ServerRouteAction<RequestConfigSchema>[];
   getPrefix(): string;
-  readonly configure: _alepha_core23.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.
@@ -622,29 +633,13 @@ interface ServerRouteAction<TConfig extends RequestConfigSchema = RequestConfigS
 }
 type LocalHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (config?: ServerRequestConfigEntry<TConfig>, options?: ClientRequestOptions) => Promise<any>;
 //#endregion
-//#region src/schemas/errorSchema.d.ts
-declare const errorSchema: _sinclair_typebox27.TObject<{
-  error: _sinclair_typebox27.TString;
-  status: _sinclair_typebox27.TNumber;
-  message: _sinclair_typebox27.TString;
-  details: _sinclair_typebox27.TOptional<_sinclair_typebox27.TString>;
-  cause: _sinclair_typebox27.TOptional<_sinclair_typebox27.TObject<{
-    name: _sinclair_typebox27.TString;
-    message: _sinclair_typebox27.TString;
-  }>>;
-}>;
-//#endregion
-//#region src/schemas/okSchema.d.ts
-declare const okSchema: _sinclair_typebox63.TObject<{
-  ok: _sinclair_typebox63.TBoolean;
-  id: _sinclair_typebox63.TOptional<_sinclair_typebox63.TUnion<[_sinclair_typebox63.TString, _sinclair_typebox63.TInteger]>>;
-  count: _sinclair_typebox63.TOptional<_sinclair_typebox63.TNumber>;
-}>;
-type Ok = Static<typeof okSchema>;
-//#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;
     };
@@ -684,10 +679,165 @@ declare module "@alepha/core" {
     };
   }
 }
+/**
+ * Provides high-performance HTTP server capabilities with declarative routing and action descriptors.
+ *
+ * The server module enables building REST APIs and web applications using `$route` and `$action` descriptors
+ * 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;
 }
+//# 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, KIND, LocalHandler, NodeHttpServerProvider, NotFoundError, Ok, RequestConfigSchema, ResponseBodyType, ResponseKind, RouteDescriptor, RouteDescriptorOptions, RouteMethod, ServerActionDescriptorProvider, ServerHandler, 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

package/topic/redis.d.ts

@@ -1,42 +1,41 @@
-import { SubscribeCallback, TopicProvider, UnSubscribeFn } from "@alepha/topic";
-import * as _alepha_core0 from "@alepha/core";
-import { Alepha } from "@alepha/core";
-import { RedisProvider, RedisSubscriberProvider } from "@alepha/redis";
+import { SubscribeCallback, TopicProvider, UnSubscribeFn } from "alepha/topic";
+import { Alepha, HookDescriptor, Logger, Module, Static, TObject, TString } from "alepha";
+import { RedisProvider, RedisSubscriberProvider } from "alepha/redis";
 
 //#region src/providers/RedisTopicProvider.d.ts
+declare const envSchema: TObject<{
+  REDIS_TOPIC_PREFIX: TString;
+}>;
 declare class RedisTopicProvider implements TopicProvider {
-  protected readonly env: {
-    REDIS_TOPIC_PREFIX: string;
-  };
+  protected readonly env: Static<typeof envSchema>;
   protected readonly redisProvider: RedisProvider;
   protected readonly redisSubscriberProvider: RedisSubscriberProvider;
-  protected readonly log: _alepha_core0.Logger;
-  protected readonly stop: _alepha_core0.HookDescriptor<"stop">;
+  protected readonly log: Logger;
+  protected readonly stop: HookDescriptor<"stop">;
   prefix(queue: string): string;
   /**
-   * Publish a message to a topic.
-   */
+  * Publish a message to a topic.
+  */
   publish(topic: string, message: string): Promise<void>;
   /**
-   * Subscribe to a topic.
-   */
+  * Subscribe to a topic.
+  */
   subscribe(name: string, callback: SubscribeCallback): Promise<UnSubscribeFn>;
   /**
-   * Unsubscribe from a topic.
-   */
+  * Unsubscribe from a topic.
+  */
   unsubscribe(name: string, callback?: SubscribeCallback): Promise<void>;
 }
 //#endregion
 //#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
 /**
- * Alepha Topic Redis Module.
- *
- * Plugin for Alepha Topic that provides Redis pub/sub capabilities.
- *
- * @see {@link RedisTopicProvider}
- * @module alepha.topic.redis
- */
-declare class AlephaTopicRedis {
+* Plugin for Alepha Topic that provides Redis pub/sub capabilities.
+*
+* @see {@link RedisTopicProvider}
+* @module alepha.topic.redis
+*/
+declare class AlephaTopicRedis implements Module {
   readonly name = "alepha.topic.redis";
   readonly $services: (alepha: Alepha) => Alepha;
 }