pg-boss 11.1.2 → 12.0.0-beta2

package/src/timekeeper.js

@@ -1,203 +0,0 @@
-const EventEmitter = require('node:events')
-const plans = require('./plans')
-const { CronExpressionParser } = require('cron-parser')
-const Attorney = require('./attorney')
-
-const QUEUES = {
-  SEND_IT: '__pgboss__send-it'
-}
-
-const EVENTS = {
-  error: 'error',
-  schedule: 'schedule',
-  warning: 'warning'
-}
-
-const WARNINGS = {
-  CLOCK_SKEW: {
-    message: 'Warning: Clock skew between this instance and the database server. This will not break scheduling, but is emitted any time the skew exceeds 60 seconds.'
-  }
-}
-
-class Timekeeper extends EventEmitter {
-  constructor (db, config) {
-    super()
-
-    this.db = db
-    this.config = config
-    this.manager = config.manager
-    this.clockSkew = 0
-    this.events = EVENTS
-
-    this.functions = [
-      this.schedule,
-      this.unschedule,
-      this.getSchedules
-    ]
-
-    this.stopped = true
-  }
-
-  async start () {
-    this.stopped = false
-
-    await this.cacheClockSkew()
-    await this.manager.createQueue(QUEUES.SEND_IT)
-
-    const options = {
-      pollingIntervalSeconds: this.config.cronWorkerIntervalSeconds,
-      batchSize: 50
-    }
-
-    await this.manager.work(QUEUES.SEND_IT, options, (jobs) => this.onSendIt(jobs))
-
-    setImmediate(() => this.onCron())
-
-    this.cronMonitorInterval = setInterval(async () => await this.onCron(), this.config.cronMonitorIntervalSeconds * 1000)
-    this.skewMonitorInterval = setInterval(async () => await this.cacheClockSkew(), this.config.clockMonitorIntervalSeconds * 1000)
-  }
-
-  async stop () {
-    if (this.stopped) {
-      return
-    }
-
-    this.stopped = true
-
-    await this.manager.offWork(QUEUES.SEND_IT)
-
-    if (this.skewMonitorInterval) {
-      clearInterval(this.skewMonitorInterval)
-      this.skewMonitorInterval = null
-    }
-
-    if (this.cronMonitorInterval) {
-      clearInterval(this.cronMonitorInterval)
-      this.cronMonitorInterval = null
-    }
-  }
-
-  async cacheClockSkew () {
-    let skew = 0
-
-    try {
-      if (this.config.__test__force_clock_monitoring_error) {
-        throw new Error(this.config.__test__force_clock_monitoring_error)
-      }
-
-      const { rows } = await this.db.executeSql(plans.getTime())
-
-      const local = Date.now()
-
-      const dbTime = parseFloat(rows[0].time)
-
-      skew = dbTime - local
-
-      const skewSeconds = Math.abs(skew) / 1000
-
-      if (skewSeconds >= 60 || this.config.__test__force_clock_skew_warning) {
-        this.emit(this.events.warning, { message: WARNINGS.CLOCK_SKEW.message, data: { seconds: skewSeconds, direction: skew > 0 ? 'slower' : 'faster' } })
-      }
-    } catch (err) {
-      this.emit(this.events.error, err)
-    } finally {
-      this.clockSkew = skew
-    }
-  }
-
-  async onCron () {
-    try {
-      if (this.stopped || this.timekeeping) return
-
-      if (this.config.__test__force_cron_monitoring_error) {
-        throw new Error(this.config.__test__force_cron_monitoring_error)
-      }
-
-      this.timekeeping = true
-
-      const sql = plans.trySetCronTime(this.config.schema, this.config.cronMonitorIntervalSeconds)
-
-      if (!this.stopped) {
-        const { rows } = await this.db.executeSql(sql)
-
-        if (!this.stopped && rows.length === 1) {
-          await this.cron()
-        }
-      }
-    } catch (err) {
-      this.emit(this.events.error, err)
-    } finally {
-      this.timekeeping = false
-    }
-  }
-
-  async cron () {
-    const schedules = await this.getSchedules()
-
-    const scheduled = schedules
-      .filter(i => this.shouldSendIt(i.cron, i.timezone))
-      .map(({ name, key, data, options }) => ({ data: { name, data, options }, singletonKey: `${name}__${key}`, singletonSeconds: 60 }))
-
-    if (scheduled.length > 0 && !this.stopped) {
-      await this.manager.insert(QUEUES.SEND_IT, scheduled)
-    }
-  }
-
-  shouldSendIt (cron, tz) {
-    const interval = CronExpressionParser.parse(cron, { tz, strict: false })
-
-    const prevTime = interval.prev()
-
-    const databaseTime = Date.now() + this.clockSkew
-
-    const prevDiff = (databaseTime - prevTime.getTime()) / 1000
-
-    return prevDiff < 60
-  }
-
-  async onSendIt (jobs) {
-    await Promise.allSettled(jobs.map(({ data }) => this.manager.send(data)))
-  }
-
-  async getSchedules (name, key = '') {
-    let sql = plans.getSchedules(this.config.schema)
-    let params = []
-
-    if (name) {
-      sql = plans.getSchedulesByQueue(this.config.schema)
-      params = [name, key]
-    }
-
-    const { rows } = await this.db.executeSql(sql, params)
-
-    return rows
-  }
-
-  async schedule (name, cron, data, options = {}) {
-    const { tz = 'UTC', key = '', ...rest } = options
-
-    CronExpressionParser.parse(cron, { tz, strict: false })
-
-    Attorney.checkSendArgs([name, data, { ...rest }])
-    Attorney.assertKey(key)
-
-    try {
-      const sql = plans.schedule(this.config.schema)
-      await this.db.executeSql(sql, [name, key, cron, tz, data, options])
-    } catch (err) {
-      if (err.message.includes('foreign key')) {
-        err.message = `Queue ${name} not found`
-      }
-
-      throw err
-    }
-  }
-
-  async unschedule (name, key = '') {
-    const sql = plans.unschedule(this.config.schema)
-    await this.db.executeSql(sql, [name, key])
-  }
-}
-
-module.exports = Timekeeper
-module.exports.QUEUES = QUEUES

package/src/tools.js

@@ -1,60 +0,0 @@
-const { setTimeout } = require('node:timers/promises')
-
-module.exports = {
-  delay,
-  resolveWithinSeconds,
-  unwrapSQLResult
-}
-
-/**
- * When sql contains multiple queries, result is an array of objects with rows property
- * This function unwraps the result into a single object with rows property
- * @param {{rows: Array<Object>} | Array<{rows: Array<Object>}>} result
- * @returns {{rows: Array<Object>}}
-*/
-function unwrapSQLResult (result) {
-  if (result instanceof Array) {
-    return { rows: result.flatMap(i => i.rows) }
-  }
-
-  return result
-}
-
-function delay (ms, error) {
-  const ac = new AbortController()
-
-  const promise = new Promise((resolve, reject) => {
-    setTimeout(ms, null, { signal: ac.signal })
-      .then(() => {
-        if (error) {
-          reject(new Error(error))
-        } else {
-          resolve()
-        }
-      })
-      .catch(resolve)
-  })
-
-  promise.abort = () => {
-    if (!ac.signal.aborted) {
-      ac.abort()
-    }
-  }
-
-  return promise
-}
-
-async function resolveWithinSeconds (promise, seconds, message) {
-  const timeout = Math.max(1, seconds) * 1000
-  const reject = delay(timeout, message)
-
-  let result
-
-  try {
-    result = await Promise.race([promise, reject])
-  } finally {
-    reject.abort()
-  }
-
-  return result
-}

package/src/worker.js

@@ -1,99 +0,0 @@
-const { delay } = require('./tools')
-
-const WORKER_STATES = {
-  created: 'created',
-  active: 'active',
-  stopping: 'stopping',
-  stopped: 'stopped'
-}
-
-class Worker {
-  constructor ({ id, name, options, interval, fetch, onFetch, onError }) {
-    this.id = id
-    this.name = name
-    this.options = options
-    this.fetch = fetch
-    this.onFetch = onFetch
-    this.onError = onError
-    this.interval = interval
-    this.jobs = []
-    this.createdOn = Date.now()
-    this.lastFetchedOn = null
-    this.lastJobStartedOn = null
-    this.lastJobEndedOn = null
-    this.lastError = null
-    this.lastErrorOn = null
-    this.state = WORKER_STATES.created
-    this.stopping = false
-    this.stopped = false
-    this.loopDelayPromise = null
-    this.beenNotified = false
-  }
-
-  notify () {
-    this.beenNotified = true
-
-    if (this.loopDelayPromise) {
-      this.loopDelayPromise.abort()
-    }
-  }
-
-  async start () {
-    this.state = WORKER_STATES.active
-
-    while (!this.stopping) {
-      const started = Date.now()
-
-      try {
-        this.beenNotified = false
-        const jobs = await this.fetch()
-
-        this.lastFetchedOn = Date.now()
-
-        if (jobs) {
-          this.jobs = jobs
-
-          this.lastJobStartedOn = this.lastFetchedOn
-
-          await this.onFetch(jobs)
-
-          this.lastJobEndedOn = Date.now()
-
-          this.jobs = []
-        }
-      } catch (err) {
-        this.lastErrorOn = Date.now()
-        this.lastError = err
-
-        err.message = `${err.message} (Queue: ${this.name}, Worker: ${this.id})`
-
-        this.onError(err)
-      }
-
-      const duration = Date.now() - started
-
-      this.lastJobDuration = duration
-
-      if (!this.stopping && !this.beenNotified && (this.interval - duration) > 100) {
-        this.loopDelayPromise = delay(this.interval - duration)
-        await this.loopDelayPromise
-        this.loopDelayPromise = null
-      }
-    }
-
-    this.stopping = false
-    this.stopped = true
-    this.state = WORKER_STATES.stopped
-  }
-
-  stop () {
-    this.stopping = true
-    this.state = WORKER_STATES.stopping
-
-    if (this.loopDelayPromise) {
-      this.loopDelayPromise.abort()
-    }
-  }
-}
-
-module.exports = Worker

package/types.d.ts

@@ -1,323 +0,0 @@
-import { EventEmitter } from 'events'
-
-declare namespace PgBoss {
-
-  type JobStates = {
-    created: 'created',
-    retry: 'retry',
-    active: 'active',
-    completed: 'completed',
-    cancelled: 'cancelled',
-    failed: 'failed'
-  }
-
-  type QueuePolicies = {
-    standard: 'standard'
-    short: 'short',
-    singleton: 'singleton',
-    stately: 'stately'
-  }
-
-  interface Db {
-    executeSql(text: string, values: any[]): Promise<{ rows: any[] }>;
-  }
-
-  interface DatabaseOptions {
-    application_name?: string;
-    database?: string;
-    user?: string;
-    password?: string | (() => string) | (() => Promise<string>);
-    host?: string;
-    port?: number;
-    schema?: string;
-    ssl?: any;
-    connectionString?: string;
-    max?: number;
-    db?: Db;
-  }
-
-  interface SchedulingOptions {
-    schedule?: boolean;
-    clockMonitorIntervalSeconds?: number;
-    cronWorkerIntervalSeconds?: number;
-    cronMonitorIntervalSeconds?: number;
-  }
-
-  interface MaintenanceOptions {
-    supervise?: boolean;
-    migrate?: boolean;
-    warningSlowQuerySeconds?: number;
-    warningQueueSize?: number;
-    superviseIntervalSeconds?: number;
-    maintenanceIntervalSeconds?: number;
-    queueCacheIntervalSeconds?: number;
-    monitorIntervalSeconds?: number;
-  }
-
-  type ConstructorOptions = DatabaseOptions & SchedulingOptions & MaintenanceOptions
-
-  interface QueueOptions {
-    expireInSeconds?: number;
-    retentionSeconds?: number;
-    deleteAfterSeconds?: number;
-    retryLimit?: number;
-    retryDelay?: number;
-    retryBackoff?: boolean;
-    retryDelayMax?: number;
-  }
-
-  interface JobOptions {
-    id?: string;
-    priority?: number;
-    startAfter?: number | string | Date;
-    singletonKey?: string;
-    singletonSeconds?: number;
-    singletonNextSlot?: boolean;
-  }
-
-  interface ConnectionOptions {
-    db?: Db;
-  }
-
-  type InsertOptions = ConnectionOptions
-
-  type SendOptions = JobOptions & QueueOptions & ConnectionOptions
-
-  type QueuePolicy = 'standard' | 'short' | 'singleton' | 'stately' | 'exclusive'
-
-  type Queue = {
-    name: string;
-    policy?: QueuePolicy;
-    partition?: boolean;
-    deadLetter?: string;
-    warningQueueSize?: number;
-  } & QueueOptions
-
-  type QueueResult = Queue & {
-    deferredCount: number;
-    queuedCount: number;
-    activeCount: number;
-    totalCount: number
-    table: number;
-    createdOn: Date;
-    updatedOn: Date;
-  }
-
-  type ScheduleOptions = SendOptions & { tz?: string, key?: string }
-
-  interface JobPollingOptions {
-    pollingIntervalSeconds?: number;
-  }
-
-  interface JobFetchOptions {
-    includeMetadata?: boolean;
-    priority?: boolean;
-    batchSize?: number;
-    ignoreStartAfter?: boolean;
-  }
-
-  type WorkOptions = JobFetchOptions & JobPollingOptions
-  type FetchOptions = JobFetchOptions & ConnectionOptions
-
-  interface WorkHandler<ReqData> {
-    (job: PgBoss.Job<ReqData>[]): Promise<any>;
-  }
-
-  interface WorkWithMetadataHandler<ReqData> {
-    (job: PgBoss.JobWithMetadata<ReqData>[]): Promise<any>;
-  }
-
-  interface Request {
-    name: string;
-    data?: object;
-    options?: SendOptions;
-  }
-
-  interface Schedule {
-    name: string;
-    key: string;
-    cron: string;
-    timezone: string;
-    data?: object;
-    options?: SendOptions;
-  }
-
-  interface Job<T = object> {
-    id: string;
-    name: string;
-    data: T;
-    expireInSeconds: number;
-  }
-
-  interface JobWithMetadata<T = object> extends Job<T> {
-    priority: number;
-    state: 'created' | 'retry' | 'active' | 'completed' | 'cancelled' | 'failed';
-    retryLimit: number;
-    retryCount: number;
-    retryDelay: number;
-    retryBackoff: boolean;
-    retryDelayMax?: number;
-    startAfter: Date;
-    startedOn: Date;
-    singletonKey: string | null;
-    singletonOn: Date | null;
-    expireInSeconds: number;
-    deleteAfterSeconds: number;
-    createdOn: Date;
-    completedOn: Date | null;
-    keepUntil: Date;
-    policy: QueuePolicy;
-    deadLetter: string;
-    output: object;
-  }
-
-  interface JobInsert<T = object> {
-    id?: string;
-    name: string;
-    data?: T;
-    priority?: number;
-    retryLimit?: number;
-    retryDelay?: number;
-    retryBackoff?: boolean;
-    retryDelayMax?: number;
-    startAfter?: Date | string;
-    singletonKey?: string;
-    singletonSeconds?: number;
-    expireInSeconds?: number;
-    deleteAfterSeconds?: number;
-    retentionSeconds?: number;
-  }
-
-  interface Worker {
-    id: string;
-    name: string;
-    options: WorkOptions;
-    state: 'created' | 'active' | 'stopping' | 'stopped';
-    count: number;
-    createdOn: Date;
-    lastFetchedOn: Date;
-    lastJobStartedOn: Date;
-    lastJobEndedOn: Date;
-    lastJobDuration: number;
-    lastError: object;
-    lastErrorOn: Date;
-  }
-
-  interface StopOptions {
-    close?: boolean;
-    graceful?: boolean;
-    timeout?: number;
-    wait?: boolean;
-  }
-
-  interface OffWorkOptions {
-    id: string
-  }
-
-}
-
-declare class PgBoss extends EventEmitter {
-  constructor (connectionString: string)
-  constructor (options: PgBoss.ConstructorOptions)
-
-  static getConstructionPlans (schema?: string): string
-  static getMigrationPlans (schema?: string, version?: string): string
-  static getRollbackPlans (schema?: string, version?: string): string
-
-  static states: PgBoss.JobStates
-  static policies: PgBoss.QueuePolicies
-
-  on (event: 'error', handler: (error: Error) => void): this
-  off (event: 'error', handler: (error: Error) => void): this
-
-  on (event: 'warning', handler: (warning: { message: string, data: object }) => void): this
-  off (event: 'warning', handler: (warning: { message: string, data: object }) => void): this
-
-  on (event: 'wip', handler: (data: PgBoss.Worker[]) => void): this
-  off (event: 'wip', handler: (data: PgBoss.Worker[]) => void): this
-
-  on (event: 'stopped', handler: () => void): this
-  off (event: 'stopped', handler: () => void): this
-
-  start (): Promise<PgBoss>
-  stop (options?: PgBoss.StopOptions): Promise<void>
-
-  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>
-
-  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>
-
-  sendThrottled (name: string, data: object, options: PgBoss.SendOptions, seconds: number, key?: string): Promise<string | null>
-  sendDebounced (name: string, data: object, options: PgBoss.SendOptions, seconds: number, key?: string): Promise<string | null>
-
-  insert (name: string, jobs: PgBoss.JobInsert[]): Promise<void>
-  insert (name: string, jobs: PgBoss.JobInsert[], options: PgBoss.InsertOptions): Promise<void>
-
-  fetch<T>(name: string): Promise<PgBoss.Job<T>[]>
-  fetch<T>(name: string, options: PgBoss.FetchOptions & { includeMetadata: true }): Promise<PgBoss.JobWithMetadata<T>[]>
-  fetch<T>(name: string, options: PgBoss.FetchOptions): Promise<PgBoss.Job<T>[]>
-
-  work<ReqData>(name: string, handler: PgBoss.WorkHandler<ReqData>): Promise<string>
-  work<ReqData>(name: string, options: PgBoss.WorkOptions & { includeMetadata: true }, handler: PgBoss.WorkWithMetadataHandler<ReqData>): Promise<string>
-  work<ReqData>(name: string, options: PgBoss.WorkOptions, handler: PgBoss.WorkHandler<ReqData>): Promise<string>
-
-  offWork (name: string): Promise<void>
-  offWork (options: PgBoss.OffWorkOptions): Promise<void>
-
-  notifyWorker (workerId: string): void
-
-  subscribe (event: string, name: string): Promise<void>
-  unsubscribe (event: string, name: string): Promise<void>
-  publish (event: string): Promise<void>
-  publish (event: string, data: object): Promise<void>
-  publish (event: string, data: object, options: PgBoss.SendOptions): Promise<void>
-
-  cancel (name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>
-  cancel (name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>
-
-  resume (name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>
-  resume (name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>
-
-  retry (name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>
-  retry (name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>
-
-  deleteJob (name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>
-  deleteJob (name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>
-  deleteQueuedJobs (name: string): Promise<void>
-  deleteStoredJobs (name: string): Promise<void>
-  deleteAllJobs (name: string): Promise<void>
-
-  complete (name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>
-  complete (name: string, id: string, data: object, options?: PgBoss.ConnectionOptions): Promise<void>
-  complete (name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>
-
-  fail (name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<void>
-  fail (name: string, id: string, data: object, options?: PgBoss.ConnectionOptions): Promise<void>
-  fail (name: string, ids: string[], options?: PgBoss.ConnectionOptions): Promise<void>
-
-  getJobById<T>(name: string, id: string, options?: PgBoss.ConnectionOptions): Promise<PgBoss.JobWithMetadata<T> | null>
-
-  createQueue (name: string, options?: Omit<PgBoss.Queue, 'name'>): Promise<void>
-  createQueue (options: PgBoss.Queue): Promise<void>
-  updateQueue (name: string, options?: Omit<PgBoss.Queue, 'name', 'partition', 'policy'>): Promise<void>
-  updateQueue (options: Omit<PgBoss.Queue, 'partition', 'policy'>): Promise<void>
-  deleteQueue (name: string): Promise<void>
-  getQueues (): Promise<PgBoss.QueueResult[]>
-  getQueue (name: string): Promise<PgBoss.QueueResult | null>
-  getQueueStats (name: string): Promise<PgBoss.QueueResult>
-
-  supervise (name?: string): Promise<void>
-  isInstalled (): Promise<boolean>
-  schemaVersion (): Promise<number>
-
-  schedule (name: string, cron: string, data?: object, options?: PgBoss.ScheduleOptions): Promise<void>
-  unschedule (name: string, key?: string): Promise<void>
-  getSchedules (name?: string, key?: string): Promise<PgBoss.Schedule[]>
-
-  getDb (): PgBoss.Db
-}
-
-export = PgBoss

package/version.json

@@ -1,3 +0,0 @@
-{
-  "schema": 26
-}