expose no-op caches in getBindingsProxy

.changeset/happy-pandas-sparkle.md

@@ -0,0 +1,12 @@
+---
+"wrangler": minor
+---
+
+expose new (no-op) `caches` field in `getBindingsProxy` result
+
+add a new `caches` field to the `getBindingsProxy` result, such field implements a
+no operation (no-op) implementation of the runtime `caches`
+
+Note: Miniflare exposes a proper `caches` mock, we will want to use that one in
+the future but issues regarding it must be ironed out first, so for the
+time being a no-op will have to do

fixtures/get-bindings-proxy/package.json

@@ -11,5 +11,8 @@
 		"@cloudflare/workers-tsconfig": "workspace:*",
 		"@cloudflare/workers-types": "^4.20221111.1",
 		"wrangler": "workspace:*"
+	},
+	"dependencies": {
+		"undici": "^5.28.2"
 	}
 }

fixtures/get-bindings-proxy/tests/get-bindings-proxy.test.ts

@@ -6,6 +6,7 @@ import {
 	Fetcher,
 	R2Bucket,
 } from "@cloudflare/workers-types";
+import { Request, Response } from "undici";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import {
 	getBindingsProxy as originalGetBindingsProxy,
@@ -227,6 +228,25 @@ describe("getBindingsProxy", () => {
 			await dispose();
 		}
 	});
+
+	describe("caches", () => {
+		(["default", "named"] as const).forEach((cacheType) =>
+			it(`correctly obtains a no-op ${cacheType} cache`, async () => {
+				const { caches, dispose } = await getBindingsProxy<Bindings>({
+					configPath: wranglerTomlFilePath,
+				});
+				try {
+					const cache =
+						cacheType === "default"
+							? caches.default
+							: await caches.open("my-cache");
+					testNoOpCache(cache);
+				} finally {
+					await dispose();
+				}
+			})
+		);
+	});
 });
 
 /**
@@ -263,3 +283,17 @@ async function testDoBinding(
 	const doRespText = await doResp.text();
 	expect(doRespText).toBe(expectedResponse);
 }
+
+async function testNoOpCache(
+	cache: Awaited<ReturnType<typeof getBindingsProxy>>["caches"]["default"]
+) {
+	let match = await cache.match("http://0.0.0.0/test");
+	expect(match).toBeUndefined();
+
+	const req = new Request("http://0.0.0.0/test");
+	await cache.put(req, new Response("test"));
+	const resp = await cache.match(req);
+	expect(resp).toBeUndefined();
+	const deleted = await cache.delete(req);
+	expect(deleted).toBe(false);
+}

packages/wrangler/src/api/integrations/bindings/index.ts

@@ -39,6 +39,10 @@ export type BindingsProxy<Bindings = Record<string, unknown>> = {
 	 * Object containing the various proxies
 	 */
 	bindings: Bindings;
+	/**
+	 * Caches object emulating the Workers Cache runtime API
+	 */
+	caches: CacheStorage;
 	/**
 	 * Function used to dispose of the child process providing the bindings implementation
 	 */
@@ -83,6 +87,7 @@ export async function getBindingsProxy<Bindings = Record<string, unknown>>(
 			...vars,
 			...bindings,
 		},
+		caches: getNoopCaches(),
 		dispose: () => mf.dispose(),
 	};
 }
@@ -162,3 +167,51 @@ function getMiniflarePersistOptions(
 		d1Persist: `${persistPath}/d1`,
 	};
 }
+
+// Note as to why we are re-implementing the Cache types here:
+//  The Request and Response types to be used with the caches come from miniflare itself, if we
+//  were to use the proper types users would need to provided to the utility objects typed with
+//  the actual miniflare types, which is actually what we don't want, so for now we just use
+// `unknown`s and we can think of better types later when we actually make the `caches` non no-op
+type CacheStorage = {
+	open(cacheName: string): Promise<Cache>;
+	readonly default: Cache;
+};
+type CacheRequest = unknown;
+type CacheResponse = unknown;
+
+type Cache = {
+	delete(request: CacheRequest, options?: CacheQueryOptions): Promise<boolean>;
+	match(
+		request: CacheRequest,
+		options?: CacheQueryOptions
+	): Promise<CacheResponse | undefined>;
+	put(request: CacheRequest, response: CacheResponse): Promise<void>;
+};
+type CacheQueryOptions = {
+	ignoreMethod?: boolean;
+};
+
+function getNoopCache(): Cache {
+	const noopCache: Cache = {
+		async delete() {
+			return false;
+		},
+		async match() {
+			return undefined;
+		},
+		async put() {},
+	};
+	return noopCache;
+}
+
+// We are not ready to expose miniflare's caches as those are problematic to use in a generic context
+// (since they only accept instances of the miniflare Request class and return only instances of the
+// miniflare Response class, making them tricky to use in generic node.js code), so we provide a no-op
+// implementation here until we sort the above issue out
+function getNoopCaches(): CacheStorage {
+	return {
+		default: getNoopCache(),
+		open: () => Promise.resolve(getNoopCache()),
+	};
+}