wrangler 2.0.28 → 2.0.29

package/miniflare-dist/index.mjs

@@ -4934,9 +4934,57 @@ var FatalError = class extends Error {
 };
 
 // src/miniflare-cli/assets.ts
-var import_mime = __toESM(require_mime());
 import { existsSync, lstatSync, readFileSync as readFileSync4 } from "node:fs";
 import { join } from "node:path";
+
+// ../pages-shared/src/asset-server/rulesEngine.ts
+var ESCAPE_REGEX_CHARACTERS = /[-/\\^$*+?.()|[\]{}]/g;
+var escapeRegex = (str) => {
+  return str.replace(ESCAPE_REGEX_CHARACTERS, "\\$&");
+};
+var HOST_PLACEHOLDER_REGEX = /(?<=^https:\\\/\\\/[^/]*?):([^\\]+)(?=\\)/g;
+var PLACEHOLDER_REGEX = /:(\w+)/g;
+var replacer = (str, replacements) => {
+  for (const [replacement, value] of Object.entries(replacements)) {
+    str = str.replaceAll(`:${replacement}`, value);
+  }
+  return str;
+};
+var generateRulesMatcher = (rules, replacerFn = (match) => match) => {
+  if (!rules)
+    return () => [];
+  const compiledRules = Object.entries(rules).map(([rule, match]) => {
+    const crossHost = rule.startsWith("https://");
+    rule = rule.split("*").map(escapeRegex).join("(?<splat>.*)");
+    const host_matches = rule.matchAll(HOST_PLACEHOLDER_REGEX);
+    for (const host_match of host_matches) {
+      rule = rule.split(host_match[0]).join(`(?<${host_match[1]}>[^/.]+)`);
+    }
+    const path_matches = rule.matchAll(PLACEHOLDER_REGEX);
+    for (const path_match of path_matches) {
+      rule = rule.split(path_match[0]).join(`(?<${path_match[1]}>[^/]+)`);
+    }
+    rule = "^" + rule + "$";
+    try {
+      const regExp = new RegExp(rule);
+      return [{ crossHost, regExp }, match];
+    } catch {
+    }
+  }).filter((value) => value !== void 0);
+  return ({ request }) => {
+    const { pathname, host } = new URL(request.url);
+    return compiledRules.map(([{ crossHost, regExp }, match]) => {
+      const test = crossHost ? `https://${host}${pathname}` : pathname;
+      const result = regExp.exec(test);
+      if (result) {
+        return replacerFn(match, result.groups || {});
+      }
+    }).filter((value) => value !== void 0);
+  };
+};
+
+// src/miniflare-cli/assets.ts
+var import_mime = __toESM(require_mime());
 import { fetch as miniflareFetch } from "@miniflare/core";
 import { watch } from "chokidar";
 import { Response } from "miniflare";
@@ -4967,49 +5015,6 @@ async function generateASSETSBinding(options) {
     }
   };
 }
-function escapeRegex(str) {
-  return str.replace(/[-/\\^$*+?.()|[]{}]/g, "\\$&");
-}
-function replacer(str, replacements) {
-  for (const [replacement, value] of Object.entries(replacements)) {
-    str = str.replace(`:${replacement}`, value);
-  }
-  return str;
-}
-function generateRulesMatcher(rules, replacerFn = (match) => match) {
-  if (!rules)
-    return () => [];
-  const compiledRules = Object.entries(rules).map(([rule, match]) => {
-    const crossHost = rule.startsWith("https://");
-    rule = rule.split("*").map(escapeRegex).join("(?<splat>.*)");
-    const host_matches = rule.matchAll(
-      /(?<=^https:\\\/\\\/[^/]*?):([^\\]+)(?=\\)/g
-    );
-    for (const hostMatch of host_matches) {
-      rule = rule.split(hostMatch[0]).join(`(?<${hostMatch[1]}>[^/.]+)`);
-    }
-    const path_matches = rule.matchAll(/:(\w+)/g);
-    for (const pathMatch of path_matches) {
-      rule = rule.split(pathMatch[0]).join(`(?<${pathMatch[1]}>[^/]+)`);
-    }
-    rule = "^" + rule + "$";
-    try {
-      const regExp = new RegExp(rule);
-      return [{ crossHost, regExp }, match];
-    } catch {
-    }
-  }).filter((value) => value !== void 0);
-  return ({ request }) => {
-    const { pathname, host } = new URL(request.url);
-    return compiledRules.map(([{ crossHost, regExp }, match]) => {
-      const test = crossHost ? `https://${host}${pathname}` : pathname;
-      const result = regExp.exec(test);
-      if (result) {
-        return replacerFn(match, result.groups || {});
-      }
-    }).filter((value) => value !== void 0);
-  };
-}
 function generateHeadersMatcher(headersFile) {
   if (existsSync(headersFile)) {
     const contents = readFileSync4(headersFile).toString();
@@ -5403,7 +5408,7 @@ async function main() {
   }
   config.bindings = {
     ...config.bindings,
-    ...Object.fromEntries(
+    ...config.externalDurableObjects && Object.fromEntries(
       Object.entries(
         config.externalDurableObjects
       ).map(([binding, { name, host, port }]) => {
@@ -5427,7 +5432,10 @@ async function main() {
               requestFromArgs
             );
             request.headers.set("x-miniflare-durable-object-name", name);
-            request.headers.set("x-miniflare-durable-object-id", id.toString());
+            request.headers.set(
+              "x-miniflare-durable-object-id",
+              id.toString()
+            );
             return fetch(request);
           };
           return stub;

package/package.json

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

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

@@ -0,0 +1,19 @@
+import { unstable_dev } from "../api";
+
+jest.unmock("undici");
+
+describe("unstable_dev", () => {
+	it("should return Hello World", async () => {
+		const worker = await unstable_dev(
+			"src/__tests__/helpers/hello-world-worker.js",
+			{},
+			{ disableExperimentalWarning: true }
+		);
+		const resp = await worker.fetch();
+		if (resp) {
+			const text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Hello World!"`);
+		}
+		await worker.stop();
+	});
+});

package/src/__tests__/helpers/hello-world-worker.js

@@ -0,0 +1,5 @@
+export default {
+	async fetch() {
+		return new Response("Hello World!");
+	},
+};

package/src/__tests__/jest.setup.ts

@@ -15,6 +15,19 @@ import {
 } from "./helpers/mock-cfetch";
 import { MockWebSocket } from "./helpers/mock-web-socket";
 
+/**
+ * The relative path between the bundled code and the Wrangler package.
+ * This is used as a reliable way to compute paths relative to the Wrangler package
+ * in the source files, rather than relying upon `__dirname` which can change depending
+ * on whether the source files have been bundled and the location of the outdir.
+ *
+ * This is exposed in the source via the `getBasePath()` function, which should be used
+ * in place of `__dirname` and similar Node.js constants.
+ */
+(
+	global as unknown as { __RELATIVE_PACKAGE_PATH__: string }
+).__RELATIVE_PACKAGE_PATH__ = "..";
+
 // Mock out getPort since we don't actually care about what ports are open in unit tests.
 jest.mock("get-port", () => {
 	return {