alepha 0.7.3 → 0.7.5

package/react.d.ts

@@ -1,8 +1,9 @@
 import * as _alepha_core from '@alepha/core';
-import { TSchema as TSchema$1, KIND, OPTIONS, Static as Static$1, Async, Alepha, Service, TObject as TObject$1 } from '@alepha/core';
-import { ServerRoute, ServerRequest, ApiLinksResponse, HttpClient, ClientScope, HttpVirtualClient, ServerRouterProvider, ServerTimingProvider, ServerHandler } from '@alepha/server';
+import { TSchema as TSchema$1, KIND, OPTIONS, Static, Async, Alepha, Service, TObject, Module } from '@alepha/core';
+import { ServerRequest, ApiLinksResponse, HttpClient, ClientScope, HttpVirtualClient, ServerRouterProvider, ServerTimingProvider, ServerHandler } from '@alepha/server';
 import * as React from 'react';
 import React__default, { PropsWithChildren, ReactNode, FC, ErrorInfo, AnchorHTMLAttributes } from 'react';
+import { ServerRouteCache } from '@alepha/server-cache';
 import { Root } from 'react-dom/client';
 import { RouterProvider, Route } from '@alepha/router';
 import * as react_jsx_runtime from 'react/jsx-runtime';
@@ -17,10 +18,6 @@ declare const Hint: unique symbol;
 /** Symbol key applied to types */
 declare const Kind: unique symbol;
 
-type TReadonly<T extends TSchema> = T & {
-    [ReadonlyKind]: 'Readonly';
-};
-
 type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
 type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
 interface StringOptions extends SchemaOptions {
@@ -53,49 +50,6 @@ type TOptional<T extends TSchema> = T & {
     [OptionalKind]: 'Optional';
 };
 
-/** Creates a static type from a TypeBox type */
-type Static<Type extends TSchema, Params extends unknown[] = [], Result = (Type & {
-    params: Params;
-})['static']> = Result;
-
-type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never;
-}[keyof T];
-type ReadonlyPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? never : K) : never;
-}[keyof T];
-type OptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : K) : never;
-}[keyof T];
-type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
-type ObjectStaticProperties<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
-type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, {
-    [K in keyof T]: Static<T[K], P>;
-}>;
-type TPropertyKey = string | number;
-type TProperties = Record<TPropertyKey, TSchema>;
-type TAdditionalProperties = undefined | TSchema | boolean;
-interface ObjectOptions extends SchemaOptions {
-    /** Additional property constraints for this object */
-    additionalProperties?: TAdditionalProperties;
-    /** The minimum number of properties allowed on this object */
-    minProperties?: number;
-    /** The maximum number of properties allowed on this object */
-    maxProperties?: number;
-}
-interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
-    [Kind]: 'Object';
-    static: ObjectStatic<T, this['params']>;
-    additionalProperties?: TAdditionalProperties;
-    type: 'object';
-    properties: T;
-    required?: string[];
-}
-
-type Evaluate<T> = T extends infer O ? {
-    [K in keyof O]: O[K];
-} : never;
-
 interface SchemaOptions {
     $schema?: string;
     /** Id for this schema */
@@ -148,7 +102,7 @@ interface PageConfigSchema {
 }
 type TPropsDefault = any;
 type TPropsParentDefault = {};
-interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> extends Pick<ServerRoute, "cache"> {
+interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
     /**
      * Name your page.
      *
@@ -228,6 +182,7 @@ interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSch
      */
     client?: boolean | ClientOnlyProps;
     afterHandler?: (request: ServerRequest) => any;
+    cache?: ServerRouteCache;
 }
 interface PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
     [KIND]: typeof KEY;
@@ -292,8 +247,8 @@ interface Head$1 {
     };
 }
 interface PageRequestConfig<TConfig extends PageConfigSchema = PageConfigSchema> {
-    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>;
+    params: TConfig["params"] extends TSchema$1 ? Static<TConfig["params"]> : Record<string, string>;
+    query: TConfig["query"] extends TSchema$1 ? Static<TConfig["query"]> : Record<string, string>;
 }
 type PageResolve<TConfig extends PageConfigSchema = PageConfigSchema, TPropsParent extends object = TPropsParentDefault> = PageRequestConfig<TConfig> & TPropsParent & PageReactContext;
 
@@ -301,7 +256,7 @@ declare const envSchema$1: _alepha_core.TObject<{
     REACT_STRICT_MODE: TBoolean;
 }>;
 declare module "alepha" {
-    interface Env extends Partial<Static$1<typeof envSchema$1>> {
+    interface Env extends Partial<Static<typeof envSchema$1>> {
     }
 }
 declare class PageDescriptorProvider {
@@ -483,6 +438,51 @@ interface ReactHydrationState {
     links?: ApiLinksResponse;
 }
 
+/**
+ * Props for the ErrorBoundary component.
+ */
+interface ErrorBoundaryProps {
+    /**
+     * Fallback React node to render when an error is caught.
+     * If not provided, a default error message will be shown.
+     */
+    fallback: (error: Error) => ReactNode;
+    /**
+     * Optional callback that receives the error and error info.
+     * Use this to log errors to a monitoring service.
+     */
+    onError?: (error: Error, info: ErrorInfo) => void;
+}
+/**
+ * State of the ErrorBoundary component.
+ */
+interface ErrorBoundaryState {
+    error?: Error;
+}
+/**
+ * A reusable error boundary for catching rendering errors
+ * in any part of the React component tree.
+ */
+declare class ErrorBoundary extends React__default.Component<PropsWithChildren<ErrorBoundaryProps>, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    /**
+     * Update state so the next render shows the fallback UI.
+     */
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    /**
+     * Lifecycle method called when an error is caught.
+     * You can log the error or perform side effects here.
+     */
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    render(): ReactNode;
+}
+
+interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    to: string | PageDescriptor;
+    children?: React__default.ReactNode;
+}
+declare const Link: (props: LinkProps) => react_jsx_runtime.JSX.Element | null;
+
 interface NestedViewProps {
     children?: ReactNode;
 }
@@ -509,6 +509,19 @@ interface NestedViewProps {
  */
 declare const NestedView: (props: NestedViewProps) => react_jsx_runtime.JSX.Element;
 
+interface RouterContextValue {
+    alepha: Alepha;
+    state: RouterState;
+    context: PageReactContext;
+}
+declare const RouterContext: React.Context<RouterContextValue | undefined>;
+
+interface RouterLayerContextValue {
+    index: number;
+    path: string;
+}
+declare const RouterLayerContext: React.Context<RouterLayerContextValue | undefined>;
+
 declare class RouterHookApi {
     private readonly pages;
     private readonly state;
@@ -570,64 +583,6 @@ declare class RedirectionError extends Error {
     constructor(page: HrefLike);
 }
 
-/**
- * Props for the ErrorBoundary component.
- */
-interface ErrorBoundaryProps {
-    /**
-     * Fallback React node to render when an error is caught.
-     * If not provided, a default error message will be shown.
-     */
-    fallback: (error: Error) => ReactNode;
-    /**
-     * Optional callback that receives the error and error info.
-     * Use this to log errors to a monitoring service.
-     */
-    onError?: (error: Error, info: ErrorInfo) => void;
-}
-/**
- * State of the ErrorBoundary component.
- */
-interface ErrorBoundaryState {
-    error?: Error;
-}
-/**
- * A reusable error boundary for catching rendering errors
- * in any part of the React component tree.
- */
-declare class ErrorBoundary extends React__default.Component<PropsWithChildren<ErrorBoundaryProps>, ErrorBoundaryState> {
-    constructor(props: ErrorBoundaryProps);
-    /**
-     * Update state so the next render shows the fallback UI.
-     */
-    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
-    /**
-     * Lifecycle method called when an error is caught.
-     * You can log the error or perform side effects here.
-     */
-    componentDidCatch(error: Error, info: ErrorInfo): void;
-    render(): ReactNode;
-}
-
-interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
-    to: string | PageDescriptor;
-    children?: React__default.ReactNode;
-}
-declare const Link: (props: LinkProps) => react_jsx_runtime.JSX.Element | null;
-
-interface RouterContextValue {
-    alepha: Alepha;
-    state: RouterState;
-    context: PageReactContext;
-}
-declare const RouterContext: React.Context<RouterContextValue | undefined>;
-
-interface RouterLayerContextValue {
-    index: number;
-    path: string;
-}
-declare const RouterLayerContext: React.Context<RouterLayerContextValue | undefined>;
-
 declare const useActive: (path: HrefLike) => UseActiveHook;
 interface UseActiveHook {
     isActive: boolean;
@@ -647,7 +602,7 @@ interface UseQueryParamsHookOptions {
     key?: string;
     push?: boolean;
 }
-declare const useQueryParams: <T extends TObject$1>(schema: T, options?: UseQueryParamsHookOptions) => [Static$1<T>, (data: Static$1<T>) => void];
+declare const useQueryParams: <T extends TObject>(schema: T, options?: UseQueryParamsHookOptions) => [Static<T>, (data: Static<T>) => void];
 
 declare const useRouter: () => RouterHookApi;
 
@@ -666,14 +621,14 @@ declare const useRouterEvents: (opts?: {
 
 declare const useRouterState: () => RouterState;
 
-declare const envSchema: TObject<{
+declare const envSchema: _alepha_core.TObject<{
     REACT_SERVER_DIST: TString;
     REACT_SERVER_PREFIX: TString;
     REACT_SSR_ENABLED: TOptional<TBoolean>;
     REACT_ROOT_ID: TString;
 }>;
 declare module "alepha/core" {
-    interface Env extends Partial<Static$1<typeof envSchema>> {
+    interface Env extends Partial<Static<typeof envSchema>> {
     }
     interface State {
         "ReactServerProvider.template"?: string;
@@ -748,9 +703,18 @@ declare module "@alepha/core" {
         };
     }
 }
-declare class ReactModule {
-    protected readonly alepha: Alepha;
-    constructor();
+/**
+ * Alepha React Module
+ *
+ * Alepha React Module contains a router for client-side navigation and server-side rendering.
+ * Routes can be defined using the `$page` descriptor.
+ *
+ * @see {@link $page}
+ * @module alepha.react
+ */
+declare class AlephaReact implements Module {
+    readonly name = "alepha.react";
+    readonly $services: (alepha: Alepha) => Alepha;
 }
 
-export { $page, type AnchorProps, ClientOnly, type CreateLayersResult, ErrorBoundary, type Head$1 as Head, type HrefLike, type Layer, Link, NestedView, type PageConfigSchema, type PageDescriptor, type PageDescriptorOptions, PageDescriptorProvider, type PageDescriptorRenderOptions, type PageDescriptorRenderResult, type PageReactContext, type PageRequest, type PageRequestConfig, type PageResolve, type PageRoute, type PageRouteEntry, type PreviousLayerData, ReactBrowserProvider, type ReactHydrationState, ReactModule, ReactServerProvider, RedirectionError, RouterContext, type RouterContextValue, type RouterGoOptions, RouterHookApi, RouterLayerContext, type RouterLayerContextValue, type RouterRenderResult, type RouterStackItem, type RouterState, type TPropsDefault, type TPropsParentDefault, type TransitionOptions, type UseActiveHook, type UseQueryParamsHookOptions, type VirtualRouter, envSchema, isPageRoute, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };
+export { $page, AlephaReact, type AnchorProps, ClientOnly, type CreateLayersResult, ErrorBoundary, type Head$1 as Head, type HrefLike, type Layer, Link, NestedView, type PageConfigSchema, type PageDescriptor, type PageDescriptorOptions, PageDescriptorProvider, type PageDescriptorRenderOptions, type PageDescriptorRenderResult, type PageReactContext, type PageRequest, type PageRequestConfig, type PageResolve, type PageRoute, type PageRouteEntry, type PreviousLayerData, ReactBrowserProvider, type ReactHydrationState, ReactServerProvider, RedirectionError, RouterContext, type RouterContextValue, type RouterGoOptions, RouterHookApi, RouterLayerContext, type RouterLayerContextValue, type RouterRenderResult, type RouterStackItem, type RouterState, type TPropsDefault, type TPropsParentDefault, type TransitionOptions, type UseActiveHook, type UseQueryParamsHookOptions, type VirtualRouter, isPageRoute, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };

package/redis.d.ts

@@ -1,7 +1,6 @@
-import * as _redis_client from '@redis/client';
-import { createClient, SetOptions } from '@redis/client';
 import * as _alepha_core from '@alepha/core';
 import { Static, Alepha } from '@alepha/core';
+import { RedisClientType, createClient, SetOptions } from '@redis/client';
 
 /** Symbol key applied to readonly types */
 declare const ReadonlyKind: unique symbol;
@@ -89,7 +88,9 @@ declare module "alepha" {
     interface Env extends Partial<Static<typeof envSchema>> {
     }
 }
-type RedisClient = ReturnType<typeof createClient>;
+type RedisClient = RedisClientType<{}, {}, {}, 3, {
+    36: BufferConstructor;
+}>;
 type RedisClientOptions = Parameters<typeof createClient>[0];
 type RedisSetOptions = SetOptions;
 declare class RedisProvider {
@@ -100,7 +101,7 @@ declare class RedisProvider {
         REDIS_PORT: number;
         REDIS_HOST: string;
     };
-    protected readonly client: _redis_client.RedisClientType<_redis_client.RedisModules, _redis_client.RedisFunctions, _redis_client.RedisScripts, _redis_client.RespVersions, _redis_client.TypeMapping>;
+    protected readonly client: RedisClient;
     get publisher(): RedisClient;
     protected readonly start: _alepha_core.HookDescriptor<"start">;
     protected readonly stop: _alepha_core.HookDescriptor<"stop">;
@@ -113,6 +114,11 @@ declare class RedisProvider {
      */
     close(): Promise<void>;
     duplicate(options?: Partial<RedisClientOptions>): RedisClient;
+    get(key: string): Promise<Buffer | undefined>;
+    set(key: string, value: Buffer | string, options?: RedisSetOptions): Promise<Buffer>;
+    has(key: string): Promise<boolean>;
+    keys(pattern: string): Promise<string[]>;
+    del(keys: string[]): Promise<void>;
     /**
      * Redis subscriber client factory method.
      */
@@ -123,7 +129,7 @@ declare class RedisSubscriberProvider {
     protected readonly log: _alepha_core.Logger;
     protected readonly alepha: Alepha;
     protected readonly redisProvider: RedisProvider;
-    protected readonly client: _redis_client.RedisClientType<_redis_client.RedisModules, _redis_client.RedisFunctions, _redis_client.RedisScripts, _redis_client.RespVersions, _redis_client.TypeMapping>;
+    protected readonly client: RedisClient;
     get subscriber(): RedisClient;
     protected readonly start: _alepha_core.HookDescriptor<"start">;
     protected readonly stop: _alepha_core.HookDescriptor<"stop">;

package/retry.d.ts

@@ -1,5 +1,35 @@
 import { MaybePromise } from '@alepha/core';
 
+/**
+ * `$retry` creates a retry descriptor.
+ *
+ * It will retry the given function up to `max` times with a delay of `delay` milliseconds between attempts.
+ *
+ * @example
+ * ```ts
+ * import { $retry } from "@alepha/core";
+ *
+ * class MyService {
+ * 	fetchData = $retry({
+ * 		max: 5, // maximum number of attempts
+ * 		delay: 1000, // ms
+ * 		when: (error) => error.message.includes("Network Error"),
+ * 		handler: async (url: string) => {
+ * 			const response = await fetch(url);
+ * 			if (!response.ok) {
+ * 				throw new Error(`Failed to fetch: ${response.statusText}`);
+ * 			}
+ * 			return response.json();
+ * 		},
+ * 		onError: (error, attempt, url) => {
+ * 	    // error happened, log it or handle it
+ * 			console.error(`Attempt ${attempt} failed for ${url}:`, error);
+ * 		},
+ * 	});
+ * }
+ * ```
+ */
+declare const $retry: <T extends (...args: any[]) => any>(opts: RetryDescriptorOptions<T>) => RetryDescriptor<T>;
 /**
  * Retry Descriptor options.
  */
@@ -34,35 +64,5 @@ interface RetryDescriptorOptions<T extends (...args: any[]) => any> {
     onError?: (error: Error, attempt: number, ...parameters: Parameters<T>) => void;
 }
 type RetryDescriptor<T extends (...args: any[]) => any> = (...parameters: Parameters<T>) => MaybePromise<ReturnType<T>>;
-/**
- * `$retry` creates a retry descriptor.
- *
- * It will retry the given function up to `max` times with a delay of `delay` milliseconds between attempts.
- *
- * @example
- * ```ts
- * import { $retry } from "@alepha/core";
- *
- * class MyService {
- * 	fetchData = $retry({
- * 		max: 5, // maximum number of attempts
- * 		delay: 1000, // ms
- * 		when: (error) => error.message.includes("Network Error"),
- * 		handler: async (url: string) => {
- * 			const response = await fetch(url);
- * 			if (!response.ok) {
- * 				throw new Error(`Failed to fetch: ${response.statusText}`);
- * 			}
- * 			return response.json();
- * 		},
- * 		onError: (error, attempt, url) => {
- * 	    // error happened, log it or handle it
- * 			console.error(`Attempt ${attempt} failed for ${url}:`, error);
- * 		},
- * 	});
- * }
- * ```
- */
-declare const $retry: <T extends (...args: any[]) => any>(opts: RetryDescriptorOptions<T>) => RetryDescriptor<T>;
 
 export { $retry, type RetryDescriptor, type RetryDescriptorOptions };

package/scheduler.d.ts

@@ -1,15 +1,23 @@
 import * as _alepha_core from '@alepha/core';
-import { Async, KIND, OPTIONS, Static, Alepha } from '@alepha/core';
-import { DurationLike, DateTimeProvider, Interval } from '@alepha/datetime';
+import { Async, KIND, OPTIONS, Alepha, Static } from '@alepha/core';
+import { DateTime, DurationLike, DateTimeProvider, Interval } from '@alepha/datetime';
 import * as _alepha_lock from '@alepha/lock';
-import { ScheduledTask } from 'node-cron';
+import { Cron } from 'cron-schedule';
 
 declare const KEY = "SCHEDULER";
+/**
+ * Scheduler descriptor.
+ */
+declare const $scheduler: {
+    (options: SchedulerDescriptorOptions): SchedulerDescriptor;
+    [KIND]: string;
+};
+declare const isScheduler: (value: any) => value is SchedulerDescriptor;
 type SchedulerDescriptorOptions = {
     /**
      * Function to run on schedule.
      */
-    handler: () => Async<void>;
+    handler: (args: SchedulerHandlerArguments) => Async<void>;
     /**
      * Name of the scheduler. Defaults to the function name.
      */
@@ -28,7 +36,9 @@ type SchedulerDescriptorOptions = {
     interval?: DurationLike;
     /**
      * If true, the scheduler will be locked and only one instance will run at a time.
-     * Defaults to true.
+     * You probably need to import {@link AlephaLockRedis} for distributed locking.
+     *
+     * @default true
      */
     lock?: boolean;
 };
@@ -37,17 +47,9 @@ interface SchedulerDescriptor {
     [OPTIONS]: SchedulerDescriptorOptions;
     (): Promise<void>;
 }
-/**
- * Scheduler descriptor.
- *
- * @param options - The scheduler options.
- * @returns The descriptor value.
- */
-declare const $scheduler: {
-    (options: SchedulerDescriptorOptions): SchedulerDescriptor;
-    [KIND]: string;
-};
-declare const isScheduler: (value: any) => value is SchedulerDescriptor;
+interface SchedulerHandlerArguments {
+    now: DateTime;
+}
 
 /** Symbol key applied to readonly types */
 declare const ReadonlyKind: unique symbol;
@@ -113,6 +115,28 @@ interface TSchema extends TKind, SchemaOptions {
     static: unknown;
 }
 
+interface CronJob {
+    handler: (context: {
+        now: DateTime;
+    }) => Promise<void>;
+    cron: Cron;
+    loop: boolean;
+    running?: boolean;
+    onError?: (error: Error) => void;
+    abort: AbortController;
+}
+declare class CronProvider {
+    protected readonly dt: DateTimeProvider;
+    protected readonly alepha: Alepha;
+    protected readonly log: _alepha_core.Logger;
+    start(cron: CronJob): void;
+    stop(cron: CronJob): void;
+    create(expression: string, handler: (context: {
+        now: DateTime;
+    }) => Promise<void>): CronJob;
+    run(task: CronJob, now?: undefined): void;
+}
+
 declare const envSchema: _alepha_core.TObject<{
     SCHEDULER_PREFIX: TOptional<TString>;
 }>;
@@ -127,10 +151,12 @@ declare class SchedulerDescriptorProvider {
     };
     protected readonly alepha: Alepha;
     protected readonly dateTimeProvider: DateTimeProvider;
+    protected readonly cronProvider: CronProvider;
     protected readonly schedulers: Scheduler[];
     protected readonly configure: _alepha_core.HookDescriptor<"configure">;
     protected readonly start: _alepha_core.HookDescriptor<"start">;
     protected readonly stop: _alepha_core.HookDescriptor<"stop">;
+    protected createContextId(): string;
     /**
      * Get the schedulers.
      */
@@ -150,16 +176,14 @@ declare class SchedulerDescriptorProvider {
      * @protected
      */
     protected createScheduler(options: SchedulerDescriptorOptions, instance: any, key: string): Scheduler;
+    protected createHandler(name: string, options: SchedulerDescriptorOptions): (args: SchedulerHandlerArguments) => Promise<void>;
     trigger(name: string): Promise<void>;
     protected runLock: _alepha_lock.LockDescriptor<(options: SchedulerDescriptorOptions & {
         name: string;
+        args: SchedulerHandlerArguments;
     }) => Promise<void>>;
-    protected run(options: SchedulerDescriptorOptions): Promise<void>;
     /**
      * Prefix the scheduler key.
-     *
-     * @param key
-     * @protected
      */
     protected prefix(key: string): string;
     /**
@@ -172,14 +196,22 @@ declare class SchedulerDescriptorProvider {
 interface Scheduler {
     name: string;
     options: SchedulerDescriptorOptions;
-    trigger: () => Promise<void>;
-    cron?: ScheduledTask;
+    trigger: (args: SchedulerHandlerArguments) => Promise<void>;
+    cron?: CronJob;
     interval?: Interval;
 }
 
-declare class SchedulerModule {
-    protected readonly alepha: Alepha;
-    constructor();
+/**
+ * Alepha Scheduler Module
+ *
+ * Generic interface for scheduling tasks.
+ *
+ * @see {@link $scheduler}
+ * @module alepha.scheduler
+ */
+declare class AlephaScheduler {
+    readonly name = "alepha.scheduler";
+    readonly $services: (alepha: Alepha) => Alepha;
 }
 
-export { $scheduler, type Scheduler, type SchedulerDescriptor, type SchedulerDescriptorOptions, SchedulerDescriptorProvider, SchedulerModule, isScheduler };
+export { $scheduler, AlephaScheduler, type Scheduler, type SchedulerDescriptor, type SchedulerDescriptorOptions, SchedulerDescriptorProvider, type SchedulerHandlerArguments, isScheduler };

package/security.d.ts

@@ -697,9 +697,9 @@ declare module "alepha/core" {
         };
     }
 }
-declare class SecurityModule {
-    protected readonly alepha: Alepha;
-    constructor();
+declare class AlephaSecurity {
+    readonly name = "alepha.security";
+    readonly $services: (alepha: Alepha) => Alepha;
 }
 
-export { $permission, $realm, $role, $serviceAccount, type AccessTokenResponse, type ExtendedJWTPayload, InvalidPermissionError, type JwtParseResult, JwtProvider, type JwtServiceAccountDescriptorOptions, type JwtSignOptions, type KeyLoader, type KeyLoaderHolder, type Oauth2ServiceAccountDescriptorOptions, type Permission, type PermissionDescriptor, type PermissionDescriptorOptions, type Realm, type RealmConfig, type RealmDescriptor, type RealmDescriptorOptions, type Role, type RoleDescriptor, type RoleDescriptorOptions, type SecurityCheckResult, SecurityError, SecurityModule, SecurityProvider, type SecurityUserAccountProvider, type ServiceAccountDescriptor, type ServiceAccountDescriptorOptions, type ServiceAccountStore, type UserAccountInfo, type UserAccountToken, permissionSchema, roleSchema };
+export { $permission, $realm, $role, $serviceAccount, type AccessTokenResponse, AlephaSecurity, type ExtendedJWTPayload, InvalidPermissionError, type JwtParseResult, JwtProvider, type JwtServiceAccountDescriptorOptions, type JwtSignOptions, type KeyLoader, type KeyLoaderHolder, type Oauth2ServiceAccountDescriptorOptions, type Permission, type PermissionDescriptor, type PermissionDescriptorOptions, type Realm, type RealmConfig, type RealmDescriptor, type RealmDescriptorOptions, type Role, type RoleDescriptor, type RoleDescriptorOptions, type SecurityCheckResult, SecurityError, SecurityProvider, type SecurityUserAccountProvider, type ServiceAccountDescriptor, type ServiceAccountDescriptorOptions, type ServiceAccountStore, type UserAccountInfo, type UserAccountToken, permissionSchema, roleSchema };

package/server/cache.d.ts

@@ -1,12 +1,12 @@
 import * as _alepha_core from '@alepha/core';
-import { Alepha, OPTIONS } from '@alepha/core';
+import { Alepha, OPTIONS, Module } from '@alepha/core';
 import { CacheDescriptorOptions, CacheDescriptorProvider, Cache } from '@alepha/cache';
 import { DurationLike, DateTimeProvider } from '@alepha/datetime';
 import { ServerHandler, ServerRequestConfig } from '@alepha/server';
 
 declare module "alepha/server" {
     interface ServerRoute {
-        cache?: ServiceRouteCache;
+        cache?: ServerRouteCache;
     }
     interface ActionDescriptor {
         invalidate: () => Promise<void>;
@@ -27,7 +27,7 @@ declare class ServerCacheProvider {
     protected getCacheByRoute(route: RouteLike): RouteCache | undefined;
     protected createCacheKey(args: ServerRequestConfig): string;
 }
-type ServiceRouteCache = boolean | DurationLike | Omit<CacheDescriptorOptions<any>, "handler" | "key">;
+type ServerRouteCache = boolean | DurationLike | Omit<CacheDescriptorOptions<any>, "handler" | "key">;
 type RouteCache = Cache<{
     contentType?: string;
     body: string;
@@ -43,9 +43,40 @@ type RouteLike = {
     handler?: ServerHandler;
 };
 
-declare class ServerCacheModule {
-    protected readonly alepha: Alepha;
-    constructor();
+/**
+ * # Alepha Server Cache Module
+ *
+ * @description
+ * Plugin for Alepha Server that provides server-side caching capabilities.
+ * It uses the Alepha Cache module to cache responses from server actions ($action).
+ * It also provides a ETag-based cache invalidation mechanism.
+ *
+ * @example
+ * ```ts
+ * import { Alepha } from "@alepha/core";
+ * import { $action } from "@alepha/server";
+ * import { AlephaServerCache } from "alepha/server/cache";
+ *
+ * class ApiServer {
+ *   hello = $action({
+ *     cache: true,
+ *     handler: () => "Hello, World!",
+ *   });
+ * }
+ *
+ * const alepha = Alepha.create()
+ *   .with(AlephaServerCache)
+ *   .with(ApiServer);
+ *
+ * run(alepha);
+ * ```
+ *
+ * @see {@link ServerCacheProvider}
+ * @module alepha.server.cache
+ */
+declare class AlephaServerCache implements Module {
+    readonly name = "alepha.server.cache";
+    readonly $services: (alepha: Alepha) => Alepha;
 }
 
-export { ServerCacheModule, ServerCacheProvider, type ServiceRouteCache };
+export { AlephaServerCache, ServerCacheProvider, type ServerRouteCache };

package/server/swagger.d.ts

@@ -1,5 +1,5 @@
 import * as _alepha_core from '@alepha/core';
-import { KIND, OPTIONS, Alepha, TObject } from '@alepha/core';
+import { KIND, OPTIONS, Alepha, TObject, Module } from '@alepha/core';
 import { OpenAPIV3 } from 'openapi-types';
 import { ServerActionDescriptorProvider, ServerRouterProvider, ServerRouteAction } from '@alepha/server';
 import { ServerStaticProvider } from '@alepha/server-static';
@@ -100,4 +100,19 @@ declare class ServerSwaggerProvider {
     protected configureSwaggerUi(prefix: string, options: SwaggerDescriptorOptions): Promise<void>;
 }
 
-export { $swagger, ServerSwaggerProvider, type SwaggerDescriptor, type SwaggerDescriptorOptions, type SwaggerUiOptions };
+/**
+ * Alepha Server Swagger Module
+ *
+ * Plugin for Alepha Server that provides Swagger documentation capabilities.
+ * It generates OpenAPI v3 documentation for the server's endpoints ($action).
+ * It also provides a Swagger UI for interactive API documentation.
+ *
+ * @see {@link ServerSwaggerProvider}
+ * @module alepha.server.swagger
+ */
+declare class AlephaServerSwagger implements Module {
+    readonly name = "alepha.server.swagger";
+    readonly $services: (alepha: Alepha) => Alepha;
+}
+
+export { $swagger, AlephaServerSwagger, ServerSwaggerProvider, type SwaggerDescriptor, type SwaggerDescriptorOptions, type SwaggerUiOptions };