wrangler 0.0.0-e2a26a0 → 0.0.0-e2b7352

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wrangler",
-  "version": "0.0.0-e2a26a0",
+  "version": "0.0.0-e2b7352",
   "author": "wrangler@cloudflare.com",
   "description": "Command-line interface for all things Cloudflare Workers",
   "bin": {
@@ -36,27 +36,31 @@
     "cli"
   ],
   "dependencies": {
-    "esbuild": "0.14.14",
-    "miniflare": "2.2.0",
+    "esbuild": "0.14.23",
+    "miniflare": "2.3.0",
     "path-to-regexp": "^6.2.0",
+    "selfsigned": "^2.0.0",
     "semiver": "^1.1.0",
-    "xxhash-addon": "^1.4.0"
+    "xxhash-wasm": "^1.0.1"
   },
   "optionalDependencies": {
     "fsevents": "~2.3.2"
   },
   "devDependencies": {
-    "@babel/types": "^7.16.0",
     "@iarna/toml": "^2.2.5",
-    "@types/estree": "^0.0.50",
+    "@sentry/cli": "^1.71.0",
+    "@sentry/integrations": "^6.17.6",
+    "@sentry/node": "^6.17.6",
+    "@types/command-exists": "^1.2.0",
+    "@types/glob-to-regexp": "0.4.1",
     "@types/mime": "^2.0.3",
+    "@types/prompts": "^2.0.14",
     "@types/react": "^17.0.37",
     "@types/serve-static": "^1.13.10",
     "@types/signal-exit": "^3.0.1",
+    "@types/supports-color": "^8.1.1",
     "@types/ws": "^8.2.1",
     "@types/yargs": "^17.0.7",
-    "acorn": "^8.6.0",
-    "acorn-walk": "^8.2.0",
     "chokidar": "^3.5.2",
     "clipboardy": "^3.0.0",
     "cmd-shim": "^4.1.0",
@@ -66,6 +70,8 @@
     "faye-websocket": "^0.11.4",
     "finalhandler": "^1.1.2",
     "find-up": "^6.2.0",
+    "get-port": "^6.1.2",
+    "glob-to-regexp": "0.4.1",
     "ignore": "^5.2.0",
     "ink": "^3.2.0",
     "ink-select-input": "^4.2.1",
@@ -73,14 +79,17 @@
     "ink-testing-library": "^2.1.0",
     "ink-text-input": "^4.0.2",
     "jest-fetch-mock": "^3.0.3",
+    "jest-websocket-mock": "^2.3.0",
     "mime": "^3.0.0",
     "open": "^8.4.0",
+    "prompts": "^2.4.2",
     "react": "^17.0.2",
     "react-error-boundary": "^3.1.4",
     "serve-static": "^1.14.1",
     "signal-exit": "^3.0.6",
+    "supports-color": "^9.2.1",
     "tmp-promise": "^3.0.3",
-    "undici": "4.13.0",
+    "undici": "^4.15.1",
     "ws": "^8.3.0",
     "yargs": "^17.3.0"
   },
@@ -89,16 +98,18 @@
     "bin",
     "pages",
     "miniflare-config-stubs",
+    "miniflare-dist",
     "wrangler-dist",
     "templates",
     "vendor",
     "import_meta_url.js"
   ],
   "scripts": {
-    "clean": "rm -rf wrangler-dist",
+    "clean": "rm -rf wrangler-dist miniflare-dist",
     "check:type": "tsc",
     "bundle": "node -r esbuild-register scripts/bundle.ts",
     "build": "npm run clean && npm run bundle",
+    "prepublishOnly": "npm run build",
     "start": "npm run bundle && NODE_OPTIONS=--enable-source-maps ./bin/wrangler.js",
     "test": "jest --silent=false --verbose=true",
     "test-watch": "npm run test -- --runInBand --testTimeout=50000 --watch"
@@ -111,10 +122,11 @@
     "testTimeout": 30000,
     "testRegex": ".*.(test|spec)\\.[jt]sx?$",
     "transformIgnorePatterns": [
-      "node_modules/(?!find-up|locate-path|p-locate|p-limit|yocto-queue|path-exists|execa|strip-final-newline|npm-run-path|path-key|onetime|mimic-fn|human-signals|is-stream)"
+      "node_modules/(?!find-up|locate-path|p-locate|p-limit|yocto-queue|path-exists|execa|strip-final-newline|npm-run-path|path-key|onetime|mimic-fn|human-signals|is-stream|get-port|supports-color)"
     ],
     "moduleNameMapper": {
-      "clipboardy": "<rootDir>/src/__tests__/helpers/clipboardy-mock.js"
+      "clipboardy": "<rootDir>/src/__tests__/helpers/clipboardy-mock.js",
+      "miniflare/cli": "<rootDir>/../../node_modules/miniflare/dist/src/cli.js"
     },
     "transform": {
       "^.+\\.c?(t|j)sx?$": [

package/pages/functions/filepath-routing.test.ts

@@ -1,47 +1,223 @@
+import { writeFileSync, mkdirSync } from "fs";
+import { runInTempDir } from "../../src/__tests__/helpers/run-in-tmp";
 import { toUrlPath } from "../../src/paths";
-import { compareRoutes } from "./filepath-routing";
-
-describe("compareRoutes()", () => {
-  const url = toUrlPath;
-  test("routes / last", () => {
-    expect(compareRoutes([url("/")], [url("/foo")])).toBeGreaterThanOrEqual(1);
-    expect(compareRoutes([url("/")], [url("/:foo")])).toBeGreaterThanOrEqual(1);
-    expect(compareRoutes([url("/")], [url("/:foo*")])).toBeGreaterThanOrEqual(
-      1
-    );
-  });
+import { compareRoutes, generateConfigFromFileTree } from "./filepath-routing";
+import type { UrlPath } from "../../src/paths";
+import type { HTTPMethod, RouteConfig } from "./routes";
 
-  test("routes with fewer segments come after those with more segments", () => {
-    expect(
-      compareRoutes([url("/foo")], [url("/foo/bar")])
-    ).toBeGreaterThanOrEqual(1);
-    expect(
-      compareRoutes([url("/foo")], [url("/foo/bar/cat")])
-    ).toBeGreaterThanOrEqual(1);
-  });
+describe("filepath-routing", () => {
+  describe("compareRoutes()", () => {
+    test("routes / last", () => {
+      expect(
+        compareRoutes(routeConfig("/"), routeConfig("/foo"))
+      ).toBeGreaterThanOrEqual(1);
+      expect(
+        compareRoutes(routeConfig("/"), routeConfig("/:foo"))
+      ).toBeGreaterThanOrEqual(1);
+      expect(
+        compareRoutes(routeConfig("/"), routeConfig("/:foo*"))
+      ).toBeGreaterThanOrEqual(1);
+    });
 
-  test("routes with wildcard segments come after those without", () => {
-    expect(compareRoutes([url("/:foo*")], [url("/foo")])).toBe(1);
-    expect(compareRoutes([url("/:foo*")], [url("/:foo")])).toBe(1);
-  });
+    test("routes with fewer segments come after those with more segments", () => {
+      expect(
+        compareRoutes(routeConfig("/foo"), routeConfig("/foo/bar"))
+      ).toBeGreaterThanOrEqual(1);
+      expect(
+        compareRoutes(routeConfig("/foo"), routeConfig("/foo/bar/cat"))
+      ).toBeGreaterThanOrEqual(1);
+    });
 
-  test("routes with dynamic segments come after those without", () => {
-    expect(compareRoutes([url("/:foo")], [url("/foo")])).toBe(1);
-  });
+    test("routes with wildcard segments come after those without", () => {
+      expect(compareRoutes(routeConfig("/:foo*"), routeConfig("/foo"))).toBe(1);
+      expect(compareRoutes(routeConfig("/:foo*"), routeConfig("/:foo"))).toBe(
+        1
+      );
+    });
 
-  test("routes with dynamic segments occurring earlier come after those with dynamic segments in later positions", () => {
-    expect(compareRoutes([url("/foo/:id/bar")], [url("/foo/bar/:id")])).toBe(1);
-  });
+    test("routes with dynamic segments come after those without", () => {
+      expect(compareRoutes(routeConfig("/:foo"), routeConfig("/foo"))).toBe(1);
+    });
 
-  test("routes with no HTTP method come after those specifying a method", () => {
-    expect(compareRoutes([url("/foo")], [url("/foo"), "GET"])).toBe(1);
-  });
+    test("routes with dynamic segments occurring earlier come after those with dynamic segments in later positions", () => {
+      expect(
+        compareRoutes(routeConfig("/foo/:id/bar"), routeConfig("/foo/bar/:id"))
+      ).toBe(1);
+    });
+
+    test("routes with no HTTP method come after those specifying a method", () => {
+      expect(
+        compareRoutes(routeConfig("/foo"), routeConfig("/foo", "GET"))
+      ).toBe(1);
+    });
+
+    test("two equal routes are sorted according to their original position in the list", () => {
+      expect(
+        compareRoutes(routeConfig("/foo", "GET"), routeConfig("/foo", "GET"))
+      ).toBe(0);
+    });
 
-  test("two equal routes are sorted according to their original position in the list", () => {
-    expect(compareRoutes([url("/foo"), "GET"], [url("/foo"), "GET"])).toBe(0);
+    test("it returns -1 if the first argument should appear first in the list", () => {
+      expect(
+        compareRoutes(routeConfig("/foo", "GET"), routeConfig("/foo"))
+      ).toBe(-1);
+    });
   });
 
-  test("it returns -1 if the first argument should appear first in the list", () => {
-    expect(compareRoutes([url("/foo"), "GET"], [url("/foo")])).toBe(-1);
+  describe("generateConfigFromFileTree", () => {
+    runInTempDir();
+
+    it("should generate a route entry for each file in the tree", async () => {
+      writeFileSync(
+        "foo.ts",
+        `
+      export function onRequestGet() {}
+      export function onRequestPost() {}
+      `
+      );
+      writeFileSync(
+        "bar.ts",
+        `
+      export function onRequestPut() {}
+      export function onRequestDelete() {}
+      `
+      );
+
+      mkdirSync("todos");
+
+      writeFileSync(
+        "todos/[id].ts",
+        `
+      export function onRequestPost() {}
+      export function onRequestDelete() {}
+      `
+      );
+
+      mkdirSync("authors");
+      mkdirSync("authors/[authorId]");
+      mkdirSync("authors/[authorId]/todos");
+
+      writeFileSync(
+        "authors/[authorId]/todos/[todoId].ts",
+        `
+      export function onRequestPost() {}
+      `
+      );
+
+      mkdirSync("books");
+
+      writeFileSync(
+        "books/[[title]].ts",
+        `
+      export function onRequestPost() {}
+      `
+      );
+
+      mkdirSync("cats");
+      mkdirSync("cats/[[breed]]");
+
+      writeFileSync(
+        "cats/[[breed]]/blah.ts",
+        `
+      export function onRequestPost() {}
+      `
+      );
+
+      // This won't actually work at runtime.
+      writeFileSync(
+        "cats/[[breed]]/[[name]].ts",
+        `
+      export function onRequestPost() {}
+      `
+      );
+
+      const entries = await generateConfigFromFileTree({
+        baseDir: ".",
+        baseURL: "/base" as UrlPath,
+      });
+      expect(entries).toMatchInlineSnapshot(`
+        Object {
+          "routes": Array [
+            Object {
+              "method": "POST",
+              "module": Array [
+                "authors/[authorId]/todos/[todoId].ts:onRequestPost",
+              ],
+              "routePath": "/base/authors/:authorId/todos/:todoId",
+            },
+            Object {
+              "method": "POST",
+              "module": Array [
+                "cats/[[breed]]/blah.ts:onRequestPost",
+              ],
+              "routePath": "/base/cats/:breed*/blah",
+            },
+            Object {
+              "method": "POST",
+              "module": Array [
+                "cats/[[breed]]/[[name]].ts:onRequestPost",
+              ],
+              "routePath": "/base/cats/:breed*/:name*",
+            },
+            Object {
+              "method": "DELETE",
+              "module": Array [
+                "todos/[id].ts:onRequestDelete",
+              ],
+              "routePath": "/base/todos/:id",
+            },
+            Object {
+              "method": "POST",
+              "module": Array [
+                "todos/[id].ts:onRequestPost",
+              ],
+              "routePath": "/base/todos/:id",
+            },
+            Object {
+              "method": "POST",
+              "module": Array [
+                "books/[[title]].ts:onRequestPost",
+              ],
+              "routePath": "/base/books/:title*",
+            },
+            Object {
+              "method": "DELETE",
+              "module": Array [
+                "bar.ts:onRequestDelete",
+              ],
+              "routePath": "/base/bar",
+            },
+            Object {
+              "method": "PUT",
+              "module": Array [
+                "bar.ts:onRequestPut",
+              ],
+              "routePath": "/base/bar",
+            },
+            Object {
+              "method": "GET",
+              "module": Array [
+                "foo.ts:onRequestGet",
+              ],
+              "routePath": "/base/foo",
+            },
+            Object {
+              "method": "POST",
+              "module": Array [
+                "foo.ts:onRequestPost",
+              ],
+              "routePath": "/base/foo",
+            },
+          ],
+        }
+      `);
+    });
   });
 });
+
+function routeConfig(routePath: string, method?: string): RouteConfig {
+  return {
+    routePath: toUrlPath(routePath),
+    method: method as HTTPMethod,
+  };
+}

package/pages/functions/filepath-routing.ts

@@ -1,26 +1,18 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import * as acorn from "acorn";
-import * as acornWalk from "acorn-walk";
-import { transform } from "esbuild";
+import { build } from "esbuild";
 import { toUrlPath } from "../../src/paths";
 import type { UrlPath } from "../../src/paths";
-import type { Config, RouteConfig } from "./routes";
-import type { ExportNamedDeclaration, Identifier } from "estree";
-
-type Arguments = {
-  baseDir: string;
-  baseURL: UrlPath;
-};
-
-type Method = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD";
-type RouteKey = [UrlPath, Method] | [UrlPath, undefined] | [UrlPath];
+import type { HTTPMethod, RouteConfig } from "./routes";
 
 export async function generateConfigFromFileTree({
   baseDir,
   baseURL,
-}: Arguments) {
-  let routeEntries: [RouteKey, RouteConfig][] = [];
+}: {
+  baseDir: string;
+  baseURL: UrlPath;
+}) {
+  let routeEntries: RouteConfig[] = [];
 
   if (!baseURL.startsWith("/")) {
     baseURL = `/${baseURL}` as UrlPath;
@@ -33,137 +25,95 @@ export async function generateConfigFromFileTree({
   await forEachFile(baseDir, async (filepath) => {
     const ext = path.extname(filepath);
     if (/^\.(mjs|js|ts|tsx|jsx)$/.test(ext)) {
-      // transform the code to ensure we're working with vanilla JS + ESM
-      const { code } = await transform(await fs.readFile(filepath, "utf-8"), {
-        loader: ext === ".ts" ? "ts" : "js",
+      const { metafile } = await build({
+        metafile: true,
+        write: false,
+        bundle: false,
+        entryPoints: [path.resolve(filepath)],
       });
+      const exportNames: string[] = [];
+      if (metafile) {
+        for (const output in metafile?.outputs) {
+          exportNames.push(...metafile.outputs[output].exports);
+        }
+      }
+      for (const exportName of exportNames) {
+        const [match, method = ""] = (exportName.match(
+          /^onRequest(Get|Post|Put|Patch|Delete|Options|Head)?$/
+        ) ?? []) as (string | undefined)[];
 
-      // parse each file into an AST and search for module exports that match "onRequest" and friends
-      const ast = acorn.parse(code, {
-        ecmaVersion: "latest",
-        sourceType: "module",
-      });
-      acornWalk.simple(ast, {
-        ExportNamedDeclaration(_node: unknown) {
-          // This dynamic cast assumes that the AST generated by acornWalk will generate nodes that
-          // are compatible with the eslint AST nodes.
-          const node = _node as ExportNamedDeclaration;
-
-          // this is an array because multiple things can be exported from a single statement
-          // i.e. `export {foo, bar}` or `export const foo = "f", bar = "b"`
-          const exportNames: string[] = [];
-
-          if (node.declaration) {
-            const declaration = node.declaration;
-
-            // `export async function onRequest() {...}`
-            if (declaration.type === "FunctionDeclaration" && declaration.id) {
-              exportNames.push(declaration.id.name);
-            }
-
-            // `export const onRequestGet = () => {}, onRequestPost = () => {}`
-            if (declaration.type === "VariableDeclaration") {
-              exportNames.push(
-                ...declaration.declarations.map(
-                  (variableDeclarator) =>
-                    (variableDeclarator.id as unknown as Identifier).name
-                )
-              );
-            }
-          }
+        if (match) {
+          const basename = path.basename(filepath).slice(0, -ext.length);
+
+          const isIndexFile = basename === "index";
+          // TODO: deprecate _middleware_ in favor of _middleware
+          const isMiddlewareFile =
+            basename === "_middleware" || basename === "_middleware_";
 
-          // `export {foo, bar}`
-          if (node.specifiers.length) {
-            exportNames.push(
-              ...node.specifiers.map(
-                (exportSpecifier) =>
-                  (exportSpecifier.exported as unknown as Identifier).name
-              )
-            );
+          let routePath = path
+            .relative(baseDir, filepath)
+            .slice(0, -ext.length);
+
+          if (isIndexFile || isMiddlewareFile) {
+            routePath = path.dirname(routePath);
           }
 
-          for (const exportName of exportNames) {
-            const [match, method] =
-              exportName.match(
-                /^onRequest(Get|Post|Put|Patch|Delete|Options|Head)?$/
-              ) ?? [];
-
-            if (match) {
-              const basename = path.basename(filepath).slice(0, -ext.length);
-
-              const isIndexFile = basename === "index";
-              // TODO: deprecate _middleware_ in favor of _middleware
-              const isMiddlewareFile =
-                basename === "_middleware" || basename === "_middleware_";
-
-              let routePath = path
-                .relative(baseDir, filepath)
-                .slice(0, -ext.length);
-
-              if (isIndexFile || isMiddlewareFile) {
-                routePath = path.dirname(routePath);
-              }
-
-              if (routePath === ".") {
-                routePath = "";
-              }
-
-              routePath = `${baseURL}/${routePath}`;
-
-              routePath = routePath.replace(/\[\[(.+)]]/g, ":$1*"); // transform [[id]] => :id*
-              routePath = routePath.replace(/\[(.+)]/g, ":$1"); // transform [id] => :id
-
-              const routeUrlPath = toUrlPath(routePath);
-              const routeKey: RouteKey = [
-                routeUrlPath,
-                method ? (method.toUpperCase() as Method) : undefined,
-              ];
-
-              routeEntries.push([
-                routeKey,
-                {
-                  [isMiddlewareFile ? "middleware" : "module"]: [
-                    `${path.relative(baseDir, filepath)}:${exportName}`,
-                  ],
-                },
-              ]);
-            }
+          if (routePath === ".") {
+            routePath = "";
           }
-        },
-      });
+
+          routePath = `${baseURL}/${routePath}`;
+
+          routePath = routePath.replace(/\[\[([^\]]+)\]\]/g, ":$1*"); // transform [[id]] => :id*
+          routePath = routePath.replaceAll(/\[([^\]]+)\]/g, ":$1"); // transform [id] => :id
+
+          // These are used as module specifiers so UrlPaths are okay to use even on Windows
+          const modulePath = toUrlPath(path.relative(baseDir, filepath));
+
+          const routeEntry: RouteConfig = {
+            routePath: toUrlPath(routePath),
+            method: method.toUpperCase() as HTTPMethod,
+            [isMiddlewareFile ? "middleware" : "module"]: [
+              `${modulePath}:${exportName}`,
+            ],
+          };
+
+          routeEntries.push(routeEntry);
+        }
+      }
     }
   });
-
   // Combine together any routes (index routes) which contain both a module and a middleware
   routeEntries = routeEntries.reduce(
-    (acc: typeof routeEntries, [routePath, routeHandler]) => {
+    (acc: typeof routeEntries, { routePath, ...rest }) => {
       const existingRouteEntry = acc.find(
-        (routeEntry) => routeEntry[0] === routePath
+        (routeEntry) =>
+          routeEntry.routePath === routePath &&
+          routeEntry.method === rest.method
       );
       if (existingRouteEntry !== undefined) {
-        existingRouteEntry[1] = {
-          ...existingRouteEntry[1],
-          ...routeHandler,
-        };
+        Object.assign(existingRouteEntry, rest);
       } else {
-        acc.push([routePath, routeHandler]);
+        acc.push({ routePath, ...rest });
       }
       return acc;
     },
     []
   );
 
-  routeEntries.sort(([a], [b]) => compareRoutes(a, b));
+  routeEntries.sort((a, b) => compareRoutes(a, b));
 
-  return { routes: Object.fromEntries(routeEntries) } as Config;
+  return {
+    routes: routeEntries,
+  };
 }
 
 // Ensure routes are produced in order of precedence so that
 // more specific routes aren't occluded from matching due to
 // less specific routes appearing first in the route list.
 export function compareRoutes(
-  [routePathA, methodA]: RouteKey,
-  [routePathB, methodB]: RouteKey
+  { routePath: routePathA, method: methodA }: RouteConfig,
+  { routePath: routePathB, method: methodB }: RouteConfig
 ) {
   function parseRoutePath(routePath: UrlPath): string[] {
     return routePath.slice(1).split("/").filter(Boolean);

package/pages/functions/routes.ts

@@ -1,6 +1,5 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { toUrlPath } from "../../src/paths";
 import { isValidIdentifier, normalizeIdentifier } from "./identifiers";
 import type { UrlPath } from "../../src/paths";
 
@@ -22,21 +21,19 @@ export function isHTTPMethod(
 
 export type RoutesCollection = Array<{
   routePath: UrlPath;
-  methods: HTTPMethod[];
+  method?: HTTPMethod;
   modules: string[];
   middlewares: string[];
 }>;
 
 export type Config = {
-  routes?: RoutesConfig;
+  routes?: RouteConfig[];
   schedules?: unknown;
 };
 
-export type RoutesConfig = {
-  [route: UrlPath]: RouteConfig;
-};
-
 export type RouteConfig = {
+  routePath: UrlPath;
+  method?: HTTPMethod;
   middleware?: string | string[];
   module?: string | string[];
 };
@@ -116,16 +113,10 @@ export function parseConfig(config: Config, baseDir: string) {
     });
   }
 
-  for (const [route, props] of Object.entries(config.routes ?? {})) {
-    let [_methods, routePath] = route.split(" ");
-    if (!routePath) {
-      routePath = _methods;
-      _methods = "";
-    }
-
+  for (const { routePath, method, ...props } of config.routes ?? []) {
     routes.push({
-      routePath: toUrlPath(routePath),
-      methods: _methods.split("|").filter(isHTTPMethod),
+      routePath,
+      method,
       middlewares: parseModuleIdentifiers(props.middleware),
       modules: parseModuleIdentifiers(props.module),
     });
@@ -150,7 +141,7 @@ export const routes = [
     .map(
       (route) => `  {
       routePath: "${route.routePath}",
-      methods: ${JSON.stringify(route.methods)},
+      method: "${route.method}",
       middlewares: [${route.middlewares.join(", ")}],
       modules: [${route.modules.join(", ")}],
     },`