Class MaintenanceWorker

src/app/maintenance-worker.ts:73–250

}

export class MaintenanceWorker implements IRunnable {
  private interval: NodeJS.Timeout | undefined
  private isRunning = false

  public constructor(
    private readonly process: NodeJS.Process,
    private readonly paymentsService: IPaymentsService,
    private readonly maintenanceService: IMaintenanceService,
    private readonly settings: () => Settings,
    private readonly nip05VerificationRepository: INip05VerificationRepository,
  ) {
    this.process
      .on('SIGINT', this.onExit.bind(this))
      .on('SIGHUP', this.onExit.bind(this))
      .on('SIGTERM', this.onExit.bind(this))
      .on('uncaughtException', this.onError.bind(this))
      .on('unhandledRejection', this.onError.bind(this))
  }

  private async clearOldEventsSafely(): Promise<void> {
    try {
      await Promise.race([
        this.maintenanceService.clearOldEvents(),
        delayMs(CLEAR_OLD_EVENTS_TIMEOUT_MS).then(() => {
          throw new Error(`clearOldEvents timed out after ${CLEAR_OLD_EVENTS_TIMEOUT_MS}ms`)
        }),
      ])
    } catch (error) {
      logger('unable to clear old events: %o', error)
    }
  }

  public run(): void {
    this.interval = setInterval(async () => {
      if (this.isRunning) {
        logger('skipping scheduled maintenance run because previous run is still in progress')
        return
      }

      this.isRunning = true
      try {
        await this.onSchedule()
      } catch (error) {
        this.onError(error as Error)
      } finally {
        this.isRunning = false
      }
    }, UPDATE_INVOICE_INTERVAL)
  }

  private async onSchedule(): Promise<void> {
    const currentSettings = this.settings()
    const clearOldEventsPromise = this.clearOldEventsSafely()

    await this.processNip05Reverifications(currentSettings)

    if (!path(['payments', 'enabled'], currentSettings)) {
      await clearOldEventsPromise