feat(plugin): add withCaching plugin (#49)

* feat(plugin): add `withCaching` plugin

* Create many-mails-tie.md

* fix(with-caching): export drivers

Author: teofanis

.changeset/breezy-coins-buy.md

@@ -0,0 +1,6 @@
+---
+'@composite-fetcher/with-caching': minor
+'@composite-fetcher/with-logging': minor
+---
+
+feat(plugin): add `withCaching` plugin

.changeset/many-mails-tie.md

@@ -0,0 +1,6 @@
+---
+"@composite-fetcher/with-caching": patch
+"@composite-fetcher/with-logging": patch
+---
+
+feat(plugin): add `withCaching` plugin

composite-fetcher.code-workspace

@@ -4,10 +4,14 @@
       "name": "Fetcher Core",
       "path": "packages/core"
     },
-      {
+    {
       "name": "withLogging Plugin",
       "path": "packages/with-logging"
     },
+    {
+      "name": "withCaching Plugin",
+      "path": "packages/with-caching"
+    },
     {
       "name": "Docs",
       "path": "apps/docs"

packages/with-caching/.eslintignore

@@ -0,0 +1 @@
+.eslintrc.cjs

packages/with-caching/.eslintrc.cjs

@@ -0,0 +1,7 @@
+module.exports = {
+  root: true,
+  extends: ['@composite-fetcher/eslint-config/base'],
+  parserOptions: {
+    project: ['./tsconfig.json'],
+  },
+};

packages/with-caching/README.md

@@ -0,0 +1,7 @@
+# `@composite-fetcher/with-caching`
+
+## Description
+
+withCaching is a simple fetcher core plugin to manage request caching with different drivers
+
+- Teofanis Papadopulos

packages/with-caching/jest.config.cjs

@@ -0,0 +1,37 @@
+module.exports = {
+  preset: 'ts-jest',
+  moduleNameMapper: {
+    '^@/(.*)$': '<rootDir>/src/$1',
+  },
+  transform: {
+    '^.+\\.(j|t)s?$': [
+      'ts-jest',
+      {
+        tsconfig: 'tsconfig.jest.json',
+      },
+    ],
+  },
+  extensionsToTreatAsEsm: ['.ts', '.tsx'],
+  resetModules: false,
+  clearMocks: true,
+  collectCoverage: true,
+  collectCoverageFrom: [
+    '<rootDir>/src/**/*.{js,jsx,ts,tsx}',
+    '!<rootDir>/src/**/_*.{js,jsx,ts,tsx}',
+    '!<rootDir>/src/**/index.{js,jsx,ts,tsx}',
+    '!**/node_modules/**',
+    '!**/*.d.ts',
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 75,
+      functions: 75,
+      lines: 75,
+      statements: 75,
+    },
+  },
+  transformIgnorePatterns: [],
+  coverageReporters: ['json-summary', 'text', 'lcov'],
+  coverageDirectory: '<rootDir>/coverage',
+  testEnvironment: 'jest-environment-node',
+};

packages/with-caching/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@composite-fetcher/with-caching",
+  "description": "withCaching is a simple fetcher core plugin to manage request caching with different drivers",
+  "version": "0.0.0",
+  "author": "Teofanis Papadopulos",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "files": [
+    "dist/**"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "pnpm run build -- --watch",
+    "lint": "eslint \"src/**/*.ts*\"",
+    "test": "jest",
+    "format": "pnpm run lint -- --fix && prettier --write \"src/**/*.ts*\" --ignore-path .gitignore",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  },
+  "devDependencies": {
+    "@composite-fetcher/eslint-config": "workspace:*",
+    "@composite-fetcher/tsconfig": "workspace:*",
+    "@types/isomorphic-fetch": "^0.0.36",
+    "@types/jest": "^29.5.5",
+    "@types/node": "^20.7.0",
+    "fetch-mock": "^9.11.0",
+    "isomorphic-fetch": "^3.0.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1"
+  },
+  "dependencies": {
+    "@composite-fetcher/core": "workspace:^"
+  }
+}

packages/with-caching/src/__mocks__/isomorphic-fetch.js

@@ -0,0 +1,6 @@
+// eslint-disable-next-line import/no-extraneous-dependencies, @typescript-eslint/no-var-requires
+const fetchMock = require('fetch-mock');
+
+const fetch = fetchMock.sandbox();
+
+module.exports = fetch;

packages/with-caching/src/__tests__/InMemoryCacheDriver.test.ts

@@ -0,0 +1,87 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import InMemoryCacheDriver from '@/drivers/InMemoryCacheDriver';
+import _fetchMock from 'isomorphic-fetch';
+
+type FetchMock = typeof import('fetch-mock');
+const fetchMock = _fetchMock as unknown as FetchMock;
+
+describe('InMemoryCacheDriver', () => {
+  let cacheDriver: InMemoryCacheDriver;
+
+  let mockResponse: (bodyContent: string) => Response;
+
+  beforeEach(() => {
+    cacheDriver = new InMemoryCacheDriver();
+    global.Response = fetchMock.config.Response as unknown as typeof Response;
+    mockResponse = (bodyContent: string) =>
+      new Response(bodyContent, {
+        headers: {
+          'Content-Type': 'text/plain',
+        },
+      });
+  });
+
+  it('should add an item to the cache', async () => {
+    const response = mockResponse('value1');
+    await cacheDriver.set('key1', response);
+    expect(await cacheDriver.has('key1')).toBeTruthy();
+  });
+
+  it('should retrieve an item from the cache', async () => {
+    const response = mockResponse('value1');
+    await cacheDriver.set('key1', response);
+    const cachedResponse = await cacheDriver.get('key1');
+    expect(cachedResponse).toBeDefined();
+    expect(await cachedResponse!.text()).toBe('value1');
+  });
+
+  it('should return null for a non-existent item', async () => {
+    const cachedResponse = await cacheDriver.get('nonexistent');
+    expect(cachedResponse).toBeNull();
+  });
+
+  it('should delete an item from the cache', async () => {
+    const response = mockResponse('value1');
+    await cacheDriver.set('key1', response);
+    expect(await cacheDriver.has('key1')).toBeTruthy();
+
+    await cacheDriver.delete('key1');
+    expect(await cacheDriver.has('key1')).toBeFalsy();
+  });
+
+  it('should clear all items from the cache', async () => {
+    await cacheDriver.set('key1', mockResponse('value1'));
+    await cacheDriver.set('key2', mockResponse('value2'));
+
+    await cacheDriver.clear();
+
+    expect(await cacheDriver.has('key1')).toBeFalsy();
+    expect(await cacheDriver.has('key2')).toBeFalsy();
+  });
+
+  it('should not retrieve expired items', async () => {
+    const oneSecondAgo = new Date(Date.now() - 1000);
+    await cacheDriver.set('key1', mockResponse('value1'), oneSecondAgo);
+
+    const cachedResponse = await cacheDriver.get('key1');
+    expect(cachedResponse).toBeNull();
+  });
+
+  it('should automatically remove expired items when checking its existence', async () => {
+    const oneSecondAgo = new Date(Date.now() - 1000);
+    await cacheDriver.set('key1', mockResponse('value1'), oneSecondAgo);
+
+    // Checking its existence will internally remove it because it's expired
+    const exists = await cacheDriver.has('key1');
+    expect(exists).toBeFalsy();
+  });
+
+  it('should retrieve items that are not yet expired', async () => {
+    const tenSecondsFromNow = new Date(Date.now() + 10000);
+    await cacheDriver.set('key1', mockResponse('value1'), tenSecondsFromNow);
+
+    const cachedResponse = await cacheDriver.get('key1');
+    expect(cachedResponse).toBeDefined();
+    expect(await cachedResponse!.text()).toBe('value1');
+  });
+});