alepha 0.13.6 → 0.13.8

package/dist/queue/core/index.js

@@ -0,0 +1,391 @@
+import { $env, $hook, $inject, $module, Alepha, KIND, Primitive, createPrimitive, t } from "alepha";
+import { $logger } from "alepha/logger";
+import { DateTimeProvider } from "alepha/datetime";
+
+//#region ../../src/queue/core/primitives/$consumer.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."
+*     });
+*   }
+* }
+* ```
+*/
+const $consumer = (options) => {
+	return createPrimitive(ConsumerPrimitive, options);
+};
+var ConsumerPrimitive = class extends Primitive {};
+$consumer[KIND] = ConsumerPrimitive;
+
+//#endregion
+//#region ../../src/queue/core/providers/MemoryQueueProvider.ts
+var MemoryQueueProvider = class {
+	log = $logger();
+	queueList = {};
+	async push(queue, ...messages) {
+		if (this.queueList[queue] == null) this.queueList[queue] = [];
+		this.queueList[queue].push(...messages);
+	}
+	async pop(queue) {
+		return this.queueList[queue]?.shift();
+	}
+};
+
+//#endregion
+//#region ../../src/queue/core/providers/QueueProvider.ts
+/**
+* Minimalist Queue interface.
+*
+* Will be probably enhanced in the future to support more advanced features. But for now, it's enough!
+*/
+var QueueProvider = class {};
+
+//#endregion
+//#region ../../src/queue/core/providers/WorkerProvider.ts
+const envSchema = t.object({
+	QUEUE_WORKER_INTERVAL: t.integer({ default: 1e3 }),
+	QUEUE_WORKER_MAX_INTERVAL: t.integer({ default: 32e3 }),
+	QUEUE_WORKER_CONCURRENCY: t.integer({ default: 1 })
+});
+var WorkerProvider = class {
+	log = $logger();
+	env = $env(envSchema);
+	alepha = $inject(Alepha);
+	queueProvider = $inject(QueueProvider);
+	dateTimeProvider = $inject(DateTimeProvider);
+	workerPromises = [];
+	workersRunning = 0;
+	abortController = new AbortController();
+	workerIntervals = {};
+	consumers = [];
+	get isRunning() {
+		return this.workersRunning > 0;
+	}
+	start = $hook({
+		on: "start",
+		priority: "last",
+		handler: () => {
+			for (const queue of this.alepha.primitives($queue)) {
+				const handler = queue.options.handler;
+				if (handler) this.consumers.push({
+					handler,
+					queue
+				});
+			}
+			for (const consumer of this.alepha.primitives($consumer)) this.consumers.push(consumer.options);
+			if (this.consumers.length > 0) {
+				this.startWorkers();
+				this.log.debug(`Watching for ${this.consumers.length} queue${this.consumers.length > 1 ? "s" : ""} with ${this.env.QUEUE_WORKER_CONCURRENCY} worker${this.env.QUEUE_WORKER_CONCURRENCY > 1 ? "s" : ""}.`);
+			}
+		}
+	});
+	/**
+	* Start the workers.
+	* This method will create an endless loop that will check for new messages!
+	*/
+	startWorkers() {
+		const workerToStart = this.env.QUEUE_WORKER_CONCURRENCY - this.workersRunning;
+		for (let i = 0; i < workerToStart; i++) {
+			this.workersRunning += 1;
+			this.log.debug(`Starting worker n-${i}`);
+			const workerLoop = async () => {
+				while (this.workersRunning > 0) {
+					this.log.trace(`Worker n-${i} is checking for new messages`);
+					const next = await this.getNextMessage();
+					if (next) {
+						this.workerIntervals[i] = 0;
+						await this.processMessage(next);
+					} else await this.waitForNextMessage(i);
+				}
+				this.log.info(`Worker n-${i} has stopped`);
+				if (this.workersRunning > 0) this.workersRunning -= 1;
+			};
+			this.workerPromises.push(workerLoop().catch((e) => {
+				this.log.error(`Worker n-${i} has crashed`, e);
+				this.workersRunning -= 1;
+			}));
+		}
+	}
+	stop = $hook({
+		on: "stop",
+		handler: async () => {
+			if (this.consumers.length > 0) await this.stopWorkers();
+		}
+	});
+	/**
+	* 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.
+	*/
+	async waitForNextMessage(n) {
+		const intervals = this.workerIntervals;
+		const milliseconds = intervals[n] || this.env.QUEUE_WORKER_INTERVAL;
+		this.log.trace(`Worker n-${n} is waiting for ${milliseconds}ms.`);
+		if (this.abortController.signal.aborted) {
+			this.log.warn(`Worker n-${n} aborted.`);
+			return;
+		}
+		await this.dateTimeProvider.wait(milliseconds, { signal: this.abortController.signal });
+		if (intervals[n]) {
+			if (intervals[n] < this.env.QUEUE_WORKER_MAX_INTERVAL) intervals[n] = intervals[n] * 2;
+		} else intervals[n] = milliseconds;
+	}
+	/**
+	* Get the next message.
+	*/
+	async getNextMessage() {
+		for (const consumer of this.consumers) {
+			const message = await consumer.queue.provider.pop(consumer.queue.name);
+			if (message) return {
+				message,
+				consumer
+			};
+		}
+	}
+	/**
+	* Process a message from a queue.
+	*/
+	async processMessage(response) {
+		const { message, consumer } = response;
+		try {
+			const json = JSON.parse(message);
+			const payload = this.alepha.codec.decode(consumer.queue.options.schema, json.payload);
+			await this.alepha.context.run(() => consumer.handler({ payload }));
+		} catch (e) {
+			this.log.error("Failed to process message", e);
+		}
+	}
+	/**
+	* Stop the workers.
+	*
+	* This method will stop the workers and wait for them to finish processing.
+	*/
+	async stopWorkers() {
+		this.workersRunning = 0;
+		this.log.trace("Stopping workers...");
+		this.abortController.abort();
+		this.log.trace("Waiting for workers to finish...");
+		await Promise.all(this.workerPromises);
+	}
+	/**
+	* Force the workers to get back to work.
+	*/
+	wakeUp() {
+		this.log.debug("Waking up workers...");
+		this.abortController.abort();
+		this.abortController = new AbortController();
+		this.startWorkers();
+	}
+};
+
+//#endregion
+//#region ../../src/queue/core/primitives/$queue.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;
+*     }
+*   }
+* });
+* ```
+*/
+const $queue = (options) => {
+	return createPrimitive(QueuePrimitive, options);
+};
+var QueuePrimitive = class extends Primitive {
+	log = $logger();
+	workerProvider = $inject(WorkerProvider);
+	provider = this.$provider();
+	async push(...payloads) {
+		await Promise.all(payloads.map((payload) => this.provider.push(this.name, JSON.stringify({
+			headers: {},
+			payload: this.alepha.codec.decode(this.options.schema, payload)
+		}))));
+		this.log.debug(`Pushed to queue ${this.name}`, payloads);
+		this.workerProvider.wakeUp();
+	}
+	get name() {
+		return this.options.name || this.config.propertyKey;
+	}
+	$provider() {
+		if (!this.options.provider) return this.alepha.inject(QueueProvider);
+		if (this.options.provider === "memory") return this.alepha.inject(MemoryQueueProvider);
+		return this.alepha.inject(this.options.provider);
+	}
+};
+$queue[KIND] = QueuePrimitive;
+
+//#endregion
+//#region ../../src/queue/core/index.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
+*/
+const AlephaQueue = $module({
+	name: "alepha.queue",
+	primitives: [$queue, $consumer],
+	services: [
+		QueueProvider,
+		MemoryQueueProvider,
+		WorkerProvider
+	],
+	register: (alepha) => alepha.with({
+		optional: true,
+		provide: QueueProvider,
+		use: MemoryQueueProvider
+	}).with(WorkerProvider)
+});
+
+//#endregion
+export { $consumer, $queue, AlephaQueue, ConsumerPrimitive, MemoryQueueProvider, QueuePrimitive, QueueProvider, WorkerProvider };
+//# sourceMappingURL=index.js.map

package/dist/queue/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/queue/core/primitives/$consumer.ts","../../../src/queue/core/providers/MemoryQueueProvider.ts","../../../src/queue/core/providers/QueueProvider.ts","../../../src/queue/core/providers/WorkerProvider.ts","../../../src/queue/core/primitives/$queue.ts","../../../src/queue/core/index.ts"],"sourcesContent":["import {\n  createPrimitive,\n  KIND,\n  Primitive,\n  type Static,\n  type TSchema,\n} from \"alepha\";\nimport type { QueuePrimitive } from \"./$queue.ts\";\n\n/**\n * Creates a consumer primitive to process messages from a specific queue.\n *\n * Provides a dedicated message consumer that connects to a queue and processes messages\n * with custom handler logic, enabling scalable architectures where multiple consumers\n * can process messages from the same queue.\n *\n * **Key Features**\n * - Seamless integration with any $queue primitive\n * - Full type safety inherited from queue schema\n * - Automatic worker management for background processing\n * - Built-in error handling and retry mechanisms\n * - Support for multiple consumers per queue for horizontal scaling\n *\n * **Common Use Cases**\n * - Email sending and notification services\n * - Image and media processing workers\n * - Data synchronization and background jobs\n *\n * @example\n * ```ts\n * class EmailService {\n *   emailQueue = $queue({\n *     name: \"emails\",\n *     schema: t.object({\n *       to: t.text(),\n *       subject: t.text(),\n *       body: t.text()\n *     })\n *   });\n *\n *   emailConsumer = $consumer({\n *     queue: this.emailQueue,\n *     handler: async (message) => {\n *       const { to, subject, body } = message.payload;\n *       await this.sendEmail(to, subject, body);\n *     }\n *   });\n *\n *   async sendWelcomeEmail(userEmail: string) {\n *     await this.emailQueue.push({\n *       to: userEmail,\n *       subject: \"Welcome!\",\n *       body: \"Thanks for joining.\"\n *     });\n *   }\n * }\n * ```\n */\nexport const $consumer = <T extends TSchema>(\n  options: ConsumerPrimitiveOptions<T>,\n): ConsumerPrimitive<T> => {\n  return createPrimitive(ConsumerPrimitive<T>, options);\n};\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport interface ConsumerPrimitiveOptions<T extends TSchema> {\n  /**\n   * The queue primitive that this consumer will process messages from.\n   *\n   * This establishes the connection between the consumer and its source queue:\n   * - The consumer inherits the queue's message schema for type safety\n   * - Messages pushed to the queue will be automatically routed to this consumer\n   * - Multiple consumers can be attached to the same queue for parallel processing\n   * - The consumer will use the queue's provider and configuration settings\n   *\n   * **Queue Integration Benefits**:\n   * - Type safety: Consumer handler gets fully typed message payloads\n   * - Schema validation: Messages are validated before reaching the consumer\n   * - Error handling: Failed messages can be retried or moved to dead letter queues\n   * - Monitoring: Queue metrics include consumer processing statistics\n   *\n   * @example\n   * ```ts\n   * // First, define a queue\n   * emailQueue = $queue({\n   *   name: \"emails\",\n   *   schema: t.object({ to: t.text(), subject: t.text() })\n   * });\n   *\n   * // Then, create a consumer for that queue\n   * emailConsumer = $consumer({\n   *   queue: this.emailQueue,  // Reference the queue primitive\n   *   handler: async (message) => { } // process email\n   * });\n   * ```\n   */\n  queue: QueuePrimitive<T>;\n\n  /**\n   * Message handler function that processes individual messages from the queue.\n   *\n   * This function:\n   * - Receives fully typed and validated message payloads from the connected queue\n   * - Runs in the background worker system for non-blocking operation\n   * - Should implement the core business logic for processing this message type\n   * - Can throw errors to trigger the queue's retry mechanisms\n   * - Has access to the full Alepha dependency injection container\n   * - Should be idempotent to handle potential duplicate deliveries\n   *\n   * **Handler Design Guidelines**:\n   * - Keep handlers focused on a single responsibility\n   * - Use proper error handling and meaningful error messages\n   * - Log important processing steps for debugging and monitoring\n   * - Consider transaction boundaries for data consistency\n   * - Make operations idempotent when possible\n   * - Validate business rules within the handler logic\n   *\n   * **Error Handling Strategy**:\n   * - Throw errors for temporary failures that should be retried\n   * - Log and handle permanent failures gracefully\n   * - Use specific error types to control retry behavior\n   * - Consider implementing circuit breakers for external service calls\n   *\n   * @param message - The queue message containing the validated payload\n   * @param message.payload - The typed message data based on the queue's schema\n   * @returns Promise that resolves when processing is complete\n   *\n   * @example\n   * ```ts\n   * handler: async (message) => {\n   *   const { userId, action, data } = message.payload;\n   *\n   *   try {\n   *     // Log processing start\n   *     this.logger.info(`Processing ${action} for user ${userId}`);\n   *\n   *     // Validate business rules\n   *     if (!await this.userService.exists(userId)) {\n   *       throw new Error(`User ${userId} not found`);\n   *     }\n   *\n   *     // Perform the main processing logic\n   *     switch (action) {\n   *       case \"create\":\n   *         await this.processCreation(userId, data);\n   *         break;\n   *       case \"update\":\n   *         await this.processUpdate(userId, data);\n   *         break;\n   *       default:\n   *         throw new Error(`Unknown action: ${action}`);\n   *     }\n   *\n   *     // Log successful completion\n   *     this.logger.info(`Successfully processed ${action} for user ${userId}`);\n   *\n   *   } catch (error) {\n   *     // Log error with context\n   *     this.logger.error(`Failed to process ${action} for user ${userId}`, {\n   *       error: error.message,\n   *       userId,\n   *       action,\n   *       data\n   *     });\n   *\n   *     // Re-throw to trigger queue retry mechanism\n   *     throw error;\n   *   }\n   * }\n   * ```\n   */\n  handler: (message: { payload: Static<T> }) => Promise<void>;\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport class ConsumerPrimitive<T extends TSchema> extends Primitive<\n  ConsumerPrimitiveOptions<T>\n> {}\n\n$consumer[KIND] = ConsumerPrimitive;\n","import { $logger } from \"alepha/logger\";\nimport type { QueueProvider } from \"./QueueProvider.ts\";\n\nexport class MemoryQueueProvider implements QueueProvider {\n  protected readonly log = $logger();\n  protected queueList: Record<string, string[]> = {};\n\n  public async push(queue: string, ...messages: string[]): Promise<void> {\n    if (this.queueList[queue] == null) {\n      this.queueList[queue] = [];\n    }\n\n    this.queueList[queue].push(...messages);\n  }\n\n  public async pop(queue: string): Promise<string | undefined> {\n    return this.queueList[queue]?.shift();\n  }\n}\n","/**\n * Minimalist Queue interface.\n *\n * Will be probably enhanced in the future to support more advanced features. But for now, it's enough!\n */\nexport abstract class QueueProvider {\n  /**\n   * Push a message to the queue.\n   *\n   * @param queue Name of the queue to push the message to.\n   * @param message String message to be pushed to the queue. Buffer messages are not supported for now.\n   */\n  public abstract push(queue: string, message: string): Promise<void>;\n\n  /**\n   * Pop a message from the queue.\n   *\n   * @param queue Name of the queue to pop the message from.\n   *\n   * @returns The message popped or `undefined` if the queue is empty.\n   */\n  public abstract pop(queue: string): Promise<string | undefined>;\n}\n","import {\n  $env,\n  $hook,\n  $inject,\n  Alepha,\n  type Static,\n  type TSchema,\n  t,\n} from \"alepha\";\nimport { DateTimeProvider } from \"alepha/datetime\";\nimport { $logger } from \"alepha/logger\";\nimport { $consumer } from \"../primitives/$consumer.ts\";\nimport {\n  $queue,\n  type QueueMessage,\n  type QueuePrimitive,\n} from \"../primitives/$queue.ts\";\nimport { QueueProvider } from \"./QueueProvider.ts\";\n\nconst envSchema = t.object({\n  /**\n   * The interval in milliseconds to wait before checking for new messages.\n   */\n  QUEUE_WORKER_INTERVAL: t.integer({\n    default: 1000,\n  }),\n  /**\n   * The maximum interval in milliseconds to wait before checking for new messages.\n   */\n  QUEUE_WORKER_MAX_INTERVAL: t.integer({\n    default: 32000,\n  }),\n  /**\n   * The number of workers to run concurrently. Defaults to 1.\n   * Useful only if you are doing a lot of I/O.\n   */\n  QUEUE_WORKER_CONCURRENCY: t.integer({\n    default: 1,\n  }),\n});\n\ndeclare module \"alepha\" {\n  interface Env extends Partial<Static<typeof envSchema>> {}\n}\n\nexport class WorkerProvider {\n  protected readonly log = $logger();\n  protected readonly env = $env(envSchema);\n  protected readonly alepha = $inject(Alepha);\n  protected readonly queueProvider = $inject(QueueProvider);\n  protected readonly dateTimeProvider = $inject(DateTimeProvider);\n\n  protected workerPromises: Array<Promise<void>> = [];\n  protected workersRunning = 0;\n  protected abortController = new AbortController();\n  protected workerIntervals: Record<number, number> = {};\n  protected consumers: Array<Consumer> = [];\n\n  public get isRunning(): boolean {\n    return this.workersRunning > 0;\n  }\n\n  protected readonly start = $hook({\n    on: \"start\",\n    priority: \"last\",\n    handler: () => {\n      for (const queue of this.alepha.primitives($queue)) {\n        const handler = queue.options.handler;\n        if (handler) {\n          this.consumers.push({\n            handler,\n            queue,\n          });\n        }\n      }\n\n      for (const consumer of this.alepha.primitives($consumer)) {\n        this.consumers.push(consumer.options);\n      }\n\n      if (this.consumers.length > 0) {\n        this.startWorkers();\n        this.log.debug(\n          `Watching for ${this.consumers.length} queue${this.consumers.length > 1 ? \"s\" : \"\"} with ${this.env.QUEUE_WORKER_CONCURRENCY} worker${\n            this.env.QUEUE_WORKER_CONCURRENCY > 1 ? \"s\" : \"\"\n          }.`,\n        );\n      }\n    },\n  });\n\n  // -------------------------------------------------------------------------------------------------------------------\n\n  // Engine part - this is the part that will run the workers and process the messages\n\n  /**\n   * Start the workers.\n   * This method will create an endless loop that will check for new messages!\n   */\n  protected startWorkers(): void {\n    const workerToStart =\n      this.env.QUEUE_WORKER_CONCURRENCY - this.workersRunning;\n\n    for (let i = 0; i < workerToStart; i++) {\n      this.workersRunning += 1;\n      this.log.debug(`Starting worker n-${i}`);\n\n      const workerLoop = async () => {\n        while (this.workersRunning > 0) {\n          this.log.trace(`Worker n-${i} is checking for new messages`);\n          const next = await this.getNextMessage();\n          if (next) {\n            this.workerIntervals[i] = 0;\n            await this.processMessage(next);\n          } else {\n            await this.waitForNextMessage(i);\n          }\n        }\n        this.log.info(`Worker n-${i} has stopped`);\n        // Only decrement if we're not already at 0 (shutdown case)\n        if (this.workersRunning > 0) {\n          this.workersRunning -= 1;\n        }\n      };\n\n      this.workerPromises.push(\n        workerLoop().catch((e) => {\n          this.log.error(`Worker n-${i} has crashed`, e);\n          // Always decrement on crash, regardless of shutdown state\n          this.workersRunning -= 1;\n        }),\n      );\n    }\n  }\n\n  protected readonly stop = $hook({\n    on: \"stop\",\n    handler: async () => {\n      if (this.consumers.length > 0) {\n        await this.stopWorkers();\n      }\n    },\n  });\n\n  /**\n   * Wait for the next message, where `n` is the worker number.\n   *\n   * This method will wait for a certain amount of time, increasing the wait time again if no message is found.\n   */\n  protected async waitForNextMessage(n: number): Promise<void> {\n    const intervals = this.workerIntervals;\n    const milliseconds = intervals[n] || this.env.QUEUE_WORKER_INTERVAL;\n\n    this.log.trace(`Worker n-${n} is waiting for ${milliseconds}ms.`);\n\n    if (this.abortController.signal.aborted) {\n      this.log.warn(`Worker n-${n} aborted.`);\n      return;\n    }\n\n    await this.dateTimeProvider.wait(milliseconds, {\n      signal: this.abortController.signal,\n    });\n\n    if (intervals[n]) {\n      if (intervals[n] < this.env.QUEUE_WORKER_MAX_INTERVAL) {\n        intervals[n] = intervals[n] * 2;\n      }\n    } else {\n      intervals[n] = milliseconds;\n    }\n  }\n\n  /**\n   * Get the next message.\n   */\n  protected async getNextMessage(): Promise<undefined | NextMessage> {\n    for (const consumer of this.consumers) {\n      const provider = consumer.queue.provider;\n      const message = await provider.pop(consumer.queue.name);\n      if (message) {\n        return { message, consumer };\n      }\n    }\n  }\n\n  /**\n   * Process a message from a queue.\n   */\n  protected async processMessage(response: {\n    message: any;\n    consumer: Consumer;\n  }) {\n    const { message, consumer } = response;\n\n    try {\n      const json = JSON.parse(message);\n      const payload = this.alepha.codec.decode(\n        consumer.queue.options.schema,\n        json.payload,\n      );\n      await this.alepha.context.run(() => consumer.handler({ payload }));\n    } catch (e) {\n      this.log.error(\"Failed to process message\", e);\n    }\n  }\n\n  /**\n   * Stop the workers.\n   *\n   * This method will stop the workers and wait for them to finish processing.\n   */\n  protected async stopWorkers() {\n    this.workersRunning = 0;\n\n    this.log.trace(\"Stopping workers...\");\n    this.abortController.abort();\n\n    this.log.trace(\"Waiting for workers to finish...\");\n    await Promise.all(this.workerPromises);\n  }\n\n  /**\n   * Force the workers to get back to work.\n   */\n  public wakeUp(): void {\n    this.log.debug(\"Waking up workers...\");\n    this.abortController.abort();\n    this.abortController = new AbortController();\n\n    // if no workers are running, start them, (should not happen, but just in case)\n    this.startWorkers();\n  }\n}\n\nexport interface Consumer<T extends TSchema = TSchema> {\n  queue: QueuePrimitive<T>;\n  handler: (message: QueueMessage<T>) => Promise<void>;\n}\n\nexport interface NextMessage {\n  consumer: Consumer;\n  message: string;\n}\n","import {\n  $inject,\n  createPrimitive,\n  KIND,\n  Primitive,\n  type Service,\n  type Static,\n  type TSchema,\n} from \"alepha\";\nimport { $logger } from \"alepha/logger\";\nimport { MemoryQueueProvider } from \"../providers/MemoryQueueProvider.ts\";\nimport { QueueProvider } from \"../providers/QueueProvider.ts\";\nimport { WorkerProvider } from \"../providers/WorkerProvider.ts\";\n\n/**\n * Creates a queue primitive for asynchronous message processing with background workers.\n *\n * The $queue primitive enables powerful asynchronous communication patterns in your application.\n * It provides type-safe message queuing with automatic worker processing, making it perfect for\n * decoupling components and handling background tasks efficiently.\n *\n * **Background Processing**\n * - Automatic worker threads for non-blocking message processing\n * - Built-in retry mechanisms and error handling\n * - Dead letter queues for failed message handling\n * - Graceful shutdown and worker lifecycle management\n *\n * **Type Safety**\n * - Full TypeScript support with schema validation using TypeBox\n * - Type-safe message payloads with automatic inference\n * - Runtime validation of all queued messages\n * - Compile-time errors for invalid message structures\n *\n * **Storage Flexibility**\n * - Memory provider for development and testing\n * - Redis provider for production scalability and persistence\n * - Custom provider support for specialized backends\n * - Automatic failover and connection pooling\n *\n * **Performance & Scalability**\n * - Batch processing support for high-throughput scenarios\n * - Horizontal scaling with distributed queue backends\n * - Configurable concurrency and worker pools\n * - Efficient serialization and message routing\n *\n * **Reliability**\n * - Message persistence across application restarts\n * - Automatic retry with exponential backoff\n * - Dead letter handling for permanently failed messages\n * - Comprehensive logging and monitoring integration\n *\n * @example Basic notification queue\n * ```typescript\n * const emailQueue = $queue({\n *   name: \"email-notifications\",\n *   schema: t.object({\n *     to: t.text(),\n *     subject: t.text(),\n *     body: t.text(),\n *     priority: t.optional(t.enum([\"high\", \"normal\"]))\n *   }),\n *   handler: async (message) => {\n *     await emailService.send(message.payload);\n *     console.log(`Email sent to ${message.payload.to}`);\n *   }\n * });\n *\n * // Push messages for background processing\n * await emailQueue.push({\n *   to: \"user@example.com\",\n *   subject: \"Welcome!\",\n *   body: \"Welcome to our platform\",\n *   priority: \"high\"\n * });\n * ```\n *\n * @example Batch processing with Redis\n * ```typescript\n * const imageQueue = $queue({\n *   name: \"image-processing\",\n *   provider: RedisQueueProvider,\n *   schema: t.object({\n *     imageId: t.text(),\n *     operations: t.array(t.enum([\"resize\", \"compress\", \"thumbnail\"]))\n *   }),\n *   handler: async (message) => {\n *     for (const op of message.payload.operations) {\n *       await processImage(message.payload.imageId, op);\n *     }\n *   }\n * });\n *\n * // Batch processing multiple images\n * await imageQueue.push(\n *   { imageId: \"img1\", operations: [\"resize\", \"thumbnail\"] },\n *   { imageId: \"img2\", operations: [\"compress\"] },\n *   { imageId: \"img3\", operations: [\"resize\", \"compress\", \"thumbnail\"] }\n * );\n * ```\n *\n * @example Development with memory provider\n * ```typescript\n * const taskQueue = $queue({\n *   name: \"dev-tasks\",\n *   provider: \"memory\",\n *   schema: t.object({\n *     taskType: t.enum([\"cleanup\", \"backup\", \"report\"]),\n *     data: t.record(t.text(), t.any())\n *   }),\n *   handler: async (message) => {\n *     switch (message.payload.taskType) {\n *       case \"cleanup\":\n *         await performCleanup(message.payload.data);\n *         break;\n *       case \"backup\":\n *         await createBackup(message.payload.data);\n *         break;\n *       case \"report\":\n *         await generateReport(message.payload.data);\n *         break;\n *     }\n *   }\n * });\n * ```\n */\nexport const $queue = <T extends TSchema>(\n  options: QueuePrimitiveOptions<T>,\n): QueuePrimitive<T> => {\n  return createPrimitive(QueuePrimitive<T>, options);\n};\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport interface QueuePrimitiveOptions<T extends TSchema> {\n  /**\n   * Unique name for the queue.\n   *\n   * This name is used for:\n   * - Queue identification across the system\n   * - Storage backend key generation\n   * - Logging and monitoring\n   * - Worker assignment and routing\n   *\n   * If not provided, defaults to the property key where the queue is declared.\n   *\n   * @example \"email-notifications\"\n   * @example \"image-processing\"\n   * @example \"order-fulfillment\"\n   */\n  name?: string;\n\n  /**\n   * Human-readable description of the queue's purpose.\n   *\n   * Used for:\n   * - Documentation generation\n   * - Monitoring dashboards\n   * - Development team communication\n   * - Queue management interfaces\n   *\n   * @example \"Process user registration emails and welcome sequences\"\n   * @example \"Handle image uploads, resizing, and thumbnail generation\"\n   * @example \"Manage order processing, payment, and shipping workflows\"\n   */\n  description?: string;\n\n  /**\n   * Queue storage provider configuration.\n   *\n   * Options:\n   * - **\"memory\"**: In-memory queue (default for development, lost on restart)\n   * - **Service<QueueProvider>**: Custom provider class (e.g., RedisQueueProvider)\n   * - **undefined**: Uses the default queue provider from dependency injection\n   *\n   * **Provider Selection Guidelines**:\n   * - Development: Use \"memory\" for fast, simple testing\n   * - Production: Use Redis or database-backed providers for persistence\n   * - High-throughput: Use specialized providers with connection pooling\n   * - Distributed systems: Use Redis or message brokers for scalability\n   *\n   * @default Uses injected QueueProvider\n   * @example \"memory\"\n   * @example RedisQueueProvider\n   * @example DatabaseQueueProvider\n   */\n  provider?: \"memory\" | Service<QueueProvider>;\n\n  /**\n   * TypeBox schema defining the structure of messages in this queue.\n   *\n   * This schema:\n   * - Validates all messages pushed to the queue\n   * - Provides full TypeScript type inference\n   * - Ensures type safety between producers and consumers\n   * - Enables automatic serialization/deserialization\n   *\n   * **Schema Design Best Practices**:\n   * - Keep schemas simple and focused on the specific task\n   * - Use optional fields for data that might not always be available\n   * - Include version fields for schema evolution\n   * - Use union types for different message types in the same queue\n   *\n   * @example\n   * ```ts\n   * t.object({\n   *   userId: t.text(),\n   *   action: t.enum([\"create\", \"update\"]),\n   *   data: t.record(t.text(), t.any()),\n   *   timestamp: t.optional(t.number())\n   * })\n   * ```\n   */\n  schema: T;\n\n  /**\n   * Message handler function that processes queue messages.\n   *\n   * This function:\n   * - Runs in background worker threads for non-blocking processing\n   * - Receives type-safe message payloads based on the schema\n   * - Should be idempotent to handle potential retries\n   * - Can throw errors to trigger retry mechanisms\n   * - Has access to the full Alepha dependency injection container\n   *\n   * **Handler Best Practices**:\n   * - Keep handlers focused on a single responsibility\n   * - Use proper error handling and logging\n   * - Make operations idempotent when possible\n   * - Validate critical business logic within handlers\n   * - Consider using transactions for data consistency\n   *\n   * @param message - The queue message with validated payload\n   * @returns Promise that resolves when processing is complete\n   *\n   * @example\n   * ```ts\n   * handler: async (message) => {\n   *   const { userId, email, template } = message.payload;\n   *\n   *   try {\n   *     await this.emailService.send({\n   *       to: email,\n   *       template,\n   *       data: { userId }\n   *     });\n   *\n   *     await this.userService.markEmailSent(userId, template);\n   *   } catch (error) {\n   *     // Log error and let the queue system handle retries\n   *     this.logger.error(`Failed to send email to ${email}`, error);\n   *     throw error;\n   *   }\n   * }\n   * ```\n   */\n  handler?: (message: QueueMessage<T>) => Promise<void>;\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport class QueuePrimitive<T extends TSchema> extends Primitive<\n  QueuePrimitiveOptions<T>\n> {\n  protected readonly log = $logger();\n  protected readonly workerProvider = $inject(WorkerProvider);\n  public readonly provider = this.$provider();\n\n  public async push(...payloads: Array<Static<T>>) {\n    await Promise.all(\n      payloads.map((payload) =>\n        this.provider.push(\n          this.name,\n          JSON.stringify({\n            headers: {},\n            payload: this.alepha.codec.decode(this.options.schema, payload),\n          }),\n        ),\n      ),\n    );\n\n    this.log.debug(`Pushed to queue ${this.name}`, payloads);\n    this.workerProvider.wakeUp();\n  }\n\n  public get name() {\n    return this.options.name || this.config.propertyKey;\n  }\n\n  protected $provider() {\n    if (!this.options.provider) {\n      return this.alepha.inject(QueueProvider);\n    }\n    if (this.options.provider === \"memory\") {\n      return this.alepha.inject(MemoryQueueProvider);\n    }\n    return this.alepha.inject(this.options.provider);\n  }\n}\n\n$queue[KIND] = QueuePrimitive;\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport interface QueueMessageSchema {\n  payload: TSchema;\n}\n\nexport interface QueueMessage<T extends TSchema> {\n  payload: Static<T>;\n}\n","import { $module, type Alepha } from \"alepha\";\nimport { $consumer } from \"./primitives/$consumer.ts\";\nimport { $queue } from \"./primitives/$queue.ts\";\nimport { MemoryQueueProvider } from \"./providers/MemoryQueueProvider.ts\";\nimport { QueueProvider } from \"./providers/QueueProvider.ts\";\nimport { WorkerProvider } from \"./providers/WorkerProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./primitives/$consumer.ts\";\nexport * from \"./primitives/$queue.ts\";\nexport * from \"./providers/MemoryQueueProvider.ts\";\nexport * from \"./providers/QueueProvider.ts\";\nexport * from \"./providers/WorkerProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Provides asynchronous message queuing and processing capabilities through declarative queue descriptors.\n *\n * The queue module enables reliable background job processing and message passing using the `$queue` descriptor\n * on class properties. It supports schema validation, automatic retries, and multiple queue backends for\n * building scalable, decoupled applications with robust error handling.\n *\n * @see {@link $queue}\n * @see {@link $consumer}\n * @module alepha.queue\n */\nexport const AlephaQueue = $module({\n  name: \"alepha.queue\",\n  primitives: [$queue, $consumer],\n  services: [QueueProvider, MemoryQueueProvider, WorkerProvider],\n  register: (alepha: Alepha) =>\n    alepha\n      .with({\n        optional: true,\n        provide: QueueProvider,\n        use: MemoryQueueProvider,\n      })\n      .with(WorkerProvider),\n});\n"],"mappings":"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"}

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

@@ -0,0 +1,28 @@
+import * as alepha1 from "alepha";
+import { Static } from "alepha";
+import { QueueProvider } from "alepha/queue";
+import { RedisProvider } from "alepha/redis";
+
+//#region ../../src/queue/redis/providers/RedisQueueProvider.d.ts
+declare const envSchema: alepha1.TObject<{
+  REDIS_QUEUE_PREFIX: alepha1.TString;
+}>;
+declare class RedisQueueProvider implements QueueProvider {
+  protected readonly env: Static<typeof envSchema>;
+  protected readonly redisProvider: RedisProvider;
+  prefix(queue: string): string;
+  push(queue: string, message: string): Promise<void>;
+  pop(queue: string): Promise<string | undefined>;
+}
+//#endregion
+//#region ../../src/queue/redis/index.d.ts
+/**
+ * Plugin for Alepha Queue that provides Redis queue capabilities.
+ *
+ * @see {@link RedisQueueProvider}
+ * @module alepha.queue.redis
+ */
+declare const AlephaQueueRedis: alepha1.Service<alepha1.Module>;
+//#endregion
+export { AlephaQueueRedis, RedisQueueProvider };
+//# sourceMappingURL=index.d.ts.map

package/dist/queue/redis/index.js

@@ -0,0 +1,43 @@
+import { $env, $inject, $module, t } from "alepha";
+import { AlephaQueue, QueueProvider } from "alepha/queue";
+import { RedisProvider } from "alepha/redis";
+
+//#region ../../src/queue/redis/providers/RedisQueueProvider.ts
+const envSchema = t.object({ REDIS_QUEUE_PREFIX: t.text({ default: "queue" }) });
+var RedisQueueProvider = class {
+	env = $env(envSchema);
+	redisProvider = $inject(RedisProvider);
+	prefix(queue) {
+		return `${this.env.REDIS_QUEUE_PREFIX}:${queue}`;
+	}
+	async push(queue, message) {
+		await this.redisProvider.publisher.LPUSH(this.prefix(queue), message);
+	}
+	async pop(queue) {
+		const value = await this.redisProvider.publisher.RPOP(this.prefix(queue));
+		if (value == null) return;
+		return String(value);
+	}
+};
+
+//#endregion
+//#region ../../src/queue/redis/index.ts
+/**
+* Plugin for Alepha Queue that provides Redis queue capabilities.
+*
+* @see {@link RedisQueueProvider}
+* @module alepha.queue.redis
+*/
+const AlephaQueueRedis = $module({
+	name: "alepha.queue.redis",
+	services: [RedisQueueProvider],
+	register: (alepha) => alepha.with({
+		optional: true,
+		provide: QueueProvider,
+		use: RedisQueueProvider
+	}).with(AlephaQueue)
+});
+
+//#endregion
+export { AlephaQueueRedis, RedisQueueProvider };
+//# sourceMappingURL=index.js.map

package/dist/queue/redis/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/queue/redis/providers/RedisQueueProvider.ts","../../../src/queue/redis/index.ts"],"sourcesContent":["import { $env, $inject, type Static, t } from \"alepha\";\nimport type { QueueProvider } from \"alepha/queue\";\nimport { RedisProvider } from \"alepha/redis\";\n\nconst envSchema = t.object({\n  REDIS_QUEUE_PREFIX: t.text({\n    default: \"queue\",\n  }),\n});\n\nexport class RedisQueueProvider implements QueueProvider {\n  protected readonly env: Static<typeof envSchema> = $env(envSchema);\n  protected readonly redisProvider: RedisProvider = $inject(RedisProvider);\n\n  public prefix(queue: string): string {\n    return `${this.env.REDIS_QUEUE_PREFIX}:${queue}`;\n  }\n\n  public async push(queue: string, message: string): Promise<void> {\n    await this.redisProvider.publisher.LPUSH(this.prefix(queue), message);\n  }\n\n  public async pop(queue: string): Promise<string | undefined> {\n    const value = await this.redisProvider.publisher.RPOP(this.prefix(queue));\n    if (value == null) {\n      return undefined;\n    }\n\n    return String(value);\n  }\n}\n","import { $module, type Alepha } from \"alepha\";\nimport { AlephaQueue, QueueProvider } from \"alepha/queue\";\nimport { RedisQueueProvider } from \"./providers/RedisQueueProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./providers/RedisQueueProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Plugin for Alepha Queue that provides Redis queue capabilities.\n *\n * @see {@link RedisQueueProvider}\n * @module alepha.queue.redis\n */\nexport const AlephaQueueRedis = $module({\n  name: \"alepha.queue.redis\",\n  services: [RedisQueueProvider],\n  register: (alepha: Alepha) =>\n    alepha\n      .with({\n        optional: true,\n        provide: QueueProvider,\n        use: RedisQueueProvider,\n      })\n      .with(AlephaQueue),\n});\n"],"mappings":";;;;;AAIA,MAAM,YAAY,EAAE,OAAO,EACzB,oBAAoB,EAAE,KAAK,EACzB,SAAS,SACV,CAAC,EACH,CAAC;AAEF,IAAa,qBAAb,MAAyD;CACvD,AAAmB,MAAgC,KAAK,UAAU;CAClE,AAAmB,gBAA+B,QAAQ,cAAc;CAExE,AAAO,OAAO,OAAuB;AACnC,SAAO,GAAG,KAAK,IAAI,mBAAmB,GAAG;;CAG3C,MAAa,KAAK,OAAe,SAAgC;AAC/D,QAAM,KAAK,cAAc,UAAU,MAAM,KAAK,OAAO,MAAM,EAAE,QAAQ;;CAGvE,MAAa,IAAI,OAA4C;EAC3D,MAAM,QAAQ,MAAM,KAAK,cAAc,UAAU,KAAK,KAAK,OAAO,MAAM,CAAC;AACzE,MAAI,SAAS,KACX;AAGF,SAAO,OAAO,MAAM;;;;;;;;;;;;ACZxB,MAAa,mBAAmB,QAAQ;CACtC,MAAM;CACN,UAAU,CAAC,mBAAmB;CAC9B,WAAW,WACT,OACG,KAAK;EACJ,UAAU;EACV,SAAS;EACT,KAAK;EACN,CAAC,CACD,KAAK,YAAY;CACvB,CAAC"}

package/dist/scheduler/index.d.ts

@@ -1,10 +1,10 @@
-import * as alepha4 from "alepha";
+import * as alepha1 from "alepha";
 import { Alepha, Async, KIND, Primitive, Static } from "alepha";
 import * as alepha_lock0 from "alepha/lock";
 import { DateTime, DateTimeProvider, DurationLike } from "alepha/datetime";
 import * as alepha_logger0 from "alepha/logger";
-import * as dayjs0 from "dayjs";
 import { Cron } from "cron-schedule";
+import * as dayjs0 from "dayjs";
 
 //#region ../../src/scheduler/constants/CRON.d.ts
 declare const CRON: {
@@ -23,8 +23,8 @@ declare class CronProvider {
   protected readonly log: alepha_logger0.Logger;
   protected readonly cronJobs: Array<CronJob>;
   getCronJobs(): Array<CronJob>;
-  protected readonly start: alepha4.HookPrimitive<"start">;
-  protected readonly stop: alepha4.HookPrimitive<"stop">;
+  protected readonly start: alepha1.HookPrimitive<"start">;
+  protected readonly stop: alepha1.HookPrimitive<"stop">;
   protected boot(name: string | CronJob): void;
   abort(name: string | CronJob): void;
   /**
@@ -87,8 +87,8 @@ type SchedulerPrimitiveOptions = {
    */
   lock?: boolean;
 };
-declare const envSchema: alepha4.TObject<{
-  SCHEDULER_PREFIX: alepha4.TOptional<alepha4.TString>;
+declare const envSchema: alepha1.TObject<{
+  SCHEDULER_PREFIX: alepha1.TOptional<alepha1.TString>;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -139,7 +139,7 @@ declare module "alepha" {
  * @see {@link $scheduler}
  * @module alepha.scheduler
  */
-declare const AlephaScheduler: alepha4.Service<alepha4.Module>;
+declare const AlephaScheduler: alepha1.Service<alepha1.Module>;
 //#endregion
 export { $scheduler, AlephaScheduler, CRON, CronJob, CronProvider, SchedulerHandlerArguments, SchedulerPrimitive, SchedulerPrimitiveOptions };
 //# sourceMappingURL=index.d.ts.map