pg-boss 7.4.0 → 8.1.0

package/README.md

@@ -50,7 +50,7 @@ This will likely cater the most to teams already familiar with the simplicity of
 * Automatic maintenance operations to manage table growth
 
 ## Requirements
-* Node 12 or higher
+* Node 14 or higher
 * PostgreSQL 9.5 or higher
 
 ## Installation

package/package.json

@@ -1,31 +1,34 @@
 {
   "name": "pg-boss",
-  "version": "7.4.0",
+  "version": "8.1.0",
   "description": "Queueing jobs in Node.js using PostgreSQL like a boss",
   "main": "./src/index.js",
   "engines": {
-    "node": ">=12.0.0"
+    "node": ">=14"
   },
   "dependencies": {
     "cron-parser": "^4.0.0",
     "delay": "^5.0.0",
     "lodash.debounce": "^4.0.8",
-    "p-map": "^4.0.0",
+    "p-map": "^5.3.0",
     "pg": "^8.5.1",
-    "uuid": "^8.3.2"
+    "serialize-error": "^11.0.0",
+    "uuid": "^9.0.0"
   },
   "devDependencies": {
-    "@types/node": "^17.0.2",
+    "@types/node": "^18.0.0",
     "coveralls": "^3.1.0",
-    "luxon": "^2.0.1",
-    "mocha": "^9.0.1",
+    "luxon": "^3.0.1",
+    "mocha": "^10.0.0",
     "nyc": "^15.1.0",
-    "standard": "^16.0.3"
+    "standard": "^17.0.0"
   },
   "scripts": {
     "test": "standard && mocha",
     "cover": "nyc --reporter=text npm test",
-    "forcover": "npm run cover && nyc report --reporter=text-lcov | coveralls",
+    "travis-cover": "nyc --reporter=text npm run travis-test",
+    "travis-test": "standard && mocha --jobs 0 --exit",
+    "forcover": "npm run travis-cover && nyc report --reporter=text-lcov | coveralls",
     "export-schema": "node ./scripts/construct.js",
     "export-migration": "node ./scripts/migrate.js",
     "export-rollback": "node ./scripts/rollback.js",

package/src/attorney.js

@@ -377,7 +377,7 @@ function applyMonitoringConfig (config) {
 
 function applyUuidConfig (config) {
   assert(!('uuid' in config) || config.uuid === 'v1' || config.uuid === 'v4', 'configuration assert: uuid option only supports v1 or v4')
-  config.uuid = config.uuid || 'v1'
+  config.uuid = config.uuid || 'v4'
 }
 
 function warnClockSkew (message) {

package/src/index.js

@@ -90,6 +90,8 @@ class PgBoss extends EventEmitter {
   }
 
   async start () {
+    const { serializeError } = await import('serialize-error')
+
     if (!this.stopped) {
       return this
     }
@@ -104,7 +106,7 @@ class PgBoss extends EventEmitter {
 
     this.started = true
 
-    this.manager.start()
+    this.manager.start({ stringify: serializeError })
 
     if (!this.config.noSupervisor) {
       await this.boss.supervise()

package/src/manager.js

@@ -1,6 +1,5 @@
 const assert = require('assert')
 const EventEmitter = require('events')
-const pMap = require('p-map')
 const delay = require('delay')
 const uuid = require('uuid')
 const debounce = require('lodash.debounce')
@@ -45,6 +44,8 @@ class Manager extends EventEmitter {
   constructor (db, config) {
     super()
 
+    this.stringify = null
+
     this.config = config
     this.db = db
 
@@ -97,7 +98,8 @@ class Manager extends EventEmitter {
     this.emitWipThrottled = debounce(() => this.emit(events.wip, this.getWipData()), WIP_EVENT_INTERVAL, WIP_DEBOUNCE_OPTIONS)
   }
 
-  start () {
+  start ({ stringify }) {
+    this.stringify = stringify
     this.stopping = false
   }
 
@@ -211,6 +213,8 @@ class Manager extends EventEmitter {
     const fetch = () => this.fetch(name, batchSize || (teamSize - queueSize), { includeMetadata })
 
     const onFetch = async (jobs) => {
+      const { default: pMap } = await import('p-map')
+
       if (this.config.__test__throw_worker) {
         throw new Error('__test__throw_worker')
       }
@@ -393,6 +397,7 @@ class Manager extends EventEmitter {
 
   async createJob (name, data, options, singletonOffset = 0) {
     const {
+      db: wrapper,
       expireIn,
       priority,
       startAfter,
@@ -423,8 +428,8 @@ class Manager extends EventEmitter {
       keepUntil, // 13
       onComplete // 14
     ]
-
-    const result = await this.db.executeSql(this.insertJobCommand, values)
+    const db = wrapper || this.db
+    const result = await db.executeSql(this.insertJobCommand, values)
 
     if (result && result.rowCount === 1) {
       return result.rows[0].id
@@ -445,10 +450,12 @@ class Manager extends EventEmitter {
     return await this.createJob(name, data, options, singletonOffset)
   }
 
-  async insert (jobs) {
+  async insert (jobs, options = {}) {
+    const { db: wrapper } = options
+    const db = wrapper || this.db
     const checkedJobs = Attorney.checkInsertArgs(jobs)
     const data = JSON.stringify(checkedJobs)
-    return await this.db.executeSql(this.insertJobsCommand, [data])
+    return await db.executeSql(this.insertJobsCommand, [data])
   }
 
   getDebounceStartAfter (singletonSeconds, clockOffset) {
@@ -470,8 +477,8 @@ class Manager extends EventEmitter {
 
   async fetch (name, batchSize, options = {}) {
     const values = Attorney.checkFetchArgs(name, batchSize, options)
-
-    const result = await this.db.executeSql(
+    const db = options.db || this.db
+    const result = await db.executeSql(
       this.nextJobCommand(options.includeMetadata || false),
       [values.name, batchSize || 1]
     )
@@ -513,15 +520,11 @@ class Manager extends EventEmitter {
   mapCompletionDataArg (data) {
     if (data === null || typeof data === 'undefined' || typeof data === 'function') { return null }
 
-    if (data instanceof Error) {
-      const newData = {}
-      Object.getOwnPropertyNames(data).forEach(key => { newData[key] = data[key] })
-      data = newData
-    }
-
-    return (typeof data === 'object' && !Array.isArray(data))
+    const result = (typeof data === 'object' && !Array.isArray(data))
       ? data
       : { value: data }
+
+    return this.stringify(result)
   }
 
   mapCompletionResponse (ids, result) {
@@ -532,27 +535,31 @@ class Manager extends EventEmitter {
     }
   }
 
-  async complete (id, data) {
+  async complete (id, data, options = {}) {
+    const db = options.db || this.db
     const ids = this.mapCompletionIdArg(id, 'complete')
-    const result = await this.db.executeSql(this.completeJobsCommand, [ids, this.mapCompletionDataArg(data)])
+    const result = await db.executeSql(this.completeJobsCommand, [ids, this.mapCompletionDataArg(data)])
     return this.mapCompletionResponse(ids, result)
   }
 
-  async fail (id, data) {
+  async fail (id, data, options = {}) {
+    const db = options.db || this.db
     const ids = this.mapCompletionIdArg(id, 'fail')
-    const result = await this.db.executeSql(this.failJobsCommand, [ids, this.mapCompletionDataArg(data)])
+    const result = await db.executeSql(this.failJobsCommand, [ids, this.mapCompletionDataArg(data)])
     return this.mapCompletionResponse(ids, result)
   }
 
-  async cancel (id) {
+  async cancel (id, options = {}) {
+    const db = options.db || this.db
     const ids = this.mapCompletionIdArg(id, 'cancel')
-    const result = await this.db.executeSql(this.cancelJobsCommand, [ids])
+    const result = await db.executeSql(this.cancelJobsCommand, [ids])
     return this.mapCompletionResponse(ids, result)
   }
 
-  async resume (id) {
+  async resume (id, options = {}) {
+    const db = options.db || this.db
     const ids = this.mapCompletionIdArg(id, 'resume')
-    const result = await this.db.executeSql(this.resumeJobsCommand, [ids])
+    const result = await db.executeSql(this.resumeJobsCommand, [ids])
     return this.mapCompletionResponse(ids, result)
   }
 
@@ -584,14 +591,15 @@ class Manager extends EventEmitter {
     return result ? parseFloat(result.rows[0].count) : null
   }
 
-  async getJobById (id) {
-    const result1 = await this.db.executeSql(this.getJobByIdCommand, [id])
+  async getJobById (id, options = {}) {
+    const db = options.db || this.db
+    const result1 = await db.executeSql(this.getJobByIdCommand, [id])
 
     if (result1 && result1.rows && result1.rows.length === 1) {
       return result1.rows[0]
     }
 
-    const result2 = await this.db.executeSql(this.getArchivedJobByIdCommand, [id])
+    const result2 = await db.executeSql(this.getArchivedJobByIdCommand, [id])
 
     if (result2 && result2.rows && result2.rows.length === 1) {
       return result2.rows[0]

package/src/plans.js

@@ -69,6 +69,7 @@ function locked (schema, query) {
 
   return `
     BEGIN;
+    SET LOCAL statement_timeout = '30s';
     ${advisoryLock(schema)};
     ${query};
     COMMIT;

package/src/timekeeper.js

@@ -1,4 +1,3 @@
-const pMap = require('p-map')
 const EventEmitter = require('events')
 const plans = require('./plans')
 const cronParser = require('cron-parser')
@@ -126,6 +125,8 @@ class Timekeeper extends EventEmitter {
   async onCron () {
     if (this.stopped) return
 
+    const { default: pMap } = await import('p-map')
+
     try {
       if (this.config.__test__throw_clock_monitoring) {
         throw new Error('clock monitoring error')

package/types.d.ts

@@ -91,7 +91,13 @@ declare namespace PgBoss {
     singletonNextSlot?: boolean;
   }
 
-  type SendOptions = JobOptions & ExpirationOptions & RetentionOptions & RetryOptions & CompletionOptions
+  interface ConnectionOptions {
+    db?: Db;
+  }
+
+  type InsertOptions = ConnectionOptions;
+
+  type SendOptions = JobOptions & ExpirationOptions & RetentionOptions & RetryOptions & CompletionOptions & ConnectionOptions;
 
   type ScheduleOptions = SendOptions & { tz?: string }
 
@@ -112,7 +118,7 @@ declare namespace PgBoss {
 
   type FetchOptions = {
     includeMetadata?: boolean;
-  }
+  } & ConnectionOptions;
 
   interface WorkHandler<ReqData, ResData> {
     (job: PgBoss.JobWithDoneCallback<ReqData, ResData>): Promise<ResData> | void;
@@ -190,7 +196,7 @@ declare namespace PgBoss {
     retryLimit?: number;
     retryDelay?: number;
     retryBackoff?: boolean;
-    startAfter?: Date | string;    
+    startAfter?: Date | string;
     singletonKey?: string;
     expireInSeconds?: number;
     keepUntil?: Date | string;
@@ -298,6 +304,7 @@ declare class PgBoss extends EventEmitter {
   sendDebounced(name: string, data: object, options: PgBoss.SendOptions, seconds: number, key: string): Promise<string | null>;
 
   insert(jobs: PgBoss.JobInsert[]): Promise<void>;
+  insert(jobs: PgBoss.JobInsert[], options: PgBoss.InsertOptions): Promise<void>;
 
   work<ReqData, ResData>(name: string, handler: PgBoss.WorkHandler<ReqData, ResData>): Promise<string>;
   work<ReqData, ResData>(name: string, options: PgBoss.WorkOptions & { includeMetadata: true }, handler: PgBoss.WorkWithMetadataHandler<ReqData, ResData>): Promise<string>;
@@ -311,7 +318,7 @@ declare class PgBoss extends EventEmitter {
 
   /**
    * Notify worker that something has changed
-   * @param workerId 
+   * @param workerId
    */
   notifyWorker(workerId: string): void;
 
@@ -334,22 +341,22 @@ declare class PgBoss extends EventEmitter {
   fetchCompleted<T>(name: string, batchSize: number, options: PgBoss.FetchOptions & { includeMetadata: true }): Promise<PgBoss.JobWithMetadata<T>[] | null>;
   fetchCompleted<T>(name: string, batchSize: number, options: PgBoss.FetchOptions): Promise<PgBoss.Job<T>[] | null>;
 
-  cancel(id: string): Promise<void>;
-  cancel(ids: string[]): Promise<void>;
+  cancel(id: string, options: PgBoss.ConnectionOptions): Promise<void>;
+  cancel(ids: string[], options: PgBoss.ConnectionOptions): Promise<void>;
 
-  resume(id: string): Promise<void>;
-  resume(ids: string[]): Promise<void>;
+  resume(id: string, options: PgBoss.ConnectionOptions): Promise<void>;
+  resume(ids: string[], options: PgBoss.ConnectionOptions): Promise<void>;
 
-  complete(id: string): Promise<void>;
-  complete(id: string, data: object): Promise<void>;
-  complete(ids: string[]): Promise<void>;
+  complete(id: string, options: PgBoss.ConnectionOptions): Promise<void>;
+  complete(id: string, data: object, options: PgBoss.ConnectionOptions): Promise<void>;
+  complete(ids: string[], options: PgBoss.ConnectionOptions): Promise<void>;
 
-  fail(id: string): Promise<void>;
-  fail(id: string, data: object): Promise<void>;
-  fail(ids: string[]): Promise<void>;
+  fail(id: string, options: PgBoss.ConnectionOptions): Promise<void>;
+  fail(id: string, data: object, options: PgBoss.ConnectionOptions): Promise<void>;
+  fail(ids: string[], options: PgBoss.ConnectionOptions): Promise<void>;
 
   getQueueSize(name: string, options?: object): Promise<number>;
-  getJobById(id: string): Promise<PgBoss.JobWithMetadata | null>;
+  getJobById(id: string, options: PgBoss.ConnectionOptions): Promise<PgBoss.JobWithMetadata | null>;
 
   deleteQueue(name: string): Promise<void>;
   deleteAllQueues(): Promise<void>;