Adding new fields for error, errorTime, and consecutiveErrors to records and stored data

Author: andrewshell

lib/cacheism.js

@@ -7,19 +7,20 @@ function _sanitize(string) {
 function Cacheism(store) {
     this.store = store;
     this.status = common.Status;
+    this.type = common.Type;
 }
 
 Cacheism.prototype.go = async function (cacheDomain, cachePath, status, callback) {
     let response, name = this.cacheName(cacheDomain, cachePath);
 
-    try {
+    let existing = new common.Miss(name, new Error('Missing cache'), 0);
+    let hasCache = await this.store.isset(name);
 
-        let existing = new common.Miss(name, new Error('Missing cache'));
-        let hasCache = await this.store.isset(name);
+    if (hasCache) {
+        existing = await this.store.get(name);
+    }
 
-        if (hasCache) {
-            existing = await this.store.get(name);
-        }
+    try {
 
         if (status >= this.status.preferCache && hasCache) {
             response = existing;
@@ -30,20 +31,23 @@ Cacheism.prototype.go = async function (cacheDomain, cachePath, status, callback
             if (!(response instanceof common.Hit)) {
                 response = new common.Hit(name, response);
             }
-            await this.store.set(response);
         }
 
     } catch (err) {
 
-        if (status >= this.status.cacheOnFail && await this.store.isset(name)) {
-            response = await this.store.get(name);
+        if (status >= this.status.cacheOnFail && hasCache) {
+            response = existing;
             response.error = err;
+            response.errorTime = new Date();
+            response.consecutiveErrors++;
         } else {
-            response = new common.Miss(name, err);
+            response = new common.Miss(name, err, existing.consecutiveErrors + 1);
         }
 
     }
 
+    await this.store.set(response);
+
     Object.freeze(response);
     return response;
 }
@@ -68,6 +72,7 @@ Cacheism.Hit = common.Hit;
 Cacheism.Miss = common.Miss;
 Cacheism.Data = common.Data;
 Cacheism.Status = common.Status;
+Cacheism.Type = common.Type;
 
 Cacheism.store = {
     filesystem: require('./store-filesystem'),

lib/common.js

@@ -7,75 +7,140 @@ Status.cacheOnFail = 1;
 Status.preferCache = 2;
 Status.onlyCache = 3;
 
+class Type {}
+
+Type.hit = 'Hit';
+Type.miss = 'Miss';
+
 Object.freeze(Status);
 
 class Hit {
     constructor(name, data, etag) {
-        this.version = 2;
+        this.version = 3;
         this.cacheName = name;
         this.cached = false;
         this.created = new Date();
         this.data = data;
         this.error = null;
+        this.errorTime = null;
+        this.consecutiveErrors = 0;
         this.etag = null == etag ? generateEtag(JSON.stringify(data)) : etag;
         this.isHit = true;
         this.isMiss = false;
     }
 }
 
 class Miss {
-    constructor(name, error) {
-        this.version = 2;
+    constructor(name, error, consecutiveErrors) {
+        this.version = 3;
         this.cacheName = name;
         this.cached = false;
         this.created = new Date();
         this.data = null;
         this.error = error;
+        this.errorTime = new Date(this.created);
+        this.consecutiveErrors = consecutiveErrors;
         this.etag = null;
         this.isHit = false;
         this.isMiss = true;
     }
 }
 
 class Data {
-    constructor(version, name, created, data, etag) {
+    constructor(version, type, name, created, data, error, errorTime, consecutiveErrors, etag) {
         this.version = version;
+        this.type = type;
         this.cacheName = name;
         this.created = created;
         this.data = data;
+        this.error = error;
+        this.errorTime = errorTime;
+        this.consecutiveErrors = consecutiveErrors;
         this.etag = etag;
     }
 
-    hit() {
-        if (2 !== this.version) {
+    response() {
+        if (3 !== this.version) {
             throw new Error(`Unknown cache version number: ${this.version}`);
         }
 
-        const hit = new Hit(this.cacheName, this.data, this.etag);
-        hit.cached = true;
-        hit.created = this.created;
+        let response;
+
+        if (this.type === Type.hit) {
+            response = new Hit(this.cacheName, this.data, this.etag);
+            response.cached = true;
+            response.created = this.created;
+        } else {
+            response = new Miss(this.cacheName, this.error, this.consecutiveErrors);
+            response.cached = true;
+            response.created = this.created;
+            response.errorTime = this.errorTime;
+        }
 
-        return hit;
+        return response;
     }
 
     stringify() {
         return JSON.stringify({
             version: this.version,
+            type: this.type,
             cacheName: this.cacheName,
             created: this.created,
             data: this.data,
+            error: null == this.error ? null : this.error.toString(),
+            errorTime: this.errorTime,
+            consecutiveErrors: this.consecutiveErrors,
             etag: this.etag,
         }, null, 2);
     }
 
-    static fromHit(hit) {
-        return new Data(hit.version, hit.cacheName, hit.created, hit.data, hit.etag);
+    static fromResponse(response) {
+        return new Data(
+            response.version,
+            response.isHit ? Type.hit : Type.miss,
+            response.cacheName,
+            response.created,
+            response.data,
+            response.error,
+            response.errorTime,
+            response.consecutiveErrors,
+            response.etag
+        );
     }
 
     static parse(value) {
         const parsed = JSON.parse(value);
-        return new Data(parsed.version, parsed.cacheName, new Date(parsed.created), parsed.data, parsed.etag);
+
+        if (2 === parsed.version) {
+            return new Data(
+                3,
+                Type.hit,
+                parsed.cacheName,
+                new Date(parsed.created),
+                parsed.data,
+                null,
+                null,
+                0,
+                parsed.etag
+            );
+        }
+
+        if (3 === parsed.version) {
+            return new Data(
+                3,
+                parsed.type,
+                parsed.cacheName,
+                new Date(parsed.created),
+                parsed.data,
+                parsed.error,
+                null === parsed.errorTime ? null : new Date(parsed.errorTime),
+                parsed.consecutiveErrors,
+                parsed.etag
+            );
+        }
+
+        throw new Error(`Unknown cache version number: ${parsed.version}`);
     }
 }
 
-module.exports = { Hit, Miss, Data, Status };
+module.exports = { Hit, Miss, Data, Status, Type };

lib/store-filesystem.js

@@ -16,13 +16,13 @@ module.exports = function (config) {
     storeFilesystem.get = async (cacheName) => {
         const filename = path.resolve(config.datadir, `${cacheName}.json`);
         const data = await fsPromises.readFile(filename, 'utf8');
-        return common.Data.parse(data).hit();
+        return common.Data.parse(data).response();
     }
 
     storeFilesystem.set = async (hit) => {
         const filename = path.resolve(config.datadir, `${hit.cacheName}.json`);
         _mkdir(path.dirname(filename));
-        await fsPromises.writeFile(filename, common.Data.fromHit(hit).stringify(), 'utf8');
+        await fsPromises.writeFile(filename, common.Data.fromResponse(hit).stringify(), 'utf8');
     }
 
     storeFilesystem.isset = async (cacheName) => {

lib/store-memory.js

@@ -4,11 +4,11 @@ module.exports = function (config) {
     const storeMemory = { data: {} };
 
     storeMemory.get = async (cacheName) => {
-        return common.Data.parse(storeMemory.data[cacheName]).hit();
+        return common.Data.parse(storeMemory.data[cacheName]).response();
     }
 
     storeMemory.set = async (hit) => {
-        storeMemory.data[hit.cacheName] = common.Data.fromHit(hit).stringify();
+        storeMemory.data[hit.cacheName] = common.Data.fromResponse(hit).stringify();
     }
 
     storeMemory.isset = async (cacheName) => {

package-lock.json

@@ -22,7 +22,8 @@
   "homepage": "https://github.com/andrewshell/cacheism#readme",
   "devDependencies": {
     "expect.js": "^0.3.1",
-    "mocha": "^9.2.2"
+    "mocha": "^9.2.2",
+    "mockdate": "^3.0.5"
   },
   "dependencies": {
     "etag": "^1.8.1"

package.json

@@ -0,0 +1,86 @@
+const expect = require('expect.js');
+const mockdate = require('mockdate');
+
+const Cacheism = require('../lib/cacheism');
+
+function expectCacheHit(c, cached, data) {
+    expect(c).to.be.a(Cacheism.Hit);
+    expect(c).to.have.property('version', 3);
+    expect(c).to.have.property('cacheName', '-internal/cache');
+    expect(c).to.have.property('cached', cached);
+    expect(c).to.have.property('created');
+    expect(c.created).to.be.a(Date);
+    expect(c).to.have.property('data', data);
+    expect(c).to.have.property('etag');
+}
+
+function expectCacheMiss(c, cached, data) {
+    expect(c).to.be.a(Cacheism.Miss);
+    expect(c).to.have.property('version', 3);
+    expect(c).to.have.property('cacheName', '-internal/cache');
+    expect(c).to.have.property('cached', cached);
+    expect(c).to.have.property('created');
+    expect(c.created).to.be.a(Date);
+    expect(c).to.have.property('data', data);
+    expect(c).to.have.property('etag', null);
+}
+
+function expectCacheNoErrors(c) {
+    expect(c).to.have.property('error', null);
+    expect(c).to.have.property('errorTime', null);
+    expect(c).to.have.property('consecutiveErrors', 0);
+}
+
+function expectCacheErrors(c, error, errors) {
+    expect(c).to.have.property('error');
+    expect(c.error).to.be.an(Error);
+    expect(c.error).to.have.property('message', error);
+    expect(c).to.have.property('errorTime');
+    expect(c.errorTime).to.be.a(Date);
+    expect(c).to.have.property('consecutiveErrors', errors);
+}
+
+function expectDataHit(d, data, etag) {
+    expect(d).to.be.a(Cacheism.Data);
+    expect(d).to.have.property('version', 3);
+    expect(d).to.have.property('type', Cacheism.Type.hit);
+    expect(d).to.have.property('created');
+    expect(d.created).to.be.a(Date);
+    expect(d).to.have.property('data', data);
+    expect(d).to.have.property('etag', etag);
+}
+
+function expectDataMiss(d, data, etag) {
+    expect(d).to.be.a(Cacheism.Data);
+    expect(d).to.have.property('version', 3);
+    expect(d).to.have.property('type', Cacheism.Type.miss);
+    expect(d).to.have.property('created');
+    expect(d.created).to.be.a(Date);
+    expect(d).to.have.property('data', data);
+    expect(d).to.have.property('etag', etag);
+}
+
+function expectDataNoErrors(d) {
+    expect(d).to.have.property('error', null);
+    expect(d).to.have.property('errorTime', null);
+    expect(d).to.have.property('consecutiveErrors', 0);
+}
+
+
+function expectDataErrors(d, error, errors) {
+    expect(d).to.have.property('error', error);
+    expect(d).to.have.property('errorTime');
+    expect(d.errorTime).to.be.a(Date);
+    expect(d).to.have.property('consecutiveErrors', errors);
+}
+
+module.exports = {
+    expectCacheHit,
+    expectCacheMiss,
+    expectCacheNoErrors,
+    expectCacheErrors,
+    expectDataHit,
+    expectDataMiss,
+    expectDataNoErrors,
+    expectDataErrors,
+};