wrangler 0.0.0-e8df68ee → 0.0.0-e9106dfa5

package/templates/middleware/loader-modules.ts

@@ -1,23 +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__";
 
-import worker from "__ENTRY_POINT__";
-
-// We need to preserve all of the exports from the worker
+// 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,
@@ -36,61 +30,34 @@ class __Facade_ScheduledController__ implements ScheduledController {
 	}
 }
 
-const __facade_modules_fetch__: 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);
-};
-
-function getMaskedEnv(rawEnv: unknown) {
-	let env = rawEnv as Record<string, unknown>;
-	if (worker.envWrappers && worker.envWrappers.length > 0) {
-		for (const wrapFn of worker.envWrappers) {
-			env = wrapFn(env);
-		}
+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);
 	}
-	return env;
-}
-
-/**
- * This type is here to cause a type error if a new export handler is added to
- * `ExportHandler` without it being included in the `facade` below.
- */
-type MissingExportHandlers = Omit<
-	Required<ExportedHandler>,
-	"tail" | "trace" | "scheduled" | "queue" | "test" | "fetch"
->;
-
-const facade: ExportedHandler<unknown> & MissingExportHandlers = {
-	...(worker.tail && {
-		tail: maskHandlerEnv(worker.tail),
-	}),
-	...(worker.trace && {
-		trace: maskHandlerEnv(worker.trace),
-	}),
-	...(worker.scheduled && {
-		scheduled: maskHandlerEnv(worker.scheduled),
-	}),
-	...(worker.queue && {
-		queue: maskHandlerEnv(worker.queue),
-	}),
-	...(worker.test && {
-		test: maskHandlerEnv(worker.test),
-	}),
 
-	fetch(request, rawEnv, ctx) {
-		const env = getMaskedEnv(rawEnv);
-		// 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(),
@@ -100,28 +67,68 @@ const facade: ExportedHandler<unknown> & MissingExportHandlers = {
 					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 behavior
-			// as if the worker completely bypassed middleware.
-			return __facade_modules_fetch__(request, env, ctx);
 		}
-	},
-};
-
-type HandlerFn<D, R> = (data: D, env: unknown, ctx: ExecutionContext) => R;
-function maskHandlerEnv<D, R>(handler: HandlerFn<D, R>): HandlerFn<D, R> {
-	return (data, env, ctx) => handler(data, getMaskedEnv(env), ctx);
+	};
 }
 
-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,12 +1,13 @@
 import {
+	__facade_invoke__,
+	__facade_register__,
+	__facade_registerInternal__,
 	Awaitable,
 	Dispatcher,
 	IncomingRequest,
 	Middleware,
-	__facade_invoke__,
-	__facade_register__,
-	__facade_registerInternal__,
 } from "./common";
+
 export { __facade_register__, __facade_registerInternal__ };
 
 // Miniflare 2's `EventTarget` follows the spec and doesn't allow exceptions to

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-mock-analytics-engine.d.ts

@@ -0,0 +1,3 @@
+declare module "config:middleware/mock-analytics-engine" {
+	export const bindings: string[];
+}

package/templates/middleware/middleware-mock-analytics-engine.ts

@@ -0,0 +1,30 @@
+/// <reference path="middleware-mock-analytics-engine.d.ts"/>
+
+import { bindings } from "config:middleware/mock-analytics-engine";
+import type { Middleware } from "./common";
+
+const bindingsEnv = Object.fromEntries(
+	bindings.map((binding) => [
+		binding,
+		{
+			writeDataPoint() {
+				// no op in dev
+			},
+		},
+	])
+) satisfies Record<string, AnalyticsEngineDataset>;
+
+const analyticsEngine: Middleware = async (
+	request,
+	env,
+	_ctx,
+	middlewareCtx
+) => {
+	// we're going to directly modify env so it maintains referential equality
+	for (const binding of bindings) {
+		env[binding] ??= bindingsEnv[binding];
+	}
+	return await middlewareCtx.next(request, env);
+};
+
+export default analyticsEngine;

package/templates/middleware/middleware-patch-console-prefix.d.ts

@@ -0,0 +1,3 @@
+declare module "config:middleware/patch-console-prefix" {
+	export const prefix: string;
+}

package/templates/middleware/middleware-patch-console-prefix.ts

@@ -0,0 +1,21 @@
+/// <reference path="middleware-patch-console-prefix.d.ts"/>
+
+import { prefix } from "config:middleware/patch-console-prefix";
+import type { Middleware } from "./common";
+
+// @ts-expect-error globalThis.console _does_ exist
+globalThis.console = new Proxy(globalThis.console, {
+	get(target, p, receiver) {
+		if (p === "log" || p === "debug" || p === "info") {
+			return (...args: unknown[]) =>
+				Reflect.get(target, p, receiver)(prefix, ...args);
+		}
+		return Reflect.get(target, p, receiver);
+	},
+});
+
+const passthrough: Middleware = (request, env, _ctx, middlewareCtx) => {
+	return middlewareCtx.next(request, env);
+};
+
+export default passthrough;

package/templates/middleware/middleware-scheduled.ts

@@ -9,7 +9,21 @@ const scheduled: Middleware = async (request, env, _ctx, middlewareCtx) => {
 
 		return new Response("Ran scheduled event");
 	}
-	return middlewareCtx.next(request, env);
+
+	const resp = await middlewareCtx.next(request, env);
+
+	// If you open the `/__scheduled` page in a browser, the browser will automatically make a request to `/favicon.ico`.
+	// For scheduled Workers _without_ a fetch handler, this will result in a 500 response that clutters the log with unhelpful error messages.
+	// To avoid this, inject a 404 response to favicon.ico loads on the `/__scheduled` page
+	if (
+		request.headers.get("referer")?.endsWith("/__scheduled") &&
+		url.pathname === "/favicon.ico" &&
+		resp.status === 500
+	) {
+		return new Response(null, { status: 404 });
+	}
+
+	return resp;
 };
 
 export default scheduled;

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/pages-dev-pipeline.ts

@@ -1,8 +1,9 @@
 // @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__;
@@ -19,10 +20,11 @@ export default <ExportedHandler<{ ASSETS: Fetcher }>>{
 
 		for (const include of routes.include) {
 			if (isRoutingRuleMatch(pathname, include)) {
-				if (worker.fetch === undefined) {
+				const workerAsHandler = worker as ExportedHandler;
+				if (workerAsHandler.fetch === undefined) {
 					throw new TypeError("Entry point missing `fetch` handler");
 				}
-				return worker.fetch(request, env, context);
+				return workerAsHandler.fetch(request, env, context);
 			}
 		}
 

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

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 */