alepha 0.6.8 → 0.6.10

package/cache.d.ts

@@ -92,6 +92,7 @@ interface TSchema extends TKind, SchemaOptions {
 }
 
 declare class CacheProvider {
+    constructor();
     /**
      * Get the value of a key.
      *

package/core.d.ts

@@ -8,6 +8,7 @@ import { ValueError } from '@sinclair/typebox/errors';
 import { ReadableStream as ReadableStream$1 } from 'node:stream/web';
 import * as TypeBoxValue from '@sinclair/typebox/value';
 export { TypeBoxValue };
+import { Readable } from 'node:stream';
 
 /**
  * Used for identifying descriptors.
@@ -16,6 +17,13 @@ export { TypeBoxValue };
  */
 declare const KIND: unique symbol;
 
+/**
+ * Used for identifying descriptors.
+ *
+ * @internal
+ */
+declare const OPTIONS: unique symbol;
+
 /**
  * Represents a value that can be either a value or a promise.
  */
@@ -83,42 +91,7 @@ interface ClassProvider<T extends object = any> {
     parents: Array<Class | null>;
 }
 
-/**
- * Used for identifying descriptors.
- *
- * @internal
- */
-declare const OPTIONS: unique symbol;
-
 declare const KEY = "HOOK";
-interface Hooks {
-    /**
-     * Triggered during the configuration phase. Before the start phase.
-     *
-     * - Configuration should technically be called many times without any side effects.
-     * - Spamming Alepha#configure() should not cause any issues.
-     */
-    configure: Alepha;
-    /**
-     * Triggered during the start phase. When `Alepha#start()` is called.
-     *
-     * - Start is called only once. It should not be called multiple times.
-     */
-    start: Alepha;
-    /**
-     * Triggered during the ready phase. After the start phase.
-     *
-     * - Ready is called only once. It should not be called multiple times.
-     */
-    ready: Alepha;
-    /**
-     * Triggered during the stop phase.
-     *
-     * - Stop is called only once. It should not be called multiple times.
-     * - Stop should be called after a SIGINT or SIGTERM signal in order to gracefully shutdown the application.
-     */
-    stop: Alepha;
-}
 interface HookOptions<T extends keyof Hooks> {
     /**
      * The name of the hook. "configure", "start", "ready", "stop", ...
@@ -441,6 +414,35 @@ interface State {
     afterEach?: (run: any) => any;
     onTestFinished?: (run: any) => any;
 }
+interface Hooks {
+    echo: any;
+    /**
+     * Triggered during the configuration phase. Before the start phase.
+     *
+     * - Configuration should technically be called many times without any side effects.
+     * - Spamming Alepha#configure() should not cause any issues.
+     */
+    configure: Alepha;
+    /**
+     * Triggered during the start phase. When `Alepha#start()` is called.
+     *
+     * - Start is called only once. It should not be called multiple times.
+     */
+    start: Alepha;
+    /**
+     * Triggered during the ready phase. After the start phase.
+     *
+     * - Ready is called only once. It should not be called multiple times.
+     */
+    ready: Alepha;
+    /**
+     * Triggered during the stop phase.
+     *
+     * - Stop is called only once. It should not be called multiple times.
+     * - Stop should be called after a SIGINT or SIGTERM signal in order to gracefully shutdown the application.
+     */
+    stop: Alepha;
+}
 /**
  *
  *
@@ -622,10 +624,11 @@ declare class Alepha {
         skipRegistration?: boolean;
         args?: any[];
     }): T;
-    on<T extends keyof Hooks>(event: T, hook: Hook<T>): () => void;
+    on<T extends keyof Hooks>(event: T, hookOrFunc: Hook<T> | ((payload: Hooks[T]) => Async<void>)): () => void;
     emit<T extends keyof Hooks>(func: keyof Hooks, payload: Hooks[T], options?: {
         reverse?: boolean;
         log?: boolean;
+        catch?: boolean;
     }): Promise<void>;
     /**
      * Casts the given value to the specified schema.
@@ -733,11 +736,15 @@ declare const $logger: (name?: string) => Logger;
  */
 interface RetryDescriptorOptions<T extends (...args: any[]) => any> {
     /**
+     * Maximum number of attempts.
      *
+     * @default 3
      */
     max?: number;
     /**
+     * Delay in milliseconds.
      *
+     * @default 0
      */
     delay?: number;
     /**
@@ -778,26 +785,6 @@ declare class TypeBoxError extends Error {
     constructor(value: ValueError);
 }
 
-interface EventEmitterItem<T extends object> {
-    name: keyof T;
-    handler: (arg: any) => Async<void>;
-}
-declare class EventEmitter<T extends object> {
-    protected events: EventEmitterItem<T>[];
-    /**
-     *
-     * @param name
-     * @param handler
-     */
-    on<Key extends keyof T>(name: Key, handler: (arg: T[Key]) => void): () => void;
-    /**
-     *
-     * @param name
-     * @param data
-     */
-    emit<Key extends keyof T>(name: Key, data: T[Key]): Promise<void>;
-}
-
 declare class TypeProvider {
     static DEFAULT_STRING_MAX_LENGTH: number;
     static DEFAULT_LONG_STRING_MAX_LENGTH: number;
@@ -963,19 +950,25 @@ declare class TypeProvider {
     file: (options?: {
         max?: number;
     }) => TFile;
+    stream: () => TStream;
 }
 interface FileLike {
     name: string;
     type: string;
     size: number;
     lastModified: number;
-    stream(): ReadableStream | ReadableStream$1;
+    stream(): StreamLike;
     arrayBuffer(): Promise<ArrayBuffer>;
     text(): Promise<string>;
+    filepath?: string;
 }
-declare const t: TypeProvider;
 type TFile = TUnsafe<FileLike>;
+type StreamLike = ReadableStream | ReadableStream$1 | Readable;
+type TStream = TUnsafe<StreamLike>;
+declare const t: TypeProvider;
 declare const isTypeFile: (value: TSchema) => value is TFile;
+declare const isFileLike: (value: any) => value is FileLike;
+declare const isTypeStream: (value: TSchema) => value is TStream;
 type TextLength = "short" | "long" | "rich";
 interface AlephaStringOptions extends StringOptions {
     size?: TextLength;
@@ -988,4 +981,4 @@ declare const run: (arg: Alepha | Class | ((env?: Env) => Alepha), opts?: {
     ready?: (alepha: Alepha) => Async<void>;
 }) => Alepha;
 
-export { $cursor, $hook, $inject, $logger, $retry, Alepha, type AlephaStringOptions, AppNotStartedError, type Async, type AsyncFn, type AsyncLocalStorageData, AsyncLocalStorageProvider, COLORS, CircularDependencyError, type Class, type ClassEntry, type ClassProvider, type ClassSwap, ContainerLockedError, type CursorDescriptor, type Descriptor, type DescriptorIdentifier, type DescriptorItem, type Env, EventEmitter, type EventEmitterItem, EventEmitterLike, type FileLike, type Hook, type HookDescriptor, type HookOptions, type Hooks, KIND, LEVEL_COLORS, type LogLevel, Logger, type LoggerEnv, type LoggerOptions, MockLogger, type MockLoggerStore, NotImplementedError, OPTIONS, PROVIDER, type PromiseFn, type RetryDescriptorOptions, type State, type TFile, type TextLength, TypeBoxError, TypeProvider, __alephaRef, __bind, __descriptor, descriptorEvents, isDescriptorValue, isTypeFile, isUUID, run, t };
+export { $cursor, $hook, $inject, $logger, $retry, Alepha, type AlephaStringOptions, AppNotStartedError, type Async, type AsyncFn, type AsyncLocalStorageData, AsyncLocalStorageProvider, COLORS, CircularDependencyError, type Class, type ClassEntry, type ClassProvider, type ClassSwap, ContainerLockedError, type CursorDescriptor, type Descriptor, type DescriptorIdentifier, type DescriptorItem, type Env, EventEmitterLike, type FileLike, type Hook, type HookDescriptor, type HookOptions, type Hooks, KIND, LEVEL_COLORS, type LogLevel, Logger, type LoggerEnv, type LoggerOptions, MockLogger, type MockLoggerStore, NotImplementedError, OPTIONS, PROVIDER, type PromiseFn, type RetryDescriptorOptions, type State, type StreamLike, type TFile, type TStream, type TextLength, TypeBoxError, TypeProvider, __alephaRef, __bind, __descriptor, descriptorEvents, isDescriptorValue, isFileLike, isTypeFile, isTypeStream, isUUID, run, t };

package/lock.d.ts

@@ -123,6 +123,7 @@ declare const $lock: {
  * Store Provider Interface
  */
 declare class LockProvider {
+    constructor();
     /**
      * Set the string value of a key.
      *
@@ -238,7 +239,7 @@ declare class MemoryLockProvider implements LockProvider {
 /**
  * A store provider that uses Redis.
  */
-declare class RedisLockProvider extends LockProvider {
+declare class RedisLockProvider implements LockProvider {
     protected readonly log: _alepha_core.Logger;
     protected readonly redisProvider: RedisProvider;
     /**

package/package.json

@@ -1,31 +1,37 @@
 {
 	"name": "alepha",
-	"version": "0.6.8",
+	"version": "0.6.10",
 	"type": "module",
 	"license": "MIT",
+	"description": "TypeScript framework for building full-stack apps with strict conventions, custom schemas, and React-based SPA or SSR without filesystem-based routing.",
+	"homepage": "https://github.com/feunard/alepha",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/feunard/alepha.git"
+	},
 	"main": "./core.js",
 	"types": "./core.d.ts",
 	"dependencies": {
-		"@alepha/cache": "0.6.8",
-		"@alepha/core": "0.6.8",
-		"@alepha/datetime": "0.6.8",
-		"@alepha/lock": "0.6.8",
-		"@alepha/postgres": "0.6.8",
-		"@alepha/queue": "0.6.8",
-		"@alepha/react": "0.6.8",
-		"@alepha/react-auth": "0.6.8",
-		"@alepha/redis": "0.6.8",
-		"@alepha/scheduler": "0.6.8",
-		"@alepha/security": "0.6.8",
-		"@alepha/server": "0.6.8",
-		"@alepha/server-cookies": "0.6.8",
-		"@alepha/server-metrics": "0.6.8",
-		"@alepha/server-proxy": "0.6.8",
-		"@alepha/server-static": "0.6.8",
-		"@alepha/server-swagger": "0.6.8",
-		"@alepha/testing": "0.6.8",
-		"@alepha/topic": "0.6.8",
-		"@alepha/vite": "0.6.8"
+		"@alepha/cache": "0.6.10",
+		"@alepha/core": "0.6.10",
+		"@alepha/datetime": "0.6.10",
+		"@alepha/lock": "0.6.10",
+		"@alepha/postgres": "0.6.10",
+		"@alepha/queue": "0.6.10",
+		"@alepha/react": "0.6.10",
+		"@alepha/react-auth": "0.6.10",
+		"@alepha/redis": "0.6.10",
+		"@alepha/scheduler": "0.6.10",
+		"@alepha/security": "0.6.10",
+		"@alepha/server": "0.6.10",
+		"@alepha/server-cookies": "0.6.10",
+		"@alepha/server-metrics": "0.6.10",
+		"@alepha/server-proxy": "0.6.10",
+		"@alepha/server-static": "0.6.10",
+		"@alepha/server-swagger": "0.6.10",
+		"@alepha/testing": "0.6.10",
+		"@alepha/topic": "0.6.10",
+		"@alepha/vite": "0.6.10"
 	},
 	"peerDependencies": {
 		"@types/react": "^19",
@@ -159,5 +165,19 @@
 			"require": "./server/swagger.cjs",
 			"types": "./server/swagger.d.ts"
 		}
-	}
+	},
+	"keywords": [
+		"alepha",
+		"cache",
+		"datetime",
+		"lock",
+		"postgres",
+		"queue",
+		"react",
+		"redis",
+		"scheduler",
+		"security",
+		"server",
+		"topic"
+	]
 }

package/postgres.d.ts

@@ -1,7 +1,7 @@
 import * as _alepha_core from '@alepha/core';
 import { TObject as TObject$1, Static as Static$1, Alepha, KIND, OPTIONS } from '@alepha/core';
 import * as _sinclair_typebox from '@sinclair/typebox';
-import { TObject, Static, TSchema, ObjectOptions, Kind, TProperties, Evaluate, TReadonly, TOptional, TAdditionalProperties, OptionalKind, TArray, TIntersect, TBoolean, TInteger, IntegerOptions, StringOptions, TOptionalWithFlag } from '@sinclair/typebox';
+import { TObject, Static, TSchema, ObjectOptions, Kind, TProperties, Evaluate, TReadonly, TOptional, TAdditionalProperties, OptionalKind, TArray, TIntersect, TRecord, TBoolean, TInteger, IntegerOptions, StringOptions, TOptionalWithFlag } from '@sinclair/typebox';
 import * as drizzle_orm from 'drizzle-orm';
 import { TableConfig, SQLWrapper, SQL, BuildColumns } from 'drizzle-orm';
 export { sql } from 'drizzle-orm';
@@ -114,6 +114,7 @@ type PgTableWithColumnsAndSchema<T extends TableConfig, R extends TObject$1> = P
 
 type SQLLike = SQLWrapper | string;
 declare class PostgresProvider {
+    constructor();
     /**
      * Get the database instance
      */
@@ -662,11 +663,11 @@ type PageQuery = Static$1<typeof pageQuerySchema>;
  * @param objectSchema
  * @param options
  */
-declare const pageSchema: <T extends TObject | TIntersect>(objectSchema: T, options?: ObjectOptions) => TPage<T>;
+declare const pageSchema: <T extends TObject | TIntersect | TRecord>(objectSchema: T, options?: ObjectOptions) => TPage<T>;
 /**
  *
  */
-type TPage<T extends TObject | TIntersect> = TObject<{
+type TPage<T extends TObject | TIntersect | TRecord> = TObject<{
     content: TArray<T>;
     can: TObject<{
         next: TBoolean;
@@ -696,10 +697,6 @@ type Page<T> = {
  *
  */
 declare class Repository<TTable extends PgTableWithColumns<TableConfig$1>, TTableSchema extends TObject> {
-    readonly options: {
-        table: TTable;
-        schema: TTableSchema;
-    };
     readonly provider: PostgresProvider;
     protected readonly alepha: Alepha;
     static of: <TEntity extends TableConfig$1, TSchema extends TObject>(table: PgTableWithColumnsAndSchema<TEntity, TSchema>) => (new () => Repository<PgTableWithColumnsAndSchema<TEntity, TSchema>, TSchema>);
@@ -724,6 +721,10 @@ declare class Repository<TTable extends PgTableWithColumns<TableConfig$1>, TTabl
         table: TTable;
         schema: TTableSchema;
     };
+    readonly options: {
+        table: TTable;
+        schema: TTableSchema;
+    };
     constructor(options: {
         table: TTable;
         schema: TTableSchema;

package/queue.d.ts

@@ -60,6 +60,7 @@ interface TSchema extends TKind, SchemaOptions {
 }
 
 declare class QueueProvider {
+    constructor();
     /**
      * Push a message to the queue.
      *

package/redis.d.ts

@@ -1,7 +1,7 @@
 import * as _alepha_core from '@alepha/core';
 import { Static, Alepha } from '@alepha/core';
 import * as Redis from 'ioredis';
-import Redis__default from 'ioredis';
+import Redis__default, { RedisOptions } from 'ioredis';
 
 /** Symbol key applied to readonly types */
 declare const ReadonlyKind: unique symbol;
@@ -110,6 +110,7 @@ declare class RedisProvider {
      * Close the connection to the Redis server.
      */
     close(): Promise<void>;
+    duplicate(options?: Partial<RedisOptions>): RedisClient;
     /**
      * Redis subscriber client factory method.
      */

package/security.d.ts

@@ -2,6 +2,28 @@ import * as _alepha_core from '@alepha/core';
 import { Static as Static$1, KIND, OPTIONS, Alepha } from '@alepha/core';
 import { JWSHeaderParameters, FlattenedJWSInput, CryptoKey, KeyObject, JSONWebKeySet, JWTVerifyResult, JWTPayload, JWTHeaderParameters } from 'jose';
 
+/**
+ * Represents a User Account extracted from JWT.
+ */
+interface UserAccountInfo {
+    /**
+     * ID of user account. Based on JWT.sub.
+     */
+    id: string;
+    /**
+     * Represents the roles assigned to a user.
+     */
+    roles?: string[];
+    /**
+     * User full name, if available.
+     */
+    name?: string;
+    /**
+     * Organization ID, if available.
+     */
+    organization?: string;
+}
+
 /** Symbol key applied to readonly types */
 declare const ReadonlyKind: unique symbol;
 /** Symbol key applied to optional types */
@@ -142,39 +164,6 @@ interface TSchema extends TKind, SchemaOptions {
     static: unknown;
 }
 
-declare const roleSchema: TObject<{
-    name: TString;
-    description: TOptional<TString>;
-    default: TOptional<TBoolean>;
-    permissions: TArray<TObject<{
-        name: TString;
-        ownership: TOptional<TBoolean>;
-    }>>;
-}>;
-type Role = Static$1<typeof roleSchema>;
-
-/**
- * Represents a User Account extracted from JWT.
- */
-interface UserAccountInfo {
-    /**
-     * ID of user account. Based on JWT.sub.
-     */
-    id: string;
-    /**
-     * Represents the roles assigned to a user.
-     */
-    roles?: Role[];
-    /**
-     * User full name, if available.
-     */
-    name?: string;
-    /**
-     * Organization ID, if available.
-     */
-    organization?: string;
-}
-
 declare const permissionSchema: TObject<{
     name: TString;
     group: TOptional<TString>;
@@ -241,6 +230,17 @@ interface UserAccountToken extends UserAccountInfo {
     ownership?: string | boolean;
 }
 
+declare const roleSchema: TObject<{
+    name: TString;
+    description: TOptional<TString>;
+    default: TOptional<TBoolean>;
+    permissions: TArray<TObject<{
+        name: TString;
+        ownership: TOptional<TBoolean>;
+    }>>;
+}>;
+type Role = Static$1<typeof roleSchema>;
+
 /**
  * Provides utilities for working with JSON Web Tokens (JWT).
  */
@@ -406,9 +406,9 @@ declare class SecurityProvider {
      * Bonus: we check also if the user has "ownership" flag.
      *
      * @param permissionLike - The permission to check for.
-     * @param roles - The roles to check for the permission.
+     * @param roleEntries - The roles to check for the permission.
      */
-    checkPermission(permissionLike: string | Permission, ...roles: Role[]): SecurityCheckResult;
+    checkPermission(permissionLike: string | Permission, ...roleEntries: string[]): SecurityCheckResult;
     /**
      * Creates a user account from the provided payload.
      *
@@ -423,7 +423,7 @@ declare class SecurityProvider {
      * @param permission - The permission to check for.
      * @returns True if the user has the role, false otherwise.
      */
-    can(roleName: string, permission: string | Permission): boolean;
+    can(role: string, permission: string | Permission): boolean;
     /**
      * Converts a permission object to a string.
      *
@@ -550,6 +550,10 @@ interface RealmDescriptor {
      * Set all roles in the realm.
      */
     setRoles(roles: Role[]): Promise<void>;
+    /**
+     * Get a role by name, throws an error if not found.
+     */
+    getRoleByName(name: string): Role;
     /**
      * Create a token for the subject.
      */

package/server/proxy.d.ts

@@ -5,9 +5,10 @@ import { ServerRequest, ServerRouterProvider } from '@alepha/server';
 type ProxyDescriptorOptions = {
     path: string;
     target: string;
+    disabled?: boolean;
     beforeRequest?: (request: ServerRequest, proxyRequest: RequestInit) => Async<void>;
     afterResponse?: (request: ServerRequest, proxyResponse: Response) => Async<void>;
-    disabled?: boolean;
+    rewrite?: (url: URL) => void;
 };
 interface ProxyDescriptor {
     [KIND]: "PROXY";

package/server.d.ts

@@ -1,10 +1,10 @@
 import * as _alepha_core from '@alepha/core';
-import { Static as Static$1, TSchema as TSchema$1, Async, Alepha, OPTIONS, KIND, FileLike } from '@alepha/core';
+import { Static as Static$1, TObject as TObject$1, TSchema as TSchema$1, Async, StreamLike, Alepha, OPTIONS, KIND, FileLike } from '@alepha/core';
 export { KIND } from '@alepha/core';
-import { UserAccountToken, Permission, SecurityProvider } from '@alepha/security';
+import { UserAccountToken, Permission, SecurityProvider, JwtProvider } from '@alepha/security';
 import { IncomingMessage, ServerResponse as ServerResponse$1 } from 'node:http';
 import { Readable } from 'node:stream';
-import { ReadableStream as ReadableStream$1 } from 'node:stream/web';
+import { ReadableStream } from 'node:stream/web';
 import { Route, RouterProvider } from '@alepha/router';
 import * as _alepha_cache from '@alepha/cache';
 import { DurationLike } from '@alepha/datetime';
@@ -189,7 +189,7 @@ interface TSchema extends TKind, SchemaOptions {
 declare const routeMethods: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "CONNECT", "TRACE"];
 type RouteMethod = (typeof routeMethods)[number];
 
-declare const envSchema$4: _alepha_core.TObject<{
+declare const envSchema$4: TObject$1<{
     SERVER_ALS_ENABLED: TBoolean;
 }>;
 declare module "alepha" {
@@ -211,7 +211,7 @@ declare class ServerRouterProvider extends RouterProvider<ServerRouteWithHandler
         };
         body: any;
     }>;
-    protected doRequestHandler(route: ServerRoute, request: ServerRequest, responseType: ResponseType, withAls: boolean): Promise<void>;
+    protected tryRequestProcessing(route: ServerRoute, request: ServerRequest, responseType: ResponseType, withAls: boolean): Promise<void>;
     protected getResponseType(schema?: RequestConfigSchema): ResponseType;
     protected errorHandler(route: ServerRoute, request: ServerRequest, error: Error): Promise<void>;
     validateRequest(route: {
@@ -221,16 +221,16 @@ declare class ServerRouterProvider extends RouterProvider<ServerRouteWithHandler
 }
 interface RequestConfigSchema {
     body?: TSchema$1;
-    params?: TSchema$1;
-    query?: TSchema$1;
-    headers?: TSchema$1;
+    params?: TObject$1;
+    query?: TObject$1;
+    headers?: TObject$1;
     response?: TSchema$1;
 }
 interface ServerRequestConfig<TConfig extends RequestConfigSchema = RequestConfigSchema> {
     body: TConfig["body"] extends TSchema$1 ? Static$1<TConfig["body"]> : any;
-    headers: TConfig["headers"] extends TSchema$1 ? Static$1<TConfig["headers"]> : Record<string, string>;
-    params: TConfig["params"] extends TSchema$1 ? Static$1<TConfig["params"]> : Record<string, string>;
-    query: TConfig["query"] extends TSchema$1 ? Static$1<TConfig["query"]> : Record<string, string>;
+    headers: TConfig["headers"] extends TObject$1 ? Static$1<TConfig["headers"]> : Record<string, string>;
+    params: TConfig["params"] extends TObject$1 ? Static$1<TConfig["params"]> : Record<string, string>;
+    query: TConfig["query"] extends TObject$1 ? Static$1<TConfig["query"]> : Record<string, string>;
 }
 type ServerRequestConfigEntry<TConfig extends RequestConfigSchema = RequestConfigSchema> = Partial<ServerRequestConfig<TConfig>>;
 interface ServerRequest<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRequestConfig<TConfig> {
@@ -244,7 +244,7 @@ interface ServerRequest<TConfig extends RequestConfigSchema = RequestConfigSchem
             res: ServerResponse$1;
         };
     };
-    user?: UserAccountToken;
+    user: UserAccountToken;
 }
 interface ServerRoute<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Route {
     method?: RouteMethod;
@@ -253,19 +253,19 @@ interface ServerRoute<TConfig extends RequestConfigSchema = RequestConfigSchema>
     schema?: TConfig;
 }
 type ServerResponseBody<TConfig extends RequestConfigSchema = RequestConfigSchema> = TConfig["response"] extends TSchema$1 ? Static$1<TConfig["response"]> : ResponseBodyType;
-type ResponseType = "json" | "text" | "void" | "stream" | "buffer" | "file";
-type ResponseBodyType = string | ArrayBuffer | Readable | ReadableStream$1 | ReadableStream | undefined | null | void;
+type ResponseType = "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>>;
 interface ServerReply {
     headers: Record<string, string> & {
         "set-cookie"?: string[];
     };
     status?: number;
-    body?: ResponseBodyType;
+    body?: any;
     redirect(url: string): void;
 }
 interface ServerResponse {
-    body: string | ArrayBuffer | Readable | ReadableStream$1;
+    body: string | ArrayBuffer | Readable | ReadableStream;
     headers: Record<string, string>;
     status: number;
 }
@@ -426,7 +426,12 @@ declare class HttpError extends Error {
         cause: {
             name: string;
             message: string;
-        } | undefined;
+        };
+    } | {
+        status: number;
+        error: string | undefined;
+        message: string;
+        cause?: undefined;
     };
     readonly status: number;
     readonly error?: string;
@@ -446,23 +451,41 @@ declare class HttpError extends Error {
 }
 declare const errorNameByStatus: Record<number, string>;
 
+declare class RouteDescriptorHelper {
+    name(options: RouteDescriptorOptions, instance: any, key: string): string;
+    path(options: RouteDescriptorOptions, instance: any, key: string, prefix?: string): string;
+    link(options: RouteDescriptorOptions, instance: any, key: string, prefix?: string): HttpClientLink;
+    method(options: {
+        method?: string;
+        schema?: any;
+    }): RouteMethod;
+    permission(options: RouteDescriptorOptions, instance: any, key: string, prefix?: string): Permission;
+    group(options: RouteDescriptorOptions, instance: any): string;
+    isMultipart(options: {
+        schema?: RequestConfigSchema;
+    }): boolean;
+    bodyContentType(options: RouteDescriptorOptions): string | undefined;
+    protected short(name: string): string;
+}
+
 declare class HttpClient {
     protected readonly alepha: Alepha;
     protected readonly env: {
         SERVER_API_URL: string;
+        CLIENT_API_PREFIX: string;
     };
+    protected readonly helper: RouteDescriptorHelper;
     readonly URL_LINKS = "/_links";
     readonly cache: _alepha_cache.CacheDescriptor<any, any[]>;
     links?: Array<HttpClientLink>;
     protected readonly pendingRequests: HttpClientPendingRequests;
-    protected host: string;
     json<T = any>(url: string, options?: RequestInit): Promise<T>;
     clear(): Promise<void>;
-    createFetchFunction(link: HttpClientLink, options?: FetchFactoryAdditionalOptions): (config?: Partial<ClientRequestEntry>, fetchOptions?: ClientRequestOptions) => Promise<any>;
+    createFetchFunction(link: HttpClientLink, options?: FetchFactoryAdditionalOptions): (config?: Partial<ClientRequestEntry>, request?: ClientRequestOptions) => Promise<any>;
     request(args: {
-        link: HttpClientLink;
-        fetch?: ClientRequestOptions;
         config?: ServerRequestConfigEntry;
+        link: HttpClientLink;
+        request?: ClientRequestOptions;
         host?: string;
     }): Promise<any>;
     protected url(host: string, link: HttpClientLink, args: ServerRequestConfigEntry): string;
@@ -476,12 +499,23 @@ declare class HttpClient {
      * @protected
      */
     protected response(response: Response, options: FetchRunOptions): Promise<Response | any>;
+    protected isMaybeFile(response: Response): boolean;
+    protected getFileLike(response: Response, defaultFileName?: string): FileLike;
     protected pathVariables(url: string, action: HttpClientLink, args?: ServerRequestConfigEntry): string;
-    protected queryParams(url: string, action: HttpClientLink, args?: ServerRequestConfigEntry): string;
+    queryParams(url: string, action: {
+        schema?: {
+            query?: TObject$1;
+        };
+    }, args?: ServerRequestConfigEntry): string;
     of<T extends object>(options?: {
         group?: string;
         host?: string | (() => string);
     }): HttpVirtualClient<T>;
+    follow(name: string, config?: any, options?: {
+        request?: ClientRequestOptions;
+        group?: string;
+        host?: string | (() => string);
+    }): Promise<any>;
     can(name: string): boolean;
     getLinks(opts?: {
         force?: boolean;
@@ -506,6 +540,8 @@ interface HttpClientLink {
     protected?: boolean;
     schema?: RequestConfigSchema;
     handler?: ServerHandler;
+    host?: string;
+    proxy?: boolean;
 }
 type HttpVirtualClient<T> = {
     [K in keyof T as T[K] extends RouteDescriptor ? K : never]: T[K] & {
@@ -519,11 +555,23 @@ interface RemoteDescriptorOptions {
      * The URL of the remote service.
      */
     url: string | (() => string);
+    /**
+     * @default "/api/_links"
+     */
+    linkPath?: string;
+    /**
+     * If true, all methods of the remote service will be exposed as actions.
+     */
+    proxy?: boolean | {
+        beforeRequest?: (request: ServerRequest, proxyRequest: RequestInit) => Async<void>;
+        afterResponse?: (request: ServerRequest, proxyResponse: Response) => Async<void>;
+        rewrite?: (url: URL) => void;
+    };
     /**
      * One or many instance of classes to be registered as remote services.
      * Services must contain some $action() descriptors.
      */
-    services: object | Array<object>;
+    services?: object | Array<object>;
     /**
      * The name of the remote service.
      *
@@ -540,24 +588,8 @@ declare const $remote: {
     [KIND]: string;
 };
 
-declare class RouteDescriptorHelper {
-    name(options: RouteDescriptorOptions, instance: any, key: string): string;
-    path(options: RouteDescriptorOptions, instance: any, key: string, prefix?: string): string;
-    link(options: RouteDescriptorOptions, instance: any, key: string, prefix?: string): HttpClientLink;
-    method(options: {
-        method?: string;
-        schema?: any;
-    }): RouteMethod;
-    permission(options: RouteDescriptorOptions, instance: any, key: string, prefix?: string): Permission;
-    group(options: RouteDescriptorOptions, instance: any): string;
-    isMultipart(options: {
-        schema?: RequestConfigSchema;
-    }): boolean;
-    bodyContentType(options: RouteDescriptorOptions): string | undefined;
-    protected short(name: string): string;
-}
-
 declare class ServerProvider {
+    constructor();
     get hostname(): string;
 }
 
@@ -584,7 +616,14 @@ declare class ServerActionDescriptorProvider {
     protected readonly actions: ServerRouteAction[];
     getActions(): ServerRouteAction<RequestConfigSchema>[];
     readonly configure: _alepha_core.HookDescriptor<"configure">;
-    registerRemote(value: RemoteDescriptor, key: string): void;
+    registerRemote(value: RemoteDescriptor, key: string): Promise<void>;
+    loadRemoteLinks: (options: RemoteDescriptorOptions) => Promise<Promise<void>>;
+    proxy(url: string, link: HttpClientLink, options: {
+        beforeRequest?: (request: ServerRequest, proxyRequest: RequestInit) => Async<void>;
+        afterResponse?: (request: ServerRequest, proxyResponse: Response) => Async<void>;
+        rewrite?: (url: URL) => void;
+    }): Promise<void>;
+    private getRawRequestBody;
     registerAction(value: RouteDescriptor, key: string, instance: any, prefix?: string): Promise<void>;
     /**
      * When your action has no handler, it's considered as an 'API'.
@@ -642,6 +681,7 @@ interface ServerRemote {
     url: string;
     services: object[];
     name: string;
+    proxy: boolean;
 }
 interface ServerRouteAction<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRoute<TConfig> {
     method: RouteMethod;
@@ -667,13 +707,16 @@ declare class BrowserActionDescriptorProvider {
     };
     protected readonly helper: RouteDescriptorHelper;
     readonly configure: _alepha_core.HookDescriptor<"configure">;
+    configureActions(): void;
     registerAction(value: RouteDescriptor, instance: any, key: string): void;
 }
 
 declare class ServerSecurityProvider {
     protected readonly log: _alepha_core.Logger;
     protected readonly securityProvider: SecurityProvider;
+    protected readonly jwtProvider: JwtProvider;
     protected readonly alepha: Alepha;
+    readonly onClientRequest: _alepha_core.HookDescriptor<"client:onRequest">;
     protected readonly onRequest: _alepha_core.HookDescriptor<"server:onRequest">;
     protected readonly onRoute: _alepha_core.HookDescriptor<"server:onRoute">;
 }
@@ -705,7 +748,7 @@ declare class ServerMultipartProvider {
     protected readonly helper: RouteDescriptorHelper;
     protected readonly alepha: Alepha;
     readonly onRequest: _alepha_core.HookDescriptor<"server:onRequest">;
-    readonly onSend: _alepha_core.HookDescriptor<"server:onSend">;
+    readonly onSend: _alepha_core.HookDescriptor<"server:onResponse">;
     handleMultipartBodyFromNode(route: ServerRoute, stream: IncomingMessage): Promise<{
         body: Record<string, any>;
         cleanup: () => Promise<void>;
@@ -727,12 +770,13 @@ interface HybridFile extends FileLike {
 /**
  * Create a file-like object from various sources.
  */
-declare const file: (source: string | Buffer | ArrayBuffer, // TODO: FileLike, Blob, WebStream, NodeStream
-options?: {
+declare const file: (source: string | Buffer | ArrayBuffer | StreamLike, options?: {
     type?: string;
     name?: string;
-}) => Promise<FileLike>;
-declare const isFileLike: (value: any) => value is FileLike;
+}) => FileLike;
+declare const bufferToStream: (buffer: Buffer) => Readable;
+declare const streamToBuffer: (stream: Readable) => Promise<Buffer>;
+declare const bufferToArrayBuffer: (buffer: Buffer) => ArrayBuffer;
 declare const getContentType: (filename: string) => string;
 
 declare const envSchema$1: _alepha_core.TObject<{
@@ -837,6 +881,11 @@ declare module "@alepha/core" {
             headers: Record<string, string>;
             request: RequestInit;
         };
+        "client:beforeFetch": {
+            url: string;
+            options: FetchRunOptions;
+            request: RequestInit;
+        };
         "client:onError": {
             route?: HttpClientLink;
             error: HttpError;
@@ -855,4 +904,4 @@ declare class ServerModule {
     constructor();
 }
 
-export { $action, $remote, $route, BadRequestError, BrowserActionDescriptorProvider, type ClientRequestEntry, type ClientRequestEntryContainer, type ClientRequestOptions, type ClientRequestResponse, ConflictError, type FetchFactoryAdditionalOptions, type FetchRunOptions, ForbiddenError, HttpClient, type HttpClientLink, type HttpClientPendingRequests, HttpError, type HttpVirtualClient, NodeHttpServerProvider, NotFoundError, type Ok, REMOTE_DESCRIPTOR_KEY, type RemoteDescriptor, type RemoteDescriptorOptions, type RequestConfigSchema, type ResponseBodyType, type ResponseType, type RouteDescriptor, type RouteDescriptorOptions, type RouteMethod, ServerActionDescriptorProvider, type ServerHandler, ServerLinksProvider, ServerLoggerProvider, ServerModule, ServerMultipartProvider, ServerProvider, type ServerRawRequest, type ServerRemote, type ServerReply, type ServerRequest, type ServerRequestConfig, type ServerRequestConfigEntry, type ServerResponse, type ServerResponseBody, type ServerRoute, type ServerRouteAction, type ServerRouteWithHandler, ServerRouterProvider, ServerSecurityProvider, UnauthorizedError, ValidationError, errorNameByStatus, errorSchema, file, getContentType, isFileLike, isServerAction, okSchema, routeMethods };
+export { $action, $remote, $route, BadRequestError, BrowserActionDescriptorProvider, type ClientRequestEntry, type ClientRequestEntryContainer, type ClientRequestOptions, type ClientRequestResponse, ConflictError, type FetchFactoryAdditionalOptions, type FetchRunOptions, ForbiddenError, HttpClient, type HttpClientLink, type HttpClientPendingRequests, HttpError, type HttpVirtualClient, NodeHttpServerProvider, NotFoundError, type Ok, REMOTE_DESCRIPTOR_KEY, type RemoteDescriptor, type RemoteDescriptorOptions, type RequestConfigSchema, type ResponseBodyType, type ResponseType, type RouteDescriptor, type RouteDescriptorOptions, type RouteMethod, ServerActionDescriptorProvider, type ServerHandler, ServerLinksProvider, ServerLoggerProvider, ServerModule, ServerMultipartProvider, ServerProvider, type ServerRawRequest, type ServerRemote, type ServerReply, type ServerRequest, type ServerRequestConfig, type ServerRequestConfigEntry, type ServerResponse, type ServerResponseBody, type ServerRoute, type ServerRouteAction, type ServerRouteWithHandler, ServerRouterProvider, ServerSecurityProvider, UnauthorizedError, ValidationError, bufferToArrayBuffer, bufferToStream, errorNameByStatus, errorSchema, file, getContentType, isServerAction, okSchema, routeMethods, streamToBuffer };

package/topic.d.ts

@@ -47,6 +47,7 @@ interface TSchema extends TKind, SchemaOptions {
 }
 
 declare class TopicProvider {
+    constructor();
     /**
      * Publish a message to a topic.
      *