wrangler 2.1.4 → 2.1.6

package/miniflare-dist/index.mjs

@@ -6099,7 +6099,10 @@ async function generateAssetsFetch(directory, log) {
           );
         }
         const body = readFileSync5(filepath);
-        const contentType = (0, import_mime.getType)(filepath) || "application/octet-stream";
+        let contentType = (0, import_mime.getType)(filepath) || "application/octet-stream";
+        if (contentType.startsWith("text/") && !contentType.includes("charset")) {
+          contentType = `${contentType}; charset=utf-8`;
+        }
         return { body, contentType };
       }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrangler",
-	"version": "2.1.4",
+	"version": "2.1.6",
 	"description": "Command-line interface for all things Cloudflare Workers",
 	"keywords": [
 		"wrangler",

package/src/__tests__/api-dev.test.ts

@@ -8,7 +8,7 @@ jest.unmock("undici");
 describe("unstable_dev", () => {
 	it("should return Hello World", async () => {
 		const worker = await unstable_dev(
-			"src/__tests__/helpers/hello-world-worker.js",
+			"src/__tests__/helpers/worker-scripts/hello-world-worker.js",
 			{},
 			{ disableExperimentalWarning: true }
 		);
@@ -24,7 +24,7 @@ describe("unstable_dev", () => {
 describe("unstable dev fetch input protocol", () => {
 	it("should use http localProtocol", async () => {
 		const worker = await unstable_dev(
-			"src/__tests__/helpers/hello-world-worker.js",
+			"src/__tests__/helpers/worker-scripts/hello-world-worker.js",
 			{ localProtocol: "http" },
 			{ disableExperimentalWarning: true }
 		);
@@ -38,7 +38,7 @@ describe("unstable dev fetch input protocol", () => {
 
 	it("should use undefined localProtocol", async () => {
 		const worker = await unstable_dev(
-			"src/__tests__/helpers/hello-world-worker.js",
+			"src/__tests__/helpers/worker-scripts/hello-world-worker.js",
 			{ localProtocol: undefined },
 			{ disableExperimentalWarning: true }
 		);

package/src/__tests__/api-devregistry.test.js

@@ -0,0 +1,56 @@
+import { unstable_dev } from "../api";
+import { fetch } from "undici";
+
+jest.unmock("undici");
+
+/**
+ * a huge caveat to how testing multi-worker scripts works:
+ * you can't shutdown the first worker you spun up, or it'll kill the devRegistry
+ */
+describe("multi-worker testing", () => {
+	let childWorker;
+	let parentWorker;
+
+	beforeAll(async () => {
+		childWorker = await unstable_dev(
+			"src/__tests__/helpers/worker-scripts/hello-world-worker.js",
+			{ config: "src/__tests__/helpers/worker-scripts/child-wrangler.toml" },
+			{ disableExperimentalWarning: true }
+		);
+		parentWorker = await unstable_dev(
+			"src/__tests__/helpers/worker-scripts/parent-worker.js",
+			{ config: "src/__tests__/helpers/worker-scripts/parent-wrangler.toml" },
+			{ disableExperimentalWarning: true }
+		);
+	});
+
+	afterAll(async () => {
+		await childWorker.stop();
+		await parentWorker.stop();
+	});
+
+	it("parentWorker and childWorker should be added devRegistry", async () => {
+		const resp = await fetch("http://localhost:6284/workers");
+		if (resp) {
+			const parsedResp = await resp.json();
+			expect(parsedResp.parent).toBeTruthy();
+			expect(parsedResp.child).toBeTruthy();
+		}
+	});
+
+	it("childWorker should return Hello World itself", async () => {
+		const resp = await childWorker.fetch();
+		if (resp) {
+			const text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Hello World!"`);
+		}
+	});
+
+	it("parentWorker should return Hello World by invoking the child worker", async () => {
+		const resp = await parentWorker.fetch();
+		if (resp) {
+			const parsedResp = await resp.text();
+			expect(parsedResp).toEqual("Parent worker sees: Hello World!");
+		}
+	});
+});

package/src/__tests__/configuration.test.ts

@@ -73,6 +73,7 @@ describe("normalizeAndValidateConfig()", () => {
 			minify: undefined,
 			node_compat: undefined,
 			first_party_worker: undefined,
+			keep_vars: undefined,
 		});
 		expect(diagnostics.hasErrors()).toBe(false);
 		expect(diagnostics.hasWarnings()).toBe(false);
@@ -106,6 +107,7 @@ describe("normalizeAndValidateConfig()", () => {
 			const expectedConfig = {
 				legacy_env: "FOO",
 				send_metrics: "BAD",
+				keep_vars: "NEVER",
 				dev: {
 					ip: 222,
 					port: "FOO",
@@ -128,6 +130,7 @@ describe("normalizeAndValidateConfig()", () => {
 			"Processing wrangler configuration:
 			  - Expected \\"legacy_env\\" to be of type boolean but got \\"FOO\\".
 			  - Expected \\"send_metrics\\" to be of type boolean but got \\"BAD\\".
+			  - Expected \\"keep_vars\\" to be of type boolean but got \\"NEVER\\".
 			  - Expected \\"dev.ip\\" to be of type string but got 222.
 			  - Expected \\"dev.port\\" to be of type number but got \\"FOO\\".
 			  - Expected \\"dev.local_protocol\\" field to be one of [\\"http\\",\\"https\\"] but got \\"wss\\".

package/src/__tests__/dev.test.tsx

@@ -1027,7 +1027,9 @@ describe("wrangler dev", () => {
 			      --node-compat                                Enable node.js compatibility  [boolean]
 			      --persist                                    Enable persistence for local mode, using default path: .wrangler/state  [boolean]
 			      --persist-to                                 Specify directory to use for local persistence (implies --persist)  [string]
-			      --inspect                                    Enable dev tools  [deprecated] [boolean]",
+			      --inspect                                    Enable dev tools  [deprecated] [boolean]
+			      --test-scheduled                             Test scheduled events by visiting /__scheduled in browser  [boolean] [default: false]
+			      --log-level                                  Specify logging level  [choices: \\"debug\\", \\"info\\", \\"log\\", \\"warn\\", \\"error\\", \\"none\\"] [default: \\"log\\"]",
 			  "warn": "",
 			}
 		`);
@@ -1211,6 +1213,42 @@ describe("wrangler dev", () => {
 		});
 	});
 
+	describe("--log-level", () => {
+		it("should not output warnings with log-level 'none'", async () => {
+			fs.writeFileSync("index.js", `export default {};`);
+			await runWrangler("dev index.js --inspect --log-level none");
+			expect(std).toMatchInlineSnapshot(`
+			Object {
+			  "debug": "",
+			  "err": "",
+			  "out": "",
+			  "warn": "",
+			}
+		`);
+		});
+
+		it("should output warnings with log-level 'warn'", async () => {
+			fs.writeFileSync("index.js", `export default {};`);
+			await runWrangler("dev index.js --inspect --log-level warn");
+			expect(std).toMatchInlineSnapshot(`
+			Object {
+			  "debug": "",
+			  "err": "",
+			  "out": "",
+			  "warn": "▲ [WARNING] Passing --inspect is unnecessary, now you can always connect to devtools.
+
+			",
+			}
+		`);
+		});
+
+		it("should not output Errors with log-level error", async () => {
+			fs.writeFileSync("index.js", `export default {};`);
+			await runWrangler("dev index.js --inspect --log-level debug");
+			expect(std.debug.length > 1).toBe(true);
+		});
+	});
+
 	describe("service bindings", () => {
 		it("should warn when using service bindings", async () => {
 			writeWranglerToml({

package/src/__tests__/helpers/worker-scripts/child-wrangler.toml

@@ -0,0 +1 @@
+name = 'child'

package/src/__tests__/helpers/worker-scripts/hello-world-wrangler.toml

@@ -0,0 +1 @@
+name = 'hello-world'

package/src/__tests__/helpers/worker-scripts/parent-worker.js

@@ -0,0 +1,8 @@
+export default {
+	async fetch(req, env) {
+		const resp = await env.CHILD.fetch(req);
+		const text = await resp.text();
+		console.log("text: ", text);
+		return new Response(`Parent worker sees: ${text}`);
+	},
+};

package/src/__tests__/helpers/worker-scripts/parent-wrangler.toml

@@ -0,0 +1,5 @@
+name = 'parent'
+
+[[services]]
+binding = "CHILD"
+service = 'child'

package/src/__tests__/init.test.ts

@@ -2270,6 +2270,12 @@ describe("init", () => {
 			expectedAccountId = "",
 			expectedScriptName = "",
 			expectedEnvironment = "",
+			expectedCompatDate,
+		}: {
+			expectedAccountId: string;
+			expectedScriptName: string;
+			expectedEnvironment: string;
+			expectedCompatDate: string | undefined;
 		}) {
 			setMockResponse(
 				`/accounts/:accountId/workers/services/:scriptName`,
@@ -2278,6 +2284,9 @@ describe("init", () => {
 					expect(accountId).toEqual(expectedAccountId);
 					expect(scriptName).toEqual(expectedScriptName);
 
+					if (expectedCompatDate === undefined)
+						(mockServiceMetadata.default_environment.script
+							.compatibility_date as unknown) = expectedCompatDate;
 					return mockServiceMetadata;
 				}
 			);
@@ -2340,6 +2349,7 @@ describe("init", () => {
 				expectedAccountId: "LCARS",
 				expectedScriptName: "memory-crystal",
 				expectedEnvironment: "test",
+				expectedCompatDate: "1987-9-27",
 			});
 			setMockFetchDashScript({
 				accountId: "LCARS",
@@ -2394,6 +2404,7 @@ describe("init", () => {
 				expectedAccountId: "LCARS",
 				expectedScriptName: "isolinear-optical-chip",
 				expectedEnvironment: "test",
+				expectedCompatDate: "1987-9-27",
 			});
 			setMockFetchDashScript({
 				accountId: "LCARS",
@@ -2447,6 +2458,7 @@ describe("init", () => {
 				expectedAccountId: "LCARS",
 				expectedScriptName: "isolinear-optical-chip",
 				expectedEnvironment: "test",
+				expectedCompatDate: "1987-9-27",
 			});
 			setMockFetchDashScript({
 				accountId: "LCARS",
@@ -2494,6 +2506,66 @@ describe("init", () => {
 				},
 			});
 		});
+
+		it("should use fallback compatibility date if none is upstream", async () => {
+			const mockDate = "1988-08-07";
+			jest
+				.spyOn(Date.prototype, "toISOString")
+				.mockImplementation(() => `${mockDate}T00:00:00.000Z`);
+
+			mockSupportingDashRequests({
+				expectedAccountId: "LCARS",
+				expectedScriptName: "isolinear-optical-chip",
+				expectedEnvironment: "test",
+				expectedCompatDate: undefined,
+			});
+			setMockFetchDashScript({
+				accountId: "LCARS",
+				fromDashScriptName: "isolinear-optical-chip",
+				environment: mockServiceMetadata.default_environment.environment,
+				mockResponse: mockDashboardScript,
+			});
+			mockConfirm(
+				{
+					text: "Would you like to use git to manage this Worker?",
+					result: false,
+				},
+				{
+					text: "Would you like to use TypeScript?",
+					result: true,
+				},
+				{
+					text: "No package.json found. Would you like to create one?",
+					result: true,
+				},
+				{
+					text: "Would you like to install the type definitions for Workers into your package.json?",
+					result: true,
+				}
+			);
+
+			await runWrangler("init  --from-dash isolinear-optical-chip");
+
+			mockConfigExpected.compatibility_date = "1988-08-07";
+			checkFiles({
+				items: {
+					"isolinear-optical-chip/src/index.ts": {
+						contents: mockDashboardScript,
+					},
+					"isolinear-optical-chip/package.json": {
+						contents: expect.objectContaining({
+							name: "isolinear-optical-chip",
+						}),
+					},
+					"isolinear-optical-chip/tsconfig.json": true,
+					"isolinear-optical-chip/wrangler.toml": wranglerToml({
+						...mockConfigExpected,
+						name: "isolinear-optical-chip",
+					}),
+				},
+			});
+		});
+
 		it("should throw an error to retry if a request fails", async () => {
 			setMockResponse(
 				`/accounts/:accountId/workers/services/:scriptName`,

package/src/__tests__/middleware.scheduled.test.ts

@@ -0,0 +1,135 @@
+import * as fs from "node:fs";
+import { unstable_dev } from "../api";
+import { runInTempDir } from "./helpers/run-in-tmp";
+
+jest.unmock("undici");
+
+describe("run scheduled events with middleware", () => {
+	describe("module workers", () => {
+		runInTempDir();
+
+		beforeEach(() => {
+			const scriptContent = `
+			export default {
+				fetch(request, env, ctx) {
+					const url = new URL(request.url);
+					if (url.pathname === "/__scheduled") {
+						return new Response("Fetch triggered at /__scheduled");
+					}
+					return new Response("Hello world!");
+				},
+				scheduled(controller, env, ctx) {
+					console.log("Doing something scheduled in modules...");
+				},
+			};
+			`;
+			fs.writeFileSync("index.js", scriptContent);
+		});
+
+		it("should not intercept when middleware is not enabled", async () => {
+			const worker = await unstable_dev(
+				"index.js",
+				{},
+				{ disableExperimentalWarning: true }
+			);
+
+			const resp = await worker.fetch("/__scheduled");
+			let text;
+			if (resp) text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Fetch triggered at /__scheduled"`);
+			await worker.stop();
+		});
+
+		it("should intercept when middleware is enabled", async () => {
+			const worker = await unstable_dev(
+				"index.js",
+				{ testScheduled: true },
+				{ disableExperimentalWarning: true }
+			);
+
+			const resp = await worker.fetch("/__scheduled");
+			let text;
+			if (resp) text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Ran scheduled event"`);
+			await worker.stop();
+		});
+
+		it("should not trigger scheduled event on wrong route", async () => {
+			const worker = await unstable_dev(
+				"index.js",
+				{ testScheduled: true },
+				{ disableExperimentalWarning: true }
+			);
+
+			const resp = await worker.fetch("/test");
+			let text;
+			if (resp) text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Hello world!"`);
+			await worker.stop();
+		});
+	});
+
+	describe("service workers", () => {
+		runInTempDir();
+
+		beforeEach(() => {
+			const scriptContent = `
+			addEventListener("scheduled", (event) => {
+				console.log("Doing something scheduled in service worker...");
+			});
+
+			addEventListener("fetch", (event) => {
+				const url = new URL(event.request.url);
+				if (url.pathname === "/__scheduled") {
+					event.respondWith(new Response("Fetch triggered at /__scheduled"));
+				} else {
+					event.respondWith(new Response("Hello world!"));
+				}
+			});
+			`;
+			fs.writeFileSync("index.js", scriptContent);
+		});
+
+		it("should not intercept when middleware is not enabled", async () => {
+			const worker = await unstable_dev(
+				"index.js",
+				{},
+				{ disableExperimentalWarning: true }
+			);
+
+			const resp = await worker.fetch("/__scheduled");
+			let text;
+			if (resp) text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Fetch triggered at /__scheduled"`);
+			await worker.stop();
+		});
+
+		it("should intercept when middleware is enabled", async () => {
+			const worker = await unstable_dev(
+				"index.js",
+				{ testScheduled: true },
+				{ disableExperimentalWarning: true }
+			);
+
+			const resp = await worker.fetch("/__scheduled");
+			let text;
+			if (resp) text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Ran scheduled event"`);
+			await worker.stop();
+		});
+
+		it("should not trigger scheduled event on wrong route", async () => {
+			const worker = await unstable_dev(
+				"index.js",
+				{ testScheduled: true },
+				{ disableExperimentalWarning: true }
+			);
+
+			const resp = await worker.fetch("/test");
+			let text;
+			if (resp) text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Hello world!"`);
+			await worker.stop();
+		});
+	});
+});