Async/await let's go!

lib/cache.ts

@@ -17,162 +17,124 @@
  * along with GenieACS.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-import { MongoClient } from "mongodb";
+import { MongoClient, Collection } from "mongodb";
 import * as config from "./config";
 
 const MAX_CACHE_TTL = +config.get("MAX_CACHE_TTL");
 
-let mongoClient;
-let mongoCollection;
+let mongoClient: MongoClient;
+let mongoCollection: Collection;
 let mongoTimeOffset = 0;
 
-export function connect(callback): void {
+export async function connect(): Promise<void> {
   const MONGODB_CONNECTION_URL = "" + config.get("MONGODB_CONNECTION_URL");
-
-  MongoClient.connect(
-    MONGODB_CONNECTION_URL,
-    { useNewUrlParser: true },
-    (err, client) => {
-      if (err) return void callback(err);
-
-      const db = client.db();
-      mongoClient = client;
-      mongoCollection = db.collection("cache");
-      mongoCollection.createIndex({ expire: 1 }, { expireAfterSeconds: 0 });
-
-      const now = Date.now();
-      db.command({ hostInfo: 1 }, (err, res) => {
-        if (err) return void callback(err);
-        mongoTimeOffset = res.system.currentTime.getTime() - now;
-        callback();
-      });
-    }
-  );
+  mongoClient = await MongoClient.connect(MONGODB_CONNECTION_URL, {
+    useNewUrlParser: true
+  });
+  const db = mongoClient.db();
+  mongoCollection = db.collection("cache");
+  await mongoCollection.createIndex({ expire: 1 }, { expireAfterSeconds: 0 });
+  const now = Date.now();
+  const res = await db.command({ hostInfo: 1 });
+  mongoTimeOffset = res.system.currentTime.getTime() - now;
 }
 
-export function disconnect(): void {
-  if (mongoClient) mongoClient.close();
+export async function disconnect(): Promise<void> {
+  if (mongoClient) await mongoClient.close();
 }
 
-export function get(key, callback): void {
+export async function get(key): Promise<any> {
   const expire = new Date(Date.now() - mongoTimeOffset);
   if (Array.isArray(key)) {
-    mongoCollection.find({ _id: { $in: key } }).toArray((err, res) => {
-      if (err) return void callback(err);
+    const res = await mongoCollection.find({ _id: { $in: key } }).toArray();
 
-      const indices = {};
-      key.forEach((v, i) => {
-        indices[v] = i;
-      });
-
-      const values = [];
-      res.forEach(r => {
-        if (r["expire"] > expire) values[indices[r["_id"]]] = r["value"];
-      });
-      callback(null, values);
+    const indices = {};
+    key.forEach((v, i) => {
+      indices[v] = i;
     });
+
+    const values = [];
+    res.forEach(r => {
+      if (r["expire"] > expire) values[indices[r["_id"]]] = r["value"];
+    });
+
+    return values;
   } else {
-    mongoCollection.findOne({ _id: { $in: [key] } }, (err, res) => {
-      if (err || !res) return void callback(err);
-
-      if (res["expire"] > expire) return void callback(null, res["value"]);
-
-      callback();
-    });
+    const res = await mongoCollection.findOne({ _id: { $in: [key] } });
+    if (res && res["expire"] > expire) return res["value"];
+    return res;
   }
 }
 
-export function del(key, callback): void {
+export async function del(key): Promise<void> {
   if (Array.isArray(key))
-    mongoCollection.deleteMany({ _id: { $in: key } }, callback);
-  else mongoCollection.deleteOne({ _id: key }, callback);
+    await mongoCollection.deleteMany({ _id: { $in: key } });
+  else await mongoCollection.deleteOne({ _id: key });
 }
 
-export function set(
+export async function set(
   key: string,
   value: string | number,
-  callback: (err?: Error) => void
-): void;
-export function set(
-  key: string,
-  value: string | number,
-  ttl: number,
-  callback: (err?: Error) => void
-): void;
-export function set(
-  key: string,
-  value: string | number,
-  ttl: number | ((err?: Error) => void),
-  callback?: (err?: Error) => void
-): void {
-  if (!callback && typeof ttl === "function") {
-    callback = ttl;
-    ttl = null;
-  }
-
-  if (!ttl) ttl = MAX_CACHE_TTL;
-
-  const expire = new Date(
-    Date.now() - mongoTimeOffset + (ttl as number) * 1000
-  );
-  mongoCollection.replaceOne(
+  ttl: number = MAX_CACHE_TTL
+): Promise<void> {
+  const expire = new Date(Date.now() - mongoTimeOffset + ttl * 1000);
+  await mongoCollection.replaceOne(
     { _id: key },
     { _id: key, value: value, expire: expire },
-    { upsert: true },
-    callback
+    { upsert: true }
   );
 }
 
-export function pop(key, callback): void {
-  mongoCollection.findOneAndDelete({ _id: key }, (err, res) => {
-    if (err || !res["value"]) return void callback(err);
+export async function pop(key): Promise<any> {
+  const res = await mongoCollection.findOneAndDelete({ _id: key });
 
-    if (res["value"]["expire"] > new Date(Date.now() - mongoTimeOffset))
-      return void callback(null, res["value"]["value"]);
+  if (
+    res &&
+    res["value"] &&
+    +res["value"]["expire"] - (Date.now() - mongoTimeOffset)
+  )
+    return res["value"]["value"];
 
-    callback();
-  });
+  return null;
 }
 
-export function lock(lockName, ttl, callback): void {
+export async function lock(lockName, ttl): Promise<Function> {
   const token = Math.random()
     .toString(36)
     .slice(2);
 
-  function unlockOrExtend(extendTtl): void {
+  async function unlockOrExtend(extendTtl): Promise<void> {
     if (!extendTtl) {
-      mongoCollection.deleteOne({ _id: lockName, value: token }, (err, res) => {
-        if (err || res["result"]["n"] !== 1)
-          throw err || new Error("Lock expired");
+      const res = await mongoCollection.deleteOne({
+        _id: lockName,
+        value: token
       });
+      if (res["result"]["n"] !== 1) throw new Error("Lock expired");
     } else {
       const expire = new Date(Date.now() - mongoTimeOffset + extendTtl * 1000);
-      mongoCollection.updateOne(
+      const res = await mongoCollection.updateOne(
         { _id: lockName, value: token },
-        { expire: expire },
-        (err, res) => {
-          if (err || res["result"]["n"] !== 1)
-            throw err || new Error("Lock expired");
-        }
+        { expire: expire }
       );
+      if (res["result"]["n"] !== 1) throw new Error("Lock expired");
     }
   }
 
   const expireTest = new Date(Date.now() - mongoTimeOffset);
   const expireSet = new Date(Date.now() - mongoTimeOffset + ttl * 1000);
 
-  mongoCollection.updateOne(
-    { _id: lockName, expire: { $lte: expireTest } },
-    { $set: { value: token, expire: expireSet } },
-    { upsert: true },
-    err => {
-      if (err && err.code === 11000) {
-        return setTimeout(() => {
-          lock(lockName, ttl, callback);
-        }, 200);
-      }
-
-      return callback(err, unlockOrExtend);
+  try {
+    await mongoCollection.updateOne(
+      { _id: lockName, expire: { $lte: expireTest } },
+      { $set: { value: token, expire: expireSet } },
+      { upsert: true }
+    );
+  } catch (err) {
+    if (err && err.code === 11000) {
+      await new Promise(resolve => setTimeout(resolve, 200));
+      return lock(lockName, ttl);
     }
-  );
+  }
+
+  return unlockOrExtend;
 }