wrangler 0.0.0-e3278fa → 0.0.0-e33bea9b

package/templates/middleware/loader-sw.ts

@@ -0,0 +1,233 @@
+import {
+	Awaitable,
+	Dispatcher,
+	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
+// 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`
+// isn't exposed on the global scope, but `WorkerGlobalScope` (which extends
+// `ThrowingEventTarget`) is. Therefore, we get at it in this nasty way.
+let __FACADE_EVENT_TARGET__: EventTarget;
+if ((globalThis as any).MINIFLARE) {
+	__FACADE_EVENT_TARGET__ = new (Object.getPrototypeOf(WorkerGlobalScope))();
+} else {
+	__FACADE_EVENT_TARGET__ = new EventTarget();
+}
+
+function __facade_isSpecialEvent__(
+	type: string
+): type is "fetch" | "scheduled" {
+	return type === "fetch" || type === "scheduled";
+}
+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 as EventListenerOrEventListenerObject,
+			options
+		);
+	} else {
+		__facade__originalAddEventListener__(type, listener, options);
+	}
+};
+globalThis.removeEventListener = function (type, listener, options) {
+	if (__facade_isSpecialEvent__(type)) {
+		__FACADE_EVENT_TARGET__.removeEventListener(
+			type,
+			listener as EventListenerOrEventListenerObject,
+			options
+		);
+	} else {
+		__facade__originalRemoveEventListener__(type, listener, options);
+	}
+};
+globalThis.dispatchEvent = function (event) {
+	if (__facade_isSpecialEvent__(event.type)) {
+		return __FACADE_EVENT_TARGET__.dispatchEvent(event);
+	} else {
+		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__");
+
+class __Facade_ExtendableEvent__ extends Event {
+	[__facade_waitUntil__]: Awaitable<unknown>[] = [];
+
+	waitUntil(promise: Awaitable<any>) {
+		if (!(this instanceof __Facade_ExtendableEvent__)) {
+			throw new TypeError("Illegal invocation");
+		}
+		this[__facade_waitUntil__].push(promise);
+	}
+}
+
+interface FetchEventInit extends EventInit {
+	request: Request;
+	passThroughOnException: FetchEvent["passThroughOnException"];
+}
+
+class __Facade_FetchEvent__ extends __Facade_ExtendableEvent__ {
+	#request: Request;
+	#passThroughOnException: FetchEvent["passThroughOnException"];
+	[__facade_response__]?: Awaitable<Response>;
+	[__facade_dispatched__] = false;
+
+	constructor(type: "fetch", init: FetchEventInit) {
+		super(type);
+		this.#request = init.request;
+		this.#passThroughOnException = init.passThroughOnException;
+	}
+
+	get request() {
+		return this.#request;
+	}
+
+	respondWith(response: Awaitable<Response>) {
+		if (!(this instanceof __Facade_FetchEvent__)) {
+			throw new TypeError("Illegal invocation");
+		}
+		if (this[__facade_response__] !== undefined) {
+			throw new DOMException(
+				"FetchEvent.respondWith() has already been called; it can only be called once.",
+				"InvalidStateError"
+			);
+		}
+		if (this[__facade_dispatched__]) {
+			throw new DOMException(
+				"Too late to call FetchEvent.respondWith(). It must be called synchronously in the event handler.",
+				"InvalidStateError"
+			);
+		}
+		this.stopImmediatePropagation();
+		this[__facade_response__] = response;
+	}
+
+	passThroughOnException() {
+		if (!(this instanceof __Facade_FetchEvent__)) {
+			throw new TypeError("Illegal invocation");
+		}
+		// Need to call native method immediately in case uncaught error thrown
+		this.#passThroughOnException();
+	}
+}
+
+interface ScheduledEventInit extends EventInit {
+	scheduledTime: number;
+	cron: string;
+	noRetry: ScheduledEvent["noRetry"];
+}
+
+class __Facade_ScheduledEvent__ extends __Facade_ExtendableEvent__ {
+	#scheduledTime: number;
+	#cron: string;
+	#noRetry: ScheduledEvent["noRetry"];
+
+	constructor(type: "scheduled", init: ScheduledEventInit) {
+		super(type);
+		this.#scheduledTime = init.scheduledTime;
+		this.#cron = init.cron;
+		this.#noRetry = init.noRetry;
+	}
+
+	get scheduledTime() {
+		return this.#scheduledTime;
+	}
+
+	get cron() {
+		return this.#cron;
+	}
+
+	noRetry() {
+		if (!(this instanceof __Facade_ScheduledEvent__)) {
+			throw new TypeError("Illegal invocation");
+		}
+		// Need to call native method immediately in case uncaught error thrown
+		this.#noRetry();
+	}
+}
+
+__facade__originalAddEventListener__("fetch", (event) => {
+	const ctx: ExecutionContext = {
+		waitUntil: event.waitUntil.bind(event),
+		passThroughOnException: event.passThroughOnException.bind(event),
+	};
+
+	const __facade_sw_dispatch__: Dispatcher = function (type, init) {
+		if (type === "scheduled") {
+			const facadeEvent = new __Facade_ScheduledEvent__("scheduled", {
+				scheduledTime: Date.now(),
+				cron: init.cron ?? "",
+				noRetry() {},
+			});
+
+			__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__]));
+		}
+	};
+
+	const __facade_sw_fetch__: Middleware = function (request, _env, ctx) {
+		const facadeEvent = new __Facade_FetchEvent__("fetch", {
+			request,
+			passThroughOnException: ctx.passThroughOnException,
+		});
+
+		__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__];
+		if (response === undefined) {
+			throw new Error("No response!"); // TODO: proper error message
+		}
+		return response;
+	};
+
+	event.respondWith(
+		__facade_invoke__(
+			event.request,
+			globalThis,
+			ctx,
+			__facade_sw_dispatch__,
+			__facade_sw_fetch__
+		)
+	);
+});
+
+__facade__originalAddEventListener__("scheduled", (event) => {
+	const facadeEvent = new __Facade_ScheduledEvent__("scheduled", {
+		scheduledTime: event.scheduledTime,
+		cron: event.cron,
+		noRetry: event.noRetry.bind(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-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-pretty-error.ts

@@ -0,0 +1,40 @@
+import type { Middleware } from "./common";
+
+// A middleware has to be a function of type Middleware
+const prettyError: Middleware = async (request, env, _ctx, middlewareCtx) => {
+	try {
+		const response = await middlewareCtx.next(request, env);
+		return response;
+	} catch (e: any) {
+		const html = `
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta http-equiv="X-UA-Compatible" content="IE=edge">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Error 🚨</title>
+        <style>
+          pre {
+            margin: 16px auto;
+            max-width: 600px;
+            background-color: #eeeeee;
+            border-radius: 4px;
+            padding: 16px;
+          }
+        </style>
+    </head>
+    <body>
+        <pre>${e.stack}</pre>
+    </body>
+    </html>
+    `;
+
+		return new Response(html, {
+			status: 500,
+			headers: { "Content-Type": "text/html;charset=utf-8" },
+		});
+	}
+};
+
+export default prettyError;

package/templates/middleware/middleware-scheduled.ts

@@ -0,0 +1,15 @@
+import type { Middleware } from "./common";
+
+// A middleware has to be a function of type Middleware
+const scheduled: Middleware = async (request, env, _ctx, middlewareCtx) => {
+	const url = new URL(request.url);
+	if (url.pathname === "/__scheduled") {
+		const cron = url.searchParams.get("cron") ?? "";
+		await middlewareCtx.dispatch("scheduled", { cron });
+
+		return new Response("Ran scheduled event");
+	}
+	return middlewareCtx.next(request, env);
+};
+
+export default scheduled;

package/templates/new-worker-scheduled.js

@@ -11,7 +11,7 @@
  */
 
 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

@@ -11,22 +11,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 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, env, ctx) {
+		return new Response("Hello World!");
+	},
 };

package/templates/new-worker.ts

@@ -9,22 +9,25 @@
  */
 
 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;
+	//
+	// Example binding to a Service. Learn more at https://developers.cloudflare.com/workers/runtime-apis/service-bindings/
+	// MY_SERVICE: Fetcher;
 }
 
 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-dev-pipeline.ts

@@ -0,0 +1,31 @@
+// @ts-ignore entry point will get replaced
+import worker from "__ENTRY_POINT__";
+// @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 <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,52 @@
+/**
+ * @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.replace("*", ".*")}$`;
+
+	// ^/foo.*$ => /^\/foo.*$/
+	return new RegExp(transformedRule);
+}

package/templates/pages-shim.ts

@@ -0,0 +1,12 @@
+// 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) {
+		// @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);
+	},
+};