wrangler 0.0.0-c18fbaf5 → 0.0.0-c2b2dfb8

package/bin/wrangler.js

@@ -93,7 +93,15 @@ function runDelegatedWrangler() {
 	} = JSON.parse(fs.readFileSync(packageJsonPath));
 	const resolvedBinaryPath = path.resolve(packageJsonPath, "..", binaryPath);
 
-	debug(`Delegating to locally-installed version of wrangler @ v${version}`);
+	// Make sure the user knows we're delegating to a different installation
+	const currentPackageJsonPath = path.resolve(__dirname, "..", "package.json");
+	const currentPackage = JSON.parse(fs.readFileSync(currentPackageJsonPath));
+	const argv = process.argv.slice(2).join(" ");
+	console.log(
+		`Delegating to locally-installed wrangler@${version} over global wrangler@${currentPackage.version}...
+Run \`npx wrangler ${argv}\` to use the local version directly.
+`
+	);
 
 	// this call to `spawn` is simpler because the delegated version will do all
 	// of the other work.

package/miniflare-dist/index.mjs

@@ -130,41 +130,43 @@ var init_environment_polyfills = __esm({
 
 // ../pages-shared/environment-polyfills/miniflare-tre.ts
 var miniflare_tre_exports = {};
-import {
-  fetch as miniflareFetch,
-  Headers as MiniflareHeaders,
-  Request as MiniflareRequest,
-  Response as MiniflareResponse
-} from "@miniflare/tre";
+__export(miniflare_tre_exports, {
+  default: () => miniflare_tre_default
+});
+var miniflare_tre_default;
 var init_miniflare_tre = __esm({
   "../pages-shared/environment-polyfills/miniflare-tre.ts"() {
     init_environment_polyfills();
-    polyfill({
-      fetch: miniflareFetch,
-      Headers: MiniflareHeaders,
-      Request: MiniflareRequest,
-      Response: MiniflareResponse
-    });
+    miniflare_tre_default = async () => {
+      const mf = await import("@miniflare/tre");
+      polyfill({
+        fetch: mf.fetch,
+        Headers: mf.Headers,
+        Request: mf.Request,
+        Response: mf.Response
+      });
+    };
   }
 });
 
 // ../pages-shared/environment-polyfills/miniflare.ts
 var miniflare_exports = {};
-import {
-  fetch as miniflareFetch2,
-  Headers as MiniflareHeaders2,
-  Request as MiniflareRequest2,
-  Response as MiniflareResponse2
-} from "@miniflare/core";
+__export(miniflare_exports, {
+  default: () => miniflare_default
+});
+var miniflare_default;
 var init_miniflare = __esm({
   "../pages-shared/environment-polyfills/miniflare.ts"() {
     init_environment_polyfills();
-    polyfill({
-      fetch: miniflareFetch2,
-      Headers: MiniflareHeaders2,
-      Request: MiniflareRequest2,
-      Response: MiniflareResponse2
-    });
+    miniflare_default = async () => {
+      const mf = await import("@miniflare/core");
+      polyfill({
+        fetch: mf.fetch,
+        Headers: mf.Headers,
+        Request: mf.Request,
+        Response: mf.Response
+      });
+    };
   }
 });
 
@@ -786,8 +788,8 @@ import {
   Log as MiniflareLog,
   LogLevel as MiniflareLogLevel,
   Miniflare,
-  Request as MiniflareRequest3,
-  Response as MiniflareResponse3
+  Request as MiniflareRequest,
+  Response as MiniflareResponse
 } from "miniflare";
 
 // ../../node_modules/yargs/lib/platform-shims/esm.mjs
@@ -6066,11 +6068,8 @@ async function generateASSETSBinding(options) {
   };
 }
 async function generateAssetsFetch(directory, log, tre) {
-  if (tre) {
-    await Promise.resolve().then(() => (init_miniflare_tre(), miniflare_tre_exports));
-  } else {
-    await Promise.resolve().then(() => (init_miniflare(), miniflare_exports));
-  }
+  const polyfill2 = tre ? (await Promise.resolve().then(() => (init_miniflare_tre(), miniflare_tre_exports))).default : (await Promise.resolve().then(() => (init_miniflare(), miniflare_exports))).default;
+  await polyfill2();
   const miniflare = tre ? await import("@miniflare/tre") : await import("@miniflare/core");
   const Request = miniflare.Request;
   const { generateHandler: generateHandler2, parseQualityWeightedList: parseQualityWeightedList2 } = await Promise.resolve().then(() => (init_handler(), handler_exports));
@@ -6234,12 +6233,12 @@ async function main() {
         namespace.get = (id) => {
           const stub = new DurableObjectStub(factory, id);
           stub.fetch = (...reqArgs) => {
-            const requestFromArgs = new MiniflareRequest3(...reqArgs);
+            const requestFromArgs = new MiniflareRequest(...reqArgs);
             const url = new URL(requestFromArgs.url);
             url.host = host;
             if (port !== void 0)
               url.port = port.toString();
-            const request = new MiniflareRequest3(
+            const request = new MiniflareRequest(
               url.toString(),
               requestFromArgs
             );
@@ -6299,7 +6298,7 @@ async function main() {
 				}`,
         serviceBindings: {
           DO: async (request) => {
-            request = new MiniflareRequest3(request);
+            request = new MiniflareRequest(request);
             const name = request.headers.get("x-miniflare-durable-object-name");
             const idString = request.headers.get(
               "x-miniflare-durable-object-id"
@@ -6307,7 +6306,7 @@ async function main() {
             request.headers.delete("x-miniflare-durable-object-name");
             request.headers.delete("x-miniflare-durable-object-id");
             if (!name || !idString) {
-              return new MiniflareResponse3(
+              return new MiniflareResponse(
                 "[durable-object-proxy-err] Missing `x-miniflare-durable-object-name` or `x-miniflare-durable-object-id` headers.",
                 { status: 400 }
               );
@@ -6315,14 +6314,14 @@ async function main() {
             const namespace = await mf?.getDurableObjectNamespace(name);
             const id = namespace?.idFromString(idString);
             if (!id) {
-              return new MiniflareResponse3(
+              return new MiniflareResponse(
                 "[durable-object-proxy-err] Could not generate an ID. Possibly due to a mismatched DO name and ID?",
                 { status: 500 }
               );
             }
             const stub = namespace?.get(id);
             if (!stub) {
-              return new MiniflareResponse3(
+              return new MiniflareResponse(
                 "[durable-object-proxy-err] Could not generate a stub. Possibly due to a mismatched DO name and ID?",
                 { status: 500 }
               );

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrangler",
-	"version": "0.0.0-c18fbaf5",
+	"version": "0.0.0-c2b2dfb8",
 	"description": "Command-line interface for all things Cloudflare Workers",
 	"keywords": [
 		"wrangler",
@@ -57,7 +57,7 @@
 		"assert-git-version": "node -r esbuild-register scripts/assert-git-version.ts",
 		"build": "npm run clean && npm run bundle && npm run emit-types",
 		"bundle": "node -r esbuild-register scripts/bundle.ts",
-		"check:type": "tsc",
+		"check:type": "node -r esbuild-register scripts/tsc-all.ts",
 		"clean": "rimraf wrangler-dist miniflare-dist emitted-types",
 		"dev": "npm run clean && concurrently -c black,blue --kill-others-on-fail false 'npm run bundle -- --watch' 'npm run check:type -- --watch --preserveWatchOutput'",
 		"emit-types": "tsc -p tsconfig.emit.json && node -r esbuild-register scripts/emit-types.ts",
@@ -115,6 +115,7 @@
 	},
 	"devDependencies": {
 		"@cloudflare/types": "^6.18.4",
+		"@cloudflare/workers-types": "^4.20221111.1",
 		"@databases/split-sql-query": "^1.0.3",
 		"@databases/sql": "^3.2.0",
 		"@iarna/toml": "^3.0.0",
@@ -136,6 +137,7 @@
 		"@types/yargs": "^17.0.10",
 		"@webcontainer/env": "^1.0.1",
 		"body-parser": "^1.20.0",
+		"chalk": "^2.4.2",
 		"clipboardy": "^3.0.0",
 		"cmd-shim": "^4.1.0",
 		"command-exists": "^1.2.9",

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

@@ -5,7 +5,7 @@ import { runInTempDir } from "./helpers/run-in-tmp";
 
 jest.unmock("undici");
 
-describe.skip("unstable_dev", () => {
+describe("unstable_dev", () => {
 	it("should return Hello World", async () => {
 		const worker = await unstable_dev(
 			"src/__tests__/helpers/worker-scripts/hello-world-worker.js",

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

@@ -1,13 +1,13 @@
 import { unstable_dev } from "../api";
 import { fetch } from "undici";
 
-// jest.unmock("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.skip("multi-worker testing", () => {
+describe("multi-worker testing", () => {
 	let childWorker;
 	let parentWorker;
 

package/src/__tests__/d1.test.ts

@@ -1,6 +1,9 @@
-import { mockAccountId } from "./helpers/mock-account-id";
+import { cwd } from "process";
 import { mockConsoleMethods } from "./helpers/mock-console";
+import { useMockIsTTY } from "./helpers/mock-istty";
+import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
+import writeWranglerToml from "./helpers/write-wrangler-toml";
 
 function endEventLoop() {
 	return new Promise((resolve) => setImmediate(resolve));
@@ -8,8 +11,8 @@ function endEventLoop() {
 
 describe("d1", () => {
 	const std = mockConsoleMethods();
-
-	mockAccountId();
+	runInTempDir();
+	const { setIsTTY } = useMockIsTTY();
 
 	it("should show help when no argument is passed", async () => {
 		await runWrangler("d1");
@@ -77,4 +80,44 @@ describe("d1", () => {
 		To give feedback, visit https://discord.gg/cloudflaredev"
 	`);
 	});
+
+	describe("migrate", () => {
+		describe("apply", () => {
+			it("should not attempt to login in local mode", async () => {
+				setIsTTY(false);
+				writeWranglerToml({
+					d1_databases: [
+						{ binding: "DATABASE", database_name: "db", database_id: "xxxx" },
+					],
+				});
+				// If we get to the point where we are checking for migrations then we have not been asked to log in.
+				await expect(
+					runWrangler("d1 migrations apply --local DATABASE")
+				).rejects.toThrowError(
+					`No migrations present at ${cwd().replaceAll("\\", "/")}/migrations.`
+				);
+			});
+
+			it("should try to read D1 config from wrangler.toml", async () => {
+				setIsTTY(false);
+				writeWranglerToml();
+				await expect(
+					runWrangler("d1 migrations apply DATABASE")
+				).rejects.toThrowError(
+					"Can't find a DB with name/binding 'DATABASE' in local config. Check info in wrangler.toml..."
+				);
+			});
+
+			it("should not try to read wrangler.toml in local mode", async () => {
+				setIsTTY(false);
+				writeWranglerToml();
+				// If we get to the point where we are checking for migrations then we have not checked wrangler.toml.
+				await expect(
+					runWrangler("d1 migrations apply --local DATABASE")
+				).rejects.toThrowError(
+					`No migrations present at ${cwd().replaceAll("\\", "/")}/migrations.`
+				);
+			});
+		});
+	});
 });

package/src/__tests__/deployments.test.ts

@@ -1,5 +1,7 @@
 // import * as fs from "fs";
 // import * as TOML from "@iarna/toml";
+import * as fs from "node:fs";
+import * as TOML from "@iarna/toml";
 import { rest } from "msw";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
 import { mockConsoleMethods } from "./helpers/mock-console";
@@ -26,11 +28,7 @@ describe("deployments", () => {
 			...mswSuccessUserHandlers,
 			rest.get(
 				"*/accounts/:accountId/workers/services/:scriptName",
-				(request, response, context) => {
-					expect(["undefined", "somethingElse"]).toContain(
-						request.params.scriptName
-					);
-
+				(_, response, context) => {
 					return response.once(
 						context.status(200),
 						context.json({
@@ -52,6 +50,16 @@ describe("deployments", () => {
 	});
 
 	it("should log deployments", async () => {
+		fs.writeFileSync(
+			"./wrangler.toml",
+			TOML.stringify({
+				compatibility_date: "2022-01-12",
+				name: "test-script-name",
+				first_party_worker: true,
+			}),
+			"utf-8"
+		);
+
 		await runWrangler("deployments");
 		expect(std.out).toMatchInlineSnapshot(`
 		"🚧\`wrangler deployments\` is a beta command. Please report any issues to https://github.com/cloudflare/wrangler2/issues/new/choose
@@ -71,7 +79,7 @@ describe("deployments", () => {
 	});
 
 	it("should log deployments for script with passed in name option", async () => {
-		await runWrangler("deployments --name somethingElse");
+		await runWrangler("deployments --name something-else");
 		expect(std.out).toMatchInlineSnapshot(`
 		"🚧\`wrangler deployments\` is a beta command. Please report any issues to https://github.com/cloudflare/wrangler2/issues/new/choose
 
@@ -88,4 +96,10 @@ describe("deployments", () => {
 		🟩 Active"
 	`);
 	});
+
+	it("should error on missing script name", async () => {
+		await expect(runWrangler("deployments")).rejects.toMatchInlineSnapshot(
+			`[Error: Required Worker name missing. Please specify the Worker name in wrangler.toml, or pass it as an argument with \`--name\`]`
+		);
+	});
 });

package/src/__tests__/dev.test.tsx

@@ -1,11 +1,11 @@
 import * as fs from "node:fs";
 import getPort from "get-port";
+import { rest } from "msw";
 import patchConsole from "patch-console";
 import dedent from "ts-dedent";
 import Dev from "../dev/dev";
 import { CI } from "../is-ci";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
-import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
 import {
 	msw,
@@ -33,7 +33,7 @@ describe("wrangler dev", () => {
 	afterEach(() => {
 		(Dev as jest.Mock).mockClear();
 		patchConsole(() => {});
-		unsetAllMocks();
+		msw.resetHandlers();
 	});
 
 	describe("authorization", () => {
@@ -439,16 +439,44 @@ describe("wrangler dev", () => {
 				main: "index.js",
 			});
 			fs.writeFileSync("index.js", `export default {};`);
-			mockGetZones("111.222.333.some-host.com", []);
-			mockGetZones("222.333.some-host.com", []);
-			mockGetZones("333.some-host.com", [{ id: "some-zone-id" }]);
-			await runWrangler("dev --host 111.222.333.some-host.com");
-			expect((Dev as jest.Mock).mock.calls[0][0]).toEqual(
-				expect.objectContaining({
-					host: "111.222.333.some-host.com",
-					zone: "some-zone-id",
+
+			msw.use(
+				rest.get("*/zones", (req, res, ctx) => {
+					let zone: [] | [{ id: "some-zone-id" }] = [];
+					if (
+						req.url.searchParams.get("name") === "111.222.333.some-host.com"
+					) {
+						zone = [];
+					} else if (
+						req.url.searchParams.get("name") === "222.333.some-host.com"
+					) {
+						zone = [];
+					} else if (req.url.searchParams.get("name") === "333.some-host.com") {
+						zone = [{ id: "some-zone-id" }];
+					}
+
+					return res(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: zone,
+						})
+					);
 				})
 			);
+
+			await runWrangler("dev --host 111.222.333.some-host.com");
+
+			const devMockCall = (Dev as jest.Mock).mock.calls[0][0];
+
+			expect(devMockCall).toHaveProperty("host", "111.222.333.some-host.com");
+			expect(devMockCall).toHaveProperty(
+				"localUpstream",
+				"111.222.333.some-host.com"
+			);
+			expect(devMockCall).toHaveProperty("zone", "some-zone-id");
 		});
 
 		it("should, in order, use args.host/config.dev.host/args.routes/(config.route|config.routes)", async () => {
@@ -1540,14 +1568,19 @@ describe("wrangler dev", () => {
 });
 
 function mockGetZones(domain: string, zones: { id: string }[] = []) {
-	const removeMock = setMockResponse(
-		"/zones",
-		"GET",
-		(_urlPieces, _init, queryParams) => {
-			expect([...queryParams.entries()]).toEqual([["name", domain]]);
-			// Because the API URL `/zones` is the same for each request, we can get into a situation where earlier mocks get triggered for later requests. So, we simply clear the mock on every trigger.
-			removeMock();
-			return zones;
-		}
+	msw.use(
+		rest.get("*/zones", (req, res, ctx) => {
+			expect([...req.url.searchParams.entries()]).toEqual([["name", domain]]);
+
+			return res(
+				ctx.status(200),
+				ctx.json({
+					success: true,
+					errors: [],
+					messages: [],
+					result: zones,
+				})
+			);
+		})
 	);
 }

package/src/__tests__/helpers/mock-auth-domain.ts

@@ -0,0 +1,20 @@
+const ORIGINAL_WRANGLER_AUTH_DOMAIN = process.env.WRANGLER_AUTH_DOMAIN;
+
+/**
+ * Mock the Auth URL domain so that we can control where we attempt to login.
+ *
+ * Note that you can remove any API token from the environment by setting the value to `null`.
+ * This is useful if a higher `describe()` block has already called `mockAuthDomain()`.
+ */
+export function mockAuthDomain({ domain }: { domain: string | null }) {
+	beforeEach(() => {
+		if (domain === null) {
+			delete process.env.WRANGLER_AUTH_DOMAIN;
+		} else {
+			process.env.WRANGLER_AUTH_DOMAIN = domain;
+		}
+	});
+	afterEach(() => {
+		process.env.WRANGLER_AUTH_DOMAIN = ORIGINAL_WRANGLER_AUTH_DOMAIN;
+	});
+}

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

@@ -2,7 +2,7 @@ import { Readable } from "node:stream";
 import { URL, URLSearchParams } from "node:url";
 import { pathToRegexp } from "path-to-regexp";
 import { Response } from "undici";
-import { getCloudflareApiBaseUrl } from "../../cfetch";
+import { getCloudflareApiBaseUrl } from "../../environment-variables/misc-variables";
 import type { FetchResult, FetchError } from "../../cfetch";
 import type {
 	fetchInternal,
@@ -219,31 +219,6 @@ const kvGetMocks = new Map<string, string | Buffer>();
 const r2GetMocks = new Map<string, string | undefined>();
 const dashScriptMocks = new Map<string, string | undefined>();
 
-/**
- * @mocked typeof fetchKVGetValue
- */
-export function mockFetchKVGetValue(
-	accountId: string,
-	namespaceId: string,
-	key: string
-) {
-	const mapKey = `${accountId}/${namespaceId}/${key}`;
-	if (kvGetMocks.has(mapKey)) {
-		const value = kvGetMocks.get(mapKey);
-		if (value !== undefined) return Promise.resolve(value);
-	}
-	throw new Error(`no mock value found for \`kv:key get\` - ${mapKey}`);
-}
-
-export function setMockFetchKVGetValue(
-	accountId: string,
-	namespaceId: string,
-	key: string,
-	value: string | Buffer
-) {
-	kvGetMocks.set(`${accountId}/${namespaceId}/${key}`, value);
-}
-
 /**
  * @mocked typeof fetchR2Objects
  */
@@ -300,34 +275,3 @@ export function unsetSpecialMockFns() {
 	r2GetMocks.clear();
 	dashScriptMocks.clear();
 }
-
-/**
- * @mocked typeof fetchDashScript
- * multipart/form-data is the response for modules and raw text for the Script endpoint.
- */
-export async function mockFetchDashScript(resource: string): Promise<string> {
-	if (dashScriptMocks.has(resource)) {
-		return dashScriptMocks.get(resource) ?? "";
-	}
-	throw new Error(`no mock found for \`init from-dash\` - ${resource}`);
-}
-
-/**
- * Mock setter for usage within test blocks, companion helper to `mockFetchDashScript`
- */
-export function setMockFetchDashScript({
-	accountId,
-	fromDashScriptName,
-	environment,
-	mockResponse,
-}: {
-	accountId: string;
-	fromDashScriptName: string;
-	environment: string;
-	mockResponse?: string;
-}) {
-	dashScriptMocks.set(
-		`/accounts/${accountId}/workers/services/${fromDashScriptName}/environments/${environment}/content`,
-		mockResponse
-	);
-}