pg-boss 10.0.0-beta6 → 10.0.0-beta8

package/package.json

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

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 }
   }
 
@@ -146,10 +135,11 @@ class Boss extends EventEmitter {
   }
 
   async countStates () {
-    const stateCountDefault = { ...plans.states }
+    const stateCountDefault = { ...plans.JOB_STATES }
 
-    Object.keys(stateCountDefault)
-      .forEach(key => { stateCountDefault[key] = 0 })
+    for (const key of Object.keys(stateCountDefault)) {
+      stateCountDefault[key] = 0
+    }
 
     const counts = await this.db.executeSql(this.countStatesCommand)
 

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/index.js

@@ -36,6 +36,9 @@ class PgBoss extends EventEmitter {
     return Contractor.rollbackPlans(schema, version)
   }
 
+  static states = plans.JOB_STATES
+  static policies = plans.QUEUE_POLICIES
+
   constructor (value) {
     super()
 
@@ -212,4 +215,3 @@ class PgBoss extends EventEmitter {
 }
 
 module.exports = PgBoss
-module.exports.states = plans.states

package/src/manager.js

@@ -10,7 +10,7 @@ const Worker = require('./worker')
 const plans = require('./plans')
 
 const { QUEUES: TIMEKEEPER_QUEUES } = require('./timekeeper')
-const { QUEUE_POLICY } = plans
+const { QUEUE_POLICIES } = plans
 
 const INTERNAL_QUEUES = Object.values(TIMEKEEPER_QUEUES).reduce((acc, i) => ({ ...acc, [i]: i }), {})
 
@@ -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) {
@@ -549,9 +545,9 @@ class Manager extends EventEmitter {
 
     Attorney.assertQueueName(name)
 
-    const { policy = QUEUE_POLICY.standard } = options
+    const { policy = QUEUE_POLICIES.standard } = options
 
-    assert(policy in QUEUE_POLICY, `${policy} is not a valid queue policy`)
+    assert(policy in QUEUE_POLICIES, `${policy} is not a valid queue policy`)
 
     const {
       retryLimit,
@@ -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

@@ -1,24 +1,22 @@
-const assert = require('assert')
+const DEFAULT_SCHEMA = 'pgboss'
+const MIGRATE_RACE_MESSAGE = 'division by zero'
+const CREATE_RACE_MESSAGE = 'already exists'
 
-const states = {
+const JOB_STATES = Object.freeze({
   created: 'created',
   retry: 'retry',
   active: 'active',
   completed: 'completed',
   cancelled: 'cancelled',
   failed: 'failed'
-}
+})
 
-const DEFAULT_SCHEMA = 'pgboss'
-const MIGRATE_RACE_MESSAGE = 'division by zero'
-const CREATE_RACE_MESSAGE = 'already exists'
-
-const QUEUE_POLICY = {
+const QUEUE_POLICIES = Object.freeze({
   standard: 'standard',
   short: 'short',
   singleton: 'singleton',
   stately: 'stately'
-}
+})
 
 module.exports = {
   create,
@@ -53,31 +51,28 @@ module.exports = {
   getQueueSize,
   purgeQueue,
   clearStorage,
-  getMaintenanceTime,
-  setMaintenanceTime,
-  getMonitorTime,
-  setMonitorTime,
-  getCronTime,
-  setCronTime,
+  trySetMaintenanceTime,
+  trySetMonitorTime,
+  trySetCronTime,
   locked,
-  advisoryLock,
   assertMigration,
   getArchivedJobById,
   getJobById,
-  QUEUE_POLICY,
-  states: { ...states },
+  QUEUE_POLICIES,
+  JOB_STATES,
   MIGRATE_RACE_MESSAGE,
   CREATE_RACE_MESSAGE,
   DEFAULT_SCHEMA
 }
 
+const assert = require('assert')
+
 function create (schema, version) {
   const commands = [
     createSchema(schema),
     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),
@@ -128,12 +122,12 @@ function createEnumJobState (schema) {
   // base type is numeric and first values are less than last values
   return `
     CREATE TYPE ${schema}.job_state AS ENUM (
-      '${states.created}',
-      '${states.retry}',
-      '${states.active}',
-      '${states.completed}',
-      '${states.cancelled}',
-      '${states.failed}'
+      '${JOB_STATES.created}',
+      '${JOB_STATES.retry}',
+      '${JOB_STATES.active}',
+      '${JOB_STATES.completed}',
+      '${JOB_STATES.cancelled}',
+      '${JOB_STATES.failed}'
     )
   `
 }
@@ -145,7 +139,7 @@ function createTableJob (schema) {
       name text not null,
       priority integer not null default(0),
       data jsonb,
-      state ${schema}.job_state not null default('${states.created}'),
+      state ${schema}.job_state not null default('${JOB_STATES.created}'),
       retry_limit integer not null default(0),
       retry_count integer not null default(0),
       retry_delay integer not null default(0),
@@ -238,31 +232,27 @@ function createPrimaryKeyArchive (schema) {
 }
 
 function createIndexJobPolicyShort (schema) {
-  return `CREATE UNIQUE INDEX job_policy_short ON ${schema}.job (name) WHERE state = '${states.created}' AND policy = '${QUEUE_POLICY.short}'`
+  return `CREATE UNIQUE INDEX job_policy_short ON ${schema}.job (name) WHERE state = '${JOB_STATES.created}' AND policy = '${QUEUE_POLICIES.short}'`
 }
 
 function createIndexJobPolicySingleton (schema) {
-  return `CREATE UNIQUE INDEX job_policy_singleton ON ${schema}.job (name) WHERE state = '${states.active}' AND policy = '${QUEUE_POLICY.singleton}'`
+  return `CREATE UNIQUE INDEX job_policy_singleton ON ${schema}.job (name) WHERE state = '${JOB_STATES.active}' AND policy = '${QUEUE_POLICIES.singleton}'`
 }
 
 function createIndexJobPolicyStately (schema) {
-  return `CREATE UNIQUE INDEX job_policy_stately ON ${schema}.job (name, state) WHERE state <= '${states.active}' AND policy = '${QUEUE_POLICY.stately}'`
+  return `CREATE UNIQUE INDEX job_policy_stately ON ${schema}.job (name, state) WHERE state <= '${JOB_STATES.active}' AND policy = '${QUEUE_POLICIES.stately}'`
 }
 
 function createIndexJobThrottleOn (schema) {
-  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`
+  return `CREATE UNIQUE INDEX job_throttle_on ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <= '${JOB_STATES.completed}' AND singleton_on IS NOT NULL`
 }
 
 function createIndexJobThrottleKey (schema) {
-  return `CREATE UNIQUE INDEX job_throttle_key ON ${schema}.job (name, singleton_key) WHERE state <= '${states.completed}' AND singleton_on 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 <= '${JOB_STATES.completed}' AND singleton_on IS NULL`
 }
 
 function createIndexJobFetch (schema) {
-  return `CREATE INDEX job_fetch ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < '${states.active}'`
+  return `CREATE INDEX job_fetch ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < '${JOB_STATES.active}'`
 }
 
 function createTableArchive (schema) {
@@ -277,33 +267,24 @@ function createIndexArchiveArchivedOn (schema) {
   return `CREATE INDEX archive_archived_on_idx ON ${schema}.archive(archived_on)`
 }
 
-function createIndexArchiveName (schema) {
-  return `CREATE INDEX archive_name_idx ON ${schema}.archive(name)`
+function trySetMaintenanceTime (schema) {
+  return trySetTimestamp(schema, 'maintained_on')
 }
 
-function getMaintenanceTime (schema) {
-  return `SELECT maintained_on, EXTRACT( EPOCH FROM (now() - maintained_on) ) seconds_ago FROM ${schema}.version`
+function trySetMonitorTime (schema) {
+  return trySetTimestamp(schema, 'monitored_on')
 }
 
-function setMaintenanceTime (schema) {
-  return `UPDATE ${schema}.version SET maintained_on = now()`
+function trySetCronTime (schema) {
+  return trySetTimestamp(schema, 'cron_on')
 }
 
-function getMonitorTime (schema) {
-  return `SELECT monitored_on, EXTRACT( EPOCH FROM (now() - monitored_on) ) seconds_ago FROM ${schema}.version`
-}
-
-function setMonitorTime (schema) {
-  return `UPDATE ${schema}.version SET monitored_on = now()`
-}
-
-function setCronTime (schema, time) {
-  time = time || 'now()'
-  return `UPDATE ${schema}.version SET cron_on = ${time}`
-}
-
-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) {
@@ -341,7 +322,7 @@ function deleteQueueRecords (schema) {
 }
 
 function purgeQueue (schema) {
-  return `DELETE from ${schema}.job WHERE name = $1 and state < '${states.active}'`
+  return `DELETE from ${schema}.job WHERE name = $1 and state < '${JOB_STATES.active}'`
 }
 
 function clearStorage (schema) {
@@ -349,8 +330,8 @@ function clearStorage (schema) {
 }
 
 function getQueueSize (schema, options = {}) {
-  options.before = options.before || states.active
-  assert(options.before in states, `${options.before} is not a valid state`)
+  options.before = options.before || JOB_STATES.active
+  assert(options.before in JOB_STATES, `${options.before} is not a valid state`)
   return `SELECT count(*) as count FROM ${schema}.job WHERE name = $1 AND state < '${options.before}'`
 }
 
@@ -475,14 +456,14 @@ function fetchNextJob (schema) {
       SELECT id
       FROM ${schema}.job
       WHERE name = $1
-        AND state < '${states.active}'
+        AND state < '${JOB_STATES.active}'
         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}',
+      state = '${JOB_STATES.active}',
       started_on = now(),
       retry_count = CASE WHEN started_on IS NOT NULL THEN retry_count + 1 ELSE retry_count END
     FROM next
@@ -496,11 +477,11 @@ function completeJobs (schema) {
     WITH results AS (
       UPDATE ${schema}.job
       SET completed_on = now(),
-        state = '${states.completed}',
+        state = '${JOB_STATES.completed}',
         output = $3::jsonb
       WHERE name = $1
         AND id IN (SELECT UNNEST($2::uuid[]))
-        AND state = '${states.active}'
+        AND state = '${JOB_STATES.active}'
       RETURNING *
     )
     SELECT COUNT(*) FROM results
@@ -508,14 +489,14 @@ function completeJobs (schema) {
 }
 
 function failJobsById (schema) {
-  const where = `name = $1 AND id IN (SELECT UNNEST($2::uuid[])) AND state < '${states.completed}'`
+  const where = `name = $1 AND id IN (SELECT UNNEST($2::uuid[])) AND state < '${JOB_STATES.completed}'`
   const output = '$3::jsonb'
 
   return failJobs(schema, where, output)
 }
 
 function failJobsByTimeout (schema) {
-  const where = `state = '${states.active}' AND (started_on + expire_in) < now()`
+  const where = `state = '${JOB_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)
 }
@@ -525,8 +506,8 @@ function failJobs (schema, where, output) {
     WITH results AS (
       UPDATE ${schema}.job SET
         state = CASE
-          WHEN retry_count < retry_limit THEN '${states.retry}'::${schema}.job_state
-          ELSE '${states.failed}'::${schema}.job_state
+          WHEN retry_count < retry_limit THEN '${JOB_STATES.retry}'::${schema}.job_state
+          ELSE '${JOB_STATES.failed}'::${schema}.job_state
           END,
         completed_on = CASE
           WHEN retry_count < retry_limit THEN NULL
@@ -552,7 +533,7 @@ function failJobs (schema, where, output) {
         retry_limit,
         keep_until + (keep_until - start_after)
       FROM results
-      WHERE state = '${states.failed}'
+      WHERE state = '${JOB_STATES.failed}'
         AND dead_letter IS NOT NULL
         AND NOT name = dead_letter
     )
@@ -565,10 +546,10 @@ function cancelJobs (schema) {
     with results as (
       UPDATE ${schema}.job
       SET completed_on = now(),
-        state = '${states.cancelled}'
+        state = '${JOB_STATES.cancelled}'
       WHERE name = $1
         AND id IN (SELECT UNNEST($2::uuid[]))
-        AND state < '${states.completed}'
+        AND state < '${JOB_STATES.completed}'
       RETURNING 1
     )
     SELECT COUNT(*) from results
@@ -580,7 +561,7 @@ function resumeJobs (schema) {
     with results as (
       UPDATE ${schema}.job
       SET completed_on = NULL,
-        state = '${states.created}'
+        state = '${JOB_STATES.created}'
       WHERE name = $1
         AND id IN (SELECT UNNEST($2::uuid[]))
       RETURNING 1
@@ -750,9 +731,9 @@ function archive (schema, completedInterval, failedInterval = completedInterval)
   return `
     WITH archived_rows AS (
       DELETE FROM ${schema}.job
-      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())
+      WHERE (state <> '${JOB_STATES.failed}' AND completed_on < (now() - interval '${completedInterval}'))
+        OR (state = '${JOB_STATES.failed}' AND completed_on < (now() - interval '${failedInterval}'))
+        OR (state < '${JOB_STATES.active}' AND keep_until < now())
       RETURNING *
     )
     INSERT INTO ${schema}.archive (${columns})
@@ -777,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;

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

@@ -1,8 +1,24 @@
 import { EventEmitter } from 'events'
 
 declare namespace PgBoss {
+  
+  type JobStates = {
+    created : 'created',
+    retry: 'retry',
+    active: 'active',
+    completed: 'completed',
+    cancelled: 'cancelled',
+    failed: 'failed'
+  }
+
+  type QueuePolicies = {
+    standard: 'standard'
+    short: 'short',
+    singleton: 'singleton',
+    stately: 'stately'
+  }
   interface Db {
-    executeSql(text: string, values: any[]): Promise<{ rows: any[]; rowCount: number }>;
+    executeSql(text: string, values: any[]): Promise<{ rows: any[] }>;
   }
 
   interface DatabaseOptions {
@@ -91,10 +107,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 }
 
@@ -195,7 +215,7 @@ declare namespace PgBoss {
     completedOn: Date | null;
     keepUntil: Date;
     deadLetter: string,
-    policy: string,
+    policy: QueuePolicy,
     output: object
   }
 
@@ -271,6 +291,9 @@ declare class PgBoss extends EventEmitter {
   static getRollbackPlans(schema: string): string;
   static getRollbackPlans(): 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;
 
@@ -316,10 +339,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>;
@@ -350,15 +369,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>;