alepha 0.15.0 → 0.15.2

package/dist/queue/core/index.d.ts

@@ -1,6 +1,6 @@
 import * as alepha1 from "alepha";
 import { Alepha, KIND, Primitive, Service, Static, TSchema } from "alepha";
-import * as alepha_logger0 from "alepha/logger";
+import * as alepha_logger1 from "alepha/logger";
 import { DateTimeProvider } from "alepha/datetime";
 
 //#region ../../src/queue/core/providers/QueueProvider.d.ts
@@ -11,25 +11,25 @@ import { DateTimeProvider } from "alepha/datetime";
  */
 declare abstract class QueueProvider {
   /**
-       * Push a message to the queue.
-       *
-       * @param queue Name of the queue to push the message to.
-       * @param message String message to be pushed to the queue. Buffer messages are not supported for now.
-       */
+   * Push a message to the queue.
+   *
+   * @param queue Name of the queue to push the message to.
+   * @param message String message to be pushed to the queue. Buffer messages are not supported for now.
+   */
   abstract push(queue: string, message: string): Promise<void>;
   /**
-       * Pop a message from the queue.
-       *
-       * @param queue Name of the queue to pop the message from.
-       *
-       * @returns The message popped or `undefined` if the queue is empty.
-       */
+   * Pop a message from the queue.
+   *
+   * @param queue Name of the queue to pop the message from.
+   *
+   * @returns The message popped or `undefined` if the queue is empty.
+   */
   abstract pop(queue: string): Promise<string | undefined>;
 }
 //#endregion
 //#region ../../src/queue/core/providers/MemoryQueueProvider.d.ts
 declare class MemoryQueueProvider implements QueueProvider {
-  protected readonly log: alepha_logger0.Logger;
+  protected readonly log: alepha_logger1.Logger;
   protected queueList: Record<string, string[]>;
   push(queue: string, ...messages: string[]): Promise<void>;
   pop(queue: string): Promise<string | undefined>;
@@ -38,24 +38,24 @@ declare class MemoryQueueProvider implements QueueProvider {
 //#region ../../src/queue/core/providers/WorkerProvider.d.ts
 declare const envSchema: alepha1.TObject<{
   /**
-       * The interval in milliseconds to wait before checking for new messages.
-       */
+   * The interval in milliseconds to wait before checking for new messages.
+   */
   QUEUE_WORKER_INTERVAL: alepha1.TInteger;
   /**
-       * The maximum interval in milliseconds to wait before checking for new messages.
-       */
+   * The maximum interval in milliseconds to wait before checking for new messages.
+   */
   QUEUE_WORKER_MAX_INTERVAL: alepha1.TInteger;
   /**
-       * The number of workers to run concurrently. Defaults to 1.
-       * Useful only if you are doing a lot of I/O.
-       */
+   * The number of workers to run concurrently. Defaults to 1.
+   * Useful only if you are doing a lot of I/O.
+   */
   QUEUE_WORKER_CONCURRENCY: alepha1.TInteger;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
 }
 declare class WorkerProvider {
-  protected readonly log: alepha_logger0.Logger;
+  protected readonly log: alepha_logger1.Logger;
   protected readonly env: {
     QUEUE_WORKER_INTERVAL: number;
     QUEUE_WORKER_MAX_INTERVAL: number;
@@ -72,37 +72,37 @@ declare class WorkerProvider {
   get isRunning(): boolean;
   protected readonly start: alepha1.HookPrimitive<"start">;
   /**
-       * Start the workers.
-       * This method will create an endless loop that will check for new messages!
-       */
+   * Start the workers.
+   * This method will create an endless loop that will check for new messages!
+   */
   protected startWorkers(): void;
   protected readonly stop: alepha1.HookPrimitive<"stop">;
   /**
-       * Wait for the next message, where `n` is the worker number.
-       *
-       * This method will wait for a certain amount of time, increasing the wait time again if no message is found.
-       */
+   * Wait for the next message, where `n` is the worker number.
+   *
+   * This method will wait for a certain amount of time, increasing the wait time again if no message is found.
+   */
   protected waitForNextMessage(n: number): Promise<void>;
   /**
-       * Get the next message.
-       */
+   * Get the next message.
+   */
   protected getNextMessage(): Promise<undefined | NextMessage>;
   /**
-       * Process a message from a queue.
-       */
+   * Process a message from a queue.
+   */
   protected processMessage(response: {
     message: any;
     consumer: Consumer;
   }): Promise<void>;
   /**
-       * Stop the workers.
-       *
-       * This method will stop the workers and wait for them to finish processing.
-       */
+   * Stop the workers.
+   *
+   * This method will stop the workers and wait for them to finish processing.
+   */
   protected stopWorkers(): Promise<void>;
   /**
-       * Force the workers to get back to work.
-       */
+   * Force the workers to get back to work.
+   */
   wakeUp(): void;
 }
 interface Consumer<T extends TSchema = TSchema> {
@@ -232,126 +232,126 @@ declare const $queue: {
 };
 interface QueuePrimitiveOptions<T extends TSchema> {
   /**
-       * Unique name for the queue.
-       *
-       * This name is used for:
-       * - Queue identification across the system
-       * - Storage backend key generation
-       * - Logging and monitoring
-       * - Worker assignment and routing
-       *
-       * If not provided, defaults to the property key where the queue is declared.
-       *
-       * @example "email-notifications"
-       * @example "image-processing"
-       * @example "order-fulfillment"
-       */
+   * Unique name for the queue.
+   *
+   * This name is used for:
+   * - Queue identification across the system
+   * - Storage backend key generation
+   * - Logging and monitoring
+   * - Worker assignment and routing
+   *
+   * If not provided, defaults to the property key where the queue is declared.
+   *
+   * @example "email-notifications"
+   * @example "image-processing"
+   * @example "order-fulfillment"
+   */
   name?: string;
   /**
-       * Human-readable description of the queue's purpose.
-       *
-       * Used for:
-       * - Documentation generation
-       * - Monitoring dashboards
-       * - Development team communication
-       * - Queue management interfaces
-       *
-       * @example "Process user registration emails and welcome sequences"
-       * @example "Handle image uploads, resizing, and thumbnail generation"
-       * @example "Manage order processing, payment, and shipping workflows"
-       */
+   * Human-readable description of the queue's purpose.
+   *
+   * Used for:
+   * - Documentation generation
+   * - Monitoring dashboards
+   * - Development team communication
+   * - Queue management interfaces
+   *
+   * @example "Process user registration emails and welcome sequences"
+   * @example "Handle image uploads, resizing, and thumbnail generation"
+   * @example "Manage order processing, payment, and shipping workflows"
+   */
   description?: string;
   /**
-       * Queue storage provider configuration.
-       *
-       * Options:
-       * - **"memory"**: In-memory queue (default for development, lost on restart)
-       * - **Service<QueueProvider>**: Custom provider class (e.g., RedisQueueProvider)
-       * - **undefined**: Uses the default queue provider from dependency injection
-       *
-       * **Provider Selection Guidelines**:
-       * - Development: Use "memory" for fast, simple testing
-       * - Production: Use Redis or database-backed providers for persistence
-       * - High-throughput: Use specialized providers with connection pooling
-       * - Distributed systems: Use Redis or message brokers for scalability
-       *
-       * @default Uses injected QueueProvider
-       * @example "memory"
-       * @example RedisQueueProvider
-       * @example DatabaseQueueProvider
-       */
+   * Queue storage provider configuration.
+   *
+   * Options:
+   * - **"memory"**: In-memory queue (default for development, lost on restart)
+   * - **Service<QueueProvider>**: Custom provider class (e.g., RedisQueueProvider)
+   * - **undefined**: Uses the default queue provider from dependency injection
+   *
+   * **Provider Selection Guidelines**:
+   * - Development: Use "memory" for fast, simple testing
+   * - Production: Use Redis or database-backed providers for persistence
+   * - High-throughput: Use specialized providers with connection pooling
+   * - Distributed systems: Use Redis or message brokers for scalability
+   *
+   * @default Uses injected QueueProvider
+   * @example "memory"
+   * @example RedisQueueProvider
+   * @example DatabaseQueueProvider
+   */
   provider?: "memory" | Service<QueueProvider>;
   /**
-       * TypeBox schema defining the structure of messages in this queue.
-       *
-       * This schema:
-       * - Validates all messages pushed to the queue
-       * - Provides full TypeScript type inference
-       * - Ensures type safety between producers and consumers
-       * - Enables automatic serialization/deserialization
-       *
-       * **Schema Design Best Practices**:
-       * - Keep schemas simple and focused on the specific task
-       * - Use optional fields for data that might not always be available
-       * - Include version fields for schema evolution
-       * - Use union types for different message types in the same queue
-       *
-       * @example
-       * ```ts
-       * t.object({
-       *   userId: t.text(),
-       *   action: t.enum(["create", "update"]),
-       *   data: t.record(t.text(), t.any()),
-       *   timestamp: t.optional(t.number())
-       * })
-       * ```
-       */
+   * TypeBox schema defining the structure of messages in this queue.
+   *
+   * This schema:
+   * - Validates all messages pushed to the queue
+   * - Provides full TypeScript type inference
+   * - Ensures type safety between producers and consumers
+   * - Enables automatic serialization/deserialization
+   *
+   * **Schema Design Best Practices**:
+   * - Keep schemas simple and focused on the specific task
+   * - Use optional fields for data that might not always be available
+   * - Include version fields for schema evolution
+   * - Use union types for different message types in the same queue
+   *
+   * @example
+   * ```ts
+   * t.object({
+   *   userId: t.text(),
+   *   action: t.enum(["create", "update"]),
+   *   data: t.record(t.text(), t.any()),
+   *   timestamp: t.optional(t.number())
+   * })
+   * ```
+   */
   schema: T;
   /**
-       * Message handler function that processes queue messages.
-       *
-       * This function:
-       * - Runs in background worker threads for non-blocking processing
-       * - Receives type-safe message payloads based on the schema
-       * - Should be idempotent to handle potential retries
-       * - Can throw errors to trigger retry mechanisms
-       * - Has access to the full Alepha dependency injection container
-       *
-       * **Handler Best Practices**:
-       * - Keep handlers focused on a single responsibility
-       * - Use proper error handling and logging
-       * - Make operations idempotent when possible
-       * - Validate critical business logic within handlers
-       * - Consider using transactions for data consistency
-       *
-       * @param message - The queue message with validated payload
-       * @returns Promise that resolves when processing is complete
-       *
-       * @example
-       * ```ts
-       * handler: async (message) => {
-       *   const { userId, email, template } = message.payload;
-       *
-       *   try {
-       *     await this.emailService.send({
-       *       to: email,
-       *       template,
-       *       data: { userId }
-       *     });
-       *
-       *     await this.userService.markEmailSent(userId, template);
-       *   } catch (error) {
-       *     // Log error and let the queue system handle retries
-       *     this.logger.error(`Failed to send email to ${email}`, error);
-       *     throw error;
-       *   }
-       * }
-       * ```
-       */
+   * Message handler function that processes queue messages.
+   *
+   * This function:
+   * - Runs in background worker threads for non-blocking processing
+   * - Receives type-safe message payloads based on the schema
+   * - Should be idempotent to handle potential retries
+   * - Can throw errors to trigger retry mechanisms
+   * - Has access to the full Alepha dependency injection container
+   *
+   * **Handler Best Practices**:
+   * - Keep handlers focused on a single responsibility
+   * - Use proper error handling and logging
+   * - Make operations idempotent when possible
+   * - Validate critical business logic within handlers
+   * - Consider using transactions for data consistency
+   *
+   * @param message - The queue message with validated payload
+   * @returns Promise that resolves when processing is complete
+   *
+   * @example
+   * ```ts
+   * handler: async (message) => {
+   *   const { userId, email, template } = message.payload;
+   *
+   *   try {
+   *     await this.emailService.send({
+   *       to: email,
+   *       template,
+   *       data: { userId }
+   *     });
+   *
+   *     await this.userService.markEmailSent(userId, template);
+   *   } catch (error) {
+   *     // Log error and let the queue system handle retries
+   *     this.logger.error(`Failed to send email to ${email}`, error);
+   *     throw error;
+   *   }
+   * }
+   * ```
+   */
   handler?: (message: QueueMessage<T>) => Promise<void>;
 }
 declare class QueuePrimitive<T extends TSchema> extends Primitive<QueuePrimitiveOptions<T>> {
-  protected readonly log: alepha_logger0.Logger;
+  protected readonly log: alepha_logger1.Logger;
   protected readonly workerProvider: WorkerProvider;
   readonly provider: QueueProvider | MemoryQueueProvider;
   push(...payloads: Array<Static<T>>): Promise<void>;
@@ -421,109 +421,109 @@ declare const $consumer: {
 };
 interface ConsumerPrimitiveOptions<T extends TSchema> {
   /**
-       * The queue primitive that this consumer will process messages from.
-       *
-       * This establishes the connection between the consumer and its source queue:
-       * - The consumer inherits the queue's message schema for type safety
-       * - Messages pushed to the queue will be automatically routed to this consumer
-       * - Multiple consumers can be attached to the same queue for parallel processing
-       * - The consumer will use the queue's provider and configuration settings
-       *
-       * **Queue Integration Benefits**:
-       * - Type safety: Consumer handler gets fully typed message payloads
-       * - Schema validation: Messages are validated before reaching the consumer
-       * - Error handling: Failed messages can be retried or moved to dead letter queues
-       * - Monitoring: Queue metrics include consumer processing statistics
-       *
-       * @example
-       * ```ts
-       * // First, define a queue
-       * emailQueue = $queue({
-       *   name: "emails",
-       *   schema: t.object({ to: t.text(), subject: t.text() })
-       * });
-       *
-       * // Then, create a consumer for that queue
-       * emailConsumer = $consumer({
-       *   queue: this.emailQueue,  // Reference the queue primitive
-       *   handler: async (message) => { } // process email
-       * });
-       * ```
-       */
+   * The queue primitive that this consumer will process messages from.
+   *
+   * This establishes the connection between the consumer and its source queue:
+   * - The consumer inherits the queue's message schema for type safety
+   * - Messages pushed to the queue will be automatically routed to this consumer
+   * - Multiple consumers can be attached to the same queue for parallel processing
+   * - The consumer will use the queue's provider and configuration settings
+   *
+   * **Queue Integration Benefits**:
+   * - Type safety: Consumer handler gets fully typed message payloads
+   * - Schema validation: Messages are validated before reaching the consumer
+   * - Error handling: Failed messages can be retried or moved to dead letter queues
+   * - Monitoring: Queue metrics include consumer processing statistics
+   *
+   * @example
+   * ```ts
+   * // First, define a queue
+   * emailQueue = $queue({
+   *   name: "emails",
+   *   schema: t.object({ to: t.text(), subject: t.text() })
+   * });
+   *
+   * // Then, create a consumer for that queue
+   * emailConsumer = $consumer({
+   *   queue: this.emailQueue,  // Reference the queue primitive
+   *   handler: async (message) => { } // process email
+   * });
+   * ```
+   */
   queue: QueuePrimitive<T>;
   /**
-       * Message handler function that processes individual messages from the queue.
-       *
-       * This function:
-       * - Receives fully typed and validated message payloads from the connected queue
-       * - Runs in the background worker system for non-blocking operation
-       * - Should implement the core business logic for processing this message type
-       * - Can throw errors to trigger the queue's retry mechanisms
-       * - Has access to the full Alepha dependency injection container
-       * - Should be idempotent to handle potential duplicate deliveries
-       *
-       * **Handler Design Guidelines**:
-       * - Keep handlers focused on a single responsibility
-       * - Use proper error handling and meaningful error messages
-       * - Log important processing steps for debugging and monitoring
-       * - Consider transaction boundaries for data consistency
-       * - Make operations idempotent when possible
-       * - Validate business rules within the handler logic
-       *
-       * **Error Handling Strategy**:
-       * - Throw errors for temporary failures that should be retried
-       * - Log and handle permanent failures gracefully
-       * - Use specific error types to control retry behavior
-       * - Consider implementing circuit breakers for external service calls
-       *
-       * @param message - The queue message containing the validated payload
-       * @param message.payload - The typed message data based on the queue's schema
-       * @returns Promise that resolves when processing is complete
-       *
-       * @example
-       * ```ts
-       * handler: async (message) => {
-       *   const { userId, action, data } = message.payload;
-       *
-       *   try {
-       *     // Log processing start
-       *     this.logger.info(`Processing ${action} for user ${userId}`);
-       *
-       *     // Validate business rules
-       *     if (!await this.userService.exists(userId)) {
-       *       throw new Error(`User ${userId} not found`);
-       *     }
-       *
-       *     // Perform the main processing logic
-       *     switch (action) {
-       *       case "create":
-       *         await this.processCreation(userId, data);
-       *         break;
-       *       case "update":
-       *         await this.processUpdate(userId, data);
-       *         break;
-       *       default:
-       *         throw new Error(`Unknown action: ${action}`);
-       *     }
-       *
-       *     // Log successful completion
-       *     this.logger.info(`Successfully processed ${action} for user ${userId}`);
-       *
-       *   } catch (error) {
-       *     // Log error with context
-       *     this.logger.error(`Failed to process ${action} for user ${userId}`, {
-       *       error: error.message,
-       *       userId,
-       *       action,
-       *       data
-       *     });
-       *
-       *     // Re-throw to trigger queue retry mechanism
-       *     throw error;
-       *   }
-       * }
-       * ```
-       */
+   * Message handler function that processes individual messages from the queue.
+   *
+   * This function:
+   * - Receives fully typed and validated message payloads from the connected queue
+   * - Runs in the background worker system for non-blocking operation
+   * - Should implement the core business logic for processing this message type
+   * - Can throw errors to trigger the queue's retry mechanisms
+   * - Has access to the full Alepha dependency injection container
+   * - Should be idempotent to handle potential duplicate deliveries
+   *
+   * **Handler Design Guidelines**:
+   * - Keep handlers focused on a single responsibility
+   * - Use proper error handling and meaningful error messages
+   * - Log important processing steps for debugging and monitoring
+   * - Consider transaction boundaries for data consistency
+   * - Make operations idempotent when possible
+   * - Validate business rules within the handler logic
+   *
+   * **Error Handling Strategy**:
+   * - Throw errors for temporary failures that should be retried
+   * - Log and handle permanent failures gracefully
+   * - Use specific error types to control retry behavior
+   * - Consider implementing circuit breakers for external service calls
+   *
+   * @param message - The queue message containing the validated payload
+   * @param message.payload - The typed message data based on the queue's schema
+   * @returns Promise that resolves when processing is complete
+   *
+   * @example
+   * ```ts
+   * handler: async (message) => {
+   *   const { userId, action, data } = message.payload;
+   *
+   *   try {
+   *     // Log processing start
+   *     this.logger.info(`Processing ${action} for user ${userId}`);
+   *
+   *     // Validate business rules
+   *     if (!await this.userService.exists(userId)) {
+   *       throw new Error(`User ${userId} not found`);
+   *     }
+   *
+   *     // Perform the main processing logic
+   *     switch (action) {
+   *       case "create":
+   *         await this.processCreation(userId, data);
+   *         break;
+   *       case "update":
+   *         await this.processUpdate(userId, data);
+   *         break;
+   *       default:
+   *         throw new Error(`Unknown action: ${action}`);
+   *     }
+   *
+   *     // Log successful completion
+   *     this.logger.info(`Successfully processed ${action} for user ${userId}`);
+   *
+   *   } catch (error) {
+   *     // Log error with context
+   *     this.logger.error(`Failed to process ${action} for user ${userId}`, {
+   *       error: error.message,
+   *       userId,
+   *       action,
+   *       data
+   *     });
+   *
+   *     // Re-throw to trigger queue retry mechanism
+   *     throw error;
+   *   }
+   * }
+   * ```
+   */
   handler: (message: {
     payload: Static<T>;
   }) => Promise<void>;
@@ -532,14 +532,22 @@ declare class ConsumerPrimitive<T extends TSchema> extends Primitive<ConsumerPri
 //#endregion
 //#region ../../src/queue/core/index.d.ts
 /**
- * Provides asynchronous message queuing and processing capabilities through declarative queue descriptors.
+ * | type | quality | stability |
+ * |------|---------|-----------|
+ * | backend | epic | stable |
  *
- * 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.
+ * Asynchronous message processing with automatic worker management.
+ *
+ * **Features:**
+ * - Background job queues with type-safe payloads
+ * - Queue consumer handlers
+ * - Automatic worker threads for non-blocking processing
+ * - Retry mechanisms with exponential backoff
+ * - Dead letter queues for failed messages
+ * - Batch processing support
+ * - Configurable concurrency and worker pools
+ * - Providers: Memory (dev), Redis (production)
  *
- * @see {@link $queue}
- * @see {@link $consumer}
  * @module alepha.queue
  */
 declare const AlephaQueue: alepha1.Service<alepha1.Module>;

package/dist/queue/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/queue/core/providers/QueueProvider.ts","../../../src/queue/core/providers/MemoryQueueProvider.ts","../../../src/queue/core/providers/WorkerProvider.ts","../../../src/queue/core/primitives/$queue.ts","../../../src/queue/core/primitives/$consumer.ts","../../../src/queue/core/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/queue/core/providers/QueueProvider.ts","../../../src/queue/core/providers/MemoryQueueProvider.ts","../../../src/queue/core/providers/WorkerProvider.ts","../../../src/queue/core/primitives/$queue.ts","../../../src/queue/core/primitives/$consumer.ts","../../../src/queue/core/index.ts"],"mappings":"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"}