pg-boss 6.2.2-beta → 7.0.1

package/README.md

@@ -16,11 +16,11 @@ async function readme() {
 
   const queue = 'some-queue';
 
-  let jobId = await boss.publish(queue, { param1: 'foo' })
+  let jobId = await boss.send(queue, { param1: 'foo' })
 
   console.log(`created job in queue ${queue}: ${jobId}`);
 
-  await boss.subscribe(queue, someAsyncJobHandler);
+  await boss.work(queue, someAsyncJobHandler);
 }
 
 async function someAsyncJobHandler(job) {
@@ -38,15 +38,15 @@ pg-boss relies on [SKIP LOCKED](http://blog.2ndquadrant.com/what-is-select-skip-
 This will likely cater the most to teams already familiar with the simplicity of relational database semantics and operations (SQL, querying, and backups). It will be especially useful to those already relying on PostgreSQL that want to limit how many systems are required to monitor and support in their architecture.
 
 ## Features
-* Backpressure-compatible subscriptions for monitoring queues on an interval (with configurable concurrency)
+* Backpressure-compatible workers for polling queues
 * Distributed cron-based job scheduling with database clock synchronization
+* Pub/sub API for fan-out queue relationships
 * Job deferral, retries (with exponential backoff), throttling, rate limiting, debouncing
-* Job completion subscriptions for orchestrations/sagas
-* Direct publish, fetch and completion APIs for custom integrations
-* Batching API for chunked job fetching
+* Job completion hooks for orchestrations/sagas
+* Direct send, fetch and completion APIs for custom integrations
 * Direct table access for bulk loads via COPY or INSERT
 * Multi-master compatible when running multiple instances (for example, in a Kubernetes ReplicaSet)
-* Automatic provisioning of required storage into a dedicated schema
+* Automatic provisioning of required storage
 * Automatic maintenance operations to manage table growth
 
 ## Requirements
@@ -64,8 +64,7 @@ yarn add pg-boss
 ```
 
 ## Documentation
-* [Usage](docs/usage.md)
-* [Configuration](docs/configuration.md)
+* [Docs](docs/readme.md)
 
 ## Contributing
 

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "pg-boss",
-  "version": "6.2.2-beta",
+  "version": "7.0.1",
   "description": "Queueing jobs in Node.js using PostgreSQL like a boss",
   "main": "./src/index.js",
   "engines": {
     "node": ">=12.0.0"
   },
   "dependencies": {
-    "cron-parser": "^3.3.0",
+    "cron-parser": "^4.0.0",
     "delay": "^5.0.0",
     "lodash.debounce": "^4.0.8",
     "p-map": "^4.0.0",
@@ -27,7 +27,8 @@
     "forcover": "npm run cover && nyc report --reporter=text-lcov | coveralls",
     "export-schema": "node ./scripts/construct.js",
     "export-migration": "node ./scripts/migrate.js",
-    "export-rollback": "node ./scripts/rollback.js"
+    "export-rollback": "node ./scripts/rollback.js",
+    "tsc": "tsc --noEmit types.d.ts"
   },
   "mocha": {
     "timeout": 10000,

package/src/attorney.js

@@ -3,8 +3,8 @@ const { DEFAULT_SCHEMA } = require('./plans')
 
 module.exports = {
   getConfig,
-  checkPublishArgs,
-  checkSubscribeArgs,
+  checkSendArgs,
+  checkWorkArgs,
   checkFetchArgs,
   warnClockSkew
 }
@@ -24,18 +24,18 @@ const WARNINGS = {
   }
 }
 
-function checkPublishArgs (args, defaults) {
+function checkSendArgs (args, defaults) {
   let name, data, options
 
   if (typeof args[0] === 'string') {
     name = args[0]
     data = args[1]
 
-    assert(typeof data !== 'function', 'publish() cannot accept a function as the payload.  Did you intend to use subscribe()?')
+    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, 'publish object API only accepts 1 argument')
+    assert(args.length === 1, 'send object API only accepts 1 argument')
 
     const job = args[0]
 
@@ -84,7 +84,7 @@ function checkPublishArgs (args, defaults) {
   return { name, data, options }
 }
 
-function checkSubscribeArgs (name, args, defaults) {
+function checkWorkArgs (name, args, defaults) {
   let options, callback
 
   assert(name, 'missing job name')
@@ -145,7 +145,6 @@ function getConfig (value) {
   applyMonitoringConfig(config)
   applyUuidConfig(config)
 
-  // defaults for publish and subscribe
   applyNewJobCheckInterval(config)
   applyExpirationConfig(config)
   applyRetentionConfig(config)

package/src/boss.js

@@ -56,11 +56,11 @@ class Boss extends EventEmitter {
 
     await this.maintenanceAsync()
 
-    const maintenanceSubscribeOptions = {
+    const maintenanceWorkOptions = {
       newJobCheckIntervalSeconds: Math.max(1, this.maintenanceIntervalSeconds / 2)
     }
 
-    await this.manager.subscribe(queues.MAINTENANCE, maintenanceSubscribeOptions, (job) => this.onMaintenance(job))
+    await this.manager.work(queues.MAINTENANCE, maintenanceWorkOptions, (job) => this.onMaintenance(job))
 
     if (this.monitorStates) {
       await this.manager.deleteQueue(COMPLETION_JOB_PREFIX + queues.MONITOR_STATES)
@@ -68,11 +68,11 @@ class Boss extends EventEmitter {
 
       await this.monitorStatesAsync()
 
-      const monitorStatesSubscribeOptions = {
+      const monitorStatesWorkOptions = {
         newJobCheckIntervalSeconds: Math.max(1, this.monitorIntervalSeconds / 2)
       }
 
-      await this.manager.subscribe(queues.MONITOR_STATES, monitorStatesSubscribeOptions, (job) => this.onMonitorStates(job))
+      await this.manager.work(queues.MONITOR_STATES, monitorStatesWorkOptions, (job) => this.onMonitorStates(job))
     }
   }
 
@@ -97,7 +97,7 @@ class Boss extends EventEmitter {
       onComplete: false
     }
 
-    await this.manager.publish(queues.MAINTENANCE, null, options)
+    await this.manager.send(queues.MAINTENANCE, null, options)
   }
 
   async monitorStatesAsync (options = {}) {
@@ -110,7 +110,7 @@ class Boss extends EventEmitter {
       onComplete: false
     }
 
-    await this.manager.publish(queues.MONITOR_STATES, null, options)
+    await this.manager.send(queues.MONITOR_STATES, null, options)
   }
 
   async onMaintenance (job) {
@@ -169,10 +169,10 @@ class Boss extends EventEmitter {
         clearInterval(this.metaMonitorInterval)
       }
 
-      await this.manager.unsubscribe(queues.MAINTENANCE)
+      await this.manager.offWork(queues.MAINTENANCE)
 
       if (this.monitorStates) {
-        await this.manager.unsubscribe(queues.MONITOR_STATES)
+        await this.manager.offWork(queues.MONITOR_STATES)
       }
 
       this.stopped = true

package/src/manager.js

@@ -24,6 +24,23 @@ const events = {
   wip: 'wip'
 }
 
+const resolveWithinSeconds = async (promise, seconds) => {
+  const timeout = Math.max(1, seconds) * 1000
+  const reject = delay.reject(timeout, { value: new Error(`handler execution exceeded ${timeout}ms`) })
+
+  let result
+
+  try {
+    result = await Promise.race([promise, reject])
+  } finally {
+    try {
+      reject.clear()
+    } catch {}
+  }
+
+  return result
+}
+
 class Manager extends EventEmitter {
   constructor (db, config) {
     super()
@@ -32,7 +49,7 @@ class Manager extends EventEmitter {
     this.db = db
 
     this.events = events
-    this.subscriptions = new Map()
+    this.workers = new Map()
 
     this.nextJobCommand = plans.fetchNextJob(config.schema)
     this.insertJobCommand = plans.insertJob(config.schema)
@@ -42,25 +59,31 @@ class Manager extends EventEmitter {
     this.failJobsCommand = plans.failJobs(config.schema)
     this.getJobByIdCommand = plans.getJobById(config.schema)
     this.getArchivedJobByIdCommand = plans.getArchivedJobById(config.schema)
+    this.subscribeCommand = plans.subscribe(config.schema)
+    this.unsubscribeCommand = plans.unsubscribe(config.schema)
+    this.getQueuesForEventCommand = plans.getQueuesForEvent(config.schema)
 
     // exported api to index
     this.functions = [
-      this.fetch,
       this.complete,
       this.cancel,
       this.fail,
+      this.fetch,
+      this.fetchCompleted,
+      this.work,
+      this.offWork,
+      this.onComplete,
+      this.offComplete,
       this.publish,
-      this.insert,
       this.subscribe,
       this.unsubscribe,
-      this.onComplete,
-      this.offComplete,
-      this.fetchCompleted,
-      this.publishDebounced,
-      this.publishThrottled,
-      this.publishOnce,
-      this.publishAfter,
-      this.publishSingleton,
+      this.insert,
+      this.send,
+      this.sendDebounced,
+      this.sendThrottled,
+      this.sendOnce,
+      this.sendAfter,
+      this.sendSingleton,
       this.deleteQueue,
       this.deleteAllQueues,
       this.clearStorage,
@@ -78,33 +101,33 @@ class Manager extends EventEmitter {
   async stop () {
     this.stopping = true
 
-    for (const sub of this.subscriptions.values()) {
+    for (const sub of this.workers.values()) {
       if (!INTERNAL_QUEUES[sub.name]) {
-        await this.unsubscribe(sub.name)
+        await this.offWork(sub.name)
       }
     }
   }
 
-  async subscribe (name, ...args) {
-    const { options, callback } = Attorney.checkSubscribeArgs(name, args, this.config)
+  async work (name, ...args) {
+    const { options, callback } = Attorney.checkWorkArgs(name, args, this.config)
     return await this.watch(name, options, callback)
   }
 
   async onComplete (name, ...args) {
-    const { options, callback } = Attorney.checkSubscribeArgs(name, args, this.config)
+    const { options, callback } = Attorney.checkWorkArgs(name, args, this.config)
     return await this.watch(COMPLETION_JOB_PREFIX + name, options, callback)
   }
 
   addWorker (worker) {
-    this.subscriptions.set(worker.id, worker)
+    this.workers.set(worker.id, worker)
   }
 
   removeWorker (worker) {
-    this.subscriptions.delete(worker.id)
+    this.workers.delete(worker.id)
   }
 
   getWorkers () {
-    return Array.from(this.subscriptions.values())
+    return Array.from(this.workers.values())
   }
 
   emitWip (name) {
@@ -149,7 +172,7 @@ class Manager extends EventEmitter {
 
   async watch (name, options, callback) {
     if (this.stopping) {
-      throw new Error('Subscriptions are disabled. pg-boss is stopping.')
+      throw new Error('Workers are disabled. pg-boss is stopping.')
     }
 
     const {
@@ -157,57 +180,71 @@ class Manager extends EventEmitter {
       batchSize,
       teamSize = 1,
       teamConcurrency = 1,
+      teamRefill: refill = false,
       includeMetadata = false
     } = options
 
     const id = uuid.v4()
 
-    const fetch = () => this.fetch(name, batchSize || teamSize, { includeMetadata })
+    let queueSize = 0
 
-    const onFetch = async (jobs) => {
-      if (this.config.__test__throw_subscription) {
-        throw new Error('__test__throw_subscription')
-      }
+    let refillTeamPromise
+    let resolveRefillTeam
 
-      const resolveWithinSeconds = async (promise, seconds) => {
-        const timeout = Math.max(1, seconds) * 1000
-        const reject = delay.reject(timeout, { value: new Error(`handler execution exceeded ${timeout}ms`) })
+    // Setup a promise that onFetch can await for when at least one
+    // job is finished and so the team is ready to be topped up
+    const createTeamRefillPromise = () => {
+      refillTeamPromise = new Promise((resolve) => { resolveRefillTeam = resolve })
+    }
 
-        let result
+    createTeamRefillPromise()
 
-        try {
-          result = await Promise.race([promise, reject])
-        } finally {
-          try {
-            reject.clear()
-          } catch {}
-        }
+    const onRefill = () => {
+      queueSize--
+      resolveRefillTeam()
+      createTeamRefillPromise()
+    }
 
-        return result
+    const fetch = () => this.fetch(name, batchSize || (teamSize - queueSize), { includeMetadata })
+
+    const onFetch = async (jobs) => {
+      if (this.config.__test__throw_worker) {
+        throw new Error('__test__throw_worker')
       }
 
       this.emitWip(name)
 
-      let result
-
       if (batchSize) {
         const maxExpiration = jobs.reduce((acc, i) => Math.max(acc, i.expire_in_seconds), 0)
 
         // Failing will fail all fetched jobs
-        result = await resolveWithinSeconds(Promise.all([callback(jobs)]), maxExpiration)
+        await resolveWithinSeconds(Promise.all([callback(jobs)]), maxExpiration)
           .catch(err => this.fail(jobs.map(job => job.id), err))
       } else {
-        result = await pMap(jobs, job =>
+        if (refill) {
+          queueSize += jobs.length || 1
+        }
+
+        const allTeamPromise = pMap(jobs, job =>
           resolveWithinSeconds(callback(job), job.expire_in_seconds)
             .then(result => this.complete(job.id, result))
             .catch(err => this.fail(job.id, err))
+            .then(() => refill ? onRefill() : null)
         , { concurrency: teamConcurrency }
         ).catch(() => {}) // allow promises & non-promises to live together in harmony
+
+        if (refill) {
+          if (queueSize < teamSize) {
+            return
+          } else {
+            await refillTeamPromise
+          }
+        } else {
+          await allTeamPromise
+        }
       }
 
       this.emitWip(name)
-
-      return result
     }
 
     const onError = error => {
@@ -223,7 +260,7 @@ class Manager extends EventEmitter {
     return id
   }
 
-  async unsubscribe (value) {
+  async offWork (value) {
     assert(value, 'Missing required argument')
 
     const query = (typeof value === 'string')
@@ -255,66 +292,92 @@ class Manager extends EventEmitter {
     })
   }
 
+  async subscribe (event, name) {
+    assert(event, 'Missing required argument')
+    assert(name, 'Missing required argument')
+
+    return await this.db.executeSql(this.subscribeCommand, [event, name])
+  }
+
+  async unsubscribe (event, name) {
+    assert(event, 'Missing required argument')
+    assert(name, 'Missing required argument')
+
+    return await this.db.executeSql(this.unsubscribeCommand, [event, name])
+  }
+
+  async publish (event, ...args) {
+    assert(event, 'Missing required argument')
+
+    const result = 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)))
+  }
+
   async offComplete (value) {
     if (typeof value === 'string') {
       value = COMPLETION_JOB_PREFIX + value
     }
 
-    return await this.unsubscribe(value)
+    return await this.offWork(value)
   }
 
-  async publish (...args) {
-    const { name, data, options } = Attorney.checkPublishArgs(args, this.config)
+  async send (...args) {
+    const { name, data, options } = Attorney.checkSendArgs(args, this.config)
     return await this.createJob(name, data, options)
   }
 
-  async publishOnce (name, data, options, key) {
+  async sendOnce (name, data, options, key) {
     options = options || {}
 
     options.singletonKey = key || name
 
-    const result = Attorney.checkPublishArgs([name, data, options], this.config)
+    const result = Attorney.checkSendArgs([name, data, options], this.config)
 
     return await this.createJob(result.name, result.data, result.options)
   }
 
-  async publishSingleton (name, data, options) {
+  async sendSingleton (name, data, options) {
     options = options || {}
 
     options.singletonKey = SINGLETON_QUEUE_KEY
 
-    const result = Attorney.checkPublishArgs([name, data, options], this.config)
+    const result = Attorney.checkSendArgs([name, data, options], this.config)
 
     return await this.createJob(result.name, result.data, result.options)
   }
 
-  async publishAfter (name, data, options, after) {
+  async sendAfter (name, data, options, after) {
     options = options || {}
     options.startAfter = after
 
-    const result = Attorney.checkPublishArgs([name, data, options], this.config)
+    const result = Attorney.checkSendArgs([name, data, options], this.config)
 
     return await this.createJob(result.name, result.data, result.options)
   }
 
-  async publishThrottled (name, data, options, seconds, key) {
+  async sendThrottled (name, data, options, seconds, key) {
     options = options || {}
     options.singletonSeconds = seconds
     options.singletonNextSlot = false
     options.singletonKey = key
 
-    const result = Attorney.checkPublishArgs([name, data, options], this.config)
+    const result = Attorney.checkSendArgs([name, data, options], this.config)
 
     return await this.createJob(result.name, result.data, result.options)
   }
 
-  async publishDebounced (name, data, options, seconds, key) {
+  async sendDebounced (name, data, options, seconds, key) {
     options = options || {}
     options.singletonSeconds = seconds
     options.singletonNextSlot = true
     options.singletonKey = key
 
-    const result = Attorney.checkPublishArgs([name, data, options], this.config)
+    const result = Attorney.checkSendArgs([name, data, options], this.config)
 
     return await this.createJob(result.name, result.data, result.options)
   }

package/src/migrationStore.js

@@ -67,6 +67,23 @@ function getAll (schema, config) {
   const keepUntil = config ? config.keepUntil : DEFAULT_RETENTION
 
   return [
+    {
+      release: '7.0.0',
+      version: 19,
+      previous: 18,
+      install: [
+        `CREATE TABLE ${schema}.subscription (
+          event text not null,
+          name text not null,
+          created_on timestamp with time zone not null default now(),
+          updated_on timestamp with time zone not null default now(),
+          PRIMARY KEY(event, name)
+        )`
+      ],
+      uninstall: [
+        `DROP TABLE ${schema}.subscription`
+      ]
+    },
     {
       release: '6.1.1',
       version: 18,

package/src/plans.js

@@ -33,6 +33,9 @@ module.exports = {
   getSchedules,
   schedule,
   unschedule,
+  subscribe,
+  unsubscribe,
+  getQueuesForEvent,
   expire,
   archive,
   purge,
@@ -78,6 +81,7 @@ function create (schema, version) {
     createJobTable(schema),
     cloneJobTableForArchive(schema),
     createScheduleTable(schema),
+    createSubscriptionTable(schema),
     addIdIndexToArchive(schema),
     addArchivedOnToArchive(schema),
     addArchivedOnIndexToArchive(schema),
@@ -260,6 +264,18 @@ function createScheduleTable (schema) {
   `
 }
 
+function createSubscriptionTable (schema) {
+  return `
+    CREATE TABLE ${schema}.subscription (
+      event text not null,
+      name text not null,
+      created_on timestamp with time zone not null default now(),
+      updated_on timestamp with time zone not null default now(),
+      PRIMARY KEY(event, name)
+    )
+  `
+}
+
 function getSchedules (schema) {
   return `
     SELECT * FROM ${schema}.schedule
@@ -286,6 +302,31 @@ function unschedule (schema) {
   `
 }
 
+function subscribe (schema) {
+  return `
+    INSERT INTO ${schema}.subscription (event, name)
+    VALUES ($1, $2)
+    ON CONFLICT (event, name) DO UPDATE SET
+      event = EXCLUDED.event,
+      name = EXCLUDED.name,
+      updated_on = now()
+  `
+}
+
+function unsubscribe (schema) {
+  return `
+    DELETE FROM ${schema}.subscription
+    WHERE event = $1 and name = $2
+  `
+}
+
+function getQueuesForEvent (schema) {
+  return `
+    SELECT name FROM ${schema}.subscription
+    WHERE event = $1
+  `
+}
+
 function getTime () {
   return "SELECT round(date_part('epoch', now()) * 1000) as time"
 }

package/src/timekeeper.js

@@ -50,8 +50,8 @@ class Timekeeper extends EventEmitter {
 
     await this.cacheClockSkew()
 
-    await this.manager.subscribe(queues.CRON, { newJobCheckIntervalSeconds: 4 }, (job) => this.onCron(job))
-    await this.manager.subscribe(queues.SEND_IT, { newJobCheckIntervalSeconds: 4, teamSize: 50, teamConcurrency: 5 }, (job) => this.onSendIt(job))
+    await this.manager.work(queues.CRON, { newJobCheckIntervalSeconds: 4 }, (job) => this.onCron(job))
+    await this.manager.work(queues.SEND_IT, { newJobCheckIntervalSeconds: 4, teamSize: 50, teamConcurrency: 5 }, (job) => this.onSendIt(job))
 
     await this.cronMonitorAsync()
 
@@ -68,8 +68,8 @@ class Timekeeper extends EventEmitter {
 
     this.stopped = true
 
-    await this.manager.unsubscribe(queues.CRON)
-    await this.manager.unsubscribe(queues.SEND_IT)
+    await this.manager.offWork(queues.CRON)
+    await this.manager.offWork(queues.SEND_IT)
 
     if (this.skewMonitorInterval) {
       clearInterval(this.skewMonitorInterval)
@@ -115,7 +115,7 @@ class Timekeeper extends EventEmitter {
       onComplete: false
     }
 
-    await this.manager.publishDebounced(queues.CRON, null, opts, 60)
+    await this.manager.sendDebounced(queues.CRON, null, opts, 60)
   }
 
   async onCron () {
@@ -165,13 +165,13 @@ class Timekeeper extends EventEmitter {
       onComplete: false
     }
 
-    await this.manager.publish(queues.SEND_IT, job, options)
+    await this.manager.send(queues.SEND_IT, job, options)
   }
 
   async onSendIt (job) {
     if (this.stopped) return
     const { name, data, options } = job.data
-    await this.manager.publish(name, data, options)
+    await this.manager.send(name, data, options)
   }
 
   async getSchedules () {
@@ -185,7 +185,7 @@ class Timekeeper extends EventEmitter {
     cronParser.parseExpression(cron, { tz })
 
     // validation pre-check
-    Attorney.checkPublishArgs([name, data, options], this.config)
+    Attorney.checkSendArgs([name, data, options], this.config)
 
     const values = [name, cron, tz, data, options]
 

package/types.d.ts

@@ -88,9 +88,9 @@ declare namespace PgBoss {
     singletonNextSlot?: boolean;
   }
 
-  type PublishOptions = JobOptions & ExpirationOptions & RetentionOptions & RetryOptions & CompletionOptions
+  type SendOptions = JobOptions & ExpirationOptions & RetentionOptions & RetryOptions & CompletionOptions
 
-  type ScheduleOptions = PublishOptions & { tz?: string }
+  type ScheduleOptions = SendOptions & { tz?: string }
 
   interface JobPollingOptions {
     newJobCheckInterval?: number;
@@ -104,24 +104,24 @@ declare namespace PgBoss {
     includeMetadata?: boolean;
   }
 
-  type SubscribeOptions = JobFetchOptions & JobPollingOptions
+  type WorkOptions = JobFetchOptions & JobPollingOptions
 
   type FetchOptions = {
     includeMetadata?: boolean;
   }
 
-  interface SubscribeHandler<ReqData, ResData> {
+  interface WorkHandler<ReqData, ResData> {
     (job: PgBoss.JobWithDoneCallback<ReqData, ResData>): Promise<ResData> | void;
   }
 
-  interface SubscribeWithMetadataHandler<ReqData, ResData> {
+  interface WorkWithMetadataHandler<ReqData, ResData> {
     (job: PgBoss.JobWithMetadataDoneCallback<ReqData, ResData>): Promise<ResData> | void;
   }
 
   interface Request {
     name: string;
     data?: object;
-    options?: PublishOptions;
+    options?: SendOptions;
   }
 
   interface Schedule {
@@ -213,10 +213,10 @@ declare namespace PgBoss {
     queues: object;
   }
 
-  interface Subscription {
+  interface Worker {
     id: string,
     name: string,
-    options: SubscribeOptions,
+    options: WorkOptions,
     state: 'created' | 'retry' | 'active' | 'completed' | 'expired' | 'cancelled' | 'failed',
     count: number,
     createdOn: Date,
@@ -233,7 +233,7 @@ declare namespace PgBoss {
     timeout?: number
   }
 
-  interface UnsubscribeOptions {
+  interface OffWorkOptions {
     id: string
   }
 
@@ -263,8 +263,8 @@ declare class PgBoss {
   on(event: "monitor-states", handler: (monitorStates: PgBoss.MonitorStates) => void): void;
   off(event: "monitor-states", handler: (monitorStates: PgBoss.MonitorStates) => void): void;
 
-  on(event: "wip", handler: (data: PgBoss.Subscription[]) => void): void;
-  off(event: "wip", handler: (data: PgBoss.Subscription[]) => void): void;
+  on(event: "wip", handler: (data: PgBoss.Worker[]) => void): void;
+  off(event: "wip", handler: (data: PgBoss.Worker[]) => void): void;
 
   on(event: "stopped", handler: () => void): void;
   off(event: "stopped", handler: () => void): void;
@@ -272,38 +272,44 @@ declare class PgBoss {
   start(): Promise<PgBoss>;
   stop(options?: PgBoss.StopOptions): Promise<void>;
 
-  publish(request: PgBoss.Request): Promise<string | null>;
-  publish(name: string, data: object): Promise<string | null>;
-  publish(name: string, data: object, options: PgBoss.PublishOptions): Promise<string | null>;
+  send(request: PgBoss.Request): Promise<string | null>;
+  send(name: string, data: object): Promise<string | null>;
+  send(name: string, data: object, options: PgBoss.SendOptions): Promise<string | null>;
 
-  publishAfter(name: string, data: object, options: PgBoss.PublishOptions, date: Date): Promise<string | null>;
-  publishAfter(name: string, data: object, options: PgBoss.PublishOptions, dateString: string): Promise<string | null>;
-  publishAfter(name: string, data: object, options: PgBoss.PublishOptions, seconds: number): Promise<string | null>;
+  sendAfter(name: string, data: object, options: PgBoss.SendOptions, date: Date): Promise<string | null>;
+  sendAfter(name: string, data: object, options: PgBoss.SendOptions, dateString: string): Promise<string | null>;
+  sendAfter(name: string, data: object, options: PgBoss.SendOptions, seconds: number): Promise<string | null>;
 
-  publishOnce(name: string, data: object, options: PgBoss.PublishOptions, key: string): Promise<string | null>;
+  sendOnce(name: string, data: object, options: PgBoss.SendOptions, key: string): Promise<string | null>;
 
-  publishSingleton(name: string, data: object, options: PgBoss.PublishOptions): Promise<string | null>;
+  sendSingleton(name: string, data: object, options: PgBoss.SendOptions): Promise<string | null>;
 
-  publishThrottled(name: string, data: object, options: PgBoss.PublishOptions, seconds: number): Promise<string | null>;
-  publishThrottled(name: string, data: object, options: PgBoss.PublishOptions, seconds: number, key: string): Promise<string | null>;
+  sendThrottled(name: string, data: object, options: PgBoss.SendOptions, seconds: number): Promise<string | null>;
+  sendThrottled(name: string, data: object, options: PgBoss.SendOptions, seconds: number, key: string): Promise<string | null>;
 
-  publishDebounced(name: string, data: object, options: PgBoss.PublishOptions, seconds: number): Promise<string | null>;
-  publishDebounced(name: string, data: object, options: PgBoss.PublishOptions, seconds: number, key: string): Promise<string | null>;
+  sendDebounced(name: string, data: object, options: PgBoss.SendOptions, seconds: number): Promise<string | null>;
+  sendDebounced(name: string, data: object, options: PgBoss.SendOptions, seconds: number, key: string): Promise<string | null>;
 
   insert(jobs: PgBoss.JobInsert[]): Promise<void>;
 
-  subscribe<ReqData, ResData>(name: string, handler: PgBoss.SubscribeHandler<ReqData, ResData>): Promise<string>;
-  subscribe<ReqData, ResData>(name: string, options: PgBoss.SubscribeOptions & { includeMetadata: true }, handler: PgBoss.SubscribeWithMetadataHandler<ReqData, ResData>): Promise<string>;
-  subscribe<ReqData, ResData>(name: string, options: PgBoss.SubscribeOptions, handler: PgBoss.SubscribeHandler<ReqData, ResData>): Promise<string>;
+  work<ReqData, ResData>(name: string, handler: PgBoss.WorkHandler<ReqData, ResData>): Promise<string>;
+  work<ReqData, ResData>(name: string, options: PgBoss.WorkOptions & { includeMetadata: true }, handler: PgBoss.WorkWithMetadataHandler<ReqData, ResData>): Promise<string>;
+  work<ReqData, ResData>(name: string, options: PgBoss.WorkOptions, handler: PgBoss.WorkHandler<ReqData, ResData>): Promise<string>;
 
   onComplete(name: string, handler: Function): Promise<string>;
-  onComplete(name: string, options: PgBoss.SubscribeOptions, handler: Function): Promise<string>;
+  onComplete(name: string, options: PgBoss.WorkOptions, handler: Function): Promise<string>;
 
-  unsubscribe(name: string): Promise<void>;
-  unsubscribe(options: PgBoss.UnsubscribeOptions): Promise<void>;
+  offWork(name: string): Promise<void>;
+  offWork(options: PgBoss.OffWorkOptions): Promise<void>;
+
+  subscribe(event: string, name: string): Promise<void>;
+  unsubscribe(event: string, name: string): Promise<void>;
+  publish(event: string): Promise<string[]>;
+  publish(event: string, data: object): Promise<string[]>;
+  publish(event: string, data: object, options: PgBoss.SendOptions): Promise<string[]>;
 
   offComplete(name: string): Promise<void>;
-  offComplete(options: PgBoss.UnsubscribeOptions): Promise<void>;
+  offComplete(options: PgBoss.OffWorkOptions): Promise<void>;
 
   fetch<T>(name: string): Promise<PgBoss.Job<T> | null>;
   fetch<T>(name: string, batchSize: number): Promise<PgBoss.Job<T>[] | null>;

package/version.json

@@ -1,3 +1,3 @@
 {
-  "schema": 18
+  "schema": 19
 }