alepha 0.7.7 → 0.8.1

package/queue/redis.d.ts

@@ -1,12 +1,13 @@
-import { QueueProvider } from "@alepha/queue";
-import { Alepha, Module } from "@alepha/core";
-import { RedisProvider } from "@alepha/redis";
+import { QueueProvider } from "alepha/queue";
+import { Alepha, Module, Static, TObject, TString } from "alepha";
+import { RedisProvider } from "alepha/redis";
 
 //#region src/providers/RedisQueueProvider.d.ts
+declare const envSchema: TObject<{
+  REDIS_QUEUE_PREFIX: TString;
+}>;
 declare class RedisQueueProvider implements QueueProvider {
-  protected readonly env: {
-    REDIS_QUEUE_PREFIX: string;
-  };
+  protected readonly env: Static<typeof envSchema>;
   protected readonly redisProvider: RedisProvider;
   prefix(queue: string): string;
   push(queue: string, message: string): Promise<void>;
@@ -14,14 +15,13 @@ declare class RedisQueueProvider implements QueueProvider {
 }
 //#endregion
 //#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
 /**
- * Alepha Queue Redis Module
- *
- * Plugin for Alepha Queue that provides Redis queue capabilities.
- *
- * @see {@link RedisQueueProvider}
- * @module alepha.queue.redis
- */
+* Plugin for Alepha Queue that provides Redis queue capabilities.
+*
+* @see {@link RedisQueueProvider}
+* @module alepha.queue.redis
+*/
 declare class AlephaQueueRedis implements Module {
   readonly name = "alepha.queue.redis";
   readonly $services: (alepha: Alepha) => Alepha;

package/queue.d.ts

@@ -1,8 +1,7 @@
-import * as _alepha_core0 from "@alepha/core";
-import * as _alepha_core4 from "@alepha/core";
-import { Alepha, KIND, Module, OPTIONS, Static, TSchema } from "@alepha/core";
-import { DateTimeProvider } from "@alepha/datetime";
-import * as _sinclair_typebox1 from "@sinclair/typebox";
+import * as _alepha_core0 from "alepha";
+import * as _alepha_core1 from "alepha";
+import { Alepha, KIND, Module, OPTIONS, Static, TSchema } from "alepha";
+import { DateTimeProvider } from "alepha/datetime";
 
 //#region src/providers/QueueProvider.d.ts
 /**
@@ -27,11 +26,12 @@ declare abstract class QueueProvider {
    */
   abstract pop(queue: string): Promise<string | undefined>;
 }
+//# sourceMappingURL=QueueProvider.d.ts.map
 //#endregion
 //#region src/descriptors/$queue.d.ts
 declare const KEY$1 = "QUEUE";
 /**
- * Queue descriptor.
+ * Create a new queue.
  */
 declare const $queue: {
   <T extends QueueMessageSchema>(options: QueueDescriptorOptions<T>): QueueDescriptor<T>;
@@ -87,22 +87,23 @@ declare class MemoryQueueProvider implements QueueProvider {
   push(queue: string, ...messages: string[]): Promise<void>;
   pop(queue: string): Promise<string | undefined>;
 }
+//# sourceMappingURL=MemoryQueueProvider.d.ts.map
 //#endregion
 //#region src/providers/QueueDescriptorProvider.d.ts
-declare const envSchema: _alepha_core4.TObject<{
+declare const envSchema: _alepha_core1.TObject<{
   /**
    * The interval in milliseconds to wait before checking for new messages.
    */
-  QUEUE_WORKER_INTERVAL: _sinclair_typebox1.TNumber;
+  QUEUE_WORKER_INTERVAL: _alepha_core1.TNumber;
   /**
    * The maximum interval in milliseconds to wait before checking for new messages.
    */
-  QUEUE_WORKER_MAX_INTERVAL: _sinclair_typebox1.TNumber;
+  QUEUE_WORKER_MAX_INTERVAL: _alepha_core1.TNumber;
   /**
    * The number of workers to run concurrently. Defaults to 1.
    * Useful only if you are doing a lot of I/O.
    */
-  QUEUE_WORKER_CONCURRENCY: _sinclair_typebox1.TNumber;
+  QUEUE_WORKER_CONCURRENCY: _alepha_core1.TNumber;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -116,7 +117,7 @@ interface QueueDescriptorProviderState {
   workerIntervals: Record<number, number>;
 }
 declare class QueueDescriptorProvider {
-  protected readonly log: _alepha_core4.Logger;
+  protected readonly log: _alepha_core1.Logger;
   protected readonly env: {
     QUEUE_WORKER_INTERVAL: number;
     QUEUE_WORKER_MAX_INTERVAL: number;
@@ -127,9 +128,9 @@ declare class QueueDescriptorProvider {
   protected readonly memoryQueueProvider: MemoryQueueProvider;
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly state: QueueDescriptorProviderState;
-  protected readonly configure: _alepha_core4.HookDescriptor<"configure">;
-  protected readonly start: _alepha_core4.HookDescriptor<"start">;
-  protected readonly stop: _alepha_core4.HookDescriptor<"stop">;
+  protected readonly configure: _alepha_core1.HookDescriptor<"configure">;
+  protected readonly start: _alepha_core1.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core1.HookDescriptor<"stop">;
   getQueues(): QueueDescriptor<QueueMessageSchema>[];
   getConsumers(): ConsumerDescriptorOptions<QueueMessageSchema>[];
   /**
@@ -191,11 +192,97 @@ declare class QueueDescriptorProvider {
 //#endregion
 //#region src/index.d.ts
 /**
- * Alepha Queue Module
+ * Provides asynchronous message queuing and processing capabilities through declarative queue descriptors.
  *
- * Generic interface for queueing.
- * Gives you the ability to create queues and consumers.
- * This module provides only a memory implementation of the queue provider.
+ * The queue module enables reliable background job processing and message passing using the `$queue` descriptor
+ * on class properties. It supports schema validation, automatic retries, and multiple queue backends for
+ * building scalable, decoupled applications with robust error handling.
+ *
+ * **Key Features:**
+ * - Declarative queue definition with `$queue` descriptor
+ * - Schema validation for message payloads and headers
+ * - Built-in message handlers with automatic processing
+ * - Multiple queue backends (memory, Redis, etc.)
+ * - Type-safe message publishing and consumption
+ * - Automatic retry mechanisms and error handling
+ *
+ * **Basic Usage:**
+ * ```ts
+ * import { Alepha, run, t } from "alepha";
+ * import { AlephaQueue, $queue } from "alepha/queue";
+ *
+ * class EmailService {
+ *   sendEmail = $queue({
+ *     name: "emails",
+ *     schema: {
+ *       payload: t.object({
+ *         to: t.string(),
+ *         subject: t.string(),
+ *         body: t.string(),
+ *       }),
+ *     },
+ *     handler: async ({ payload }) => {
+ *       // Process the email
+ *       await sendEmailViaProvider(payload.to, payload.subject, payload.body);
+ *       console.log(`Email sent to ${payload.to}`);
+ *     },
+ *   });
+ * }
+ *
+ * const alepha = Alepha.create()
+ *   .with(AlephaQueue)
+ *   .with(EmailService);
+ *
+ * run(alepha);
+ * ```
+ *
+ * **Queue Operations:**
+ * ```ts
+ * class NotificationService {
+ *   notifications = $queue({
+ *     name: "notifications",
+ *     provider: "memory",
+ *     schema: {
+ *       payload: t.object({
+ *         userId: t.string(),
+ *         message: t.string(),
+ *         type: t.union([t.literal("info"), t.literal("warning"), t.literal("error")]),
+ *       }),
+ *     },
+ *     handler: async ({ payload }) => {
+ *       await sendNotification(payload.userId, payload.message, payload.type);
+ *     },
+ *   });
+ *
+ *   async notifyUser(userId: string, message: string, type: "info" | "warning" | "error") {
+ *     // Push message to queue
+ *     await this.notifications.push({ userId, message, type });
+ *   }
+ * }
+ * ```
+ *
+ * **Batch Processing:**
+ * ```ts
+ * class BatchProcessor {
+ *   processTasks = $queue({
+ *     name: "batch-tasks",
+ *     schema: {
+ *       payload: t.object({
+ *         taskId: t.string(),
+ *         data: t.any(),
+ *       }),
+ *     },
+ *     handler: async ({ payload }) => {
+ *       await processTask(payload.taskId, payload.data);
+ *     },
+ *   });
+ *
+ *   async submitBatch(tasks: Array<{ taskId: string; data: any }>) {
+ *     // Push multiple messages at once
+ *     await this.processTasks.push(...tasks);
+ *   }
+ * }
+ * ```
  *
  * @see {@link $queue}
  * @see {@link $consumer}
@@ -205,6 +292,8 @@ declare class AlephaQueue implements Module {
   readonly name = "alepha.queue";
   readonly $services: (alepha: Alepha) => Alepha;
 }
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { $consumer, $queue, AlephaQueue, ConsumerDescriptor, ConsumerDescriptorOptions, MemoryQueueProvider, QueueDescriptor, QueueDescriptorOptions, QueueDescriptorProvider, QueueDescriptorProviderState, QueueMessageSchema, QueueProvider };
 //# sourceMappingURL=index.d.ts.map

package/react/auth.d.ts

@@ -1,17 +1,24 @@
-import * as _alepha_core1 from "@alepha/core";
-import * as _alepha_core52 from "@alepha/core";
-import { Alepha, Async, KIND, Module, OPTIONS } from "@alepha/core";
-import * as _alepha_server_cookies7 from "@alepha/server-cookies";
-import { Cookies, ServerCookiesProvider } from "@alepha/server-cookies";
-import * as _alepha_server41 from "@alepha/server";
-import { HttpClient } from "@alepha/server";
+import * as _alepha_core1 from "alepha";
+import * as _alepha_core52 from "alepha";
+import { Alepha, Async, KIND, Module, OPTIONS } from "alepha";
+import * as _alepha_server_cookies7 from "alepha/server/cookies";
+import { Cookies, ServerCookiesProvider } from "alepha/server/cookies";
+import * as _alepha_server41 from "alepha/server";
+import { HttpClient } from "alepha/server";
 import { Configuration } from "openid-client";
-import { HttpVirtualClient } from "@alepha/server-links";
-import { UserAccountToken } from "@alepha/security";
+import { HttpVirtualClient } from "alepha/server/links";
+import { UserAccountToken } from "alepha/security";
 import * as _sinclair_typebox2 from "@sinclair/typebox";
 
 //#region src/descriptors/$auth.d.ts
 declare const KEY = "AUTH";
+/**
+ *
+ */
+declare const $auth: {
+  (options: AuthDescriptorOptions): AuthDescriptor;
+  [KIND]: string;
+};
 type AccessToken = string;
 interface AuthDescriptorOptions {
   name?: string;
@@ -30,10 +37,6 @@ interface AuthDescriptor {
   [OPTIONS]: AuthDescriptorOptions;
   jwks: () => string;
 }
-declare const $auth: {
-  (options: AuthDescriptorOptions): AuthDescriptor;
-  [KIND]: string;
-};
 //#endregion
 //#region src/providers/ReactAuthProvider.d.ts
 declare class ReactAuthProvider {
@@ -45,7 +48,7 @@ declare class ReactAuthProvider {
     codeVerifier: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
     redirectUri: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
   }>>;
-  protected readonly tokens: _alepha_server_cookies7.CookieDescriptor<_sinclair_typebox2.TObject<{
+  readonly tokens: _alepha_server_cookies7.CookieDescriptor<_sinclair_typebox2.TObject<{
     provider: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
     access_token: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
     expires_in: _sinclair_typebox2.TOptional<_sinclair_typebox2.TNumber>;
@@ -145,6 +148,7 @@ interface ReactUser {
   name?: string;
   email?: string;
 }
+//# sourceMappingURL=ReactAuthProvider.d.ts.map
 //#endregion
 //#region src/hooks/useAuth.d.ts
 declare const useAuth: () => AuthHook;
@@ -154,6 +158,7 @@ interface AuthHook {
   login: (provider?: string) => void;
   can: <T extends object>(name: keyof HttpVirtualClient<T>) => boolean;
 }
+//# sourceMappingURL=useAuth.d.ts.map
 //#endregion
 //#region src/services/ReactAuth.d.ts
 declare class ReactAuth {
@@ -171,6 +176,7 @@ declare class ReactAuth {
   login(): void;
   logout(): void;
 }
+//# sourceMappingURL=ReactAuth.d.ts.map
 //#endregion
 //#region src/index.d.ts
 declare module "alepha/react" {
@@ -182,8 +188,6 @@ declare module "alepha/react" {
   }
 }
 /**
- * Alepha React Authentication Module
- *
  * The ReactAuthModule provides authentication services for React applications.
  *
  * @see {@link ReactAuthProvider}
@@ -193,6 +197,8 @@ declare class AlephaReactAuth implements Module {
   readonly name = "alepha.react.auth";
   readonly $services: (alepha: Alepha) => void;
 }
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { $auth, AccessToken, AlephaReactAuth, AuthDescriptor, AuthDescriptorOptions, AuthHook, AuthProvider, ReactAuth, ReactAuthProvider, ReactUser, SessionTokens, useAuth };
 //# sourceMappingURL=index.d.ts.map

package/react/head.d.ts

@@ -1,6 +1,6 @@
-import { PageConfigSchema, PageReactContext, PageRoute, RouterState, TPropsDefault, TPropsParentDefault } from "@alepha/react";
-import * as _alepha_core1 from "@alepha/core";
-import { Alepha, Module } from "@alepha/core";
+import { PageConfigSchema, PageReactContext, PageRoute, RouterState, TPropsDefault, TPropsParentDefault } from "alepha/react";
+import * as _alepha_core1 from "alepha";
+import { Alepha, Module } from "alepha";
 
 //#region src/interfaces/Head.d.ts
 interface Head extends SimpleHead {
@@ -42,15 +42,18 @@ interface SimpleHead {
     content: string;
   }>;
 }
+//# sourceMappingURL=Head.d.ts.map
 //#endregion
 //#region src/hooks/useHead.d.ts
 declare const useHead: (head?: Head | ((previous?: Head) => Head)) => void;
+//# sourceMappingURL=useHead.d.ts.map
 //#endregion
 //#region src/providers/HeadProvider.d.ts
 declare class HeadProvider {
   fillHead(state: RouterState, context: PageReactContext): void;
   protected fillHeadByPage(page: PageRoute, context: PageReactContext, props: Record<string, any>): void;
 }
+//# sourceMappingURL=HeadProvider.d.ts.map
 //#endregion
 //#region src/providers/ServerHeadProvider.d.ts
 declare class ServerHeadProvider {
@@ -61,6 +64,7 @@ declare class ServerHeadProvider {
   protected parseAttributes(attrStr: string): Record<string, string>;
   protected escapeHtml(str: string): string;
 }
+//# sourceMappingURL=ServerHeadProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
 declare module "alepha/react" {
@@ -72,7 +76,7 @@ declare module "alepha/react" {
   }
 }
 /**
- * Alepha React Head Module
+ * Fill `<head>` server & client side.
  *
  * @see {@link ServerHeadProvider}
  * @module alepha.react.head
@@ -81,6 +85,8 @@ declare class AlephaReactHead implements Module {
   readonly name = "alepha.react.head";
   readonly $services: (alepha: Alepha) => Alepha;
 }
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { AlephaReactHead, Head, ServerHeadProvider, SimpleHead, useHead };
 //# sourceMappingURL=index.d.ts.map