mongo-locks 3.0.2 → 3.1.0

package/README.md

@@ -5,6 +5,10 @@ Simple and bountiful locks to avoid doing the same operation multiple times
 The purpose of this package is simply to avoid doing the same thing twice at the same time
 and make your system a bit more user-proof.
 
+```bash
+npm install mongo-locks
+```
+
 ```ts
 import { LockManager } from "mongo-locks";
 import { MongoClient } from "mongodb";
@@ -13,7 +17,7 @@ const client = new MongoClient("mongodb://localhost:27017");
 const lockManager = new LockManager(client.db().collection("mongo-locks"));
 
 async function doStuff() {
-  await using lock = lockManager.lock("unique string key");
+  await using lock = await lockManager.lock("unique string key");
 
   if (!lock) {
     console.log("Lock already taken");

package/dist/commonjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/esm/index.js

@@ -0,0 +1,113 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ObjectId } from "mongodb";
+export class MongoLocksError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+const makeKey = (key) => {
+    // Arrays mess up the unique MongoDB indexes
+    return Array.isArray(key) ? { _key_array: key } : key;
+};
+class Lock {
+    constructor(_id, action, collection) {
+        this._id = _id;
+        this.action = action;
+        this.collection = collection;
+        this.locked = true;
+        if (this.locked) {
+            (() => __awaiter(this, void 0, void 0, function* () {
+                while (this.locked) {
+                    yield new Promise((resolve) => setTimeout(resolve, 10000));
+                    yield this.refresh().catch(() => {
+                        console.error("Failed to refresh lock", action);
+                    });
+                }
+            }))();
+        }
+    }
+    /**
+     * Instead of calling `this.free` directly you can use the `using` syntax
+     *
+     * @returns true if the lock was successfully released. False if the lock was not found
+     */
+    free() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.locked) {
+                return false;
+            }
+            this.locked = false;
+            const result = yield this.collection.deleteOne({ _id: this._id });
+            return result.deletedCount === 1;
+        });
+    }
+    /**
+     * Refreshes the lock's TTL
+     *
+     * Automatically called every 10 seconds if the lock is still active, no
+     * need to call this manually
+     *
+     * @returns true if the lock was successfully refreshed. False if the lock was not found
+     */
+    refresh() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.locked) {
+                return false;
+            }
+            const res = yield this.collection.updateOne({ _id: this._id }, { $set: { refreshedAt: new Date(), expiresAt: new Date(Date.now() + 60000) } });
+            this.locked = res.matchedCount === 1;
+            return this.locked;
+        });
+    }
+    [Symbol.dispose]() {
+        this.free();
+    }
+    [Symbol.asyncDispose]() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.free();
+        });
+    }
+}
+export class LockManager {
+    constructor(collection) {
+        this.MongoLocksError = MongoLocksError;
+        this.collection = collection;
+        collection.createIndex({ action: 1 }, { unique: true });
+        collection.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+    }
+    /**
+     * Creates a DB lock based on the key provided
+     *
+     * @returns a function that when called will release the lock
+     */
+    lock(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lockId = makeKey(key);
+            const id = new ObjectId();
+            try {
+                yield this.collection.insertOne({
+                    _id: id,
+                    action: lockId,
+                    createdAt: new Date(),
+                    refreshedAt: new Date(),
+                    expiresAt: new Date(Date.now() + 60000),
+                });
+                return new Lock(id, lockId, this.collection);
+            }
+            catch (err) {
+                if (err instanceof Error && "code" in err && err.code === 11000) {
+                    return null;
+                }
+                throw err;
+            }
+        });
+    }
+}

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "mongo-locks",
-  "version": "3.0.2",
+  "type": "module",
+  "version": "3.1.0",
   "description": "Simple and bountiful locks to avoid doing the same operation multiple times",
-  "main": "dist/index.js",
+  "main": "./dist/commonjs/index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "prepublishOnly": "npm run clean && tsc",
-    "clean": "rm -Rf dist"
+    "prepare": "tshy"
   },
   "repository": {
     "type": "git",
@@ -29,8 +29,9 @@
     "mongodb": ">=4"
   },
   "devDependencies": {
-    "@types/node": "^20.12.7",
+    "@types/node": "^22.12.7",
     "mongodb": "^6.5.0",
+    "tshy": "^3.1.0",
     "typescript": "^5.4.5"
   },
   "files": [
@@ -38,5 +39,26 @@
     "index.d.ts",
     "index.ts",
     "tsconfig.json"
-  ]
+  ],
+  "tshy": {
+    "exports": {
+      "./package.json": "./package.json",
+      ".": "./src/index.ts"
+    }
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    }
+  },
+  "types": "./dist/commonjs/index.d.ts",
+  "module": "./dist/esm/index.js"
 }

package/index.ts

@@ -1,125 +0,0 @@
-import { Collection, ObjectId } from "mongodb";
-
-export class MongoLocksError extends Error {
-  constructor(message?: string) {
-    super(message);
-  }
-}
-
-const makeKey = (key: unknown) => {
-  // Arrays mess up the unique MongoDB indexes
-  return Array.isArray(key) ? { _key_array: key } : key;
-};
-
-interface LockModel {
-  _id: ObjectId;
-  action: unknown;
-  createdAt: Date;
-  refreshedAt: Date;
-  expiresAt: Date;
-}
-
-class Lock {
-  constructor(public _id: ObjectId, public action: unknown, public collection: Collection<LockModel>) {
-    if (this.locked) {
-      (async () => {
-        while (this.locked) {
-          await new Promise((resolve) => setTimeout(resolve, 10_000));
-          await this.refresh().catch(() => {
-            console.error("Failed to refresh lock", action);
-          });
-        }
-      })();
-    }
-  }
-
-  locked = true;
-
-  /**
-   * Instead of calling `this.free` directly you can use the `using` syntax
-   *
-   * @returns true if the lock was successfully released. False if the lock was not found
-   */
-  async free(): Promise<boolean> {
-    if (!this.locked) {
-      return false;
-    }
-    this.locked = false;
-
-    const result = await this.collection.deleteOne({ _id: this._id });
-    return result.deletedCount === 1;
-  }
-
-  /**
-   * Refreshes the lock's TTL
-   *
-   * Automatically called every 10 seconds if the lock is still active, no
-   * need to call this manually
-   *
-   * @returns true if the lock was successfully refreshed. False if the lock was not found
-   */
-  async refresh(): Promise<boolean> {
-    if (!this.locked) {
-      return false;
-    }
-
-    const res = await this.collection.updateOne(
-      { _id: this._id },
-      { $set: { refreshedAt: new Date(), expiresAt: new Date(Date.now() + 60_000) } }
-    );
-
-    this.locked = res.matchedCount === 1;
-
-    return this.locked;
-  }
-
-  [Symbol.dispose]() {
-    this.free();
-  }
-
-  async [Symbol.asyncDispose]() {
-    return this.free();
-  }
-}
-
-export class LockManager {
-  collection: Collection<LockModel>;
-  MongoLocksError = MongoLocksError;
-
-  constructor(collection: Collection) {
-    this.collection = collection as unknown as Collection<LockModel>;
-
-    collection.createIndex({ action: 1 }, { unique: true });
-    collection.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 });
-  }
-
-  /**
-   * Creates a DB lock based on the key provided
-   *
-   * @returns a function that when called will release the lock
-   */
-  async lock(key: unknown): Promise<Lock | null> {
-    const lockId = makeKey(key);
-    const id = new ObjectId();
-
-    try {
-      await this.collection.insertOne({
-        _id: id,
-        action: lockId,
-        createdAt: new Date(),
-        refreshedAt: new Date(),
-        expiresAt: new Date(Date.now() + 60_000),
-      });
-
-      return new Lock(id, lockId, this.collection);
-    } catch (err) {
-      if (err instanceof Error && "code" in err && err.code === 11000) {
-        return null;
-      }
-
-      throw err;
-    }
-  }
-}
-
-export type { LockModel, Lock };