gcf-common-lib 0.35.0 → 0.36.0

package/src/mongo-lock.js

@@ -1,86 +1,86 @@
-"use strict";
-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/moment"));
-const noop_1 = __importDefault(require("lodash/noop"));
-const rxjs_1 = require("rxjs");
-const mongo_helper_1 = require("./mongo-helper");
-const bluebird_1 = __importDefault(require("bluebird"));
-/**
- * @deprecated
- */
-class MongoLock {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    async getCollection() {
-        const locksColl = await mongo_helper_1.MongoHelper.collectionSafeGet(this.client, 'locks');
-        await locksColl.indexExists('expiresAt').then(async (exists) => {
-            if (!exists)
-                await locksColl.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 });
-            return;
-        });
-        return locksColl;
-    }
-    /**
-     * 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, ttlSeconds) {
-        const collection = await this.getCollection();
-        // Entry gets removed automatically due to an expiry index in Mongo
-        const expiresAt = (0, moment_1.default)().add(ttlSeconds, 'seconds').toDate();
-        try {
-            await collection.insertOne({
-                _id: name,
-                expiresAt,
-            });
-            return true;
-        }
-        catch (error) {
-            // 11000 means duplicate key error, which is expected on an active lock
-            if (error?.code !== 11_000) {
-                // Unexpected error, what happened here :o
-                throw error;
-            }
-            // As we got a duplicate key exception, no lock could be acquired
-            return false;
-        }
-    }
-    async releaseLock(name) {
-        const collection = await this.getCollection();
-        return collection.deleteOne({ _id: name });
-    }
-    async acquireAndExecute(name, ttlSeconds, wait, fn) {
-        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 new Error('Could not acquire lock');
-        }), wait ? (0, rxjs_1.retry)({ count, delay }) : (0, rxjs_1.tap)(rxjs_1.identity), (0, rxjs_1.switchMap)(async () => {
-            const method = bluebird_1.default.method(rxjs_1.identity);
-            const withDisposer = () => method(this).disposer(mongoLock => {
-                mongoLock.releaseLock(name).catch(noop_1.default);
-            });
-            return bluebird_1.default.using(withDisposer(), () => fn());
-        })));
-    }
-    async checkLock(name, waitSeconds = 0) {
-        const delay = 200;
-        const count = Math.round((1000 / delay) * waitSeconds);
-        const collection = await this.getCollection();
-        return (0, rxjs_1.lastValueFrom)((0, rxjs_1.defer)(() => (0, rxjs_1.from)(collection.findOne({ _id: name }))).pipe((0, rxjs_1.map)(lock => {
-            // console.log(lock);
-            if (lock)
-                throw lock;
-        }), waitSeconds > 0 ? (0, rxjs_1.retry)({ count, delay }) : (0, rxjs_1.tap)(rxjs_1.identity)));
-    }
-}
-exports.MongoLock = MongoLock;
+"use strict";
+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/moment"));
+const noop_1 = __importDefault(require("lodash/noop"));
+const rxjs_1 = require("rxjs");
+const mongo_helper_1 = require("./mongo-helper");
+const bluebird_1 = __importDefault(require("bluebird"));
+/**
+ * @deprecated
+ */
+class MongoLock {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getCollection() {
+        const locksColl = await mongo_helper_1.MongoHelper.collectionSafeGet(this.client, 'locks');
+        await locksColl.indexExists('expiresAt').then(async (exists) => {
+            if (!exists)
+                await locksColl.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+            return;
+        });
+        return locksColl;
+    }
+    /**
+     * 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, ttlSeconds) {
+        const collection = await this.getCollection();
+        // Entry gets removed automatically due to an expiry index in Mongo
+        const expiresAt = (0, moment_1.default)().add(ttlSeconds, 'seconds').toDate();
+        try {
+            await collection.insertOne({
+                _id: name,
+                expiresAt,
+            });
+            return true;
+        }
+        catch (error) {
+            // 11000 means duplicate key error, which is expected on an active lock
+            if (error?.code !== 11_000) {
+                // Unexpected error, what happened here :o
+                throw error;
+            }
+            // As we got a duplicate key exception, no lock could be acquired
+            return false;
+        }
+    }
+    async releaseLock(name) {
+        const collection = await this.getCollection();
+        return collection.deleteOne({ _id: name });
+    }
+    async acquireAndExecute(name, ttlSeconds, wait, fn) {
+        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 new Error('Could not acquire lock');
+        }), wait ? (0, rxjs_1.retry)({ count, delay }) : (0, rxjs_1.tap)(rxjs_1.identity), (0, rxjs_1.switchMap)(async () => {
+            const method = bluebird_1.default.method(rxjs_1.identity);
+            const withDisposer = () => method(this).disposer(mongoLock => {
+                mongoLock.releaseLock(name).catch(noop_1.default);
+            });
+            return bluebird_1.default.using(withDisposer(), () => fn());
+        })));
+    }
+    async checkLock(name, waitSeconds = 0) {
+        const delay = 200;
+        const count = Math.round((1000 / delay) * waitSeconds);
+        const collection = await this.getCollection();
+        return (0, rxjs_1.lastValueFrom)((0, rxjs_1.defer)(() => (0, rxjs_1.from)(collection.findOne({ _id: name }))).pipe((0, rxjs_1.map)(lock => {
+            // console.log(lock);
+            if (lock)
+                throw lock;
+        }), waitSeconds > 0 ? (0, rxjs_1.retry)({ count, delay }) : (0, rxjs_1.tap)(rxjs_1.identity)));
+    }
+}
+exports.MongoLock = MongoLock;

package/src/mongo-lock.ts

@@ -1,99 +1,99 @@
-import moment from 'moment/moment';
-import { MongoClient, MongoError } from 'mongodb';
-import noop from 'lodash/noop';
-import { defer, from, identity, lastValueFrom, map, retry, switchMap, tap } from 'rxjs';
-import { MongoHelper } from './mongo-helper';
-import Bluebird from 'bluebird';
-
-/**
- * @deprecated
- */
-export class MongoLock {
-  constructor(private client: MongoClient) {}
-
-  async getCollection() {
-    const locksColl = await MongoHelper.collectionSafeGet(this.client, 'locks');
-    await locksColl.indexExists('expiresAt').then(async exists => {
-      if (!exists) await locksColl.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 });
-      return;
-    });
-    return locksColl;
-  }
-
-  /**
-   * 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 (error) {
-      // 11000 means duplicate key error, which is expected on an active lock
-      if ((error as MongoError)?.code !== 11_000) {
-        // Unexpected error, what happened here :o
-        throw error;
-      }
-
-      // 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 as any });
-  }
-
-  async acquireAndExecute<T = any>(name: string, ttlSeconds: number, wait: boolean, fn: () => Promise<T>) {
-    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 new Error('Could not acquire lock');
-        }),
-        wait ? retry({ count, delay }) : tap(identity),
-        switchMap(async () => {
-          const method = Bluebird.method(identity);
-
-          const withDisposer = () =>
-            method(this).disposer(mongoLock => {
-              mongoLock.releaseLock(name).catch(noop);
-            });
-
-          return Bluebird.using(withDisposer(), () => fn());
-        }),
-      ),
-    );
-  }
-
-  async checkLock(name: string, waitSeconds: number = 0) {
-    const delay = 200;
-    const count = Math.round((1000 / delay) * waitSeconds);
-    const collection = await this.getCollection();
-
-    return lastValueFrom(
-      defer(() => from(collection.findOne({ _id: name as any }))).pipe(
-        map(lock => {
-          // console.log(lock);
-          if (lock) throw lock;
-        }),
-        waitSeconds > 0 ? retry({ count, delay }) : tap(identity),
-      ),
-    );
-  }
-}
+import moment from 'moment/moment';
+import { MongoClient, MongoError } from 'mongodb';
+import noop from 'lodash/noop';
+import { defer, from, identity, lastValueFrom, map, retry, switchMap, tap } from 'rxjs';
+import { MongoHelper } from './mongo-helper';
+import Bluebird from 'bluebird';
+
+/**
+ * @deprecated
+ */
+export class MongoLock {
+  constructor(private client: MongoClient) {}
+
+  async getCollection() {
+    const locksColl = await MongoHelper.collectionSafeGet(this.client, 'locks');
+    await locksColl.indexExists('expiresAt').then(async exists => {
+      if (!exists) await locksColl.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+      return;
+    });
+    return locksColl;
+  }
+
+  /**
+   * 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 (error) {
+      // 11000 means duplicate key error, which is expected on an active lock
+      if ((error as MongoError)?.code !== 11_000) {
+        // Unexpected error, what happened here :o
+        throw error;
+      }
+
+      // 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 as any });
+  }
+
+  async acquireAndExecute<T = any>(name: string, ttlSeconds: number, wait: boolean, fn: () => Promise<T>) {
+    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 new Error('Could not acquire lock');
+        }),
+        wait ? retry({ count, delay }) : tap(identity),
+        switchMap(async () => {
+          const method = Bluebird.method(identity);
+
+          const withDisposer = () =>
+            method(this).disposer(mongoLock => {
+              mongoLock.releaseLock(name).catch(noop);
+            });
+
+          return Bluebird.using(withDisposer(), () => fn());
+        }),
+      ),
+    );
+  }
+
+  async checkLock(name: string, waitSeconds: number = 0) {
+    const delay = 200;
+    const count = Math.round((1000 / delay) * waitSeconds);
+    const collection = await this.getCollection();
+
+    return lastValueFrom(
+      defer(() => from(collection.findOne({ _id: name as any }))).pipe(
+        map(lock => {
+          // console.log(lock);
+          if (lock) throw lock;
+        }),
+        waitSeconds > 0 ? retry({ count, delay }) : tap(identity),
+      ),
+    );
+  }
+}

package/src/types.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/types.ts

@@ -1,84 +1,84 @@
-import Dict = NodeJS.Dict;
-import { Request, Response } from 'express';
-
-export type TPayload<E = TEvent> = {
-  event?: E;
-  context?: TContext;
-  request?: Request;
-  response?: Response;
-};
-
-export type TGSEvent<M = TMetadataOrAttributes> = {
-  bucket: string;
-  contentType: string;
-  crc32c: string;
-  etag: string;
-  generation: string;
-  id: string;
-  kind: string; // 'storage#object'
-  md5Hash: string;
-  mediaLink: string;
-  metadata: M;
-  metageneration: string;
-  name: string;
-  selfLink: string;
-  size: string;
-  storageClass: string;
-  timeCreated: string;
-  timeStorageClassUpdated: string;
-  updated: string;
-};
-
-export type TPSEvent<A = TMetadataOrAttributes> = {
-  '@type': string; // 'type.googleapis.com/google.pubsub.v1.PubsubMessage'
-  attributes?: A;
-  data?: string;
-  json?: Dict<any>;
-};
-
-export type TEvent = TGSEvent | TPSEvent;
-
-export type TMetadataOrAttributes = {
-  request_id?: string; // for rpc response [GUID]
-  consumer_id?: string; // for rpc response [GUID]
-  topic?: string; // response PubSub topic [t_{GUID}__{YYYY-MM-DD}]
-  exchange?: string; // response amqp exchange
-  queue?: string; // response amqp queue
-  //
-  filename?: string;
-  referer?: string;
-  remote_address?: string;
-  upload_id?: string;
-  user_agent?: string;
-  timestamp?: string;
-  //
-  action?: string;
-  pipeline?: string;
-  options?: string;
-  job_uid?: string;
-  user_id?: string;
-  tenant_id?: string;
-  //
-  app_id?: string; // app id
-  env?: string; // app environment
-};
-
-export type TContext = {
-  eventId: string;
-  timestamp: string;
-  eventType: 'google.storage.object.finalize' | 'google.pubsub.topic.publish';
-  resource: {
-    service: 'storage.googleapis.com' | 'pubsub.googleapis.com';
-    type: 'storage#object' | 'type.googleapis.com/google.pubsub.v1.PubsubMessage';
-    name: string;
-  };
-};
-
-export type TResponse = {
-  [prop: string]: any;
-  error?: {
-    name: string;
-    message: string;
-    stack?: string;
-  };
-};
+import Dict = NodeJS.Dict;
+import { Request, Response } from 'express';
+
+export type TPayload<E = TEvent> = {
+  event?: E;
+  context?: TContext;
+  request?: Request;
+  response?: Response;
+};
+
+export type TGSEvent<M = TMetadataOrAttributes> = {
+  bucket: string;
+  contentType: string;
+  crc32c: string;
+  etag: string;
+  generation: string;
+  id: string;
+  kind: string; // 'storage#object'
+  md5Hash: string;
+  mediaLink: string;
+  metadata: M;
+  metageneration: string;
+  name: string;
+  selfLink: string;
+  size: string;
+  storageClass: string;
+  timeCreated: string;
+  timeStorageClassUpdated: string;
+  updated: string;
+};
+
+export type TPSEvent<A = TMetadataOrAttributes> = {
+  '@type': string; // 'type.googleapis.com/google.pubsub.v1.PubsubMessage'
+  attributes?: A;
+  data?: string;
+  json?: Dict<any>;
+};
+
+export type TEvent = TGSEvent | TPSEvent;
+
+export type TMetadataOrAttributes = {
+  request_id?: string; // for rpc response [GUID]
+  consumer_id?: string; // for rpc response [GUID]
+  topic?: string; // response PubSub topic [t_{GUID}__{YYYY-MM-DD}]
+  exchange?: string; // response amqp exchange
+  queue?: string; // response amqp queue
+  //
+  filename?: string;
+  referer?: string;
+  remote_address?: string;
+  upload_id?: string;
+  user_agent?: string;
+  timestamp?: string;
+  //
+  action?: string;
+  pipeline?: string;
+  options?: string;
+  job_uid?: string;
+  user_id?: string;
+  tenant_id?: string;
+  //
+  app_id?: string; // app id
+  env?: string; // app environment
+};
+
+export type TContext = {
+  eventId: string;
+  timestamp: string;
+  eventType: 'google.storage.object.finalize' | 'google.pubsub.topic.publish';
+  resource: {
+    service: 'storage.googleapis.com' | 'pubsub.googleapis.com';
+    type: 'storage#object' | 'type.googleapis.com/google.pubsub.v1.PubsubMessage';
+    name: string;
+  };
+};
+
+export type TResponse = {
+  [prop: string]: any;
+  error?: {
+    name: string;
+    message: string;
+    stack?: string;
+  };
+};