gcf-common-lib 0.21.3 → 0.22.4

package/package.json

@@ -1,17 +1,14 @@
 {
   "name": "gcf-common-lib",
   "description": "",
-  "version": "0.21.3",
+  "version": "0.22.4",
   "publishConfig": {
     "access": "public",
     "branches": [
       "master"
     ]
   },
-  "engines": {
-    "node": ">=14",
-    "npm": ">=8"
-  },
+  "engines": {},
   "main": "src/index",
   "scripts": {
     "test": "echo \"Error: no test specified\" || exit 0"
@@ -21,15 +18,19 @@
     "url": "https://github.com/TopTechnologies/gcf-common.git"
   },
   "dependencies": {
-    "@google-cloud/pubsub": "^3.2.0",
-    "@google-cloud/secret-manager": "^4.1.3",
-    "@google-cloud/storage": "^6.5.2",
-    "lodash": "^4.17.21"
+    "@google-cloud/pubsub": "^3.2.1",
+    "@google-cloud/secret-manager": "^4.2.0",
+    "@google-cloud/storage": "^6.9.0",
+    "bluebird": "^3.7.2",
+    "lodash": "^4.17.21",
+    "moment": "^2.29.4",
+    "mongodb": "^4.13.0",
+    "rxjs": "^7.8.0"
   },
   "devDependencies": {
     "@tsconfig/node14": "^1.0.3",
-    "@types/node": "^14.18.32",
-    "@types/lodash": "^4.14.186"
+    "@types/lodash": "^4.14.191",
+    "@types/node": "^14.18.36"
   },
   "author": "alert83@gmail.com",
   "license": "MIT"

package/src/index.js

@@ -12,17 +12,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GcfCommon = exports.storage = exports.pubSub = void 0;
+exports.GcfCommon = exports.secretClient = exports.storage = exports.pubSub = void 0;
 const pubsub_1 = require("@google-cloud/pubsub");
-const secret_manager_1 = require("@google-cloud/secret-manager");
-const storage_1 = require("@google-cloud/storage");
 const fromPairs_1 = __importDefault(require("lodash/fromPairs"));
 const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
 const noop_1 = __importDefault(require("lodash/noop"));
 const utils_1 = require("./utils");
+const storage_1 = require("@google-cloud/storage");
+const secret_manager_1 = require("@google-cloud/secret-manager");
 exports.pubSub = new pubsub_1.PubSub();
 exports.storage = new storage_1.Storage();
-const secretClient = new secret_manager_1.SecretManagerServiceClient();
+exports.secretClient = new secret_manager_1.SecretManagerServiceClient();
 class GcfCommon {
     /**
      *
@@ -120,10 +120,10 @@ class GcfCommon {
     static getSecret(name, version) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            const projectId = yield secretClient.getProjectId();
+            const projectId = yield exports.secretClient.getProjectId();
             const secretName = `projects/${projectId}/secrets/${name}`;
             const secretVersion = `${secretName}/versions/${version !== null && version !== void 0 ? version : 'latest'}`;
-            const [response] = yield secretClient.accessSecretVersion({ name: secretVersion });
+            const [response] = yield exports.secretClient.accessSecretVersion({ name: secretVersion });
             return (_b = (_a = response === null || response === void 0 ? void 0 : response.payload) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.toString();
         });
     }

package/src/index.ts

@@ -1,10 +1,10 @@
 import {PubSub} from "@google-cloud/pubsub";
-import {SecretManagerServiceClient} from "@google-cloud/secret-manager";
-import {File, Storage} from "@google-cloud/storage";
 import fromPairs from "lodash/fromPairs";
 import isEmpty from "lodash/isEmpty";
 import noop from "lodash/noop";
 import {timeoutAfter} from "./utils";
+import {File, Storage} from "@google-cloud/storage";
+import {SecretManagerServiceClient} from "@google-cloud/secret-manager";
 import Dict = NodeJS.Dict;
 
 export type TGSEvent = {
@@ -70,7 +70,7 @@ export type TResponse = {
 
 export const pubSub = new PubSub();
 export const storage = new Storage();
-const secretClient = new SecretManagerServiceClient();
+export const secretClient = new SecretManagerServiceClient();
 
 export class GcfCommon {
 

package/src/mongo-lock.js

@@ -0,0 +1,75 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoLock = void 0;
+const moment_1 = __importDefault(require("moment"));
+const noop_1 = __importDefault(require("lodash/noop"));
+const rxjs_1 = require("rxjs");
+class MongoLock {
+    constructor(client) {
+        this.client = client;
+    }
+    getCollection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.db().collection('locks');
+        });
+    }
+    /**
+     * Create the MongoDB collection and an expiring index on a field named "expiresAt".
+     *
+     * db.createCollection('locks');
+     * db.locks.createIndex( { "expiresAt": 1 }, { expireAfterSeconds: 0 } )
+     **/
+    acquireLock(name, ttlSeconds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const collection = yield this.getCollection();
+            // Entry gets removed automatically due to an expiry index in Mongo
+            const expiresAt = (0, moment_1.default)().add(ttlSeconds, 'seconds').toDate();
+            try {
+                yield collection.insertOne({
+                    _id: name,
+                    expiresAt,
+                });
+                return true;
+            }
+            catch (ex) {
+                // 11000 means duplicate key error, which is expected on an active lock
+                if ((ex === null || ex === void 0 ? void 0 : ex.code) !== 11000) {
+                    // Unexpected error, what happened here :o
+                    throw ex;
+                }
+                // As we got a duplicate key exception, no lock could be acquired
+                return false;
+            }
+        });
+    }
+    releaseLock(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const collection = yield this.getCollection();
+            return collection.deleteOne({ _id: name });
+        });
+    }
+    acquireAndExecute(name, ttlSeconds, wait, fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const delay = 200;
+            const count = Math.round((1000 / delay) * ttlSeconds);
+            return (0, rxjs_1.lastValueFrom)((0, rxjs_1.defer)(() => (0, rxjs_1.from)(this.acquireLock(name, ttlSeconds))).pipe((0, rxjs_1.map)(locked => {
+                console.log(locked);
+                if (!locked)
+                    throw locked;
+            }), wait ? (0, rxjs_1.retry)({ count, delay }) : rxjs_1.identity, (0, rxjs_1.switchMap)(() => fn().finally(() => this.releaseLock(name).catch(noop_1.default)))));
+        });
+    }
+}
+exports.MongoLock = MongoLock;

package/src/mongo-lock.ts

@@ -0,0 +1,66 @@
+import {MongoClient, MongoError} from "mongodb";
+import moment from "moment";
+import noop from "lodash/noop";
+import {defer, from, identity, lastValueFrom, map, retry, switchMap} from "rxjs";
+
+export class MongoLock {
+
+    constructor(private client: MongoClient) {
+    }
+
+    private async getCollection() {
+        return this.client.db().collection('locks');
+    }
+
+    /**
+     * Create the MongoDB collection and an expiring index on a field named "expiresAt".
+     *
+     * db.createCollection('locks');
+     * db.locks.createIndex( { "expiresAt": 1 }, { expireAfterSeconds: 0 } )
+     **/
+    async acquireLock(name: string, ttlSeconds: number) {
+        const collection = await this.getCollection();
+
+        // Entry gets removed automatically due to an expiry index in Mongo
+        const expiresAt = moment().add(ttlSeconds, 'seconds').toDate();
+
+        try {
+            await collection.insertOne({
+                _id: name as any,
+                expiresAt,
+            });
+
+            return true;
+        } catch (ex) {
+            // 11000 means duplicate key error, which is expected on an active lock
+            if ((ex as MongoError)?.code !== 11000) {
+                // Unexpected error, what happened here :o
+                throw ex
+            }
+
+            // As we got a duplicate key exception, no lock could be acquired
+            return false;
+        }
+    }
+
+    async releaseLock(name: string) {
+        const collection = await this.getCollection();
+        return collection.deleteOne({_id: name});
+    }
+
+    async acquireAndExecute(name: string, ttlSeconds: number, wait: boolean, fn: () => Promise<any>) {
+        const delay = 200;
+        const count = Math.round((1000 / delay) * ttlSeconds);
+
+        return lastValueFrom(
+            defer(() => from(this.acquireLock(name, ttlSeconds))).pipe(
+                map(locked => {
+                    console.log(locked);
+                    if (!locked) throw locked;
+                }),
+                wait ? retry({count, delay}) : identity,
+                switchMap(() => fn().finally(() => this.releaseLock(name).catch(noop))),
+            ),
+        );
+    }
+}