wrangler 0.0.0-e7a0cd5b → 0.0.0-e7c06d78

package/templates/middleware/loader-modules.ts

@@ -1,25 +1,17 @@
-// // This loads all middlewares exposed on the middleware object
-// // and then starts the invocation chain.
-// // The big idea is that we can add these to the middleware export dynamically
-// // through wrangler, or we can potentially let users directly add them as a sort
-// // of "plugin" system.
+// This loads all middlewares exposed on the middleware object and then starts
+// the invocation chain. The big idea is that we can add these to the middleware
+// export dynamically through wrangler, or we can potentially let users directly
+// add them as a sort of "plugin" system.
 
-import {
-	Dispatcher,
-	Middleware,
-	__facade_invoke__,
-	__facade_register__,
-} from "./common";
+import ENTRY, { __INTERNAL_WRANGLER_MIDDLEWARE__ } from "__ENTRY_POINT__";
+import { __facade_invoke__, __facade_register__, Dispatcher } from "./common";
+import type { WorkerEntrypointConstructor } from "__ENTRY_POINT__";
 
-// @ts-expect-error We'll swap in the entry point during build
-import worker from "__ENTRY_POINT__";
-
-// We need to preserve all of the exports from the worker
-// @ts-expect-error We'll swap in the entry point during build
+// Preserve all the exports from the worker
 export * from "__ENTRY_POINT__";
 
 class __Facade_ScheduledController__ implements ScheduledController {
-	#noRetry: ScheduledController["noRetry"];
+	readonly #noRetry: ScheduledController["noRetry"];
 
 	constructor(
 		readonly scheduledTime: number,
@@ -38,20 +30,34 @@ class __Facade_ScheduledController__ implements ScheduledController {
 	}
 }
 
-const __facade_modules_fetch__: Middleware = function (request, env, ctx) {
-	if (worker.fetch === undefined) throw new Error("No fetch handler!"); // TODO: proper error message
-	return worker.fetch(request, env, ctx);
-};
+function wrapExportedHandler(worker: ExportedHandler): ExportedHandler {
+	// If we don't have any middleware defined, just return the handler as is
+	if (
+		__INTERNAL_WRANGLER_MIDDLEWARE__ === undefined ||
+		__INTERNAL_WRANGLER_MIDDLEWARE__.length === 0
+	) {
+		return worker;
+	}
+	// Otherwise, register all middleware once
+	for (const middleware of __INTERNAL_WRANGLER_MIDDLEWARE__) {
+		__facade_register__(middleware);
+	}
 
-const facade: ExportedHandler<unknown> = {
-	fetch(request, env, ctx) {
-		// Get the chain of middleware from the worker object
-		if (worker.middleware && worker.middleware.length > 0) {
-			for (const middleware of worker.middleware) {
-				__facade_register__(middleware);
-			}
+	const fetchDispatcher: ExportedHandlerFetchHandler = function (
+		request,
+		env,
+		ctx
+	) {
+		if (worker.fetch === undefined) {
+			throw new Error("Handler does not export a fetch() function.");
+		}
+		return worker.fetch(request, env, ctx);
+	};
 
-			const __facade_modules_dispatch__: Dispatcher = function (type, init) {
+	return {
+		...worker,
+		fetch(request, env, ctx) {
+			const dispatcher: Dispatcher = function (type, init) {
 				if (type === "scheduled" && worker.scheduled !== undefined) {
 					const controller = new __Facade_ScheduledController__(
 						Date.now(),
@@ -61,24 +67,68 @@ const facade: ExportedHandler<unknown> = {
 					return worker.scheduled(controller, env, ctx);
 				}
 			};
+			return __facade_invoke__(request, env, ctx, dispatcher, fetchDispatcher);
+		},
+	};
+}
 
+function wrapWorkerEntrypoint(
+	klass: WorkerEntrypointConstructor
+): WorkerEntrypointConstructor {
+	// If we don't have any middleware defined, just return the handler as is
+	if (
+		__INTERNAL_WRANGLER_MIDDLEWARE__ === undefined ||
+		__INTERNAL_WRANGLER_MIDDLEWARE__.length === 0
+	) {
+		return klass;
+	}
+	// Otherwise, register all middleware once
+	for (const middleware of __INTERNAL_WRANGLER_MIDDLEWARE__) {
+		__facade_register__(middleware);
+	}
+
+	// `extend`ing `klass` here so other RPC methods remain callable
+	return class extends klass {
+		#fetchDispatcher: ExportedHandlerFetchHandler<Record<string, unknown>> = (
+			request,
+			env,
+			ctx
+		) => {
+			this.env = env;
+			this.ctx = ctx;
+			if (super.fetch === undefined) {
+				throw new Error("Entrypoint class does not define a fetch() function.");
+			}
+			return super.fetch(request);
+		};
+
+		#dispatcher: Dispatcher = (type, init) => {
+			if (type === "scheduled" && super.scheduled !== undefined) {
+				const controller = new __Facade_ScheduledController__(
+					Date.now(),
+					init.cron ?? "",
+					() => {}
+				);
+				return super.scheduled(controller);
+			}
+		};
+
+		fetch(request: Request<unknown, IncomingRequestCfProperties>) {
 			return __facade_invoke__(
 				request,
-				env,
-				ctx,
-				__facade_modules_dispatch__,
-				__facade_modules_fetch__
+				this.env,
+				this.ctx,
+				this.#dispatcher,
+				this.#fetchDispatcher
 			);
-		} else {
-			// We didn't have any middleware so we can skip the invocation chain,
-			// and just call the fetch handler directly
-
-			// We "don't care" if this is undefined as we want to have the same behaviour
-			// as if the worker completely bypassed middleware.
-			return worker.fetch!(request, env, ctx);
 		}
-	},
-	scheduled: worker.scheduled,
-};
+	};
+}
 
-export default facade;
+let WRAPPED_ENTRY: ExportedHandler | WorkerEntrypointConstructor | undefined;
+if (typeof ENTRY === "object") {
+	WRAPPED_ENTRY = wrapExportedHandler(ENTRY);
+} else if (typeof ENTRY === "function") {
+	WRAPPED_ENTRY = wrapWorkerEntrypoint(ENTRY);
+}
+export default WRAPPED_ENTRY;

package/templates/middleware/loader-sw.ts

@@ -1,8 +1,17 @@
-import { Awaitable, Dispatcher, Middleware, __facade_invoke__ } from "./common";
-export { __facade_register__, __facade_registerInternal__ } from "./common";
-
-// Miniflare's `EventTarget` follows the spec and doesn't allow exceptions to
-// be caught by `dispatchEvent`. Instead it has a custom`ThrowingEventTarget`
+import {
+	__facade_invoke__,
+	__facade_register__,
+	__facade_registerInternal__,
+	Awaitable,
+	Dispatcher,
+	IncomingRequest,
+	Middleware,
+} from "./common";
+
+export { __facade_register__, __facade_registerInternal__ };
+
+// Miniflare 2's `EventTarget` follows the spec and doesn't allow exceptions to
+// be caught by `dispatchEvent`. Instead it has a custom `ThrowingEventTarget`
 // class that rethrows errors from event listeners in `dispatchEvent`.
 // We'd like errors to be propagated to the top-level `addEventListener`, so
 // we'd like to use `ThrowingEventTarget`. Unfortunately, `ThrowingEventTarget`
@@ -15,45 +24,52 @@ if ((globalThis as any).MINIFLARE) {
 	__FACADE_EVENT_TARGET__ = new EventTarget();
 }
 
-declare global {
-	var __facade_addEventListener__: (
-		type: string,
-		listener: EventListenerOrEventListenerObject,
-		options?: EventTargetAddEventListenerOptions | boolean
-	) => void;
-	var __facade_removeEventListener__: (
-		type: string,
-		listener: EventListenerOrEventListenerObject,
-		options?: EventTargetEventListenerOptions | boolean
-	) => void;
-	var __facade_dispatchEvent__: (event: Event) => void;
-}
-
-function __facade_isSpecialEvent__(type: string) {
+function __facade_isSpecialEvent__(
+	type: string
+): type is "fetch" | "scheduled" {
 	return type === "fetch" || type === "scheduled";
 }
-globalThis.__facade_addEventListener__ = function (type, listener, options) {
+const __facade__originalAddEventListener__ = globalThis.addEventListener;
+const __facade__originalRemoveEventListener__ = globalThis.removeEventListener;
+const __facade__originalDispatchEvent__ = globalThis.dispatchEvent;
+
+globalThis.addEventListener = function (type, listener, options) {
 	if (__facade_isSpecialEvent__(type)) {
-		__FACADE_EVENT_TARGET__.addEventListener(type, listener, options);
+		__FACADE_EVENT_TARGET__.addEventListener(
+			type,
+			listener as EventListenerOrEventListenerObject,
+			options
+		);
 	} else {
-		globalThis.addEventListener(type as any, listener, options);
+		__facade__originalAddEventListener__(type, listener, options);
 	}
 };
-globalThis.__facade_removeEventListener__ = function (type, listener, options) {
+globalThis.removeEventListener = function (type, listener, options) {
 	if (__facade_isSpecialEvent__(type)) {
-		__FACADE_EVENT_TARGET__.removeEventListener(type, listener, options);
+		__FACADE_EVENT_TARGET__.removeEventListener(
+			type,
+			listener as EventListenerOrEventListenerObject,
+			options
+		);
 	} else {
-		globalThis.removeEventListener(type as any, listener, options);
+		__facade__originalRemoveEventListener__(type, listener, options);
 	}
 };
-globalThis.__facade_dispatchEvent__ = function (event) {
+globalThis.dispatchEvent = function (event) {
 	if (__facade_isSpecialEvent__(event.type)) {
-		__FACADE_EVENT_TARGET__.dispatchEvent(event);
+		return __FACADE_EVENT_TARGET__.dispatchEvent(event);
 	} else {
-		globalThis.dispatchEvent(event as any);
+		return __facade__originalDispatchEvent__(event);
 	}
 };
 
+declare global {
+	var addMiddleware: typeof __facade_register__;
+	var addMiddlewareInternal: typeof __facade_registerInternal__;
+}
+globalThis.addMiddleware = __facade_register__;
+globalThis.addMiddlewareInternal = __facade_registerInternal__;
+
 const __facade_waitUntil__ = Symbol("__facade_waitUntil__");
 const __facade_response__ = Symbol("__facade_response__");
 const __facade_dispatched__ = Symbol("__facade_dispatched__");
@@ -154,7 +170,7 @@ class __Facade_ScheduledEvent__ extends __Facade_ExtendableEvent__ {
 	}
 }
 
-globalThis.addEventListener("fetch", (event) => {
+__facade__originalAddEventListener__("fetch", (event) => {
 	const ctx: ExecutionContext = {
 		waitUntil: event.waitUntil.bind(event),
 		passThroughOnException: event.passThroughOnException.bind(event),
@@ -192,7 +208,7 @@ globalThis.addEventListener("fetch", (event) => {
 
 	event.respondWith(
 		__facade_invoke__(
-			event.request,
+			event.request as IncomingRequest,
 			globalThis,
 			ctx,
 			__facade_sw_dispatch__,
@@ -201,7 +217,7 @@ globalThis.addEventListener("fetch", (event) => {
 	);
 });
 
-globalThis.addEventListener("scheduled", (event) => {
+__facade__originalAddEventListener__("scheduled", (event) => {
 	const facadeEvent = new __Facade_ScheduledEvent__("scheduled", {
 		scheduledTime: event.scheduledTime,
 		cron: event.cron,

package/templates/middleware/middleware-ensure-req-body-drained.ts

@@ -0,0 +1,18 @@
+import type { Middleware } from "./common";
+
+const drainBody: Middleware = async (request, env, _ctx, middlewareCtx) => {
+	try {
+		return await middlewareCtx.next(request, env);
+	} finally {
+		try {
+			if (request.body !== null && !request.bodyUsed) {
+				const reader = request.body.getReader();
+				while (!(await reader.read()).done) {}
+			}
+		} catch (e) {
+			console.error("Failed to drain the unused request body.", e);
+		}
+	}
+};
+
+export default drainBody;

package/templates/middleware/middleware-miniflare3-json-error.ts

@@ -0,0 +1,32 @@
+import type { Middleware } from "./common";
+
+interface JsonError {
+	message?: string;
+	name?: string;
+	stack?: string;
+	cause?: JsonError;
+}
+
+function reduceError(e: any): JsonError {
+	return {
+		name: e?.name,
+		message: e?.message ?? String(e),
+		stack: e?.stack,
+		cause: e?.cause === undefined ? undefined : reduceError(e.cause),
+	};
+}
+
+// See comment in `bundle.ts` for details on why this is needed
+const jsonError: Middleware = async (request, env, _ctx, middlewareCtx) => {
+	try {
+		return await middlewareCtx.next(request, env);
+	} catch (e: any) {
+		const error = reduceError(e);
+		return Response.json(error, {
+			status: 500,
+			headers: { "MF-Experimental-Error-Stack": "true" },
+		});
+	}
+};
+
+export default jsonError;

package/templates/middleware/middleware-serve-static-assets.d.ts

@@ -0,0 +1,6 @@
+declare module "config:middleware/serve-static-assets" {
+	import type { CacheControl } from "@cloudflare/kv-asset-handler";
+
+	export const spaMode: boolean;
+	export const cacheControl: Partial<CacheControl>;
+}

package/templates/middleware/middleware-serve-static-assets.ts

@@ -0,0 +1,56 @@
+/// <reference path="middleware-serve-static-assets.d.ts"/>
+
+import manifest from "__STATIC_CONTENT_MANIFEST";
+import {
+	getAssetFromKV,
+	MethodNotAllowedError,
+	NotFoundError,
+	serveSinglePageApp,
+} from "@cloudflare/kv-asset-handler";
+import { cacheControl, spaMode } from "config:middleware/serve-static-assets";
+import type { Middleware } from "./common";
+import type { Options } from "@cloudflare/kv-asset-handler";
+import type * as kvAssetHandler from "@cloudflare/kv-asset-handler";
+
+const ASSET_MANIFEST = JSON.parse(manifest);
+
+const staticAssets: Middleware = async (request, env, _ctx, middlewareCtx) => {
+	let options: Partial<Options> = {
+		ASSET_MANIFEST,
+		ASSET_NAMESPACE: env.__STATIC_CONTENT,
+		cacheControl: cacheControl,
+		mapRequestToAsset: spaMode ? serveSinglePageApp : undefined,
+	};
+
+	try {
+		const page = await (getAssetFromKV as typeof kvAssetHandler.getAssetFromKV)(
+			{
+				request,
+				waitUntil(promise) {
+					return _ctx.waitUntil(promise);
+				},
+			},
+			options
+		);
+
+		// 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");
+
+		return response;
+	} catch (e) {
+		if (e instanceof NotFoundError || e instanceof MethodNotAllowedError) {
+			// if a known error is thrown then serve from actual worker
+			return await middlewareCtx.next(request, env);
+		}
+		// otherwise it's a real error, so throw it
+		throw e;
+	}
+};
+
+export default staticAssets;

package/templates/modules-watch-stub.js

@@ -0,0 +1,4 @@
+// `esbuild` doesn't support returning `watch*` options from `onStart()`
+// plugin callbacks. Instead, we define an empty virtual module that is
+// imported by this injected file. Importing the module registers watchers.
+import "wrangler:modules-watch";

package/templates/new-worker-scheduled.ts

@@ -5,7 +5,7 @@
  * - 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
  * - 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
+ * - Run `wrangler deploy --name my-worker` to deploy your worker
  *
  * Learn more at https://developers.cloudflare.com/workers/runtime-apis/scheduled-event/
  */

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

@@ -1,13 +1,14 @@
 // @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__";
-import { isRoutingRuleMatch } from "./pages-dev-util";
 
 // @ts-ignore routes are injected
 const routes = __ROUTES__;
 
-export default {
+export default <ExportedHandler<{ ASSETS: Fetcher }>>{
 	fetch(request, env, context) {
 		const { pathname } = new URL(request.url);
 
@@ -19,6 +20,9 @@ export default {
 
 		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);
 			}
 		}

package/templates/pages-dev-util.ts

@@ -45,7 +45,10 @@ function transformRoutingRuleToRegExp(rule: string): RegExp {
 	}
 
 	// /foo* => /foo.* => ^/foo.*$
-	transformedRule = `^${transformedRule.replace("*", ".*")}$`;
+	// /*.* => /*\.* => /.*\..* => ^/.*\..*$
+	transformedRule = `^${transformedRule
+		.replaceAll(/\./g, "\\.")
+		.replaceAll(/\*/g, ".*")}$`;
 
 	// ^/foo.*$ => /^\/foo.*$/
 	return new RegExp(transformedRule);

package/templates/pages-shim.ts

@@ -1,7 +1,7 @@
 // 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 {
+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

@@ -41,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>;
@@ -119,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();
@@ -140,11 +146,20 @@ 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),
@@ -154,13 +169,9 @@ export default function (pluginArgs) {
 
 				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);
 			}
 		};
 
@@ -169,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

@@ -29,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 */
 
@@ -120,7 +120,7 @@ export default {
 	) {
 		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) => {
@@ -141,7 +141,16 @@ 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: () => {