wrangler 0.0.0-e1c615f → 0.0.0-e3cab74

package/pages/functions/template-worker.ts

@@ -22,33 +22,32 @@ declare type PagesFunction<
 
 type RouteHandler = {
   routePath: string;
-  methods: HTTPMethod[];
+  method?: HTTPMethod;
   modules: PagesFunction[];
   middlewares: PagesFunction[];
 };
 
 // inject `routes` via ESBuild
 declare const routes: RouteHandler[];
+// define `__FALLBACK_SERVICE__` via ESBuild
+declare const __FALLBACK_SERVICE__: string;
 
 // expect an ASSETS fetcher binding pointing to the asset-server stage
-type Env = {
-  [name: string]: unknown;
-  ASSETS: { fetch(url: string, init: RequestInit): Promise<Response> };
+type FetchEnv = {
+  [name: string]: { fetch: typeof fetch };
+  ASSETS: { fetch: typeof fetch };
 };
 
 type WorkerContext = {
   waitUntil: (promise: Promise<unknown>) => void;
 };
 
-function* executeRequest(request: Request, env: Env) {
+function* executeRequest(request: Request, _env: FetchEnv) {
   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;
     }
 
@@ -66,10 +65,7 @@ function* executeRequest(request: Request, env: Env) {
 
   // 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;
     }
 
@@ -85,16 +81,10 @@ function* executeRequest(request: Request, env: Env) {
       break;
     }
   }
-
-  // Finally, yield to the asset-server
-  return {
-    handler: () => env.ASSETS.fetch(request.url, request),
-    params: {} as Params,
-  };
 }
 
 export default {
-  async fetch(request: Request, env: Env, workerContext: WorkerContext) {
+  async fetch(request: Request, env: FetchEnv, workerContext: WorkerContext) {
     const handlerIterator = executeRequest(request, env);
     const data = {}; // arbitrary data the user can set between functions
     const next = async (input?: RequestInfo, init?: RequestInit) => {
@@ -102,14 +92,11 @@ export default {
         request = new Request(input, init);
       }
 
-      const { value } = handlerIterator.next();
-      if (value) {
-        const { handler, params } = value;
-        const context: EventContext<
-          unknown,
-          string,
-          Record<string, unknown>
-        > = {
+      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;
+        const context = {
           request: new Request(request.clone()),
           next,
           params,
@@ -125,6 +112,12 @@ export default {
           [101, 204, 205, 304].includes(response.status) ? null : response.body,
           response
         );
+      } else if (__FALLBACK_SERVICE__) {
+        // There are no more handlers so finish with the fallback service (`env.ASSETS.fetch` in Pages' case)
+        return env[__FALLBACK_SERVICE__].fetch(request);
+      } else {
+        // There was not fallback service so actually make the request to the origin.
+        return fetch(request);
       }
     };