Add caching

Author: FrederikBolding

packages/snaps-utils/src/fs.test.ts

@@ -1,12 +1,13 @@
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import { join } from 'path';
+import { join, dirname } from 'path';
 
 import {
   getOutfilePath,
   isDirectory,
   isFile,
   readJsonFile,
+  useFileSystemCache,
   useTemporaryFile,
   validateDirPath,
   validateFilePath,
@@ -20,13 +21,15 @@ jest.mock('fs');
 
 const BASE_PATH = '/snap';
 const MANIFEST_PATH = join(BASE_PATH, NpmSnapFileNames.Manifest);
+const CACHE_PATH = join(process.cwd(), 'node_modules/.cache');
 
 /**
  * Clears out all the files in the in-memory file system, and writes the default
  * files to the `BASE_PATH` folder, including sub-folders.
  */
 async function resetFileSystem() {
   await fs.rm(BASE_PATH, { recursive: true, force: true });
+  await fs.rm(CACHE_PATH, { recursive: true, force: true });
 
   // Create `dist` folder.
   await fs.mkdir(join(BASE_PATH, 'dist'), { recursive: true });
@@ -262,3 +265,73 @@ describe('useTemporaryFile', () => {
     expect(await isFile(filePath)).toBe(false);
   });
 });
+
+describe('useFileSystemCache', () => {
+  beforeEach(async () => {
+    await resetFileSystem();
+  });
+
+  const cachedFunction = useFileSystemCache('foo', 5000, async () => {
+    return 'foo';
+  });
+
+  const cachedFilePath = join(CACHE_PATH, 'foo.json');
+
+  it('writes cached value to the file system', async () => {
+    const spy = jest.spyOn(fs, 'writeFile');
+    expect(await cachedFunction()).toBe('foo');
+
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    const cacheValue = await fs.readFile(cachedFilePath, 'utf8');
+    const cacheJson = JSON.parse(cacheValue);
+
+    expect(cacheJson).toStrictEqual({
+      timestamp: expect.any(Number),
+      value: 'foo',
+    });
+  });
+
+  it('reads cached value from the file system', async () => {
+    const readSpy = jest.spyOn(fs, 'readFile');
+    const writeSpy = jest.spyOn(fs, 'writeFile');
+
+    expect(await cachedFunction()).toBe('foo');
+    expect(await cachedFunction()).toBe('foo');
+
+    expect(readSpy).toHaveBeenCalledTimes(2);
+    expect(writeSpy).toHaveBeenCalledTimes(1);
+
+    const cacheValue = await fs.readFile(cachedFilePath, 'utf8');
+    const cacheJson = JSON.parse(cacheValue);
+
+    expect(cacheJson).toStrictEqual({
+      timestamp: expect.any(Number),
+      value: 'foo',
+    });
+  });
+
+  it('discards cached value if it is expired', async () => {
+    await fs.mkdir(dirname(cachedFilePath), { recursive: true });
+    await fs.writeFile(
+      cachedFilePath,
+      JSON.stringify({ timestamp: Date.now() - 6000, value: 'bar' }),
+    );
+
+    const readSpy = jest.spyOn(fs, 'readFile');
+    const writeSpy = jest.spyOn(fs, 'writeFile');
+
+    expect(await cachedFunction()).toBe('foo');
+
+    expect(readSpy).toHaveBeenCalledTimes(1);
+    expect(writeSpy).toHaveBeenCalledTimes(1);
+
+    const cacheValue = await fs.readFile(cachedFilePath, 'utf8');
+    const cacheJson = JSON.parse(cacheValue);
+
+    expect(cacheJson).toStrictEqual({
+      timestamp: expect.any(Number),
+      value: 'foo',
+    });
+  });
+});

packages/snaps-utils/src/fs.ts

@@ -182,3 +182,51 @@ export async function useTemporaryFile<Type = unknown>(
     }
   }
 }
+
+/**
+ * Use the file system to cache a return value with a given key and TTL.
+ *
+ * @param cacheKey - The key to use for the cache.
+ * @param ttl - The time-to-live.
+ * @param fn - The callback function to wrap.
+ * @returns The result from the callback.
+ */
+export function useFileSystemCache<Type = unknown>(
+  cacheKey: string,
+  ttl: number,
+  fn: () => Promise<Type>,
+) {
+  return async () => {
+    const filePath = pathUtils.join(
+      process.cwd(),
+      'node_modules/.cache',
+      `${cacheKey}.json`,
+    );
+
+    try {
+      const cacheContents = await fs.readFile(filePath, 'utf8');
+      const json = JSON.parse(cacheContents);
+
+      if (json.timestamp + ttl > Date.now()) {
+        return json.value;
+      }
+    } catch {
+      // No-op
+    }
+
+    const value = await fn();
+
+    try {
+      await fs.mkdir(pathUtils.dirname(filePath), { recursive: true });
+
+      const json = { timestamp: Date.now(), value };
+      await fs.writeFile(filePath, JSON.stringify(json), {
+        encoding: 'utf8',
+      });
+    } catch {
+      // No-op
+    }
+
+    return value;
+  };
+}

packages/snaps-utils/src/manifest/validators/production-platform-version.test.ts

@@ -5,6 +5,8 @@ import fetchMock from 'jest-fetch-mock';
 import { productionPlatformVersion } from './production-platform-version';
 import { getMockSnapFiles, getSnapManifest } from '../../test-utils';
 
+jest.mock('fs');
+
 const MOCK_GITHUB_RESPONSE = JSON.stringify({
   // eslint-disable-next-line @typescript-eslint/naming-convention
   target_commitish: '5fceb7ed2ef18a3984786db1161a76ca5c8e15b9',

packages/snaps-utils/src/manifest/validators/production-platform-version.ts

@@ -1,5 +1,7 @@
+import { Duration, inMilliseconds } from '@metamask/utils';
 import { minVersion, gt } from 'semver';
 
+import { useFileSystemCache } from '../../fs';
 import type { ValidatorMeta } from '../validator-types';
 
 /**
@@ -8,30 +10,34 @@ import type { ValidatorMeta } from '../validator-types';
  *
  * @returns The production version of the Snaps platform or null if any error occurred.
  */
-async function determineProductionVersion() {
-  try {
-    // TODO: Cache this check.
-    const latestRelease = await fetch(
-      'https://api.github.com/repos/metamask/metamask-extension/releases/latest',
-    );
+const determineProductionVersion = useFileSystemCache(
+  'snaps-production-version',
+  inMilliseconds(7, Duration.Day),
+  async () => {
+    try {
+      // TODO: Cache this check.
+      const latestRelease = await fetch(
+        'https://api.github.com/repos/metamask/metamask-extension/releases/latest',
+      );
 
-    const latestReleaseJson = await latestRelease.json();
+      const latestReleaseJson = await latestRelease.json();
 
-    const latestReleaseCommit = latestReleaseJson.target_commitish;
+      const latestReleaseCommit = latestReleaseJson.target_commitish;
 
-    const packageJsonResponse = await fetch(
-      `https://raw.githubusercontent.com/MetaMask/metamask-extension/${latestReleaseCommit}/package.json`,
-    );
+      const packageJsonResponse = await fetch(
+        `https://raw.githubusercontent.com/MetaMask/metamask-extension/${latestReleaseCommit}/package.json`,
+      );
 
-    const packageJson = await packageJsonResponse.json();
+      const packageJson = await packageJsonResponse.json();
 
-    const versionRange = packageJson.dependencies['@metamask/snaps-sdk'];
+      const versionRange = packageJson.dependencies['@metamask/snaps-sdk'];
 
-    return minVersion(versionRange);
-  } catch {
-    return null;
-  }
-}
+      return minVersion(versionRange)?.format();
+    } catch {
+      return null;
+    }
+  },
+);
 
 /**
  * Check if the platform version in manifest exceeds the version
@@ -54,7 +60,7 @@ export const productionPlatformVersion: ValidatorMeta = {
 
     if (gt(manifestPlatformVersion, maximumVersion)) {
       context.report(
-        `The "platformVersion" in use is not supported in the production version of MetaMask yet. The current production version is "${maximumVersion.format()}".`,
+        `The "platformVersion" in use is not supported in the production version of MetaMask yet. The current production version is "${maximumVersion}".`,
       );
     }
   },