wrangler 0.0.0-e7cf0caa → 0.0.0-e81b1611

package/templates/middleware/common.ts

@@ -5,13 +5,18 @@ export type Dispatcher = (
 	init: { cron?: string }
 ) => Awaitable<void>;
 
+export type IncomingRequest = Request<
+	unknown,
+	IncomingRequestCfProperties<unknown>
+>;
+
 export interface MiddlewareContext {
 	dispatch: Dispatcher;
-	next(request: Request, env: any): Awaitable<Response>;
+	next(request: IncomingRequest, env: any): Awaitable<Response>;
 }
 
 export type Middleware = (
-	request: Request,
+	request: IncomingRequest,
 	env: any,
 	ctx: ExecutionContext,
 	middlewareCtx: MiddlewareContext
@@ -32,7 +37,7 @@ export function __facade_registerInternal__(
 }
 
 function __facade_invokeChain__(
-	request: Request,
+	request: IncomingRequest,
 	env: any,
 	ctx: ExecutionContext,
 	dispatch: Dispatcher,
@@ -49,7 +54,7 @@ function __facade_invokeChain__(
 }
 
 export function __facade_invoke__(
-	request: Request,
+	request: IncomingRequest,
 	env: any,
 	ctx: ExecutionContext,
 	dispatch: Dispatcher,

package/templates/middleware/loader-modules.ts

@@ -36,17 +36,68 @@ 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
+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);
 };
 
-const facade: ExportedHandler<unknown> = {
-	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);
+		}
+	}
+	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" | "email" | "fetch"
+>;
+
+let registeredMiddleware = false;
+
+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),
+	}),
+	...(worker.email && {
+		email: maskHandlerEnv(worker.email),
+	}),
+
+	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);
+			// Make sure we only register middleware once:
+			// https://github.com/cloudflare/workers-sdk/issues/2386#issuecomment-1614715911
+			if (!registeredMiddleware) {
+				registeredMiddleware = true;
+				for (const middleware of worker.middleware) {
+					__facade_register__(middleware);
+				}
 			}
 
 			const __facade_modules_dispatch__: Dispatcher = function (type, init) {
@@ -71,14 +122,16 @@ const facade: ExportedHandler<unknown> = {
 			// 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
+			// We "don't care" if this is undefined as we want to have the same behavior
 			// as if the worker completely bypassed middleware.
-			return worker.fetch!(request, env, ctx);
+			return __facade_modules_fetch__(request, env, ctx);
 		}
 	},
-	scheduled: worker.scheduled,
-	queue: worker.queue,
-	trace: worker.trace,
 };
 
+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;

package/templates/middleware/loader-sw.ts

@@ -1,6 +1,7 @@
 import {
 	Awaitable,
 	Dispatcher,
+	IncomingRequest,
 	Middleware,
 	__facade_invoke__,
 	__facade_register__,
@@ -183,8 +184,6 @@ __facade__originalAddEventListener__("fetch", (event) => {
 			});
 
 			__FACADE_EVENT_TARGET__.dispatchEvent(facadeEvent);
-			// @ts-expect-error `waitUntil` types are currently broken, blocked on
-			// https://github.com/cloudflare/workerd/pull/191
 			event.waitUntil(Promise.all(facadeEvent[__facade_waitUntil__]));
 		}
 	};
@@ -197,8 +196,6 @@ __facade__originalAddEventListener__("fetch", (event) => {
 
 		__FACADE_EVENT_TARGET__.dispatchEvent(facadeEvent);
 		facadeEvent[__facade_dispatched__] = true;
-		// @ts-expect-error `waitUntil` types are currently broken, blocked on
-		// https://github.com/cloudflare/workerd/pull/191
 		event.waitUntil(Promise.all(facadeEvent[__facade_waitUntil__]));
 
 		const response = facadeEvent[__facade_response__];
@@ -210,7 +207,7 @@ __facade__originalAddEventListener__("fetch", (event) => {
 
 	event.respondWith(
 		__facade_invoke__(
-			event.request,
+			event.request as IncomingRequest,
 			globalThis,
 			ctx,
 			__facade_sw_dispatch__,
@@ -227,7 +224,5 @@ __facade__originalAddEventListener__("scheduled", (event) => {
 	});
 
 	__FACADE_EVENT_TARGET__.dispatchEvent(facadeEvent);
-	// @ts-expect-error `waitUntil` types are currently broken, blocked on
-	// https://github.com/cloudflare/workerd/pull/191
 	event.waitUntil(Promise.all(facadeEvent[__facade_waitUntil__]));
 });

package/templates/middleware/middleware-d1-beta.d.ts

@@ -0,0 +1,3 @@
+declare module "config:middleware/d1-beta" {
+	export const D1_IMPORTS: string[];
+}

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

@@ -30,3 +30,4 @@ const jsonError: Middleware = async (request, env, _ctx, middlewareCtx) => {
 };
 
 export default jsonError;
+export const wrap = undefined;

package/templates/middleware/middleware-multiworker-dev.d.ts

@@ -0,0 +1,4 @@
+declare module "config:middleware/multiworker-dev" {
+	import type { WorkerRegistry } from "../../src/dev-registry";
+	export const workers: WorkerRegistry;
+}

package/templates/middleware/middleware-multiworker-dev.ts

@@ -0,0 +1,68 @@
+// @ts-nocheck
+/// <reference path="middleware-multiworker-dev.d.ts"/>
+
+import { workers } from "config:middleware/multiworker-dev";
+import type { WorkerRegistry } from "../../src/dev-registry";
+
+class Fetcher {
+	#name: string;
+	#details: WorkerRegistry[string];
+	constructor(name: string, details: WorkerRegistry[string]) {
+		this.#name = name;
+		this.#details = details;
+	}
+
+	async fetch(...reqArgs: Parameters<Fetcher["fetch"]>) {
+		const reqFromArgs = new Request(...reqArgs);
+		if (this.#details.headers) {
+			for (const [key, value] of Object.entries(this.#details.headers)) {
+				// In remote mode, you need to add a couple of headers
+				// to make sure it's talking to the 'dev' preview session
+				// (much like wrangler dev already does via proxy.ts)
+				reqFromArgs.headers.set(key, value);
+			}
+			return (env[this.#name] as Fetcher).fetch(reqFromArgs);
+		}
+
+		const url = new URL(reqFromArgs.url);
+		if (this.#details.protocol !== undefined) {
+			url.protocol = this.#details.protocol;
+		}
+		if (this.#details.host !== undefined) {
+			url.host = this.#details.host;
+		}
+		if (this.#details.port !== undefined) {
+			url.port = this.#details.port.toString();
+		}
+
+		const request = new Request(url.toString(), reqFromArgs);
+		return fetch(request);
+	}
+}
+
+export function wrap(env: Record<string, unknown>) {
+	const facadeEnv = { ...env };
+	// For every Worker definition that's available,
+	// create a fetcher for it on the facade env.
+	// for const [name,  binding] of env
+	// if Workers[name]
+	// const details = Workers[name];
+
+	for (const [name, details] of Object.entries(workers as WorkerRegistry)) {
+		if (details) {
+			facadeEnv[name] = new Fetcher(name, details);
+		} else {
+			// This means there's no dev binding available.
+			// Let's use whatever's available, or put a shim with a message.
+			facadeEnv[name] = facadeEnv[name] || {
+				async fetch() {
+					return new Response(
+						`You should start up wrangler dev --local on the ${name} worker`,
+						{ status: 404 }
+					);
+				},
+			};
+		}
+	}
+	return facadeEnv;
+}

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 {
+	getAssetFromKV,
+	NotFoundError,
+	MethodNotAllowedError,
+	serveSinglePageApp,
+} from "@cloudflare/kv-asset-handler";
+import type { Options } from "@cloudflare/kv-asset-handler";
+import { spaMode, cacheControl } from "config:middleware/serve-static-assets";
+import type * as kvAssetHandler from "@cloudflare/kv-asset-handler";
+import manifest from "__STATIC_CONTENT_MANIFEST";
+const ASSET_MANIFEST = JSON.parse(manifest);
+
+import type { Middleware } from "./common";
+
+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/
  */

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

@@ -3,9 +3,6 @@
 
 export default <ExportedHandler<{ ASSETS: Fetcher }>>{
 	async fetch(request, env, context) {
-		// @ts-expect-error due to a bug in `@cloudflare/workers-types`, the `cf`
-		//  types from the `request` parameter and `RequestInit` are incompatible.
-		//  We'll get this fixed very soon.
 		const response = await env.ASSETS.fetch(request.url, request);
 		return new Response(response.body, response);
 	},

package/templates/pages-template-plugin.ts

@@ -122,7 +122,8 @@ function* executeRequest(request: Request, relativePathname: string) {
 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.
@@ -149,7 +150,16 @@ export default function (pluginArgs: unknown) {
 					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),

package/templates/pages-template-worker.ts

@@ -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: () => {

package/templates/tsconfig.json

@@ -1,5 +1,5 @@
 {
-	"extends": "../tsconfig.json",
+	"extends": "@cloudflare/workers-tsconfig/tsconfig.json",
 	"compilerOptions": {
 		"types": ["@cloudflare/workers-types"]
 	},