Basic TTL engine

.npmignore

@@ -4,6 +4,6 @@
 report
 tmp/
 .env
-dist
 .cache
-.github
+.github
+docs

docs/ttl-engine.md

@@ -0,0 +1,3 @@
+# TTL cache engine Architecture
+
+![](./images/ttl-arct.png)

src/engines/TimeToLive.js

@@ -0,0 +1,91 @@
+import DefaultHashTable from '../dataStructure/HashTable';
+import DoublyLinkedList from '../dataStructure/DoublyLinkedList';
+import * as hashTableProp from '../hashTableSymbol';
+
+function TimeToLive({ HashTable = DefaultHashTable, defaultTTL } = {}) {
+  const store = new HashTable();
+  const timeSeriesIndex = new HashTable();
+  const timeIndexInterval = 5 * 60 * 1000; // milliseconds.
+
+  let lastRunGC = Date.now();
+
+  this.add = (key, value, ttl = defaultTTL) => {
+    if (!ttl)
+      throw Error(
+        'Expected ttl value. you can have to mention it in add method or mention as defaultTTL at constructor',
+      );
+
+    const expireTTL = Date.now() + ttl;
+    const bucket = getTimeBucket(expireTTL);
+    bucket.addFirst(key);
+    const tNode = bucket.getFirst();
+    const payload = { value, ttl: expireTTL, tNode };
+    store[hashTableProp.add](key, payload);
+  };
+
+  this.get = key => {
+    const payload = store[hashTableProp.get](key);
+    if (payload) {
+      const { ttl, value } = payload;
+      if (checkIfElementExpire(payload)) return undefined;
+      else return value;
+    }
+    return undefined;
+  };
+
+  this.has = key => {
+    return store[hashTableProp.has](key);
+  };
+
+  this.remove = (key) => {
+    if (this.has(key)) {
+      const { ttl, tNode } = store[hashTableProp.get](key);
+      const timeBucket = getTimeBucket(ttl);
+      timeBucket.remove(tNode);
+      store[hashTableProp.remove](key);
+    }
+  };
+
+  this.size = () => {
+    return store[hashTableProp.size]();
+  };
+
+  function getTimeBucket(expireTTL) {
+    const timeIndex = getTimeIndex({ time: expireTTL, interval:timeIndexInterval });
+
+    if (timeSeriesIndex[hashTableProp.has](timeIndex)) {
+      return timeSeriesIndex[hashTableProp.get](timeIndex);
+    } else {
+      const list = new DoublyLinkedList();
+      timeSeriesIndex[hashTableProp.add](timeIndex, list);
+      return list;
+    }
+  }
+
+  function checkIfElementExpire({ ttl }) {
+    if (ttl < Date.now()) {
+      const timeIndex = getTimeIndex({ time: ttl, interval:timeIndexInterval });
+      cleanExpired(timeIndex);
+      return true;
+    }
+    return false;
+  }
+
+  function cleanExpired(timeIndex) {
+    const keys = timeSeriesIndex[hashTableProp.get][timeIndex];
+    for (key of keys) {
+      store[hashTableProp.remove](key);
+    }
+  }
+}
+
+// time : unix timestamp milliseconds
+// interval : milliseconds (better to be factors of 60  (minutes))
+function getTimeIndex({ time, interval }) {
+  const timeParts = parseInt(time / interval, 10);
+  const forwardIndexTime = timeParts * interval + interval;
+  return forwardIndexTime;
+}
+
+export { getTimeIndex };
+export default TimeToLive;

src/engines/TimeToLive.test.js

@@ -0,0 +1,38 @@
+import TimeToLive, { getTimeIndex } from './TimeToLive';
+
+describe('TimeToLive (TTL) : getTimeIndex', () => {
+  it('should index time to next upcoming interval', () => {
+    const toMinute = val => val * 60 * 1000;
+
+    const date1 = new Date('2020-06-14T03:23:34');
+    expect(getTimeIndex({ time: date1.getTime(), interval: toMinute(5) })).toBe(
+      new Date('2020-06-14T03:25:00').getTime(),
+    );
+
+    const date2 = new Date('2020-06-14T03:43:36');
+    expect(
+      getTimeIndex({ time: date2.getTime(), interval: toMinute(10) }),
+    ).toBe(new Date('2020-06-14T03:50:00').getTime());
+
+    const date3 = new Date('2020-06-14T03:43:36');
+    expect(getTimeIndex({ time: date3.getTime(), interval: toMinute(3) })).toBe(
+      new Date('2020-06-14T03:45:00').getTime(),
+    );
+  });
+});
+
+describe('TimeToLive', () => {
+  it('should have basic cache features', () => {
+    const ttlCache = new TimeToLive();
+    ttlCache.add('apple',5,1000);
+    ttlCache.add('orange',2,2000);
+    expect(ttlCache.get('apple')).toBe(5);
+    expect(ttlCache.has('apple')).toBe(true);
+    expect(ttlCache.size()).toBe(2);
+
+    ttlCache.remove('apple');
+    expect(ttlCache.size()).toBe(1);
+    expect(ttlCache.get('apple')).toBe(undefined);
+    expect(ttlCache.get('orange')).toBe(2);
+  });
+});