@data-fair/lib-node 1.3.1 → 2.0.0

package/events-queue.d.ts

@@ -1,4 +1,5 @@
 import { type Event } from '@data-fair/lib-common-types/event/index.js';
+import { type Notification } from '@data-fair/lib-common-types/notification/index.js';
 type EventsQueueOptions = {
     eventsUrl: string;
     eventsSecret: string;
@@ -6,4 +7,5 @@ type EventsQueueOptions = {
 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 {};

package/events-queue.js

@@ -5,7 +5,8 @@ const options = () => {
   if (!_options) { throw new Error('events queue was not initialized') }
   return _options
 }
-let queue = []
+let eventsQueue = []
+let notificationsQueue = []
 let stopped = false
 let currentDrainPromise
 const loop = async () => {
@@ -22,10 +23,18 @@ const loop = async () => {
   }
 }
 const drain = async () => {
-  if (queue.length === 0) { return }
-  const events = queue
-  queue = []
-  await axios.post(options().eventsUrl + '/api/events', events, { headers: { 'x-secret-key': options().eventsSecret } })
+  if (eventsQueue.length) {
+    const events = eventsQueue
+    eventsQueue = []
+    await axios.post(options().eventsUrl + '/api/events', events, { headers: { 'x-secret-key': options().eventsSecret } })
+  }
+  if (notificationsQueue.length) {
+    const notifications = notificationsQueue
+    notificationsQueue = []
+    for (const notification of notifications) {
+      await axios.post(options().eventsUrl + '/api/notifications', notification, { headers: { 'x-secret-key': options().eventsSecret } })
+    }
+  }
 }
 export const start = async (options) => {
   _options = options
@@ -37,7 +46,12 @@ export const stop = async () => {
   await drain()
 }
 export const pushEvent = (event) => {
-  if (stopped) { throw new Error('events queue as been stopped') }
-  queue.push(event)
+  if (stopped) { throw new Error('events queue has been stopped') }
   event.date = new Date().toISOString()
+  eventsQueue.push(event)
+}
+export const pushNotification = (notification) => {
+  if (stopped) { throw new Error('notifications queue has been stopped') }
+  notification.date = new Date().toISOString()
+  notificationsQueue.push(notification)
 }

package/locks.d.ts

@@ -1,5 +1,21 @@
 import type { Db } from 'mongodb';
-export declare const init: (db: Db, ttl?: number) => Promise<void>;
-export declare const stop: () => Promise<void>;
-export declare function acquire(_id: string, origin?: string): Promise<boolean>;
-export declare const release: (_id: string, delay?: number) => Promise<void>;
+export declare class Locks {
+    pid: string;
+    private interval;
+    private _db;
+    get db(): Db;
+    get collection(): import("mongodb").Collection<{
+        _id: string;
+        pid: string;
+        origin?: string;
+        hostname: string;
+        createdAt: Date;
+    }>;
+    constructor();
+    start: (db: Db, ttl?: number) => Promise<void>;
+    stop: () => Promise<void>;
+    acquire: (_id: string, origin?: string) => Promise<boolean>;
+    release: (_id: string, delay?: number) => Promise<void>;
+}
+declare const locks: Locks;
+export default locks;

package/locks.js

@@ -2,62 +2,72 @@ import { hostname } from 'node:os'
 import { randomBytes } from 'node:crypto'
 import Debug from 'debug'
 const debug = Debug('locks')
-const pid = randomBytes(8).toString('hex')
-debug('locks with pid', pid)
-let interval
-let _db
-const collection = () => {
-  if (!_db) { throw new Error('locks utils was not initialized') }
-  return _db?.collection('locks')
-}
-export const init = async (db, ttl = 60) => {
-  _db = db
-  const locks = collection()
-  await locks.createIndex({ pid: 1 })
-  try {
-    await locks.createIndex({ updatedAt: 1 }, { expireAfterSeconds: ttl })
-  } catch (err) {
-    console.log('Failure to create TTL index. Probably because the value changed. Try to update it.')
-    db.command({ collMod: 'locks', index: { keyPattern: { updatedAt: 1 }, expireAfterSeconds: ttl } })
+export class Locks {
+  pid
+  interval
+  _db
+  get db () {
+    if (!this._db) { throw new Error('locks utils was not initialized') }
+    return this._db
   }
-  // prolongate lock acquired by this process while it is still active
-  interval = setInterval(() => {
-    locks.updateMany({ pid }, { $currentDate: { updatedAt: true } })
-  }, (ttl / 2) * 1000)
-}
-export const stop = async () => {
-  clearInterval(interval)
-  if (_db) { await collection().deleteMany({ pid }) }
-}
-export async function acquire (_id, origin) {
-  if (!_db) { throw new Error('locks not initialized') }
-  debug('acquire', _id, origin)
-  const locks = collection()
-  try {
-    await locks.insertOne({ _id, pid, origin, hostname: hostname(), createdAt: new Date() })
+
+  get collection () {
+    return this.db.collection('locks')
+  }
+
+  constructor () {
+    this.pid = randomBytes(8).toString('hex')
+    debug('locks with pid', this.pid)
+  }
+
+  start = async (db, ttl = 60) => {
+    await this.collection.createIndex({ pid: 1 })
     try {
-      await locks.updateOne({ _id }, { $currentDate: { updatedAt: true } })
+      await this.collection.createIndex({ updatedAt: 1 }, { expireAfterSeconds: ttl })
     } catch (err) {
-      await locks.deleteOne({ _id, pid })
-      throw err
+      console.log('Failure to create TTL index. Probably because the value changed. Try to update it.')
+      db.command({ collMod: 'locks', index: { keyPattern: { updatedAt: 1 }, expireAfterSeconds: ttl } })
     }
-    debug('acquire ok', _id)
-    return true
-  } catch (err) {
-    if (err.code !== 11000) { throw err }
-    // duplicate means the lock was already acquired
-    debug('acquire ko', _id)
-    return false
+    // prolongate lock acquired by this process while it is still active
+    this.interval = setInterval(() => {
+      this.collection.updateMany({ pid: this.pid }, { $currentDate: { updatedAt: true } })
+    }, (ttl / 2) * 1000)
   }
-}
-export const release = async (_id, delay = 0) => {
-  if (!_db) { throw new Error('locks not initialized') }
-  debug('release', _id)
-  const locks = collection()
-  if (delay) {
-    const date = new Date((new Date()).getTime() + delay)
-    await locks.updateOne({ _id, pid }, { $unset: { pid: 1 }, $set: { delayed: true, updatedAt: date } })
-  } else {
-    await locks.deleteOne({ _id, pid })
+
+  stop = async () => {
+    clearInterval(this.interval)
+    if (this._db) { await this.collection.deleteMany({ pid: this.pid }) }
+  }
+
+  acquire = async (_id, origin) => {
+    debug('acquire', _id, origin)
+    try {
+      await this.collection.insertOne({ _id, pid: this.pid, origin, hostname: hostname(), createdAt: new Date() })
+      try {
+        await this.collection.updateOne({ _id }, { $currentDate: { updatedAt: true } })
+      } catch (err) {
+        await this.collection.deleteOne({ _id, pid: this.pid })
+        throw err
+      }
+      debug('acquire ok', _id)
+      return true
+    } catch (err) {
+      if (err.code !== 11000) { throw err }
+      // duplicate means the lock was already acquired
+      debug('acquire ko', _id)
+      return false
+    }
+  }
+
+  release = async (_id, delay = 0) => {
+    debug('release', _id)
+    if (delay) {
+      const date = new Date((new Date()).getTime() + delay)
+      await this.collection.updateOne({ _id, pid: this.pid }, { $unset: { pid: 1 }, $set: { delayed: true, updatedAt: date } })
+    } else {
+      await this.collection.deleteOne({ _id, pid: this.pid })
+    }
   }
 }
+const locks = new Locks()
+export default locks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@data-fair/lib-node",
-  "version": "1.3.1",
+  "version": "2.0.0",
   "description": "Small nodejs related utility functions for the data-fair stack.",
   "main": "index.js",
   "files": [
@@ -14,7 +14,7 @@
     "build": "cd .. && npm run build"
   },
   "dependencies": {
-    "@data-fair/lib-common-types": "^1.1.0",
+    "@data-fair/lib-common-types": "^1.5.0",
     "@data-fair/lib-utils": "^1.1.0",
     "agentkeepalive": "^4.5.0",
     "ajv-formats": "^3.0.1",

package/upgrade-scripts.d.ts

@@ -1,7 +1,8 @@
 import type { Db } from 'mongodb';
 import type { Debugger } from 'debug';
+import type { Locks } from './locks.js';
 export interface UpgradeScript {
     description: string;
     exec: (db: Db, debug: Debugger) => Promise<void>;
 }
-export default function (db: Db, basePath?: string): Promise<void>;
+export default function (db: Db, locks: Locks, basePath?: string): Promise<void>;

package/upgrade-scripts.js

@@ -2,11 +2,10 @@ import semver from 'semver'
 import path from 'path'
 import { readdirSync, readFileSync } from 'fs'
 import Debug from 'debug'
-import { acquire, release } from './locks.js'
 const debug = Debug('upgrade')
 // chose the proper scripts to execute, then run them
-export default async function (db, basePath = './') {
-  const ack = await acquire('upgrade')
+export default async function (db, locks, basePath = './') {
+  const ack = await locks.acquire('upgrade')
   if (!ack) {
     console.warn('upgrade scripts lock is already acquired, skip them')
     // IMPORTANT: this behaviour of running the process when the upgrade scripts are still running on another one
@@ -16,7 +15,7 @@ export default async function (db, basePath = './') {
     // are not considered "up" and the previous versions keep running in the mean time
   } else {
     await runScripts(db, basePath)
-    await release('upgrade')
+    await locks.release('upgrade')
   }
 }
 async function runScripts (db, basePath) {