wrangler 0.0.0-e95bea2 → 0.0.0-e95e5a0

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;
+}

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,6 +23,7 @@ declare type PagesFunction<
 
 type RouteHandler = {
   routePath: string;
+  mountPath: string;
   method?: HTTPMethod;
   modules: PagesFunction[];
   middlewares: PagesFunction[];
@@ -42,7 +44,7 @@ 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
@@ -52,12 +54,15 @@ function* executeRequest(request: Request, _env: FetchEnv) {
     }
 
     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,
         };
       }
     }
@@ -70,12 +75,15 @@ function* executeRequest(request: Request, _env: FetchEnv) {
     }
 
     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;
@@ -85,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,
@@ -110,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");
+  });
+});