pg-boss 10.0.0-beta5 → 10.0.0-beta7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pg-boss",
-  "version": "10.0.0-beta5",
+  "version": "10.0.0-beta7",
   "description": "Queueing jobs in Postgres from Node.js like a boss",
   "main": "./src/index.js",
   "engines": {

package/src/attorney.js

@@ -152,6 +152,10 @@ function getConfig (value) {
     ? { connectionString: value }
     : { ...value }
 
+  config.schedule = ('schedule' in config) ? config.schedule : true
+  config.supervise = ('supervise' in config) ? config.supervise : true
+  config.migrate = ('migrate' in config) ? config.migrate : true
+
   applySchemaConfig(config)
   applyMaintenanceConfig(config)
   applyArchiveConfig(config)
@@ -303,10 +307,6 @@ function applyMaintenanceConfig (config) {
         : 120
 
   assert(config.maintenanceIntervalSeconds / 60 / 60 < MAX_INTERVAL_HOURS, `configuration assert: maintenance interval cannot exceed ${MAX_INTERVAL_HOURS} hours`)
-
-  config.schedule = ('schedule' in config) ? config.schedule : true
-  config.supervise = ('supervise' in config) ? config.supervise : true
-  config.migrate = ('migrate' in config) ? config.migrate : true
 }
 
 function applyDeleteConfig (config) {

package/src/boss.js

@@ -24,10 +24,8 @@ class Boss extends EventEmitter {
     this.failJobsByTimeoutCommand = plans.locked(config.schema, plans.failJobsByTimeout(config.schema))
     this.archiveCommand = plans.locked(config.schema, plans.archive(config.schema, config.archiveInterval, config.archiveFailedInterval))
     this.dropCommand = plans.locked(config.schema, plans.drop(config.schema, config.deleteAfter))
-    this.getMaintenanceTimeCommand = plans.getMaintenanceTime(config.schema)
-    this.setMaintenanceTimeCommand = plans.setMaintenanceTime(config.schema)
-    this.getMonitorTimeCommand = plans.getMonitorTime(config.schema)
-    this.setMonitorTimeCommand = plans.setMonitorTime(config.schema)
+    this.trySetMaintenanceTimeCommand = plans.trySetMaintenanceTime(config.schema)
+    this.trySetMonitorTimeCommand = plans.trySetMonitorTime(config.schema)
     this.countStatesCommand = plans.countStates(config.schema)
 
     this.functions = [
@@ -48,8 +46,6 @@ class Boss extends EventEmitter {
   }
 
   async onMonitor () {
-    let locker
-
     try {
       if (this.monitoring) {
         return
@@ -65,26 +61,24 @@ class Boss extends EventEmitter {
         throw new Error(this.config.__test__throw_monitor)
       }
 
-      locker = await this.db.lock({ key: 'monitor' })
+      if (this.stopped) {
+        return
+      }
 
-      const { secondsAgo } = await this.getMonitorTime()
+      const { rows } = await this.db.executeSql(this.trySetMonitorTimeCommand, [this.config.monitorStateIntervalSeconds])
 
-      if (secondsAgo > this.monitorStateIntervalSeconds && !this.stopped) {
+      if (rows.length === 1 && !this.stopped) {
         const states = await this.countStates()
-        this.setMonitorTime()
         this.emit(events.monitorStates, states)
       }
     } catch (err) {
       this.emit(events.error, err)
     } finally {
-      await locker?.unlock()
       this.monitoring = false
     }
   }
 
   async onSupervise () {
-    let locker
-
     try {
       if (this.maintaining) {
         return
@@ -105,18 +99,15 @@ class Boss extends EventEmitter {
         return
       }
 
-      locker = await this.db.lock({ key: 'maintenance' })
-
-      const { secondsAgo } = await this.getMaintenanceTime()
+      const { rows } = await this.db.executeSql(this.trySetMaintenanceTimeCommand, [this.config.maintenanceIntervalSeconds])
 
-      if (secondsAgo > this.maintenanceIntervalSeconds) {
+      if (rows.length === 1 && !this.stopped) {
         const result = await this.maintain()
         this.emit(events.maintenance, result)
       }
     } catch (err) {
       this.emit(events.error, err)
     } finally {
-      await locker?.unlock()
       this.maintaining = false
     }
   }
@@ -130,8 +121,6 @@ class Boss extends EventEmitter {
 
     const ended = Date.now()
 
-    await this.setMaintenanceTime()
-
     return { ms: ended - started }
   }
 

package/src/contractor.js

@@ -24,26 +24,26 @@ class Contractor {
 
     // exported api to index
     this.functions = [
-      this.version,
+      this.schemaVersion,
       this.isInstalled
     ]
   }
 
-  async version () {
+  async schemaVersion () {
     const result = await this.db.executeSql(plans.getVersion(this.config.schema))
     return result.rows.length ? parseInt(result.rows[0].version) : null
   }
 
   async isInstalled () {
     const result = await this.db.executeSql(plans.versionTableExists(this.config.schema))
-    return result.rows.length ? result.rows[0].name : null
+    return !!result.rows[0].name
   }
 
   async start () {
     const installed = await this.isInstalled()
 
     if (installed) {
-      const version = await this.version()
+      const version = await this.schemaVersion()
 
       if (schemaVersion > version) {
         throw new Error('Migrations are not supported to v10')
@@ -61,7 +61,7 @@ class Contractor {
       throw new Error('pg-boss is not installed')
     }
 
-    const version = await this.version()
+    const version = await this.schemaVersion()
 
     if (schemaVersion !== version) {
       throw new Error('pg-boss database requires migrations')

package/src/db.js

@@ -1,6 +1,5 @@
 const EventEmitter = require('events')
 const pg = require('pg')
-const { advisoryLock } = require('./plans')
 
 class Db extends EventEmitter {
   constructor (config) {
@@ -43,31 +42,6 @@ class Db extends EventEmitter {
       return await this.pool.query(text, values)
     }
   }
-
-  async lock ({ timeout = 30, key } = {}) {
-    const lockedClient = await this.pool.connect()
-
-    const query = `
-        BEGIN;
-        SET LOCAL lock_timeout = '${timeout}s';
-        SET LOCAL idle_in_transaction_session_timeout = '${timeout}s';
-        ${advisoryLock(this.config.schema, key)};
-    `
-
-    await lockedClient.query(query)
-
-    const locker = {
-      unlock: async function () {
-        try {
-          await lockedClient.query('COMMIT')
-        } finally {
-          lockedClient.release()
-        }
-      }
-    }
-
-    return locker
-  }
 }
 
 module.exports = Db

package/src/manager.js

@@ -217,7 +217,7 @@ class Manager extends EventEmitter {
       this.emitWip(name)
 
       if (batchSize) {
-        const maxExpiration = jobs.reduce((acc, i) => Math.max(acc, i.expire_in_seconds), 0)
+        const maxExpiration = jobs.reduce((acc, i) => Math.max(acc, i.expireInSeconds), 0)
 
         await resolveWithinSeconds(Promise.all([callback(jobs)]), maxExpiration)
           .then(() => this.complete(name, jobs.map(job => job.id)))
@@ -228,7 +228,7 @@ class Manager extends EventEmitter {
         }
 
         const allTeamPromise = pMap(jobs, job =>
-          resolveWithinSeconds(callback(job), job.expire_in_seconds)
+          resolveWithinSeconds(callback(job), job.expireInSeconds)
             .then(result => this.complete(name, job.id, result))
             .catch(err => this.fail(name, job.id, err))
             .then(() => refill ? onRefill() : null)
@@ -317,13 +317,9 @@ class Manager extends EventEmitter {
   async publish (event, ...args) {
     assert(event, 'Missing required argument')
 
-    const result = await this.db.executeSql(this.getQueuesForEventCommand, [event])
+    const { rows } = await this.db.executeSql(this.getQueuesForEventCommand, [event])
 
-    if (!result || result.rowCount === 0) {
-      return []
-    }
-
-    return await Promise.all(result.rows.map(({ name }) => this.send(name, ...args)))
+    return await Promise.all(rows.map(({ name }) => this.send(name, ...args)))
   }
 
   async send (...args) {
@@ -406,10 +402,10 @@ class Manager extends EventEmitter {
     ]
 
     const db = wrapper || this.db
-    const result = await db.executeSql(this.insertJobCommand, values)
+    const { rows } = await db.executeSql(this.insertJobCommand, values)
 
-    if (result && result.rowCount === 1) {
-      return result.rows[0].id
+    if (rows.length === 1) {
+      return rows[0].id
     }
 
     if (!options.singletonNextSlot) {
@@ -645,17 +641,16 @@ class Manager extends EventEmitter {
     assert(name, 'Missing queue name argument')
 
     const queueSql = plans.getQueueByName(this.config.schema)
-    const result = await this.db.executeSql(queueSql, [name])
+    const { rows } = await this.db.executeSql(queueSql, [name])
 
-    if (result?.rows?.length) {
+    if (rows.length) {
       Attorney.assertQueueName(name)
       const sql = plans.dropPartition(this.config.schema, name)
       await this.db.executeSql(sql)
     }
 
     const sql = plans.deleteQueueRecords(this.config.schema)
-    const result2 = await this.db.executeSql(sql, [name])
-    return result2?.rowCount || null
+    await this.db.executeSql(sql, [name])
   }
 
   async purgeQueue (queue) {

package/src/plans.js

@@ -53,14 +53,10 @@ module.exports = {
   getQueueSize,
   purgeQueue,
   clearStorage,
-  getMaintenanceTime,
-  setMaintenanceTime,
-  getMonitorTime,
-  setMonitorTime,
-  getCronTime,
-  setCronTime,
+  trySetMaintenanceTime,
+  trySetMonitorTime,
+  trySetCronTime,
   locked,
-  advisoryLock,
   assertMigration,
   getArchivedJobById,
   getJobById,
@@ -77,7 +73,6 @@ function create (schema, version) {
     createEnumJobState(schema),
 
     createTableJob(schema),
-    createIndexJobName(schema),
     createIndexJobFetch(schema),
     createIndexJobPolicyStately(schema),
     createIndexJobPolicyShort(schema),
@@ -89,7 +84,6 @@ function create (schema, version) {
     createPrimaryKeyArchive(schema),
     createColumnArchiveArchivedOn(schema),
     createIndexArchiveArchivedOn(schema),
-    createIndexArchiveName(schema),
 
     createTableVersion(schema),
     createTableQueue(schema),
@@ -146,26 +140,44 @@ function createTableJob (schema) {
       priority integer not null default(0),
       data jsonb,
       state ${schema}.job_state not null default('${states.created}'),
-      retryLimit integer not null default(0),
-      retryCount integer not null default(0),
-      retryDelay integer not null default(0),
-      retryBackoff boolean not null default false,
-      startAfter timestamp with time zone not null default now(),
-      startedOn timestamp with time zone,
-      singletonKey text,
-      singletonOn timestamp without time zone,
-      expireIn interval not null default interval '15 minutes',
-      createdOn timestamp with time zone not null default now(),
-      completedOn timestamp with time zone,
-      keepUntil timestamp with time zone NOT NULL default now() + interval '14 days',
+      retry_limit integer not null default(0),
+      retry_count integer not null default(0),
+      retry_delay integer not null default(0),
+      retry_backoff boolean not null default false,
+      start_after timestamp with time zone not null default now(),
+      started_on timestamp with time zone,
+      singleton_key text,
+      singleton_on timestamp without time zone,
+      expire_in interval not null default interval '15 minutes',
+      created_on timestamp with time zone not null default now(),
+      completed_on timestamp with time zone,
+      keep_until timestamp with time zone NOT NULL default now() + interval '14 days',
       output jsonb,
-      deadletter text,
+      dead_letter text,
       policy text,
       CONSTRAINT job_pkey PRIMARY KEY (name, id)
     ) PARTITION BY LIST (name)
   `
 }
 
+const baseJobColumns = 'id, name, data, EXTRACT(epoch FROM expire_in) as "expireInSeconds"'
+const allJobColumns = `${baseJobColumns}, policy, state, priority,
+  retry_limit as "retryLimit",
+  retry_count as "retryCount",
+  retry_delay as "retryDelay",
+  retry_backoff as "retryBackoff",
+  start_after as "startAfter",  
+  started_on as "startedOn",
+  singleton_key as "singletonKey",
+  singleton_on as "singletonOn",
+  expire_in as "expireIn",
+  created_on as "createdOn",
+  completed_on as "completedOn",
+  keep_until as "keepUntil",
+  dead_letter as "deadLetter",
+  output
+`
+
 function createPartition (schema, name) {
   return `SELECT ${schema}.create_partition('${name}');`
 }
@@ -232,19 +244,15 @@ function createIndexJobPolicyStately (schema) {
 }
 
 function createIndexJobThrottleOn (schema) {
-  return `CREATE UNIQUE INDEX job_throttle_on ON ${schema}.job (name, singletonOn, COALESCE(singletonKey, '')) WHERE state <= '${states.completed}' AND singletonOn IS NOT NULL`
+  return `CREATE UNIQUE INDEX job_throttle_on ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <= '${states.completed}' AND singleton_on IS NOT NULL`
 }
 
 function createIndexJobThrottleKey (schema) {
-  return `CREATE UNIQUE INDEX job_throttle_key ON ${schema}.job (name, singletonKey) WHERE state <= '${states.completed}' AND singletonOn IS NULL`
-}
-
-function createIndexJobName (schema) {
-  return `CREATE INDEX job_name ON ${schema}.job (name)`
+  return `CREATE UNIQUE INDEX job_throttle_key ON ${schema}.job (name, singleton_key) WHERE state <= '${states.completed}' AND singleton_on IS NULL`
 }
 
 function createIndexJobFetch (schema) {
-  return `CREATE INDEX job_fetch ON ${schema}.job (name, startAfter) INCLUDE (priority, createdOn, id) WHERE state < '${states.active}'`
+  return `CREATE INDEX job_fetch ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < '${states.active}'`
 }
 
 function createTableArchive (schema) {
@@ -252,40 +260,31 @@ function createTableArchive (schema) {
 }
 
 function createColumnArchiveArchivedOn (schema) {
-  return `ALTER TABLE ${schema}.archive ADD archivedOn timestamptz NOT NULL DEFAULT now()`
+  return `ALTER TABLE ${schema}.archive ADD archived_on timestamptz NOT NULL DEFAULT now()`
 }
 
 function createIndexArchiveArchivedOn (schema) {
-  return `CREATE INDEX archive_archivedon_idx ON ${schema}.archive(archivedon)`
-}
-
-function createIndexArchiveName (schema) {
-  return `CREATE INDEX archive_name_idx ON ${schema}.archive(name)`
-}
-
-function getMaintenanceTime (schema) {
-  return `SELECT maintained_on, EXTRACT( EPOCH FROM (now() - maintained_on) ) seconds_ago FROM ${schema}.version`
-}
-
-function setMaintenanceTime (schema) {
-  return `UPDATE ${schema}.version SET maintained_on = now()`
+  return `CREATE INDEX archive_archived_on_idx ON ${schema}.archive(archived_on)`
 }
 
-function getMonitorTime (schema) {
-  return `SELECT monitored_on, EXTRACT( EPOCH FROM (now() - monitored_on) ) seconds_ago FROM ${schema}.version`
+function trySetMaintenanceTime (schema) {
+  return trySetTimestamp(schema, 'maintained_on')
 }
 
-function setMonitorTime (schema) {
-  return `UPDATE ${schema}.version SET monitored_on = now()`
+function trySetMonitorTime (schema) {
+  return trySetTimestamp(schema, 'monitored_on')
 }
 
-function setCronTime (schema, time) {
-  time = time || 'now()'
-  return `UPDATE ${schema}.version SET cron_on = ${time}`
+function trySetCronTime (schema) {
+  return trySetTimestamp(schema, 'cron_on')
 }
 
-function getCronTime (schema) {
-  return `SELECT cron_on, EXTRACT( EPOCH FROM (now() - cron_on) ) seconds_ago FROM ${schema}.version`
+function trySetTimestamp (schema, column) {
+  return `
+    UPDATE ${schema}.version SET ${column} = now()
+    WHERE EXTRACT( EPOCH FROM (now() - COALESCE(${column}, now() - interval '1 week') ) ) > $1
+    RETURNING true
+  `
 }
 
 function createQueue (schema) {
@@ -458,19 +457,18 @@ function fetchNextJob (schema) {
       FROM ${schema}.job
       WHERE name = $1
         AND state < '${states.active}'
-        AND startAfter < now()
-      ORDER BY ${priority && 'priority desc, '} createdOn, id
+        AND start_after < now()
+      ORDER BY ${priority && 'priority desc, '} created_on, id
       LIMIT $2
       FOR UPDATE SKIP LOCKED
     )
     UPDATE ${schema}.job j SET
       state = '${states.active}',
-      startedOn = now(),
-      retryCount = CASE WHEN startedOn IS NOT NULL THEN retryCount + 1 ELSE retryCount END
+      started_on = now(),
+      retry_count = CASE WHEN started_on IS NOT NULL THEN retry_count + 1 ELSE retry_count END
     FROM next
     WHERE name = $1 AND j.id = next.id
-    RETURNING ${includeMetadata ? 'j.*' : 'j.id, name, data'}, 
-      EXTRACT(epoch FROM expireIn) as expire_in_seconds
+    RETURNING j.${includeMetadata ? allJobColumns : baseJobColumns}      
   `
 }
 
@@ -478,7 +476,7 @@ function completeJobs (schema) {
   return `
     WITH results AS (
       UPDATE ${schema}.job
-      SET completedOn = now(),
+      SET completed_on = now(),
         state = '${states.completed}',
         output = $3::jsonb
       WHERE name = $1
@@ -498,7 +496,7 @@ function failJobsById (schema) {
 }
 
 function failJobsByTimeout (schema) {
-  const where = `state = '${states.active}' AND (startedOn + expireIn) < now()`
+  const where = `state = '${states.active}' AND (started_on + expire_in) < now()`
   const output = '\'{ "value": { "message": "job failed by timeout in active state" } }\'::jsonb'
   return failJobs(schema, where, output)
 }
@@ -508,36 +506,36 @@ function failJobs (schema, where, output) {
     WITH results AS (
       UPDATE ${schema}.job SET
         state = CASE
-          WHEN retryCount < retryLimit THEN '${states.retry}'::${schema}.job_state
+          WHEN retry_count < retry_limit THEN '${states.retry}'::${schema}.job_state
           ELSE '${states.failed}'::${schema}.job_state
           END,
-        completedOn = CASE
-          WHEN retryCount < retryLimit THEN NULL
+        completed_on = CASE
+          WHEN retry_count < retry_limit THEN NULL
           ELSE now()
           END,
-        startAfter = CASE
-          WHEN retryCount = retryLimit THEN startAfter
-          WHEN NOT retryBackoff THEN now() + retryDelay * interval '1'
+        start_after = CASE
+          WHEN retry_count = retry_limit THEN start_after
+          WHEN NOT retry_backoff THEN now() + retry_delay * interval '1'
           ELSE now() + (
-                retryDelay * 2 ^ LEAST(16, retryCount + 1) / 2 +
-                retryDelay * 2 ^ LEAST(16, retryCount + 1) / 2 * random()
+                retry_delay * 2 ^ LEAST(16, retry_count + 1) / 2 +
+                retry_delay * 2 ^ LEAST(16, retry_count + 1) / 2 * random()
             ) * interval '1'
           END,
         output = ${output}
       WHERE ${where}
       RETURNING *
     ), dlq_jobs as (
-      INSERT INTO ${schema}.job (name, data, output, retryLimit, keepUntil)
+      INSERT INTO ${schema}.job (name, data, output, retry_limit, keep_until)
       SELECT
-        deadletter,
+        dead_letter,
         data,
         output,
-        retryLimit,
-        keepUntil + (keepUntil - startAfter)
+        retry_limit,
+        keep_until + (keep_until - start_after)
       FROM results
       WHERE state = '${states.failed}'
-        AND deadletter IS NOT NULL
-        AND NOT name = deadletter
+        AND dead_letter IS NOT NULL
+        AND NOT name = dead_letter
     )
     SELECT COUNT(*) FROM results
   `
@@ -547,7 +545,7 @@ function cancelJobs (schema) {
   return `
     with results as (
       UPDATE ${schema}.job
-      SET completedOn = now(),
+      SET completed_on = now(),
         state = '${states.cancelled}'
       WHERE name = $1
         AND id IN (SELECT UNNEST($2::uuid[]))
@@ -562,7 +560,7 @@ function resumeJobs (schema) {
   return `
     with results as (
       UPDATE ${schema}.job
-      SET completedOn = NULL,
+      SET completed_on = NULL,
         state = '${states.created}'
       WHERE name = $1
         AND id IN (SELECT UNNEST($2::uuid[]))
@@ -579,15 +577,15 @@ function insertJob (schema) {
       name,
       data,
       priority,
-      startAfter,
-      singletonKey,
-      singletonOn,
-      deadletter,
-      expireIn,
-      keepUntil,
-      retryLimit,
-      retryDelay,
-      retryBackoff,
+      start_after,
+      singleton_key,
+      singleton_on,
+      dead_letter,
+      expire_in,
+      keep_until,
+      retry_limit,
+      retry_delay,
+      retry_backoff,
       policy
     )
     SELECT
@@ -595,27 +593,27 @@ function insertJob (schema) {
       j.name,
       data,
       priority,
-      startAfter,
-      singletonKey,
-      singletonOn,
-      COALESCE(deadLetter, q.dead_letter) as deadletter,
+      start_after,
+      singleton_key,
+      singleton_on,
+      COALESCE(j.dead_letter, q.dead_letter) as dead_letter,
       CASE
-        WHEN expireIn IS NOT NULL THEN CAST(expireIn as interval)
+        WHEN expire_in IS NOT NULL THEN CAST(expire_in as interval)
         WHEN q.expire_seconds IS NOT NULL THEN q.expire_seconds * interval '1s'
-        WHEN expireInDefault IS NOT NULL THEN CAST(expireInDefault as interval)
+        WHEN expire_in_default IS NOT NULL THEN CAST(expire_in_default as interval)
         ELSE interval '15 minutes'
-        END as expireIn,
+        END as expire_in,
       CASE
-        WHEN right(keepUntil, 1) = 'Z' THEN CAST(keepUntil as timestamp with time zone)
-        ELSE startAfter + CAST(COALESCE(keepUntil, (q.retention_minutes * 60)::text, keepUntilDefault, '14 days') as interval)
-        END as keepUntil,
-      COALESCE(retryLimit, q.retry_limit, retryLimitDefault, 2) as retryLimit,
+        WHEN right(keep_until, 1) = 'Z' THEN CAST(keep_until as timestamp with time zone)
+        ELSE start_after + CAST(COALESCE(keep_until, (q.retention_minutes * 60)::text, keep_until_default, '14 days') as interval)
+        END as keep_until,
+      COALESCE(j.retry_limit, q.retry_limit, retry_limit_default, 2) as retry_limit,
       CASE
-        WHEN COALESCE(retryBackoff, q.retry_backoff, retryBackoffDefault, false)
-        THEN GREATEST(COALESCE(retryDelay, q.retry_delay, retryDelayDefault), 1)
-        ELSE COALESCE(retryDelay, q.retry_delay, retryDelayDefault, 0)
-        END as retryDelay,
-      COALESCE(retryBackoff, q.retry_backoff, retryBackoffDefault, false) as retryBackoff,
+        WHEN COALESCE(j.retry_backoff, q.retry_backoff, retry_backoff_default, false)
+        THEN GREATEST(COALESCE(j.retry_delay, q.retry_delay, retry_delay_default), 1)
+        ELSE COALESCE(j.retry_delay, q.retry_delay, retry_delay_default, 0)
+        END as retry_delay,
+      COALESCE(j.retry_backoff, q.retry_backoff, retry_backoff_default, false) as retry_backoff,
       q.policy
     FROM
       ( SELECT
@@ -626,23 +624,23 @@ function insertJob (schema) {
           CASE
             WHEN right($5, 1) = 'Z' THEN CAST($5 as timestamp with time zone)
             ELSE now() + CAST(COALESCE($5,'0') as interval)
-            END as startAfter,
-          $6 as singletonKey,
+            END as start_after,
+          $6 as singleton_key,
           CASE
             WHEN $7::integer IS NOT NULL THEN 'epoch'::timestamp + '1 second'::interval * ($7 * floor((date_part('epoch', now()) + $8) / $7))
             ELSE NULL
-            END as singletonOn,
-          $9 as deadletter,
-          $10 as expireIn,
-          $11 as expireInDefault,
-          $12 as keepUntil,
-          $13 as keepUntilDefault,
-          $14::int as retryLimit,
-          $15::int as retryLimitDefault,
-          $16::int as retryDelay,
-          $17::int as retryDelayDefault,
-          $18::bool as retryBackoff,
-          $19::bool as retryBackoffDefault
+            END as singleton_on,
+          $9 as dead_letter,
+          $10 as expire_in,
+          $11 as expire_in_default,
+          $12 as keep_until,
+          $13 as keep_until_default,
+          $14::int as retry_limit,
+          $15::int as retry_limit_default,
+          $16::int as retry_delay,
+          $17::int as retry_delay_default,
+          $18::bool as retry_backoff,
+          $19::bool as retry_backoff_default
       ) j LEFT JOIN ${schema}.queue q ON j.name = q.name
     ON CONFLICT DO NOTHING
     RETURNING id
@@ -653,25 +651,25 @@ function insertJobs (schema) {
   return `
     WITH defaults as (
       SELECT 
-        $2 as expireIn,
-        $3 as keepUntil,
-        $4::int as retryLimit,
-        $5::int as retryDelay,
-        $6::bool as retryBackoff
+        $2 as expire_in,
+        $3 as keep_until,
+        $4::int as retry_limit,
+        $5::int as retry_delay,
+        $6::bool as retry_backoff
     )
     INSERT INTO ${schema}.job (
       id,
       name,
       data,
       priority,
-      startAfter,
-      singletonKey,
-      deadletter,
-      expireIn,
-      keepUntil,
-      retryLimit,
-      retryDelay,
-      retryBackoff,
+      start_after,
+      singleton_key,
+      dead_letter,
+      expire_in,
+      keep_until,
+      retry_limit,
+      retry_delay,
+      retry_backoff,
       policy
     )
     SELECT
@@ -685,20 +683,20 @@ function insertJobs (schema) {
       CASE
         WHEN "expireInSeconds" IS NOT NULL THEN "expireInSeconds" *  interval '1s'
         WHEN q.expire_seconds IS NOT NULL THEN q.expire_seconds * interval '1s'
-        WHEN defaults.expireIn IS NOT NULL THEN CAST(defaults.expireIn as interval)
+        WHEN defaults.expire_in IS NOT NULL THEN CAST(defaults.expire_in as interval)
         ELSE interval '15 minutes'
-        END as expireIn,
+        END as expire_in,
       CASE
         WHEN "keepUntil" IS NOT NULL THEN "keepUntil"
-        ELSE COALESCE("startAfter", now()) + CAST(COALESCE((q.retention_minutes * 60)::text, defaults.keepUntil, '14 days') as interval)
-        END as keepUntil,
-      COALESCE("retryLimit", q.retry_limit, defaults.retryLimit, 2),
+        ELSE COALESCE("startAfter", now()) + CAST(COALESCE((q.retention_minutes * 60)::text, defaults.keep_until, '14 days') as interval)
+        END as keep_until,
+      COALESCE("retryLimit", q.retry_limit, defaults.retry_limit, 2),
       CASE
-        WHEN COALESCE("retryBackoff", q.retry_backoff, defaults.retryBackoff, false)
-          THEN GREATEST(COALESCE("retryDelay", q.retry_delay, defaults.retryDelay), 1)
-        ELSE COALESCE("retryDelay", q.retry_delay, defaults.retryDelay, 0)
-        END as retryDelay,      
-      COALESCE("retryBackoff", q.retry_backoff, defaults.retryBackoff, false) as retryBackoff,
+        WHEN COALESCE("retryBackoff", q.retry_backoff, defaults.retry_backoff, false)
+          THEN GREATEST(COALESCE("retryDelay", q.retry_delay, defaults.retry_delay), 1)
+        ELSE COALESCE("retryDelay", q.retry_delay, defaults.retry_delay, 0)
+        END as retry_delay,      
+      COALESCE("retryBackoff", q.retry_backoff, defaults.retry_backoff, false) as retry_backoff,
       q.policy
     FROM json_to_recordset($1) as j (
       id uuid,
@@ -723,24 +721,23 @@ function insertJobs (schema) {
 function drop (schema, interval) {
   return `
     DELETE FROM ${schema}.archive
-    WHERE archivedOn < (now() - interval '${interval}')
+    WHERE archived_on < (now() - interval '${interval}')
   `
 }
 
 function archive (schema, completedInterval, failedInterval = completedInterval) {
+  const columns = 'id, name, priority, data, state, retry_limit, retry_count, retry_delay, retry_backoff, start_after, started_on, singleton_key, singleton_on, expire_in, created_on, completed_on, keep_until, dead_letter, policy, output'
+
   return `
     WITH archived_rows AS (
       DELETE FROM ${schema}.job
-      WHERE (state <> '${states.failed}' AND completedOn < (now() - interval '${completedInterval}'))
-        OR (state = '${states.failed}' AND completedOn < (now() - interval '${failedInterval}'))
-        OR (state < '${states.active}' AND keepUntil < now())
+      WHERE (state <> '${states.failed}' AND completed_on < (now() - interval '${completedInterval}'))
+        OR (state = '${states.failed}' AND completed_on < (now() - interval '${failedInterval}'))
+        OR (state < '${states.active}' AND keep_until < now())
       RETURNING *
     )
-    INSERT INTO ${schema}.archive (
-      id, name, priority, data, state, retryLimit, retryCount, retryDelay, retryBackoff, startAfter, startedOn, singletonKey, singletonOn, expireIn, createdOn, completedOn, keepUntil, deadletter, policy, output
-    )
-    SELECT
-      id, name, priority, data, state, retryLimit, retryCount, retryDelay, retryBackoff, startAfter, startedOn, singletonKey, singletonOn, expireIn, createdOn, completedOn, keepUntil, deadletter, policy, output
+    INSERT INTO ${schema}.archive (${columns})
+    SELECT ${columns}
     FROM archived_rows
   `
 }
@@ -761,6 +758,7 @@ function locked (schema, query) {
   return `
     BEGIN;
     SET LOCAL lock_timeout = '30s';
+    SET LOCAL idle_in_transaction_session_timeout = '30s';
     ${advisoryLock(schema)};
     ${query};
     COMMIT;
@@ -779,13 +777,13 @@ function assertMigration (schema, version) {
 }
 
 function getJobById (schema) {
-  return getJobByTableAndId(schema, 'job')
+  return getJobByTableQueueId(schema, 'job')
 }
 
 function getArchivedJobById (schema) {
-  return getJobByTableAndId(schema, 'archive')
+  return getJobByTableQueueId(schema, 'archive')
 }
 
-function getJobByTableAndId (schema, table) {
-  return `SELECT * FROM ${schema}.${table} WHERE name = $1 AND id = $2`
+function getJobByTableQueueId (schema, table) {
+  return `SELECT ${allJobColumns} FROM ${schema}.${table} WHERE name = $1 AND id = $2`
 }

package/src/timekeeper.js

@@ -31,8 +31,7 @@ class Timekeeper extends EventEmitter {
     this.getSchedulesCommand = plans.getSchedules(config.schema)
     this.scheduleCommand = plans.schedule(config.schema)
     this.unscheduleCommand = plans.unschedule(config.schema)
-    this.getCronTimeCommand = plans.getCronTime(config.schema)
-    this.setCronTimeCommand = plans.setCronTime(config.schema)
+    this.trySetCronTimeCommand = plans.trySetCronTime(config.schema)
 
     this.functions = [
       this.schedule,
@@ -44,27 +43,30 @@ class Timekeeper extends EventEmitter {
   }
 
   async start () {
-    this.stopped = false
-
     // setting the archive config too low breaks the cron 60s debounce interval so don't even try
     if (this.config.archiveSeconds < 60 || this.config.archiveFailedSeconds < 60) {
       return
     }
 
-    // cache the clock skew from the db server
+    this.stopped = false
+
     await this.cacheClockSkew()
 
     try {
       await this.manager.createQueue(queues.SEND_IT)
     } catch {}
 
-    await this.manager.work(queues.SEND_IT, { newJobCheckIntervalSeconds: this.config.cronWorkerIntervalSeconds, teamSize: 50, teamConcurrency: 5 }, (job) => this.onSendIt(job))
+    const options = {
+      newJobCheckIntervalSeconds: this.config.cronWorkerIntervalSeconds,
+      teamSize: 50,
+      teamConcurrency: 5
+    }
+
+    await this.manager.work(queues.SEND_IT, options, (job) => this.onSendIt(job))
 
     setImmediate(() => this.onCron())
 
-    // create monitoring interval to make sure cron hasn't crashed
     this.cronMonitorInterval = setInterval(async () => await this.onCron(), this.cronMonitorIntervalMs)
-    // create monitoring interval to measure and adjust for drift in clock skew
     this.skewMonitorInterval = setInterval(async () => await this.cacheClockSkew(), this.skewMonitorIntervalMs)
   }
 
@@ -117,8 +119,6 @@ class Timekeeper extends EventEmitter {
   }
 
   async onCron () {
-    let locker
-
     try {
       if (this.stopped || this.timekeeping) return
 
@@ -128,19 +128,15 @@ class Timekeeper extends EventEmitter {
 
       this.timekeeping = true
 
-      locker = await this.db.lock({ key: 'timekeeper' })
-
-      const { secondsAgo } = await this.getCronTime()
+      const { rows } = await this.db.executeSql(this.trySetCronTimeCommand, [this.config.cronMonitorIntervalSeconds])
 
-      if (secondsAgo > this.config.cronMonitorIntervalSeconds) {
+      if (rows.length === 1 && !this.stopped) {
         await this.cron()
-        await this.setCronTime()
       }
     } catch (err) {
       this.emit(this.events.error, err)
     } finally {
       this.timekeeping = false
-      await locker?.unlock()
     }
   }
 
@@ -198,28 +194,11 @@ class Timekeeper extends EventEmitter {
 
     const values = [name, cron, tz, data, options]
 
-    const result = await this.db.executeSql(this.scheduleCommand, values)
-
-    return result ? result.rowCount : null
+    await this.db.executeSql(this.scheduleCommand, values)
   }
 
   async unschedule (name) {
-    const result = await this.db.executeSql(this.unscheduleCommand, [name])
-    return result ? result.rowCount : null
-  }
-
-  async setCronTime () {
-    await this.db.executeSql(this.setCronTimeCommand)
-  }
-
-  async getCronTime () {
-    const { rows } = await this.db.executeSql(this.getCronTimeCommand)
-
-    let { cron_on: cronOn, seconds_ago: secondsAgo } = rows[0]
-
-    secondsAgo = secondsAgo !== null ? parseFloat(secondsAgo) : 61
-
-    return { cronOn, secondsAgo }
+    await this.db.executeSql(this.unscheduleCommand, [name])
   }
 }
 

package/types.d.ts

@@ -2,7 +2,7 @@ import { EventEmitter } from 'events'
 
 declare namespace PgBoss {
   interface Db {
-    executeSql(text: string, values: any[]): Promise<{ rows: any[]; rowCount: number }>;
+    executeSql(text: string, values: any[]): Promise<{ rows: any[] }>;
   }
 
   interface DatabaseOptions {
@@ -91,10 +91,14 @@ declare namespace PgBoss {
   interface ConnectionOptions {
     db?: Db;
   }
-
+  
   type InsertOptions = ConnectionOptions;
-
+  
   type SendOptions = JobOptions & ExpirationOptions & RetentionOptions & RetryOptions & ConnectionOptions;
+  
+  type QueuePolicy = 'standard' | 'short' | 'singleton' | 'stately'
+  type Queue = ExpirationOptions & RetentionOptions & RetryOptions & { policy: QueuePolicy }
+  type QueueUpdateOptions = ExpirationOptions & RetentionOptions & RetryOptions
 
   type ScheduleOptions = SendOptions & { tz?: string }
 
@@ -176,24 +180,26 @@ declare namespace PgBoss {
     data: T;
   }
 
-  interface JobWithMetadata<T = object> extends Job<T> {
+  interface JobWithMetadata<T = object> {
+    id: string;
+    name: string;
+    data: T;
     priority: number;
     state: 'created' | 'retry' | 'active' | 'completed' | 'cancelled' | 'failed';
-    retrylimit: number;
-    retrycount: number;
-    retrydelay: number;
-    retrybackoff: boolean;
-    startafter: Date;
-    // This is nullable in the schema, but by the time this type is reified,
-    // it will have been set.
-    startedon: Date;
-    singletonkey: string | null;
-    singletonon: Date | null;
-    expirein: PostgresInterval;
-    createdon: Date;
-    completedon: Date | null;
-    keepuntil: Date;
-    deadletter: string,
+    retryLimit: number;
+    retryCount: number;
+    retryDelay: number;
+    retryBackoff: boolean;
+    startAfter: Date;
+    startedOn: Date;
+    singletonKey: string | null;
+    singletonOn: Date | null;
+    expireIn: PostgresInterval;
+    createdOn: Date;
+    completedOn: Date | null;
+    keepUntil: Date;
+    deadLetter: string,
+    policy: QueuePolicy,
     output: object
   }
 
@@ -314,10 +320,6 @@ declare class PgBoss extends EventEmitter {
   offWork(name: string): Promise<void>;
   offWork(options: PgBoss.OffWorkOptions): Promise<void>;
 
-  /**
-   * Notify worker that something has changed
-   * @param workerId
-   */
   notifyWorker(workerId: string): void;
 
   subscribe(event: string, name: string): Promise<void>;
@@ -348,15 +350,19 @@ declare class PgBoss extends EventEmitter {
   getQueueSize(name: string, options?: object): Promise<number>;
   getJobById(name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<PgBoss.JobWithMetadata | null>;
 
-  createQueue(name: string, options?: { policy: 'standard' | 'short' | 'singleton' | 'stately' }): Promise<void>;
+  createQueue(name: string, options?: PgBoss.Queue): Promise<void>;
+  getQueue(name: string): Promise<PgBoss.Queue | null>;
+  updateQueue(name: string, options?: PgBoss.QueueUpdateOptions): Promise<void>;
   deleteQueue(name: string): Promise<void>;
   purgeQueue(name: string): Promise<void>;
-  clearStorage(): Promise<void>;
 
+  clearStorage(): Promise<void>;
   archive(): Promise<void>;
   purge(): Promise<void>;
   expire(): Promise<void>;
   maintain(): Promise<void>;
+  isInstalled(): Promise<Boolean>;
+  schemaVersion(): Promise<Number>;
 
   schedule(name: string, cron: string, data?: object, options?: PgBoss.ScheduleOptions): Promise<void>;
   unschedule(name: string): Promise<void>;