alepha 0.13.0 → 0.13.2

package/dist/queue/index.cjs

@@ -1,1044 +0,0 @@
-let alepha = require("alepha");
-let alepha_logger = require("alepha/logger");
-let alepha_datetime = require("alepha/datetime");
-
-//#region src/queue/descriptors/$consumer.ts
-/**
-* Creates a consumer descriptor 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 descriptor
-* - 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 (0, alepha.createDescriptor)(ConsumerDescriptor, options);
-};
-var ConsumerDescriptor = class extends alepha.Descriptor {};
-$consumer[alepha.KIND] = ConsumerDescriptor;
-
-//#endregion
-//#region src/queue/providers/QueueProvider.ts
-/**
-* Queue provider interface supporting both simple message-based and advanced job-based operations.
-*
-* The simple API (push/pop/popBlocking) is for basic fire-and-forget messaging.
-* The job API provides crash recovery, retries, delayed jobs, priorities, and job history.
-*/
-var QueueProvider = class {
-	eventHandlers = /* @__PURE__ */ new Map();
-	on(event, handler) {
-		if (!this.eventHandlers.has(event)) this.eventHandlers.set(event, /* @__PURE__ */ new Set());
-		this.eventHandlers.get(event).add(handler);
-		return () => {
-			this.eventHandlers.get(event)?.delete(handler);
-		};
-	}
-	/**
-	* Emit a queue event to all registered handlers.
-	*
-	* @param event The event to emit.
-	*/
-	async emit(event) {
-		const handlers = [...this.eventHandlers.get(event.type) ?? [], ...this.eventHandlers.get("*") ?? []];
-		await Promise.all(handlers.map((handler) => handler(event)));
-	}
-};
-
-//#endregion
-//#region src/queue/providers/MemoryQueueProvider.ts
-const DEFAULT_MAX_ATTEMPTS = 1;
-const DEFAULT_LOCK_DURATION = 3e4;
-const DEFAULT_BACKOFF_DELAY = 1e3;
-const DEFAULT_BACKOFF_MAX_DELAY = 3e4;
-/**
-* In-memory queue provider with full job support.
-*
-* This provider stores all data in memory and is suitable for:
-* - Development and testing
-* - Single-instance applications
-* - Scenarios where job persistence across restarts is not required
-*/
-var MemoryQueueProvider = class extends QueueProvider {
-	log = (0, alepha_logger.$logger)();
-	messageQueues = {};
-	messageWaiters = /* @__PURE__ */ new Set();
-	jobs = /* @__PURE__ */ new Map();
-	waiting = /* @__PURE__ */ new Map();
-	delayed = /* @__PURE__ */ new Map();
-	active = /* @__PURE__ */ new Map();
-	completed = /* @__PURE__ */ new Map();
-	failed = /* @__PURE__ */ new Map();
-	jobWaiters = /* @__PURE__ */ new Set();
-	jobIdCounter = 0;
-	async push(queue, ...messages) {
-		if (this.messageQueues[queue] == null) this.messageQueues[queue] = [];
-		for (const message of messages) {
-			const waiter = this.findMessageWaiter(queue);
-			if (waiter) {
-				this.removeMessageWaiter(waiter);
-				waiter.resolve({
-					queue,
-					message
-				});
-			} else this.messageQueues[queue].push(message);
-		}
-	}
-	async pop(queue) {
-		return this.messageQueues[queue]?.shift();
-	}
-	async popBlocking(queues, timeoutSeconds) {
-		for (const queue of queues) {
-			const message = this.messageQueues[queue]?.shift();
-			if (message) return {
-				queue,
-				message
-			};
-		}
-		return new Promise((resolve) => {
-			const timer = setTimeout(() => {
-				this.removeMessageWaiter(waiter);
-				resolve(void 0);
-			}, timeoutSeconds * 1e3);
-			const waiter = {
-				queues: new Set(queues),
-				resolve: (result) => {
-					clearTimeout(timer);
-					resolve(result);
-				},
-				timer
-			};
-			this.messageWaiters.add(waiter);
-		});
-	}
-	findMessageWaiter(queue) {
-		for (const waiter of this.messageWaiters) if (waiter.queues.has(queue)) return waiter;
-	}
-	removeMessageWaiter(waiter) {
-		clearTimeout(waiter.timer);
-		this.messageWaiters.delete(waiter);
-	}
-	generateJobId() {
-		return `job_${++this.jobIdCounter}_${Date.now()}`;
-	}
-	ensureQueueStructures(queue) {
-		if (!this.jobs.has(queue)) {
-			this.jobs.set(queue, /* @__PURE__ */ new Map());
-			this.waiting.set(queue, []);
-			this.delayed.set(queue, []);
-			this.active.set(queue, /* @__PURE__ */ new Set());
-			this.completed.set(queue, []);
-			this.failed.set(queue, []);
-		}
-	}
-	async addJob(queue, payload, options) {
-		this.ensureQueueStructures(queue);
-		const now = Date.now();
-		const delay = options?.delay ?? 0;
-		const isDelayed = delay > 0;
-		const job = {
-			id: this.generateJobId(),
-			queue,
-			payload,
-			options: {
-				priority: options?.priority ?? 0,
-				delay: options?.delay ?? 0,
-				maxAttempts: options?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
-				backoff: options?.backoff,
-				lockDuration: options?.lockDuration ?? DEFAULT_LOCK_DURATION,
-				removeOnComplete: options?.removeOnComplete,
-				removeOnFail: options?.removeOnFail
-			},
-			state: {
-				status: isDelayed ? "delayed" : "waiting",
-				attempts: 0,
-				createdAt: now,
-				availableAt: isDelayed ? now + delay : now
-			}
-		};
-		this.jobs.get(queue).set(job.id, job);
-		if (isDelayed) this.insertDelayed(queue, job);
-		else {
-			this.insertWaiting(queue, job);
-			this.notifyJobWaiters(queue);
-		}
-		this.log.debug(`Added job ${job.id} to queue ${queue}`, {
-			status: job.state.status,
-			priority: job.options.priority
-		});
-		if (!isDelayed) await this.emit({
-			type: "waiting",
-			queue,
-			jobId: job.id,
-			timestamp: now,
-			job
-		});
-		return job;
-	}
-	insertWaiting(queue, job) {
-		const waitingList = this.waiting.get(queue);
-		const priority = job.options.priority ?? 0;
-		let insertIndex = waitingList.length;
-		for (let i = 0; i < waitingList.length; i++) {
-			const existingJob = this.jobs.get(queue).get(waitingList[i]);
-			if (existingJob && (existingJob.options.priority ?? 0) > priority) {
-				insertIndex = i;
-				break;
-			}
-		}
-		waitingList.splice(insertIndex, 0, job.id);
-	}
-	insertDelayed(queue, job) {
-		const delayedList = this.delayed.get(queue);
-		const availableAt = job.state.availableAt ?? 0;
-		let insertIndex = delayedList.length;
-		for (let i = 0; i < delayedList.length; i++) {
-			const existingJob = this.jobs.get(queue).get(delayedList[i]);
-			if (existingJob && (existingJob.state.availableAt ?? 0) > availableAt) {
-				insertIndex = i;
-				break;
-			}
-		}
-		delayedList.splice(insertIndex, 0, job.id);
-	}
-	notifyJobWaiters(queue) {
-		for (const waiter of this.jobWaiters) if (waiter.queues.has(queue)) {
-			const result = this.tryAcquireJob(Array.from(waiter.queues), waiter.workerId);
-			if (result) {
-				this.removeJobWaiter(waiter);
-				waiter.resolve(result);
-				return;
-			}
-		}
-	}
-	removeJobWaiter(waiter) {
-		clearTimeout(waiter.timer);
-		this.jobWaiters.delete(waiter);
-	}
-	tryAcquireJob(queues, workerId) {
-		const now = Date.now();
-		for (const queue of queues) {
-			const waitingList = this.waiting.get(queue);
-			if (!waitingList || waitingList.length === 0) continue;
-			const jobId = waitingList.shift();
-			const job = this.jobs.get(queue).get(jobId);
-			if (!job) continue;
-			job.state.status = "active";
-			job.state.attempts += 1;
-			job.state.lockedBy = workerId;
-			job.state.lockedUntil = now + (job.options.lockDuration ?? DEFAULT_LOCK_DURATION);
-			job.state.processedAt = now;
-			this.active.get(queue).add(jobId);
-			this.log.debug(`Worker ${workerId} acquired job ${jobId}`, {
-				queue,
-				attempt: job.state.attempts
-			});
-			this.emit({
-				type: "active",
-				queue,
-				jobId,
-				timestamp: now,
-				workerId,
-				attempt: job.state.attempts
-			});
-			return {
-				queue,
-				job
-			};
-		}
-	}
-	async acquireJob(queues, workerId, timeoutSeconds) {
-		for (const queue of queues) this.ensureQueueStructures(queue);
-		const result = this.tryAcquireJob(queues, workerId);
-		if (result) return result;
-		return new Promise((resolve) => {
-			const timer = setTimeout(() => {
-				this.removeJobWaiter(waiter);
-				resolve(void 0);
-			}, timeoutSeconds * 1e3);
-			const waiter = {
-				queues: new Set(queues),
-				workerId,
-				resolve: (result$1) => {
-					clearTimeout(timer);
-					resolve(result$1);
-				},
-				timer
-			};
-			this.jobWaiters.add(waiter);
-		});
-	}
-	async completeJob(queue, jobId, result) {
-		const job = this.jobs.get(queue)?.get(jobId);
-		if (!job) {
-			this.log.warn(`Attempted to complete unknown job ${jobId}`);
-			return;
-		}
-		const now = Date.now();
-		const duration = now - (job.state.processedAt ?? now);
-		this.active.get(queue)?.delete(jobId);
-		job.state.status = "completed";
-		job.state.completedAt = now;
-		job.state.result = result;
-		job.state.lockedBy = void 0;
-		job.state.lockedUntil = void 0;
-		const removeOnComplete = job.options.removeOnComplete;
-		if (removeOnComplete === true) {
-			this.jobs.get(queue)?.delete(jobId);
-			this.log.debug(`Job ${jobId} completed and removed`, {
-				queue,
-				result
-			});
-		} else {
-			this.completed.get(queue).unshift(jobId);
-			if (typeof removeOnComplete === "number" && removeOnComplete >= 0) await this.cleanJobs(queue, "completed", { maxCount: removeOnComplete });
-			this.log.debug(`Job ${jobId} completed`, {
-				queue,
-				result
-			});
-		}
-		await this.emit({
-			type: "completed",
-			queue,
-			jobId,
-			timestamp: now,
-			result,
-			duration
-		});
-	}
-	async failJob(queue, jobId, error, stackTrace) {
-		const job = this.jobs.get(queue)?.get(jobId);
-		if (!job) {
-			this.log.warn(`Attempted to fail unknown job ${jobId}`);
-			return;
-		}
-		const now = Date.now();
-		this.active.get(queue)?.delete(jobId);
-		const maxAttempts = job.options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
-		if (job.state.attempts < maxAttempts) {
-			const backoffDelay = this.calculateBackoff(job);
-			job.state.status = "delayed";
-			job.state.availableAt = now + backoffDelay;
-			job.state.error = error;
-			job.state.stackTrace = stackTrace;
-			job.state.lockedBy = void 0;
-			job.state.lockedUntil = void 0;
-			this.insertDelayed(queue, job);
-			this.log.debug(`Job ${jobId} failed, will retry in ${backoffDelay}ms`, {
-				queue,
-				attempt: job.state.attempts,
-				maxAttempts,
-				error
-			});
-			await this.emit({
-				type: "retrying",
-				queue,
-				jobId,
-				timestamp: now,
-				error,
-				attempt: job.state.attempts + 1,
-				delay: backoffDelay
-			});
-		} else {
-			job.state.status = "failed";
-			job.state.failedAt = now;
-			job.state.error = error;
-			job.state.stackTrace = stackTrace;
-			job.state.lockedBy = void 0;
-			job.state.lockedUntil = void 0;
-			const removeOnFail = job.options.removeOnFail;
-			if (removeOnFail === true) {
-				this.jobs.get(queue)?.delete(jobId);
-				this.log.debug(`Job ${jobId} permanently failed and removed after ${job.state.attempts} attempts`, {
-					queue,
-					error
-				});
-			} else {
-				this.failed.get(queue).unshift(jobId);
-				if (typeof removeOnFail === "number" && removeOnFail >= 0) await this.cleanJobs(queue, "failed", { maxCount: removeOnFail });
-				this.log.debug(`Job ${jobId} permanently failed after ${job.state.attempts} attempts`, {
-					queue,
-					error
-				});
-			}
-			await this.emit({
-				type: "failed",
-				queue,
-				jobId,
-				timestamp: now,
-				error,
-				stackTrace,
-				attempts: job.state.attempts
-			});
-		}
-	}
-	calculateBackoff(job) {
-		const backoff = job.options.backoff;
-		const attempt = job.state.attempts;
-		if (!backoff) return DEFAULT_BACKOFF_DELAY;
-		const baseDelay = backoff.delay ?? DEFAULT_BACKOFF_DELAY;
-		const maxDelay = backoff.maxDelay ?? DEFAULT_BACKOFF_MAX_DELAY;
-		if (backoff.type === "fixed") return baseDelay;
-		const exponentialDelay = baseDelay * 2 ** (attempt - 1);
-		return Math.min(exponentialDelay, maxDelay);
-	}
-	async renewJobLock(queue, jobId, workerId) {
-		const job = this.jobs.get(queue)?.get(jobId);
-		if (!job || job.state.lockedBy !== workerId) return false;
-		job.state.lockedUntil = Date.now() + (job.options.lockDuration ?? DEFAULT_LOCK_DURATION);
-		return true;
-	}
-	async getJob(queue, jobId) {
-		return this.jobs.get(queue)?.get(jobId);
-	}
-	async getJobs(queue, status, options) {
-		const limit = options?.limit ?? 100;
-		const offset = options?.offset ?? 0;
-		let jobIds;
-		switch (status) {
-			case "waiting":
-				jobIds = this.waiting.get(queue) ?? [];
-				break;
-			case "delayed":
-				jobIds = this.delayed.get(queue) ?? [];
-				break;
-			case "active":
-				jobIds = Array.from(this.active.get(queue) ?? []);
-				break;
-			case "completed":
-				jobIds = this.completed.get(queue) ?? [];
-				break;
-			case "failed":
-				jobIds = this.failed.get(queue) ?? [];
-				break;
-			default: jobIds = [];
-		}
-		const jobsMap = this.jobs.get(queue);
-		if (!jobsMap) return [];
-		return jobIds.slice(offset, offset + limit).map((id) => jobsMap.get(id)).filter((job) => job !== void 0);
-	}
-	async getJobCounts(queue) {
-		return {
-			waiting: this.waiting.get(queue)?.length ?? 0,
-			delayed: this.delayed.get(queue)?.length ?? 0,
-			active: this.active.get(queue)?.size ?? 0,
-			completed: this.completed.get(queue)?.length ?? 0,
-			failed: this.failed.get(queue)?.length ?? 0
-		};
-	}
-	async promoteDelayedJobs(queue) {
-		const delayedList = this.delayed.get(queue);
-		if (!delayedList || delayedList.length === 0) return 0;
-		const now = Date.now();
-		let promoted = 0;
-		while (delayedList.length > 0) {
-			const jobId = delayedList[0];
-			const job = this.jobs.get(queue)?.get(jobId);
-			if (!job || (job.state.availableAt ?? 0) > now) break;
-			delayedList.shift();
-			job.state.status = "waiting";
-			this.insertWaiting(queue, job);
-			promoted++;
-			this.log.debug(`Promoted delayed job ${jobId}`, { queue });
-			this.emit({
-				type: "waiting",
-				queue,
-				jobId,
-				timestamp: now,
-				job
-			});
-		}
-		if (promoted > 0) this.notifyJobWaiters(queue);
-		return promoted;
-	}
-	async recoverStalledJobs(queue, stalledThresholdMs) {
-		const activeSet = this.active.get(queue);
-		if (!activeSet || activeSet.size === 0) return [];
-		const now = Date.now();
-		const stalledJobIds = [];
-		for (const jobId of activeSet) {
-			const job = this.jobs.get(queue)?.get(jobId);
-			if (!job) continue;
-			if ((job.state.lockedUntil ?? 0) + stalledThresholdMs < now) stalledJobIds.push(jobId);
-		}
-		for (const jobId of stalledJobIds) {
-			const job = this.jobs.get(queue).get(jobId);
-			const workerId = job.state.lockedBy;
-			activeSet.delete(jobId);
-			const maxAttempts = job.options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
-			const hasMoreAttempts = job.state.attempts < maxAttempts;
-			await this.emit({
-				type: "stalled",
-				queue,
-				jobId,
-				timestamp: now,
-				workerId,
-				willRetry: hasMoreAttempts
-			});
-			if (hasMoreAttempts) {
-				job.state.status = "waiting";
-				job.state.lockedBy = void 0;
-				job.state.lockedUntil = void 0;
-				job.state.error = "Job stalled (worker timeout)";
-				this.insertWaiting(queue, job);
-				this.log.warn(`Recovered stalled job ${jobId}, returning to waiting`, {
-					queue,
-					attempt: job.state.attempts
-				});
-				await this.emit({
-					type: "waiting",
-					queue,
-					jobId,
-					timestamp: now,
-					job
-				});
-			} else {
-				job.state.status = "failed";
-				job.state.failedAt = now;
-				job.state.lockedBy = void 0;
-				job.state.lockedUntil = void 0;
-				job.state.error = "Job stalled (worker timeout) - max attempts exceeded";
-				const removeOnFail = job.options.removeOnFail;
-				if (removeOnFail === true) this.jobs.get(queue)?.delete(jobId);
-				else {
-					this.failed.get(queue).unshift(jobId);
-					if (typeof removeOnFail === "number" && removeOnFail > 0) await this.cleanJobs(queue, "failed", { maxCount: removeOnFail });
-				}
-				this.log.warn(`Stalled job ${jobId} permanently failed`, {
-					queue,
-					attempts: job.state.attempts
-				});
-				await this.emit({
-					type: "failed",
-					queue,
-					jobId,
-					timestamp: now,
-					error: job.state.error,
-					attempts: job.state.attempts
-				});
-			}
-		}
-		if (stalledJobIds.length > 0) this.notifyJobWaiters(queue);
-		return stalledJobIds;
-	}
-	async cleanJobs(queue, status, options) {
-		const jobsList = status === "completed" ? this.completed.get(queue) : this.failed.get(queue);
-		if (!jobsList || jobsList.length === 0) return 0;
-		const jobsMap = this.jobs.get(queue);
-		if (!jobsMap) return 0;
-		const now = Date.now();
-		const maxAge = options?.maxAge;
-		const maxCount = options?.maxCount;
-		let removed = 0;
-		if (maxAge !== void 0) {
-			const cutoff = now - maxAge;
-			const toRemove = [];
-			for (const jobId of jobsList) {
-				const job = jobsMap.get(jobId);
-				if (job) {
-					const timestamp = status === "completed" ? job.state.completedAt : job.state.failedAt;
-					if (timestamp && timestamp < cutoff) toRemove.push(jobId);
-				}
-			}
-			for (const jobId of toRemove) {
-				const idx = jobsList.indexOf(jobId);
-				if (idx !== -1) {
-					jobsList.splice(idx, 1);
-					jobsMap.delete(jobId);
-					removed++;
-				}
-			}
-		}
-		if (maxCount !== void 0 && jobsList.length > maxCount) {
-			const toRemove = jobsList.splice(maxCount);
-			for (const jobId of toRemove) {
-				jobsMap.delete(jobId);
-				removed++;
-			}
-		}
-		return removed;
-	}
-	async removeJob(queue, jobId) {
-		const job = this.jobs.get(queue)?.get(jobId);
-		if (!job) return;
-		const previousStatus = job.state.status;
-		switch (job.state.status) {
-			case "waiting": {
-				const list = this.waiting.get(queue);
-				const idx = list?.indexOf(jobId) ?? -1;
-				if (idx !== -1) list.splice(idx, 1);
-				break;
-			}
-			case "delayed": {
-				const list = this.delayed.get(queue);
-				const idx = list?.indexOf(jobId) ?? -1;
-				if (idx !== -1) list.splice(idx, 1);
-				break;
-			}
-			case "active":
-				this.active.get(queue)?.delete(jobId);
-				break;
-			case "completed": {
-				const list = this.completed.get(queue);
-				const idx = list?.indexOf(jobId) ?? -1;
-				if (idx !== -1) list.splice(idx, 1);
-				break;
-			}
-			case "failed": {
-				const list = this.failed.get(queue);
-				const idx = list?.indexOf(jobId) ?? -1;
-				if (idx !== -1) list.splice(idx, 1);
-				break;
-			}
-		}
-		this.jobs.get(queue)?.delete(jobId);
-		await this.emit({
-			type: "removed",
-			queue,
-			jobId,
-			timestamp: Date.now(),
-			previousStatus
-		});
-	}
-	cancelWaiters() {
-		for (const waiter of this.jobWaiters) {
-			clearTimeout(waiter.timer);
-			waiter.resolve(void 0);
-		}
-		this.jobWaiters.clear();
-		for (const waiter of this.messageWaiters) {
-			clearTimeout(waiter.timer);
-			waiter.resolve(void 0);
-		}
-		this.messageWaiters.clear();
-	}
-};
-
-//#endregion
-//#region src/queue/descriptors/$queue.ts
-/**
-* Creates a queue descriptor for asynchronous message processing with background workers.
-*
-* The $queue descriptor 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 (0, alepha.createDescriptor)(QueueDescriptor, options);
-};
-var QueueDescriptor = class extends alepha.Descriptor {
-	log = (0, alepha_logger.$logger)();
-	provider = this.$provider();
-	async push(payloadOrFirst, optionsOrSecond, ...rest) {
-		if (optionsOrSecond != null && typeof optionsOrSecond === "object" && ("priority" in optionsOrSecond || "delay" in optionsOrSecond)) {
-			const payload = this.alepha.codec.decode(this.options.schema, payloadOrFirst);
-			await this.provider.addJob(this.name, payload, {
-				...this.getDefaultJobOptions(),
-				priority: optionsOrSecond.priority,
-				delay: optionsOrSecond.delay
-			});
-			this.log.debug(`Pushed job to queue ${this.name}`, {
-				payload,
-				options: optionsOrSecond
-			});
-		} else {
-			const payloads = optionsOrSecond != null ? [
-				payloadOrFirst,
-				optionsOrSecond,
-				...rest
-			] : [payloadOrFirst, ...rest];
-			await Promise.all(payloads.map((p) => {
-				const payload = this.alepha.codec.decode(this.options.schema, p);
-				return this.provider.addJob(this.name, payload, this.getDefaultJobOptions());
-			}));
-			this.log.debug(`Pushed ${payloads.length} job(s) to queue ${this.name}`, payloads);
-		}
-	}
-	/**
-	* Get default job options from descriptor configuration.
-	*/
-	getDefaultJobOptions() {
-		return {
-			maxAttempts: this.options.maxAttempts,
-			backoff: this.options.backoff,
-			lockDuration: this.options.lockDuration,
-			removeOnComplete: this.options.removeOnComplete,
-			removeOnFail: this.options.removeOnFail
-		};
-	}
-	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[alepha.KIND] = QueueDescriptor;
-
-//#endregion
-//#region src/queue/providers/WorkerProvider.ts
-const envSchema = alepha.t.object({
-	QUEUE_WORKER_BLOCKING_TIMEOUT: alepha.t.integer({ default: 5 }),
-	QUEUE_WORKER_CONCURRENCY: alepha.t.integer({ default: 1 }),
-	QUEUE_WORKER_LOCK_RENEWAL_INTERVAL: alepha.t.integer({ default: 1e4 }),
-	QUEUE_SCHEDULER_INTERVAL: alepha.t.integer({ default: 5e3 }),
-	QUEUE_STALLED_THRESHOLD: alepha.t.integer({ default: 5e3 })
-});
-var WorkerProvider = class {
-	log = (0, alepha_logger.$logger)();
-	env = (0, alepha.$env)(envSchema);
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	queueProvider = (0, alepha.$inject)(QueueProvider);
-	dateTime = (0, alepha.$inject)(alepha_datetime.DateTimeProvider);
-	workerPromises = [];
-	workersRunning = 0;
-	shouldStop = false;
-	consumers = [];
-	consumersByProvider = /* @__PURE__ */ new Map();
-	schedulerPromise;
-	schedulerRunning = false;
-	abortController;
-	workerId = `worker_${process.pid}_${Date.now()}`;
-	get isRunning() {
-		return this.workersRunning > 0;
-	}
-	start = (0, alepha.$hook)({
-		on: "start",
-		priority: "last",
-		handler: () => {
-			for (const queue of this.alepha.descriptors($queue)) {
-				const handler = queue.options.handler;
-				if (handler) this.consumers.push({
-					handler,
-					queue
-				});
-			}
-			for (const consumer of this.alepha.descriptors($consumer)) this.consumers.push(consumer.options);
-			for (const consumer of this.consumers) {
-				const provider = consumer.queue.provider;
-				const list = this.consumersByProvider.get(provider) ?? [];
-				list.push(consumer);
-				this.consumersByProvider.set(provider, list);
-			}
-			if (this.consumers.length > 0) {
-				this.startWorkers();
-				this.startScheduler();
-				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.
-	* Each worker acquires jobs and processes them with proper lifecycle management.
-	*/
-	startWorkers() {
-		const workerToStart = this.env.QUEUE_WORKER_CONCURRENCY - this.workersRunning;
-		for (let i = 0; i < workerToStart; i++) {
-			this.workersRunning += 1;
-			const workerIndex = i;
-			const localWorkerId = `${this.workerId}_${workerIndex}`;
-			this.log.debug(`Starting worker n-${workerIndex}`);
-			const workerLoop = async () => {
-				while (!this.shouldStop) {
-					this.log.trace(`Worker n-${workerIndex} is waiting for jobs`);
-					const acquired = await this.acquireNextJob(localWorkerId);
-					if (acquired) await this.processJob(acquired, localWorkerId);
-				}
-				this.log.info(`Worker n-${workerIndex} has stopped`);
-			};
-			this.workerPromises.push(workerLoop().catch((e) => {
-				this.log.error(`Worker n-${workerIndex} has crashed`, e);
-				this.workersRunning -= 1;
-			}));
-		}
-	}
-	/**
-	* Start the scheduler for delayed job promotion and stalled job recovery.
-	*/
-	startScheduler() {
-		if (this.schedulerRunning) return;
-		this.schedulerRunning = true;
-		this.abortController = new AbortController();
-		this.log.debug("Starting scheduler");
-		const schedulerLoop = async () => {
-			while (!this.shouldStop) {
-				try {
-					await this.runSchedulerCycle();
-				} catch (e) {
-					this.log.error("Scheduler cycle failed", e);
-				}
-				await this.dateTime.wait(this.env.QUEUE_SCHEDULER_INTERVAL, { signal: this.abortController?.signal });
-			}
-			this.log.debug("Scheduler stopped");
-		};
-		this.schedulerPromise = schedulerLoop();
-	}
-	/**
-	* Run one cycle of the scheduler.
-	* Promotes delayed jobs and recovers stalled jobs.
-	*/
-	async runSchedulerCycle() {
-		for (const [provider, consumers] of this.consumersByProvider) {
-			const queues = new Set(consumers.map((c) => c.queue.name));
-			for (const queue of queues) {
-				const promoted = await provider.promoteDelayedJobs(queue);
-				if (promoted > 0) this.log.debug(`Promoted ${promoted} delayed jobs in queue ${queue}`);
-				const recovered = await provider.recoverStalledJobs(queue, this.env.QUEUE_STALLED_THRESHOLD);
-				if (recovered.length > 0) this.log.warn(`Recovered ${recovered.length} stalled jobs in queue ${queue}`);
-			}
-		}
-	}
-	stop = (0, alepha.$hook)({
-		on: "stop",
-		handler: async () => {
-			if (this.consumers.length > 0) await this.stopWorkers();
-		}
-	});
-	/**
-	* Acquire the next available job from any provider.
-	*/
-	async acquireNextJob(localWorkerId) {
-		for (const [provider, consumers] of this.consumersByProvider) {
-			const queueNames = consumers.map((c) => c.queue.name);
-			const acquired = await provider.acquireJob(queueNames, localWorkerId, this.env.QUEUE_WORKER_BLOCKING_TIMEOUT);
-			if (acquired) {
-				const consumer = consumers.find((c) => c.queue.name === acquired.queue);
-				if (consumer) return {
-					acquired,
-					consumer,
-					provider
-				};
-			}
-		}
-	}
-	/**
-	* Process a job with proper lifecycle management.
-	* - Starts a lock renewal interval
-	* - Calls the handler
-	* - Marks job as completed or failed
-	*/
-	async processJob({ acquired, consumer, provider }, localWorkerId) {
-		const { queue, job } = acquired;
-		const lockRenewalInterval = this.dateTime.createInterval(async () => {
-			try {
-				if (!await provider.renewJobLock(queue, job.id, localWorkerId)) this.log.warn(`Failed to renew lock for job ${job.id}, lock may have been stolen`);
-			} catch (e) {
-				this.log.error(`Error renewing lock for job ${job.id}`, e);
-			}
-		}, this.env.QUEUE_WORKER_LOCK_RENEWAL_INTERVAL, true);
-		try {
-			const payload = this.alepha.codec.decode(consumer.queue.options.schema, job.payload);
-			await this.alepha.context.run(() => consumer.handler({ payload }));
-			await provider.completeJob(queue, job.id);
-			this.log.debug(`Job ${job.id} completed successfully`, { queue });
-		} catch (e) {
-			const error = e instanceof Error ? e.message : String(e);
-			const stackTrace = e instanceof Error ? e.stack : void 0;
-			await provider.failJob(queue, job.id, error, stackTrace);
-			this.log.error(`Job ${job.id} failed`, e);
-		} finally {
-			this.dateTime.clearInterval(lockRenewalInterval);
-		}
-	}
-	/**
-	* Stop the workers and scheduler.
-	*/
-	async stopWorkers() {
-		this.shouldStop = true;
-		this.workersRunning = 0;
-		this.schedulerRunning = false;
-		this.abortController?.abort();
-		for (const provider of this.consumersByProvider.keys()) provider.cancelWaiters();
-		this.log.trace("Stopping workers...");
-		this.log.trace("Waiting for workers to finish...");
-		const promises = [...this.workerPromises];
-		if (this.schedulerPromise) promises.push(this.schedulerPromise);
-		await Promise.all(promises);
-	}
-};
-
-//#endregion
-//#region src/queue/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 = (0, alepha.$module)({
-	name: "alepha.queue",
-	descriptors: [$queue, $consumer],
-	services: [
-		QueueProvider,
-		MemoryQueueProvider,
-		WorkerProvider
-	],
-	register: (alepha$1) => alepha$1.with({
-		optional: true,
-		provide: QueueProvider,
-		use: MemoryQueueProvider
-	}).with(WorkerProvider)
-});
-
-//#endregion
-exports.$consumer = $consumer;
-exports.$queue = $queue;
-exports.AlephaQueue = AlephaQueue;
-exports.ConsumerDescriptor = ConsumerDescriptor;
-exports.MemoryQueueProvider = MemoryQueueProvider;
-exports.QueueDescriptor = QueueDescriptor;
-exports.QueueProvider = QueueProvider;
-exports.WorkerProvider = WorkerProvider;
-//# sourceMappingURL=index.cjs.map