alepha 0.13.6 → 0.13.8

package/dist/queue-redis/index.js

@@ -1,872 +0,0 @@
-import { $env, $hook, $inject, $module, t } from "alepha";
-import { AlephaQueue, QueueProvider } from "alepha/queue";
-import { $logger } from "alepha/logger";
-import { RedisProvider } from "alepha/redis";
-
-//#region ../../src/queue-redis/providers/RedisQueueProvider.ts
-const DEFAULT_MAX_ATTEMPTS = 1;
-const DEFAULT_LOCK_DURATION = 3e4;
-const DEFAULT_BACKOFF_DELAY = 1e3;
-const DEFAULT_BACKOFF_MAX_DELAY = 3e4;
-const envSchema = t.object({ REDIS_QUEUE_PREFIX: t.text({ default: "queue" }) });
-const ACQUIRE_JOB_SCRIPT = `
-local waitingKey = KEYS[1]
-local activeKey = KEYS[2]
-local jobKeyPrefix = KEYS[3]
-local workerId = ARGV[1]
-local now = tonumber(ARGV[2])
-local lockDuration = tonumber(ARGV[3])
-
--- Get highest priority job (lowest score)
-local jobs = redis.call('ZRANGE', waitingKey, 0, 0)
-if #jobs == 0 then
-  return nil
-end
-
-local jobId = jobs[1]
-local jobKey = jobKeyPrefix .. ':' .. jobId
-
--- Remove from waiting (atomic check)
-local removed = redis.call('ZREM', waitingKey, jobId)
-if removed == 0 then
-  return nil
-end
-
--- Get current job data
-local jobData = redis.call('HGETALL', jobKey)
-if #jobData == 0 then
-  return nil
-end
-
--- Parse job data into table
-local job = {}
-for i = 1, #jobData, 2 do
-  job[jobData[i]] = jobData[i + 1]
-end
-
--- Parse current state
-local state = cjson.decode(job['state'])
-local options = cjson.decode(job['options'])
-
--- Update state
-state['status'] = 'active'
-state['attempts'] = state['attempts'] + 1
-state['lockedBy'] = workerId
-state['lockedUntil'] = now + (options['lockDuration'] or lockDuration)
-state['processedAt'] = now
-
--- Save updated state
-redis.call('HSET', jobKey, 'state', cjson.encode(state))
-
--- Add to active set
-redis.call('SADD', activeKey, jobId)
-
--- Return job data
-return cjson.encode({
-  id = job['id'],
-  queue = job['queue'],
-  payload = cjson.decode(job['payload']),
-  options = options,
-  state = state
-})
-`;
-const COMPLETE_JOB_SCRIPT = `
-local jobKey = KEYS[1]
-local activeKey = KEYS[2]
-local completedKey = KEYS[3]
-local jobId = ARGV[1]
-local now = tonumber(ARGV[2])
-local result = ARGV[3]
-
--- Get job data
-local jobData = redis.call('HGETALL', jobKey)
-if #jobData == 0 then
-  return nil
-end
-
--- Parse job data
-local job = {}
-for i = 1, #jobData, 2 do
-  job[jobData[i]] = jobData[i + 1]
-end
-
-local state = cjson.decode(job['state'])
-local options = cjson.decode(job['options'])
-local processedAt = state['processedAt'] or now
-
--- Remove from active
-redis.call('SREM', activeKey, jobId)
-
--- Update state
-state['status'] = 'completed'
-state['completedAt'] = now
-state['result'] = result ~= '' and cjson.decode(result) or nil
-state['lockedBy'] = nil
-state['lockedUntil'] = nil
-
-local removeOnComplete = options['removeOnComplete']
-
-if removeOnComplete == true then
-  -- Remove job immediately
-  redis.call('DEL', jobKey)
-  return cjson.encode({ removed = true, duration = now - processedAt })
-else
-  -- Update job state
-  redis.call('HSET', jobKey, 'state', cjson.encode(state))
-
-  -- Add to completed list (newest first)
-  redis.call('LPUSH', completedKey, jobId)
-
-  -- If removeOnComplete is a number, trim the list (0 means keep none)
-  if type(removeOnComplete) == 'number' and removeOnComplete >= 0 then
-    -- Get jobs to remove
-    local toRemove = redis.call('LRANGE', completedKey, removeOnComplete, -1)
-    for _, oldJobId in ipairs(toRemove) do
-      redis.call('DEL', jobKey:gsub(jobId, oldJobId))
-    end
-    redis.call('LTRIM', completedKey, 0, removeOnComplete - 1)
-  end
-
-  return cjson.encode({ removed = false, duration = now - processedAt })
-end
-`;
-const FAIL_JOB_SCRIPT = `
-local jobKey = KEYS[1]
-local activeKey = KEYS[2]
-local delayedKey = KEYS[3]
-local failedKey = KEYS[4]
-local jobId = ARGV[1]
-local now = tonumber(ARGV[2])
-local errorMsg = ARGV[3]
-local stackTrace = ARGV[4]
-local backoffDelay = tonumber(ARGV[5])
-
--- Get job data
-local jobData = redis.call('HGETALL', jobKey)
-if #jobData == 0 then
-  return nil
-end
-
--- Parse job data
-local job = {}
-for i = 1, #jobData, 2 do
-  job[jobData[i]] = jobData[i + 1]
-end
-
-local state = cjson.decode(job['state'])
-local options = cjson.decode(job['options'])
-
--- Remove from active
-redis.call('SREM', activeKey, jobId)
-
-local maxAttempts = options['maxAttempts'] or 1
-local hasMoreAttempts = state['attempts'] < maxAttempts
-
-if hasMoreAttempts then
-  -- Schedule for retry
-  state['status'] = 'delayed'
-  state['availableAt'] = now + backoffDelay
-  state['error'] = errorMsg
-  state['stackTrace'] = stackTrace ~= '' and stackTrace or nil
-  state['lockedBy'] = nil
-  state['lockedUntil'] = nil
-
-  redis.call('HSET', jobKey, 'state', cjson.encode(state))
-  redis.call('ZADD', delayedKey, now + backoffDelay, jobId)
-
-  return cjson.encode({ status = 'retrying', delay = backoffDelay, attempt = state['attempts'] + 1 })
-else
-  -- Permanently failed
-  state['status'] = 'failed'
-  state['failedAt'] = now
-  state['error'] = errorMsg
-  state['stackTrace'] = stackTrace ~= '' and stackTrace or nil
-  state['lockedBy'] = nil
-  state['lockedUntil'] = nil
-
-  local removeOnFail = options['removeOnFail']
-
-  if removeOnFail == true then
-    redis.call('DEL', jobKey)
-    return cjson.encode({ status = 'failed', removed = true, attempts = state['attempts'] })
-  else
-    redis.call('HSET', jobKey, 'state', cjson.encode(state))
-    redis.call('LPUSH', failedKey, jobId)
-
-    if type(removeOnFail) == 'number' and removeOnFail >= 0 then
-      local toRemove = redis.call('LRANGE', failedKey, removeOnFail, -1)
-      for _, oldJobId in ipairs(toRemove) do
-        redis.call('DEL', jobKey:gsub(jobId, oldJobId))
-      end
-      redis.call('LTRIM', failedKey, 0, removeOnFail - 1)
-    end
-
-    return cjson.encode({ status = 'failed', removed = false, attempts = state['attempts'] })
-  end
-end
-`;
-/**
-* Redis-based queue provider with full job support.
-*
-* Features:
-* - Atomic job acquisition using Lua scripts
-* - Blocking wait using Redis BZPOPMIN (no polling)
-* - Event emission for job lifecycle
-* - removeOnComplete/removeOnFail support
-*
-* Uses the following Redis data structures:
-* - HASH `{prefix}:job:{queue}:{id}` - Job data
-* - ZSET `{prefix}:waiting:{queue}` - Waiting jobs (score = priority)
-* - ZSET `{prefix}:delayed:{queue}` - Delayed jobs (score = availableAt timestamp)
-* - SET `{prefix}:active:{queue}` - Active jobs
-* - LIST `{prefix}:completed:{queue}` - Completed jobs (newest first)
-* - LIST `{prefix}:failed:{queue}` - Failed jobs (newest first)
-* - LIST `{prefix}:messages:{queue}` - Simple message queue (backward compat)
-* - LIST `{prefix}:notify:{queue}` - Notification list for blocking wait
-*/
-var RedisQueueProvider = class extends QueueProvider {
-	log = $logger();
-	env = $env(envSchema);
-	redisProvider = $inject(RedisProvider);
-	blockingClient;
-	shouldStop = false;
-	acquireJobSha;
-	completeJobSha;
-	failJobSha;
-	start = $hook({
-		on: "start",
-		handler: async () => {
-			this.shouldStop = false;
-			this.blockingClient = this.redisProvider.duplicate();
-			await this.blockingClient.connect();
-			const redis = this.redisProvider.publisher;
-			const acquireSha = await redis.scriptLoad(ACQUIRE_JOB_SCRIPT);
-			const completeSha = await redis.scriptLoad(COMPLETE_JOB_SCRIPT);
-			const failSha = await redis.scriptLoad(FAIL_JOB_SCRIPT);
-			this.acquireJobSha = acquireSha.toString();
-			this.completeJobSha = completeSha.toString();
-			this.failJobSha = failSha.toString();
-		}
-	});
-	stop = $hook({
-		on: "stop",
-		handler: async () => {
-			this.shouldStop = true;
-			if (this.blockingClient?.isOpen) await this.blockingClient.close();
-		}
-	});
-	key(type, queue, id) {
-		const base = `${this.env.REDIS_QUEUE_PREFIX}:${type}:${queue}`;
-		return id ? `${base}:${id}` : base;
-	}
-	messageKey(queue) {
-		return `${this.env.REDIS_QUEUE_PREFIX}:${queue}`;
-	}
-	notifyKey(queue) {
-		return `${this.env.REDIS_QUEUE_PREFIX}:notify:${queue}`;
-	}
-	async push(queue, message) {
-		await this.redisProvider.publisher.LPUSH(this.messageKey(queue), message);
-	}
-	async pop(queue) {
-		const value = await this.redisProvider.publisher.RPOP(this.messageKey(queue));
-		if (value == null) return void 0;
-		return String(value);
-	}
-	async popBlocking(queues, timeoutSeconds) {
-		if (queues.length === 0 || !this.blockingClient) return;
-		const prefixedQueues = queues.map((q) => this.messageKey(q));
-		const result = await this.blockingClient.BRPOP(prefixedQueues, timeoutSeconds);
-		if (result == null) return void 0;
-		const key = result.key.toString();
-		const prefixLength = this.env.REDIS_QUEUE_PREFIX.length + 1;
-		return {
-			queue: key.substring(prefixLength),
-			message: result.element.toString()
-		};
-	}
-	async generateJobId() {
-		return `job_${await this.redisProvider.publisher.INCR(`${this.env.REDIS_QUEUE_PREFIX}:job_counter`)}_${Date.now()}`;
-	}
-	serializeJob(job) {
-		return {
-			id: job.id,
-			queue: job.queue,
-			payload: JSON.stringify(job.payload),
-			options: JSON.stringify(job.options),
-			state: JSON.stringify(job.state)
-		};
-	}
-	deserializeJob(data) {
-		if (!data.id) return void 0;
-		return {
-			id: data.id,
-			queue: data.queue,
-			payload: JSON.parse(data.payload),
-			options: JSON.parse(data.options),
-			state: JSON.parse(data.state)
-		};
-	}
-	async addJob(queue, payload, options) {
-		const redis = this.redisProvider.publisher;
-		const now = Date.now();
-		const delay = options?.delay ?? 0;
-		const isDelayed = delay > 0;
-		const job = {
-			id: await 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
-			}
-		};
-		await redis.HSET(this.key("job", queue, job.id), this.serializeJob(job));
-		if (isDelayed) await redis.ZADD(this.key("delayed", queue), {
-			score: job.state.availableAt,
-			value: job.id
-		});
-		else {
-			await redis.ZADD(this.key("waiting", queue), {
-				score: job.options.priority ?? 0,
-				value: job.id
-			});
-			await redis.LPUSH(this.notifyKey(queue), job.id);
-		}
-		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;
-	}
-	async acquireJob(queues, workerId, timeoutSeconds) {
-		if (!this.blockingClient || this.shouldStop) return;
-		const redis = this.redisProvider.publisher;
-		const endTime = Date.now() + timeoutSeconds * 1e3;
-		while (Date.now() < endTime && !this.shouldStop) {
-			for (const queue of queues) try {
-				const result = await redis.evalSha(this.acquireJobSha, {
-					keys: [
-						this.key("waiting", queue),
-						this.key("active", queue),
-						this.key("job", queue)
-					],
-					arguments: [
-						workerId,
-						String(Date.now()),
-						String(DEFAULT_LOCK_DURATION)
-					]
-				});
-				if (result) {
-					const job = JSON.parse(result);
-					this.log.debug(`Worker ${workerId} acquired job ${job.id}`, {
-						queue,
-						attempt: job.state.attempts
-					});
-					await this.emit({
-						type: "active",
-						queue,
-						jobId: job.id,
-						timestamp: Date.now(),
-						workerId,
-						attempt: job.state.attempts
-					});
-					return {
-						queue,
-						job
-					};
-				}
-			} catch (error) {
-				this.log.warn(`Failed to acquire job from ${queue}`, error);
-			}
-			const notifyKeys = queues.map((q) => this.notifyKey(q));
-			const remainingTimeout = Math.max(1, Math.ceil((endTime - Date.now()) / 1e3));
-			try {
-				if (await this.blockingClient.BRPOP(notifyKeys, Math.min(remainingTimeout, 5))) {}
-			} catch {
-				if (this.shouldStop) return;
-			}
-		}
-	}
-	bufferRecordToString(record) {
-		const result = {};
-		for (const [key, value] of Object.entries(record)) result[key] = value?.toString() ?? "";
-		return result;
-	}
-	async completeJob(queue, jobId, result) {
-		const redis = this.redisProvider.publisher;
-		const now = Date.now();
-		try {
-			const luaResult = await redis.evalSha(this.completeJobSha, {
-				keys: [
-					this.key("job", queue, jobId),
-					this.key("active", queue),
-					this.key("completed", queue)
-				],
-				arguments: [
-					jobId,
-					String(now),
-					result !== void 0 ? JSON.stringify(result) : ""
-				]
-			});
-			if (!luaResult) {
-				this.log.warn(`Attempted to complete unknown job ${jobId}`);
-				return;
-			}
-			const { removed, duration } = JSON.parse(luaResult);
-			this.log.debug(`Job ${jobId} completed${removed ? " and removed" : ""}`, {
-				queue,
-				result
-			});
-			await this.emit({
-				type: "completed",
-				queue,
-				jobId,
-				timestamp: now,
-				result,
-				duration
-			});
-		} catch (error) {
-			this.log.warn(`Lua completeJob failed, using fallback`, error);
-			await this.completeJobFallback(queue, jobId, result);
-		}
-	}
-	async completeJobFallback(queue, jobId, result) {
-		const redis = this.redisProvider.publisher;
-		const now = Date.now();
-		const jobData = await redis.HGETALL(this.key("job", queue, jobId));
-		const job = this.deserializeJob(this.bufferRecordToString(jobData));
-		if (!job) {
-			this.log.warn(`Attempted to complete unknown job ${jobId}`);
-			return;
-		}
-		const duration = now - (job.state.processedAt ?? now);
-		await redis.SREM(this.key("active", queue), 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) await redis.DEL(this.key("job", queue, jobId));
-		else {
-			await redis.HSET(this.key("job", queue, jobId), { state: JSON.stringify(job.state) });
-			await redis.LPUSH(this.key("completed", queue), jobId);
-			if (typeof removeOnComplete === "number" && removeOnComplete >= 0) await this.cleanJobs(queue, "completed", { maxCount: removeOnComplete });
-		}
-		this.log.debug(`Job ${jobId} completed`, { queue });
-		await this.emit({
-			type: "completed",
-			queue,
-			jobId,
-			timestamp: now,
-			result,
-			duration
-		});
-	}
-	async failJob(queue, jobId, error, stackTrace) {
-		const redis = this.redisProvider.publisher;
-		const now = Date.now();
-		const jobData = await redis.HGETALL(this.key("job", queue, jobId));
-		const job = this.deserializeJob(this.bufferRecordToString(jobData));
-		if (!job) {
-			this.log.warn(`Attempted to fail unknown job ${jobId}`);
-			return;
-		}
-		const backoffDelay = this.calculateBackoff(job);
-		try {
-			const luaResult = await redis.evalSha(this.failJobSha, {
-				keys: [
-					this.key("job", queue, jobId),
-					this.key("active", queue),
-					this.key("delayed", queue),
-					this.key("failed", queue)
-				],
-				arguments: [
-					jobId,
-					String(now),
-					error,
-					stackTrace ?? "",
-					String(backoffDelay)
-				]
-			});
-			if (!luaResult) {
-				this.log.warn(`Attempted to fail unknown job ${jobId}`);
-				return;
-			}
-			const result = JSON.parse(luaResult);
-			if (result.status === "retrying") {
-				this.log.debug(`Job ${jobId} failed, will retry in ${result.delay}ms`, {
-					queue,
-					attempt: job.state.attempts,
-					error
-				});
-				await this.emit({
-					type: "retrying",
-					queue,
-					jobId,
-					timestamp: now,
-					error,
-					attempt: result.attempt,
-					delay: result.delay
-				});
-			} else {
-				this.log.debug(`Job ${jobId} permanently failed${result.removed ? " and removed" : ""}`, {
-					queue,
-					error
-				});
-				await this.emit({
-					type: "failed",
-					queue,
-					jobId,
-					timestamp: now,
-					error,
-					stackTrace,
-					attempts: result.attempts
-				});
-			}
-		} catch (luaError) {
-			this.log.warn(`Lua failJob failed, using fallback`, luaError);
-			await this.failJobFallback(queue, jobId, error, stackTrace);
-		}
-	}
-	async failJobFallback(queue, jobId, error, stackTrace) {
-		const redis = this.redisProvider.publisher;
-		const now = Date.now();
-		const jobData = await redis.HGETALL(this.key("job", queue, jobId));
-		const job = this.deserializeJob(this.bufferRecordToString(jobData));
-		if (!job) {
-			this.log.warn(`Attempted to fail unknown job ${jobId}`);
-			return;
-		}
-		await redis.SREM(this.key("active", queue), 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;
-			await redis.HSET(this.key("job", queue, jobId), { state: JSON.stringify(job.state) });
-			await redis.ZADD(this.key("delayed", queue), {
-				score: job.state.availableAt,
-				value: jobId
-			});
-			this.log.debug(`Job ${jobId} failed, will retry in ${backoffDelay}ms`, {
-				queue,
-				attempt: job.state.attempts,
-				maxAttempts
-			});
-			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) await redis.DEL(this.key("job", queue, jobId));
-			else {
-				await redis.HSET(this.key("job", queue, jobId), { state: JSON.stringify(job.state) });
-				await redis.LPUSH(this.key("failed", queue), jobId);
-				if (typeof removeOnFail === "number" && removeOnFail >= 0) await this.cleanJobs(queue, "failed", { maxCount: removeOnFail });
-			}
-			this.log.debug(`Job ${jobId} permanently failed`, { queue });
-			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 redis = this.redisProvider.publisher;
-		const jobData = await redis.HGETALL(this.key("job", queue, jobId));
-		const job = this.deserializeJob(this.bufferRecordToString(jobData));
-		if (!job || job.state.lockedBy !== workerId) return false;
-		job.state.lockedUntil = Date.now() + (job.options.lockDuration ?? DEFAULT_LOCK_DURATION);
-		await redis.HSET(this.key("job", queue, jobId), { state: JSON.stringify(job.state) });
-		return true;
-	}
-	async getJob(queue, jobId) {
-		const jobData = await this.redisProvider.publisher.HGETALL(this.key("job", queue, jobId));
-		return this.deserializeJob(this.bufferRecordToString(jobData));
-	}
-	async getJobs(queue, status, options) {
-		const redis = this.redisProvider.publisher;
-		const limit = options?.limit ?? 100;
-		const offset = options?.offset ?? 0;
-		let jobIds;
-		switch (status) {
-			case "waiting":
-				jobIds = (await redis.ZRANGE(this.key("waiting", queue), offset, offset + limit - 1)).map((r) => r.toString());
-				break;
-			case "delayed":
-				jobIds = (await redis.ZRANGE(this.key("delayed", queue), offset, offset + limit - 1)).map((r) => r.toString());
-				break;
-			case "active":
-				jobIds = (await redis.SMEMBERS(this.key("active", queue))).map((r) => r.toString()).slice(offset, offset + limit);
-				break;
-			case "completed":
-				jobIds = (await redis.LRANGE(this.key("completed", queue), offset, offset + limit - 1)).map((r) => r.toString());
-				break;
-			case "failed":
-				jobIds = (await redis.LRANGE(this.key("failed", queue), offset, offset + limit - 1)).map((r) => r.toString());
-				break;
-			default: jobIds = [];
-		}
-		const jobs = [];
-		for (const jobId of jobIds) {
-			const job = await this.getJob(queue, jobId);
-			if (job) jobs.push(job);
-		}
-		return jobs;
-	}
-	async getJobCounts(queue) {
-		const redis = this.redisProvider.publisher;
-		const [waiting, delayed, active, completed, failed] = await Promise.all([
-			redis.ZCARD(this.key("waiting", queue)),
-			redis.ZCARD(this.key("delayed", queue)),
-			redis.SCARD(this.key("active", queue)),
-			redis.LLEN(this.key("completed", queue)),
-			redis.LLEN(this.key("failed", queue))
-		]);
-		return {
-			waiting,
-			delayed,
-			active,
-			completed,
-			failed
-		};
-	}
-	async promoteDelayedJobs(queue) {
-		const redis = this.redisProvider.publisher;
-		const now = Date.now();
-		const results = await redis.ZRANGEBYSCORE(this.key("delayed", queue), "-inf", now);
-		let promoted = 0;
-		for (const result of results) {
-			const jobId = result.toString();
-			if (await redis.ZREM(this.key("delayed", queue), jobId) === 0) continue;
-			const job = await this.getJob(queue, jobId);
-			if (!job) continue;
-			job.state.status = "waiting";
-			await redis.HSET(this.key("job", queue, jobId), { state: JSON.stringify(job.state) });
-			await redis.ZADD(this.key("waiting", queue), {
-				score: job.options.priority ?? 0,
-				value: jobId
-			});
-			await redis.LPUSH(this.notifyKey(queue), jobId);
-			promoted++;
-			this.log.debug(`Promoted delayed job ${jobId}`, { queue });
-			await this.emit({
-				type: "waiting",
-				queue,
-				jobId,
-				timestamp: now,
-				job
-			});
-		}
-		return promoted;
-	}
-	async recoverStalledJobs(queue, stalledThresholdMs) {
-		const redis = this.redisProvider.publisher;
-		const now = Date.now();
-		const activeJobIds = await redis.SMEMBERS(this.key("active", queue));
-		const stalledJobIds = [];
-		for (const result of activeJobIds) {
-			const jobId = result.toString();
-			const job = await this.getJob(queue, jobId);
-			if (!job) continue;
-			if (!((job.state.lockedUntil ?? 0) + stalledThresholdMs < now)) continue;
-			stalledJobIds.push(jobId);
-			const workerId = job.state.lockedBy;
-			await redis.SREM(this.key("active", queue), 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)";
-				await redis.HSET(this.key("job", queue, jobId), { state: JSON.stringify(job.state) });
-				await redis.ZADD(this.key("waiting", queue), {
-					score: job.options.priority ?? 0,
-					value: jobId
-				});
-				await redis.LPUSH(this.notifyKey(queue), jobId);
-				this.log.warn(`Recovered stalled job ${jobId}`, { queue });
-				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) await redis.DEL(this.key("job", queue, jobId));
-				else {
-					await redis.HSET(this.key("job", queue, jobId), { state: JSON.stringify(job.state) });
-					await redis.LPUSH(this.key("failed", queue), jobId);
-					if (typeof removeOnFail === "number" && removeOnFail >= 0) await this.cleanJobs(queue, "failed", { maxCount: removeOnFail });
-				}
-				this.log.warn(`Stalled job ${jobId} permanently failed`, { queue });
-				await this.emit({
-					type: "failed",
-					queue,
-					jobId,
-					timestamp: now,
-					error: job.state.error,
-					attempts: job.state.attempts
-				});
-			}
-		}
-		return stalledJobIds;
-	}
-	async cleanJobs(queue, status, options) {
-		const redis = this.redisProvider.publisher;
-		const listKey = this.key(status, queue);
-		const maxAge = options?.maxAge;
-		const maxCount = options?.maxCount;
-		let removed = 0;
-		if (maxAge !== void 0) {
-			const cutoff = Date.now() - maxAge;
-			const jobIds = await redis.LRANGE(listKey, 0, -1);
-			for (const result of jobIds) {
-				const jobId = result.toString();
-				const job = await this.getJob(queue, jobId);
-				if (!job) continue;
-				const timestamp = status === "completed" ? job.state.completedAt : job.state.failedAt;
-				if (timestamp && timestamp < cutoff) {
-					await redis.LREM(listKey, 1, jobId);
-					await redis.DEL(this.key("job", queue, jobId));
-					removed++;
-				}
-			}
-		}
-		if (maxCount !== void 0) {
-			if (await redis.LLEN(listKey) > maxCount) {
-				const toRemove = await redis.LRANGE(listKey, maxCount, -1);
-				for (const result of toRemove) {
-					const jobId = result.toString();
-					await redis.DEL(this.key("job", queue, jobId));
-					removed++;
-				}
-				await redis.LTRIM(listKey, 0, maxCount - 1);
-			}
-		}
-		return removed;
-	}
-	async removeJob(queue, jobId) {
-		const redis = this.redisProvider.publisher;
-		const job = await this.getJob(queue, jobId);
-		if (!job) return;
-		const previousStatus = job.state.status;
-		switch (job.state.status) {
-			case "waiting":
-				await redis.ZREM(this.key("waiting", queue), jobId);
-				break;
-			case "delayed":
-				await redis.ZREM(this.key("delayed", queue), jobId);
-				break;
-			case "active":
-				await redis.SREM(this.key("active", queue), jobId);
-				break;
-			case "completed":
-				await redis.LREM(this.key("completed", queue), 1, jobId);
-				break;
-			case "failed":
-				await redis.LREM(this.key("failed", queue), 1, jobId);
-				break;
-		}
-		await redis.DEL(this.key("job", queue, jobId));
-		await this.emit({
-			type: "removed",
-			queue,
-			jobId,
-			timestamp: Date.now(),
-			previousStatus
-		});
-	}
-	cancelWaiters() {
-		this.shouldStop = true;
-	}
-};
-
-//#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