wrangler 2.0.29 → 2.1.2

package/src/pages/upload.tsx

@@ -1,14 +1,5 @@
 import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
-import {
-	basename,
-	dirname,
-	extname,
-	join,
-	relative,
-	resolve,
-	sep,
-} from "node:path";
-import { hash as blake3hash } from "blake3-wasm";
+import { dirname, join, relative, resolve, sep } from "node:path";
 import { render, Text } from "ink";
 import Spinner from "ink-spinner";
 import { getType } from "mime";
@@ -25,6 +16,7 @@ import {
 	MAX_CHECK_MISSING_ATTEMPTS,
 	MAX_UPLOAD_ATTEMPTS,
 } from "./constants";
+import { hashFile } from "./hash";
 import { pagesBetaWarning } from "./utils";
 import type { UploadPayloadFile, YargsOptionsToInterface } from "./types";
 import type { Argv } from "yargs";
@@ -144,11 +136,6 @@ export const upload = async (
 				} else {
 					const name = relative(startingDir, filepath).split(sep).join("/");
 
-					const fileContent = await readFile(filepath);
-
-					const base64Content = fileContent.toString("base64");
-					const extension = extname(basename(name)).substring(1);
-
 					if (filestat.size > 25 * 1024 * 1024) {
 						throw new FatalError(
 							`Error: Pages only supports files up to ${prettyBytes(
@@ -163,9 +150,7 @@ export const upload = async (
 						path: filepath,
 						contentType: getType(name) || "application/octet-stream",
 						sizeInBytes: filestat.size,
-						hash: blake3hash(base64Content + extension)
-							.toString("hex")
-							.slice(0, 32),
+						hash: hashFile(filepath),
 					});
 				}
 			})

package/src/publish.ts

@@ -8,7 +8,7 @@ import { printBundleSize } from "./bundle-reporter";
 import { fetchListResult, fetchResult } from "./cfetch";
 import { printBindings } from "./config";
 import { createWorkerUploadForm } from "./create-worker-upload-form";
-import { confirm } from "./dialogs";
+import { confirm, fromDashMessagePrompt } from "./dialogs";
 import { getMigrationsToUpload } from "./durable";
 import { logger } from "./logger";
 import { getMetricsUsageHeaders } from "./metrics";
@@ -218,11 +218,38 @@ Update them to point to this script instead?`;
 
 export default async function publish(props: Props): Promise<void> {
 	// TODO: warn if git/hg has uncommitted changes
-	const { config, accountId } = props;
+	const { config, accountId, name } = props;
+	if (accountId && name) {
+		try {
+			const serviceMetaData = await fetchResult(
+				`/accounts/${accountId}/workers/services/${name}`
+			);
+			const { default_environment } = serviceMetaData as {
+				default_environment: {
+					script: { last_deployed_from: "dash" | "wrangler" | "api" };
+				};
+			};
+
+			if (
+				(await fromDashMessagePrompt(
+					default_environment.script.last_deployed_from
+				)) === false
+			)
+				return;
+		} catch (e) {
+			// code: 10090, message: workers.api.error.service_not_found
+			// is thrown from the above fetchResult on the first publish of a Worker
+			if ((e as { code?: number }).code !== 10090) {
+				logger.error(e);
+			}
+		}
+	}
 
 	if (!(props.compatibilityDate || config.compatibility_date)) {
 		const compatibilityDateStr = `${new Date().getFullYear()}-${(
-			new Date().getMonth() + ""
+			new Date().getMonth() +
+			1 +
+			""
 		).padStart(2, "0")}-${(new Date().getDate() + "").padStart(2, "0")}`;
 
 		throw new Error(`A compatibility_date is required when publishing. Add the following to your wrangler.toml file:.
@@ -397,6 +424,9 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 						// facades on top of it
 						workerDefinitions: undefined,
 						firstPartyWorkerDevFacade: false,
+						// We want to know if the build is for development or publishing
+						// This could potentially cause issues as we no longer have identical behaviour between dev and publish?
+						targetConsumer: "publish",
 					}
 			  );
 
@@ -475,10 +505,14 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 			keep_bindings: true,
 		};
 
-		void printBundleSize(
+		// As this is not deterministic for testing, we detect if in a jest environment and run asynchronously
+		// We do not care about the timing outside of testing
+		const bundleSizePromise = printBundleSize(
 			{ name: path.basename(resolvedEntryPointPath), content: content },
 			modules
 		);
+		if (process.env.JEST_WORKER_ID !== undefined) await bundleSizePromise;
+		else void bundleSizePromise;
 
 		const withoutStaticAssets = {
 			...bindings,

package/src/tail/filters.ts

@@ -122,7 +122,6 @@ type QueryFilter = {
  */
 export type TailFilterMessage = {
 	filters: TailAPIFilter[];
-	debug: boolean;
 };
 
 /**
@@ -130,12 +129,10 @@ export type TailFilterMessage = {
  * into a message that we can send to the tail worker.
  *
  * @param cliFilters An object containing all the filters passed in from the CLI
- * @param debug Whether or not we should be in debug mode
  * @returns A filter message ready to be sent to the tail worker
  */
 export function translateCLICommandToFilterMessage(
-	cliFilters: TailCLIFilters,
-	debug: boolean
+	cliFilters: TailCLIFilters
 ): TailFilterMessage {
 	const apiFilters: TailAPIFilter[] = [];
 
@@ -165,7 +162,6 @@ export function translateCLICommandToFilterMessage(
 
 	return {
 		filters: apiFilters,
-		debug,
 	};
 }
 

package/src/tail/index.ts

@@ -69,13 +69,15 @@ function makeDeleteTailUrl(
  *
  * @param accountId the account ID associated with the worker to tail
  * @param workerName the name of the worker to tail
- * @param message a `TailFilterMessage` to send up to the tail worker
+ * @param filters A list of `TailAPIFilters` given to the tail
+ * @param debug Flag to run tail in debug mode
  * @returns a websocket connection, an expiration, and a function to call to delete the tail
  */
 export async function createTail(
 	accountId: string,
 	workerName: string,
-	message: TailFilterMessage,
+	filters: TailFilterMessage,
+	debug: boolean,
 	env: string | undefined
 ): Promise<{
 	tail: WebSocket;
@@ -90,6 +92,7 @@ export async function createTail(
 		expires_at: expiration,
 	} = await fetchResult<TailCreationApiResponse>(createTailUrl, {
 		method: "POST",
+		body: JSON.stringify(filters),
 	});
 
 	// delete the tail (not yet!)
@@ -109,7 +112,7 @@ export async function createTail(
 	// send filters when we open up
 	tail.on("open", function () {
 		tail.send(
-			JSON.stringify(message),
+			JSON.stringify({ debug: debug }),
 			{ binary: false, compress: false, mask: false, fin: true },
 			(err) => {
 				if (err) {

package/templates/middleware/common.ts

@@ -0,0 +1,62 @@
+export type Awaitable<T> = T | Promise<T>;
+// TODO: allow dispatching more events?
+export type Dispatcher = (
+	type: "scheduled",
+	init: { cron?: string }
+) => Awaitable<void>;
+
+export interface MiddlewareContext {
+	dispatch: Dispatcher;
+	next(request: Request, env: any): Awaitable<Response>;
+}
+
+export type Middleware = (
+	request: Request,
+	env: any,
+	ctx: ExecutionContext,
+	middlewareCtx: MiddlewareContext
+) => Awaitable<Response>;
+
+const __facade_middleware__: Middleware[] = [];
+
+// The register functions allow for the insertion of one or many middleware,
+// We register internal middleware first in the stack, but have no way of controlling
+// the order that addMiddleware is run in service workers so need an internal function.
+export function __facade_register__(...args: (Middleware | Middleware[])[]) {
+	__facade_middleware__.push(...args.flat());
+}
+export function __facade_registerInternal__(
+	...args: (Middleware | Middleware[])[]
+) {
+	__facade_middleware__.unshift(...args.flat());
+}
+
+function __facade_invokeChain__(
+	request: Request,
+	env: any,
+	ctx: ExecutionContext,
+	dispatch: Dispatcher,
+	middlewareChain: Middleware[]
+): Awaitable<Response> {
+	const [head, ...tail] = middlewareChain;
+	const middlewareCtx: MiddlewareContext = {
+		dispatch,
+		next(newRequest, newEnv) {
+			return __facade_invokeChain__(newRequest, newEnv, ctx, dispatch, tail);
+		},
+	};
+	return head(request, env, ctx, middlewareCtx);
+}
+
+export function __facade_invoke__(
+	request: Request,
+	env: any,
+	ctx: ExecutionContext,
+	dispatch: Dispatcher,
+	finalMiddleware: Middleware
+): Awaitable<Response> {
+	return __facade_invokeChain__(request, env, ctx, dispatch, [
+		...__facade_middleware__,
+		finalMiddleware,
+	]);
+}

package/templates/middleware/loader-modules.ts

@@ -0,0 +1,84 @@
+// // 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";
+
+// @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
+export * from "__ENTRY_POINT__";
+
+class __Facade_ScheduledController__ implements ScheduledController {
+	#noRetry: ScheduledController["noRetry"];
+
+	constructor(
+		readonly scheduledTime: number,
+		readonly cron: string,
+		noRetry: ScheduledController["noRetry"]
+	) {
+		this.#noRetry = noRetry;
+	}
+
+	noRetry() {
+		if (!(this instanceof __Facade_ScheduledController__)) {
+			throw new TypeError("Illegal invocation");
+		}
+		// Need to call native method immediately in case uncaught error thrown
+		this.#noRetry();
+	}
+}
+
+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);
+};
+
+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 __facade_modules_dispatch__: Dispatcher = function (type, init) {
+				if (type === "scheduled" && worker.scheduled !== undefined) {
+					const controller = new __Facade_ScheduledController__(
+						Date.now(),
+						init.cron ?? "",
+						() => {}
+					);
+					return worker.scheduled(controller, env, ctx);
+				}
+			};
+
+			return __facade_invoke__(
+				request,
+				env,
+				ctx,
+				__facade_modules_dispatch__,
+				__facade_modules_fetch__
+			);
+		} 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;

package/templates/middleware/loader-sw.ts

@@ -0,0 +1,213 @@
+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`
+// 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();
+}
+
+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) {
+	return type === "fetch" || type === "scheduled";
+}
+globalThis.__facade_addEventListener__ = function (type, listener, options) {
+	if (__facade_isSpecialEvent__(type)) {
+		__FACADE_EVENT_TARGET__.addEventListener(type, listener, options);
+	} else {
+		globalThis.addEventListener(type as any, listener, options);
+	}
+};
+globalThis.__facade_removeEventListener__ = function (type, listener, options) {
+	if (__facade_isSpecialEvent__(type)) {
+		__FACADE_EVENT_TARGET__.removeEventListener(type, listener, options);
+	} else {
+		globalThis.removeEventListener(type as any, listener, options);
+	}
+};
+globalThis.__facade_dispatchEvent__ = function (event) {
+	if (__facade_isSpecialEvent__(event.type)) {
+		__FACADE_EVENT_TARGET__.dispatchEvent(event);
+	} else {
+		globalThis.dispatchEvent(event as any);
+	}
+};
+
+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();
+	}
+}
+
+globalThis.addEventListener("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);
+			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;
+		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__
+		)
+	);
+});
+
+globalThis.addEventListener("scheduled", (event) => {
+	const facadeEvent = new __Facade_ScheduledEvent__("scheduled", {
+		scheduledTime: event.scheduledTime,
+		cron: event.cron,
+		noRetry: event.noRetry.bind(event),
+	});
+
+	__FACADE_EVENT_TARGET__.dispatchEvent(facadeEvent);
+	event.waitUntil(Promise.all(facadeEvent[__facade_waitUntil__]));
+});

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,14 @@
+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("OK");
+	}
+	return middlewareCtx.next(request, env);
+};
+
+export default scheduled;