wrangler 2.0.24 → 2.0.27

package/miniflare-dist/index.mjs

@@ -105,7 +105,18 @@ var require_mime = __commonJS({
 });
 
 // src/miniflare-cli/index.ts
-import { Log, LogLevel, Miniflare } from "miniflare";
+import { fetch } from "@miniflare/core";
+import {
+  DurableObjectNamespace,
+  DurableObjectStub
+} from "@miniflare/durable-objects";
+import {
+  Log,
+  LogLevel,
+  Miniflare,
+  Response as MiniflareResponse,
+  Request as MiniflareRequest
+} from "miniflare";
 
 // ../../node_modules/yargs/lib/platform-shims/esm.mjs
 import { notStrictEqual, strictEqual } from "assert";
@@ -4914,6 +4925,14 @@ function isYargsInstance(y) {
 var Yargs = YargsFactory(esm_default);
 var yargs_default = Yargs;
 
+// src/errors.ts
+var FatalError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+};
+
 // src/miniflare-cli/assets.ts
 var import_mime = __toESM(require_mime());
 import { existsSync, lstatSync, readFileSync as readFileSync4 } from "node:fs";
@@ -5147,6 +5166,11 @@ async function generateAssetsFetch(directory, log) {
   };
   const generateResponse = (request) => {
     const url = new URL(request.url);
+    let assetName = url.pathname;
+    try {
+      assetName = decodeURIComponent(url.pathname);
+    } catch {
+    }
     const deconstructedResponse = {
       status: 200,
       headers: new Headers(),
@@ -5176,7 +5200,7 @@ async function generateAssetsFetch(directory, log) {
       return deconstructedResponse;
     }
     const notFound = () => {
-      let cwd = url.pathname;
+      let cwd = assetName;
       while (cwd) {
         cwd = cwd.slice(0, cwd.lastIndexOf("/"));
         if (asset = getAsset(`${cwd}/404.html`)) {
@@ -5201,34 +5225,34 @@ async function generateAssetsFetch(directory, log) {
       return deconstructedResponse;
     };
     let asset;
-    if (url.pathname.endsWith("/")) {
-      if (asset = getAsset(`${url.pathname}/index.html`)) {
+    if (assetName.endsWith("/")) {
+      if (asset = getAsset(`${assetName}/index.html`)) {
         deconstructedResponse.body = serveAsset(asset);
         deconstructedResponse.headers.set(
           "Content-Type",
           (0, import_mime.getType)(asset) || "application/octet-stream"
         );
         return deconstructedResponse;
-      } else if (asset = getAsset(`${url.pathname.replace(/\/$/, ".html")}`)) {
+      } else if (asset = getAsset(`${assetName.replace(/\/$/, ".html")}`)) {
         deconstructedResponse.status = 301;
         deconstructedResponse.headers.set(
           "Location",
-          `${url.pathname.slice(0, -1)}${url.search}`
+          `${assetName.slice(0, -1)}${url.search}`
         );
         return deconstructedResponse;
       }
     }
-    if (url.pathname.endsWith("/index")) {
+    if (assetName.endsWith("/index")) {
       deconstructedResponse.status = 301;
       deconstructedResponse.headers.set(
         "Location",
-        `${url.pathname.slice(0, -"index".length)}${url.search}`
+        `${assetName.slice(0, -"index".length)}${url.search}`
       );
       return deconstructedResponse;
     }
-    if (asset = getAsset(url.pathname)) {
-      if (url.pathname.endsWith(".html")) {
-        const extensionlessPath = url.pathname.slice(0, -".html".length);
+    if (asset = getAsset(assetName)) {
+      if (assetName.endsWith(".html")) {
+        const extensionlessPath = assetName.slice(0, -".html".length);
         if (getAsset(extensionlessPath) || extensionlessPath === "/") {
           deconstructedResponse.body = serveAsset(asset);
           deconstructedResponse.headers.set(
@@ -5252,11 +5276,19 @@ async function generateAssetsFetch(directory, log) {
         );
         return deconstructedResponse;
       }
-    } else if (hasFileExtension(url.pathname)) {
+    } else if (hasFileExtension(assetName)) {
+      if (asset = getAsset(assetName + ".html")) {
+        deconstructedResponse.body = serveAsset(asset);
+        deconstructedResponse.headers.set(
+          "Content-Type",
+          (0, import_mime.getType)(asset) || "application/octet-stream"
+        );
+        return deconstructedResponse;
+      }
       notFound();
       return deconstructedResponse;
     }
-    if (asset = getAsset(`${url.pathname}.html`)) {
+    if (asset = getAsset(`${assetName}.html`)) {
       deconstructedResponse.body = serveAsset(asset);
       deconstructedResponse.headers.set(
         "Content-Type",
@@ -5264,11 +5296,11 @@ async function generateAssetsFetch(directory, log) {
       );
       return deconstructedResponse;
     }
-    if (asset = getAsset(`${url.pathname}/index.html`)) {
+    if (asset = getAsset(`${assetName}/index.html`)) {
       deconstructedResponse.status = 301;
       deconstructedResponse.headers.set(
         "Location",
-        `${url.pathname}/${url.search}`
+        `${assetName}/${url.search}`
       );
       return deconstructedResponse;
     } else {
@@ -5369,7 +5401,44 @@ async function main() {
   if (logLevel > LogLevel.INFO) {
     console.log("OPTIONS:\n", JSON.stringify(config, null, 2));
   }
+  config.bindings = {
+    ...config.bindings,
+    ...Object.fromEntries(
+      Object.entries(
+        config.externalDurableObjects
+      ).map(([binding, { name, host, port }]) => {
+        const factory = () => {
+          throw new FatalError(
+            "An external Durable Object instance's state has somehow been attempted to be accessed.",
+            1
+          );
+        };
+        const namespace = new DurableObjectNamespace(name, factory);
+        namespace.get = (id) => {
+          const stub = new DurableObjectStub(factory, id);
+          stub.fetch = (...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 MiniflareRequest(
+              url.toString(),
+              requestFromArgs
+            );
+            request.headers.set("x-miniflare-durable-object-name", name);
+            request.headers.set("x-miniflare-durable-object-id", id.toString());
+            return fetch(request);
+          };
+          return stub;
+        };
+        return [binding, namespace];
+      })
+    )
+  };
   let mf;
+  let durableObjectsMf = void 0;
+  let durableObjectsMfPort = void 0;
   try {
     if (args._[1]) {
       const opts = JSON.parse(
@@ -5393,11 +5462,68 @@ async function main() {
     mf = new Miniflare(config);
     await mf.startServer();
     await mf.startScheduler();
-    process.send && process.send("ready");
+    const internalDurableObjectClassNames = Object.values(
+      config.durableObjects
+    );
+    if (internalDurableObjectClassNames.length > 0) {
+      durableObjectsMf = new Miniflare({
+        host: config.host,
+        port: 0,
+        script: `
+				export default {
+					fetch(request, env) {
+						return env.DO.fetch(request)
+					}
+				}`,
+        serviceBindings: {
+          DO: async (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"
+            );
+            request.headers.delete("x-miniflare-durable-object-name");
+            request.headers.delete("x-miniflare-durable-object-id");
+            if (!name || !idString) {
+              return new MiniflareResponse(
+                "[durable-object-proxy-err] Missing `x-miniflare-durable-object-name` or `x-miniflare-durable-object-id` headers.",
+                { status: 400 }
+              );
+            }
+            const namespace = await mf?.getDurableObjectNamespace(name);
+            const id = namespace?.idFromString(idString);
+            if (!id) {
+              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 MiniflareResponse(
+                "[durable-object-proxy-err] Could not generate a stub. Possibly due to a mismatched DO name and ID?",
+                { status: 500 }
+              );
+            }
+            return stub.fetch(request);
+          }
+        },
+        modules: true
+      });
+      const server = await durableObjectsMf.startServer();
+      durableObjectsMfPort = server.address().port;
+    }
+    process.send && process.send(
+      JSON.stringify({
+        ready: true,
+        durableObjectsPort: durableObjectsMfPort
+      })
+    );
   } catch (e) {
     mf?.log.error(e);
     process.exitCode = 1;
     await mf?.dispose();
+    await durableObjectsMf?.dispose();
   }
 }
 await main();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrangler",
-	"version": "2.0.24",
+	"version": "2.0.27",
 	"description": "Command-line interface for all things Cloudflare Workers",
 	"keywords": [
 		"wrangler",
@@ -52,11 +52,11 @@
 		"build": "npm run clean && npm run bundle && npm run emit-types",
 		"bundle": "node -r esbuild-register scripts/bundle.ts",
 		"check:type": "tsc",
-		"clean": "rm -rf wrangler-dist miniflare-dist emitted-types",
+		"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",
 		"prepublishOnly": "SOURCEMAPS=false npm run build",
-		"start": "npm run bundle && NODE_OPTIONS=--enable-source-maps ./bin/wrangler.js",
+		"start": "npm run bundle && cross-env NODE_OPTIONS=--enable-source-maps ./bin/wrangler.js",
 		"test": "jest --silent=false --verbose=true",
 		"test-watch": "npm run test -- --runInBand --testTimeout=50000 --watch",
 		"test:ci": "npm run test -- --verbose=true --coverage"

package/src/__tests__/configuration.test.ts

@@ -26,7 +26,7 @@ describe("normalizeAndValidateConfig()", () => {
 			compatibility_flags: [],
 			configPath: undefined,
 			dev: {
-				ip: "localhost",
+				ip: "0.0.0.0",
 				local_protocol: "http",
 				port: undefined, // the default of 8787 is set at runtime
 				upstream_protocol: "https",
@@ -1635,6 +1635,7 @@ describe("normalizeAndValidateConfig()", () => {
 								id: "KV_ID_2",
 								preview_id: 2222,
 							},
+							{ binding: "VALID", id: "" },
 						],
 					} as unknown as RawConfig,
 					undefined,
@@ -1654,7 +1655,8 @@ describe("normalizeAndValidateConfig()", () => {
 			            - \\"kv_namespaces[1]\\" bindings should have a string \\"id\\" field but got {\\"binding\\":\\"VALID\\"}.
 			            - \\"kv_namespaces[2]\\" bindings should have a string \\"binding\\" field but got {\\"binding\\":2000,\\"id\\":2111}.
 			            - \\"kv_namespaces[2]\\" bindings should have a string \\"id\\" field but got {\\"binding\\":2000,\\"id\\":2111}.
-			            - \\"kv_namespaces[3]\\" bindings should, optionally, have a string \\"preview_id\\" field but got {\\"binding\\":\\"KV_BINDING_2\\",\\"id\\":\\"KV_ID_2\\",\\"preview_id\\":2222}."
+			            - \\"kv_namespaces[3]\\" bindings should, optionally, have a string \\"preview_id\\" field but got {\\"binding\\":\\"KV_BINDING_2\\",\\"id\\":\\"KV_ID_2\\",\\"preview_id\\":2222}.
+			            - \\"kv_namespaces[4]\\" bindings should have a string \\"id\\" field but got {\\"binding\\":\\"VALID\\",\\"id\\":\\"\\"}."
 		        `);
 			});
 		});
@@ -1740,6 +1742,7 @@ describe("normalizeAndValidateConfig()", () => {
 								bucket_name: "R2_BUCKET_2",
 								preview_bucket_name: 2555,
 							},
+							{ binding: "R2_BINDING_1", bucket_name: "" },
 						],
 					} as unknown as RawConfig,
 					undefined,
@@ -1759,7 +1762,8 @@ describe("normalizeAndValidateConfig()", () => {
 			            - \\"r2_buckets[1]\\" bindings should have a string \\"bucket_name\\" field but got {\\"binding\\":\\"R2_BINDING_1\\"}.
 			            - \\"r2_buckets[2]\\" bindings should have a string \\"binding\\" field but got {\\"binding\\":2333,\\"bucket_name\\":2444}.
 			            - \\"r2_buckets[2]\\" bindings should have a string \\"bucket_name\\" field but got {\\"binding\\":2333,\\"bucket_name\\":2444}.
-			            - \\"r2_buckets[3]\\" bindings should, optionally, have a string \\"preview_bucket_name\\" field but got {\\"binding\\":\\"R2_BINDING_2\\",\\"bucket_name\\":\\"R2_BUCKET_2\\",\\"preview_bucket_name\\":2555}."
+			            - \\"r2_buckets[3]\\" bindings should, optionally, have a string \\"preview_bucket_name\\" field but got {\\"binding\\":\\"R2_BINDING_2\\",\\"bucket_name\\":\\"R2_BUCKET_2\\",\\"preview_bucket_name\\":2555}.
+			            - \\"r2_buckets[4]\\" bindings should have a string \\"bucket_name\\" field but got {\\"binding\\":\\"R2_BINDING_1\\",\\"bucket_name\\":\\"\\"}."
 		        `);
 			});
 		});

package/src/__tests__/dev.test.tsx

@@ -68,6 +68,28 @@ describe("wrangler dev", () => {
 		});
 	});
 
+	describe("usage-model", () => {
+		it("should read wrangler.toml's usage_model", async () => {
+			writeWranglerToml({
+				main: "index.js",
+				usage_model: "unbound",
+			});
+			fs.writeFileSync("index.js", `export default {};`);
+			await runWrangler("dev");
+			expect((Dev as jest.Mock).mock.calls[0][0].usageModel).toEqual("unbound");
+		});
+
+		it("should read wrangler.toml's usage_model in local mode", async () => {
+			writeWranglerToml({
+				main: "index.js",
+				usage_model: "unbound",
+			});
+			fs.writeFileSync("index.js", `export default {};`);
+			await runWrangler("dev --local");
+			expect((Dev as jest.Mock).mock.calls[0][0].usageModel).toEqual("unbound");
+		});
+	});
+
 	describe("entry-points", () => {
 		it("should error if there is no entry-point specified", async () => {
 			writeWranglerToml();
@@ -630,13 +652,13 @@ describe("wrangler dev", () => {
 	});
 
 	describe("ip", () => {
-		it("should default ip to localhost", async () => {
+		it("should default ip to 0.0.0.0", async () => {
 			writeWranglerToml({
 				main: "index.js",
 			});
 			fs.writeFileSync("index.js", `export default {};`);
 			await runWrangler("dev");
-			expect((Dev as jest.Mock).mock.calls[0][0].ip).toEqual("localhost");
+			expect((Dev as jest.Mock).mock.calls[0][0].ip).toEqual("0.0.0.0");
 			expect(std.out).toMatchInlineSnapshot(`""`);
 			expect(std.warn).toMatchInlineSnapshot(`""`);
 			expect(std.err).toMatchInlineSnapshot(`""`);
@@ -849,7 +871,7 @@ describe("wrangler dev", () => {
 			});
 			fs.writeFileSync("index.js", `export default {};`);
 			await runWrangler("dev");
-			expect((Dev as jest.Mock).mock.calls[0][0].ip).toEqual("localhost");
+			expect((Dev as jest.Mock).mock.calls[0][0].ip).toEqual("0.0.0.0");
 			expect(std.out).toMatchInlineSnapshot(`
 			        "Your worker has access to the following bindings:
 			        - Durable Objects:
@@ -983,7 +1005,7 @@ describe("wrangler dev", () => {
 			      --compatibility-date                         Date to use for compatibility checks  [string]
 			      --compatibility-flags, --compatibility-flag  Flags to use for compatibility checks  [array]
 			      --latest                                     Use the latest version of the worker runtime  [boolean] [default: true]
-			      --ip                                         IP address to listen on, defaults to \`localhost\`  [string]
+			      --ip                                         IP address to listen on  [string] [default: \\"0.0.0.0\\"]
 			      --port                                       Port to listen on  [number]
 			      --inspector-port                             Port for devtools to connect to  [number]
 			      --routes, --route                            Routes to upload  [array]

package/src/__tests__/generate.test.ts

@@ -1,6 +1,4 @@
 import fs from "node:fs";
-import path from "node:path";
-import process from "node:process";
 import { setup } from "create-cloudflare";
 import { mockConsoleMethods } from "./helpers/mock-console";
 import { mockConfirm, clearConfirmMocks } from "./helpers/mock-dialogs";
@@ -73,7 +71,7 @@ describe("generate", () => {
 		).resolves.toBeUndefined();
 
 		expect(createCloudflareMock).lastCalledWith(
-			path.resolve(process.cwd(), "my-worker-1"),
+			"my-worker-1",
 			"some-template",
 			{ debug: false, force: false, init: true }
 		);
@@ -85,7 +83,7 @@ describe("generate", () => {
 		).resolves.toBeUndefined();
 
 		expect(createCloudflareMock).lastCalledWith(
-			path.resolve(process.cwd(), "my-worker-2"),
+			"my-worker-2",
 			"some-template",
 			{ debug: false, force: false, init: true }
 		);

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

@@ -183,6 +183,7 @@ export function unsetAllMocks() {
 
 const kvGetMocks = new Map<string, string | Buffer>();
 const r2GetMocks = new Map<string, string | undefined>();
+const dashScriptMocks = new Map<string, string | undefined>();
 
 /**
  * @mocked typeof fetchKVGetValue
@@ -217,7 +218,7 @@ export async function mockFetchR2Objects(
 	bodyInit: {
 		body: BodyInit | Readable;
 		headers: HeadersInit | undefined;
-		method: "PUT" | "GET";
+		method: "PUT" | "GET" | "DELETE";
 	}
 ): Promise<Response> {
 	/**
@@ -234,7 +235,7 @@ export async function mockFetchR2Objects(
 
 		return new Response(value);
 	}
-	throw new Error(`no expected mock found for \`r2 object get\` - ${resource}`);
+	throw new Error(`no mock found for \`r2 object\` - ${resource}`);
 }
 
 /**
@@ -260,4 +261,36 @@ export function setMockFetchR2Objects({
 export function unsetSpecialMockFns() {
 	kvGetMocks.clear();
 	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)) {
+		const value = dashScriptMocks.get(resource) ?? "";
+
+		return value;
+	}
+	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,
+	mockResponse,
+}: {
+	accountId: string;
+	fromDashScriptName: string;
+	mockResponse?: string;
+}) {
+	dashScriptMocks.set(
+		`/accounts/${accountId}/workers/scripts/${fromDashScriptName}`,
+		mockResponse
+	);
 }