wrangler 0.0.0-eab9542 → 0.0.0-eaf71b86c

package/templates/new-worker.js

@@ -9,7 +9,7 @@
  */
 
 export default {
-	async fetch(request) {
+	async fetch(request, env, ctx) {
 		return new Response("Hello World!");
 	},
 };

package/templates/new-worker.ts

@@ -3,7 +3,7 @@
  *
  * - Run `wrangler dev src/index.ts` in your terminal to start a development server
  * - Open a browser tab at http://localhost:8787/ to see your worker in action
- * - Run `wrangler publish src/index.ts --name my-worker` to publish your worker
+ * - Run `wrangler deploy src/index.ts --name my-worker` to deploy your worker
  *
  * Learn more at https://developers.cloudflare.com/workers/
  */
@@ -17,6 +17,9 @@ export interface Env {
 	//
 	// Example binding to R2. Learn more at https://developers.cloudflare.com/workers/runtime-apis/r2/
 	// MY_BUCKET: R2Bucket;
+	//
+	// Example binding to a Service. Learn more at https://developers.cloudflare.com/workers/runtime-apis/service-bindings/
+	// MY_SERVICE: Fetcher;
 }
 
 export default {

package/templates/pages-dev-pipeline.ts

@@ -0,0 +1,32 @@
+// @ts-ignore entry point will get replaced
+import worker from "__ENTRY_POINT__";
+import { isRoutingRuleMatch } from "./pages-dev-util";
+
+// @ts-ignore entry point will get replaced
+export * from "__ENTRY_POINT__";
+
+// @ts-ignore routes are injected
+const routes = __ROUTES__;
+
+export default <ExportedHandler<{ ASSETS: Fetcher }>>{
+	fetch(request, env, context) {
+		const { pathname } = new URL(request.url);
+
+		for (const exclude of routes.exclude) {
+			if (isRoutingRuleMatch(pathname, exclude)) {
+				return env.ASSETS.fetch(request);
+			}
+		}
+
+		for (const include of routes.include) {
+			if (isRoutingRuleMatch(pathname, include)) {
+				if (worker.fetch === undefined) {
+					throw new TypeError("Entry point missing `fetch` handler");
+				}
+				return worker.fetch(request, env, context);
+			}
+		}
+
+		return env.ASSETS.fetch(request);
+	},
+};

package/templates/pages-dev-util.ts

@@ -0,0 +1,55 @@
+/**
+ * @param pathname A pathname string, such as `/foo` or `/foo/bar`
+ * @param routingRule The routing rule, such as `/foo/*`
+ * @returns True if pathname matches the routing rule
+ *
+ * /       ->  /
+ * /*      ->  /*
+ * /foo    ->  /foo
+ * /foo*   ->  /foo, /foo-bar, /foo/*
+ * /foo/*  ->  /foo, /foo/bar
+ */
+export function isRoutingRuleMatch(
+	pathname: string,
+	routingRule: string
+): boolean {
+	// sanity checks
+	if (!pathname) {
+		throw new Error("Pathname is undefined.");
+	}
+	if (!routingRule) {
+		throw new Error("Routing rule is undefined.");
+	}
+
+	const ruleRegExp = transformRoutingRuleToRegExp(routingRule);
+	return pathname.match(ruleRegExp) !== null;
+}
+
+function transformRoutingRuleToRegExp(rule: string): RegExp {
+	let transformedRule;
+
+	if (rule === "/" || rule === "/*") {
+		transformedRule = rule;
+	} else if (rule.endsWith("/*")) {
+		// make `/*` an optional group so we can match both /foo/* and /foo
+		// /foo/* => /foo(/*)?
+		transformedRule = `${rule.substring(0, rule.length - 2)}(/*)?`;
+	} else if (rule.endsWith("/")) {
+		// make `/` an optional group so we can match both /foo/ and /foo
+		// /foo/ => /foo(/)?
+		transformedRule = `${rule.substring(0, rule.length - 1)}(/)?`;
+	} else if (rule.endsWith("*")) {
+		transformedRule = rule;
+	} else {
+		transformedRule = `${rule}(/)?`;
+	}
+
+	// /foo* => /foo.* => ^/foo.*$
+	// /*.* => /*\.* => /.*\..* => ^/.*\..*$
+	transformedRule = `^${transformedRule
+		.replaceAll(/\./g, "\\.")
+		.replaceAll(/\*/g, ".*")}$`;
+
+	// ^/foo.*$ => /^\/foo.*$/
+	return new RegExp(transformedRule);
+}

package/templates/pages-shim.ts

@@ -0,0 +1,9 @@
+// This Worker is used as a default when no Pages Functions are present.
+// It proxies the request directly on to the asset server binding.
+
+export default <ExportedHandler<{ ASSETS: Fetcher }>>{
+	async fetch(request, env, context) {
+		const response = await env.ASSETS.fetch(request.url, request);
+		return new Response(response.body, response);
+	},
+};

package/templates/pages-template-plugin.ts

@@ -1,5 +1,8 @@
 import { match } from "path-to-regexp";
 
+//note: this explicitly does not include the * character, as pages requires this
+const escapeRegex = /[.+?^${}()|[\]\\]/g;
+
 type HTTPMethod =
 	| "HEAD"
 	| "OPTIONS"
@@ -16,6 +19,7 @@ type EventContext<Env, P extends string, Data> = {
 	request: Request;
 	functionPath: string;
 	waitUntil: (promise: Promise<unknown>) => void;
+	passThroughOnException: () => void;
 	next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
 	env: Env & { ASSETS: { fetch: typeof fetch } };
 	params: Params<P>;
@@ -26,6 +30,7 @@ type EventPluginContext<Env, P extends string, Data, PluginArgs> = {
 	request: Request;
 	functionPath: string;
 	waitUntil: (promise: Promise<unknown>) => void;
+	passThroughOnException: () => void;
 	next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
 	env: Env & { ASSETS: { fetch: typeof fetch } };
 	params: Params<P>;
@@ -36,14 +41,14 @@ type EventPluginContext<Env, P extends string, Data, PluginArgs> = {
 declare type PagesFunction<
 	Env = unknown,
 	P extends string = string,
-	Data extends Record<string, unknown> = Record<string, unknown>
+	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
+	PluginArgs = unknown,
 > = (
 	context: EventPluginContext<Env, P, Data, PluginArgs>
 ) => Response | Promise<Response>;
@@ -67,8 +72,13 @@ function* executeRequest(request: Request, relativePathname: string) {
 			continue;
 		}
 
-		const routeMatcher = match(route.routePath, { end: false });
-		const mountMatcher = match(route.mountPath, { end: false });
+		// replaces with "\\$&", this prepends a backslash to the matched string, e.g. "[" becomes "\["
+		const routeMatcher = match(route.routePath.replace(escapeRegex, "\\$&"), {
+			end: false,
+		});
+		const mountMatcher = match(route.mountPath.replace(escapeRegex, "\\$&"), {
+			end: false,
+		});
 		const matchResult = routeMatcher(relativePathname);
 		const mountMatchResult = mountMatcher(relativePathname);
 		if (matchResult && mountMatchResult) {
@@ -88,8 +98,12 @@ function* executeRequest(request: Request, relativePathname: string) {
 			continue;
 		}
 
-		const routeMatcher = match(route.routePath, { end: true });
-		const mountMatcher = match(route.mountPath, { end: false });
+		const routeMatcher = match(route.routePath.replace(escapeRegex, "\\$&"), {
+			end: true,
+		});
+		const mountMatcher = match(route.mountPath.replace(escapeRegex, "\\$&"), {
+			end: false,
+		});
 		const matchResult = routeMatcher(relativePathname);
 		const mountMatchResult = mountMatcher(relativePathname);
 		if (matchResult && mountMatchResult && route.modules.length) {
@@ -105,20 +119,26 @@ function* executeRequest(request: Request, relativePathname: string) {
 	}
 }
 
-export default function (pluginArgs) {
+export default function (pluginArgs: unknown) {
 	const onRequest: PagesPluginFunction = async (workerContext) => {
 		let { request } = workerContext;
-		const { env, next, data } = workerContext;
+		const { env, next } = workerContext;
+		let { data } = workerContext;
 
 		const url = new URL(request.url);
+		// TODO: Replace this with something actually legible.
 		const relativePathname = `/${
-			url.pathname.split(workerContext.functionPath)[1] || ""
+			url.pathname.replace(workerContext.functionPath, "") || ""
 		}`.replace(/^\/\//, "/");
 
 		const handlerIterator = executeRequest(request, relativePathname);
 		const pluginNext = 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();
@@ -126,25 +146,32 @@ export default function (pluginArgs) {
 			if (result.done === false) {
 				const { handler, params, path } = result.value;
 				const context = {
-					request,
+					request: new Request(request.clone()),
 					functionPath: workerContext.functionPath + path,
 					next: pluginNext,
 					params,
-					data,
+					get data() {
+						return data;
+					},
+					set data(value) {
+						if (typeof value !== "object" || value === null) {
+							throw new Error("context.data must be an object");
+						}
+						// user has overriden context.data, so we need to merge it with the existing data
+						data = value;
+					},
 					pluginArgs,
 					env,
 					waitUntil: workerContext.waitUntil.bind(workerContext),
+					passThroughOnException:
+						workerContext.passThroughOnException.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) }
-				);
+				return cloneResponse(response);
 			} else {
-				return next();
+				return next(request);
 			}
 		};
 
@@ -153,3 +180,11 @@ export default function (pluginArgs) {
 
 	return onRequest;
 }
+
+// This makes a Response mutable
+const cloneResponse = (response: Response) =>
+	// https://fetch.spec.whatwg.org/#null-body-status
+	new Response(
+		[101, 204, 205, 304].includes(response.status) ? null : response.body,
+		response
+	);

package/templates/pages-template-worker.ts

@@ -1,5 +1,8 @@
 import { match } from "path-to-regexp";
 
+//note: this explicitly does not include the * character, as pages requires this
+const escapeRegex = /[.+?^${}()|[\]\\]/g;
+
 type HTTPMethod =
 	| "HEAD"
 	| "OPTIONS"
@@ -16,6 +19,7 @@ type EventContext<Env, P extends string, Data> = {
 	request: Request;
 	functionPath: string;
 	waitUntil: (promise: Promise<unknown>) => void;
+	passThroughOnException: () => void;
 	next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
 	env: Env & { ASSETS: { fetch: typeof fetch } };
 	params: Params<P>;
@@ -25,7 +29,7 @@ type EventContext<Env, P extends string, Data> = {
 declare type PagesFunction<
 	Env = unknown,
 	P extends string = string,
-	Data extends Record<string, unknown> = Record<string, unknown>
+	Data extends Record<string, unknown> = Record<string, unknown>,
 > = (context: EventContext<Env, P, Data>) => Response | Promise<Response>;
 /* end @cloudflare/workers-types */
 
@@ -50,6 +54,7 @@ type FetchEnv = {
 
 type WorkerContext = {
 	waitUntil: (promise: Promise<unknown>) => void;
+	passThroughOnException: () => void;
 };
 
 function* executeRequest(request: Request) {
@@ -61,8 +66,13 @@ function* executeRequest(request: Request) {
 			continue;
 		}
 
-		const routeMatcher = match(route.routePath, { end: false });
-		const mountMatcher = match(route.mountPath, { end: false });
+		// replaces with "\\$&", this prepends a backslash to the matched string, e.g. "[" becomes "\["
+		const routeMatcher = match(route.routePath.replace(escapeRegex, "\\$&"), {
+			end: false,
+		});
+		const mountMatcher = match(route.mountPath.replace(escapeRegex, "\\$&"), {
+			end: false,
+		});
 		const matchResult = routeMatcher(requestPath);
 		const mountMatchResult = mountMatcher(requestPath);
 		if (matchResult && mountMatchResult) {
@@ -81,9 +91,12 @@ function* executeRequest(request: Request) {
 		if (route.method && route.method !== request.method) {
 			continue;
 		}
-
-		const routeMatcher = match(route.routePath, { end: true });
-		const mountMatcher = match(route.mountPath, { end: false });
+		const routeMatcher = match(route.routePath.replace(escapeRegex, "\\$&"), {
+			end: true,
+		});
+		const mountMatcher = match(route.mountPath.replace(escapeRegex, "\\$&"), {
+			end: false,
+		});
 		const matchResult = routeMatcher(requestPath);
 		const mountMatchResult = mountMatcher(requestPath);
 		if (matchResult && mountMatchResult && route.modules.length) {
@@ -100,9 +113,16 @@ function* executeRequest(request: Request) {
 }
 
 export default {
-	async fetch(request: Request, env: FetchEnv, workerContext: WorkerContext) {
+	async fetch(
+		originalRequest: Request,
+		env: FetchEnv,
+		workerContext: WorkerContext
+	) {
+		let request = originalRequest;
 		const handlerIterator = executeRequest(request);
-		const data = {}; // arbitrary data the user can set between functions
+		let data = {}; // arbitrary data the user can set between functions
+		let isFailOpen = false;
+
 		const next = async (input?: RequestInfo, init?: RequestInit) => {
 			if (input !== undefined) {
 				let url = input;
@@ -121,9 +141,21 @@ export default {
 					functionPath: path,
 					next,
 					params,
-					data,
+					get data() {
+						return data;
+					},
+					set data(value) {
+						if (typeof value !== "object" || value === null) {
+							throw new Error("context.data must be an object");
+						}
+						// user has overriden context.data, so we need to merge it with the existing data
+						data = value;
+					},
 					env,
 					waitUntil: workerContext.waitUntil.bind(workerContext),
+					passThroughOnException: () => {
+						isFailOpen = true;
+					},
 				};
 
 				const response = await handler(context);
@@ -145,9 +177,14 @@ export default {
 		};
 
 		try {
-			return next();
-		} catch (err) {
-			return new Response("Internal Error", { status: 500 });
+			return await next();
+		} catch (error) {
+			if (isFailOpen) {
+				const response = await env[__FALLBACK_SERVICE__].fetch(request);
+				return cloneResponse(response);
+			}
+
+			throw error;
 		}
 	},
 };