@data-fair/lib-node 2.1.4 → 2.2.0

package/events-queue.d.ts

@@ -4,8 +4,19 @@ type EventsQueueOptions = {
     eventsUrl: string;
     eventsSecret: string;
 };
-export declare const start: (options: EventsQueueOptions) => Promise<void>;
-export declare const stop: () => Promise<void>;
-export declare const pushEvent: (event: Omit<Event, "date">) => void;
-export declare const pushNotification: (notification: Omit<Notification, "date">) => void;
-export {};
+export declare class EventsQueue {
+    _options: EventsQueueOptions | undefined;
+    eventsQueue: Event[];
+    notificationsQueue: Notification[];
+    stopped: boolean;
+    currentDrainPromise: Promise<void> | undefined;
+    options(): EventsQueueOptions;
+    start: (options: EventsQueueOptions) => Promise<void>;
+    stop: () => Promise<void>;
+    loop(): Promise<void>;
+    drain(): Promise<void>;
+    pushEvent(event: Omit<Event, 'date'>): void;
+    pushNotification(notification: Omit<Notification, 'date'>): void;
+}
+declare const eventsQueue: EventsQueue;
+export default eventsQueue;

package/events-queue.js

@@ -2,64 +2,74 @@ import { internalError } from '@data-fair/lib-node/observer.js'
 import axios from './axios.js'
 import Debug from 'debug'
 const debug = Debug('events-queue')
-let _options
-const options = () => {
-  if (!_options) { throw new Error('events queue was not initialized') }
-  return _options
-}
-let eventsQueue = []
-let notificationsQueue = []
-let stopped = false
-let currentDrainPromise
-const loop = async () => {
-  // eslint-disable-next-line no-unmodified-loop-condition
-  while (!stopped) {
-    await new Promise(resolve => setTimeout(resolve, 3000))
-    try {
-      currentDrainPromise = drain()
-      await currentDrainPromise
-      currentDrainPromise = undefined
-    } catch (err) {
-      internalError('events-queue-drain', err)
-    }
+export class EventsQueue {
+  _options
+  eventsQueue = []
+  notificationsQueue = []
+  stopped = false
+  currentDrainPromise
+  options () {
+    if (!this._options) { throw new Error('events queue was not initialized') }
+    return this._options
   }
-}
-const drain = async () => {
-  if (eventsQueue.length) {
-    const events = eventsQueue
-    eventsQueue = []
-    debug('drain events', events.length)
-    await axios.post(options().eventsUrl + '/api/events', events, { headers: { 'x-secret-key': options().eventsSecret } })
+
+  start = async (options) => {
+    if (this._options) { throw new Error('events queue was already initialized') }
+    this._options = options
+    this.loop()
+  }
+
+  stop = async () => {
+    this.stopped = true
+    if (this.currentDrainPromise) { await this.currentDrainPromise }
+    await this.drain()
   }
-  if (notificationsQueue.length) {
-    const notifications = notificationsQueue
-    notificationsQueue = []
-    debug('drain notifications', notifications.length)
-    for (const notification of notifications) {
-      await axios.post(options().eventsUrl + '/api/notifications', notification, { headers: { 'x-secret-key': options().eventsSecret } })
+
+  async loop () {
+    while (!this.stopped) {
+      await new Promise(resolve => setTimeout(resolve, 3000))
+      try {
+        this.currentDrainPromise = this.drain()
+        await this.currentDrainPromise
+        this.currentDrainPromise = undefined
+      } catch (err) {
+        internalError('events-queue-drain', err)
+      }
     }
   }
+
+  async drain () {
+    if (this.eventsQueue.length) {
+      const events = this.eventsQueue
+      this.eventsQueue = []
+      debug('drain events', events.length)
+      await axios.post(this.options().eventsUrl + '/api/events', events, { headers: { 'x-secret-key': this.options().eventsSecret } })
+    }
+    if (this.notificationsQueue.length) {
+      const notifications = this.notificationsQueue
+      this.notificationsQueue = []
+      debug('drain notifications', notifications.length)
+      for (const notification of notifications) {
+        await axios.post(this.options().eventsUrl + '/api/notifications', notification, { headers: { 'x-secret-key': this.options().eventsSecret } })
+      }
+    }
+  }
+
+  pushEvent (event) {
+    this.options()
+    if (this.stopped) { throw new Error('events queue has been stopped') }
+    event.date = new Date().toISOString()
+    debug('pushEvent', event)
+    this.eventsQueue.push(event)
+  }
+
+  pushNotification (notification) {
+    this.options()
+    if (this.stopped) { throw new Error('notifications queue has been stopped') }
+    notification.date = new Date().toISOString()
+    debug('pushNotification', notification)
+    this.notificationsQueue.push(notification)
+  }
 }
-export const start = async (options) => {
-  _options = options
-  loop()
-}
-export const stop = async () => {
-  stopped = true
-  if (currentDrainPromise) { await currentDrainPromise }
-  await drain()
-}
-export const pushEvent = (event) => {
-  options()
-  if (stopped) { throw new Error('events queue has been stopped') }
-  event.date = new Date().toISOString()
-  debug('pushEvent', event)
-  eventsQueue.push(event)
-}
-export const pushNotification = (notification) => {
-  options()
-  if (stopped) { throw new Error('notifications queue has been stopped') }
-  notification.date = new Date().toISOString()
-  debug('pushNotification', notification)
-  notificationsQueue.push(notification)
-}
+const eventsQueue = new EventsQueue()
+export default eventsQueue

package/locks.js

@@ -21,6 +21,7 @@ export class Locks {
   }
 
   start = async (db, ttl = 60) => {
+    if (this._db) { throw new Error('locks utils was already initialized') }
     this._db = db
     await this.collection.createIndex({ pid: 1 })
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@data-fair/lib-node",
-  "version": "2.1.4",
+  "version": "2.2.0",
   "description": "Small nodejs related utility functions for the data-fair stack.",
   "main": "index.js",
   "files": [