pg-boss 12.3.0 → 12.4.0

package/dist/src/timekeeper.mjs

@@ -1,160 +0,0 @@
-import { getSchedules, getSchedulesByQueue, getTime, schedule, trySetCronTime, unschedule } from "./plans.mjs";
-import { assertKey, checkSendArgs } from "./attorney.mjs";
-import EventEmitter from "node:events";
-import { CronExpressionParser } from "cron-parser";
-
-//#region src/timekeeper.ts
-const QUEUES = { SEND_IT: "__pgboss__send-it" };
-const EVENTS = {
-	error: "error",
-	schedule: "schedule",
-	warning: "warning"
-};
-const WARNINGS = { CLOCK_SKEW: { message: "Warning: Clock skew between this instance and the database server. This will not break scheduling, but is emitted any time the skew exceeds 60 seconds." } };
-var Timekeeper = class extends EventEmitter {
-	db;
-	config;
-	manager;
-	stopped = true;
-	cronMonitorInterval;
-	skewMonitorInterval;
-	timekeeping;
-	clockSkew = 0;
-	events = EVENTS;
-	constructor(db, manager, config) {
-		super();
-		this.db = db;
-		this.config = config;
-		this.manager = manager;
-	}
-	async start() {
-		this.stopped = false;
-		await this.cacheClockSkew();
-		await this.manager.createQueue(QUEUES.SEND_IT);
-		const options = {
-			pollingIntervalSeconds: this.config.cronWorkerIntervalSeconds,
-			batchSize: 50
-		};
-		await this.manager.work(QUEUES.SEND_IT, options, (jobs) => this.onSendIt(jobs));
-		setImmediate(() => this.onCron());
-		this.cronMonitorInterval = setInterval(async () => await this.onCron(), this.config.cronMonitorIntervalSeconds * 1e3);
-		this.skewMonitorInterval = setInterval(async () => await this.cacheClockSkew(), this.config.clockMonitorIntervalSeconds * 1e3);
-	}
-	async stop() {
-		if (this.stopped) return;
-		this.stopped = true;
-		await this.manager.offWork(QUEUES.SEND_IT, { wait: true });
-		if (this.skewMonitorInterval) {
-			clearInterval(this.skewMonitorInterval);
-			this.skewMonitorInterval = null;
-		}
-		if (this.cronMonitorInterval) {
-			clearInterval(this.cronMonitorInterval);
-			this.cronMonitorInterval = null;
-		}
-	}
-	async cacheClockSkew() {
-		let skew = 0;
-		try {
-			if (this.config.__test__force_clock_monitoring_error) throw new Error(this.config.__test__force_clock_monitoring_error);
-			const { rows } = await this.db.executeSql(getTime());
-			const local = Date.now();
-			skew = parseFloat(rows[0].time) - local;
-			const skewSeconds = Math.abs(skew) / 1e3;
-			if (skewSeconds >= 60 || this.config.__test__force_clock_skew_warning) this.emit(this.events.warning, {
-				message: WARNINGS.CLOCK_SKEW.message,
-				data: {
-					seconds: skewSeconds,
-					direction: skew > 0 ? "slower" : "faster"
-				}
-			});
-		} catch (err) {
-			this.emit(this.events.error, err);
-		} finally {
-			this.clockSkew = skew;
-		}
-	}
-	async onCron() {
-		try {
-			if (this.stopped || this.timekeeping) return;
-			if (this.config.__test__force_cron_monitoring_error) throw new Error(this.config.__test__force_cron_monitoring_error);
-			this.timekeeping = true;
-			const sql = trySetCronTime(this.config.schema, this.config.cronMonitorIntervalSeconds);
-			if (!this.stopped) {
-				const { rows } = await this.db.executeSql(sql);
-				if (!this.stopped && rows.length === 1) await this.cron();
-			}
-		} catch (err) {
-			this.emit(this.events.error, err);
-		} finally {
-			this.timekeeping = false;
-		}
-	}
-	async cron() {
-		const scheduled = (await this.getSchedules()).filter((i) => this.shouldSendIt(i.cron, i.timezone)).map(({ name, key, data, options }) => ({
-			data: {
-				name,
-				data,
-				options
-			},
-			singletonKey: `${name}__${key}`,
-			singletonSeconds: 60
-		}));
-		if (scheduled.length > 0 && !this.stopped) await this.manager.insert(QUEUES.SEND_IT, scheduled);
-	}
-	shouldSendIt(cron, tz) {
-		const prevTime = CronExpressionParser.parse(cron, {
-			tz,
-			strict: false
-		}).prev();
-		return (Date.now() + this.clockSkew - prevTime.getTime()) / 1e3 < 60;
-	}
-	async onSendIt(jobs) {
-		await Promise.allSettled(jobs.map(({ data }) => this.manager.send(data)));
-	}
-	async getSchedules(name, key = "") {
-		let sql = getSchedules(this.config.schema);
-		let params = [];
-		if (name) {
-			sql = getSchedulesByQueue(this.config.schema);
-			params = [name, key];
-		}
-		const { rows } = await this.db.executeSql(sql, params);
-		return rows;
-	}
-	async schedule(name, cron, data, options = {}) {
-		const { tz = "UTC", key = "", ...rest } = options;
-		CronExpressionParser.parse(cron, {
-			tz,
-			strict: false
-		});
-		checkSendArgs([
-			name,
-			data,
-			{ ...rest }
-		]);
-		assertKey(key);
-		try {
-			const sql = schedule(this.config.schema);
-			await this.db.executeSql(sql, [
-				name,
-				key,
-				cron,
-				tz,
-				data,
-				options
-			]);
-		} catch (err) {
-			if (err.message.includes("foreign key")) err.message = `Queue ${name} not found`;
-			throw err;
-		}
-	}
-	async unschedule(name, key = "") {
-		const sql = unschedule(this.config.schema);
-		await this.db.executeSql(sql, [name, key]);
-	}
-};
-var timekeeper_default = Timekeeper;
-
-//#endregion
-export { QUEUES, timekeeper_default as default };

package/dist/src/tools.mjs

@@ -1,37 +0,0 @@
-import { setTimeout } from "node:timers/promises";
-
-//#region src/tools.ts
-/**
-* When sql contains multiple queries, result is an array of objects with rows property
-* This function unwraps the result into a single object with rows property
-*/
-function unwrapSQLResult(result) {
-	if (Array.isArray(result)) return { rows: result.flatMap((i) => i.rows) };
-	return result;
-}
-function delay(ms, error) {
-	const ac = new AbortController();
-	const promise = new Promise((resolve, reject) => {
-		setTimeout(ms, null, { signal: ac.signal }).then(() => {
-			if (error) reject(new Error(error));
-			else resolve();
-		}).catch(resolve);
-	});
-	promise.abort = () => {
-		if (!ac.signal.aborted) ac.abort();
-	};
-	return promise;
-}
-async function resolveWithinSeconds(promise, seconds, message) {
-	const reject = delay(Math.max(1, seconds) * 1e3, message);
-	let result;
-	try {
-		result = await Promise.race([promise, reject]);
-	} finally {
-		reject.abort();
-	}
-	return result;
-}
-
-//#endregion
-export { delay, resolveWithinSeconds, unwrapSQLResult };

package/dist/src/types.d.mts

@@ -1,207 +0,0 @@
-//#region src/types.d.ts
-type JobStates = {
-  created: 'created';
-  retry: 'retry';
-  active: 'active';
-  completed: 'completed';
-  cancelled: 'cancelled';
-  failed: 'failed';
-};
-type Events = {
-  error: 'error';
-  warning: 'warning';
-  wip: 'wip';
-  stopped: 'stopped';
-};
-interface IDatabase {
-  executeSql(text: string, values?: unknown[]): Promise<{
-    rows: any[];
-  }>;
-}
-interface DatabaseOptions {
-  application_name?: string;
-  database?: string;
-  user?: string;
-  password?: string | (() => string) | (() => Promise<string>);
-  host?: string;
-  port?: number;
-  schema?: string;
-  ssl?: any;
-  connectionString?: string;
-  max?: number;
-  db?: IDatabase;
-  connectionTimeoutMillis?: number;
-}
-interface SchedulingOptions {
-  schedule?: boolean;
-  clockMonitorIntervalSeconds?: number;
-  cronWorkerIntervalSeconds?: number;
-  cronMonitorIntervalSeconds?: number;
-}
-interface MaintenanceOptions {
-  supervise?: boolean;
-  migrate?: boolean;
-  createSchema?: boolean;
-  warningSlowQuerySeconds?: number;
-  warningQueueSize?: number;
-  superviseIntervalSeconds?: number;
-  maintenanceIntervalSeconds?: number;
-  queueCacheIntervalSeconds?: number;
-  monitorIntervalSeconds?: number;
-}
-interface ConstructorOptions extends DatabaseOptions, SchedulingOptions, MaintenanceOptions {}
-interface QueueOptions {
-  expireInSeconds?: number;
-  retentionSeconds?: number;
-  deleteAfterSeconds?: number;
-  retryLimit?: number;
-  retryDelay?: number;
-  retryBackoff?: boolean;
-  retryDelayMax?: number;
-}
-interface JobOptions {
-  id?: string;
-  priority?: number;
-  startAfter?: number | string | Date;
-  singletonKey?: string;
-  singletonSeconds?: number;
-  singletonNextSlot?: boolean;
-  keepUntil?: number | string | Date;
-}
-interface ConnectionOptions {
-  db?: IDatabase;
-}
-type InsertOptions = ConnectionOptions;
-type SendOptions = JobOptions & QueueOptions & ConnectionOptions;
-type QueuePolicy = 'standard' | 'short' | 'singleton' | 'stately' | 'exclusive';
-interface Queue extends QueueOptions {
-  name: string;
-  policy?: QueuePolicy;
-  partition?: boolean;
-  deadLetter?: string;
-  warningQueueSize?: number;
-}
-interface QueueResult extends Queue {
-  deferredCount: number;
-  queuedCount: number;
-  activeCount: number;
-  totalCount: number;
-  table: string;
-  createdOn: Date;
-  updatedOn: Date;
-  singletonsActive: string[] | null;
-}
-type ScheduleOptions = SendOptions & {
-  tz?: string;
-  key?: string;
-};
-interface JobPollingOptions {
-  pollingIntervalSeconds?: number;
-}
-interface JobFetchOptions {
-  includeMetadata?: boolean;
-  priority?: boolean;
-  batchSize?: number;
-  ignoreStartAfter?: boolean;
-}
-type WorkOptions = JobFetchOptions & JobPollingOptions;
-type FetchOptions = JobFetchOptions & ConnectionOptions;
-interface WorkHandler<ReqData> {
-  (job: Job<ReqData>[]): Promise<any>;
-}
-interface WorkWithMetadataHandler<ReqData> {
-  (job: JobWithMetadata<ReqData>[]): Promise<any>;
-}
-interface Request {
-  name: string;
-  data?: object;
-  options?: SendOptions;
-}
-interface Schedule {
-  name: string;
-  key: string;
-  cron: string;
-  timezone: string;
-  data?: object;
-  options?: SendOptions;
-}
-interface Job<T = object> {
-  id: string;
-  name: string;
-  data: T;
-  expireInSeconds: number;
-}
-interface JobWithMetadata<T = object> extends Job<T> {
-  priority: number;
-  state: 'created' | 'retry' | 'active' | 'completed' | 'cancelled' | 'failed';
-  retryLimit: number;
-  retryCount: number;
-  retryDelay: number;
-  retryBackoff: boolean;
-  retryDelayMax?: number;
-  startAfter: Date;
-  startedOn: Date;
-  singletonKey: string | null;
-  singletonOn: Date | null;
-  expireInSeconds: number;
-  deleteAfterSeconds: number;
-  createdOn: Date;
-  completedOn: Date | null;
-  keepUntil: Date;
-  policy: QueuePolicy;
-  deadLetter: string;
-  output: object;
-}
-interface JobInsert<T = object> {
-  id?: string;
-  data?: T;
-  priority?: number;
-  retryLimit?: number;
-  retryDelay?: number;
-  retryBackoff?: boolean;
-  retryDelayMax?: number;
-  startAfter?: number | string | Date;
-  singletonKey?: string;
-  singletonSeconds?: number;
-  expireInSeconds?: number;
-  deleteAfterSeconds?: number;
-  retentionSeconds?: number;
-}
-type WorkerState = 'created' | 'active' | 'stopping' | 'stopped';
-interface WipData {
-  id: string;
-  name: string;
-  options: WorkOptions;
-  state: WorkerState;
-  count: number;
-  createdOn: number;
-  lastFetchedOn: number | null;
-  lastJobStartedOn: number | null;
-  lastJobEndedOn: number | null;
-  lastJobDuration: number | null;
-  lastError: object | null;
-  lastErrorOn: number | null;
-}
-interface StopOptions {
-  close?: boolean;
-  graceful?: boolean;
-  timeout?: number;
-}
-interface OffWorkOptions {
-  id?: string;
-  wait?: boolean;
-}
-type UpdateQueueOptions = Omit<Queue, 'name' | 'partition' | 'policy'>;
-interface Warning {
-  message: string;
-  data: object;
-}
-interface CommandResponse {}
-type PgBossEventMap = {
-  error: [error: Error];
-  warning: [warning: Warning];
-  wip: [data: WipData[]];
-  stopped: [];
-};
-//#endregion
-export { CommandResponse, ConnectionOptions, ConstructorOptions, Events, FetchOptions, IDatabase, InsertOptions, Job, JobFetchOptions, JobInsert, JobPollingOptions, JobStates, JobWithMetadata, MaintenanceOptions, OffWorkOptions, PgBossEventMap, Queue, QueuePolicy, QueueResult, Request, Schedule, ScheduleOptions, SchedulingOptions, SendOptions, StopOptions, UpdateQueueOptions, WipData, WorkHandler, WorkOptions, WorkWithMetadataHandler };

package/dist/src/worker.mjs

@@ -1,102 +0,0 @@
-import { delay } from "./tools.mjs";
-
-//#region src/worker.ts
-const WORKER_STATES = {
-	created: "created",
-	active: "active",
-	stopping: "stopping",
-	stopped: "stopped"
-};
-var Worker = class {
-	id;
-	name;
-	options;
-	fetch;
-	onFetch;
-	onError;
-	interval;
-	jobs = [];
-	createdOn = Date.now();
-	state = WORKER_STATES.created;
-	lastFetchedOn = null;
-	lastJobStartedOn = null;
-	lastJobEndedOn = null;
-	lastJobDuration = null;
-	lastError = null;
-	lastErrorOn = null;
-	stopping = false;
-	stopped = false;
-	loopDelayPromise = null;
-	beenNotified = false;
-	constructor({ id, name, options, interval, fetch, onFetch, onError }) {
-		this.id = id;
-		this.name = name;
-		this.options = options;
-		this.fetch = fetch;
-		this.onFetch = onFetch;
-		this.onError = onError;
-		this.interval = interval;
-	}
-	notify() {
-		this.beenNotified = true;
-		if (this.loopDelayPromise) this.loopDelayPromise.abort();
-	}
-	async start() {
-		this.state = WORKER_STATES.active;
-		while (!this.stopping) {
-			const started = Date.now();
-			try {
-				this.beenNotified = false;
-				const jobs = await this.fetch();
-				this.lastFetchedOn = Date.now();
-				if (jobs) {
-					this.jobs = jobs;
-					this.lastJobStartedOn = this.lastFetchedOn;
-					await this.onFetch(jobs);
-					this.lastJobEndedOn = Date.now();
-					this.jobs = [];
-				}
-			} catch (err) {
-				this.lastErrorOn = Date.now();
-				this.lastError = err;
-				err.message = `${err.message} (Queue: ${this.name}, Worker: ${this.id})`;
-				this.onError(err);
-			}
-			const duration = Date.now() - started;
-			this.lastJobDuration = duration;
-			if (!this.stopping && !this.beenNotified && this.interval - duration > 100) {
-				this.loopDelayPromise = delay(this.interval - duration);
-				await this.loopDelayPromise;
-				this.loopDelayPromise = null;
-			}
-		}
-		this.stopping = false;
-		this.stopped = true;
-		this.state = WORKER_STATES.stopped;
-	}
-	stop() {
-		this.stopping = true;
-		this.state = WORKER_STATES.stopping;
-		if (this.loopDelayPromise) this.loopDelayPromise.abort();
-	}
-	toWipData() {
-		return {
-			id: this.id,
-			name: this.name,
-			options: this.options,
-			state: this.state,
-			count: this.jobs.length,
-			createdOn: this.createdOn,
-			lastFetchedOn: this.lastFetchedOn,
-			lastJobStartedOn: this.lastJobStartedOn,
-			lastJobEndedOn: this.lastJobEndedOn,
-			lastError: this.lastError,
-			lastErrorOn: this.lastErrorOn,
-			lastJobDuration: this.lastJobDuration
-		};
-	}
-};
-var worker_default = Worker;
-
-//#endregion
-export { worker_default as default };