wrangler 0.0.0-e88a54e → 0.0.0-e95e5a0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wrangler",
-  "version": "0.0.0-e88a54e",
+  "version": "0.0.0-e95e5a0",
   "author": "wrangler@cloudflare.com",
   "description": "Command-line interface for all things Cloudflare Workers",
   "bin": {
@@ -36,10 +36,14 @@
     "cli"
   ],
   "dependencies": {
-    "esbuild": "0.14.23",
-    "miniflare": "2.3.0",
+    "@esbuild-plugins/node-globals-polyfill": "^0.1.1",
+    "@esbuild-plugins/node-modules-polyfill": "^0.1.4",
+    "blake3-wasm": "^2.1.5",
+    "esbuild": "0.14.34",
+    "miniflare": "2.4.0",
+    "nanoid": "^3.3.3",
     "path-to-regexp": "^6.2.0",
-    "selfsigned": "^2.0.0",
+    "selfsigned": "^2.0.1",
     "semiver": "^1.1.0",
     "xxhash-wasm": "^1.0.1"
   },
@@ -47,53 +51,54 @@
     "fsevents": "~2.3.2"
   },
   "devDependencies": {
-    "@iarna/toml": "^2.2.5",
-    "@sentry/cli": "^1.71.0",
-    "@sentry/integrations": "^6.17.6",
-    "@sentry/node": "^6.17.6",
+    "@iarna/toml": "^3.0.0",
     "@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/react-test-renderer": "^17.0.1",
     "@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",
-    "chokidar": "^3.5.2",
+    "@types/ws": "^8.5.3",
+    "@types/yargs": "^17.0.10",
+    "chokidar": "^3.5.3",
     "clipboardy": "^3.0.0",
     "cmd-shim": "^4.1.0",
     "command-exists": "^1.2.9",
     "devtools-protocol": "^0.0.955664",
-    "execa": "^6.0.0",
+    "dotenv": "^16.0.0",
+    "execa": "^6.1.0",
     "faye-websocket": "^0.11.4",
-    "finalhandler": "^1.1.2",
-    "find-up": "^6.2.0",
+    "finalhandler": "^1.2.0",
+    "find-up": "^6.3.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",
+    "ink-spinner": "^4.0.3",
     "ink-table": "^3.0.0",
     "ink-testing-library": "^2.1.0",
-    "ink-text-input": "^4.0.2",
+    "ink-text-input": "^4.0.3",
     "jest-fetch-mock": "^3.0.3",
     "jest-websocket-mock": "^2.3.0",
     "mime": "^3.0.0",
     "open": "^8.4.0",
+    "pretty-bytes": "^6.0.0",
     "prompts": "^2.4.2",
     "react": "^17.0.2",
     "react-error-boundary": "^3.1.4",
-    "react-test-renderer": "^17.0.2",
-    "serve-static": "^1.14.1",
-    "signal-exit": "^3.0.6",
-    "supports-color": "^9.2.1",
+    "serve-static": "^1.15.0",
+    "signal-exit": "^3.0.7",
+    "supports-color": "^9.2.2",
+    "timeago.js": "^4.0.2",
     "tmp-promise": "^3.0.3",
+    "ts-dedent": "^2.2.0",
     "undici": "^4.15.1",
-    "ws": "^8.3.0",
-    "yargs": "^17.3.0"
+    "update-check": "^1.5.4",
+    "ws": "^8.5.0",
+    "yargs": "^17.4.1"
   },
   "files": [
     "src",
@@ -111,7 +116,7 @@
     "check:type": "tsc",
     "bundle": "node -r esbuild-register scripts/bundle.ts",
     "build": "npm run clean && npm run bundle",
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "SOURCEMAPS=false 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"
@@ -124,7 +129,7 @@
     "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|get-port|supports-color)"
+      "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|pretty-bytes)"
     ],
     "moduleNameMapper": {
       "clipboardy": "<rootDir>/src/__tests__/helpers/clipboardy-mock.js",

package/pages/functions/buildPlugin.ts

@@ -0,0 +1,92 @@
+import { access, lstat } from "node:fs/promises";
+import { dirname, relative, resolve } from "node:path";
+import { build } from "esbuild";
+
+type Options = {
+  routesModule: string;
+  outfile: string;
+  minify?: boolean;
+  sourcemap?: boolean;
+  watch?: boolean;
+  onEnd?: () => void;
+};
+
+export function buildPlugin({
+  routesModule,
+  outfile = "bundle.js",
+  minify = false,
+  sourcemap = false,
+  watch = false,
+  onEnd = () => {},
+}: Options) {
+  return build({
+    entryPoints: [resolve(__dirname, "../pages/functions/template-plugin.ts")],
+    inject: [routesModule],
+    bundle: true,
+    format: "esm",
+    target: "esnext",
+    outfile,
+    minify,
+    sourcemap,
+    watch,
+    allowOverwrite: true,
+    plugins: [
+      {
+        name: "wrangler notifier and monitor",
+        setup(pluginBuild) {
+          pluginBuild.onEnd((result) => {
+            if (result.errors.length > 0) {
+              console.error(
+                `${result.errors.length} error(s) and ${result.warnings.length} warning(s) when compiling Worker.`
+              );
+            } else if (result.warnings.length > 0) {
+              console.warn(
+                `${result.warnings.length} warning(s) when compiling Worker.`
+              );
+              onEnd();
+            } else {
+              console.log("Compiled Worker successfully.");
+              onEnd();
+            }
+          });
+        },
+      },
+      {
+        name: "Assets",
+        setup(pluginBuild) {
+          if (pluginBuild.initialOptions.outfile) {
+            const outdir = dirname(pluginBuild.initialOptions.outfile);
+
+            pluginBuild.onResolve({ filter: /^assets:/ }, async (args) => {
+              const directory = resolve(
+                args.resolveDir,
+                args.path.slice("assets:".length)
+              );
+
+              const exists = await access(directory)
+                .then(() => true)
+                .catch(() => false);
+
+              const isDirectory =
+                exists && (await lstat(directory)).isDirectory();
+
+              if (!isDirectory) {
+                return {
+                  errors: [
+                    {
+                      text: `'${directory}' does not exist or is not a directory.`,
+                    },
+                  ],
+                };
+              }
+
+              const path = `assets:./${relative(outdir, directory)}`;
+
+              return { path, external: true, namespace: "assets" };
+            });
+          }
+        },
+      },
+    ],
+  });
+}

package/pages/functions/buildWorker.ts

@@ -1,5 +1,7 @@
-import path from "node:path";
+import { access, cp, lstat, rm } from "node:fs/promises";
+import { join, resolve } from "node:path";
 import { build } from "esbuild";
+import { nanoid } from "nanoid";
 
 type Options = {
   routesModule: string;
@@ -9,6 +11,7 @@ type Options = {
   fallbackService?: string;
   watch?: boolean;
   onEnd?: () => void;
+  buildOutputDirectory?: string;
 };
 
 export function buildWorker({
@@ -19,11 +22,10 @@ export function buildWorker({
   fallbackService = "ASSETS",
   watch = false,
   onEnd = () => {},
+  buildOutputDirectory,
 }: Options) {
   return build({
-    entryPoints: [
-      path.resolve(__dirname, "../pages/functions/template-worker.ts"),
-    ],
+    entryPoints: [resolve(__dirname, "../pages/functions/template-worker.ts")],
     inject: [routesModule],
     bundle: true,
     format: "esm",
@@ -57,6 +59,80 @@ export function buildWorker({
           });
         },
       },
+      {
+        name: "Assets",
+        setup(pluginBuild) {
+          const identifiers = new Map<string, string>();
+
+          pluginBuild.onResolve({ filter: /^assets:/ }, async (args) => {
+            const directory = resolve(
+              args.resolveDir,
+              args.path.slice("assets:".length)
+            );
+
+            const exists = await access(directory)
+              .then(() => true)
+              .catch(() => false);
+
+            const isDirectory =
+              exists && (await lstat(directory)).isDirectory();
+
+            if (!isDirectory) {
+              return {
+                errors: [
+                  {
+                    text: `'${directory}' does not exist or is not a directory.`,
+                  },
+                ],
+              };
+            }
+
+            // TODO: Consider hashing the contents rather than using a unique identifier every time?
+            identifiers.set(directory, nanoid());
+            if (!buildOutputDirectory) {
+              console.warn(
+                "You're attempting to import static assets as part of your Pages Functions, but have not specified a directory in which to put them. You must use 'wrangler pages dev <directory>' rather than 'wrangler pages dev -- <command>' to import static assets in Functions."
+              );
+            }
+            return { path: directory, namespace: "assets" };
+          });
+
+          pluginBuild.onLoad(
+            { filter: /.*/, namespace: "assets" },
+            async (args) => {
+              const identifier = identifiers.get(args.path);
+
+              if (buildOutputDirectory) {
+                const staticAssetsOutputDirectory = join(
+                  buildOutputDirectory,
+                  "cdn-cgi",
+                  "pages-plugins",
+                  identifier as string
+                );
+                await rm(staticAssetsOutputDirectory, {
+                  force: true,
+                  recursive: true,
+                });
+                await cp(args.path, staticAssetsOutputDirectory, {
+                  force: true,
+                  recursive: true,
+                });
+
+                return {
+                  // TODO: Watch args.path for changes and re-copy when updated
+                  contents: `export const onRequest = ({ request, env, functionPath }) => {
+                    const url = new URL(request.url)
+                    const relativePathname = url.pathname.split(functionPath)[1] || "/";
+                    url.pathname = '/cdn-cgi/pages-plugins/${identifier}' + relativePathname
+                    request = new Request(url.toString(), request)
+                    return env.ASSETS.fetch(request)
+                  }`,
+                };
+              }
+            }
+          );
+        },
+      },
     ],
   });
 }

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

@@ -143,6 +143,7 @@ describe("filepath-routing", () => {
               "module": Array [
                 "authors/[authorId]/todos/[todoId].ts:onRequestPost",
               ],
+              "mountPath": "/base/authors/:authorId/todos",
               "routePath": "/base/authors/:authorId/todos/:todoId",
             },
             Object {
@@ -150,6 +151,7 @@ describe("filepath-routing", () => {
               "module": Array [
                 "cats/[[breed]]/blah.ts:onRequestPost",
               ],
+              "mountPath": "/base/cats/:breed*",
               "routePath": "/base/cats/:breed*/blah",
             },
             Object {
@@ -157,6 +159,7 @@ describe("filepath-routing", () => {
               "module": Array [
                 "cats/[[breed]]/[[name]].ts:onRequestPost",
               ],
+              "mountPath": "/base/cats/:breed*",
               "routePath": "/base/cats/:breed*/:name*",
             },
             Object {
@@ -164,6 +167,7 @@ describe("filepath-routing", () => {
               "module": Array [
                 "todos/[id].ts:onRequestDelete",
               ],
+              "mountPath": "/base/todos",
               "routePath": "/base/todos/:id",
             },
             Object {
@@ -171,6 +175,7 @@ describe("filepath-routing", () => {
               "module": Array [
                 "todos/[id].ts:onRequestPost",
               ],
+              "mountPath": "/base/todos",
               "routePath": "/base/todos/:id",
             },
             Object {
@@ -178,6 +183,7 @@ describe("filepath-routing", () => {
               "module": Array [
                 "books/[[title]].ts:onRequestPost",
               ],
+              "mountPath": "/base/books",
               "routePath": "/base/books/:title*",
             },
             Object {
@@ -185,6 +191,7 @@ describe("filepath-routing", () => {
               "module": Array [
                 "bar.ts:onRequestDelete",
               ],
+              "mountPath": "/base/",
               "routePath": "/base/bar",
             },
             Object {
@@ -192,6 +199,7 @@ describe("filepath-routing", () => {
               "module": Array [
                 "bar.ts:onRequestPut",
               ],
+              "mountPath": "/base/",
               "routePath": "/base/bar",
             },
             Object {
@@ -199,6 +207,7 @@ describe("filepath-routing", () => {
               "module": Array [
                 "foo.ts:onRequestGet",
               ],
+              "mountPath": "/base/",
               "routePath": "/base/foo",
             },
             Object {
@@ -206,6 +215,7 @@ describe("filepath-routing", () => {
               "module": Array [
                 "foo.ts:onRequestPost",
               ],
+              "mountPath": "/base/",
               "routePath": "/base/foo",
             },
           ],
@@ -218,6 +228,7 @@ describe("filepath-routing", () => {
 function routeConfig(routePath: string, method?: string): RouteConfig {
   return {
     routePath: toUrlPath(routePath),
+    mountPath: toUrlPath("/"),
     method: method as HTTPMethod,
   };
 }

package/pages/functions/filepath-routing.ts

@@ -53,6 +53,7 @@ export async function generateConfigFromFileTree({
           let routePath = path
             .relative(baseDir, filepath)
             .slice(0, -ext.length);
+          let mountPath = path.dirname(routePath);
 
           if (isIndexFile || isMiddlewareFile) {
             routePath = path.dirname(routePath);
@@ -61,17 +62,24 @@ export async function generateConfigFromFileTree({
           if (routePath === ".") {
             routePath = "";
           }
+          if (mountPath === ".") {
+            mountPath = "";
+          }
 
           routePath = `${baseURL}/${routePath}`;
+          mountPath = `${baseURL}/${mountPath}`;
 
           routePath = routePath.replace(/\[\[([^\]]+)\]\]/g, ":$1*"); // transform [[id]] => :id*
           routePath = routePath.replaceAll(/\[([^\]]+)\]/g, ":$1"); // transform [id] => :id
+          mountPath = mountPath.replace(/\[\[([^\]]+)\]\]/g, ":$1*"); // transform [[id]] => :id*
+          mountPath = mountPath.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),
+            mountPath: toUrlPath(mountPath),
             method: method.toUpperCase() as HTTPMethod,
             [isMiddlewareFile ? "middleware" : "module"]: [
               `${modulePath}:${exportName}`,

package/pages/functions/routes.ts

@@ -21,6 +21,7 @@ export function isHTTPMethod(
 
 export type RoutesCollection = Array<{
   routePath: UrlPath;
+  mountPath: UrlPath;
   method?: HTTPMethod;
   modules: string[];
   middlewares: string[];
@@ -33,6 +34,7 @@ export type Config = {
 
 export type RouteConfig = {
   routePath: UrlPath;
+  mountPath: UrlPath;
   method?: HTTPMethod;
   middleware?: string | string[];
   module?: string | string[];
@@ -113,9 +115,11 @@ export function parseConfig(config: Config, baseDir: string) {
     });
   }
 
-  for (const { routePath, method, ...props } of config.routes ?? []) {
+  for (const { routePath, mountPath, method, ...props } of config.routes ??
+    []) {
     routes.push({
       routePath,
+      mountPath,
       method,
       middlewares: parseModuleIdentifiers(props.middleware),
       modules: parseModuleIdentifiers(props.module),
@@ -141,6 +145,7 @@ export const routes = [
     .map(
       (route) => `  {
       routePath: "${route.routePath}",
+      mountPath: "${route.mountPath}",
       method: "${route.method}",
       middlewares: [${route.middlewares.join(", ")}],
       modules: [${route.modules.join(", ")}],

package/pages/functions/template-plugin.ts

@@ -0,0 +1,146 @@
+import { match } from "path-to-regexp";
+import type { HTTPMethod } from "./routes";
+
+/* TODO: Grab these from @cloudflare/workers-types instead */
+type Params<P extends string = string> = Record<P, string | string[]>;
+
+type EventContext<Env, P extends string, Data> = {
+  request: Request;
+  functionPath: string;
+  waitUntil: (promise: Promise<unknown>) => void;
+  next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
+  env: Env & { ASSETS: { fetch: typeof fetch } };
+  params: Params<P>;
+  data: Data;
+};
+
+type EventPluginContext<Env, P extends string, Data, PluginArgs> = {
+  request: Request;
+  functionPath: string;
+  waitUntil: (promise: Promise<unknown>) => void;
+  next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
+  env: Env & { ASSETS: { fetch: typeof fetch } };
+  params: Params<P>;
+  data: Data;
+  pluginArgs: PluginArgs;
+};
+
+declare type PagesFunction<
+  Env = unknown,
+  P extends string = string,
+  Data extends Record<string, unknown> = Record<string, unknown>
+> = (context: EventContext<Env, P, Data>) => Response | Promise<Response>;
+
+declare type PagesPluginFunction<
+  Env = unknown,
+  P extends string = string,
+  Data extends Record<string, unknown> = Record<string, unknown>,
+  PluginArgs = unknown
+> = (
+  context: EventPluginContext<Env, P, Data, PluginArgs>
+) => Response | Promise<Response>;
+/* end @cloudflare/workers-types */
+
+type RouteHandler = {
+  routePath: string;
+  mountPath: string;
+  method?: HTTPMethod;
+  modules: PagesFunction[];
+  middlewares: PagesFunction[];
+};
+
+// inject `routes` via ESBuild
+declare const routes: RouteHandler[];
+
+function* executeRequest(request: Request, relativePathname: string) {
+  // First, iterate through the routes (backwards) and execute "middlewares" on partial route matches
+  for (const route of [...routes].reverse()) {
+    if (route.method && route.method !== request.method) {
+      continue;
+    }
+
+    const routeMatcher = match(route.routePath, { end: false });
+    const mountMatcher = match(route.mountPath, { end: false });
+    const matchResult = routeMatcher(relativePathname);
+    const mountMatchResult = mountMatcher(relativePathname);
+    if (matchResult && mountMatchResult) {
+      for (const handler of route.middlewares.flat()) {
+        yield {
+          handler,
+          params: matchResult.params as Params,
+          path: mountMatchResult.path,
+        };
+      }
+    }
+  }
+
+  // Then look for the first exact route match and execute its "modules"
+  for (const route of routes) {
+    if (route.method && route.method !== request.method) {
+      continue;
+    }
+
+    const routeMatcher = match(route.routePath, { end: true });
+    const mountMatcher = match(route.mountPath, { end: false });
+    const matchResult = routeMatcher(relativePathname);
+    const mountMatchResult = mountMatcher(relativePathname);
+    if (matchResult && mountMatchResult && route.modules.length) {
+      for (const handler of route.modules.flat()) {
+        yield {
+          handler,
+          params: matchResult.params as Params,
+          path: matchResult.path,
+        };
+      }
+      break;
+    }
+  }
+}
+
+export default function (pluginArgs) {
+  const onRequest: PagesPluginFunction = async (workerContext) => {
+    let { request } = workerContext;
+    const { env, next, data } = workerContext;
+
+    const url = new URL(request.url);
+    const relativePathname =
+      url.pathname.split(workerContext.functionPath)[1] || "/";
+
+    const handlerIterator = executeRequest(request, relativePathname);
+    const pluginNext = async (input?: RequestInfo, init?: RequestInit) => {
+      if (input !== undefined) {
+        request = new Request(input, init);
+      }
+
+      const result = handlerIterator.next();
+      // Note we can't use `!result.done` because this doesn't narrow to the correct type
+      if (result.done === false) {
+        const { handler, params, path } = result.value;
+        const context = {
+          request,
+          functionPath: workerContext.functionPath + path,
+          next: pluginNext,
+          params,
+          data,
+          pluginArgs,
+          env,
+          waitUntil: workerContext.waitUntil.bind(workerContext),
+        };
+
+        const response = await handler(context);
+
+        // https://fetch.spec.whatwg.org/#null-body-status
+        return new Response(
+          [101, 204, 205, 304].includes(response.status) ? null : response.body,
+          { ...response, headers: new Headers(response.headers) }
+        );
+      } else {
+        return next();
+      }
+    };
+
+    return pluginNext();
+  };
+
+  return onRequest;
+}