feat(memo): Cache timeout (#630)

* Add base tests for memoize and clear

* feat: create timedMemoize function

* feat: add reset timer functionality

* refactor: join not timed and timed memoize funcs

* refactor: dry timed functions to only one

* style: remove comments

Co-authored-by: guijun13 <guilhermejun13.grillo@gmail.com>

Author: tassoevan

packages/memo/.eslintrc.js

@@ -29,28 +29,50 @@
     "/dist"
   ],
   "scripts": {
-    "build": "run-s .:build:clean .:build:esm .:build:cjs",
-    ".:build:clean": "rimraf dist",
+    "clean": "rimraf dist",
+    "build": "run .:build:esm && run .:build:cjs",
     ".:build:esm": "tsc -p tsconfig-esm.json",
     ".:build:cjs": "tsc -p tsconfig-cjs.json",
     "lint": "lint",
     "lint-and-fix": "lint-and-fix",
     "lint-staged": "lint-staged",
+    "test": "jest --runInBand",
     "docs": "typedoc"
   },
   "devDependencies": {
     "@rocket.chat/eslint-config-alt": "workspace:~",
     "@rocket.chat/prettier-config": "workspace:~",
+    "@types/jest": "~27.4.0",
     "eslint": "~8.8.0",
+    "jest": "~27.5.1",
     "lint-all": "workspace:~",
     "lint-staged": "~12.3.3",
-    "npm-run-all": "^4.1.5",
     "prettier": "~2.5.1",
-    "rimraf": "^3.0.2",
+    "rimraf": "~3.0.2",
+    "ts-jest": "~27.1.3",
     "typedoc": "~0.22.11",
     "typescript": "~4.3.5"
   },
-  "dependencies": {
-    "tslib": "^2.3.1"
+  "eslintConfig": {
+    "extends": "@rocket.chat/eslint-config-alt/typescript",
+    "env": {
+      "jest": true
+    }
+  },
+  "prettier": "@rocket.chat/prettier-config/fuselage",
+  "jest": {
+    "preset": "ts-jest",
+    "errorOnDeprecated": true,
+    "testMatch": [
+      "<rootDir>/src/**/*.spec.ts"
+    ],
+    "globals": {
+      "ts-jest": {
+        "tsconfig": {
+          "noUnusedLocals": false,
+          "noUnusedParameters": false
+        }
+      }
+    }
   }
 }

packages/memo/.prettierrc.js

@@ -0,0 +1,105 @@
+import { memoize, clear } from './memoize';
+
+it('should memoize a function that takes no parameter', () => {
+  const fn = jest.fn(() => 'foo');
+  const memoized = jest.fn(memoize(fn));
+
+  memoized(undefined);
+  memoized(undefined);
+
+  expect(memoized).toHaveBeenCalledTimes(2);
+  expect(fn).toHaveBeenCalledTimes(1);
+
+  expect(fn).toHaveReturnedWith('foo');
+  expect(memoized).toHaveReturnedWith('foo');
+});
+
+it('should memoize a function that takes one parameter', () => {
+  const fn = jest.fn((i: number) => i + 1);
+  const memoized = jest.fn(memoize(fn));
+
+  memoized(5);
+  memoized(5);
+  memoized(2);
+
+  expect(memoized).toHaveBeenCalledTimes(3);
+  expect(fn).toHaveBeenCalledTimes(2);
+
+  expect(fn).toHaveNthReturnedWith(1, 6);
+  expect(fn).toHaveNthReturnedWith(2, 3);
+
+  expect(memoized).toHaveNthReturnedWith(1, 6);
+  expect(memoized).toHaveNthReturnedWith(2, 6);
+  expect(memoized).toHaveNthReturnedWith(3, 3);
+});
+
+describe('clear', () => {
+  it('should discard cached values of a memoized function', () => {
+    const fn = jest.fn(() => 'foo');
+    const memoized = memoize(fn);
+    const spiedMemoized = jest.fn(memoized);
+
+    spiedMemoized(undefined);
+    spiedMemoized(undefined);
+    clear(memoized);
+    spiedMemoized(undefined);
+
+    expect(spiedMemoized).toHaveBeenCalledTimes(3);
+    expect(fn).toHaveBeenCalledTimes(2);
+
+    expect(fn).toHaveReturnedWith('foo');
+    expect(spiedMemoized).toHaveReturnedWith('foo');
+  });
+
+  it('should do nothing when a non-memoized function is passed', () => {
+    const fn = jest.fn(() => 'foo');
+
+    expect(() => clear(fn)).not.toThrowError();
+  });
+});
+
+describe('timeout', () => {
+  it('should memoize a function that takes one parameter and clear after x ms', () => {
+    jest.useFakeTimers();
+
+    const fn = jest.fn((i: number) => i + 1);
+    const memoized = jest.fn(memoize(fn, { maxAge: 3000 }));
+
+    memoized(5);
+    jest.advanceTimersByTime(2000);
+    memoized(5);
+    jest.advanceTimersByTime(2000);
+    memoized(5);
+    jest.advanceTimersByTime(3000);
+    memoized(5);
+
+    expect(fn).toHaveBeenCalledTimes(2);
+
+    expect(memoized).toHaveNthReturnedWith(1, 6);
+    expect(memoized).toHaveNthReturnedWith(2, 6);
+    expect(memoized).toHaveNthReturnedWith(3, 6);
+    expect(memoized).toHaveNthReturnedWith(4, 6);
+  });
+
+  it('should memoize a function caching for two parameters and clearing both after x ms each one', () => {
+    jest.useFakeTimers();
+
+    const fn = jest.fn((i: number) => i + 1);
+    const memoized = jest.fn(memoize(fn, { maxAge: 3000 }));
+
+    memoized(5);
+    jest.advanceTimersByTime(2000);
+    memoized(6);
+    jest.advanceTimersByTime(2000);
+
+    memoized(6);
+    memoized(5);
+
+    expect(fn).toHaveBeenCalledTimes(3);
+
+    expect(memoized).toHaveNthReturnedWith(1, 6);
+    expect(memoized).toHaveNthReturnedWith(2, 7);
+    expect(memoized).toHaveNthReturnedWith(3, 7);
+    expect(memoized).toHaveNthReturnedWith(4, 6);
+  });
+});

packages/memo/CHANGELOG.md

@@ -1,6 +1,10 @@
 type MemoizableFunction<T, A, R> = (this: T, arg: A) => R;
 type MemoizedFunction<T, A, R> = (this: T, arg: A) => R;
 
+interface Options {
+  maxAge: number;
+}
+
 const store = new WeakMap<
   MemoizableFunction<unknown, unknown, unknown>,
   Map<unknown, unknown>
@@ -13,21 +17,43 @@ const isCachedValue = <A, R>(
 ): cachedValue is R => cache.has(arg) && cache.get(arg) === cachedValue;
 
 export const memoize = <T, A, R>(
-  fn: MemoizableFunction<T, A, R>
+  fn: MemoizableFunction<T, A, R>,
+  _options?: Options
 ): MemoizedFunction<T, A, R> => {
   const cache = new Map<A, R>();
+  const cacheTimers = new Map<A, ReturnType<typeof setTimeout>>();
 
   const memoized: MemoizedFunction<T, A, R> = function (this, arg) {
+    const cleanUp = (): void => {
+      cache.delete(arg);
+      cacheTimers.delete(arg);
+    };
+
     const cachedValue = cache.get(arg);
 
     if (isCachedValue(cachedValue, arg, cache)) {
+      const oldTimer = cacheTimers.get(arg);
+      if (oldTimer) {
+        clearTimeout(oldTimer);
+      }
+
+      if (_options) {
+        const timer = setTimeout(cleanUp, _options.maxAge);
+        cacheTimers.set(arg, timer);
+      }
+
       return cachedValue;
     }
 
     const result = fn.call(this, arg);
 
     cache.set(arg, result);
 
+    if (_options) {
+      const timer = setTimeout(cleanUp, _options.maxAge);
+      cacheTimers.set(arg, timer);
+    }
+
     return result;
   };
 
@@ -37,11 +63,8 @@ export const memoize = <T, A, R>(
 };
 
 export const clear = (
-  fn: MemoizableFunction<unknown, unknown, unknown>
+  fn: MemoizedFunction<unknown, unknown, unknown>
 ): void => {
-  const x = store.get(fn);
-
-  if (x) {
-    x.clear();
-  }
+  const cache = store.get(fn);
+  cache?.clear();
 };

packages/memo/package.json

@@ -12,5 +12,9 @@
     "forceConsistentCasingInFileNames": true,
     "moduleResolution": "node",
     "resolveJsonModule": true
+  },
+  "typedocOptions": {
+    "entryPoints": ["src/index.ts"],
+    "out": "../../static/memo"
   }
 }

packages/memo/src/memoize.spec.ts

@@ -5784,13 +5784,14 @@ __metadata:
   dependencies:
     "@rocket.chat/eslint-config-alt": "workspace:~"
     "@rocket.chat/prettier-config": "workspace:~"
+    "@types/jest": ~27.4.0
     eslint: ~8.8.0
+    jest: ~27.5.1
     lint-all: "workspace:~"
     lint-staged: ~12.3.3
-    npm-run-all: ^4.1.5
     prettier: ~2.5.1
-    rimraf: ^3.0.2
-    tslib: ^2.3.1
+    rimraf: ~3.0.2
+    ts-jest: ~27.1.3
     typedoc: ~0.22.11
     typescript: ~4.3.5
   languageName: unknown
@@ -17462,12 +17463,12 @@ fsevents@~2.1.2:
   linkType: hard
 
 "istanbul-reports@npm:^3.1.3":
-  version: 3.1.4
-  resolution: "istanbul-reports@npm:3.1.4"
+  version: 3.1.3
+  resolution: "istanbul-reports@npm:3.1.3"
   dependencies:
     html-escaper: ^2.0.0
     istanbul-lib-report: ^3.0.0
-  checksum: 2132983355710c522f6b26808015cab9a0ee8b9f5ae0db0d3edeff40b886dd83cb670fb123cb7b32dbe59473d7c00cdde2ba6136bc0acdb20a865fccea64dfe1
+  checksum: ef6e0d9ed05ecab1974c6eb46cc2a12d8570911934192db4ed40cf1978449240ea80aae32c4dd5555b67407cdf860212d1a9e415443af69641aa57ed1da5ebbb
   languageName: node
   linkType: hard