Merge pull request #1283 from Real-Dev-Squad/feat/cache-invalidator

Add middleware to invalidate cache

Author: ankushdharkar

constants/cacheKeys.js

@@ -0,0 +1,3 @@
+const ALL_TASKS = "cache:ALL-TASKS";
+
+module.exports = { ALL_TASKS };

routes/taskRequests.js

@@ -4,10 +4,10 @@ const router = express.Router();
 const authenticate = require("../middlewares/authenticate");
 const authorizeRoles = require("../middlewares/authorizeRoles");
 const taskRequests = require("../controllers/tasksRequests");
-const cache = require("../utils/cache");
+const { cacheResponse } = require("../utils/cache");
 const { validateUser } = require("../middlewares/taskRequests");
 
-router.get("/", authenticate, authorizeRoles([SUPERUSER]), cache(), taskRequests.fetchTaskRequests);
+router.get("/", authenticate, authorizeRoles([SUPERUSER]), cacheResponse(), taskRequests.fetchTaskRequests);
 router.post("/addOrUpdate", authenticate, validateUser, taskRequests.addOrUpdate);
 router.patch("/approve", authenticate, authorizeRoles([SUPERUSER]), validateUser, taskRequests.approveTaskRequest);
 

routes/tasks.js

@@ -6,16 +6,38 @@ const { createTask, updateTask, updateSelfTask, getTasksValidator } = require(".
 const authorizeRoles = require("../middlewares/authorizeRoles");
 const { APPOWNER, SUPERUSER } = require("../constants/roles");
 const assignTask = require("../middlewares/assignTask");
-const cache = require("../utils/cache");
+const { cacheResponse, invalidateCache } = require("../utils/cache");
+const { ALL_TASKS } = require("../constants/cacheKeys");
 
-router.get("/", getTasksValidator, cache(), tasks.fetchTasks);
+router.get("/", getTasksValidator, cacheResponse({ invalidationKey: ALL_TASKS, expiry: 10 }), tasks.fetchTasks);
 router.get("/self", authenticate, tasks.getSelfTasks);
 router.get("/overdue", authenticate, authorizeRoles([SUPERUSER]), tasks.overdueTasks);
-router.post("/", authenticate, authorizeRoles([APPOWNER, SUPERUSER]), createTask, tasks.addNewTask);
-router.patch("/:id", authenticate, authorizeRoles([APPOWNER, SUPERUSER]), updateTask, tasks.updateTask);
+router.post(
+  "/",
+  authenticate,
+  authorizeRoles([APPOWNER, SUPERUSER]),
+  invalidateCache({ invalidationKeys: [ALL_TASKS] }),
+  createTask,
+  tasks.addNewTask
+);
+router.patch(
+  "/:id",
+  authenticate,
+  authorizeRoles([APPOWNER, SUPERUSER]),
+  invalidateCache({ invalidationKeys: [ALL_TASKS] }),
+  updateTask,
+  tasks.updateTask
+);
 router.get("/:id/details", tasks.getTask);
 router.get("/:username", tasks.getUserTasks);
-router.patch("/self/:id", authenticate, updateSelfTask, tasks.updateTaskStatus, assignTask);
-router.patch("/assign/self", authenticate, tasks.assignTask);
+router.patch(
+  "/self/:id",
+  authenticate,
+  invalidateCache({ invalidationKeys: [ALL_TASKS] }),
+  updateSelfTask,
+  tasks.updateTaskStatus,
+  assignTask
+);
+router.patch("/assign/self", authenticate, invalidateCache({ invalidationKeys: [ALL_TASKS] }), tasks.assignTask);
 
 module.exports = router;

test/fixtures/cache/cache.js

@@ -0,0 +1,3 @@
+const dummyResponse = { body: "test" };
+
+module.exports = { dummyResponse };

test/unit/middlewares/cache.test.js

@@ -0,0 +1,78 @@
+const sinon = require("sinon");
+const { expect } = require("chai");
+const { cacheResponse, invalidateCache } = require("../../../utils/cache");
+
+const { dummyResponse } = require("../../fixtures/cache/cache");
+
+const responseBody = JSON.stringify(dummyResponse);
+
+describe("Middleware | Utils | cache", function () {
+  afterEach(function () {
+    sinon.restore();
+  });
+  it("should cache the response", function () {
+    const cacheTestKey = "__cache__1";
+
+    const request = {
+      method: "GET",
+      originalUrl: "/test1",
+    };
+
+    const response = {
+      send: sinon.spy(),
+    };
+
+    const nextSpy = sinon.spy();
+
+    const cacheMiddleware = cacheResponse({ invalidationKey: cacheTestKey });
+
+    cacheMiddleware(request, response, nextSpy);
+
+    response.send(responseBody);
+
+    expect(nextSpy.callCount).to.equal(1);
+    expect(response.send.callCount).to.equal(1);
+
+    cacheMiddleware(request, response, nextSpy);
+
+    expect(nextSpy.callCount).to.equal(1);
+    expect(response.send.callCount).to.equal(2);
+  });
+
+  it("should invalidate stale the response", function () {
+    const cacheTestKey = "__cache__2";
+
+    const request = {
+      method: "GET",
+      originalUrl: "/test2",
+    };
+    const response = {
+      send: sinon.spy(),
+    };
+
+    const nextSpy = sinon.spy();
+
+    const cacheMiddlewareForCache = cacheResponse({ invalidationKey: cacheTestKey });
+
+    cacheMiddlewareForCache(request, response, nextSpy);
+
+    response.send(responseBody);
+
+    expect(nextSpy.callCount).to.equal(1);
+    expect(response.send.callCount).to.equal(1);
+
+    const cacheMiddlewareForInvalidation = invalidateCache({ invalidationKeys: [cacheTestKey] });
+
+    cacheMiddlewareForInvalidation(request, response, nextSpy);
+    response.send(responseBody);
+
+    expect(nextSpy.callCount).to.equal(2);
+    expect(response.send.callCount).to.equal(2);
+
+    cacheMiddlewareForCache(request, response, nextSpy);
+    response.send(responseBody);
+
+    expect(nextSpy.callCount).to.equal(3);
+    expect(response.send.callCount).to.equal(3);
+  });
+});

test/unit/utils/cache.test.js

@@ -0,0 +1,73 @@
+const { expect } = require("chai");
+const { cachedKeysStore } = require("../../../utils/cache");
+
+describe("cachedKeysStore", function () {
+  let keyStore;
+  const modelKey = "modelKey";
+  beforeEach(function () {
+    keyStore = cachedKeysStore();
+  });
+
+  describe("getCachedKeys", function () {
+    it("should return an array of cached keys for a model key", function () {
+      const cachedKeys = new Set(["key1", "key2", "key3"]);
+      keyStore.addCachedKey(modelKey, "key1");
+      keyStore.addCachedKey(modelKey, "key2");
+      keyStore.addCachedKey(modelKey, "key3");
+
+      const result = keyStore.getCachedKeys(modelKey);
+
+      expect(result).to.be.an("set");
+      expect(result).to.be.deep.equal(cachedKeys);
+    });
+  });
+
+  describe("addCachedKey", function () {
+    it("should add a cached key to the key store", function () {
+      const cachedKey = "key1";
+
+      keyStore.addCachedKey(modelKey, cachedKey);
+
+      const result = keyStore.getCachedKeys(modelKey);
+      expect(result).to.deep.equal(new Set([cachedKey]));
+    });
+  });
+
+  describe("removeModelKey", function () {
+    it("should remove the model key and its associated cached keys from the key store", function () {
+      keyStore.addCachedKey(modelKey, "key1");
+      keyStore.addCachedKey(modelKey, "key2");
+      keyStore.addCachedKey(modelKey, "key3");
+
+      keyStore.removeModelKey(modelKey);
+
+      const result = keyStore.getCachedKeys(modelKey);
+      expect(result).to.be.an("set");
+      expect(result).to.deep.equal(new Set());
+    });
+  });
+
+  describe("removeCachedKey", function () {
+    it("should remove a cached key from the key store for a given model key", function () {
+      const cachedKey = "key1";
+      keyStore.addCachedKey(modelKey, cachedKey);
+
+      keyStore.removeCachedKey(modelKey, cachedKey);
+
+      const result = keyStore.getCachedKeys(modelKey);
+      expect(result).to.be.an("set");
+      expect(result).to.deep.equal(new Set());
+    });
+
+    it("should not remove other cached keys for the same model key", function () {
+      keyStore.addCachedKey(modelKey, "key1");
+      keyStore.addCachedKey(modelKey, "key2");
+      keyStore.addCachedKey(modelKey, "key3");
+
+      keyStore.removeCachedKey(modelKey, "key2");
+
+      const result = keyStore.getCachedKeys(modelKey);
+      expect(result).to.deep.equal(new Set(["key1", "key3"]));
+    });
+  });
+});