pg-boss 9.0.3 → 10.0.0-beta10

package/src/index.js

@@ -6,13 +6,24 @@ const Manager = require('./manager')
 const Timekeeper = require('./timekeeper')
 const Boss = require('./boss')
 const Db = require('./db')
-const delay = require('delay')
+const { delay } = require('./tools')
 
 const events = {
   error: 'error',
   stopped: 'stopped'
 }
 class PgBoss extends EventEmitter {
+  #stoppingOn
+  #stopped
+  #starting
+  #started
+  #config
+  #db
+  #boss
+  #contractor
+  #manager
+  #timekeeper
+
   static getConstructionPlans (schema) {
     return Contractor.constructionPlans(schema)
   }
@@ -25,158 +36,182 @@ class PgBoss extends EventEmitter {
     return Contractor.rollbackPlans(schema, version)
   }
 
-  constructor (value) {
-    const config = Attorney.getConfig(value)
+  static states = plans.JOB_STATES
+  static policies = plans.QUEUE_POLICIES
 
+  constructor (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)
 
-    function promoteFunction (obj, func) {
-      this[func.name] = (...args) => {
-        const shouldRun = !this.started || !((func.name === 'work' || func.name === 'onComplete') && (this.stopped || this.stoppingOn))
+    this.#boss = boss
+    this.#contractor = contractor
+    this.#manager = manager
+    this.#timekeeper = timekeeper
+  }
 
-        if (shouldRun) {
-          return func.apply(obj, args)
-        } else {
-          const state = this.stoppingOn ? 'stopping' : this.stopped ? 'stopped' : !this.started ? 'not started' : 'started'
-          return Promise.reject(new Error(`pg-boss is ${state}.`))
-        }
-      }
+  getDb () {
+    if (this.#db) {
+      return this.#db
+    }
+
+    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.stopped) {
-      return this
+    if (this.#starting || this.#started) {
+      return
     }
 
-    if (this.db.isOurs && !this.db.opened) {
-      await this.db.open()
+    this.#starting = true
+
+    if (this.#db.isOurs && !this.#db.opened) {
+      await this.#db.open()
     }
 
-    await this.contractor.start()
+    if (this.#config.migrate) {
+      await this.#contractor.start()
+    } else {
+      await this.#contractor.check()
+    }
 
-    this.stopped = false
-    this.started = true
+    this.#manager.start()
 
-    this.manager.start()
+    if (this.#config.supervise) {
+      await this.#boss.supervise()
+    }
 
-    if (!this.config.noSupervisor) {
-      await this.boss.supervise()
+    if (this.#config.monitorStateIntervalSeconds) {
+      await this.#boss.monitor()
     }
 
-    if (!this.config.noScheduling) {
-      await this.timekeeper.start()
+    if (this.#config.schedule) {
+      await this.#timekeeper.start()
     }
 
+    this.#starting = false
+    this.#started = true
+    this.#stopped = false
+
     return this
   }
 
   async stop (options = {}) {
-    if (this.stoppingOn) {
+    if (this.#stoppingOn || this.#stopped) {
       return
     }
 
-    if (this.stopped) {
-      this.emit(events.stopped)
-    }
-
-    let { destroy = false, graceful = true, timeout = 30000 } = options
+    let { destroy = false, graceful = true, timeout = 30000, wait = true } = options
 
     timeout = Math.max(timeout, 1000)
 
-    this.stoppingOn = Date.now()
+    this.#stoppingOn = Date.now()
 
-    await this.manager.stop()
-    await this.timekeeper.stop()
+    await this.#manager.stop()
+    await this.#timekeeper.stop()
+    await this.#boss.stop()
 
-    const shutdown = async () => {
-      this.stopped = true
-      this.stoppingOn = null
+    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.db.isOurs && this.db.opened && destroy) {
-        await this.db.close()
-      }
+          await this.#manager.failWip()
 
-      this.emit(events.stopped)
-    }
+          if (this.#db.isOurs && this.#db.opened && destroy) {
+            await this.#db.close()
+          }
 
-    if (!graceful) {
-      await this.boss.stop()
-      await shutdown()
-      return
-    }
+          this.#stopped = true
+          this.#stoppingOn = null
+          this.#started = false
 
-    setImmediate(async () => {
-      let closing = false
+          this.emit(events.stopped)
+          resolve()
+        } catch (err) {
+          this.emit(events.error, err)
+          reject(err)
+        }
+      }
 
-      try {
-        while (Date.now() - this.stoppingOn < timeout) {
-          if (this.manager.getWipData({ includeInternal: closing }).length === 0) {
-            if (closing) {
-              break
-            }
+      if (!graceful) {
+        return shutdown()
+      }
 
-            closing = true
+      if (!wait) {
+        resolve()
+      }
 
-            await this.boss.stop()
+      setImmediate(async () => {
+        try {
+          if (this.#config.__test__throw_stop_monitor) {
+            throw new Error(this.#config.__test__throw_stop_monitor)
           }
 
-          await delay(1000)
-        }
+          const isWip = () => this.#manager.getWipData({ includeInternal: false }).length > 0
 
-        await this.boss.stop()
-        await shutdown()
-      } catch (err) {
-        this.emit(events.error, err)
-      }
+          while ((Date.now() - this.#stoppingOn) < timeout && isWip()) {
+            await delay(500)
+          }
+
+          await shutdown()
+        } catch (err) {
+          reject(err)
+          this.emit(events.error, err)
+        }
+      })
     })
   }
 }
 
 module.exports = PgBoss
-module.exports.states = plans.states