wrangler 2.0.26 → 2.0.29

package/src/__tests__/paths.test.ts

@@ -0,0 +1,17 @@
+import * as path from "node:path";
+import { getBasePath } from "../paths";
+
+describe("paths", () => {
+	describe("getBasePath()", () => {
+		it("should return the path to the wrangler package", () => {
+			expect(getBasePath()).toMatch(/packages[/\\]wrangler$/);
+		});
+
+		it("should use the __RELATIVE_PACKAGE_PATH__ as defined on the global context to compute the base path", () => {
+			(
+				global as unknown as { __RELATIVE_PACKAGE_PATH__: string }
+			).__RELATIVE_PACKAGE_PATH__ = "/foo/bar";
+			expect(getBasePath()).toEqual(path.resolve("/foo/bar"));
+		});
+	});
+});

package/src/__tests__/publish.test.ts

@@ -13,7 +13,9 @@ import {
 } from "./helpers/mock-cfetch";
 import { mockConsoleMethods, normalizeSlashes } from "./helpers/mock-console";
 import { mockConfirm } from "./helpers/mock-dialogs";
+import { mockGetZoneFromHostRequest } from "./helpers/mock-get-zone-from-host";
 import { useMockIsTTY } from "./helpers/mock-istty";
+import { mockCollectKnownRoutesRequest } from "./helpers/mock-known-routes";
 import { mockKeyListRequest } from "./helpers/mock-kv";
 import { mockGetMemberships, mockOAuthFlow } from "./helpers/mock-oauth-flow";
 import { runInTempDir } from "./helpers/run-in-tmp";
@@ -3615,6 +3617,32 @@ addEventListener('fetch', event => {});`
 			        "
 		      `);
 		});
+
+		it("can be overridden with cli args", async () => {
+			writeWranglerToml({
+				main: "index.js",
+				define: {
+					abc: "123",
+				},
+			});
+			fs.writeFileSync(
+				"index.js",
+				`
+				console.log(abc);
+			`
+			);
+			mockSubDomainRequest();
+			mockUploadWorkerRequest();
+			await runWrangler("publish --dry-run --outdir dist --define abc:789");
+			expect(fs.readFileSync("dist/index.js", "utf-8")).toMatchInlineSnapshot(`
+			        "(() => {
+			          // index.js
+			          console.log(789);
+			        })();
+			        //# sourceMappingURL=index.js.map
+			        "
+		      `);
+		});
 	});
 
 	describe("custom builds", () => {
@@ -5232,6 +5260,29 @@ addEventListener('fetch', event => {});`
 				expect(std.err).toMatchInlineSnapshot(`""`);
 				expect(std.warn).toMatchInlineSnapshot(`""`);
 			});
+
+			it("should read vars passed as cli arguments", async () => {
+				writeWranglerToml();
+				writeWorkerSource();
+				mockSubDomainRequest();
+				mockUploadWorkerRequest();
+				await runWrangler("publish index.js --var TEXT:sometext --var COUNT:1");
+				expect(std).toMatchInlineSnapshot(`
+			Object {
+			  "debug": "",
+			  "err": "",
+			  "out": "Your worker has access to the following bindings:
+			- Vars:
+			  - TEXT: \\"(hidden)\\"
+			  - COUNT: \\"(hidden)\\"
+			Total Upload: 0xx KiB / gzip: 0xx KiB
+			Uploaded test-name (TIMINGS)
+			Published test-name (TIMINGS)
+			  https://test-name.test-sub-domain.workers.dev",
+			  "warn": "",
+			}
+		`);
+			});
 		});
 
 		describe("[r2_buckets]", () => {
@@ -5514,10 +5565,10 @@ addEventListener('fetch', event => {});`
 			});
 		});
 
-		describe("[worker_namespaces]", () => {
-			it("should support bindings to a worker namespace", async () => {
+		describe("[dispatch_namespaces]", () => {
+			it("should support bindings to a dispatch namespace", async () => {
 				writeWranglerToml({
-					worker_namespaces: [
+					dispatch_namespaces: [
 						{
 							binding: "foo",
 							namespace: "Foo",
@@ -5538,7 +5589,7 @@ addEventListener('fetch', event => {});`
 				await runWrangler("publish index.js");
 				expect(std.out).toMatchInlineSnapshot(`
 			          "Your worker has access to the following bindings:
-			          - Worker Namespaces:
+			          - dispatch namespaces:
 			            - foo: Foo
 			          Total Upload: 0xx KiB / gzip: 0xx KiB
 			          Uploaded test-name (TIMINGS)
@@ -5549,7 +5600,7 @@ addEventListener('fetch', event => {});`
 				expect(std.warn).toMatchInlineSnapshot(`
 			"▲ [WARNING] Processing wrangler.toml configuration:
 
-			    - \\"worker_namespaces\\" fields are experimental and may change or break at any time.
+			    - \\"dispatch_namespaces\\" fields are experimental and may change or break at any time.
 
 			"
 		`);
@@ -6487,6 +6538,9 @@ function mockUploadWorkerRequest(
 			} else {
 				expect(metadata.body_part).toEqual("index.js");
 			}
+
+			expect(metadata.keep_bindings).toEqual(["plain_text", "json"]);
+
 			if ("expectedBindings" in options) {
 				expect(metadata.bindings).toEqual(expectedBindings);
 			}
@@ -6622,19 +6676,6 @@ function mockUnauthorizedPublishRoutesRequest({
 	);
 }
 
-function mockCollectKnownRoutesRequest(
-	routes: { pattern: string; script: string }[]
-) {
-	setMockResponse(`/zones/:zoneId/workers/routes`, "GET", () => routes);
-}
-
-function mockGetZoneFromHostRequest(host: string, zone: string) {
-	setMockResponse("/zones", (_uri, _init, queryParams) => {
-		expect(queryParams.get("name")).toEqual(host);
-		return [{ id: zone }];
-	});
-}
-
 function mockPublishRoutesFallbackRequest(route: {
 	pattern: string;
 	script: string;

package/src/__tests__/r2.test.ts

@@ -82,10 +82,11 @@ describe("wrangler", () => {
 				function mockCreateRequest(expectedBucketName: string) {
 					const requests = { count: 0 };
 					setMockResponse(
-						"/accounts/:accountId/r2/buckets/:bucketName",
-						"PUT",
-						([_url, accountId, bucketName]) => {
+						"/accounts/:accountId/r2/buckets",
+						"POST",
+						([_url, accountId], { body }) => {
 							expect(accountId).toEqual("some-account-id");
+							const bucketName = JSON.parse(body as string).name;
 							expect(bucketName).toEqual(expectedBucketName);
 							requests.count += 1;
 						}

package/src/__tests__/tail.test.ts

@@ -3,7 +3,9 @@ import { Headers, Request } from "undici";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
 import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
+import { mockGetZoneFromHostRequest } from "./helpers/mock-get-zone-from-host";
 import { useMockIsTTY } from "./helpers/mock-istty";
+import { mockCollectKnownRoutesRequest } from "./helpers/mock-known-routes";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 import type {
@@ -53,6 +55,38 @@ describe("tail", () => {
 			api.ws.close();
 			expect(api.requests.deletion.count).toStrictEqual(1);
 		});
+		it("should connect to the worker assigned to a given route", async () => {
+			const api = mockWebsocketAPIs();
+			expect(api.requests.creation.count).toStrictEqual(0);
+
+			mockGetZoneFromHostRequest("example.com", "test-zone");
+			mockCollectKnownRoutesRequest([
+				{
+					pattern: "example.com/*",
+					script: "test-worker",
+				},
+			]);
+			await runWrangler("tail example.com/*");
+
+			await expect(api.ws.connected).resolves.toBeTruthy();
+			expect(api.requests.creation.count).toStrictEqual(1);
+			expect(api.requests.deletion.count).toStrictEqual(0);
+
+			api.ws.close();
+			expect(api.requests.deletion.count).toStrictEqual(1);
+		});
+
+		it("should error if a given route is not assigned to the user's zone", async () => {
+			mockGetZoneFromHostRequest("example.com", "test-zone");
+			mockCollectKnownRoutesRequest([]);
+
+			await expect(runWrangler("tail example.com/*")).rejects.toThrow();
+		});
+		it("should error if a given route is not within the user's zone", async () => {
+			mockGetZoneFromHostRequest("example.com");
+
+			await expect(runWrangler("tail example.com/*")).rejects.toThrow();
+		});
 
 		it("creates and then delete tails: legacy envs", async () => {
 			const api = mockWebsocketAPIs("some-env", true);

package/src/__tests__/test-old-node-version.js

@@ -1,4 +1,4 @@
-// this test has to be run with a version of node.js older than 16.7 to pass
+// this test has to be run with a version of node.js older than 16.13 to pass
 
 const { spawn } = require("child_process");
 const path = require("path");
@@ -11,7 +11,7 @@ const wranglerProcess = spawn(
 	{ stdio: "pipe" }
 );
 
-const messageToMatch = "Wrangler requires at least node.js v16.7.0";
+const messageToMatch = "Wrangler requires at least node.js v16.13.0";
 
 wranglerProcess.once("exit", (code) => {
 	try {
@@ -25,7 +25,7 @@ wranglerProcess.once("exit", (code) => {
 	} catch (err) {
 		console.error("Error:", err);
 		throw new Error(
-			"This test has to be run with a version of node.js under 16.7 to pass"
+			"This test has to be run with a version of node.js under 16.13 to pass"
 		);
 	}
 });

package/src/__tests__/user.test.ts

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import fetchMock from "jest-fetch-mock";
 import { getGlobalWranglerConfigPath } from "../global-wrangler-config-path";
+import { CI } from "../is-ci";
 import {
 	loginOrRefreshIfRequired,
 	readAuthConfigFile,
@@ -18,6 +19,7 @@ import type { Config } from "../config";
 import type { UserAuthConfig } from "../user";
 
 describe("User", () => {
+	let isCISpy: jest.SpyInstance;
 	runInTempDir();
 	const std = mockConsoleMethods();
 	const {
@@ -30,6 +32,10 @@ describe("User", () => {
 
 	const { setIsTTY } = useMockIsTTY();
 
+	beforeEach(() => {
+		isCISpy = jest.spyOn(CI, "isCI").mockReturnValue(false);
+	});
+
 	describe("login", () => {
 		it("should login a user when `wrangler login` is run", async () => {
 			mockOAuthServerCallback();
@@ -132,6 +138,11 @@ describe("User", () => {
 		expect(std.err).toContain("");
 	});
 
+	it("should revert to non-interactive mode if in CI", async () => {
+		isCISpy.mockReturnValue(true);
+		await expect(loginOrRefreshIfRequired()).resolves.toEqual(false);
+	});
+
 	it("should revert to non-interactive mode if isTTY throws an error", async () => {
 		setIsTTY({
 			stdin() {

package/src/__tests__/worker-namespace.test.ts

@@ -4,7 +4,7 @@ import { mockConsoleMethods } from "./helpers/mock-console";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 
-describe("worker-namespace", () => {
+describe("dispatch-namespace", () => {
 	runInTempDir();
 	const std = mockConsoleMethods();
 	mockAccountId();
@@ -14,8 +14,8 @@ describe("worker-namespace", () => {
 		unsetAllMocks();
 	});
 
-	it("should should display a list of available subcommands, for worker-namespace with no subcommand", async () => {
-		await runWrangler("worker-namespace");
+	it("should should display a list of available subcommands, for dispatch-namespace with no subcommand", async () => {
+		await runWrangler("dispatch-namespace");
 
 		// wait a tick for the help menu to be printed
 		await new Promise((resolve) => setImmediate(resolve));
@@ -24,16 +24,16 @@ describe("worker-namespace", () => {
 		Object {
 		  "debug": "",
 		  "err": "",
-		  "out": "wrangler worker-namespace
+		  "out": "wrangler dispatch-namespace
 
-		📦 Interact with a worker namespace
+		📦 Interact with a dispatch namespace
 
 		Commands:
-		  wrangler worker-namespace list                          List all Worker namespaces
-		  wrangler worker-namespace get <name>                    Get information about a Worker namespace
-		  wrangler worker-namespace create <name>                 Create a Worker namespace
-		  wrangler worker-namespace delete <name>                 Delete a Worker namespace
-		  wrangler worker-namespace rename <old-name> <new-name>  Rename a Worker namespace
+		  wrangler dispatch-namespace list                          List all dispatch namespaces
+		  wrangler dispatch-namespace get <name>                    Get information about a dispatch namespace
+		  wrangler dispatch-namespace create <name>                 Create a dispatch namespace
+		  wrangler dispatch-namespace delete <name>                 Delete a dispatch namespace
+		  wrangler dispatch-namespace rename <old-name> <new-name>  Rename a dispatch namespace
 
 		Flags:
 		  -c, --config   Path to .toml configuration file  [string]
@@ -73,19 +73,19 @@ describe("worker-namespace", () => {
 
 		it("should display help for create", async () => {
 			await expect(
-				runWrangler("worker-namespace create")
+				runWrangler("dispatch-namespace create")
 			).rejects.toThrowErrorMatchingInlineSnapshot(
 				`"Not enough non-option arguments: got 0, need at least 1"`
 			);
 
 			expect(std.out).toMatchInlineSnapshot(`
 			"
-			wrangler worker-namespace create <name>
+			wrangler dispatch-namespace create <name>
 
-			Create a Worker namespace
+			Create a dispatch namespace
 
 			Positionals:
-			  name  Name of the Worker namespace  [string] [required]
+			  name  Name of the dispatch namespace  [string] [required]
 
 			Flags:
 			  -c, --config   Path to .toml configuration file  [string]
@@ -97,11 +97,11 @@ describe("worker-namespace", () => {
 		it("should attempt to create the given namespace", async () => {
 			const namespaceName = "my-namespace";
 			const requests = mockCreateRequest(namespaceName);
-			await runWrangler(`worker-namespace create ${namespaceName}`);
+			await runWrangler(`dispatch-namespace create ${namespaceName}`);
 			expect(requests.count).toEqual(1);
 
 			expect(std.out).toMatchInlineSnapshot(
-				`"Created Worker namespace \\"my-namespace\\" with ID \\"some-namespace-id\\""`
+				`"Created dispatch namespace \\"my-namespace\\" with ID \\"some-namespace-id\\""`
 			);
 		});
 	});
@@ -125,19 +125,19 @@ describe("worker-namespace", () => {
 
 		it("should display help for delete", async () => {
 			await expect(
-				runWrangler("worker-namespace create")
+				runWrangler("dispatch-namespace create")
 			).rejects.toThrowErrorMatchingInlineSnapshot(
 				`"Not enough non-option arguments: got 0, need at least 1"`
 			);
 
 			expect(std.out).toMatchInlineSnapshot(`
 			"
-			wrangler worker-namespace create <name>
+			wrangler dispatch-namespace create <name>
 
-			Create a Worker namespace
+			Create a dispatch namespace
 
 			Positionals:
-			  name  Name of the Worker namespace  [string] [required]
+			  name  Name of the dispatch namespace  [string] [required]
 
 			Flags:
 			  -c, --config   Path to .toml configuration file  [string]
@@ -149,11 +149,11 @@ describe("worker-namespace", () => {
 		it("should try to delete the given namespace", async () => {
 			const namespaceName = "my-namespace";
 			const requests = mockDeleteRequest(namespaceName);
-			await runWrangler(`worker-namespace delete ${namespaceName}`);
+			await runWrangler(`dispatch-namespace delete ${namespaceName}`);
 			expect(requests.count).toBe(1);
 
 			expect(std.out).toMatchInlineSnapshot(
-				`"Deleted Worker namespace \\"my-namespace\\""`
+				`"Deleted dispatch namespace \\"my-namespace\\""`
 			);
 		});
 	});
@@ -183,19 +183,19 @@ describe("worker-namespace", () => {
 
 		it("should display help for get", async () => {
 			await expect(
-				runWrangler("worker-namespace get")
+				runWrangler("dispatch-namespace get")
 			).rejects.toThrowErrorMatchingInlineSnapshot(
 				`"Not enough non-option arguments: got 0, need at least 1"`
 			);
 
 			expect(std.out).toMatchInlineSnapshot(`
 			        "
-			        wrangler worker-namespace get <name>
+			        wrangler dispatch-namespace get <name>
 
-			        Get information about a Worker namespace
+			        Get information about a dispatch namespace
 
 			        Positionals:
-			          name  Name of the Worker namespace  [string] [required]
+			          name  Name of the dispatch namespace  [string] [required]
 
 			        Flags:
 			          -c, --config   Path to .toml configuration file  [string]
@@ -207,7 +207,7 @@ describe("worker-namespace", () => {
 		it("should attempt to get info for the given namespace", async () => {
 			const namespaceName = "my-namespace";
 			const requests = mockInfoRequest(namespaceName);
-			await runWrangler(`worker-namespace get ${namespaceName}`);
+			await runWrangler(`dispatch-namespace get ${namespaceName}`);
 			expect(requests.count).toBe(1);
 
 			expect(std.out).toMatchInlineSnapshot(`
@@ -248,7 +248,7 @@ describe("worker-namespace", () => {
 
 		it("should list all namespaces", async () => {
 			const requests = mockListRequest();
-			await runWrangler("worker-namespace list");
+			await runWrangler("dispatch-namespace list");
 			expect(requests.count).toBe(1);
 			expect(std.out).toMatchInlineSnapshot(`
 			"[
@@ -291,20 +291,20 @@ describe("worker-namespace", () => {
 
 		it("should display help for rename", async () => {
 			await expect(
-				runWrangler("worker-namespace rename")
+				runWrangler("dispatch-namespace rename")
 			).rejects.toThrowErrorMatchingInlineSnapshot(
 				`"Not enough non-option arguments: got 0, need at least 2"`
 			);
 
 			expect(std.out).toMatchInlineSnapshot(`
 			"
-			wrangler worker-namespace rename <old-name> <new-name>
+			wrangler dispatch-namespace rename <old-name> <new-name>
 
-			Rename a Worker namespace
+			Rename a dispatch namespace
 
 			Positionals:
-			  old-name  Name of the Worker namespace  [string] [required]
-			  new-name  New name of the Worker namespace  [string] [required]
+			  old-name  Name of the dispatch namespace  [string] [required]
+			  new-name  New name of the dispatch namespace  [string] [required]
 
 			Flags:
 			  -c, --config   Path to .toml configuration file  [string]
@@ -317,10 +317,12 @@ describe("worker-namespace", () => {
 			const namespaceName = "my-namespace";
 			const newName = "new-namespace";
 			const requests = mockRenameRequest(namespaceName);
-			await runWrangler(`worker-namespace rename ${namespaceName} ${newName}`);
+			await runWrangler(
+				`dispatch-namespace rename ${namespaceName} ${newName}`
+			);
 			expect(requests.count).toBe(1);
 			expect(std.out).toMatchInlineSnapshot(
-				`"Renamed Worker namespace \\"my-namespace\\" to \\"new-namespace\\""`
+				`"Renamed dispatch namespace \\"my-namespace\\" to \\"new-namespace\\""`
 			);
 		});
 	});

package/src/api/dev.ts

@@ -1,10 +1,11 @@
-import { startDev } from "../dev";
+import { startApiDev, startDev } from "../dev";
 import { logger } from "../logger";
 
 import type { EnablePagesAssetsServiceBindingOptions } from "../miniflare-cli";
 import type { RequestInit, Response } from "undici";
 
 interface DevOptions {
+	config?: string;
 	env?: string;
 	ip?: string;
 	port?: number;
@@ -20,7 +21,7 @@ interface DevOptions {
 	experimentalEnableLocalPersistence?: boolean;
 	liveReload?: boolean;
 	watch?: boolean;
-	vars: {
+	vars?: {
 		[key: string]: unknown;
 	};
 	kv?: {
@@ -48,46 +49,91 @@ interface DevOptions {
 	_?: (string | number)[]; //yargs wants this
 	$0?: string; //yargs wants this
 }
+
+interface DevApiOptions {
+	testMode?: boolean;
+	disableExperimentalWarning?: boolean;
+}
+
+interface UnstableDev {
+	stop: () => Promise<void>;
+	fetch: (init?: RequestInit) => Promise<Response | undefined>;
+	waitUntilExit: () => Promise<void>;
+}
 /**
  *  unstable_dev starts a wrangler dev server, and returns a promise that resolves with utility functions to interact with it.
  *  @param {string} script
  *  @param {DevOptions} options
+ *  @param {DevApiOptions} apiOptions
+ * @returns {Promise<UnstableDev>}
  */
 export async function unstable_dev(
 	script: string,
-	options: DevOptions,
-	disableExperimentalWarning?: boolean
+	options?: DevOptions,
+	apiOptions?: DevApiOptions
 ) {
+	const { testMode = true, disableExperimentalWarning = false } =
+		apiOptions || {};
 	if (!disableExperimentalWarning) {
 		logger.warn(
 			`unstable_dev() is experimental\nunstable_dev()'s behaviour will likely change in future releases`
 		);
 	}
-
-	return new Promise<{
-		stop: () => void;
-		fetch: (init?: RequestInit) => Promise<Response | undefined>;
-		waitUntilExit: () => Promise<void>;
-	}>((resolve) => {
-		//lmao
-		return new Promise<Awaited<ReturnType<typeof startDev>>>((ready) => {
-			const devServer = startDev({
-				script: script,
-				inspect: false,
-				logLevel: "none",
-				showInteractiveDevSession: false,
-				_: [],
-				$0: "",
-				...options,
-				local: true,
-				onReady: () => ready(devServer),
+	//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) => {
+			//lmao
+			return new Promise<Awaited<ReturnType<typeof startApiDev>>>((ready) => {
+				// once the devServer is ready for requests, we resolve the inner promise
+				// (where we've named the resolve function "ready")
+				const devServer = startApiDev({
+					script: script,
+					inspect: false,
+					logLevel: "none",
+					showInteractiveDevSession: false,
+					_: [],
+					$0: "",
+					...options,
+					local: true,
+					onReady: () => ready(devServer),
+				});
+			}).then((devServer) => {
+				// now that the inner promise has resolved, we can resolve the outer promise
+				// with an object that lets you fetch and stop the dev server
+				resolve({
+					stop: devServer.stop,
+					fetch: devServer.fetch,
+					//no-op, does nothing in tests
+					waitUntilExit: async () => {
+						return;
+					},
+				});
 			});
-		}).then((devServer) => {
-			resolve({
-				stop: devServer.stop,
-				fetch: devServer.fetch,
-				waitUntilExit: devServer.devReactElement.waitUntilExit,
+		});
+	} else {
+		//outside of test mode, rebuilds work fine, but only one instance of wrangler will work at a time
+		return new Promise<UnstableDev>((resolve) => {
+			//lmao
+			return new Promise<Awaited<ReturnType<typeof startDev>>>((ready) => {
+				const devServer = startDev({
+					script: script,
+					inspect: false,
+					logLevel: "none",
+					showInteractiveDevSession: false,
+					_: [],
+					$0: "",
+					...options,
+					local: true,
+					onReady: () => ready(devServer),
+				});
+			}).then((devServer) => {
+				resolve({
+					stop: devServer.stop,
+					fetch: devServer.fetch,
+					waitUntilExit: devServer.devReactElement.waitUntilExit,
+				});
 			});
 		});
-	});
+	}
 }