pg-boss 10.0.0-beta2 → 10.0.0-beta4

package/README.md

@@ -9,24 +9,23 @@ async function readme() {
   const PgBoss = require('pg-boss');
   const boss = new PgBoss('postgres://user:pass@host/database');
 
-  boss.on('error', error => console.error(error));
+  boss.on('error', console.error)
 
-  await boss.start();
+  await boss.start()
 
-  const queue = 'some-queue';
+  const queue = 'readme-queue'
 
-  let jobId = await boss.send(queue, { param1: 'foo' })
+  try {
+    await boss.createQueue(queue)
+  } catch {}
 
-  console.log(`created job in queue ${queue}: ${jobId}`);
+  const id = await boss.send(queue, { arg1: 'read me' })
 
-  await boss.work(queue, someAsyncJobHandler);
-}
-
-async function someAsyncJobHandler(job) {
-  console.log(`job ${job.id} received with data:`);
-  console.log(JSON.stringify(job.data));
+  console.log(`created job ${id} in queue ${queue}`)
 
-  await doSomethingAsyncWithThis(job.data);
+  await boss.work(queue, async job => {
+    console.log(`received job ${job.id} with data ${JSON.stringify(job.data)}`)
+  })
 }
 ```
 

package/package.json

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

package/src/attorney.js

@@ -8,7 +8,8 @@ module.exports = {
   checkWorkArgs,
   checkFetchArgs,
   warnClockSkew,
-  assertPostgresObjectName
+  assertPostgresObjectName,
+  assertQueueName
 }
 
 const MAX_INTERVAL_HOURS = 24
@@ -29,8 +30,6 @@ const WARNINGS = {
 }
 
 function checkQueueArgs (name, options = {}) {
-  assertPostgresObjectName(name)
-
   assert(!('deadLetter' in options) || (typeof options.deadLetter === 'string'), 'deadLetter must be a string')
 
   applyRetryConfig(options)
@@ -178,8 +177,14 @@ function applySchemaConfig (config) {
 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 and underscores')
-  assert(!/^d/.test(name), 'Name cannot start with a number')
+  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(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, underscores, or hyphens')
 }
 
 function applyArchiveConfig (config) {
@@ -363,21 +368,21 @@ function applyMonitoringConfig (config) {
           ? config.clockMonitorIntervalSeconds
           : TEN_MINUTES_IN_SECONDS
 
-  assert(!('cronMonitorIntervalSeconds' in config) || (config.cronMonitorIntervalSeconds >= 1 && config.cronMonitorIntervalSeconds <= 60),
-    'configuration assert: cronMonitorIntervalSeconds must be between 1 and 60 seconds')
+  assert(!('cronMonitorIntervalSeconds' in config) || (config.cronMonitorIntervalSeconds >= 1 && config.cronMonitorIntervalSeconds <= 45),
+    'configuration assert: cronMonitorIntervalSeconds must be between 1 and 45 seconds')
 
   config.cronMonitorIntervalSeconds =
     ('cronMonitorIntervalSeconds' in config)
       ? config.cronMonitorIntervalSeconds
-      : 60
+      : 30
 
-  assert(!('cronWorkerIntervalSeconds' in config) || (config.cronWorkerIntervalSeconds >= 1 && config.cronWorkerIntervalSeconds <= 60),
-    'configuration assert: cronWorkerIntervalSeconds must be between 1 and 60 seconds')
+  assert(!('cronWorkerIntervalSeconds' in config) || (config.cronWorkerIntervalSeconds >= 1 && config.cronWorkerIntervalSeconds <= 45),
+    'configuration assert: cronWorkerIntervalSeconds must be between 1 and 45 seconds')
 
   config.cronWorkerIntervalSeconds =
     ('cronWorkerIntervalSeconds' in config)
       ? config.cronWorkerIntervalSeconds
-      : 4
+      : 5
 }
 
 function warnClockSkew (message) {

package/src/boss.js

@@ -77,10 +77,7 @@ class Boss extends EventEmitter {
     } catch (err) {
       this.emit(events.error, err)
     } finally {
-      if (locker?.locked) {
-        await locker.unlock()
-      }
-
+      await locker?.unlock()
       this.monitoring = false
     }
   }
@@ -119,10 +116,7 @@ class Boss extends EventEmitter {
     } catch (err) {
       this.emit(events.error, err)
     } finally {
-      if (locker?.locked) {
-        await locker.unlock()
-      }
-
+      await locker?.unlock()
       this.maintaining = false
     }
   }

package/src/contractor.js

@@ -21,6 +21,12 @@ class Contractor {
     this.config = config
     this.db = db
     this.migrations = this.config.migrations || migrationStore.getAll(this.config.schema)
+
+    // exported api to index
+    this.functions = [
+      this.version,
+      this.isInstalled
+    ]
   }
 
   async version () {

package/src/db.js

@@ -11,6 +11,10 @@ class Db extends EventEmitter {
     this.config = config
   }
 
+  events = {
+    error: 'error'
+  }
+
   async open () {
     this.pool = new pg.Pool(this.config)
     this.pool.on('error', error => this.emit('error', error))
@@ -41,27 +45,23 @@ class Db extends EventEmitter {
   }
 
   async lock ({ timeout = 30, key } = {}) {
-    // const lockedClient = new pg.Client(this.config)
-    // await lockedClient.connect()
     const lockedClient = await this.pool.connect()
 
     const query = `
         BEGIN;
         SET LOCAL lock_timeout = '${timeout}s';
-        SET LOCAL idle_in_transaction_session_timeout = '3600s';
+        SET LOCAL idle_in_transaction_session_timeout = '${timeout}s';
         ${advisoryLock(this.config.schema, key)};
     `
 
     await lockedClient.query(query)
 
     const locker = {
-      locked: true,
       unlock: async function () {
         try {
           await lockedClient.query('COMMIT')
-          await lockedClient.end()
         } finally {
-          this.locked = false
+          lockedClient.release()
         }
       }
     }

package/src/index.js

@@ -13,6 +13,17 @@ const events = {
   stopped: 'stopped'
 }
 class PgBoss extends EventEmitter {
+  #stoppingOn
+  #stopped
+  #starting
+  #started
+  #config
+  #db
+  #boss
+  #contractor
+  #manager
+  #timekeeper
+
   static getConstructionPlans (schema) {
     return Contractor.constructionPlans(schema)
   }
@@ -26,100 +37,112 @@ class PgBoss extends EventEmitter {
   }
 
   constructor (value) {
-    const config = Attorney.getConfig(value)
-
     super()
 
-    const db = getDb(config)
+    this.#stoppingOn = null
+    this.#stopped = true
+
+    const config = Attorney.getConfig(value)
+    this.#config = config
+
+    const db = this.getDb()
+    this.#db = db
 
     if (db.isOurs) {
-      promoteEvent.call(this, db, 'error')
+      this.#promoteEvents(db)
     }
 
-    const manager = new Manager(db, config)
-    Object.keys(manager.events).forEach(event => promoteEvent.call(this, manager, manager.events[event]))
-    manager.functions.forEach(func => promoteFunction.call(this, manager, func))
+    const contractor = new Contractor(db, config)
 
+    const manager = new Manager(db, config)
     const bossConfig = { ...config, manager }
 
     const boss = new Boss(db, bossConfig)
-    Object.keys(boss.events).forEach(event => promoteEvent.call(this, boss, boss.events[event]))
-    boss.functions.forEach(func => promoteFunction.call(this, boss, func))
 
     const timekeeper = new Timekeeper(db, bossConfig)
-    Object.keys(timekeeper.events).forEach(event => promoteEvent.call(this, timekeeper, timekeeper.events[event]))
-    timekeeper.functions.forEach(func => promoteFunction.call(this, timekeeper, func))
-
     manager.timekeeper = timekeeper
 
-    this.stoppingOn = null
-    this.stopped = true
-    this.config = config
-    this.db = db
-    this.boss = boss
-    this.contractor = new Contractor(db, config)
-    this.manager = manager
-    this.timekeeper = timekeeper
-
-    function getDb (config) {
-      if (config.db) {
-        return config.db
-      }
+    this.#promoteEvents(manager)
+    this.#promoteEvents(boss)
+    this.#promoteEvents(timekeeper)
 
-      const db = new Db(config)
-      db.isOurs = true
-      return db
+    this.#promoteFunctions(boss)
+    this.#promoteFunctions(contractor)
+    this.#promoteFunctions(manager)
+    this.#promoteFunctions(timekeeper)
+
+    this.#boss = boss
+    this.#contractor = contractor
+    this.#manager = manager
+    this.#timekeeper = timekeeper
+  }
+
+  getDb () {
+    if (this.#db) {
+      return this.#db
     }
 
-    function promoteFunction (obj, func) {
-      this[func.name] = (...args) => func.apply(obj, args)
+    if (this.#config.db) {
+      return this.#config.db
     }
 
-    function promoteEvent (emitter, event) {
+    const db = new Db(this.#config)
+    db.isOurs = true
+    return db
+  }
+
+  #promoteEvents (emitter) {
+    for (const event of Object.values(emitter?.events)) {
       emitter.on(event, arg => this.emit(event, arg))
     }
   }
 
+  #promoteFunctions (obj) {
+    for (const func of obj?.functions) {
+      this[func.name] = (...args) => func.apply(obj, args)
+    }
+  }
+
   async start () {
-    if (this.starting || this.started) {
+    if (this.#starting || this.#started) {
       return
     }
 
-    this.starting = true
+    this.#starting = true
 
-    if (this.db.isOurs && !this.db.opened) {
-      await this.db.open()
+    if (this.#db.isOurs && !this.#db.opened) {
+      await this.#db.open()
     }
 
-    if (this.config.migrate) {
-      await this.contractor.start()
+    if (this.#config.migrate) {
+      await this.#contractor.start()
     } else {
-      await this.contractor.check()
+      await this.#contractor.check()
     }
 
-    this.manager.start()
+    this.#manager.start()
 
-    if (this.config.supervise) {
-      await this.boss.supervise()
+    if (this.#config.supervise) {
+      await this.#boss.supervise()
     }
 
-    if (this.config.monitorStateIntervalSeconds) {
-      await this.boss.monitor()
+    if (this.#config.monitorStateIntervalSeconds) {
+      await this.#boss.monitor()
     }
 
-    if (this.config.schedule) {
-      await this.timekeeper.start()
+    if (this.#config.schedule) {
+      await this.#timekeeper.start()
     }
 
-    this.starting = false
-    this.started = true
-    this.stopped = false
+    this.#starting = false
+    this.#started = true
+    this.#stopped = false
 
     return this
   }
 
   async stop (options = {}) {
-    if (this.stoppingOn || this.stopped) {
+    if (this.#stoppingOn || this.#stopped) {
       return
     }
 
@@ -127,28 +150,28 @@ class PgBoss extends EventEmitter {
 
     timeout = Math.max(timeout, 1000)
 
-    this.stoppingOn = Date.now()
+    this.#stoppingOn = Date.now()
 
-    await this.manager.stop()
-    await this.timekeeper.stop()
-    await this.boss.stop()
+    await this.#manager.stop()
+    await this.#timekeeper.stop()
+    await this.#boss.stop()
 
     await new Promise((resolve, reject) => {
       const shutdown = async () => {
         try {
-          if (this.config.__test__throw_shutdown) {
-            throw new Error(this.config.__test__throw_shutdown)
+          if (this.#config.__test__throw_shutdown) {
+            throw new Error(this.#config.__test__throw_shutdown)
           }
 
-          await this.manager.failWip()
+          await this.#manager.failWip()
 
-          if (this.db.isOurs && this.db.opened && destroy) {
-            await this.db.close()
+          if (this.#db.isOurs && this.#db.opened && destroy) {
+            await this.#db.close()
           }
 
-          this.stopped = true
-          this.stoppingOn = null
-          this.started = false
+          this.#stopped = true
+          this.#stoppingOn = null
+          this.#started = false
 
           this.emit(events.stopped)
           resolve()
@@ -168,13 +191,13 @@ class PgBoss extends EventEmitter {
 
       setImmediate(async () => {
         try {
-          if (this.config.__test__throw_stop_monitor) {
-            throw new Error(this.config.__test__throw_stop_monitor)
+          if (this.#config.__test__throw_stop_monitor) {
+            throw new Error(this.#config.__test__throw_stop_monitor)
           }
 
-          const isWip = () => this.manager.getWipData({ includeInternal: false }).length > 0
+          const isWip = () => this.#manager.getWipData({ includeInternal: false }).length > 0
 
-          while ((Date.now() - this.stoppingOn) < timeout && isWip()) {
+          while ((Date.now() - this.#stoppingOn) < timeout && isWip()) {
             await delay(500)
           }
 

package/src/manager.js

@@ -547,6 +547,8 @@ class Manager extends EventEmitter {
   async createQueue (name, options = {}) {
     assert(name, 'Missing queue name argument')
 
+    Attorney.assertQueueName(name)
+
     const { policy = QUEUE_POLICY.standard } = options
 
     assert(policy in QUEUE_POLICY, `${policy} is not a valid queue policy`)
@@ -560,7 +562,7 @@ class Manager extends EventEmitter {
       deadLetter
     } = Attorney.checkQueueArgs(name, options)
 
-    const paritionSql = plans.partitionCreateJobName(this.config.schema, name)
+    const paritionSql = plans.createPartition(this.config.schema, name)
 
     await this.db.executeSql(paritionSql)
 
@@ -646,8 +648,8 @@ class Manager extends EventEmitter {
     const result = await this.db.executeSql(queueSql, [name])
 
     if (result?.rows?.length) {
-      Attorney.assertPostgresObjectName(name)
-      const sql = plans.dropJobTablePartition(this.config.schema, name)
+      Attorney.assertQueueName(name)
+      const sql = plans.dropPartition(this.config.schema, name)
       await this.db.executeSql(sql)
     }
 

package/src/plans.js

@@ -46,8 +46,8 @@ module.exports = {
   countStates,
   createQueue,
   updateQueue,
-  partitionCreateJobName,
-  dropJobTablePartition,
+  createPartition,
+  dropPartition,
   deleteQueueRecords,
   getQueueByName,
   getQueueSize,
@@ -96,6 +96,10 @@ function create (schema, version) {
     createTableSchedule(schema),
     createTableSubscription(schema),
 
+    getPartitionFunction(schema),
+    createPartitionFunction(schema),
+    dropPartitionFunction(schema),
+
     insertVersion(schema, version)
   ]
 
@@ -162,16 +166,53 @@ function createTableJob (schema) {
   `
 }
 
-function partitionCreateJobName (schema, name) {
+function createPartition (schema, name) {
+  return `SELECT ${schema}.create_partition('${name}');`
+}
+
+function getPartitionFunction (schema) {
+  return `
+    CREATE FUNCTION ${schema}.get_partition(queue_name text, out name text) AS
+    $$
+    SELECT '${schema}.job_' || encode(digest(queue_name, 'sha1'), 'hex');
+    $$
+    LANGUAGE SQL
+    IMMUTABLE
+  `
+}
+
+function createPartitionFunction (schema) {
+  return `
+    CREATE FUNCTION ${schema}.create_partition(queue_name text)
+    RETURNS VOID AS
+    $$
+    DECLARE
+      table_name varchar := ${schema}.get_partition(queue_name);
+    BEGIN
+      EXECUTE format('CREATE TABLE %I (LIKE ${schema}.job INCLUDING DEFAULTS INCLUDING CONSTRAINTS)', table_name);
+      EXECUTE format('ALTER TABLE %I ADD CHECK (name=%L)', table_name, queue_name);
+      EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION %I FOR VALUES IN (%L)', table_name, queue_name);
+    END;
+    $$
+    LANGUAGE plpgsql;
+  `
+}
+
+function dropPartitionFunction (schema) {
   return `
-    CREATE TABLE ${schema}.job_${name} (LIKE ${schema}.job INCLUDING DEFAULTS INCLUDING CONSTRAINTS);
-    ALTER TABLE ${schema}.job_${name} ADD CONSTRAINT job_check_${name} CHECK (name='${name}');
-    ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.job_${name} FOR VALUES IN ('${name}');
+    CREATE FUNCTION ${schema}.drop_partition(queue_name text)
+    RETURNS VOID AS
+    $$
+    BEGIN  
+      EXECUTE format('DROP TABLE IF EXISTS %I', ${schema}.get_partition(queue_name));
+    END;
+    $$
+    LANGUAGE plpgsql;
   `
 }
 
-function dropJobTablePartition (schema, name) {
-  return `DROP TABLE IF EXISTS ${schema}.job_${name}`
+function dropPartition (schema, name) {
+  return `SELECT ${schema}.drop_partition('${name}');`
 }
 
 function createPrimaryKeyArchive (schema) {
@@ -274,6 +315,8 @@ function getQueueByName (schema) {
 function deleteQueueRecords (schema) {
   return `WITH dq AS (
       DELETE FROM ${schema}.queue WHERE name = $1
+    ), ds AS (
+      DELETE FROM ${schema}.schedule WHERE name = $1
     )
     DELETE FROM ${schema}.job WHERE name = $1
   `
@@ -337,7 +380,9 @@ function createTableSubscription (schema) {
 
 function getSchedules (schema) {
   return `
-    SELECT * FROM ${schema}.schedule
+    SELECT s.*
+    FROM ${schema}.schedule s
+      JOIN ${schema}.queue q on s.name = q.name
   `
 }
 
@@ -723,8 +768,8 @@ function locked (schema, query) {
 }
 
 function advisoryLock (schema, key) {
-  return `SELECT pg_advisory_xact_lock(
-      ('x' || md5(current_database() || '.pgboss.${schema}${key || ''}'))::bit(64)::bigint
+  return `SELECT pg_advisory_xact_lock(      
+      ('x' || encode(digest(current_database() || '.pgboss.${schema}${key || ''}', 'sha256'), 'hex'))::bit(64)::bigint
   )`
 }
 

package/src/timekeeper.js

@@ -5,8 +5,7 @@ const Attorney = require('./attorney')
 const pMap = require('p-map')
 
 const queues = {
-  CRON: '__pgboss__cron',
-  SEND_IT: '__pgboss__send_it'
+  SEND_IT: '__pgboss__send-it'
 }
 
 const events = {
@@ -28,6 +27,7 @@ class Timekeeper extends EventEmitter {
     this.events = events
 
     this.getTimeCommand = plans.getTime(config.schema)
+    this.getQueueCommand = plans.getQueueByName(config.schema)
     this.getSchedulesCommand = plans.getSchedules(config.schema)
     this.scheduleCommand = plans.schedule(config.schema)
     this.unscheduleCommand = plans.unschedule(config.schema)
@@ -44,6 +44,8 @@ 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
@@ -52,21 +54,18 @@ class Timekeeper extends EventEmitter {
     // cache the clock skew from the db server
     await this.cacheClockSkew()
 
-    await this.manager.createQueue(queues.CRON)
-    await this.manager.createQueue(queues.SEND_IT)
+    try {
+      await this.manager.createQueue(queues.SEND_IT)
+    } catch {}
 
-    await this.manager.work(queues.CRON, { newJobCheckIntervalSeconds: this.config.cronWorkerIntervalSeconds }, (job) => this.onCron(job))
     await this.manager.work(queues.SEND_IT, { newJobCheckIntervalSeconds: this.config.cronWorkerIntervalSeconds, teamSize: 50, teamConcurrency: 5 }, (job) => this.onSendIt(job))
 
-    // uses sendDebounced() to enqueue a cron check
-    await this.checkSchedulesAsync()
+    setImmediate(() => this.onCron())
 
     // create monitoring interval to make sure cron hasn't crashed
-    this.cronMonitorInterval = setInterval(async () => await this.monitorCron(), this.cronMonitorIntervalMs)
+    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)
-
-    this.stopped = false
   }
 
   async stop () {
@@ -76,7 +75,6 @@ class Timekeeper extends EventEmitter {
 
     this.stopped = true
 
-    await this.manager.offWork(queues.CRON)
     await this.manager.offWork(queues.SEND_IT)
 
     if (this.skewMonitorInterval) {
@@ -90,22 +88,6 @@ class Timekeeper extends EventEmitter {
     }
   }
 
-  async monitorCron () {
-    try {
-      if (this.config.__test__force_cron_monitoring_error) {
-        throw new Error(this.config.__test__force_cron_monitoring_error)
-      }
-
-      const { secondsAgo } = await this.getCronTime()
-
-      if (secondsAgo > 60) {
-        await this.checkSchedulesAsync()
-      }
-    } catch (err) {
-      this.emit(this.events.error, err)
-    }
-  }
-
   async cacheClockSkew () {
     let skew = 0
 
@@ -134,43 +116,42 @@ class Timekeeper extends EventEmitter {
     }
   }
 
-  async checkSchedulesAsync () {
-    const opts = {
-      retryLimit: 2,
-      retentionSeconds: 60
-    }
-
-    await this.manager.sendDebounced(queues.CRON, null, opts, 60)
-  }
-
   async onCron () {
-    if (this.stopped) return
+    let locker
 
     try {
-      if (this.config.__test__throw_cron_processing) {
-        throw new Error(this.config.__test__throw_cron_processing)
-      }
+      if (this.stopped || this.timekeeping) return
 
-      const items = await this.getSchedules()
+      if (this.config.__test__force_cron_monitoring_error) {
+        throw new Error(this.config.__test__force_cron_monitoring_error)
+      }
 
-      const sending = items.filter(i => this.shouldSendIt(i.cron, i.timezone))
+      this.timekeeping = true
 
-      if (sending.length && !this.stopped) {
-        await pMap(sending, it => this.send(it), { concurrency: 5 })
-      }
+      locker = await this.db.lock({ key: 'timekeeper' })
 
-      if (this.stopped) return
+      const { secondsAgo } = await this.getCronTime()
 
-      // set last time cron was evaluated for downstream usage in cron monitoring
-      await this.setCronTime()
+      if (secondsAgo > this.config.cronMonitorIntervalSeconds) {
+        await this.cron()
+        await this.setCronTime()
+      }
     } catch (err) {
       this.emit(this.events.error, err)
+    } finally {
+      this.timekeeping = false
+      await locker?.unlock()
     }
+  }
 
-    if (this.stopped) return
+  async cron () {
+    const items = await this.getSchedules()
 
-    // uses sendDebounced() to enqueue a cron check
-    await this.checkSchedulesAsync()
+    const sending = items.filter(i => this.shouldSendIt(i.cron, i.timezone))
+
+    if (sending.length && !this.stopped) {
+      await pMap(sending, it => this.send(it), { concurrency: 5 })
+    }
   }
 
   shouldSendIt (cron, tz) {
@@ -186,12 +167,7 @@ class Timekeeper extends EventEmitter {
   }
 
   async send (job) {
-    const options = {
-      singletonKey: job.name,
-      singletonSeconds: 60
-    }
-
-    await this.manager.send(queues.SEND_IT, job, options)
+    await this.manager.send(queues.SEND_IT, job, { singletonKey: job.name, singletonSeconds: 60 })
   }
 
   async onSendIt (job) {
@@ -213,6 +189,13 @@ class Timekeeper extends EventEmitter {
     // validation pre-check
     Attorney.checkSendArgs([name, data, options], this.config)
 
+    // make sure queue exists before scheduling
+    const queue = await this.db.executeSql(this.getQueueCommand, [name])
+
+    if (!queue.rows.length === 0) {
+      throw new Error(`Queue '${name}' not found`)
+    }
+
     const values = [name, cron, tz, data, options]
 
     const result = await this.db.executeSql(this.scheduleCommand, values)

package/types.d.ts

@@ -348,7 +348,7 @@ 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, policy: 'standard' | 'short' | 'singleton' | 'stately'): Promise<void>;
+  createQueue(name: string, options?: { policy: 'standard' | 'short' | 'singleton' | 'stately' }): Promise<void>;
   deleteQueue(name: string): Promise<void>;
   purgeQueue(name: string): Promise<void>;
   clearStorage(): Promise<void>;