wrangler 0.0.0-e978986 → 0.0.0-ea7ee45

package/templates/new-worker-scheduled.js

@@ -4,14 +4,14 @@
  * - Run `wrangler dev --local` in your terminal to start a development server
  * - Run `curl "http://localhost:8787/cdn-cgi/mf/scheduled"` to trigger the scheduled event
  * - Go back to the console to see what your worker has logged
- * - Add a Cron trigger to wrangler.toml (see https://developers.cloudflare.com/workers/wrangler/configuration/#triggers)
+ * - Update the Cron trigger in wrangler.toml (see https://developers.cloudflare.com/workers/wrangler/configuration/#triggers)
  * - Run `wrangler publish --name my-worker` to publish your worker
  *
  * Learn more at https://developers.cloudflare.com/workers/runtime-apis/scheduled-event/
  */
 
 export default {
-  async scheduled(controller, env, ctx) {
-    console.log(`Hello World!`);
-  },
+	async scheduled(controller, env, ctx) {
+		console.log(`Hello World!`);
+	},
 };

package/templates/new-worker-scheduled.ts

@@ -4,29 +4,29 @@
  * - Run `wrangler dev --local` in your terminal to start a development server
  * - Run `curl "http://localhost:8787/cdn-cgi/mf/scheduled"` to trigger the scheduled event
  * - Go back to the console to see what your worker has logged
- * - Add a Cron trigger to wrangler.toml (see https://developers.cloudflare.com/workers/wrangler/configuration/#triggers)
+ * - Update the Cron trigger in wrangler.toml (see https://developers.cloudflare.com/workers/wrangler/configuration/#triggers)
  * - Run `wrangler publish --name my-worker` to publish your worker
  *
  * Learn more at https://developers.cloudflare.com/workers/runtime-apis/scheduled-event/
  */
 
 export interface Env {
-  // Example binding to KV. Learn more at https://developers.cloudflare.com/workers/runtime-apis/kv/
-  // MY_KV_NAMESPACE: KVNamespace;
-  //
-  // Example binding to Durable Object. Learn more at https://developers.cloudflare.com/workers/runtime-apis/durable-objects/
-  // MY_DURABLE_OBJECT: DurableObjectNamespace;
-  //
-  // Example binding to R2. Learn more at https://developers.cloudflare.com/workers/runtime-apis/r2/
-  // MY_BUCKET: R2Bucket;
+	// Example binding to KV. Learn more at https://developers.cloudflare.com/workers/runtime-apis/kv/
+	// MY_KV_NAMESPACE: KVNamespace;
+	//
+	// Example binding to Durable Object. Learn more at https://developers.cloudflare.com/workers/runtime-apis/durable-objects/
+	// MY_DURABLE_OBJECT: DurableObjectNamespace;
+	//
+	// Example binding to R2. Learn more at https://developers.cloudflare.com/workers/runtime-apis/r2/
+	// MY_BUCKET: R2Bucket;
 }
 
 export default {
-  async scheduled(
-    controller: ScheduledController,
-    env: Env,
-    ctx: ExecutionContext
-  ): Promise<void> {
-    console.log(`Hello World!`);
-  },
+	async scheduled(
+		controller: ScheduledController,
+		env: Env,
+		ctx: ExecutionContext
+	): Promise<void> {
+		console.log(`Hello World!`);
+	},
 };

package/templates/new-worker.js

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

package/templates/new-worker.ts

@@ -9,22 +9,22 @@
  */
 
 export interface Env {
-  // Example binding to KV. Learn more at https://developers.cloudflare.com/workers/runtime-apis/kv/
-  // MY_KV_NAMESPACE: KVNamespace;
-  //
-  // Example binding to Durable Object. Learn more at https://developers.cloudflare.com/workers/runtime-apis/durable-objects/
-  // MY_DURABLE_OBJECT: DurableObjectNamespace;
-  //
-  // Example binding to R2. Learn more at https://developers.cloudflare.com/workers/runtime-apis/r2/
-  // MY_BUCKET: R2Bucket;
+	// Example binding to KV. Learn more at https://developers.cloudflare.com/workers/runtime-apis/kv/
+	// MY_KV_NAMESPACE: KVNamespace;
+	//
+	// Example binding to Durable Object. Learn more at https://developers.cloudflare.com/workers/runtime-apis/durable-objects/
+	// MY_DURABLE_OBJECT: DurableObjectNamespace;
+	//
+	// Example binding to R2. Learn more at https://developers.cloudflare.com/workers/runtime-apis/r2/
+	// MY_BUCKET: R2Bucket;
 }
 
 export default {
-  async fetch(
-    request: Request,
-    env: Env,
-    ctx: ExecutionContext
-  ): Promise<Response> {
-    return new Response("Hello World!");
-  },
+	async fetch(
+		request: Request,
+		env: Env,
+		ctx: ExecutionContext
+	): Promise<Response> {
+		return new Response("Hello World!");
+	},
 };

package/templates/no-op-worker.js

@@ -0,0 +1,10 @@
+export default {
+	fetch() {
+		return new Response("Not found", {
+			status: 404,
+			headers: {
+				"Content-Type": "text/html",
+			},
+		});
+	},
+};

package/templates/pages-template-plugin.ts

@@ -0,0 +1,155 @@
+import { match } from "path-to-regexp";
+
+type HTTPMethod =
+	| "HEAD"
+	| "OPTIONS"
+	| "GET"
+	| "POST"
+	| "PUT"
+	| "PATCH"
+	| "DELETE";
+
+/* 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/templates/pages-template-worker.ts

@@ -0,0 +1,161 @@
+import { match } from "path-to-regexp";
+
+type HTTPMethod =
+	| "HEAD"
+	| "OPTIONS"
+	| "GET"
+	| "POST"
+	| "PUT"
+	| "PATCH"
+	| "DELETE";
+
+/* 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;
+};
+
+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>;
+/* end @cloudflare/workers-types */
+
+type RouteHandler = {
+	routePath: string;
+	mountPath: string;
+	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 FetchEnv = {
+	[name: string]: { fetch: typeof fetch };
+	ASSETS: { fetch: typeof fetch };
+};
+
+type WorkerContext = {
+	waitUntil: (promise: Promise<unknown>) => void;
+};
+
+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.method && route.method !== request.method) {
+			continue;
+		}
+
+		const routeMatcher = match(route.routePath, { end: false });
+		const mountMatcher = match(route.mountPath, { end: false });
+		const matchResult = routeMatcher(requestPath);
+		const mountMatchResult = mountMatcher(requestPath);
+		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(requestPath);
+		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;
+		}
+	}
+}
+
+export default {
+	async fetch(request: Request, env: FetchEnv, workerContext: WorkerContext) {
+		const handlerIterator = executeRequest(request);
+		const data = {}; // arbitrary data the user can set between functions
+		const next = async (input?: RequestInfo, init?: RequestInit) => {
+			if (input !== undefined) {
+				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, path } = result.value;
+				const context = {
+					request: new Request(request.clone()),
+					functionPath: path,
+					next,
+					params,
+					data,
+					env,
+					waitUntil: workerContext.waitUntil.bind(workerContext),
+				};
+
+				const response = await handler(context);
+
+				if (!(response instanceof Response)) {
+					throw new Error("Your Pages function should return a Response");
+				}
+
+				return cloneResponse(response);
+			} else if (__FALLBACK_SERVICE__) {
+				// There are no more handlers so finish with the fallback service (`env.ASSETS.fetch` in Pages' case)
+				const response = await env[__FALLBACK_SERVICE__].fetch(request);
+				return cloneResponse(response);
+			} else {
+				// There was not fallback service so actually make the request to the origin.
+				const response = await fetch(request);
+				return cloneResponse(response);
+			}
+		};
+
+		try {
+			return next();
+		} catch (err) {
+			return new Response("Internal Error", { status: 500 });
+		}
+	},
+};
+
+// 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/static-asset-facade.js

@@ -1,47 +1,43 @@
 // DO NOT IMPORT THIS DIRECTLY
 import worker from "__ENTRY_POINT__";
-import { getAssetFromKV } from "@cloudflare/kv-asset-handler";
+import { getAssetFromKV } from "__KV_ASSET_HANDLER__";
 import manifest from "__STATIC_CONTENT_MANIFEST";
 const ASSET_MANIFEST = JSON.parse(manifest);
 
-// TODO: remove this
-globalThis.__STATIC_CONTENT = undefined;
-globalThis.__STATIC_CONTENT_MANIFEST = undefined;
-
 export default {
-  async fetch(request, env, ctx) {
-    let options = {
-      ASSET_MANIFEST,
-      ASSET_NAMESPACE: env.__STATIC_CONTENT,
-    };
+	async fetch(request, env, ctx) {
+		let options = {
+			ASSET_MANIFEST,
+			ASSET_NAMESPACE: env.__STATIC_CONTENT,
+		};
 
-    try {
-      const page = await getAssetFromKV(
-        {
-          request,
-          waitUntil(promise) {
-            return ctx.waitUntil(promise);
-          },
-        },
-        options
-      );
+		try {
+			const page = await getAssetFromKV(
+				{
+					request,
+					waitUntil(promise) {
+						return ctx.waitUntil(promise);
+					},
+				},
+				options
+			);
 
-      // allow headers to be altered
-      const response = new Response(page.body, page);
+			// allow headers to be altered
+			const response = new Response(page.body, page);
 
-      response.headers.set("X-XSS-Protection", "1; mode=block");
-      response.headers.set("X-Content-Type-Options", "nosniff");
-      response.headers.set("X-Frame-Options", "DENY");
-      response.headers.set("Referrer-Policy", "unsafe-url");
-      response.headers.set("Feature-Policy", "none");
+			response.headers.set("X-XSS-Protection", "1; mode=block");
+			response.headers.set("X-Content-Type-Options", "nosniff");
+			response.headers.set("X-Frame-Options", "DENY");
+			response.headers.set("Referrer-Policy", "unsafe-url");
+			response.headers.set("Feature-Policy", "none");
 
-      return response;
-    } catch (e) {
-      console.error(e);
-      // if an error is thrown then serve from actual worker
-      return worker.fetch(request);
-      // TODO: throw here if worker is not available
-      // (which implies it may be a service-worker)
-    }
-  },
+			return response;
+		} catch (e) {
+			console.error(e);
+			// if an error is thrown then serve from actual worker
+			return worker.fetch(request, env, ctx);
+			// TODO: throw here if worker is not available
+			// (which implies it may be a service-worker)
+		}
+	},
 };