wrangler 2.7.1 → 2.8.0

package/package.json

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

package/src/__tests__/helpers/mock-dialogs.ts

@@ -1,4 +1,5 @@
 import prompts from "prompts";
+
 /**
  * The expected values for a confirmation request.
  */
@@ -30,6 +31,7 @@ export function mockConfirm(...expectations: ConfirmExpectation[]) {
 				if (expectation.options) {
 					expect(initial).toStrictEqual(expectation.options?.defaultValue);
 				}
+
 				return Promise.resolve({ value: expectation.result });
 			}
 		);

package/src/__tests__/helpers/mock-get-zone-from-host.ts

@@ -1,8 +1,11 @@
-import { setMockResponse } from "./mock-cfetch";
+import { rest } from "msw";
+import { msw, createFetchResult } from "./msw";
 
 export function mockGetZoneFromHostRequest(host: string, zone?: string) {
-	setMockResponse("/zones", (_uri, _init, queryParams) => {
-		expect(queryParams.get("name")).toEqual(host);
-		return zone ? [{ id: zone }] : [];
-	});
+	msw.use(
+		rest.get("*/zones", (req, res, ctx) => {
+			expect(req.url.searchParams.get("name")).toEqual(host);
+			return res(ctx.json(createFetchResult(zone ? [{ id: zone }] : [])));
+		})
+	);
 }

package/src/__tests__/helpers/mock-known-routes.ts

@@ -1,7 +1,12 @@
-import { setMockResponse } from "./mock-cfetch";
+import { rest } from "msw";
+import { createFetchResult, msw } from "./msw";
 
 export function mockCollectKnownRoutesRequest(
 	routes: { pattern: string; script: string }[]
 ) {
-	setMockResponse(`/zones/:zoneId/workers/routes`, "GET", () => routes);
+	msw.use(
+		rest.get(`*/zones/:zoneId/workers/routes`, (_, res, ctx) =>
+			res.once(ctx.json(createFetchResult(routes)))
+		)
+	);
 }

package/src/__tests__/helpers/mock-kv.ts

@@ -1,4 +1,5 @@
-import { createFetchResult, setMockRawResponse } from "./mock-cfetch";
+import { rest } from "msw";
+import { createFetchResult, msw } from "./msw";
 import type { NamespaceKeyInfo } from "../../kv/helpers";
 
 export function mockKeyListRequest(
@@ -9,25 +10,37 @@ export function mockKeyListRequest(
 ) {
 	const requests = { count: 0 };
 	// See https://api.cloudflare.com/#workers-kv-namespace-list-a-namespace-s-keys
+	msw.use(
+		rest.get(
+			"*/accounts/:accountId/storage/kv/namespaces/:namespaceId/keys",
+			(req, res, ctx) => {
+				requests.count++;
+				expect(req.params.accountId).toEqual("some-account-id");
+				expect(req.params.namespaceId).toEqual(expectedNamespaceId);
+				let response: undefined | NamespaceKeyInfo[];
+				if (expectedKeys.length <= keysPerRequest) {
+					response = expectedKeys;
+				}
 
-	setMockRawResponse(
-		"/accounts/:accountId/storage/kv/namespaces/:namespaceId/keys",
-		"GET",
-		([_url, accountId, namespaceId], _init, query) => {
-			requests.count++;
-			expect(accountId).toEqual("some-account-id");
-			expect(namespaceId).toEqual(expectedNamespaceId);
-			if (expectedKeys.length <= keysPerRequest) {
-				return createFetchResult(expectedKeys);
-			} else {
-				const start = parseInt(query.get("cursor") ?? "0") || 0;
+				const start = parseInt(req.url.searchParams.get("cursor") ?? "0") || 0;
 				const end = start + keysPerRequest;
 				const cursor = end < expectedKeys.length ? end : blankCursorValue;
-				return createFetchResult(expectedKeys.slice(start, end), true, [], [], {
-					cursor,
-				});
+
+				return res(
+					ctx.json(
+						createFetchResult(
+							response ? response : expectedKeys.slice(start, end),
+							true,
+							[],
+							[],
+							{
+								cursor,
+							}
+						)
+					)
+				);
 			}
-		}
+		)
 	);
 	return requests;
 }

package/src/__tests__/helpers/mock-oauth-flow.ts

@@ -1,30 +1,34 @@
-import fetchMock from "jest-fetch-mock";
+import { rest } from "msw";
 import { Request } from "undici";
 import openInBrowser from "../../open-in-browser";
-import { setMockResponse } from "./mock-cfetch";
 import { mockHttpServer } from "./mock-http-server";
+import { createFetchResult, msw } from "./msw";
 
 export function mockGetMemberships(
 	accounts: { id: string; account: { id: string; name: string } }[]
 ) {
-	setMockResponse("/memberships", "GET", () => {
-		return accounts;
-	});
+	msw.use(
+		rest.get("*/memberships", (_, res, ctx) => {
+			return res.once(ctx.json(createFetchResult(accounts)));
+		})
+	);
+}
+export function mockGetMembershipsFail() {
+	msw.use(
+		rest.get("*/memberships", (_, res, ctx) => {
+			return res.once(ctx.json(createFetchResult([], false)));
+		})
+	);
 }
-
-// the response to send when wrangler wants an oauth grant
-let oauthGrantResponse: GrantResponseOptions | "timeout" = {};
 
 /**
  * Functions to help with mocking various parts of the OAuth Flow
  */
 export const mockOAuthFlow = () => {
+	// the response to send when wrangler wants an oauth grant
+	let oauthGrantResponse: GrantResponseOptions | "timeout" = {};
 	const fetchHttp = mockHttpServer();
 
-	afterEach(() => {
-		fetchMock.resetMocks();
-	});
-
 	/**
 	 * Mock out the callback from a browser to our HttpServer.
 	 *
@@ -61,7 +65,7 @@ export const mockOAuthFlow = () => {
 		});
 	};
 
-	//TODO: this can just handled in `mockOAuthServerCallback`
+	// Handled in `mockOAuthServerCallback`
 	const mockGrantAuthorization = ({
 		respondWith,
 	}: {
@@ -82,25 +86,6 @@ export const mockOAuthFlow = () => {
 		}
 	};
 
-	const mockRevokeAuthorization = ({
-		domain = "dash.cloudflare.com",
-	}: { domain?: string } = {}) => {
-		const outcome = {
-			actual: new Request("https://example.org"),
-			expected: new Request(`https://${domain}/oauth2/revoke`, {
-				method: "POST",
-			}),
-		};
-
-		fetchMock.mockIf(outcome.expected.url, async (req) => {
-			// TODO: update Miniflare typings to match full undici Request
-			outcome.actual = req as unknown as Request;
-			return "";
-		});
-
-		return outcome;
-	};
-
 	const mockGrantAccessToken = ({
 		respondWith,
 		domain = "dash.cloudflare.com",
@@ -109,94 +94,101 @@ export const mockOAuthFlow = () => {
 		domain?: string;
 	}) => {
 		const outcome = {
-			actual: new Request("https://example.org"),
-			expected: new Request(`https://${domain}/oauth2/token`, {
-				method: "POST",
-			}),
+			actual: "https://example.org",
+			expected: `https://${domain}/oauth2/token`,
 		};
-
-		fetchMock.mockOnceIf(outcome.expected.url, async (req) => {
-			// TODO: update Miniflare typings to match full undici Request
-			outcome.actual = req as unknown as Request;
-			return makeTokenResponse(respondWith);
-		});
+		msw.use(
+			rest.post(outcome.expected, async (req, res, ctx) => {
+				// TODO: update Miniflare typings to match full undici Request
+				outcome.actual = req.url.toString();
+				return res.once(ctx.json(makeTokenResponse(respondWith)));
+			})
+		);
 
 		return outcome;
 	};
 
-	const mockExchangeRefreshTokenForAccessToken = ({
-		respondWith,
-		domain = "dash.cloudlfare.com",
+	function mockDomainUsesAccess({
+		usesAccess,
+		domain = "dash.cloudflare.com",
 	}: {
-		respondWith: "refreshSuccess" | "refreshError" | "badResponse";
+		usesAccess: boolean;
 		domain?: string;
-	}) => {
-		fetchMock.mockOnceIf(`https://${domain}/oauth2/token`, async () => {
+	}) {
+		// If the domain relies upon Cloudflare Access, then a request to the domain
+		// will result in a redirect to the `cloudflareaccess.com` domain.
+		msw.use(
+			rest.get(`https://${domain}/`, (_, res, ctx) => {
+				let status = 200;
+				let headers: Record<string, string> = {
+					"Content-Type": "application/json",
+				};
+				if (usesAccess) {
+					status = 302;
+					headers = { location: "cloudflareaccess.com" };
+				}
+				return res.once(ctx.status(status), ctx.set(headers));
+			})
+		);
+	}
+
+	return {
+		mockHttpServer,
+		mockDomainUsesAccess,
+		mockGrantAccessToken,
+		mockOAuthServerCallback,
+		mockExchangeRefreshTokenForAccessToken,
+	};
+};
+
+export function mockExchangeRefreshTokenForAccessToken({
+	respondWith,
+	domain = "dash.cloudflare.com",
+}: {
+	respondWith: "refreshSuccess" | "refreshError" | "badResponse";
+	domain?: string;
+}) {
+	msw.use(
+		rest.post(`https://${domain}/oauth2/token`, async (_, res, ctx) => {
 			switch (respondWith) {
 				case "refreshSuccess":
-					return {
-						status: 200,
-						body: JSON.stringify({
+					return res.once(
+						ctx.status(200),
+						ctx.json({
 							access_token: "access_token_success_mock",
 							expires_in: 1701,
 							refresh_token: "refresh_token_success_mock",
 							scope: "scope_success_mock",
 							token_type: "bearer",
-						}),
-					};
+						})
+					);
 				case "refreshError":
-					return {
-						status: 400,
-						body: JSON.stringify({
+					return res.once(
+						ctx.status(400),
+						ctx.json({
 							error: "invalid_request",
 							error_description: "error_description_mock",
 							error_hint: "error_hint_mock",
 							error_verbose: "error_verbose_mock",
 							status_code: 400,
-						}),
-					};
+						})
+					);
 				case "badResponse":
-					return {
-						status: 400,
-						body: `<html> <body> This shouldn't be sent, but should be handled </body> </html>`,
-					};
+					return res.once(
+						ctx.status(400),
+						ctx.text(
+							`<html> <body> This shouldn't be sent, but should be handled </body> </html>`
+						)
+					);
 
 				default:
-					return "Not a respondWith option for `mockExchangeRefreshTokenForAccessToken`";
-			}
-		});
-	};
-
-	const mockDomainUsesAccess = ({
-		usesAccess,
-		domain = "dash.cloudflare.com",
-	}: {
-		usesAccess: boolean;
-		domain?: string;
-	}) => {
-		// If the domain relies upon Cloudflare Access, then a request to the domain
-		// will result in a redirect to the `cloudflareaccess.com` domain.
-		fetchMock.mockOnceIf(`https://${domain}/`, async () => {
-			if (usesAccess) {
-				return {
-					status: 302,
-					headers: { location: "cloudflareaccess.com" },
-				};
-			} else {
-				return { status: 200 };
+					throw new Error(
+						"Not a respondWith option for `mockExchangeRefreshTokenForAccessToken`"
+					);
 			}
-		});
-	};
-
-	return {
-		mockDomainUsesAccess,
-		mockGrantAccessToken,
-		mockGrantAuthorization,
-		mockOAuthServerCallback,
-		mockRevokeAuthorization,
-		mockExchangeRefreshTokenForAccessToken,
-	};
-};
+		})
+	);
+}
 
 type GrantResponseOptions = {
 	code?: string;
@@ -249,7 +241,7 @@ type MockTokenResponse =
 			error: ErrorType;
 	  };
 
-const makeTokenResponse = (partialResponse: MockTokenResponse): string => {
+const makeTokenResponse = (partialResponse: MockTokenResponse) => {
 	let fullResponse: MockTokenResponse;
 
 	if (partialResponse === "ok") {
@@ -267,5 +259,5 @@ const makeTokenResponse = (partialResponse: MockTokenResponse): string => {
 		fullResponse = partialResponse;
 	}
 
-	return JSON.stringify(fullResponse);
+	return fullResponse;
 };

package/src/__tests__/helpers/msw/handlers/deployments.ts

@@ -57,3 +57,21 @@ export const mswSuccessDeployments = [
 			)
 	),
 ];
+
+export const mswSuccessLastDeployment = [
+	rest.get(
+		"*/accounts/:accountId/workers/services/:scriptName",
+		(req, res, ctx) => {
+			return res.once(
+				ctx.json({
+					success: true,
+					messages: [],
+					errors: [],
+					result: {
+						default_environment: { script: { last_deployed_from: "wrangler" } },
+					},
+				})
+			);
+		}
+	),
+];

package/src/__tests__/helpers/msw/index.ts

@@ -1,15 +1,43 @@
 import { setupServer } from "msw/node";
 import { default as mswAccessHandlers } from "./handlers/access";
-import { mswSuccessDeployments } from "./handlers/deployments";
+import {
+	mswSuccessDeployments,
+	mswSuccessLastDeployment,
+} from "./handlers/deployments";
 import { mswSuccessNamespacesHandlers } from "./handlers/namespaces";
 import { mswSuccessOauthHandlers } from "./handlers/oauth";
 import { mswSuccessR2handlers } from "./handlers/r2";
 import { default as mswSucessScriptHandlers } from "./handlers/script";
 import { mswSuccessUserHandlers } from "./handlers/user";
 import { default as mswZoneHandlers } from "./handlers/zones";
+
 export const msw = setupServer();
 
+function createFetchResult(
+	result: unknown,
+	success = true,
+	errors: unknown[] = [],
+	messages: unknown[] = [],
+	result_info?: Record<string, unknown>
+) {
+	return result_info
+		? {
+				result,
+				success,
+				errors,
+				messages,
+				result_info,
+		  }
+		: {
+				result,
+				success,
+				errors,
+				messages,
+		  };
+}
+
 export {
+	createFetchResult,
 	mswSuccessUserHandlers,
 	mswSuccessR2handlers,
 	mswSuccessOauthHandlers,
@@ -18,4 +46,5 @@ export {
 	mswZoneHandlers,
 	mswSuccessDeployments,
 	mswAccessHandlers,
+	mswSuccessLastDeployment,
 };

package/src/__tests__/init.test.ts

@@ -4,9 +4,7 @@ import * as TOML from "@iarna/toml";
 import { execa, execaSync } from "execa";
 import { rest } from "msw";
 import { parseConfigFileTextToJson } from "typescript";
-import { FormData } from "undici";
 import { version as wranglerVersion } from "../../package.json";
-import { fetchDashboardScript } from "../cfetch/internal";
 import { getPackageManager } from "../package-manager";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
 import { mockConsoleMethods } from "./helpers/mock-console";
@@ -46,8 +44,6 @@ describe("init", () => {
 
 	afterEach(() => {
 		clearDialogs();
-		msw.resetHandlers();
-		msw.restoreHandlers();
 	});
 
 	const std = mockConsoleMethods();
@@ -2798,6 +2794,7 @@ describe("init", () => {
 					"isolinear-optical-chip/wrangler.toml": wranglerToml({
 						...mockConfigExpected,
 						name: "isolinear-optical-chip",
+						main: "src/index.js",
 					}),
 				},
 			});
@@ -3070,19 +3067,11 @@ export function setMockFetchDashScript(mockResponse: string) {
 	msw.use(
 		rest.get(
 			`*/accounts/:accountId/workers/services/:fromDashScriptName/environments/:environment/content`,
-			(req, res, ctx) => {
-				// This is a fake FormData object, until we can get MSW (beta) that supports FormData
-				const mockForm = new FormData();
-				mockForm.append("name", mockResponse);
-				// Sending it as JSON will result in empty object, but cause the fetchDashboardScript to execute its code
-				return res(ctx.status(200), ctx.json(mockForm));
+			(_, res, ctx) => {
+				return res(ctx.text(mockResponse));
 			}
 		)
 	);
-	// Mock the actual return value that FormData would return
-	(fetchDashboardScript as jest.Mock).mockImplementationOnce(() => {
-		return mockResponse;
-	});
 }
 
 /**

package/src/__tests__/jest.setup.ts

@@ -1,16 +1,4 @@
 import fetchMock from "jest-fetch-mock";
-import {
-	fetchDashboardScript,
-	fetchInternal,
-	fetchKVGetValue,
-	fetchR2Objects,
-	performApiFetch,
-} from "../cfetch/internal";
-import {
-	mockFetchInternal,
-	mockFetchR2Objects,
-	mockPerformApiFetch,
-} from "./helpers/mock-cfetch";
 import { MockWebSocket } from "./helpers/mock-web-socket";
 import { msw } from "./helpers/msw";
 
@@ -89,17 +77,6 @@ afterEach(() => {
 });
 afterAll(() => msw.close());
 
-jest.mock("../cfetch/internal");
-(fetchDashboardScript as jest.Mock).mockImplementation(
-	jest.requireActual("../cfetch/internal")["fetchDashboardScript"]
-);
-(fetchInternal as jest.Mock).mockImplementation(mockFetchInternal);
-(fetchKVGetValue as jest.Mock).mockImplementation(
-	jest.requireActual("../cfetch/internal").fetchKVGetValue
-);
-(fetchR2Objects as jest.Mock).mockImplementation(mockFetchR2Objects);
-(performApiFetch as jest.Mock).mockImplementation(mockPerformApiFetch);
-
 jest.mock("../dev/dev", () => {
 	const { useApp } = jest.requireActual("ink");
 	const { useEffect } = jest.requireActual("react");

package/src/__tests__/pages-deployment-tail.test.ts

@@ -12,6 +12,7 @@ import type {
 	RequestEvent,
 	ScheduledEvent,
 	AlarmEvent,
+	EmailEvent,
 } from "../tail/createTail";
 import type { RequestInit } from "undici";
 import type WebSocket from "ws";
@@ -355,6 +356,20 @@ describe("pages deployment tail", () => {
 			expect(std.out).toMatch(deserializeToJson(serializedMessage));
 		});
 
+		it("logs email messages in json format", async () => {
+			const api = mockTailAPIs();
+			await runWrangler(
+				"pages deployment tail mock-deployment-id --project-name mock-project --format json"
+			);
+
+			const event = generateMockEmailEvent();
+			const message = generateMockEventMessage({ event });
+			const serializedMessage = serialize(message);
+
+			api.ws.send(serializedMessage);
+			expect(std.out).toMatch(deserializeToJson(serializedMessage));
+		});
+
 		it("logs request messages in pretty format", async () => {
 			const api = mockTailAPIs();
 			await runWrangler(
@@ -436,6 +451,33 @@ describe("pages deployment tail", () => {
 			`);
 		});
 
+		it("logs email messages in pretty format", async () => {
+			const api = mockTailAPIs();
+			await runWrangler(
+				"pages deployment tail mock-deployment-id --project-name mock-project --format pretty"
+			);
+
+			const event = generateMockEmailEvent();
+			const message = generateMockEventMessage({ event });
+			const serializedMessage = serialize(message);
+
+			api.ws.send(serializedMessage);
+			expect(
+				std.out
+					.replace(
+						new Date(mockEventTimestamp).toLocaleString(),
+						"[mock event timestamp]"
+					)
+					.replace(
+						mockTailExpiration.toLocaleString(),
+						"[mock expiration date]"
+					)
+			).toMatchInlineSnapshot(`
+					"Connected to deployment mock-deployment-id, waiting for logs...
+					Email from:${mockEmailEventFrom} to:${mockEmailEventTo} size:${mockEmailEventSize} @ [mock event timestamp] - Ok"
+			`);
+		});
+
 		it("should not crash when the tail message has a void event", async () => {
 			const api = mockTailAPIs();
 			await runWrangler(
@@ -608,7 +650,13 @@ function serialize(message: TailEventMessage): WebSocket.RawData {
  * @returns true if `event` is a RequestEvent
  */
 function isRequest(
-	event: ScheduledEvent | RequestEvent | AlarmEvent | undefined | null
+	event:
+		| ScheduledEvent
+		| RequestEvent
+		| AlarmEvent
+		| EmailEvent
+		| undefined
+		| null
 ): event is RequestEvent {
 	return Boolean(event && "request" in event);
 }
@@ -742,6 +790,21 @@ const mockEventTimestamp = 1645454470467;
  */
 const mockEventScheduledTime = new Date(mockEventTimestamp).toISOString();
 
+/**
+ * Default value for email event from
+ */
+const mockEmailEventFrom = "from@example.com";
+
+/**
+ * Default value for email event to
+ */
+const mockEmailEventTo = "to@example.com";
+
+/**
+ * Default value for email event mail size
+ */
+const mockEmailEventSize = 45416;
+
 /**
  * Mock out the API hit during Tail deletion
  *
@@ -882,3 +945,11 @@ function generateMockAlarmEvent(opts?: Partial<AlarmEvent>): AlarmEvent {
 		scheduledTime: opts?.scheduledTime || mockEventScheduledTime,
 	};
 }
+
+function generateMockEmailEvent(opts?: Partial<EmailEvent>): EmailEvent {
+	return {
+		mailFrom: opts?.mailFrom || mockEmailEventFrom,
+		rcptTo: opts?.rcptTo || mockEmailEventTo,
+		rawSize: opts?.rawSize || mockEmailEventSize,
+	};
+}