pg-boss 11.1.2 → 12.0.0-beta2

package/src/attorney.js

@@ -1,258 +0,0 @@
-const assert = require('node:assert')
-const { DEFAULT_SCHEMA } = require('./plans')
-
-const POLICY = {
-  MAX_EXPIRATION_HOURS: 24,
-  MIN_POLLING_INTERVAL_MS: 500,
-  MAX_RETENTION_DAYS: 365
-}
-
-module.exports = {
-  POLICY,
-  getConfig,
-  checkSendArgs,
-  validateQueueArgs,
-  checkWorkArgs,
-  checkFetchArgs,
-  assertPostgresObjectName,
-  assertQueueName,
-  assertKey
-}
-
-function validateQueueArgs (config = {}) {
-  assert(!('deadLetter' in config) || config.deadLetter === null || (typeof config.deadLetter === 'string'), 'deadLetter must be a string')
-  assert(!('deadLetter' in config) || config.deadLetter === null || /[\w-]/.test(config.deadLetter), 'deadLetter can only contain alphanumeric characters, underscores, or hyphens')
-
-  validateRetryConfig(config)
-  validateExpirationConfig(config)
-  validateRetentionConfig(config)
-  validateDeletionConfig(config)
-}
-
-function checkSendArgs (args) {
-  let name, data, options
-
-  if (typeof args[0] === 'string') {
-    name = args[0]
-    data = args[1]
-
-    assert(typeof data !== 'function', 'send() cannot accept a function as the payload.  Did you intend to use work()?')
-
-    options = args[2]
-  } else if (typeof args[0] === 'object') {
-    assert(args.length === 1, 'send object API only accepts 1 argument')
-
-    const job = args[0]
-
-    assert(job, 'boss requires all jobs to have a name')
-
-    name = job.name
-    data = job.data
-    options = job.options
-  }
-
-  options = options || {}
-
-  assert(name, 'boss requires all jobs to have a queue name')
-  assert(typeof options === 'object', 'options should be an object')
-
-  options = { ...options }
-
-  assert(!('priority' in options) || (Number.isInteger(options.priority)), 'priority must be an integer')
-  options.priority = options.priority || 0
-
-  options.startAfter = (options.startAfter instanceof Date && typeof options.startAfter.toISOString === 'function')
-    ? options.startAfter.toISOString()
-    : (options.startAfter > 0)
-        ? '' + options.startAfter
-        : (typeof options.startAfter === 'string')
-            ? options.startAfter
-            : null
-
-  validateRetryConfig(options)
-  validateExpirationConfig(options)
-  validateRetentionConfig(options)
-  validateDeletionConfig(options)
-
-  return { name, data, options }
-}
-
-function checkWorkArgs (name, args) {
-  let options, callback
-
-  assert(name, 'missing job name')
-
-  if (args.length === 1) {
-    callback = args[0]
-    options = {}
-  } else if (args.length > 1) {
-    options = args[0] || {}
-    callback = args[1]
-  }
-
-  assert(typeof callback === 'function', 'expected callback to be a function')
-  assert(typeof options === 'object', 'expected config to be an object')
-
-  options = { ...options }
-
-  applyPollingInterval(options)
-
-  assert(!('batchSize' in options) || (Number.isInteger(options.batchSize) && options.batchSize >= 1), 'batchSize must be an integer > 0')
-  assert(!('includeMetadata' in options) || typeof options.includeMetadata === 'boolean', 'includeMetadata must be a boolean')
-  assert(!('priority' in options) || typeof options.priority === 'boolean', 'priority must be a boolean')
-
-  options.batchSize = options.batchSize || 1
-
-  return { options, callback }
-}
-
-function checkFetchArgs (name, options) {
-  assert(name, 'missing queue name')
-
-  assert(!('batchSize' in options) || (Number.isInteger(options.batchSize) && options.batchSize >= 1), 'batchSize must be an integer > 0')
-  assert(!('includeMetadata' in options) || typeof options.includeMetadata === 'boolean', 'includeMetadata must be a boolean')
-  assert(!('priority' in options) || typeof options.priority === 'boolean', 'priority must be a boolean')
-  assert(!('ignoreStartAfter' in options) || typeof options.ignoreStartAfter === 'boolean', 'ignoreStartAfter must be a boolean')
-
-  options.batchSize = options.batchSize || 1
-}
-
-function getConfig (value) {
-  assert(value && (typeof value === 'object' || typeof value === 'string'),
-    'configuration assert: string or config object is required to connect to postgres')
-
-  const config = (typeof value === 'string')
-    ? { 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)
-  applyOpsConfig(config)
-  applyScheduleConfig(config)
-  validateWarningConfig(config)
-
-  return config
-}
-
-function applySchemaConfig (config) {
-  if (config.schema) {
-    assertPostgresObjectName(config.schema)
-  }
-
-  config.schema = config.schema || DEFAULT_SCHEMA
-}
-
-function validateWarningConfig (config) {
-  assert(!('warningQueueSize' in config) || config.warningQueueSize >= 1,
-    'configuration assert: warningQueueSize must be at least 1')
-
-  assert(!('warningSlowQuerySeconds' in config) || config.warningSlowQuerySeconds >= 1,
-    'configuration assert: warningSlowQuerySeconds must be at least 1')
-}
-
-function assertPostgresObjectName (name) {
-  assert(typeof name === 'string', 'Name must be a string')
-  assert(name.length <= 50, 'Name cannot exceed 50 characters')
-  assert(!/\W/.test(name), 'Name can only contain alphanumeric characters or underscores')
-  assert(!/^\d/.test(name), 'Name cannot start with a number')
-}
-
-function assertQueueName (name) {
-  assert(name, 'Name is required')
-  assert(typeof name === 'string', 'Name must be a string')
-  assert(/[\w-]/.test(name), 'Name can only contain alphanumeric characters, underscores, or hyphens')
-}
-
-function assertKey (key) {
-  if (!key) return
-  assert(typeof key === 'string', 'Key must be a string')
-  assert(/[\w-]/.test(key), 'Key can only contain alphanumeric characters, underscores, or hyphens')
-}
-
-function validateRetentionConfig (config) {
-  assert(!('retentionSeconds' in config) || config.retentionSeconds >= 1,
-    'configuration assert: retentionSeconds must be at least every second')
-}
-
-function validateExpirationConfig (config) {
-  assert(!('expireInSeconds' in config) || config.expireInSeconds >= 1,
-    'configuration assert: expireInSeconds must be at least every second')
-
-  assert(!config.expireInSeconds || config.expireInSeconds / 60 / 60 < POLICY.MAX_EXPIRATION_HOURS, `configuration assert: expiration cannot exceed ${POLICY.MAX_EXPIRATION_HOURS} hours`)
-}
-
-function validateRetryConfig (config) {
-  assert(!('retryDelay' in config) || (Number.isInteger(config.retryDelay) && config.retryDelay >= 0), 'retryDelay must be an integer >= 0')
-  assert(!('retryLimit' in config) || (Number.isInteger(config.retryLimit) && config.retryLimit >= 0), 'retryLimit must be an integer >= 0')
-  assert(!('retryBackoff' in config) || (config.retryBackoff === true || config.retryBackoff === false), 'retryBackoff must be either true or false')
-  assert(!('retryDelayMax' in config) || config.retryDelayMax === null || config.retryBackoff === true, 'retryDelayMax can only be set if retryBackoff is true')
-  assert(!('retryDelayMax' in config) || config.retryDelayMax === null || (Number.isInteger(config.retryDelayMax) && config.retryDelayMax >= 0), 'retryDelayMax must be an integer >= 0')
-}
-
-function applyPollingInterval (config) {
-  assert(!('pollingIntervalSeconds' in config) || config.pollingIntervalSeconds >= POLICY.MIN_POLLING_INTERVAL_MS / 1000,
-    `configuration assert: pollingIntervalSeconds must be at least every ${POLICY.MIN_POLLING_INTERVAL_MS}ms`)
-
-  config.pollingInterval = ('pollingIntervalSeconds' in config)
-    ? config.pollingIntervalSeconds * 1000
-    : 2000
-}
-
-function applyOpsConfig (config) {
-  assert(!('superviseIntervalSeconds' in config) || config.superviseIntervalSeconds >= 1,
-    'configuration assert: superviseIntervalSeconds must be at least every second')
-
-  config.superviseIntervalSeconds = config.superviseIntervalSeconds || 60
-
-  assert(config.superviseIntervalSeconds / 60 / 60 <= POLICY.MAX_EXPIRATION_HOURS,
-    `configuration assert: superviseIntervalSeconds cannot exceed ${POLICY.MAX_EXPIRATION_HOURS} hours`)
-
-  assert(!('maintenanceIntervalSeconds' in config) || config.maintenanceIntervalSeconds >= 1,
-    'configuration assert: maintenanceIntervalSeconds must be at least every second')
-
-  config.maintenanceIntervalSeconds = config.maintenanceIntervalSeconds || POLICY.MAX_EXPIRATION_HOURS * 60 * 60
-
-  assert(config.maintenanceIntervalSeconds / 60 / 60 <= POLICY.MAX_EXPIRATION_HOURS,
-    `configuration assert: maintenanceIntervalSeconds cannot exceed ${POLICY.MAX_EXPIRATION_HOURS} hours`)
-
-  assert(!('monitorIntervalSeconds' in config) || config.monitorIntervalSeconds >= 1,
-    'configuration assert: monitorIntervalSeconds must be at least every second')
-
-  config.monitorIntervalSeconds = config.monitorIntervalSeconds || 60
-
-  assert(config.monitorIntervalSeconds / 60 / 60 <= POLICY.MAX_EXPIRATION_HOURS,
-    `configuration assert: monitorIntervalSeconds cannot exceed ${POLICY.MAX_EXPIRATION_HOURS} hours`)
-
-  assert(!('queueCacheIntervalSeconds' in config) || config.queueCacheIntervalSeconds >= 1,
-    'configuration assert: queueCacheIntervalSeconds must be at least every second')
-
-  config.queueCacheIntervalSeconds = config.queueCacheIntervalSeconds || 60
-
-  assert(config.queueCacheIntervalSeconds / 60 / 60 <= POLICY.MAX_EXPIRATION_HOURS,
-    `configuration assert: queueCacheIntervalSeconds cannot exceed ${POLICY.MAX_EXPIRATION_HOURS} hours`)
-}
-
-function validateDeletionConfig (config) {
-  assert(!('deleteAfterSeconds' in config) || config.deleteAfterSeconds >= 1,
-    'configuration assert: deleteAfterSeconds must be at least every second')
-}
-
-function applyScheduleConfig (config) {
-  assert(!('clockMonitorIntervalSeconds' in config) || (config.clockMonitorIntervalSeconds >= 1 && config.clockMonitorIntervalSeconds <= 600),
-    'configuration assert: clockMonitorIntervalSeconds must be between 1 second and 10 minutes')
-
-  config.clockMonitorIntervalSeconds = config.clockMonitorIntervalSeconds || 600
-
-  assert(!('cronMonitorIntervalSeconds' in config) || (config.cronMonitorIntervalSeconds >= 1 && config.cronMonitorIntervalSeconds <= 45),
-    'configuration assert: cronMonitorIntervalSeconds must be between 1 and 45 seconds')
-
-  config.cronMonitorIntervalSeconds = config.cronMonitorIntervalSeconds || 30
-
-  assert(!('cronWorkerIntervalSeconds' in config) || (config.cronWorkerIntervalSeconds >= 1 && config.cronWorkerIntervalSeconds <= 45),
-    'configuration assert: cronWorkerIntervalSeconds must be between 1 and 45 seconds')
-
-  config.cronWorkerIntervalSeconds = config.cronWorkerIntervalSeconds || 5
-}

package/src/boss.js

@@ -1,158 +0,0 @@
-const EventEmitter = require('node:events')
-const plans = require('./plans')
-const { unwrapSQLResult } = require('./tools')
-
-const events = {
-  error: 'error',
-  warning: 'warning'
-}
-
-const WARNINGS = {
-  SLOW_QUERY: { seconds: 30, message: 'Warning: slow query. Your queues and/or database server should be reviewed' },
-  LARGE_QUEUE: { size: 10_000, mesasge: 'Warning: large queue backlog. Your queue should be reviewed' }
-}
-
-class Boss extends EventEmitter {
-  #stopped
-  #maintaining
-  #superviseInterval
-  #db
-  #config
-  #manager
-
-  constructor (db, config) {
-    super()
-
-    this.#db = db
-    this.#config = config
-    this.#manager = config.manager
-    this.#stopped = true
-
-    this.events = events
-    this.functions = [
-      this.supervise
-    ]
-
-    if (config.warningSlowQuerySeconds) {
-      WARNINGS.SLOW_QUERY.seconds = config.warningSlowQuerySeconds
-    }
-
-    if (config.warningQueueSize) {
-      WARNINGS.LARGE_QUEUE.size = config.warningQueueSize
-    }
-  }
-
-  async start () {
-    if (this.#stopped) {
-      this.#superviseInterval = setInterval(() => this.#onSupervise(), this.#config.superviseIntervalSeconds * 1000)
-      this.#stopped = false
-    }
-  }
-
-  async stop () {
-    if (!this.#stopped) {
-      if (this.#superviseInterval) clearInterval(this.#superviseInterval)
-      this.#stopped = true
-    }
-  }
-
-  async #executeSql (sql, values) {
-    const started = Date.now()
-
-    const result = unwrapSQLResult(await this.#db.executeSql(sql, values))
-
-    const ended = Date.now()
-
-    const elapsed = (ended - started) / 1000
-
-    if (elapsed > WARNINGS.SLOW_QUERY.seconds || this.#config.__test__warn_slow_query) {
-      this.emit(events.warning, { message: WARNINGS.SLOW_QUERY.message, data: { elapsed, sql, values } })
-    }
-
-    return result
-  }
-
-  async #onSupervise () {
-    try {
-      if (this.#stopped) return
-      if (this.#maintaining) return
-      if (this.#config.__test__throw_maint) throw new Error(this.#config.__test__throw_maint)
-
-      this.#maintaining = true
-
-      const queues = await this.#manager.getQueues()
-
-      for (const queue of queues) {
-        !this.#stopped && await this.supervise(queue)
-      }
-    } catch (err) {
-      this.emit(events.error, err)
-    } finally {
-      this.#maintaining = false
-    }
-  }
-
-  async supervise (value) {
-    let queues
-
-    if (!value) {
-      queues = await this.#manager.getQueues()
-    } if (typeof value === 'string') {
-      queues = await this.#manager.getQueues(value)
-    } else if (typeof value === 'object') {
-      queues = [value]
-    }
-
-    const queueGroups = queues.reduce((acc, q) => {
-      const { table } = q
-      acc[table] = acc[table] || { table, queues: [] }
-      acc[table].queues.push(q)
-      return acc
-    }, {})
-
-    for (const queueGroup of Object.values(queueGroups)) {
-      const { table, queues } = queueGroup
-      const names = queues.map(i => i.name)
-
-      while (names.length) {
-        const chunk = names.splice(0, 100)
-
-        await this.#monitor(table, chunk)
-        await this.#maintain(table, chunk)
-      }
-    }
-  }
-
-  async #monitor (table, names) {
-    const command = plans.trySetQueueMonitorTime(this.#config.schema, names, this.#config.monitorIntervalSeconds)
-    const { rows } = await this.#executeSql(command)
-
-    if (rows.length) {
-      const queues = rows.map(q => q.name)
-
-      const cacheStatsSql = plans.cacheQueueStats(this.#config.schema, table, queues)
-      const { rows: rowsCacheStats } = await this.#executeSql(cacheStatsSql)
-      const warnings = rowsCacheStats.filter(i => i.queuedCount > (i.warningQueueSize || WARNINGS.LARGE_QUEUE.size))
-
-      for (const warning of warnings) {
-        this.emit(events.warning, { message: WARNINGS.LARGE_QUEUE.mesasge, data: warning })
-      }
-
-      const sql = plans.failJobsByTimeout(this.#config.schema, table, queues)
-      await this.#executeSql(sql)
-    }
-  }
-
-  async #maintain (table, names) {
-    const command = plans.trySetQueueDeletionTime(this.#config.schema, names, this.#config.maintenanceIntervalSeconds)
-    const { rows } = await this.#executeSql(command)
-
-    if (rows.length) {
-      const queues = rows.map(q => q.name)
-      const sql = plans.deletion(this.#config.schema, table, queues)
-      await this.#executeSql(sql)
-    }
-  }
-}
-
-module.exports = Boss

package/src/contractor.js

@@ -1,99 +0,0 @@
-const assert = require('node:assert')
-const plans = require('./plans')
-const { DEFAULT_SCHEMA } = plans
-const migrationStore = require('./migrationStore')
-const schemaVersion = require('../version.json').schema
-
-class Contractor {
-  static constructionPlans (schema = DEFAULT_SCHEMA) {
-    return plans.create(schema, schemaVersion)
-  }
-
-  static migrationPlans (schema = DEFAULT_SCHEMA, version = schemaVersion - 1) {
-    return migrationStore.migrate(schema, version)
-  }
-
-  static rollbackPlans (schema = DEFAULT_SCHEMA, version = schemaVersion) {
-    return migrationStore.rollback(schema, version)
-  }
-
-  constructor (db, config) {
-    this.config = config
-    this.db = db
-    this.migrations = this.config.migrations || migrationStore.getAll(this.config.schema)
-
-    // exported api to index
-    this.functions = [
-      this.schemaVersion,
-      this.isInstalled
-    ]
-  }
-
-  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[0].name
-  }
-
-  async start () {
-    const installed = await this.isInstalled()
-
-    if (installed) {
-      const version = await this.schemaVersion()
-
-      if (schemaVersion > version) {
-        await this.migrate(version)
-      }
-    } else {
-      await this.create()
-    }
-  }
-
-  async check () {
-    const installed = await this.isInstalled()
-
-    if (!installed) {
-      throw new Error('pg-boss is not installed')
-    }
-
-    const version = await this.schemaVersion()
-
-    if (schemaVersion !== version) {
-      throw new Error('pg-boss database requires migrations')
-    }
-  }
-
-  async create () {
-    try {
-      const commands = plans.create(this.config.schema, schemaVersion)
-      await this.db.executeSql(commands)
-    } catch (err) {
-      assert(err.message.includes(plans.CREATE_RACE_MESSAGE), err)
-    }
-  }
-
-  async migrate (version) {
-    try {
-      const commands = migrationStore.migrate(this.config, version, this.migrations)
-      await this.db.executeSql(commands)
-    } catch (err) {
-      assert(err.message.includes(plans.MIGRATE_RACE_MESSAGE), err)
-    }
-  }
-
-  async next (version) {
-    const commands = migrationStore.next(this.config.schema, version, this.migrations)
-    await this.db.executeSql(commands)
-  }
-
-  async rollback (version) {
-    const commands = migrationStore.rollback(this.config.schema, version, this.migrations)
-    await this.db.executeSql(commands)
-  }
-}
-
-module.exports = Contractor

package/src/db.js

@@ -1,50 +0,0 @@
-const EventEmitter = require('node:events')
-const pg = require('pg')
-
-class Db extends EventEmitter {
-  constructor (config) {
-    super()
-
-    config.application_name = config.application_name || 'pgboss'
-    // config.maxUses = config.maxUses || 1000
-
-    this.config = config
-    this._pgbdb = true
-    this.opened = false
-  }
-
-  events = {
-    error: 'error'
-  }
-
-  async open () {
-    this.pool = new pg.Pool(this.config)
-    this.pool.on('error', error => this.emit('error', error))
-    this.opened = true
-  }
-
-  async close () {
-    if (!this.pool.ending) {
-      this.opened = false
-      await this.pool.end()
-    }
-  }
-
-  async executeSql (text, values) {
-    if (this.opened) {
-      // if (this.config.debug === true) {
-      //   console.log(`${new Date().toISOString()}: DEBUG SQL`)
-      //   console.log(text)
-
-      //   if (values) {
-      //     console.log(`${new Date().toISOString()}: DEBUG VALUES`)
-      //     console.log(values)
-      //   }
-      // }
-
-      return await this.pool.query(text, values)
-    }
-  }
-}
-
-module.exports = Db