pg-boss 12.3.1 → 12.4.0

package/dist/index.d.mts

@@ -108,11 +108,11 @@ interface JobFetchOptions {
 }
 type WorkOptions = JobFetchOptions & JobPollingOptions;
 type FetchOptions = JobFetchOptions & ConnectionOptions;
-interface WorkHandler<ReqData> {
-  (job: Job<ReqData>[]): Promise<any>;
+interface WorkHandler<ReqData, ResData = any> {
+  (job: Job<ReqData>[]): Promise<ResData>;
 }
-interface WorkWithMetadataHandler<ReqData> {
-  (job: JobWithMetadata<ReqData>[]): Promise<any>;
+interface WorkWithMetadataHandler<ReqData, ResData = any> {
+  (job: JobWithMetadata<ReqData>[]): Promise<ResData>;
 }
 interface Request {
   name: string;
@@ -132,6 +132,7 @@ interface Job<T = object> {
   name: string;
   data: T;
   expireInSeconds: number;
+  signal: AbortSignal;
 }
 interface JobWithMetadata<T = object> extends Job<T> {
   priority: number;
@@ -246,11 +247,11 @@ declare class PgBoss extends EventEmitter<PgBossEventMap> {
     includeMetadata: true;
   }): Promise<JobWithMetadata<T>[]>;
   fetch<T>(name: string, options?: FetchOptions): Promise<Job<T>[]>;
-  work<ReqData>(name: string, handler: WorkHandler<ReqData>): Promise<string>;
-  work<ReqData>(name: string, options: WorkOptions & {
+  work<ReqData, ResData = any>(name: string, handler: WorkHandler<ReqData, ResData>): Promise<string>;
+  work<ReqData, ResData = any>(name: string, options: WorkOptions & {
     includeMetadata: true;
-  }, handler: WorkWithMetadataHandler<ReqData>): Promise<string>;
-  work<ReqData>(name: string, options: WorkOptions, handler: WorkHandler<ReqData>): Promise<string>;
+  }, handler: WorkWithMetadataHandler<ReqData, ResData>): Promise<string>;
+  work<ReqData, ResData = any>(name: string, options: WorkOptions, handler: WorkHandler<ReqData, ResData>): Promise<string>;
   offWork(name: string, options?: OffWorkOptions): Promise<void>;
   notifyWorker(workerId: string): void;
   subscribe(event: string, name: string): Promise<void>;

package/dist/index.mjs

@@ -938,7 +938,6 @@ function checkWorkArgs(name, args) {
 	assert(!("batchSize" in options) || Number.isInteger(options.batchSize) && options.batchSize >= 1, "batchSize must be an integer > 0");
 	assert(!("includeMetadata" in options) || typeof options.includeMetadata === "boolean", "includeMetadata must be a boolean");
 	assert(!("priority" in options) || typeof options.priority === "boolean", "priority must be a boolean");
-	options.batchSize = options.batchSize || 1;
 	return {
 		options,
 		callback
@@ -950,7 +949,6 @@ function checkFetchArgs(name, options) {
 	assert(!("includeMetadata" in options) || typeof options.includeMetadata === "boolean", "includeMetadata must be a boolean");
 	assert(!("priority" in options) || typeof options.priority === "boolean", "priority must be a boolean");
 	assert(!("ignoreStartAfter" in options) || typeof options.ignoreStartAfter === "boolean", "ignoreStartAfter must be a boolean");
-	options.batchSize = options.batchSize || 1;
 }
 function getConfig(value) {
 	assert(value && (typeof value === "object" || typeof value === "string"), "configuration assert: string or config object is required to connect to postgres");
@@ -1507,8 +1505,8 @@ function unwrapSQLResult(result) {
 	if (Array.isArray(result)) return { rows: result.flatMap((i) => i.rows) };
 	return result;
 }
-function delay(ms, error) {
-	const ac = new AbortController();
+function delay(ms, error, abortController) {
+	const ac = abortController || new AbortController();
 	const promise = new Promise((resolve, reject) => {
 		setTimeout(ms, null, { signal: ac.signal }).then(() => {
 			if (error) reject(new Error(error));
@@ -1520,8 +1518,8 @@ function delay(ms, error) {
 	};
 	return promise;
 }
-async function resolveWithinSeconds(promise, seconds, message) {
-	const reject = delay(Math.max(1, seconds) * 1e3, message);
+async function resolveWithinSeconds(promise, seconds, message, abortController) {
+	const reject = delay(Math.max(1, seconds) * 1e3, message, abortController);
 	let result;
 	try {
 		result = await Promise.race([promise, reject]);
@@ -1702,36 +1700,8 @@ var Manager = class extends EventEmitter {
 	}
 	async work(name, ...args) {
 		const { options, callback } = checkWorkArgs(name, args);
-		return await this.watch(name, options, callback);
-	}
-	addWorker(worker) {
-		this.workers.set(worker.id, worker);
-	}
-	removeWorker(worker) {
-		this.workers.delete(worker.id);
-	}
-	getWorkers() {
-		return Array.from(this.workers.values());
-	}
-	emitWip(name) {
-		if (!INTERNAL_QUEUES[name]) {
-			const now = Date.now();
-			if (now - this.wipTs > 2e3) {
-				this.emit(events$2.wip, this.getWipData());
-				this.wipTs = now;
-			}
-		}
-	}
-	getWipData(options = {}) {
-		const { includeInternal = false } = options;
-		return this.getWorkers().map((i) => i.toWipData()).filter((i) => i.state !== "stopped" && (!INTERNAL_QUEUES[i.name] || includeInternal));
-	}
-	hasPendingCleanups() {
-		return this.pendingOffWorkCleanups.size > 0;
-	}
-	async watch(name, options, callback) {
 		if (this.stopped) throw new Error("Workers are disabled. pg-boss is stopped");
-		const { pollingInterval: interval, batchSize, includeMetadata = false, priority = true } = options;
+		const { pollingInterval: interval, batchSize = 1, includeMetadata = false, priority = true } = options;
 		const id = randomUUID({ disableEntropyCache: true });
 		const fetch = () => this.fetch(name, {
 			batchSize,
@@ -1744,8 +1714,12 @@ var Manager = class extends EventEmitter {
 			this.emitWip(name);
 			const maxExpiration = jobs.reduce((acc, i) => Math.max(acc, i.expireInSeconds), 0);
 			const jobIds = jobs.map((job) => job.id);
+			const ac = new AbortController();
+			jobs.forEach((job) => {
+				job.signal = ac.signal;
+			});
 			try {
-				const result = await resolveWithinSeconds(callback(jobs), maxExpiration, `handler execution exceeded ${maxExpiration}s`);
+				const result = await resolveWithinSeconds(callback(jobs), maxExpiration, `handler execution exceeded ${maxExpiration}s`, ac);
 				await this.complete(name, jobIds, jobIds.length === 1 ? result : void 0);
 			} catch (err) {
 				await this.fail(name, jobIds, err);
@@ -1774,6 +1748,31 @@ var Manager = class extends EventEmitter {
 		worker.start();
 		return id;
 	}
+	addWorker(worker) {
+		this.workers.set(worker.id, worker);
+	}
+	removeWorker(worker) {
+		this.workers.delete(worker.id);
+	}
+	getWorkers() {
+		return Array.from(this.workers.values());
+	}
+	emitWip(name) {
+		if (!INTERNAL_QUEUES[name]) {
+			const now = Date.now();
+			if (now - this.wipTs > 2e3) {
+				this.emit(events$2.wip, this.getWipData());
+				this.wipTs = now;
+			}
+		}
+	}
+	getWipData(options = {}) {
+		const { includeInternal = false } = options;
+		return this.getWorkers().map((i) => i.toWipData()).filter((i) => i.state !== "stopped" && (!INTERNAL_QUEUES[i.name] || includeInternal));
+	}
+	hasPendingCleanups() {
+		return this.pendingOffWorkCleanups.size > 0;
+	}
 	async offWork(name, options = { wait: true }) {
 		assert(name, "queue name is required");
 		assert(typeof name === "string", "queue name must be a string");
@@ -1918,7 +1917,7 @@ var Manager = class extends EventEmitter {
 			table,
 			name,
 			policy,
-			limit: options.batchSize,
+			limit: options.batchSize || 1,
 			ignoreSingletons: singletonsActive
 		};
 		const sql = fetchNextJob(fetchOptions);
@@ -2011,15 +2010,18 @@ var Manager = class extends EventEmitter {
 	async createQueue(name, options = {}) {
 		name = name || options.name;
 		assertQueueName(name);
-		options.policy = options.policy || QUEUE_POLICIES.standard;
-		assert(options.policy in QUEUE_POLICIES, `${options.policy} is not a valid queue policy`);
+		const policy = options.policy || QUEUE_POLICIES.standard;
+		assert(policy in QUEUE_POLICIES, `${policy} is not a valid queue policy`);
 		validateQueueArgs(options);
 		if (options.deadLetter) {
 			assertQueueName(options.deadLetter);
 			notStrictEqual(name, options.deadLetter, "deadLetter cannot be itself");
 			await this.getQueueCache(options.deadLetter);
 		}
-		const sql = createQueue(this.config.schema, name, options);
+		const sql = createQueue(this.config.schema, name, {
+			...options,
+			policy
+		});
 		await this.db.executeSql(sql);
 	}
 	async getQueues(names) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pg-boss",
-  "version": "12.3.1",
+  "version": "12.4.0",
   "description": "Queueing jobs in Postgres from Node.js like a boss",
   "type": "module",
   "main": "./dist/index.mjs",