pg-boss 11.0.5 → 11.0.7

package/package.json

@@ -1,25 +1,27 @@
 {
   "name": "pg-boss",
-  "version": "11.0.5",
+  "version": "11.0.7",
   "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",
+    "@types/node": "^22.18.8",
+    "eslint": "^9.37.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

@@ -340,6 +340,7 @@ class Manager extends EventEmitter {
       singletonNextSlot,
       expireInSeconds,
       deleteAfterSeconds,
+      retentionSeconds,
       keepUntil,
       retryLimit,
       retryDelay,
@@ -358,6 +359,7 @@ class Manager extends EventEmitter {
       singletonOffset,
       expireInSeconds,
       deleteAfterSeconds,
+      retentionSeconds,
       keepUntil,
       retryLimit,
       retryDelay,

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',
@@ -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'
 
@@ -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,107 +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;
+  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?: 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>;
+  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