semola 0.5.4 → 0.6.1

package/dist/lib/queue/index.mjs

@@ -1,181 +1 @@
-import { err, mightThrow, mightThrowSync, ok } from "../errors/index.mjs";
-//#region src/lib/queue/index.ts
-const toMinimalJob = (jobState) => ({
-	id: jobState.id,
-	data: jobState.data,
-	attempts: jobState.attempts,
-	maxRetries: jobState.maxRetries,
-	createdAt: jobState.createdAt
-});
-const DEFAULT_RETRIES = 3;
-const DEFAULT_TIMEOUT = 3e4;
-const DEFAULT_CONCURRENCY = 1;
-const DEFAULT_POLL_INTERVAL = 100;
-const MAX_BACKOFF_DELAY = 6e4;
-const BASE_BACKOFF_DELAY = 1e3;
-const BACKOFF_MULTIPLIER = 2;
-const SHUTDOWN_POLL_INTERVAL = 10;
-var Queue = class {
-	options;
-	running = true;
-	activeWorkers = 0;
-	retries;
-	timeout;
-	concurrency;
-	pollInterval;
-	constructor(options) {
-		this.options = options;
-		this.retries = options.retries ?? DEFAULT_RETRIES;
-		this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
-		this.concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
-		this.pollInterval = options.pollInterval ?? DEFAULT_POLL_INTERVAL;
-		this.startWorkers();
-	}
-	async enqueue(data) {
-		const job = {
-			id: crypto.randomUUID(),
-			data,
-			attempts: 0,
-			maxRetries: this.retries,
-			createdAt: Date.now()
-		};
-		const [serializeError, serialized] = this.serializeJob(job);
-		if (serializeError || !serialized) return err("QueueError", "Unable to serialize job data");
-		const [enqueueError] = await this.enqueueJobData(serialized);
-		if (enqueueError) return err("QueueError", "Unable to enqueue job");
-		return ok(job.id);
-	}
-	async stop() {
-		this.running = false;
-		while (this.activeWorkers > 0) await new Promise((resolve) => setTimeout(resolve, SHUTDOWN_POLL_INTERVAL));
-	}
-	waitForPollInterval() {
-		return new Promise((resolve) => setTimeout(resolve, this.pollInterval));
-	}
-	serializeJob(job) {
-		return mightThrowSync(() => JSON.stringify(job));
-	}
-	async enqueueJobData(serialized) {
-		const queueKey = `queue:${this.options.name}:jobs`;
-		return mightThrow(this.options.redis.lpush(queueKey, serialized));
-	}
-	async moveToDeadLetterQueue(jobData, parseError) {
-		const deadLetterKey = `queue:${this.options.name}:dead-letter`;
-		const deadLetterEntry = JSON.stringify({
-			jobData,
-			parseError: this.formatErrorMessage(parseError),
-			timestamp: Date.now()
-		});
-		return mightThrow(this.options.redis.lpush(deadLetterKey, deadLetterEntry));
-	}
-	formatErrorMessage(error) {
-		return error instanceof Error ? error.message : String(error);
-	}
-	startWorkers() {
-		for (let i = 0; i < this.concurrency; i++) this.processJobs();
-	}
-	async processJobs() {
-		while (this.running) {
-			const queueKey = `queue:${this.options.name}:jobs`;
-			const [popError, jobData] = await mightThrow(this.options.redis.rpop(queueKey));
-			if (popError) {
-				await this.waitForPollInterval();
-				continue;
-			}
-			if (!jobData) {
-				await this.waitForPollInterval();
-				continue;
-			}
-			const [parseError, job] = mightThrowSync(() => JSON.parse(jobData));
-			if (parseError || !job) {
-				await this.callOnErrorForParseFailure(jobData, parseError);
-				await this.moveToDeadLetterQueue(jobData, parseError);
-				await this.waitForPollInterval();
-				continue;
-			}
-			if (!this.running) {
-				const [stringifyError, serialized] = this.serializeJob(job);
-				if (!stringifyError && serialized) await mightThrow(this.options.redis.lpush(queueKey, serialized));
-				break;
-			}
-			this.activeWorkers++;
-			await mightThrow(this.handleJob(job));
-			this.activeWorkers--;
-		}
-	}
-	async handleJob(job) {
-		const controller = new AbortController();
-		const handlerPromise = Promise.resolve().then(() => this.options.handler(job.data, controller.signal));
-		let timerId;
-		const timeoutPromise = new Promise((_, reject) => {
-			timerId = setTimeout(() => {
-				reject(/* @__PURE__ */ new Error(`Job timeout after ${this.timeout}ms`));
-			}, this.timeout);
-		});
-		const [handlerError] = await mightThrow(Promise.race([handlerPromise.then(() => void 0), timeoutPromise]));
-		if (timerId) clearTimeout(timerId);
-		if (handlerError && !controller.signal.aborted) controller.abort();
-		if (!handlerError) {
-			if (this.options.onSuccess) await mightThrow(Promise.resolve(this.options.onSuccess(toMinimalJob(job))));
-			return;
-		}
-		job.attempts++;
-		const errorMsg = this.formatErrorMessage(handlerError);
-		job.error = errorMsg;
-		if (!job.errorHistory) job.errorHistory = [];
-		job.errorHistory.push({
-			attempt: job.attempts,
-			error: errorMsg,
-			timestamp: Date.now()
-		});
-		if (job.attempts <= job.maxRetries) {
-			if (this.options.onRetry) {
-				const delay = Math.min(BASE_BACKOFF_DELAY * BACKOFF_MULTIPLIER ** (job.attempts - 1), MAX_BACKOFF_DELAY);
-				await mightThrow(Promise.resolve(this.options.onRetry({
-					job: toMinimalJob(job),
-					error: errorMsg,
-					nextRetryDelayMs: delay,
-					retriesRemaining: job.maxRetries - job.attempts,
-					backoffMultiplier: BACKOFF_MULTIPLIER
-				})));
-			}
-			await this.retryJob(job);
-		} else await this.callOnError(job);
-	}
-	async callOnError(job) {
-		if (!this.options.onError) return;
-		await mightThrow(Promise.resolve(this.options.onError({
-			job: toMinimalJob(job),
-			lastError: job.error ?? "",
-			totalDurationMs: Date.now() - job.createdAt,
-			totalAttempts: job.attempts,
-			errorHistory: job.errorHistory ?? []
-		})));
-	}
-	async callOnErrorForParseFailure(jobData, parseError) {
-		if (!this.options.onParseError) return;
-		await mightThrow(Promise.resolve(this.options.onParseError({
-			rawJobData: jobData,
-			parseError: this.formatErrorMessage(parseError),
-			timestamp: Date.now()
-		})));
-	}
-	async retryJob(job) {
-		const delay = Math.min(BASE_BACKOFF_DELAY * BACKOFF_MULTIPLIER ** (job.attempts - 1), MAX_BACKOFF_DELAY);
-		await new Promise((resolve) => setTimeout(resolve, delay));
-		const [stringifyError, serialized] = this.serializeJob(job);
-		if (stringifyError || !serialized) {
-			job.error = `Failed to serialize job for retry: ${this.formatErrorMessage(stringifyError)}`;
-			await this.callOnError(job);
-			return;
-		}
-		const queueKey = `queue:${this.options.name}:jobs`;
-		const [pushError] = await mightThrow(this.options.redis.lpush(queueKey, serialized));
-		if (pushError) {
-			job.error = `Failed to re-enqueue job for retry: ${this.formatErrorMessage(pushError)}`;
-			await this.callOnError(job);
-		}
-	}
-};
-//#endregion
-export { Queue };
+import{mightThrow as e,mightThrowSync as t}from"../errors/index.mjs";import n from"node:assert";var r=class extends Error{constructor(e){super(e),this.name=`SerializationError`}},i=class extends Error{constructor(e){super(e),this.name=`EnqueueError`}};const a=e=>({id:e.id,data:e.data,attempts:e.attempts,maxRetries:e.maxRetries,createdAt:e.createdAt});var o=class{options;running=!0;activeWorkers=0;retries;timeout;concurrency;pollInterval;retryBaseDelay;retryMultiplier;retryMaxDelay;constructor(e){this.options=e,this.retries=e.retries??3,this.timeout=e.timeout??3e4,this.concurrency=e.concurrency??1,this.pollInterval=e.pollInterval??100,this.retryBaseDelay=e.retryBackoff?.baseDelay??1e3,this.retryMultiplier=e.retryBackoff?.multiplier??2,this.retryMaxDelay=e.retryBackoff?.maxDelay??6e4,n.ok(Number.isFinite(this.retryBaseDelay)&&this.retryBaseDelay>0,`Invalid retryBackoff.baseDelay: must be a positive finite number`),n.ok(Number.isFinite(this.retryMultiplier)&&this.retryMultiplier>0,`Invalid retryBackoff.multiplier: must be a positive finite number`),n.ok(Number.isFinite(this.retryMaxDelay)&&this.retryMaxDelay>0,`Invalid retryBackoff.maxDelay: must be a positive finite number`),this.startWorkers()}computeBackoffDelay(e){return Math.min(this.retryBaseDelay*this.retryMultiplier**(e-1),this.retryMaxDelay)}async enqueue(e){let t={id:crypto.randomUUID(),data:e,attempts:0,maxRetries:this.retries,createdAt:Date.now()},[n,a]=this.serializeJob(t);if(n||!a)throw new r(`Unable to serialize job data`);let[o]=await this.enqueueJobData(a);if(o)throw new i(`Unable to enqueue job`);return t.id}async stop(){for(this.running=!1;this.activeWorkers>0;)await new Promise(e=>setTimeout(e,10))}waitForPollInterval(){return new Promise(e=>setTimeout(e,this.pollInterval))}serializeJob(e){return t(()=>JSON.stringify(e))}async enqueueJobData(t){let n=`queue:${this.options.name}:jobs`;return e(this.options.redis.lpush(n,t))}async moveToDeadLetterQueue(t,n){let r=`queue:${this.options.name}:dead-letter`,i=JSON.stringify({jobData:t,parseError:this.formatErrorMessage(n),timestamp:Date.now()});return e(this.options.redis.lpush(r,i))}formatErrorMessage(e){return e?e.message:`Unknown error`}startWorkers(){for(let e=0;e<this.concurrency;e++)this.processJobs()}async processJobs(){for(;this.running;){let n=`queue:${this.options.name}:jobs`,[r,i]=await e(this.options.redis.rpop(n));if(r){await this.waitForPollInterval();continue}if(!i){await this.waitForPollInterval();continue}let[a,o]=t(()=>JSON.parse(i));if(a||!o){await this.callOnErrorForParseFailure(i,a),await this.moveToDeadLetterQueue(i,a),await this.waitForPollInterval();continue}if(!this.running){let[t,r]=this.serializeJob(o);!t&&r&&await e(this.options.redis.lpush(n,r));break}this.activeWorkers++,await e(this.handleJob(o)),this.activeWorkers--}}async handleJob(t){let n=new AbortController,r=Promise.resolve().then(()=>this.options.handler(t.data,n.signal)),i,o=new Promise((e,t)=>{i=setTimeout(()=>{t(Error(`Job timeout after ${this.timeout}ms`))},this.timeout)}),[s]=await e(Promise.race([r.then(()=>void 0),o]));if(i&&clearTimeout(i),s&&!n.signal.aborted&&n.abort(),!s){this.options.onSuccess&&await e(Promise.resolve(this.options.onSuccess(a(t))));return}t.attempts++;let c=this.formatErrorMessage(s);if(t.error=c,t.errorHistory||=[],t.errorHistory.push({attempt:t.attempts,error:c,timestamp:Date.now()}),t.attempts<=t.maxRetries){if(this.options.onRetry){let n=this.computeBackoffDelay(t.attempts);await e(Promise.resolve(this.options.onRetry({job:a(t),error:c,nextRetryDelayMs:n,retriesRemaining:t.maxRetries-t.attempts,backoffMultiplier:this.retryMultiplier})))}await this.retryJob(t)}else await this.callOnError(t)}async callOnError(t){this.options.onError&&await e(Promise.resolve(this.options.onError({job:a(t),lastError:t.error??``,totalDurationMs:Date.now()-t.createdAt,totalAttempts:t.attempts,errorHistory:t.errorHistory??[]})))}async callOnErrorForParseFailure(t,n){this.options.onParseError&&await e(Promise.resolve(this.options.onParseError({rawJobData:t,parseError:this.formatErrorMessage(n),timestamp:Date.now()})))}async retryJob(t){let n=this.computeBackoffDelay(t.attempts);await new Promise(e=>setTimeout(e,n));let[r,i]=this.serializeJob(t);if(r||!i){t.error=`Failed to serialize job for retry: ${this.formatErrorMessage(r)}`,await this.callOnError(t);return}let a=`queue:${this.options.name}:jobs`,[o]=await e(this.options.redis.lpush(a,i));o&&(t.error=`Failed to re-enqueue job for retry: ${this.formatErrorMessage(o)}`,await this.callOnError(t))}};export{o as Queue};