wrangler 2.1.7 → 2.1.9

package/src/dev.tsx

@@ -62,6 +62,7 @@ interface DevArgs {
 	"jsx-fragment"?: string;
 	tsconfig?: string;
 	local?: boolean;
+	"experimental-local"?: boolean;
 	minify?: boolean;
 	var?: string[];
 	define?: string[];
@@ -234,6 +235,20 @@ export function devOptions(yargs: Argv): Argv<DevArgs> {
 				type: "boolean",
 				default: false, // I bet this will a point of contention. We'll revisit it.
 			})
+			.option("experimental-local", {
+				describe: "Run on my machine using the Cloudflare Workers runtime",
+				type: "boolean",
+				default: false,
+			})
+			.check((argv) => {
+				if (argv.local && argv["experimental-local"]) {
+					throw new Error(
+						"--local and --experimental-local are mutually exclusive. " +
+							"Please select one or the other."
+					);
+				}
+				return true;
+			})
 			.option("minify", {
 				describe: "Minify the script",
 				type: "boolean",
@@ -405,7 +420,9 @@ export async function startDev(args: StartDevOptions) {
 					nodeCompat={nodeCompat}
 					build={configParam.build || {}}
 					define={{ ...configParam.define, ...cliDefines }}
-					initialMode={args.local ? "local" : "remote"}
+					initialMode={
+						args.local || args.experimentalLocal ? "local" : "remote"
+					}
 					jsxFactory={args["jsx-factory"] || configParam.jsx_factory}
 					jsxFragment={args["jsx-fragment"] || configParam.jsx_fragment}
 					tsconfig={args.tsconfig ?? configParam.tsconfig}
@@ -444,6 +461,7 @@ export async function startDev(args: StartDevOptions) {
 					firstPartyWorker={configParam.first_party_worker}
 					sendMetrics={configParam.send_metrics}
 					testScheduled={args["test-scheduled"]}
+					experimentalLocal={args.experimentalLocal}
 				/>
 			);
 		}
@@ -543,10 +561,13 @@ export async function startApiDev(args: StartDevOptions) {
 			isWorkersSite: Boolean(args.site || configParam.site),
 			compatibilityDate: getDevCompatibilityDate(
 				config,
-				args["compatibility-date"]
+				// Only `compatibilityDate` will be set when using `unstable_dev`
+				args["compatibility-date"] ?? args.compatibilityDate
 			),
 			compatibilityFlags:
-				args["compatibility-flags"] || configParam.compatibility_flags,
+				args["compatibility-flags"] ??
+				args.compatibilityFlags ??
+				configParam.compatibility_flags,
 			usageModel: configParam.usage_model,
 			bindings: bindings,
 			crons: configParam.triggers.crons,
@@ -560,6 +581,7 @@ export async function startApiDev(args: StartDevOptions) {
 			firstPartyWorker: configParam.first_party_worker,
 			sendMetrics: configParam.send_metrics,
 			testScheduled: args.testScheduled,
+			experimentalLocal: args.experimentalLocal,
 		});
 	}
 

package/src/init.ts

@@ -946,12 +946,16 @@ async function getWorkerConfig(
 			new Date().toISOString().substring(0, 10),
 		...routeOrRoutesToConfig,
 		usage_model: serviceEnvMetadata.script.usage_model,
-		migrations: [
-			{
-				tag: serviceEnvMetadata.script.migration_tag,
-				new_classes: durableObjectClassNames,
-			},
-		],
+		...(durableObjectClassNames.length
+			? {
+					migrations: [
+						{
+							tag: serviceEnvMetadata.script.migration_tag,
+							new_classes: durableObjectClassNames,
+						},
+					],
+			  }
+			: {}),
 		triggers: {
 			crons: cronTriggers.schedules.map((scheduled) => scheduled.cron),
 		},

package/src/module-collection.ts

@@ -7,6 +7,13 @@ import type { Config, ConfigModuleRuleType } from "./config";
 import type { CfModule, CfModuleType, CfScriptFormat } from "./worker";
 import type esbuild from "esbuild";
 
+function flipObject<
+	K extends string | number | symbol,
+	V extends string | number | symbol
+>(obj: Record<K, V>): Record<V, K> {
+	return Object.fromEntries(Object.entries(obj).map(([k, v]) => [v, k]));
+}
+
 const RuleTypeToModuleType: Record<ConfigModuleRuleType, CfModuleType> = {
 	ESModule: "esm",
 	CommonJS: "commonjs",
@@ -15,6 +22,8 @@ const RuleTypeToModuleType: Record<ConfigModuleRuleType, CfModuleType> = {
 	Text: "text",
 };
 
+export const ModuleTypeToRuleType = flipObject(RuleTypeToModuleType);
+
 // This is a combination of an esbuild plugin and a mutable array
 // that we use to collect module references from source code.
 // There will be modules that _shouldn't_ be inlined directly into

package/src/proxy.ts

@@ -1,8 +1,8 @@
 import { createServer as createHttpServer } from "node:http";
 import { connect } from "node:http2";
 import { createServer as createHttpsServer } from "node:https";
+import https from "node:https";
 import { networkInterfaces } from "node:os";
-import WebSocket from "faye-websocket";
 import { createHttpTerminator } from "http-terminator";
 import { useEffect, useRef, useState } from "react";
 import serveStatic from "serve-static";
@@ -19,12 +19,7 @@ import type {
 } from "node:http";
 import type { ClientHttp2Session, ServerHttp2Stream } from "node:http2";
 import type { Server as HttpsServer } from "node:https";
-import type ws from "ws";
-
-interface IWebsocket extends ws {
-	// Pipe implements .on("message", ...)
-	pipe<T>(fn: T): IWebsocket;
-}
+import type { Duplex, Writable } from "node:stream";
 
 /**
  * `usePreviewServer` is a React hook that creates a local development
@@ -70,6 +65,26 @@ function rewriteRemoteHostToLocalHostInHeaders(
 	}
 }
 
+function writeHead(
+	socket: Writable,
+	res: Pick<
+		IncomingMessage,
+		"httpVersion" | "statusCode" | "statusMessage" | "headers"
+	>
+) {
+	socket.write(
+		`HTTP/${res.httpVersion} ${res.statusCode} ${res.statusMessage}\r\n`
+	);
+	for (const [key, values] of Object.entries(res.headers)) {
+		if (Array.isArray(values)) {
+			for (const value of values) socket.write(`${key}: ${value}\r\n`);
+		} else {
+			socket.write(`${key}: ${values}\r\n`);
+		}
+	}
+	socket.write("\r\n");
+}
+
 type PreviewProxy = {
 	server: HttpServer | HttpsServer;
 	terminator: HttpTerminator;
@@ -273,27 +288,47 @@ export function usePreviewServer({
 
 		/** HTTP/1 -> WebSocket (over HTTP/1)  */
 		const handleUpgrade = (
-			message: IncomingMessage,
-			socket: WebSocket,
-			body: Buffer
+			originalMessage: IncomingMessage,
+			originalSocket: Duplex,
+			originalHead: Buffer
 		) => {
-			const { headers, url } = message;
+			const { headers, method, url } = originalMessage;
 			addCfPreviewTokenHeader(headers, previewToken.value);
 			headers["host"] = previewToken.host;
-			const localWebsocket = new WebSocket(message, socket, body) as IWebsocket;
-			// TODO(soon): Custom WebSocket protocol is not working?
-			const remoteWebsocketClient = new WebSocket.Client(
-				`wss://${previewToken.host}${url}`,
-				[],
-				{ headers }
-			) as IWebsocket;
-			localWebsocket.pipe(remoteWebsocketClient).pipe(localWebsocket);
-			// We close down websockets whenever we refresh the token.
-			cleanupListeners.push(() => {
-				localWebsocket.close();
-				remoteWebsocketClient.close();
-			});
+
+			if (originalHead?.byteLength) originalSocket.unshift(originalHead);
+
+			const runtimeRequest = https.request(
+				{
+					hostname: previewToken.host,
+					path: url,
+					method,
+					headers,
+				},
+				(runtimeResponse) => {
+					if (!(runtimeResponse as { upgrade?: boolean }).upgrade) {
+						writeHead(originalSocket, runtimeResponse);
+						runtimeResponse.pipe(originalSocket);
+					}
+				}
+			);
+
+			runtimeRequest.on(
+				"upgrade",
+				(runtimeResponse, runtimeSocket, runtimeHead) => {
+					if (runtimeHead?.byteLength) runtimeSocket.unshift(runtimeHead);
+					writeHead(originalSocket, {
+						httpVersion: "1.1",
+						statusCode: 101,
+						statusMessage: "Switching Protocols",
+						headers: runtimeResponse.headers,
+					});
+					runtimeSocket.pipe(originalSocket).pipe(runtimeSocket);
+				}
+			);
+			originalMessage.pipe(runtimeRequest);
 		};
+
 		proxy.server.on("upgrade", handleUpgrade);
 		cleanupListeners.push(() => proxy.server.off("upgrade", handleUpgrade));
 

package/src/publish.ts

@@ -434,6 +434,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 						// This could potentially cause issues as we no longer have identical behaviour between dev and publish?
 						targetConsumer: "publish",
 						local: false,
+						experimentalLocalStubCache: false,
 					}
 			  );
 

package/templates/experimental-local-cache-stubs.js

@@ -0,0 +1,27 @@
+// `workerd` currently throws on any use of the Cache API. Workers Sites
+// requires the Cache API to function though, so stub it out to no-ops, like in
+// regular `wrangler dev`.
+
+class Cache {
+	async put(req, res) {}
+
+	async match(req, options) {}
+
+	async delete(req, options) {
+		return false;
+	}
+}
+
+class CacheStorage {
+	#cache = new Cache();
+
+	get default() {
+		return this.#cache;
+	}
+
+	async open(cacheName) {
+		return this.#cache;
+	}
+}
+
+globalThis.caches = new CacheStorage();

package/templates/new-worker.js

@@ -9,7 +9,7 @@
  */
 
 export default {
-	async fetch(request) {
+	async fetch(request, env, ctx) {
 		return new Response("Hello World!");
 	},
 };

package/wrangler-dist/cli.d.ts

@@ -127,6 +127,7 @@ declare interface DevOptions {
     _?: (string | number)[];
     $0?: string;
     testScheduled?: boolean;
+    experimentalLocal?: boolean;
 }
 
 declare interface EnablePagesAssetsServiceBindingOptions {