1.0.8

dependencies.yml

@@ -1 +0,0 @@
-.gitignore: ../gitignore/

npmextra.json

@@ -1,8 +1,6 @@
 {
   "npmci": {
-    "npmGlobalTools": [
+    "npmGlobalTools": [],
-      "@gitzone/npmts",
+    "npmAccessLevel": "public"
-      "ts-node"
-    ]
   }
 }

package.json

@@ -1,6 +1,6 @@
 {
-  "name": "smartcache",
+  "name": "@pushrocks/smartcache",
-  "version": "1.0.2",
+  "version": "1.0.8",
   "private": false,
   "description": "cache things in smart ways",
   "main": "dist/index.js",
@@ -8,17 +8,21 @@
   "author": "Lossless GmbH",
   "license": "MIT",
   "scripts": {
-    "test": "(tsrun test/test.ts)",
+    "test": "(tstest test/)",
-    "build": "(npmts)"
+    "build": "(tsbuild)"
   },
   "devDependencies": {
-    "@types/node": "^10.5.2"
+    "@gitzone/tsbuild": "^2.0.22",
+    "@gitzone/tsrun": "^1.1.12",
+    "@gitzone/tstest": "^1.0.15",
+    "@pushrocks/tapbundle": "^3.0.5",
+    "@types/node": "^10.7.1"
   },
   "dependencies": {
-    "@pushrocks/smartdelay": "^2.0.1",
+    "@pushrocks/smartdelay": "^2.0.2",
     "@pushrocks/smarterror": "^2.0.1",
     "@pushrocks/smartpromise": "^2.0.5",
-    "@pushrocks/smarttime": "^2.0.1",
+    "@pushrocks/smarttime": "^2.0.2",
     "nodehash": "^1.0.4"
   }
 }

test/test.ts

@@ -1,36 +1,51 @@
-// import { expect, tap } from 'tapbundle';
+import { expect, tap } from "@pushrocks/tapbundle";
-import * as smartcache from '../ts/index';
+import * as smartcache from "../ts/index";
-import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartdelay from "@pushrocks/smartdelay";
 
-const smartcacheInstance = new smartcache.SmartCache();
+let smartcacheInstance: smartcache.SmartCache;
-const getResponse = async () => {
-  const response = await smartcacheInstance.cacheReturn(async () => {
-    console.log('function ran')
-    return 'hello';
-  }, 1000).catch(err => {
-    console.log(err);
-  });
-  console.log('response is:')
-  console.log(response);
-};
 
-const getResponse2 = async () => {
+tap.test("should create a valid instance of SmartCache", async () => {
-  const response = await smartcacheInstance.cacheReturn(async () => {
+  smartcacheInstance = new smartcache.SmartCache();
-    console.log('function ran')
+  expect(smartcacheInstance).to.be.instanceof(smartcache.SmartCache);
-    return 'hello';
-  }, 1000).catch(err => {
-    console.log(err);
-  });
-  console.log('response is:')
-  console.log(response);
-};
-
-getResponse();
-getResponse();
-getResponse2();
-getResponse2();
-smartdelay.delayFor(1000).then(() => {
-  getResponse();
-  // getResponse2();
 });
 
+tap.test("try to get async responses", async () => {
+  const getResponse = async () => {
+    const response = await smartcacheInstance
+      .cacheReturn(async () => {
+        console.log("function ran");
+        return "hello";
+      }, 1000)
+      .catch(err => {
+        console.log(err);
+      });
+    console.log("response is:");
+    console.log(response);
+  };
+
+  const getResponse2 = async () => {
+    const response = await smartcacheInstance
+      .cacheReturn(async () => {
+        console.log("function 2 ran");
+        return "hello";
+      }, 1000)
+      .catch(err => {
+        console.log(err);
+      });
+    console.log("response is:");
+    console.log(response);
+  };
+
+  getResponse();
+  getResponse();
+  getResponse2();
+  getResponse2();
+  smartdelay.delayFor(1000).then(() => {
+    getResponse();
+    // getResponse2();
+  });
+});
+
+tap.start({
+  throwOnError: true
+});

ts/smartcache.classes.cachemanager.ts

@@ -20,9 +20,12 @@ export class CacheManager {
   }
 
   stillValid(identifierArg: string): boolean {
-    if (this.cacheExists(identifierArg) && this._cacheMap[identifierArg].timer.startedAt.isYoungerThanMilliSeconds(
+    if (
-      this._cacheMap[identifierArg].timer.timeInMilliseconds
+      this.cacheExists(identifierArg) &&
-    )) {
+      this._cacheMap[identifierArg].timer.startedAt.isYoungerThanMilliSeconds(
+        this._cacheMap[identifierArg].timer.timeInMilliseconds
+      )
+    ) {
       return true;
     }
     return false;
@@ -37,21 +40,23 @@ export class CacheManager {
     };
     this._cacheMap[identifierArg].timer.start();
     this._cacheMap[identifierArg].timer.completed.then(() => {
-      this.deleteCache(identifierArg)
+      this.deleteCache(identifierArg);
     });
   }
 
   /**
    * waits for the cache to be ready
    */
-  async waitForCacheReady (identifierArg: string) {
+  async waitForCacheReady(identifierArg: string) {
-    await this._cacheMap[identifierArg].cachedDeferred.promise
+    await this._cacheMap[identifierArg].cachedDeferred.promise;
     return true;
   }
 
   setCache(identifierArg: string, cachedObjectArg: any, validForArg = 1000) {
-    if(!this.cacheExists(identifierArg)) {
+    if (!this.cacheExists(identifierArg)) {
-      console.log(new SmartError(`Cache for ${identifierArg} has not been announced or timed out!`));
+      console.log(
+        new SmartError(`Cache for ${identifierArg} has not been announced or timed out!`)
+      );
     }
     this._cacheMap[identifierArg].cachedObject = cachedObjectArg;
     this._cacheMap[identifierArg].cachedDeferred.resolve();

ts/smartcache.classes.smartcache.ts

@@ -7,13 +7,17 @@ export class SmartCache {
   async cacheReturn(asyncCachedFuncArg: () => Promise<any>, cacheDuration: number = 5000) {
     let callStack: string = new plugins.smarterror.SmartError('').cleanFullStack;
     let callHash = plugins.nodehash.sha256FromStringSync(callStack);
-    
+
-    console.log(callHash);
+    // console.log(callHash);
-    if(this._cacheManager.cacheExists(callHash) && await this._cacheManager.waitForCacheReady(callHash) && this._cacheManager.stillValid(callHash)) {
+    if (
+      this._cacheManager.cacheExists(callHash) &&
+      (await this._cacheManager.waitForCacheReady(callHash)) &&
+      this._cacheManager.stillValid(callHash)
+    ) {
       return this._cacheManager.getCache(callHash).cachedObject;
     } else {
       this._cacheManager.announceCache(callHash, cacheDuration);
-      let newCachedObject = await asyncCachedFuncArg()
+      let newCachedObject = await asyncCachedFuncArg();
       this._cacheManager.setCache(callHash, newCachedObject, cacheDuration);
       return newCachedObject;
     }