wrangler 2.1.2 → 2.1.4

package/package.json

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

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

@@ -1,4 +1,7 @@
+import * as fs from "node:fs";
+import { Request } from "undici";
 import { unstable_dev } from "../api";
+import { runInTempDir } from "./helpers/run-in-tmp";
 
 jest.unmock("undici");
 
@@ -17,3 +20,170 @@ describe("unstable_dev", () => {
 		await worker.stop();
 	});
 });
+
+describe("unstable dev fetch input protocol", () => {
+	it("should use http localProtocol", async () => {
+		const worker = await unstable_dev(
+			"src/__tests__/helpers/hello-world-worker.js",
+			{ localProtocol: "http" },
+			{ disableExperimentalWarning: true }
+		);
+		const res = await worker.fetch();
+		if (res) {
+			const text = await res.text();
+			expect(text).toMatchInlineSnapshot(`"Hello World!"`);
+		}
+		await worker.stop();
+	});
+
+	it("should use undefined localProtocol", async () => {
+		const worker = await unstable_dev(
+			"src/__tests__/helpers/hello-world-worker.js",
+			{ localProtocol: undefined },
+			{ disableExperimentalWarning: true }
+		);
+		const res = await worker.fetch();
+		if (res) {
+			const text = await res.text();
+			expect(text).toMatchInlineSnapshot(`"Hello World!"`);
+		}
+		await worker.stop();
+	});
+});
+
+describe("unstable dev fetch input parsing", () => {
+	runInTempDir();
+
+	it("should pass in a request object unchanged", async () => {
+		const scriptContent = `
+	export default {
+		fetch(request, env, ctx) {
+			const url = new URL(request.url);
+			if (url.pathname === "/test") {
+				if (request.method === "POST") {
+					return new Response("requestPOST");
+				}
+				return new Response("requestGET");
+			}
+			return new Response('Hello world');
+		}
+	};
+	`;
+		fs.writeFileSync("index.js", scriptContent);
+		const port = 21213;
+		const worker = await unstable_dev(
+			"index.js",
+			{ port },
+			{ disableExperimentalWarning: true }
+		);
+		const req = new Request("http://0.0.0.0:21213/test", {
+			method: "POST",
+		});
+		const resp = await worker.fetch(req);
+		let text;
+		if (resp) text = await resp.text();
+		expect(text).toMatchInlineSnapshot(`"requestPOST"`);
+		await worker.stop();
+	});
+
+	it("should strip back to pathname for URL objects", async () => {
+		const scriptContent = `
+	export default {
+		fetch(request, env, ctx) {
+			const url = new URL(request.url);
+			if (url.pathname === "/test") {
+				return new Response("request");
+			}
+			return new Response('Hello world');
+		}
+	};
+	`;
+		fs.writeFileSync("index.js", scriptContent);
+		const worker = await unstable_dev(
+			"index.js",
+			{},
+			{ disableExperimentalWarning: true }
+		);
+		const url = new URL("http://localhost:80/test");
+		const resp = await worker.fetch(url);
+		let text;
+		if (resp) text = await resp.text();
+		expect(text).toMatchInlineSnapshot(`"request"`);
+		await worker.stop();
+	});
+
+	it("should allow full url passed in string, and stripped back to pathname", async () => {
+		const scriptContent = `
+	export default {
+		fetch(request, env, ctx) {
+			const url = new URL(request.url);
+			if (url.pathname === "/test") {
+				return new Response("request");
+			}
+			return new Response('Hello world');
+		}
+	};
+	`;
+		fs.writeFileSync("index.js", scriptContent);
+		const worker = await unstable_dev(
+			"index.js",
+			{},
+			{ disableExperimentalWarning: true }
+		);
+		const resp = await worker.fetch("http://example.com/test");
+		let text;
+		if (resp) text = await resp.text();
+		expect(text).toMatchInlineSnapshot(`"request"`);
+		await worker.stop();
+	});
+
+	it("should allow pathname to be passed in", async () => {
+		const scriptContent = `
+	export default {
+		fetch(request, env, ctx) {
+			const url = new URL(request.url);
+			if (url.pathname === "/test") {
+				return new Response("request");
+			}
+			return new Response('Hello world');
+		}
+	};
+	`;
+		fs.writeFileSync("index.js", scriptContent);
+		const worker = await unstable_dev(
+			"index.js",
+			{},
+			{ disableExperimentalWarning: true }
+		);
+		const resp = await worker.fetch("/test");
+		let text;
+		if (resp) text = await resp.text();
+		expect(text).toMatchInlineSnapshot(`"request"`);
+		await worker.stop();
+	});
+
+	it("should allow no input be passed in", async () => {
+		const scriptContent = `
+	export default {
+		fetch(request, env, ctx) {
+			const url = new URL(request.url);
+			if (url.pathname === "/test") {
+				return new Response("request");
+			}
+			return new Response('Hello world');
+		}
+	};
+	`;
+		fs.writeFileSync("index.js", scriptContent);
+		const worker = await unstable_dev(
+			"index.js",
+			{},
+			{ disableExperimentalWarning: true }
+		);
+		const resp = await worker.fetch("");
+		let text;
+		if (resp) text = await resp.text();
+		expect(text).toMatchInlineSnapshot(`"Hello world"`);
+		await worker.stop();
+	});
+});

package/src/__tests__/api.test.ts

@@ -0,0 +1,80 @@
+import { Request } from "undici";
+import { parseRequestInput } from "../api/dev";
+
+describe("parseRequestInput for fetch on unstable dev", () => {
+	it("should allow no input to be passed in", () => {
+		const [input, _] = parseRequestInput("0.0.0.0", 8080);
+
+		expect(input).toMatchInlineSnapshot(`"http://0.0.0.0:8080"`);
+	});
+
+	it("should allow string of pathname to be passed in", () => {
+		const [input, _] = parseRequestInput("0.0.0.0", 8080, "/test");
+
+		expect(input).toMatchInlineSnapshot(`"http://0.0.0.0:8080/test"`);
+	});
+
+	it("should allow full url to be passed in as string and stripped", () => {
+		const [input, _] = parseRequestInput(
+			"0.0.0.0",
+			8080,
+			"http://cloudflare.com/test"
+		);
+
+		expect(input).toMatchInlineSnapshot(`"http://0.0.0.0:8080/test"`);
+	});
+
+	it("should allow URL object without pathname to be passed in and stripped", () => {
+		const [input, _] = parseRequestInput(
+			"0.0.0.0",
+			8080,
+			new URL("http://cloudflare.com")
+		);
+
+		expect(input).toMatchInlineSnapshot(`"http://0.0.0.0:8080/"`);
+	});
+
+	it("should allow URL object with pathname to be passed in and stripped", () => {
+		const [input, _] = parseRequestInput(
+			"0.0.0.0",
+			8080,
+			new URL("http://cloudflare.com/test")
+		);
+
+		expect(input).toMatchInlineSnapshot(`"http://0.0.0.0:8080/test"`);
+	});
+
+	it("should allow request object to be passed in", () => {
+		const [input, init] = parseRequestInput(
+			"0.0.0.0",
+			8080,
+			new Request("http://cloudflare.com/test", { method: "POST" })
+		);
+
+		expect(init).toBeUndefined();
+		expect(input).toBeInstanceOf(Request);
+		// We don't expect the request to be modified
+		expect((input as Request).url).toMatchInlineSnapshot(
+			`"http://cloudflare.com/test"`
+		);
+		expect((input as Request).method).toMatchInlineSnapshot(`"POST"`);
+	});
+
+	it("should parse to give https url with localProtocol = https", () => {
+		const [input, _] = parseRequestInput("0.0.0.0", 8080, "/test", {}, "https");
+
+		expect(input).toMatchInlineSnapshot(`"https://0.0.0.0:8080/test"`);
+	});
+
+	it("should parse to give http url with localProtocol = http", () => {
+		const [input, _] = parseRequestInput("0.0.0.0", 8080, "/test", {}, "http");
+
+		expect(input).toMatchInlineSnapshot(`"http://0.0.0.0:8080/test"`);
+	});
+
+	it("should parse to give http url with localProtocol not set", () => {
+		const [input, _] = parseRequestInput("0.0.0.0", 8080, "/test", {});
+
+		expect(input).toMatchInlineSnapshot(`"http://0.0.0.0:8080/test"`);
+	});
+});

package/src/__tests__/dev.test.tsx

@@ -1025,7 +1025,8 @@ describe("wrangler dev", () => {
 			  -l, --local                                      Run on my machine  [boolean] [default: false]
 			      --minify                                     Minify the script  [boolean]
 			      --node-compat                                Enable node.js compatibility  [boolean]
-			      --experimental-enable-local-persistence      Enable persistence for this session (only for local mode)  [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]",
 			  "warn": "",
 			}

package/src/__tests__/dialogs.test.tsx

@@ -0,0 +1,40 @@
+jest.unmock("../dialogs");
+import { fromDashMessagePrompt } from "../dialogs";
+import { CI } from "../is-ci";
+
+describe("fromDashMessagePrompt", () => {
+	it("should return undefined in CI when last deployed from api", async () => {
+		//in CI
+		jest.spyOn(CI, "isCI").mockReturnValue(true);
+		const result = await fromDashMessagePrompt("api");
+		expect(result).toBe(undefined);
+	});
+
+	it("should return undefined in CI when last deployed from wrangler", async () => {
+		//in CI
+		jest.spyOn(CI, "isCI").mockReturnValue(true);
+		const result = await fromDashMessagePrompt("wrangler");
+		expect(result).toBe(undefined);
+	});
+
+	it("should return true in CI when last deployed from dash", async () => {
+		//in CI
+		jest.spyOn(CI, "isCI").mockReturnValue(true);
+		const result = await fromDashMessagePrompt("dash");
+		expect(result).toBe(true);
+	});
+
+	it("should return undefined when last deployed from api", async () => {
+		//not in CI
+		jest.spyOn(CI, "isCI").mockReturnValue(false);
+		const result = await fromDashMessagePrompt("api");
+		expect(result).toBe(undefined);
+	});
+
+	it("should return undefined when last deployed from wrangler", async () => {
+		//not in CI
+		jest.spyOn(CI, "isCI").mockReturnValue(false);
+		const result = await fromDashMessagePrompt("wrangler");
+		expect(result).toBe(undefined);
+	});
+});

package/src/__tests__/init.test.ts

@@ -982,7 +982,8 @@ describe("init", () => {
 				{
 					text: "Would you like to use TypeScript?",
 					result: false,
-				}
+				},
+				{ text: "Would you like us to write your first test?", result: false }
 			);
 			mockSelect({
 				text: "Would you like to create a Worker at src/index.js?",
@@ -1562,7 +1563,8 @@ describe("init", () => {
 				{
 					text: "Would you like to use TypeScript?",
 					result: false,
-				}
+				},
+				{ text: "Would you like us to write your first test?", result: false }
 			);
 			mockSelect({
 				text: "Would you like to create a Worker at src/index.js?",
@@ -1596,6 +1598,127 @@ describe("init", () => {
 			        To publish your Worker to the Internet, run \`npm run deploy\`"
 		      `);
 		});
+		it("should add a jest test for a non-ts project with .js extension", async () => {
+			mockConfirm(
+				{
+					text: "Would you like to use git to manage this Worker?",
+					result: false,
+				},
+				{
+					text: "No package.json found. Would you like to create one?",
+					result: true,
+				},
+				{
+					text: "Would you like to install wrangler into package.json?",
+					result: false,
+				},
+				{
+					text: "Would you like to use TypeScript?",
+					result: false,
+				},
+				{ text: "Would you like us to write your first test?", result: true }
+			);
+			mockSelect(
+				{
+					text: "Would you like to create a Worker at src/index.js?",
+					result: "fetch",
+				},
+				{ text: "Which test runner would you like to use?", result: "jest" }
+			);
+
+			await runWrangler("init");
+
+			checkFiles({
+				items: {
+					"src/index.js": true,
+					"src/index.test.js": true,
+					"src/index.ts": false,
+					"package.json": {
+						contents: expect.objectContaining({
+							name: expect.stringContaining("wrangler-tests"),
+							version: "0.0.0",
+							scripts: {
+								start: "wrangler dev",
+								deploy: "wrangler publish",
+								test: "jest",
+							},
+						}),
+					},
+				},
+			});
+			expect(std.out).toMatchInlineSnapshot(`
+			"✨ Created wrangler.toml
+			✨ Created package.json
+			✨ Created src/index.js
+			✨ Created src/index.test.js
+			✨ Installed jest into devDependencies
+
+			To start developing your Worker, run \`npm start\`
+			To start testing your Worker, run \`npm test\`
+			To publish your Worker to the Internet, run \`npm run deploy\`"
+		`);
+		});
+
+		it("should add a vitest test for a non-ts project with .js extension", async () => {
+			mockConfirm(
+				{
+					text: "Would you like to use git to manage this Worker?",
+					result: false,
+				},
+				{
+					text: "No package.json found. Would you like to create one?",
+					result: true,
+				},
+				{
+					text: "Would you like to install wrangler into package.json?",
+					result: false,
+				},
+				{
+					text: "Would you like to use TypeScript?",
+					result: false,
+				},
+				{ text: "Would you like us to write your first test?", result: true }
+			);
+			mockSelect(
+				{
+					text: "Would you like to create a Worker at src/index.js?",
+					result: "fetch",
+				},
+				{ text: "Which test runner would you like to use?", result: "vitest" }
+			);
+
+			await runWrangler("init");
+
+			checkFiles({
+				items: {
+					"src/index.js": true,
+					"src/index.test.js": true,
+					"src/index.ts": false,
+					"package.json": {
+						contents: expect.objectContaining({
+							name: expect.stringContaining("wrangler-tests"),
+							version: "0.0.0",
+							scripts: {
+								start: "wrangler dev",
+								deploy: "wrangler publish",
+								test: "vitest",
+							},
+						}),
+					},
+				},
+			});
+			expect(std.out).toMatchInlineSnapshot(`
+			"✨ Created wrangler.toml
+			✨ Created package.json
+			✨ Created src/index.js
+			✨ Created src/index.test.js
+			✨ Installed vitest into devDependencies
+
+			To start developing your Worker, run \`npm start\`
+			To start testing your Worker, run \`npm test\`
+			To publish your Worker to the Internet, run \`npm run deploy\`"
+		`);
+		});
 
 		it("should not overwrite package.json scripts for a non-ts project with .js extension", async () => {
 			mockConfirm(
@@ -1610,7 +1733,8 @@ describe("init", () => {
 				{
 					text: "Would you like to use TypeScript?",
 					result: false,
-				}
+				},
+				{ text: "Would you like us to write your first test?", result: false }
 			);
 			mockSelect({
 				text: "Would you like to create a Worker at src/index.js?",

package/src/__tests__/secret.test.ts

@@ -124,7 +124,9 @@ describe("wrangler secret", () => {
 			"🌀 Creating the secrets for the Worker \\"script-name\\"
 			✨ Successfully created secret for key: secret-name-1
 			✨ Successfully created secret for key: secret-name-2
-			✨ Finished processing secrets JSON file"
+
+			Finished processing secrets JSON file:
+			✨ 2 secrets successfully uploaded"
 		`);
 				expect(std.err).toMatchInlineSnapshot(`""`);
 			});
@@ -157,7 +159,10 @@ describe("wrangler secret", () => {
 
 				expect(std.out).toMatchInlineSnapshot(`
 			"🌀 Creating the secrets for the Worker \\"script-name\\"
-			✨ Finished processing secrets JSON file"
+
+			Finished processing secrets JSON file:
+			✨ 0 secrets successfully uploaded
+			🚨 2 secrets failed to upload"
 		`);
 				expect(std.err).toMatchInlineSnapshot(`
 			"X [ERROR] 🚨 Error uploading secret for key: secret-name-1:
@@ -173,6 +178,75 @@ describe("wrangler secret", () => {
 		`);
 			});
 
+			it("should count success and failed secret:bulk", async () => {
+				writeFileSync(
+					"secret.json",
+					JSON.stringify({
+						"secret-name-1": "secret_text",
+						"secret-name-2": "secret_text",
+						"secret-name-3": "secret_text",
+						"secret-name-4": "secret_text",
+						"secret-name-5": "secret_text",
+						"secret-name-6": "secret_text",
+						"secret-name-7": "secret_text",
+					})
+				);
+
+				// User counter to pass different secrets to the request mock
+				let counter = 0;
+				setMockResponse(
+					`/accounts/:accountId/workers/scripts/:scriptName/secrets`,
+					"PUT",
+					([_url, accountId]) => {
+						expect(accountId).toEqual("some-account-id");
+						counter++;
+
+						if (counter % 2 === 0) {
+							return { name: `secret-name-${counter}`, type: "secret_text" };
+						} else {
+							return Promise.reject(
+								new Error(`Failed to create secret ${counter}`)
+							);
+						}
+					}
+				);
+
+				await runWrangler("secret:bulk ./secret.json --name script-name");
+
+				expect(std.out).toMatchInlineSnapshot(`
+			"🌀 Creating the secrets for the Worker \\"script-name\\"
+			✨ Successfully created secret for key: secret-name-2
+			✨ Successfully created secret for key: secret-name-4
+			✨ Successfully created secret for key: secret-name-6
+
+			Finished processing secrets JSON file:
+			✨ 3 secrets successfully uploaded
+			🚨 4 secrets failed to upload"
+		`);
+				expect(std.err).toMatchInlineSnapshot(`
+			"X [ERROR] 🚨 Error uploading secret for key: secret-name-1:
+
+			  										Failed to create secret 1
+
+
+			X [ERROR] 🚨 Error uploading secret for key: secret-name-3:
+
+			  										Failed to create secret 3
+
+
+			X [ERROR] 🚨 Error uploading secret for key: secret-name-5:
+
+			  										Failed to create secret 5
+
+
+			X [ERROR] 🚨 Error uploading secret for key: secret-name-7:
+
+			  										Failed to create secret 7
+
+			"
+		`);
+			});
+
 			it("should create a secret: legacy envs", async () => {
 				mockPrompt({
 					text: "Enter a secret value:",

package/src/api/dev.ts

@@ -1,9 +1,9 @@
-import { fetch } from "undici";
+import { fetch, Request } from "undici";
 import { startApiDev, startDev } from "../dev";
 import { logger } from "../logger";
 
 import type { EnablePagesAssetsServiceBindingOptions } from "../miniflare-cli";
-import type { RequestInit, Response } from "undici";
+import type { RequestInit, Response, RequestInfo } from "undici";
 
 interface DevOptions {
 	config?: string;
@@ -19,7 +19,8 @@ interface DevOptions {
 	nodeCompat?: boolean;
 	compatibilityDate?: string;
 	compatibilityFlags?: string[];
-	experimentalEnableLocalPersistence?: boolean;
+	persist?: boolean;
+	persistTo?: string;
 	liveReload?: boolean;
 	watch?: boolean;
 	vars?: {
@@ -56,9 +57,12 @@ interface DevApiOptions {
 	disableExperimentalWarning?: boolean;
 }
 
-interface UnstableDev {
+export interface UnstableDevWorker {
 	stop: () => Promise<void>;
-	fetch: (init?: RequestInit) => Promise<Response | undefined>;
+	fetch: (
+		input?: RequestInfo,
+		init?: RequestInit
+	) => Promise<Response | undefined>;
 	waitUntilExit: () => Promise<void>;
 }
 /**
@@ -85,7 +89,7 @@ export async function unstable_dev(
 	//due to Pages adoption of unstable_dev, we can't *just* disable rebuilds and watching. instead, we'll have two versions of startDev, which will converge.
 	if (testMode) {
 		//in testMode, we can run multiple wranglers in parallel, but rebuilds might not work out of the box
-		return new Promise<UnstableDev>((resolve) => {
+		return new Promise<UnstableDevWorker>((resolve) => {
 			//lmao
 			return new Promise<Awaited<ReturnType<typeof startApiDev>>>((ready) => {
 				// once the devServer is ready for requests, we resolve the inner promise
@@ -111,9 +115,16 @@ export async function unstable_dev(
 				// with an object that lets you fetch and stop the dev server
 				resolve({
 					stop: devServer.stop,
-					fetch: async (init?: RequestInit) => {
-						const urlToFetch = `http://${readyAddress}:${readyPort}/`;
-						return await fetch(urlToFetch, init);
+					fetch: async (input?: RequestInfo, init?: RequestInit) => {
+						return await fetch(
+							...parseRequestInput(
+								readyAddress,
+								readyPort,
+								input,
+								init,
+								options?.localProtocol
+							)
+						);
 					},
 					//no-op, does nothing in tests
 					waitUntilExit: async () => {
@@ -125,7 +136,7 @@ export async function unstable_dev(
 	} else {
 		//outside of test mode, rebuilds work fine, but only one instance of wrangler will work at a time
 
-		return new Promise<UnstableDev>((resolve) => {
+		return new Promise<UnstableDevWorker>((resolve) => {
 			//lmao
 			return new Promise<Awaited<ReturnType<typeof startDev>>>((ready) => {
 				const devServer = startDev({
@@ -146,9 +157,16 @@ export async function unstable_dev(
 			}).then((devServer) => {
 				resolve({
 					stop: devServer.stop,
-					fetch: async (init?: RequestInit) => {
-						const urlToFetch = `http://${readyAddress}:${readyPort}/`;
-						return await fetch(urlToFetch, init);
+					fetch: async (input?: RequestInfo, init?: RequestInit) => {
+						return await fetch(
+							...parseRequestInput(
+								readyAddress,
+								readyPort,
+								input,
+								init,
+								options?.localProtocol
+							)
+						);
 					},
 					waitUntilExit: devServer.devReactElement.waitUntilExit,
 				});
@@ -156,3 +174,31 @@ export async function unstable_dev(
 		});
 	}
 }
+
+export function parseRequestInput(
+	readyAddress: string,
+	readyPort: number,
+	input?: RequestInfo,
+	init?: RequestInit,
+	protocol: "http" | "https" = "http"
+): [RequestInfo, RequestInit | undefined] {
+	if (input instanceof Request) {
+		return [input, undefined];
+	} else if (input instanceof URL) {
+		input = `${protocol}://${readyAddress}:${readyPort}${input.pathname}`;
+	} else if (typeof input === "string") {
+		try {
+			// Want to strip the URL to only get the pathname, but the user could pass in only the pathname
+			// Will error if we try and pass "/something" into new URL("/something")
+			input = `${protocol}://${readyAddress}:${readyPort}${
+				new URL(input).pathname
+			}`;
+		} catch {
+			input = `${protocol}://${readyAddress}:${readyPort}${input}`;
+		}
+	} else {
+		input = `${protocol}://${readyAddress}:${readyPort}`;
+	}
+
+	return [input, init];
+}