pg-boss 11.0.4 → 11.0.6

package/package.json

@@ -1,25 +1,27 @@
 {
   "name": "pg-boss",
-  "version": "11.0.4",
+  "version": "11.0.6",
   "description": "Queueing jobs in Postgres from Node.js like a boss",
   "main": "./src/index.js",
+  "type": "commonjs",
   "engines": {
     "node": ">=22"
   },
   "dependencies": {
-    "cron-parser": "^4.9.0",
+    "cron-parser": "^5.4.0",
     "pg": "^8.16.3",
     "serialize-error": "^8.1.0"
   },
   "devDependencies": {
     "@types/node": "^22",
+    "eslint": "^9.36.0",
     "luxon": "^3.7.2",
-    "mocha": "^10.8.2",
-    "nyc": "^17.1.0",
-    "standard": "^17.1.2"
+    "mocha": "^11.7.4",
+    "neostandard": "^0.12.2",
+    "nyc": "^17.1.0"
   },
   "scripts": {
-    "test": "standard && mocha",
+    "test": "eslint . && mocha",
     "cover": "nyc npm test",
     "tsc": "tsc --noEmit types.d.ts",
     "readme": "node ./test/readme.js",
@@ -45,17 +47,6 @@
       "text"
     ]
   },
-  "standard": {
-    "globals": [
-      "describe",
-      "it",
-      "before",
-      "after",
-      "before",
-      "beforeEach",
-      "afterEach"
-    ]
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/timgit/pg-boss.git"

package/src/manager.js

@@ -648,13 +648,13 @@ class Manager extends EventEmitter {
   async getQueueStats (name) {
     Attorney.assertQueueName(name)
 
-    const { table } = await this.getQueueCache(name)
+    const queue = await this.getQueueCache(name)
 
-    const sql = plans.getQueueStats(this.config.schema, table, [name])
+    const sql = plans.getQueueStats(this.config.schema, queue.table, [name])
 
     const { rows } = await this.db.executeSql(sql)
 
-    return rows.at(0) || null
+    return Object.assign(queue, rows.at(0) || {})
   }
 
   async getJobById (name, id, options = {}) {
@@ -680,7 +680,9 @@ class Manager extends EventEmitter {
       return options.db
     }
 
-    assert(this.db._pgbdb && this.db.opened, 'Database connection is not opened')
+    if (this.db._pgbdb) {
+      assert(this.db.opened, 'Database connection is not opened')
+    }
 
     return this.db
   }

package/src/plans.js

@@ -702,7 +702,7 @@ function insertJobs (schema, { table, name, returnId = true }) {
         END as singleton_on,
       COALESCE("expireInSeconds", q.expire_seconds) as expire_seconds,
       COALESCE("deleteAfterSeconds", q.deletion_seconds) as deletion_seconds,
-      COALESCE("keepUntil", COALESCE(j.start_after, now()) + q.retention_seconds * interval '1s') as keep_until,
+      j.start_after + (COALESCE("retentionSeconds", q.retention_seconds) * interval '1s') as keep_until,
       COALESCE("retryLimit", q.retry_limit) as retry_limit,
       COALESCE("retryDelay", q.retry_delay) as retry_delay,
       COALESCE("retryBackoff", q.retry_backoff, false) as retry_backoff,
@@ -730,7 +730,7 @@ function insertJobs (schema, { table, name, returnId = true }) {
         "singletonOffset" integer,
         "expireInSeconds" integer,
         "deleteAfterSeconds" integer,
-        "keepUntil" timestamp with time zone        
+        "retentionSeconds" integer
       ) 
     ) j
     JOIN ${schema}.queue q ON q.name = '${name}'

package/src/timekeeper.js

@@ -1,6 +1,6 @@
 const EventEmitter = require('node:events')
 const plans = require('./plans')
-const cronParser = require('cron-parser')
+const { CronExpressionParser } = require('cron-parser')
 const Attorney = require('./attorney')
 
 const QUEUES = {
@@ -144,7 +144,7 @@ class Timekeeper extends EventEmitter {
   }
 
   shouldSendIt (cron, tz) {
-    const interval = cronParser.parseExpression(cron, { tz })
+    const interval = CronExpressionParser.parse(cron, { tz, strict: false })
 
     const prevTime = interval.prev()
 
@@ -176,7 +176,7 @@ class Timekeeper extends EventEmitter {
   async schedule (name, cron, data, options = {}) {
     const { tz = 'UTC', key = '', ...rest } = options
 
-    cronParser.parseExpression(cron, { tz })
+    CronExpressionParser.parse(cron, { tz, strict: false })
 
     Attorney.checkSendArgs([name, data, { ...rest }])
     Attorney.assertKey(key)

package/types.d.ts

@@ -3,7 +3,7 @@ import { EventEmitter } from 'events'
 declare namespace PgBoss {
 
   type JobStates = {
-    created : 'created',
+    created: 'created',
     retry: 'retry',
     active: 'active',
     completed: 'completed',
@@ -17,7 +17,7 @@ declare namespace PgBoss {
     singleton: 'singleton',
     stately: 'stately'
   }
-  
+
   interface Db {
     executeSql(text: string, values: any[]): Promise<{ rows: any[] }>;
   }
@@ -59,7 +59,7 @@ declare namespace PgBoss {
   interface QueueOptions {
     expireInSeconds?: number;
     retentionSeconds?: number;
-    deleteAfterSeconds?: number;    
+    deleteAfterSeconds?: number;
     retryLimit?: number;
     retryDelay?: number;
     retryBackoff?: boolean;
@@ -79,9 +79,9 @@ declare namespace PgBoss {
     db?: Db;
   }
 
-  type InsertOptions = ConnectionOptions;
+  type InsertOptions = ConnectionOptions
 
-  type SendOptions = JobOptions & QueueOptions & ConnectionOptions;
+  type SendOptions = JobOptions & QueueOptions & ConnectionOptions
 
   type QueuePolicy = 'standard' | 'short' | 'singleton' | 'stately'
 
@@ -97,7 +97,7 @@ declare namespace PgBoss {
     deferredCount: number;
     queuedCount: number;
     activeCount: number;
-    completedCount: number;
+    totalCount: number
     table: number;
     createdOn: Date;
     updatedOn: Date;
@@ -117,7 +117,7 @@ declare namespace PgBoss {
   }
 
   type WorkOptions = JobFetchOptions & JobPollingOptions
-  type FetchOptions = JobFetchOptions & ConnectionOptions;
+  type FetchOptions = JobFetchOptions & ConnectionOptions
 
   interface WorkHandler<ReqData> {
     (job: PgBoss.Job<ReqData>[]): Promise<any>;
@@ -184,8 +184,8 @@ declare namespace PgBoss {
     singletonKey?: string;
     singletonSeconds?: number;
     expireInSeconds?: number;
-    deleteAfterSeconds: number;
-    keepUntil?: Date | string;
+    deleteAfterSeconds?: number;
+    retentionSeconds?: number;
   }
 
   interface Worker {
@@ -217,102 +217,107 @@ declare namespace PgBoss {
 }
 
 declare class PgBoss extends EventEmitter {
-  constructor(connectionString: string);
-  constructor(options: PgBoss.ConstructorOptions);
+  constructor (connectionString: string)
+  constructor (options: PgBoss.ConstructorOptions)
 
-  static getConstructionPlans(schema?: string): string;
-  static getMigrationPlans(schema?: string, version?: string): string;
-  static getRollbackPlans(schema?: string, version?: string): string;
+  static getConstructionPlans (schema?: string): string
+  static getMigrationPlans (schema?: string, version?: string): string
+  static getRollbackPlans (schema?: string, version?: string): string
 
   static states: PgBoss.JobStates
   static policies: PgBoss.QueuePolicies
 
-  on(event: "error", handler: (error: Error) => void): this;
-  off(event: "error", handler: (error: Error) => void): this;
+  on (event: 'error', handler: (error: Error) => void): this
+  off (event: 'error', handler: (error: Error) => void): this
+
+  on (event: 'warning', handler: (warning: { message: string, data: object }) => void): this
+  off (event: 'warning', handler: (warning: { message: string, data: object }) => void): this
 
-  on(event: "warning", handler: (warning: { message: string, data: object }) => void): this;
-  off(event: "warning", handler: (warning: { message: string, data: object }) => void): this;
+  on (event: 'wip', handler: (data: PgBoss.Worker[]) => void): this
+  off (event: 'wip', handler: (data: PgBoss.Worker[]) => void): this
 
-  on(event: "wip", handler: (data: PgBoss.Worker[]) => void): this;
-  off(event: "wip", handler: (data: PgBoss.Worker[]) => void): this;
+  on (event: 'stopped', handler: () => void): this
+  off (event: 'stopped', handler: () => void): this
 
-  start(): Promise<PgBoss>;
-  stop(options?: PgBoss.StopOptions): Promise<void>;
+  start (): Promise<PgBoss>
+  stop (options?: PgBoss.StopOptions): Promise<void>
 
-  send(request: PgBoss.Request): Promise<string | null>;
-  send(name: string, data: object): Promise<string | null>;
-  send(name: string, data: object, options: PgBoss.SendOptions): Promise<string | null>;
+  send (request: PgBoss.Request): Promise<string | null>
+  send (name: string, data: object): Promise<string | null>
+  send (name: string, data: object, options: PgBoss.SendOptions): Promise<string | null>
 
-  sendAfter(name: string, data: object, options: PgBoss.SendOptions, date: Date): Promise<string | null>;
-  sendAfter(name: string, data: object, options: PgBoss.SendOptions, dateString: string): Promise<string | null>;
-  sendAfter(name: string, data: object, options: PgBoss.SendOptions, seconds: number): Promise<string | null>;
+  sendAfter (name: string, data: object, options: PgBoss.SendOptions, date: Date): Promise<string | null>
+  sendAfter (name: string, data: object, options: PgBoss.SendOptions, dateString: string): Promise<string | null>
+  sendAfter (name: string, data: object, options: PgBoss.SendOptions, seconds: number): Promise<string | null>
 
-  sendThrottled(name: string, data: object, options: PgBoss.SendOptions, seconds: number, key?: string): Promise<string | null>;
-  sendDebounced(name: string, data: object, options: PgBoss.SendOptions, seconds: number, key?: string): Promise<string | null>;
+  sendThrottled (name: string, data: object, options: PgBoss.SendOptions, seconds: number, key?: string): Promise<string | null>
+  sendDebounced (name: string, data: object, options: PgBoss.SendOptions, seconds: number, key?: string): Promise<string | null>
 
-  insert(name: string, jobs: PgBoss.JobInsert[]): Promise<void>;
-  insert(name: string, jobs: PgBoss.JobInsert[], options: PgBoss.InsertOptions): Promise<void>;
+  insert (name: string, jobs: PgBoss.JobInsert[]): Promise<void>
+  insert (name: string, jobs: PgBoss.JobInsert[], options: PgBoss.InsertOptions): Promise<void>
 
-  fetch<T>(name: string): Promise<PgBoss.Job<T>[]>;
-  fetch<T>(name: string, options: PgBoss.FetchOptions & { includeMetadata: true }): Promise<PgBoss.JobWithMetadata<T>[]>;
-  fetch<T>(name: string, options: PgBoss.FetchOptions): Promise<PgBoss.Job<T>[]>;
+  fetch<T>(name: string): Promise<PgBoss.Job<T>[]>
+  fetch<T>(name: string, options: PgBoss.FetchOptions & { includeMetadata: true }): Promise<PgBoss.JobWithMetadata<T>[]>
+  fetch<T>(name: string, options: PgBoss.FetchOptions): Promise<PgBoss.Job<T>[]>
 
-  work<ReqData>(name: string, handler: PgBoss.WorkHandler<ReqData>): Promise<string>;
-  work<ReqData>(name: string, options: PgBoss.WorkOptions & { includeMetadata: true }, handler: PgBoss.WorkWithMetadataHandler<ReqData>): Promise<string>;
-  work<ReqData>(name: string, options: PgBoss.WorkOptions, handler: PgBoss.WorkHandler<ReqData>): Promise<string>;
+  work<ReqData>(name: string, handler: PgBoss.WorkHandler<ReqData>): Promise<string>
+  work<ReqData>(name: string, options: PgBoss.WorkOptions & { includeMetadata: true }, handler: PgBoss.WorkWithMetadataHandler<ReqData>): Promise<string>
+  work<ReqData>(name: string, options: PgBoss.WorkOptions, handler: PgBoss.WorkHandler<ReqData>): Promise<string>
 
-  offWork(name: string): Promise<void>;
-  offWork(options: PgBoss.OffWorkOptions): Promise<void>;
+  offWork (name: string): Promise<void>
+  offWork (options: PgBoss.OffWorkOptions): Promise<void>
 
-  notifyWorker(workerId: string): void;
+  notifyWorker (workerId: string): void
 
-  subscribe(event: string, name: string): Promise<void>;
-  unsubscribe(event: string, name: string): Promise<void>;
-  publish(event: string): Promise<void>;
-  publish(event: string, data: object): Promise<void>;
-  publish(event: string, data: object, options: PgBoss.SendOptions): Promise<void>;
+  subscribe (event: string, name: string): Promise<void>
+  unsubscribe (event: string, name: string): Promise<void>
+  publish (event: string): Promise<void>
+  publish (event: string, data: object): Promise<void>
+  publish (event: string, data: object, options: PgBoss.SendOptions): Promise<void>
 
-  cancel(name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>;
-  cancel(name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>;
+  cancel (name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>
+  cancel (name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>
 
-  resume(name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>;
-  resume(name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>;
+  resume (name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>
+  resume (name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>
 
-  retry(name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>;
-  retry(name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>;
+  retry (name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>
+  retry (name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>
 
-  deleteJob(name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>;
-  deleteJob(name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>;
-  deleteQueuedJobs(name: string): Promise<void>;
-  deleteStoredJobs(name: string): Promise<void>;
-  deleteAllJobs(name: string): Promise<void>;
+  deleteJob (name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>
+  deleteJob (name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>
+  deleteQueuedJobs (name: string): Promise<void>
+  deleteStoredJobs (name: string): Promise<void>
+  deleteAllJobs (name: string): Promise<void>
 
-  complete(name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>;
-  complete(name: string, id: string, data: object, options?: PgBoss.ConnectionOptions): Promise<void>;
-  complete(name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>;
+  complete (name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>
+  complete (name: string, id: string, data: object, options?: PgBoss.ConnectionOptions): Promise<void>
+  complete (name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>
 
-  fail(name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>;
-  fail(name: string, id: string, data: object, options?: PgBoss.ConnectionOptions): Promise<void>;
-  fail(name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>;
+  fail (name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>
+  fail (name: string, id: string, data: object, options?: PgBoss.ConnectionOptions): Promise<void>
+  fail (name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>
 
-  getJobById<T>(name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<PgBoss.JobWithMetadata<T> | null>;
+  getJobById<T>(name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<PgBoss.JobWithMetadata<T> | null>
 
-  createQueue(name: string, options?: PgBoss.Queue): Promise<void>;
-  updateQueue(name: string, options?: PgBoss.Queue): Promise<void>;
-  deleteQueue(name: string): Promise<void>;
-  getQueues(): Promise<PgBoss.QueueResult[]>;
-  getQueue(name: string): Promise<PgBoss.QueueResult | null>;
-  getQueueStats(name: string): Promise<number>;
+  createQueue (name: string, options?: Omit<PgBoss.Queue, 'name'>): Promise<void>
+  createQueue (options: PgBoss.Queue): Promise<void>
+  updateQueue (name: string, options?: Omit<PgBoss.Queue, 'name'>): Promise<void>
+  updateQueue (options: PgBoss.Queue): Promise<void>
+  deleteQueue (name: string): Promise<void>
+  getQueues (): Promise<PgBoss.QueueResult[]>
+  getQueue (name: string): Promise<PgBoss.QueueResult | null>
+  getQueueStats (name: string): Promise<PgBoss.QueueResult>
 
-  supervise(name?: string): Promise<void>;
-  isInstalled(): Promise<Boolean>;
-  schemaVersion(): Promise<Number>;
+  supervise (name?: string): Promise<void>
+  isInstalled (): Promise<boolean>
+  schemaVersion (): Promise<number>
 
-  schedule(name: string, cron: string, data?: object, options?: PgBoss.ScheduleOptions): Promise<void>;
-  unschedule(name: string, key?: string): Promise<void>;
-  getSchedules(name?: string, key?: string): Promise<PgBoss.Schedule[]>;
+  schedule (name: string, cron: string, data?: object, options?: PgBoss.ScheduleOptions): Promise<void>
+  unschedule (name: string, key?: string): Promise<void>
+  getSchedules (name?: string, key?: string): Promise<PgBoss.Schedule[]>
 
-  getDb(): PgBoss.Db;
+  getDb (): PgBoss.Db
 }
 
-export = PgBoss;
+export = PgBoss