alepha 0.8.0 → 0.8.1

package/react.d.ts

@@ -1,16 +1,17 @@
 import * as _alepha_core11 from "alepha";
-import * as _alepha_core18 from "alepha";
+import * as _alepha_core24 from "alepha";
 import * as _alepha_core16 from "alepha";
 import * as _alepha_core1 from "alepha";
 import { Alepha, Async, KIND, Module, OPTIONS, Service, Static, TObject, TSchema } from "alepha";
 import { ApiLinksResponse, ServerHandler, ServerRequest, ServerRouterProvider, ServerTimingProvider } from "alepha/server";
 import { ServerRouteCache } from "alepha/server/cache";
 import { ClientScope, HttpVirtualClient, LinkProvider } from "alepha/server/links";
+import * as react20 from "react";
 import * as react23 from "react";
-import * as react24 from "react";
 import React, { AnchorHTMLAttributes, ErrorInfo, FC, PropsWithChildren, ReactNode } from "react";
+import * as react_jsx_runtime18 from "react/jsx-runtime";
+import * as react_jsx_runtime21 from "react/jsx-runtime";
 import * as react_jsx_runtime22 from "react/jsx-runtime";
-import * as react_jsx_runtime20 from "react/jsx-runtime";
 import { ServerStaticProvider } from "alepha/server/static";
 import { Route, RouterProvider } from "alepha/router";
 import { Root } from "react-dom/client";
@@ -34,6 +35,13 @@ declare const ClientOnly: (props: PropsWithChildren<ClientOnlyProps>) => ReactNo
 //#endregion
 //#region src/descriptors/$page.d.ts
 declare const KEY = "PAGE";
+/**
+ * Main descriptor for defining a React route in the application.
+ */
+declare const $page: {
+  <TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = any, TPropsParent extends object = TPropsParentDefault>(options: PageDescriptorOptions<TConfig, TProps, TPropsParent>): PageDescriptor<TConfig, TProps, TPropsParent>;
+  [KIND]: string;
+};
 interface PageConfigSchema {
   query?: TSchema;
   params?: TSchema;
@@ -138,13 +146,6 @@ interface PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema, TP
    */
   render: (options?: PageDescriptorRenderOptions) => Promise<PageDescriptorRenderResult>;
 }
-/**
- * Main descriptor for defining a React route in the application.
- */
-declare const $page: {
-  <TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = any, TPropsParent extends object = TPropsParentDefault>(options: PageDescriptorOptions<TConfig, TProps, TPropsParent>): PageDescriptor<TConfig, TProps, TPropsParent>;
-  [KIND]: string;
-};
 interface PageDescriptorRenderOptions {
   params?: Record<string, string>;
   query?: Record<string, string>;
@@ -231,6 +232,7 @@ interface Layer {
   index: number;
   path: string;
   route?: PageRoute;
+  cache?: boolean;
 }
 type PreviousLayerData = Omit<Layer, "element" | "index" | "path">;
 interface AnchorProps {
@@ -252,6 +254,7 @@ interface RouterStackItem {
   config?: Record<string, any>;
   props?: Record<string, any>;
   error?: Error;
+  cache?: boolean;
 }
 interface RouterRenderResult {
   state: RouterState;
@@ -281,11 +284,11 @@ interface BrowserRoute extends Route {
   page: PageRoute;
 }
 declare class BrowserRouterProvider extends RouterProvider<BrowserRoute> {
-  protected readonly log: _alepha_core18.Logger;
+  protected readonly log: _alepha_core24.Logger;
   protected readonly alepha: Alepha;
   protected readonly pageDescriptorProvider: PageDescriptorProvider;
   add(entry: PageRouteEntry): void;
-  protected readonly configure: _alepha_core18.HookDescriptor<"configure">;
+  protected readonly configure: _alepha_core24.HookDescriptor<"configure">;
   transition(url: URL, options?: TransitionOptions): Promise<RouterRenderResult>;
   root(state: RouterState, context: PageReactContext): ReactNode;
 }
@@ -304,7 +307,9 @@ declare class ReactBrowserProvider {
   state: RouterState;
   get document(): Document;
   get history(): History;
+  get location(): Location;
   get url(): string;
+  pushState(url: string, replace?: boolean): void;
   invalidate(props?: Record<string, any>): Promise<void>;
   go(url: string, options?: RouterGoOptions): Promise<void>;
   protected render(options?: {
@@ -373,7 +378,7 @@ interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
   to: string | PageDescriptor;
   children?: React.ReactNode;
 }
-declare const Link: (props: LinkProps) => react_jsx_runtime22.JSX.Element | null;
+declare const Link: (props: LinkProps) => react_jsx_runtime18.JSX.Element | null;
 //#endregion
 //#region src/components/NestedView.d.ts
 interface NestedViewProps {
@@ -400,7 +405,11 @@ interface NestedViewProps {
  * }
  * ```
  */
-declare const NestedView: (props: NestedViewProps) => react_jsx_runtime20.JSX.Element;
+declare const NestedView: (props: NestedViewProps) => react_jsx_runtime21.JSX.Element;
+//#endregion
+//#region src/components/NotFound.d.ts
+declare function NotFoundPage(): react_jsx_runtime22.JSX.Element;
+//# sourceMappingURL=NotFound.d.ts.map
 //#endregion
 //#region src/contexts/RouterContext.d.ts
 interface RouterContextValue {
@@ -408,7 +417,7 @@ interface RouterContextValue {
   state: RouterState;
   context: PageReactContext;
 }
-declare const RouterContext: react23.Context<RouterContextValue | undefined>;
+declare const RouterContext: react20.Context<RouterContextValue | undefined>;
 //# sourceMappingURL=RouterContext.d.ts.map
 //#endregion
 //#region src/contexts/RouterLayerContext.d.ts
@@ -416,18 +425,21 @@ interface RouterLayerContextValue {
   index: number;
   path: string;
 }
-declare const RouterLayerContext: react24.Context<RouterLayerContextValue | undefined>;
+declare const RouterLayerContext: react23.Context<RouterLayerContextValue | undefined>;
 //# sourceMappingURL=RouterLayerContext.d.ts.map
 //#endregion
 //#region src/hooks/RouterHookApi.d.ts
 declare class RouterHookApi {
   private readonly pages;
+  private readonly context;
   private readonly state;
   private readonly layer;
   private readonly browser?;
-  constructor(pages: PageRoute[], state: RouterState, layer: {
+  constructor(pages: PageRoute[], context: PageReactContext, state: RouterState, layer: {
     path: string;
   }, browser?: ReactBrowserProvider | undefined);
+  getURL(): URL;
+  get location(): Location;
   get current(): RouterState;
   get pathname(): string;
   get query(): Record<string, string>;
@@ -547,8 +559,8 @@ declare const envSchema: _alepha_core1.TObject<{
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
   interface State {
-    "ReactServerProvider.template"?: string;
-    "ReactServerProvider.ssr"?: boolean;
+    "react.server.template"?: string;
+    "react.server.ssr"?: boolean;
   }
 }
 declare class ReactServerProvider {
@@ -633,10 +645,132 @@ declare module "alepha" {
   }
 }
 /**
- * Alepha React Module
+ * Provides full-stack React development with declarative routing, server-side rendering, and client-side hydration.
  *
- * Alepha React Module contains a router for client-side navigation and server-side rendering.
- * Routes can be defined using the `$page` descriptor.
+ * The React module enables building modern React applications using the `$page` descriptor on class properties.
+ * It delivers seamless server-side rendering, automatic code splitting, and client-side navigation with full
+ * type safety and schema validation for route parameters and data.
+ *
+ * **Key Features:**
+ * - Declarative page definition with `$page` descriptor
+ * - Server-side rendering (SSR) with automatic hydration
+ * - Type-safe routing with parameter validation
+ * - Schema-based data resolution and validation
+ * - SEO-friendly meta tag management
+ * - Automatic code splitting and lazy loading
+ * - Client-side navigation with browser history
+ *
+ * **Basic Usage:**
+ * ```ts
+ * import { Alepha, run, t } from "alepha";
+ * import { AlephaReact, $page } from "alepha/react";
+ *
+ * class AppRoutes {
+ *   // Home page
+ *   home = $page({
+ *     path: "/",
+ *     component: () => (
+ *       <div>
+ *         <h1>Welcome to Alepha</h1>
+ *         <p>Build amazing React applications!</p>
+ *       </div>
+ *     ),
+ *   });
+ *
+ *   // About page with meta tags
+ *   about = $page({
+ *     path: "/about",
+ *     head: {
+ *       title: "About Us",
+ *       description: "Learn more about our mission",
+ *     },
+ *     component: () => (
+ *       <div>
+ *         <h1>About Us</h1>
+ *         <p>Learn more about our mission.</p>
+ *       </div>
+ *     ),
+ *   });
+ * }
+ *
+ * const alepha = Alepha.create()
+ *   .with(AlephaReact)
+ *   .with(AppRoutes);
+ *
+ * run(alepha);
+ * ```
+ *
+ * **Dynamic Routes with Parameters:**
+ * ```tsx
+ * class UserRoutes {
+ *   userProfile = $page({
+ *     path: "/users/:id",
+ *     schema: {
+ *       params: t.object({
+ *         id: t.string(),
+ *       }),
+ *     },
+ *     resolve: async ({ params }) => {
+ *       // Fetch user data server-side
+ *       const user = await getUserById(params.id);
+ *       return { user };
+ *     },
+ *     head: ({ user }) => ({
+ *       title: `${user.name} - Profile`,
+ *       description: `View ${user.name}'s profile`,
+ *     }),
+ *     component: ({ user }) => (
+ *       <div>
+ *         <h1>{user.name}</h1>
+ *         <p>Email: {user.email}</p>
+ *       </div>
+ *     ),
+ *   });
+ *
+ *   userSettings = $page({
+ *     path: "/users/:id/settings",
+ *     schema: {
+ *       params: t.object({
+ *         id: t.string(),
+ *       }),
+ *     },
+ *     component: ({ params }) => (
+ *       <UserSettings userId={params.id} />
+ *     ),
+ *   });
+ * }
+ * ```
+ *
+ * **Static Generation:**
+ * ```tsx
+ * class BlogRoutes {
+ *   blogPost = $page({
+ *     path: "/blog/:slug",
+ *     schema: {
+ *       params: t.object({
+ *         slug: t.string(),
+ *       }),
+ *     },
+ *     static: {
+ *       entries: [
+ *         { params: { slug: "getting-started" } },
+ *         { params: { slug: "advanced-features" } },
+ *         { params: { slug: "deployment" } },
+ *       ],
+ *     },
+ *     resolve: ({ params }) => {
+ *       const post = getBlogPost(params.slug);
+ *       return { post };
+ *     },
+ *     component: ({ post }) => (
+ *       <article>
+ *         <h1>{post.title}</h1>
+ *         <div>{post.content}</div>
+ *       </article>
+ *     ),
+ *   });
+ * }
+ * ```
  *
  * @see {@link $page}
  * @module alepha.react
@@ -648,5 +782,5 @@ declare class AlephaReact implements Module {
 //# sourceMappingURL=index.d.ts.map
 
 //#endregion
-export { $page, AlephaReact, AnchorProps, ClientOnly, CreateLayersResult, ErrorBoundary, HrefLike, Layer, Link, NestedView, PageConfigSchema, PageDescriptor, PageDescriptorOptions, PageDescriptorProvider, PageDescriptorRenderOptions, PageDescriptorRenderResult, PageReactContext, PageRequest, PageRequestConfig, PageResolve, PageRoute, PageRouteEntry, PreviousLayerData, ReactBrowserProvider, ReactHydrationState, ReactServerProvider, RedirectionError, RouterContext, RouterContextValue, RouterGoOptions, RouterHookApi, RouterLayerContext, RouterLayerContextValue, RouterRenderResult, RouterStackItem, RouterState, TPropsDefault, TPropsParentDefault, TransitionOptions, UseActiveHook, UseQueryParamsHookOptions, VirtualRouter, isPageRoute, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };
+export { $page, AlephaReact, AnchorProps, ClientOnly, CreateLayersResult, ErrorBoundary, HrefLike, Layer, Link, NestedView, NotFoundPage as NotFound, PageConfigSchema, PageDescriptor, PageDescriptorOptions, PageDescriptorProvider, PageDescriptorRenderOptions, PageDescriptorRenderResult, PageReactContext, PageRequest, PageRequestConfig, PageResolve, PageRoute, PageRouteEntry, PreviousLayerData, ReactBrowserProvider, ReactHydrationState, ReactServerProvider, RedirectionError, RouterContext, RouterContextValue, RouterGoOptions, RouterHookApi, RouterLayerContext, RouterLayerContextValue, RouterRenderResult, RouterStackItem, RouterState, TPropsDefault, TPropsParentDefault, TransitionOptions, UseActiveHook, UseQueryParamsHookOptions, VirtualRouter, isPageRoute, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };
 //# sourceMappingURL=index.d.ts.map

package/redis.d.ts

@@ -15,6 +15,9 @@ type RedisClient = RedisClientType<{}, {}, {}, 3, {
 }>;
 type RedisClientOptions = Parameters<typeof createClient>[0];
 type RedisSetOptions = SetOptions;
+/**
+* Redis client provider.
+*/
 declare class RedisProvider {
   protected readonly log: Logger;
   protected readonly alepha: Alepha;

package/retry.d.ts

@@ -3,12 +3,13 @@ import { DateTimeProvider, DurationLike } from "alepha/datetime";
 
 //#region src/descriptors/$retry.d.ts
 
-// TODO: move to RetryProvider
 /**
 * Creates a function that automatically retries a handler upon failure,
 * with support for exponential backoff, max duration, and cancellation.
 */
 declare const $retry: <T extends (...args: any[]) => any>(opts: RetryDescriptorOptions<T>) => RetryDescriptor<T>;
+// ---------------------------------------------------------------------------------------------------------------------
+// TODO: move to RetryProvider
 declare const createRetryHandler: <T extends (...args: any[]) => any>(opts: RetryDescriptorOptions<T>, dateTimeProvider: DateTimeProvider, appAbortController?: AbortController) => RetryDescriptor<T>;
 // ---------------------------------------------------------------------------------------------------------------------
 interface RetryBackoffOptions {

package/router.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/router');
+Object.keys(m).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return m[k]; }
+	});
+});

package/router.d.ts

@@ -0,0 +1,45 @@
+//#region src/providers/RouterProvider.d.ts
+declare class RouterProvider<T extends Route = Route> {
+  protected routePathRegex: RegExp;
+  protected tree: Tree<T>;
+  readonly routes: T[];
+  push(route: T): void;
+  match(path: string): RouteMatch<T>;
+  protected createRouteMatch(path: string): RouteMatch<T>;
+  protected mapParams(match: RouteMatch<T>): RouteMatch<T>;
+  protected createParts(path: string): string[];
+}
+interface RouteMatch<T extends Route> {
+  route?: T;
+  params?: Record<string, string>;
+}
+interface Route {
+  path: string;
+  /**
+  * Rename a param in the route.
+  * This is automatically filled when you have scenarios like:
+  * `/customers/:id` and `/customers/:userId/payments`
+  *
+  * In this case, `:id` will be renamed to `:userId` in the second route.
+  */
+  mapParams?: Record<string, string>;
+}
+interface Tree<T extends Route> {
+  route?: T;
+  children: {
+    [key: string]: Tree<T>;
+  };
+  param?: {
+    route?: T;
+    name: string;
+    children: {
+      [key: string]: Tree<T>;
+    };
+  };
+  wildcard?: {
+    route: T;
+  };
+}
+//#endregion
+export { Route, RouteMatch, RouterProvider, Tree };
+//# sourceMappingURL=index.d.ts.map

package/router.js

@@ -0,0 +1 @@
+export * from '@alepha/router'

package/scheduler.d.ts

@@ -15,7 +15,6 @@ declare const $scheduler: {
   (options: SchedulerDescriptorOptions): SchedulerDescriptor;
   [KIND]: string;
 };
-declare const isScheduler: (value: any) => value is SchedulerDescriptor;
 type SchedulerDescriptorOptions = {
   /**
    * Function to run on schedule.
@@ -143,8 +142,6 @@ interface Scheduler {
 //#endregion
 //#region src/index.d.ts
 /**
- * Alepha Scheduler Module
- *
  * Generic interface for scheduling tasks.
  *
  * @see {@link $scheduler}
@@ -157,5 +154,5 @@ declare class AlephaScheduler {
 //# sourceMappingURL=index.d.ts.map
 
 //#endregion
-export { $scheduler, AlephaScheduler, Scheduler, SchedulerDescriptor, SchedulerDescriptorOptions, SchedulerDescriptorProvider, SchedulerHandlerArguments, isScheduler };
+export { $scheduler, AlephaScheduler, Scheduler, SchedulerDescriptor, SchedulerDescriptorOptions, SchedulerDescriptorProvider, SchedulerHandlerArguments };
 //# sourceMappingURL=index.d.ts.map

package/security.d.ts

@@ -51,6 +51,13 @@ type Permission = Static<typeof permissionSchema>;
 //#endregion
 //#region src/descriptors/$permission.d.ts
 declare const KEY$2 = "PERMISSION";
+/**
+ *
+ */
+declare const $permission: {
+  (options?: PermissionDescriptorOptions): PermissionDescriptor;
+  [KIND]: string;
+};
 interface PermissionDescriptorOptions {
   /**
    * Name of the permission. Use Property name is not provided.
@@ -85,10 +92,6 @@ interface PermissionDescriptor {
    */
   can(user: UserAccountInfo): boolean;
 }
-declare const $permission: {
-  (options?: PermissionDescriptorOptions): PermissionDescriptor;
-  [KIND]: string;
-};
 //#endregion
 //#region src/interfaces/UserAccountToken.d.ts
 interface UserAccountToken extends UserAccountInfo {
@@ -394,6 +397,14 @@ interface RealmConfig {
 //#endregion
 //#region src/descriptors/$realm.d.ts
 declare const KEY$1 = "REALM";
+/**
+ *
+ * @param options
+ */
+declare const $realm: {
+  (options?: RealmDescriptorOptions): RealmDescriptor;
+  [KIND]: string;
+};
 interface RealmDescriptorOptions {
   /**
    * Define the realm name.
@@ -442,13 +453,16 @@ interface RealmDescriptor {
    */
   createToken(subject: string, roles?: string[]): Promise<string>;
 }
-declare const $realm: {
-  (options?: RealmDescriptorOptions): RealmDescriptor;
-  [KIND]: string;
-};
 //#endregion
 //#region src/descriptors/$role.d.ts
 declare const KEY = "ROLE";
+/**
+ *
+ */
+declare const $role: {
+  (options?: RoleDescriptorOptions): RoleDescriptor;
+  [KIND]: string;
+};
 interface RoleDescriptorOptions {
   /**
    * Name of the role.
@@ -471,10 +485,6 @@ interface RoleDescriptor {
    */
   (): Role;
 }
-declare const $role: {
-  (options?: RoleDescriptorOptions): RoleDescriptor;
-  [KIND]: string;
-};
 //#endregion
 //#region src/descriptors/$serviceAccount.d.ts
 /**
@@ -568,6 +578,175 @@ declare module "alepha" {
     };
   }
 }
+/**
+ * Provides comprehensive authentication and authorization capabilities with JWT tokens, role-based access control, and user management.
+ *
+ * The security module enables building secure applications using descriptors like `$realm`, `$role`, and `$permission`
+ * on class properties. It offers JWT-based authentication, fine-grained permissions, service accounts, and seamless
+ * integration with various authentication providers and user management systems.
+ *
+ * **Key Features:**
+ * - Declarative realm definition with `$realm` descriptor for user authentication
+ * - Role-based access control with `$role` descriptor
+ * - Fine-grained permissions with `$permission` descriptor
+ * - Service account management with `$serviceAccount` descriptor
+ * - JWT token generation and validation
+ * - OAuth integration and external provider support
+ * - User session management and security hooks
+ *
+ * **Basic Usage:**
+ * ```ts
+ * import { Alepha, run, t } from "alepha";
+ * import { AlephaSecurity, $realm, $role, $permission } from "alepha/security";
+ *
+ * // Define user roles
+ * const adminRole = $role({
+ *   name: "admin",
+ *   description: "Administrator with full access",
+ * });
+ *
+ * const userRole = $role({
+ *   name: "user",
+ *   description: "Regular user with limited access",
+ * });
+ *
+ * // Define permissions
+ * const readUsersPermission = $permission({
+ *   name: "users:read",
+ *   description: "Read user information",
+ * });
+ *
+ * const writeUsersPermission = $permission({
+ *   name: "users:write",
+ *   description: "Create and update users",
+ * });
+ *
+ * // Define authentication realm
+ * class AuthSystem {
+ *   userRealm = $realm({
+ *     name: "users",
+ *     roles: [adminRole, userRole],
+ *     permissions: [readUsersPermission, writeUsersPermission],
+ *     authenticate: async (token: string) => {
+ *       // Validate user token and return user info
+ *       const user = await validateUserToken(token);
+ *       return {
+ *         id: user.id,
+ *         email: user.email,
+ *         roles: user.roles,
+ *         permissions: user.permissions,
+ *       };
+ *     },
+ *   });
+ * }
+ *
+ * const alepha = Alepha.create()
+ *   .with(AlephaSecurity)
+ *   .with(AuthSystem);
+ *
+ * run(alepha);
+ * ```
+ *
+ * **OAuth Integration:**
+ * ```ts
+ * import { $serviceAccount } from "alepha/security";
+ *
+ * class OAuthSystem {
+ *   googleAuth = $realm({
+ *     name: "google-oauth",
+ *     provider: "oauth",
+ *     config: {
+ *       clientId: process.env.GOOGLE_CLIENT_ID,
+ *       clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+ *       redirectUri: "https://myapp.com/auth/callback",
+ *       scope: ["email", "profile"],
+ *     },
+ *     authenticate: async (oauthToken: string) => {
+ *       const userInfo = await fetchGoogleUserInfo(oauthToken);
+ *       return {
+ *         id: userInfo.sub,
+ *         email: userInfo.email,
+ *         name: userInfo.name,
+ *         roles: ["user"],
+ *       };
+ *     },
+ *   });
+ *
+ *   serviceAccount = $serviceAccount({
+ *     name: "api-service",
+ *     permissions: ["api:read", "api:write"],
+ *     secret: process.env.SERVICE_ACCOUNT_SECRET,
+ *   });
+ * }
+ * ```
+ *
+ * **Role and Permission Management:**
+ * ```ts
+ * class PermissionSystem {
+ *   // Define hierarchical roles
+ *   superAdminRole = $role({
+ *     name: "super-admin",
+ *     inherits: [adminRole],
+ *     permissions: ["*"], // All permissions
+ *   });
+ *
+ *   moderatorRole = $role({
+ *     name: "moderator",
+ *     inherits: [userRole],
+ *     permissions: ["posts:moderate", "comments:moderate"],
+ *   });
+ *
+ *   // Define resource-specific permissions
+ *   postPermissions = [
+ *     $permission({ name: "posts:create", description: "Create posts" }),
+ *     $permission({ name: "posts:edit", description: "Edit posts" }),
+ *     $permission({ name: "posts:delete", description: "Delete posts" }),
+ *     $permission({ name: "posts:moderate", description: "Moderate posts" }),
+ *   ];
+ *
+ *   // Check permissions in application logic
+ *   async checkUserPermission(userId: string, permission: string) {
+ *     const user = await this.userRealm.getUser(userId);
+ *     return user.permissions.includes(permission);
+ *   }
+ * }
+ * ```
+ *
+ * **JWT Token Management:**
+ * ```ts
+ * class TokenSystem {
+ *   userTokens = $realm({
+ *     name: "jwt-tokens",
+ *     jwtConfig: {
+ *       secret: process.env.JWT_SECRET,
+ *       expiresIn: "24h",
+ *       issuer: "myapp.com",
+ *       audience: "myapp-users",
+ *     },
+ *     authenticate: async (jwtToken: string) => {
+ *       // JWT validation is handled automatically
+ *       // Return user data from token payload
+ *       return jwtToken.payload;
+ *     },
+ *   });
+ *
+ *   async generateUserToken(user: { id: string; email: string; roles: string[] }) {
+ *     return await this.userTokens.generateToken({
+ *       sub: user.id,
+ *       email: user.email,
+ *       roles: user.roles,
+ *       iat: Date.now(),
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link $realm}
+ * @see {@link $role}
+ * @see {@link $permission}
+ * @see {@link $serviceAccount}
+ * @module alepha.security
+ */
 declare class AlephaSecurity {
   readonly name = "alepha.security";
   readonly $services: (alepha: Alepha) => Alepha;

package/server/cache.d.ts

@@ -46,9 +46,6 @@ type RouteLike = {
 //#endregion
 //#region src/index.d.ts
 /**
- * # 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.