@data-fair/lib-node 1.4.0 → 2.0.0

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.4.0",
+  "version": "2.0.0",
   "description": "Small nodejs related utility functions for the data-fair stack.",
   "main": "index.js",
   "files": [

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) {