.github/workflows/c3-e2e-project-cleanup.yml

@@ -2,6 +2,7 @@
 
 name: C3 E2E Project Cleanup
 on:
+  workflow_dispatch:
   schedule:
     - cron: "0 3 * * *" # Run at 3am each day
 env:

.github/workflows/choose-pages-projects.yml → .github/workflows/deploy-pages-projects.yml

@@ -1,5 +1,17 @@
 name: Deploy all Pages sites
 
+# On a push to `main` or a PR that has one of the `preview:...`` labels,
+# deploy the matching Pages project to Cloudflare.
+#
+# PR Label                   | Pages Project
+# ---------------------------------------------------------
+# preview:wrangler-devtools  | packages/wrangler-devtools
+# preview:quick-edit         | packages/quick-edit
+# preview:workers-playground | packages/workers-playground
+#
+# Note: these actions are not for running tests against these packages,
+# only for deploying.
+
 on:
   push:
     branches:

CODEOWNERS

@@ -17,6 +17,9 @@
 # C3 ownership
 /packages/create-cloudflare/ @cloudflare/c3
 
+# kv-asset-handler ownership
+/packages/kv-asset-handler/ @cloudflare/developer-advocacy @kristianfreeman @rickyrobinett @lauragift21 @LoganGrasby @craigsdennis
+
 # Owners intentionally left blank on these shared directories
 # to avoid noisy review requests
 /.changeset/

fixtures/additional-modules/test/index.test.ts

@@ -167,33 +167,33 @@ describe("find_additional_modules deploy", () => {
 		const bundledEntry = await fs.readFile(bundledEntryPath, "utf8");
 		expect(bundledEntry).toMatchInlineSnapshot(`
 			"// src/index.ts
-			import common from \\"./common.cjs\\";
+			import common from "./common.cjs";
 
 			// src/dep.ts
-			var dep_default = \\"bundled\\";
+			var dep_default = "bundled";
 
 			// src/index.ts
-			import text from \\"./text.txt\\";
+			import text from "./text.txt";
 			var src_default = {
 			  async fetch(request) {
 			    const url = new URL(request.url);
-			    if (url.pathname === \\"/dep\\") {
+			    if (url.pathname === "/dep") {
 			      return new Response(dep_default);
 			    }
-			    if (url.pathname === \\"/text\\") {
+			    if (url.pathname === "/text") {
 			      return new Response(text);
 			    }
-			    if (url.pathname === \\"/common\\") {
+			    if (url.pathname === "/common") {
 			      return new Response(common);
 			    }
-			    if (url.pathname === \\"/dynamic\\") {
-			      return new Response((await import(\\"./dynamic.js\\")).default);
+			    if (url.pathname === "/dynamic") {
+			      return new Response((await import("./dynamic.js")).default);
 			    }
-			    if (url.pathname.startsWith(\\"/lang/\\")) {
-			      const language = \\"./lang/\\" + url.pathname.substring(\\"/lang/\\".length) + \\".js\\";
+			    if (url.pathname.startsWith("/lang/")) {
+			      const language = "./lang/" + url.pathname.substring("/lang/".length) + ".js";
 			      return new Response((await import(language)).default.hello);
 			    }
-			    return new Response(\\"Not Found\\", { status: 404 });
+			    return new Response("Not Found", { status: 404 });
 			  }
 			};
 			export {

fixtures/dev-env/package.json

@@ -16,7 +16,7 @@
 		"@types/ws": "^8.5.7",
 		"@cloudflare/workers-tsconfig": "workspace:^",
 		"get-port": "^7.0.0",
-		"miniflare": "3.20240129.1",
+		"miniflare": "3.20240129.2",
 		"undici": "^5.28.2",
 		"wrangler": "workspace:*",
 		"ws": "^8.14.2"

fixtures/dev-env/tests/index.test.ts

@@ -230,7 +230,7 @@ describe("startDevWorker: ProxyController", () => {
 		fireAndForgetFakeUserWorkerChanges({
 			mfOpts: run.mfOpts,
 			config: run.config,
-			script: run.mfOpts.script.replace("1", "2"),
+			script: run.mfOpts.script.replace("body:1", "body:2"),
 		});
 
 		res = await run.worker.fetch("http://dummy");
@@ -295,7 +295,7 @@ describe("startDevWorker: ProxyController", () => {
 		fireAndForgetFakeUserWorkerChanges({
 			mfOpts: run.mfOpts,
 			config: run.config,
-			script: run.mfOpts.script.replace("1", "2"),
+			script: run.mfOpts.script.replace("body:1", "body:2"),
 		});
 		await executionContextClearedPromise;
 	});
@@ -599,4 +599,53 @@ describe("startDevWorker: ProxyController", () => {
 			"URL: https://mybank.co.uk/test/path/2"
 		);
 	});
+
+	test("inflight requests are retried during UserWorker reloads", async () => {
+		// to simulate inflight requests failing during UserWorker reloads,
+		// we will use a UserWorker with a longish `await setTimeout(...)`
+		// so that we can guarantee the race condition is hit
+		// when workerd is eventually terminated
+
+		const run = await fakeStartUserWorker({
+			script: `
+				export default {
+					async fetch(request) {
+            const url = new URL(request.url);
+
+            if (url.pathname === '/long') {
+              await new Promise(r => setTimeout(r, 30_000));
+            }
+						return new Response("UserWorker:1");
+					}
+				}
+			`,
+		});
+
+		res = await run.worker.fetch("http://dummy/short"); // implicitly waits for UserWorker:1 to be ready
+		await expect(res.text()).resolves.toBe("UserWorker:1");
+
+		const inflightDuringReloads = run.worker.fetch("http://dummy/long");
+
+		// this will cause workerd for UserWorker:1 to terminate (eventually, but soon)
+		fireAndForgetFakeUserWorkerChanges({
+			mfOpts: run.mfOpts,
+			config: run.config,
+			script: run.mfOpts.script.replace("UserWorker:1", "UserWorker:2"), // change response so it can be identified
+		});
+
+		res = await run.worker.fetch("http://dummy/short"); // implicitly waits for UserWorker:2 to be ready
+		await expect(res.text()).resolves.toBe("UserWorker:2");
+
+		// this will cause workerd for UserWorker:2 to terminate (eventually, but soon)
+		fireAndForgetFakeUserWorkerChanges({
+			mfOpts: run.mfOpts,
+			config: run.config,
+			script: run.mfOpts.script
+				.replace("UserWorker:1", "UserWorker:3") // change response so it can be identified
+				.replace("30_000", "0"), // remove the long wait as we won't reload this UserWorker
+		});
+
+		res = await inflightDuringReloads;
+		await expect(res.text()).resolves.toBe("UserWorker:3");
+	});
 });

fixtures/get-bindings-proxy/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "get-bindings-proxy-fixture",
 	"private": true,
-	"description": "A test for the getBindingsProxy utility",
+	"description": "A test for the getBindingsProxy (deprecated) utility",
 	"scripts": {
 		"test": "vitest run",
 		"test:watch": "vitest",

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

@@ -6,13 +6,11 @@ import {
 	Fetcher,
 	R2Bucket,
 } from "@cloudflare/workers-types";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import {
-	getBindingsProxy as originalGetBindingsProxy,
-	unstable_dev,
-} from "wrangler";
+import { describe, expect, it } from "vitest";
+import { unstable_dev } from "wrangler";
+import { getBindingsProxy } from "./shared";
 import type { KVNamespace } from "@cloudflare/workers-types";
-import type { GetBindingsProxyOptions, UnstableDevWorker } from "wrangler";
+import type { UnstableDevWorker } from "wrangler";
 
 type Bindings = {
 	MY_VAR: string;
@@ -30,27 +28,21 @@ type Bindings = {
 
 const wranglerTomlFilePath = path.join(__dirname, "..", "wrangler.toml");
 
-// Here we wrap the actual original getBindingsProxy function and disable its persistance, this is to make sure
-// that we don't implement any persistance during these tests (which would add unnecessary extra complexity)
-function getBindingsProxy<T>(
-	options: Omit<GetBindingsProxyOptions, "persist">
-): ReturnType<typeof originalGetBindingsProxy<T>> {
-	return originalGetBindingsProxy({
-		...options,
-		persist: false,
-	});
-}
-
 describe("getBindingsProxy - bindings", () => {
 	let devWorkers: UnstableDevWorker[];
 
-	beforeAll(async () => {
-		devWorkers = await startWorkers();
-	});
+	// Note: we're skipping the service workers and durable object tests
+	//       so there's no need to start separate workers right now, the
+	//       following beforeAll and afterAll should be un-commented when
+	//       we reenable the tests
 
-	afterAll(async () => {
-		await Promise.allSettled(devWorkers.map((i) => i.stop()));
-	});
+	// beforeAll(async () => {
+	// 	devWorkers = await startWorkers();
+	// });
+
+	// afterAll(async () => {
+	// 	await Promise.allSettled(devWorkers.map((i) => i.stop()));
+	// });
 
 	describe("var bindings", () => {
 		it("correctly obtains var bindings from both wrangler.toml and .dev.vars", async () => {

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

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { getBindingsProxy } from "./shared";
+
+describe("getBindingsProxy - cf", () => {
+	it("should provide mock data", async () => {
+		const { cf, dispose } = await getBindingsProxy();
+		try {
+			expect(cf).toMatchObject({
+				colo: "DFW",
+				city: "Austin",
+				regionCode: "TX",
+			});
+		} finally {
+			await dispose();
+		}
+	});
+
+	it("should match the production runtime cf object", async () => {
+		const { cf, dispose } = await getBindingsProxy();
+		try {
+			expect(cf.constructor.name).toBe("Object");
+
+			expect(() => {
+				cf.city = "test city";
+			}).toThrowError(
+				"Cannot assign to read only property 'city' of object '#<Object>'"
+			);
+			expect(cf.city).not.toBe("test city");
+
+			expect(() => {
+				cf.newField = "test new field";
+			}).toThrowError("Cannot add property newField, object is not extensible");
+			expect("newField" in cf).toBe(false);
+
+			expect(cf.botManagement).toMatchObject({
+				score: 99,
+			});
+			expect(Object.isFrozen(cf.botManagement)).toBe(true);
+		} finally {
+			await dispose();
+		}
+	});
+});

fixtures/get-platform-proxy/.dev.vars

@@ -0,0 +1,3 @@
+MY_DEV_VAR = "my-dev-var-value"
+MY_VAR_A = "my-dev-var-a"
+MY_KV = "my-dev-kv"

fixtures/get-platform-proxy/custom-toml/path/.dev.vars

@@ -0,0 +1 @@
+MY_DEV_VAR = "my-dev-var-value-from-a-custom-location"

fixtures/get-platform-proxy/custom-toml/path/test-toml

@@ -0,0 +1,7 @@
+name = "get-bindings-proxy-fixture"
+main = "src/index.ts"
+compatibility_date = "2023-11-21"
+
+[vars]
+MY_VAR = "my-var-value-from-a-custom-toml"
+MY_JSON_VAR = { test = true, customToml = true }

fixtures/get-platform-proxy/package.json

@@ -0,0 +1,16 @@
+{
+	"name": "get-platform-proxy-fixture",
+	"private": true,
+	"description": "A test for the getPlatformProxy utility",
+	"scripts": {
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"type:tests": "tsc --noEmit"
+	},
+	"devDependencies": {
+		"@cloudflare/workers-tsconfig": "workspace:*",
+		"@cloudflare/workers-types": "^4.20221111.1",
+		"wrangler": "workspace:*",
+		"undici": "^5.28.2"
+	}
+}

fixtures/get-platform-proxy/tests/get-platform-proxy.caches.test.ts

@@ -0,0 +1,34 @@
+import { Request, Response } from "undici";
+import { describe, expect, it } from "vitest";
+import { getPlatformProxy } from "./shared";
+
+describe("getPlatformProxy - caches", () => {
+	(["default", "named"] as const).forEach((cacheType) =>
+		it(`correctly obtains a no-op ${cacheType} cache`, async () => {
+			const { caches, dispose } = await getPlatformProxy();
+			try {
+				const cache =
+					cacheType === "default"
+						? caches.default
+						: await caches.open("my-cache");
+				testNoOpCache(cache);
+			} finally {
+				await dispose();
+			}
+		})
+	);
+});
+
+async function testNoOpCache(
+	cache: Awaited<ReturnType<typeof getPlatformProxy>>["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);
+}

fixtures/get-platform-proxy/tests/get-platform-proxy.cf.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { getPlatformProxy } from "./shared";
+
+describe("getPlatformProxy - cf", () => {
+	it("should provide mock data", async () => {
+		const { cf, dispose } = await getPlatformProxy();
+		try {
+			expect(cf).toMatchObject({
+				colo: "DFW",
+				city: "Austin",
+				regionCode: "TX",
+			});
+		} finally {
+			await dispose();
+		}
+	});
+
+	it("should match the production runtime cf object", async () => {
+		const { cf, dispose } = await getPlatformProxy();
+		try {
+			expect(cf.constructor.name).toBe("Object");
+
+			expect(() => {
+				cf.city = "test city";
+			}).toThrowError(
+				"Cannot assign to read only property 'city' of object '#<Object>'"
+			);
+			expect(cf.city).not.toBe("test city");
+
+			expect(() => {
+				cf.newField = "test new field";
+			}).toThrowError("Cannot add property newField, object is not extensible");
+			expect("newField" in cf).toBe(false);
+
+			expect(cf.botManagement).toMatchObject({
+				score: 99,
+			});
+			expect(Object.isFrozen(cf.botManagement)).toBe(true);
+		} finally {
+			await dispose();
+		}
+	});
+});