wrangler 0.0.0-e2a26a0 → 0.0.0-e322475

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,103 @@ 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",
-      });
-
-      // 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",
+      const { metafile } = await build({
+        metafile: true,
+        write: false,
+        bundle: false,
+        entryPoints: [path.resolve(filepath)],
       });
-      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
-                )
-              );
-            }
+      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)[];
+
+        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);
+          let mountPath = path.dirname(routePath);
+
+          if (isIndexFile || isMiddlewareFile) {
+            routePath = path.dirname(routePath);
           }
 
-          // `export {foo, bar}`
-          if (node.specifiers.length) {
-            exportNames.push(
-              ...node.specifiers.map(
-                (exportSpecifier) =>
-                  (exportSpecifier.exported as unknown as Identifier).name
-              )
-            );
+          if (routePath === ".") {
+            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 (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}`,
+            ],
+          };
+
+          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,21 @@ export function isHTTPMethod(
 
 export type RoutesCollection = Array<{
   routePath: UrlPath;
-  methods: HTTPMethod[];
+  mountPath: UrlPath;
+  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;
+  mountPath: UrlPath;
+  method?: HTTPMethod;
   middleware?: string | string[];
   module?: string | string[];
 };
@@ -116,16 +115,12 @@ 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, mountPath, method, ...props } of config.routes ??
+    []) {
     routes.push({
-      routePath: toUrlPath(routePath),
-      methods: _methods.split("|").filter(isHTTPMethod),
+      routePath,
+      mountPath,
+      method,
       middlewares: parseModuleIdentifiers(props.middleware),
       modules: parseModuleIdentifiers(props.module),
     });
@@ -150,7 +145,8 @@ export const routes = [
     .map(
       (route) => `  {
       routePath: "${route.routePath}",
-      methods: ${JSON.stringify(route.methods)},
+      mountPath: "${route.mountPath}",
+      method: "${route.method}",
       middlewares: [${route.middlewares.join(", ")}],
       modules: [${route.modules.join(", ")}],
     },`

package/pages/functions/template-plugin.ts

@@ -0,0 +1,147 @@
+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] || ""
+    }`.replace(/^\/\//, "/");
+
+    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;
+}

package/pages/functions/template-worker.ts

@@ -6,6 +6,7 @@ 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 } };
@@ -22,7 +23,8 @@ declare type PagesFunction<
 
 type RouteHandler = {
   routePath: string;
-  methods: HTTPMethod[];
+  mountPath: string;
+  method?: HTTPMethod;
   modules: PagesFunction[];
   middlewares: PagesFunction[];
 };
@@ -42,25 +44,25 @@ type WorkerContext = {
   waitUntil: (promise: Promise<unknown>) => void;
 };
 
-function* executeRequest(request: Request, _env: FetchEnv) {
+function* executeRequest(request: Request) {
   const requestPath = new URL(request.url).pathname;
 
   // First, iterate through the routes (backwards) and execute "middlewares" on partial route matches
   for (const route of [...routes].reverse()) {
-    if (
-      route.methods.length &&
-      !route.methods.includes(request.method as HTTPMethod)
-    ) {
+    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(requestPath);
-    if (matchResult) {
+    const mountMatchResult = mountMatcher(requestPath);
+    if (matchResult && mountMatchResult) {
       for (const handler of route.middlewares.flat()) {
         yield {
           handler,
           params: matchResult.params as Params,
+          path: mountMatchResult.path,
         };
       }
     }
@@ -68,20 +70,20 @@ function* executeRequest(request: Request, _env: FetchEnv) {
 
   // Then look for the first exact route match and execute its "modules"
   for (const route of routes) {
-    if (
-      route.methods.length &&
-      !route.methods.includes(request.method as HTTPMethod)
-    ) {
+    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(requestPath);
-    if (matchResult && route.modules.length) {
+    const mountMatchResult = mountMatcher(requestPath);
+    if (matchResult && mountMatchResult && route.modules.length) {
       for (const handler of route.modules.flat()) {
         yield {
           handler,
           params: matchResult.params as Params,
+          path: matchResult.path,
         };
       }
       break;
@@ -91,19 +93,24 @@ function* executeRequest(request: Request, _env: FetchEnv) {
 
 export default {
   async fetch(request: Request, env: FetchEnv, workerContext: WorkerContext) {
-    const handlerIterator = executeRequest(request, env);
+    const handlerIterator = executeRequest(request);
     const data = {}; // arbitrary data the user can set between functions
     const next = async (input?: RequestInfo, init?: RequestInit) => {
       if (input !== undefined) {
-        request = new Request(input, init);
+        let url = input;
+        if (typeof input === "string") {
+          url = new URL(input, request.url).toString();
+        }
+        request = new Request(url, 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 } = result.value;
+      if (result.done === false) {
+        const { handler, params, path } = result.value;
         const context = {
           request: new Request(request.clone()),
+          functionPath: path,
           next,
           params,
           data,
@@ -116,7 +123,7 @@ export default {
         // https://fetch.spec.whatwg.org/#null-body-status
         return new Response(
           [101, 204, 205, 304].includes(response.status) ? null : response.body,
-          response
+          { ...response, headers: new Headers(response.headers) }
         );
       } else if (__FALLBACK_SERVICE__) {
         // There are no more handlers so finish with the fallback service (`env.ASSETS.fetch` in Pages' case)

package/src/__tests__/config-cache.test.ts

@@ -0,0 +1,36 @@
+import { getConfigCache, saveToConfigCache } from "../config-cache";
+import { runInTempDir } from "./helpers/run-in-tmp";
+
+interface PagesConfigCache {
+  account_id: string;
+  pages_project_name: string;
+}
+
+describe("config cache", () => {
+  runInTempDir();
+
+  const pagesConfigCacheFilename = "pages-config-cache.json";
+
+  it("should return an empty config if no file exists", () => {
+    expect(
+      getConfigCache<PagesConfigCache>(pagesConfigCacheFilename)
+    ).toMatchInlineSnapshot(`Object {}`);
+  });
+
+  it("should read and write values without overriding old ones", () => {
+    saveToConfigCache<PagesConfigCache>(pagesConfigCacheFilename, {
+      account_id: "some-account-id",
+      pages_project_name: "foo",
+    });
+    expect(
+      getConfigCache<PagesConfigCache>(pagesConfigCacheFilename).account_id
+    ).toEqual("some-account-id");
+
+    saveToConfigCache<PagesConfigCache>(pagesConfigCacheFilename, {
+      pages_project_name: "bar",
+    });
+    expect(
+      getConfigCache<PagesConfigCache>(pagesConfigCacheFilename).account_id
+    ).toEqual("some-account-id");
+  });
+});