pg-boss 10.0.0-beta2 → 10.0.0-beta3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pg-boss",
-  "version": "10.0.0-beta2",
+  "version": "10.0.0-beta3",
   "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) {

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))

package/src/index.js

@@ -13,6 +13,15 @@ const events = {
   stopped: 'stopped'
 }
 class PgBoss extends EventEmitter {
+  #stoppingOn
+  #stopped
+  #config
+  #db
+  #boss
+  #contractor
+  #manager
+  #timekeeper
+
   static getConstructionPlans (schema) {
     return Contractor.constructionPlans(schema)
   }
@@ -26,60 +35,72 @@ 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) {
       return
@@ -87,39 +108,39 @@ class PgBoss extends EventEmitter {
 
     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.#stopped = false
 
     return this
   }
 
   async stop (options = {}) {
-    if (this.stoppingOn || this.stopped) {
+    if (this.#stoppingOn || this.#stopped) {
       return
     }
 
@@ -127,27 +148,27 @@ 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.#stopped = true
+          this.#stoppingOn = null
           this.started = false
 
           this.emit(events.stopped)
@@ -168,13 +189,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}.j' || 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) {
@@ -723,8 +764,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

@@ -6,7 +6,7 @@ const pMap = require('p-map')
 
 const queues = {
   CRON: '__pgboss__cron',
-  SEND_IT: '__pgboss__send_it'
+  SEND_IT: '__pgboss__send-it'
 }
 
 const events = {

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>;