Add support for namespaced caches

Author: mrbbot

CHANGELOG.md

@@ -1,8 +1,17 @@
 # 🚧 Changelog
 
+## 1.1.0
+
+### Features
+
+- Added support for namespaced caches with `caches.open`. See
+  [✨ Cache](https://miniflare.dev/cache.html) for more details.
+
 ## 1.0.1
 
-- Fix
+### Fixes
+
+- Fixed
   `/usr/bin/env: 'node --experimental-vm-modules': No such file or directory`
   error when running the CLI in Linux. See
   [💻 Using the CLI](https://miniflare.dev/cli.html#usage) for more details.
@@ -94,6 +103,8 @@
 
 ## 0.1.1
 
+### Fixes
+
 - Depend on `@mrbbot/node-fetch` from npm instead of GitHub, closes
   [issue #2](https://github.com/mrbbot/miniflare/issues/2)
 

docs/cache.md

@@ -1,6 +1,8 @@
 # ✨ Cache
 
 - [Cache Reference](https://developers.cloudflare.com/workers/runtime-apis/cache)
+- [How the Cache workers](https://developers.cloudflare.com/workers/learning/how-the-cache-works#cache-api)
+  (note that cache using `fetch` is unsupported)
 
 ## Default Cache
 
@@ -12,6 +14,15 @@ addEventListener("fetch", (e) => {
 });
 ```
 
+## Named Caches
+
+You can access a namespaced cache using `open`. Note that you cannot name your
+cache `default`, trying to do so will throw an error:
+
+```js
+await caches.open("cache_name");
+```
+
 ## Persistence
 
 By default, cached data is stored in memory. It will persist between reloads,
@@ -36,12 +47,15 @@ const mf = new Miniflare({
 });
 ```
 
+Each namespace will get its own directory within the cache persistence
+directory.
+
 ## Manipulating Outside Workers
 
 For testing, it can be useful to put/match data from cache outside a worker. You
 can do this with the `getCache` method:
 
-```js{23-31}
+```js{23-33}
 import { Miniflare, Response } from "miniflare";
 
 const mf = new Miniflare({
@@ -64,7 +78,8 @@ const mf = new Miniflare({
 let res = await mf.dispatchFetch("http://localhost:8787/put");
 console.log(await res.text()); // 1
 
-const cache = await mf.getCache();
+const cache = await mf.getCache(); // Gets the default cache
+const namedCache = await mf.getCached("cache_name"); // Gets a namespaced cache
 const cachedRes = await cache.match("https://miniflare.dev/");
 console.log(await cachedRes.text()); // 1
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "miniflare",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Fun, full-featured, fully-local simulator for Cloudflare Workers",
   "keywords": [
     "cloudflare",

src/modules/cache.ts

@@ -1,11 +1,13 @@
 import path from "path";
+import { MiniflareError } from "../error";
 import { Cache } from "../kv";
 import { KVStorageFactory } from "../kv/helpers";
 import { Log } from "../log";
 import { ProcessedOptions } from "../options";
 import { Context, Module } from "./module";
 
 const defaultPersistRoot = path.resolve(".mf", "cache");
+const defaultCacheName = "default";
 
 export class CacheModule extends Module {
   constructor(
@@ -15,12 +17,24 @@ export class CacheModule extends Module {
     super(log);
   }
 
-  getCache(name = "default", persist?: boolean | string): Cache {
+  getCache(name = defaultCacheName, persist?: boolean | string): Cache {
     return new Cache(this.storageFactory.getStorage(name, persist));
   }
 
   buildSandbox(options: ProcessedOptions): Context {
     const defaultCache = this.getCache(undefined, options.cachePersist);
-    return { caches: { default: defaultCache } };
+    return {
+      caches: {
+        default: defaultCache,
+        open: async (name: string) => {
+          if (name === defaultCacheName) {
+            throw new MiniflareError(
+              `\"${defaultCacheName}\" is a reserved cache name`
+            );
+          }
+          return this.getCache(name, options.cachePersist);
+        },
+      },
+    };
   }
 }

src/modules/standards.ts

@@ -236,6 +236,10 @@ export class StandardsModule extends Module {
       return new Response(null, { webSocket: worker });
     }
 
+    // TODO: (low priority) support cache using fetch:
+    //  https://developers.cloudflare.com/workers/learning/how-the-cache-works#fetch
+    //  https://developers.cloudflare.com/workers/examples/cache-using-fetch
+
     return originalFetch(request);
   }
 

test/modules/cache.spec.ts

@@ -1,7 +1,13 @@
 import { existsSync, promises as fs } from "fs";
 import path from "path";
 import test from "ava";
-import { Cache, CachedResponse, NoOpLog, Response } from "../../src";
+import {
+  Cache,
+  CachedResponse,
+  MiniflareError,
+  NoOpLog,
+  Response,
+} from "../../src";
 import { KVStorageFactory } from "../../src/kv/helpers";
 import { CacheModule } from "../../src/modules/cache";
 import { runInWorker, useTmp } from "../helpers";
@@ -217,3 +223,43 @@ test("buildSandbox: can delete from default cache", async (t) => {
     existsSync(path.join(tmp, "default", "http___localhost_8787_test.json"))
   );
 });
+test("buildSandbox: namespaced cache is separate from default cache", async (t) => {
+  const tmp = await useTmp(t);
+  const cached = await runInWorker({ cachePersist: tmp }, async () => {
+    const sandbox = self as any;
+
+    // Store something at the same URLs in default and other caches
+    const defaultCache = sandbox.caches.default as Cache;
+    const otherCache = (await sandbox.caches.open("other")) as Cache;
+
+    await defaultCache.put(
+      "http://localhost:8787/test",
+      new sandbox.Response("default", {
+        headers: { "Cache-Control": "max-age=3600" },
+      })
+    );
+    await otherCache.put(
+      "http://localhost:8787/test",
+      new sandbox.Response("other", {
+        headers: { "Cache-Control": "max-age=3600" },
+      })
+    );
+
+    const defaultCached = await defaultCache.match(
+      "http://localhost:8787/test"
+    );
+    const otherCached = await otherCache.match("http://localhost:8787/test");
+
+    return [await defaultCached?.text(), await otherCached?.text()];
+  });
+  t.deepEqual(cached, ["default", "other"]);
+});
+test("buildSandbox: trying to open default cache throws", async (t) => {
+  const tmp = await useTmp(t);
+  const module = new CacheModule(new NoOpLog(), new KVStorageFactory(tmp));
+  const { caches } = module.buildSandbox({});
+  await t.throwsAsync(caches.open("default"), {
+    instanceOf: MiniflareError,
+    message: '"default" is a reserved cache name',
+  });
+});