alepha 0.13.7 → 0.14.0

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

@@ -0,0 +1,548 @@
+import * as alepha1 from "alepha";
+import { Alepha, KIND, Primitive, Service, Static, TSchema } from "alepha";
+import * as alepha_logger1 from "alepha/logger";
+import { DateTimeProvider } from "alepha/datetime";
+
+//#region ../../src/queue/core/providers/QueueProvider.d.ts
+/**
+ * Minimalist Queue interface.
+ *
+ * Will be probably enhanced in the future to support more advanced features. But for now, it's enough!
+ */
+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.
+   */
+  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.
+   */
+  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_logger1.Logger;
+  protected queueList: Record<string, string[]>;
+  push(queue: string, ...messages: string[]): Promise<void>;
+  pop(queue: string): Promise<string | undefined>;
+}
+//#endregion
+//#region ../../src/queue/core/providers/WorkerProvider.d.ts
+declare const envSchema: alepha1.TObject<{
+  /**
+   * 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.
+   */
+  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.
+   */
+  QUEUE_WORKER_CONCURRENCY: alepha1.TInteger;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema>> {}
+}
+declare class WorkerProvider {
+  protected readonly log: alepha_logger1.Logger;
+  protected readonly env: {
+    QUEUE_WORKER_INTERVAL: number;
+    QUEUE_WORKER_MAX_INTERVAL: number;
+    QUEUE_WORKER_CONCURRENCY: number;
+  };
+  protected readonly alepha: Alepha;
+  protected readonly queueProvider: QueueProvider;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected workerPromises: Array<Promise<void>>;
+  protected workersRunning: number;
+  protected abortController: AbortController;
+  protected workerIntervals: Record<number, number>;
+  protected consumers: Array<Consumer>;
+  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!
+   */
+  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.
+   */
+  protected waitForNextMessage(n: number): Promise<void>;
+  /**
+   * Get the next message.
+   */
+  protected getNextMessage(): Promise<undefined | NextMessage>;
+  /**
+   * 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.
+   */
+  protected stopWorkers(): Promise<void>;
+  /**
+   * Force the workers to get back to work.
+   */
+  wakeUp(): void;
+}
+interface Consumer<T extends TSchema = TSchema> {
+  queue: QueuePrimitive<T>;
+  handler: (message: QueueMessage<T>) => Promise<void>;
+}
+interface NextMessage {
+  consumer: Consumer;
+  message: string;
+}
+//#endregion
+//#region ../../src/queue/core/primitives/$queue.d.ts
+/**
+ * Creates a queue primitive for asynchronous message processing with background workers.
+ *
+ * The $queue primitive enables powerful asynchronous communication patterns in your application.
+ * It provides type-safe message queuing with automatic worker processing, making it perfect for
+ * decoupling components and handling background tasks efficiently.
+ *
+ * **Background Processing**
+ * - Automatic worker threads for non-blocking message processing
+ * - Built-in retry mechanisms and error handling
+ * - Dead letter queues for failed message handling
+ * - Graceful shutdown and worker lifecycle management
+ *
+ * **Type Safety**
+ * - Full TypeScript support with schema validation using TypeBox
+ * - Type-safe message payloads with automatic inference
+ * - Runtime validation of all queued messages
+ * - Compile-time errors for invalid message structures
+ *
+ * **Storage Flexibility**
+ * - Memory provider for development and testing
+ * - Redis provider for production scalability and persistence
+ * - Custom provider support for specialized backends
+ * - Automatic failover and connection pooling
+ *
+ * **Performance & Scalability**
+ * - Batch processing support for high-throughput scenarios
+ * - Horizontal scaling with distributed queue backends
+ * - Configurable concurrency and worker pools
+ * - Efficient serialization and message routing
+ *
+ * **Reliability**
+ * - Message persistence across application restarts
+ * - Automatic retry with exponential backoff
+ * - Dead letter handling for permanently failed messages
+ * - Comprehensive logging and monitoring integration
+ *
+ * @example Basic notification queue
+ * ```typescript
+ * const emailQueue = $queue({
+ *   name: "email-notifications",
+ *   schema: t.object({
+ *     to: t.text(),
+ *     subject: t.text(),
+ *     body: t.text(),
+ *     priority: t.optional(t.enum(["high", "normal"]))
+ *   }),
+ *   handler: async (message) => {
+ *     await emailService.send(message.payload);
+ *     console.log(`Email sent to ${message.payload.to}`);
+ *   }
+ * });
+ *
+ * // Push messages for background processing
+ * await emailQueue.push({
+ *   to: "user@example.com",
+ *   subject: "Welcome!",
+ *   body: "Welcome to our platform",
+ *   priority: "high"
+ * });
+ * ```
+ *
+ * @example Batch processing with Redis
+ * ```typescript
+ * const imageQueue = $queue({
+ *   name: "image-processing",
+ *   provider: RedisQueueProvider,
+ *   schema: t.object({
+ *     imageId: t.text(),
+ *     operations: t.array(t.enum(["resize", "compress", "thumbnail"]))
+ *   }),
+ *   handler: async (message) => {
+ *     for (const op of message.payload.operations) {
+ *       await processImage(message.payload.imageId, op);
+ *     }
+ *   }
+ * });
+ *
+ * // Batch processing multiple images
+ * await imageQueue.push(
+ *   { imageId: "img1", operations: ["resize", "thumbnail"] },
+ *   { imageId: "img2", operations: ["compress"] },
+ *   { imageId: "img3", operations: ["resize", "compress", "thumbnail"] }
+ * );
+ * ```
+ *
+ * @example Development with memory provider
+ * ```typescript
+ * const taskQueue = $queue({
+ *   name: "dev-tasks",
+ *   provider: "memory",
+ *   schema: t.object({
+ *     taskType: t.enum(["cleanup", "backup", "report"]),
+ *     data: t.record(t.text(), t.any())
+ *   }),
+ *   handler: async (message) => {
+ *     switch (message.payload.taskType) {
+ *       case "cleanup":
+ *         await performCleanup(message.payload.data);
+ *         break;
+ *       case "backup":
+ *         await createBackup(message.payload.data);
+ *         break;
+ *       case "report":
+ *         await generateReport(message.payload.data);
+ *         break;
+ *     }
+ *   }
+ * });
+ * ```
+ */
+declare const $queue: {
+  <T extends TSchema>(options: QueuePrimitiveOptions<T>): QueuePrimitive<T>;
+  [KIND]: typeof QueuePrimitive;
+};
+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"
+   */
+  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"
+   */
+  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
+   */
+  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())
+   * })
+   * ```
+   */
+  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;
+   *   }
+   * }
+   * ```
+   */
+  handler?: (message: QueueMessage<T>) => Promise<void>;
+}
+declare class QueuePrimitive<T extends TSchema> extends Primitive<QueuePrimitiveOptions<T>> {
+  protected readonly log: alepha_logger1.Logger;
+  protected readonly workerProvider: WorkerProvider;
+  readonly provider: QueueProvider | MemoryQueueProvider;
+  push(...payloads: Array<Static<T>>): Promise<void>;
+  get name(): string;
+  protected $provider(): QueueProvider | MemoryQueueProvider;
+}
+interface QueueMessageSchema {
+  payload: TSchema;
+}
+interface QueueMessage<T extends TSchema> {
+  payload: Static<T>;
+}
+//#endregion
+//#region ../../src/queue/core/primitives/$consumer.d.ts
+/**
+ * Creates a consumer primitive to process messages from a specific queue.
+ *
+ * Provides a dedicated message consumer that connects to a queue and processes messages
+ * with custom handler logic, enabling scalable architectures where multiple consumers
+ * can process messages from the same queue.
+ *
+ * **Key Features**
+ * - Seamless integration with any $queue primitive
+ * - Full type safety inherited from queue schema
+ * - Automatic worker management for background processing
+ * - Built-in error handling and retry mechanisms
+ * - Support for multiple consumers per queue for horizontal scaling
+ *
+ * **Common Use Cases**
+ * - Email sending and notification services
+ * - Image and media processing workers
+ * - Data synchronization and background jobs
+ *
+ * @example
+ * ```ts
+ * class EmailService {
+ *   emailQueue = $queue({
+ *     name: "emails",
+ *     schema: t.object({
+ *       to: t.text(),
+ *       subject: t.text(),
+ *       body: t.text()
+ *     })
+ *   });
+ *
+ *   emailConsumer = $consumer({
+ *     queue: this.emailQueue,
+ *     handler: async (message) => {
+ *       const { to, subject, body } = message.payload;
+ *       await this.sendEmail(to, subject, body);
+ *     }
+ *   });
+ *
+ *   async sendWelcomeEmail(userEmail: string) {
+ *     await this.emailQueue.push({
+ *       to: userEmail,
+ *       subject: "Welcome!",
+ *       body: "Thanks for joining."
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare const $consumer: {
+  <T extends TSchema>(options: ConsumerPrimitiveOptions<T>): ConsumerPrimitive<T>;
+  [KIND]: typeof ConsumerPrimitive;
+};
+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
+   * });
+   * ```
+   */
+  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;
+   *   }
+   * }
+   * ```
+   */
+  handler: (message: {
+    payload: Static<T>;
+  }) => Promise<void>;
+}
+declare class ConsumerPrimitive<T extends TSchema> extends Primitive<ConsumerPrimitiveOptions<T>> {}
+//#endregion
+//#region ../../src/queue/core/index.d.ts
+/**
+ * Provides asynchronous message queuing and processing capabilities through declarative queue descriptors.
+ *
+ * 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.
+ *
+ * @see {@link $queue}
+ * @see {@link $consumer}
+ * @module alepha.queue
+ */
+declare const AlephaQueue: alepha1.Service<alepha1.Module>;
+//#endregion
+export { $consumer, $queue, AlephaQueue, Consumer, ConsumerPrimitive, ConsumerPrimitiveOptions, MemoryQueueProvider, NextMessage, QueueMessage, QueueMessageSchema, QueuePrimitive, QueuePrimitiveOptions, QueueProvider, WorkerProvider };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"],"sourcesContent":[],"mappings":"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"}