wrangler 2.0.24 → 2.0.25

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,11 @@ async function generateAssetsFetch(directory, log) {
         );
         return deconstructedResponse;
       }
-    } else if (hasFileExtension(url.pathname)) {
+    } else if (hasFileExtension(assetName)) {
       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 +5288,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 +5393,40 @@ 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 url = `http://${host}${port ? `:${port}` : ""}`;
+            const request = new MiniflareRequest(
+              url,
+              new MiniflareRequest(...reqArgs)
+            );
+            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 +5450,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.25",
 	"description": "Command-line interface for all things Cloudflare Workers",
 	"keywords": [
 		"wrangler",

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",

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__/helpers/mock-cfetch.ts

@@ -217,7 +217,7 @@ export async function mockFetchR2Objects(
 	bodyInit: {
 		body: BodyInit | Readable;
 		headers: HeadersInit | undefined;
-		method: "PUT" | "GET";
+		method: "PUT" | "GET" | "DELETE";
 	}
 ): Promise<Response> {
 	/**
@@ -234,7 +234,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}`);
 }
 
 /**

package/src/__tests__/r2.test.ts

@@ -290,6 +290,24 @@ describe("wrangler", () => {
 			Upload complete."
 		`);
 			});
+
+			it("should delete R2 object from bucket", async () => {
+				setMockFetchR2Objects({
+					accountId: "some-account-id",
+					bucketName: "bucketName-object-test",
+					objectName: "wormhole-img.png",
+				});
+
+				await runWrangler(
+					`r2 object delete bucketName-object-test/wormhole-img.png`
+				);
+
+				expect(std.out).toMatchInlineSnapshot(`
+			"Deleting object \\"wormhole-img.png\\" from bucket \\"bucketName-object-test\\".
+			Delete complete."
+		`);
+			});
+
 			it("should not allow `--pipe` & `--file` to run together", async () => {
 				fs.writeFileSync("wormhole-img.png", "passageway");
 				setMockFetchR2Objects({

package/src/__tests__/tail.test.ts

@@ -6,7 +6,12 @@ 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 type { TailEventMessage, RequestEvent, ScheduledEvent } from "../tail";
+import type {
+	TailEventMessage,
+	RequestEvent,
+	ScheduledEvent,
+	AlarmEvent,
+} from "../tail";
 import type WebSocket from "ws";
 
 describe("tail", () => {
@@ -251,6 +256,18 @@ describe("tail", () => {
 			expect(std.out).toMatch(deserializeToJson(serializedMessage));
 		});
 
+		it("logs alarm messages in json format", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --format json");
+
+			const event = generateMockAlarmEvent();
+			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 = mockWebsocketAPIs();
 			await runWrangler("tail test-worker --format pretty");
@@ -271,10 +288,10 @@ describe("tail", () => {
 						"[mock expiration date]"
 					)
 			).toMatchInlineSnapshot(`
-        "Successfully created tail, expires at [mock expiration date]
-        Connected to test-worker, waiting for logs...
-        GET https://example.org/ - Ok @ [mock event timestamp]"
-      `);
+			        "Successfully created tail, expires at [mock expiration date]
+			        Connected to test-worker, waiting for logs...
+			        GET https://example.org/ - Ok @ [mock event timestamp]"
+		      `);
 		});
 
 		it("logs scheduled messages in pretty format", async () => {
@@ -297,35 +314,61 @@ describe("tail", () => {
 						"[mock expiration date]"
 					)
 			).toMatchInlineSnapshot(`
-        "Successfully created tail, expires at [mock expiration date]
-        Connected to test-worker, waiting for logs...
-        \\"* * * * *\\" @ [mock timestamp string] - Ok"
-      `);
+			        "Successfully created tail, expires at [mock expiration date]
+			        Connected to test-worker, waiting for logs...
+			        \\"* * * * *\\" @ [mock timestamp string] - Ok"
+		      `);
 		});
 
-		it("should not crash when the tail message has a void event", async () => {
+		it("logs alarm messages in pretty format", async () => {
 			const api = mockWebsocketAPIs();
 			await runWrangler("tail test-worker --format pretty");
 
-			const message = generateMockEventMessage({ event: null });
+			const event = generateMockAlarmEvent();
+			const message = generateMockEventMessage({ event });
 			const serializedMessage = serialize(message);
 
 			api.ws.send(serializedMessage);
 			expect(
 				std.out
 					.replace(
-						new Date(mockEventTimestamp).toLocaleString(),
-						"[mock timestamp string]"
+						new Date(mockEventScheduledTime).toLocaleString(),
+						"[mock scheduled time]"
 					)
 					.replace(
 						mockTailExpiration.toLocaleString(),
 						"[mock expiration date]"
 					)
 			).toMatchInlineSnapshot(`
-        "Successfully created tail, expires at [mock expiration date]
-        Connected to test-worker, waiting for logs...
-        [missing request] - Ok @ [mock timestamp string]"
-      `);
+			        "Successfully created tail, expires at [mock expiration date]
+			        Connected to test-worker, waiting for logs...
+			        Alarm @ [mock scheduled time] - Ok"
+		      `);
+		});
+
+		it("should not crash when the tail message has a void event", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --format pretty");
+
+			const message = generateMockEventMessage({ event: null });
+			const serializedMessage = serialize(message);
+
+			api.ws.send(serializedMessage);
+			expect(
+				std.out
+					.replace(
+						mockTailExpiration.toLocaleString(),
+						"[mock expiration date]"
+					)
+					.replace(
+						new Date(mockEventTimestamp).toLocaleString(),
+						"[mock timestamp string]"
+					)
+			).toMatchInlineSnapshot(`
+			"Successfully created tail, expires at [mock expiration date]
+			Connected to test-worker, waiting for logs...
+			Unknown Event - Ok @ [mock timestamp string]"
+		`);
 		});
 
 		it("defaults to logging in pretty format when the output is a TTY", async () => {
@@ -349,10 +392,10 @@ describe("tail", () => {
 						"[mock expiration date]"
 					)
 			).toMatchInlineSnapshot(`
-        "Successfully created tail, expires at [mock expiration date]
-        Connected to test-worker, waiting for logs...
-        GET https://example.org/ - Ok @ [mock event timestamp]"
-      `);
+			        "Successfully created tail, expires at [mock expiration date]
+			        Connected to test-worker, waiting for logs...
+			        GET https://example.org/ - Ok @ [mock event timestamp]"
+		      `);
 		});
 
 		it("defaults to logging in json format when the output is not a TTY", async () => {
@@ -405,21 +448,21 @@ describe("tail", () => {
 						"[mock expiration date]"
 					)
 			).toMatchInlineSnapshot(`
-        "Successfully created tail, expires at [mock expiration date]
-        Connected to test-worker, waiting for logs...
-        GET https://example.org/ - Ok @ [mock event timestamp]
-          (log) some string
-          (log) { complex: 'object' }
-          (error) 1234"
-      `);
+			        "Successfully created tail, expires at [mock expiration date]
+			        Connected to test-worker, waiting for logs...
+			        GET https://example.org/ - Ok @ [mock event timestamp]
+			          (log) some string
+			          (log) { complex: 'object' }
+			          (error) 1234"
+		      `);
 			expect(std.err).toMatchInlineSnapshot(`
-        "X [ERROR]   Error: some error
+			        "X [ERROR]   Error: some error
 
 
-        X [ERROR]   Error: { complex: 'error' }
+			        X [ERROR]   Error: { complex: 'error' }
 
-        "
-      `);
+			        "
+		      `);
 			expect(std.warn).toMatchInlineSnapshot(`""`);
 		});
 	});
@@ -437,8 +480,8 @@ describe("tail", () => {
  * @returns the same type we expect when deserializing in wrangler
  */
 function serialize(message: TailEventMessage): WebSocket.RawData {
-	if (isScheduled(message.event)) {
-		// `ScheduledEvent`s work just fine
+	if (!isRequest(message.event)) {
+		// `ScheduledEvent`s and `TailEvent`s work just fine
 		const stringified = JSON.stringify(message);
 		return Buffer.from(stringified, "utf-8");
 	} else {
@@ -470,12 +513,12 @@ function serialize(message: TailEventMessage): WebSocket.RawData {
  * Small helper to disambiguate the event types possible in a `TailEventMessage`
  *
  * @param event A TailEvent
- * @returns whether event is a ScheduledEvent (true) or a RequestEvent
+ * @returns true if `event` is a RequestEvent
  */
-function isScheduled(
-	event: ScheduledEvent | RequestEvent | undefined | null
-): event is ScheduledEvent {
-	return Boolean(event && "cron" in event);
+function isRequest(
+	event: ScheduledEvent | RequestEvent | AlarmEvent | undefined | null
+): event is RequestEvent {
+	return Boolean(event && "request" in event);
 }
 
 /**
@@ -559,6 +602,11 @@ const mockTailExpiration = new Date(3005, 1);
  */
 const mockEventTimestamp = 1645454470467;
 
+/**
+ * Default value for event time ISO strings
+ */
+const mockEventScheduledTime = new Date(mockEventTimestamp).toISOString();
+
 /**
  * Mock out the API hit during Tail deletion
  *
@@ -696,3 +744,9 @@ function generateMockScheduledEvent(
 		scheduledTime: opts?.scheduledTime || mockEventTimestamp,
 	};
 }
+
+function generateMockAlarmEvent(opts?: Partial<AlarmEvent>): AlarmEvent {
+	return {
+		scheduledTime: opts?.scheduledTime || mockEventScheduledTime,
+	};
+}

package/src/api/dev.ts

@@ -8,6 +8,7 @@ interface DevOptions {
 	env?: string;
 	ip?: string;
 	port?: number;
+	inspectorPort?: number;
 	localProtocol?: "http" | "https";
 	assets?: string;
 	site?: string;
@@ -32,6 +33,11 @@ interface DevOptions {
 		script_name?: string | undefined;
 		environment?: string | undefined;
 	}[];
+	r2?: {
+		binding: string;
+		bucket_name: string;
+		preview_bucket_name?: string;
+	}[];
 	showInteractiveDevSession?: boolean;
 	logLevel?: "none" | "error" | "log" | "warn" | "debug";
 	logPrefix?: string;

package/src/bundle.ts

@@ -192,8 +192,9 @@ export async function bundleWorker(
 		format: entry.format === "modules" ? "esm" : "iife",
 		target: "es2020",
 		sourcemap: true,
-		// The root included, as the sources are relative paths to tmpDir
-		sourceRoot: entryDirectory,
+		// Include a reference to the output folder in the sourcemap.
+		// This is omitted by default, but we need it to properly resolve source paths in error output.
+		sourceRoot: destination,
 		minify,
 		metafile: true,
 		conditions: ["worker", "browser"],

package/src/config/config.ts

@@ -174,7 +174,7 @@ export interface DevConfig {
 	/**
 	 * IP address for the local dev server to listen on,
 	 *
-	 * @default `localhost`
+	 * @default `0.0.0.0`
 	 */
 	ip: string;
 

package/src/config/validation.ts

@@ -357,7 +357,7 @@ function normalizeAndValidateDev(
 	rawDev: RawDevConfig
 ): DevConfig {
 	const {
-		ip = "localhost",
+		ip = "0.0.0.0",
 		port,
 		inspector_port,
 		local_protocol = "http",