wrangler 2.1.8 → 2.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrangler",
-	"version": "2.1.8",
+	"version": "2.1.9",
 	"description": "Command-line interface for all things Cloudflare Workers",
 	"keywords": [
 		"wrangler",
@@ -112,7 +112,7 @@
 		"@databases/sql": "^3.2.0",
 		"@iarna/toml": "^3.0.0",
 		"@microsoft/api-extractor": "^7.28.3",
-		"@miniflare/tre": "3.0.0-next.1",
+		"@miniflare/tre": "3.0.0-next.2",
 		"@types/better-sqlite3": "^7.6.0",
 		"@types/busboy": "^1.5.0",
 		"@types/command-exists": "^1.2.0",
@@ -139,7 +139,6 @@
 		"dotenv": "^16.0.0",
 		"execa": "^6.1.0",
 		"express": "^4.18.1",
-		"faye-websocket": "^0.11.4",
 		"finalhandler": "^1.2.0",
 		"find-up": "^6.3.0",
 		"get-port": "^6.1.2",

package/src/__tests__/dev.test.tsx

@@ -1022,6 +1022,7 @@ describe("wrangler dev", () => {
 			      --jsx-fragment                               The function that is called for each JSX fragment  [string]
 			      --tsconfig                                   Path to a custom tsconfig.json file  [string]
 			  -l, --local                                      Run on my machine  [boolean] [default: false]
+			      --experimental-local                         Run on my machine using the Cloudflare Workers runtime  [boolean] [default: false]
 			      --minify                                     Minify the script  [boolean]
 			      --node-compat                                Enable node.js compatibility  [boolean]
 			      --persist                                    Enable persistence for local mode, using default path: .wrangler/state  [boolean]
@@ -1325,18 +1326,18 @@ describe("wrangler dev", () => {
 			fs.writeFileSync("index.js", `export default {};`);
 			await runWrangler("dev index.js");
 			expect(std).toMatchInlineSnapshot(`
-			        Object {
-			          "debug": "",
-			          "err": "",
-			          "out": "Using vars defined in .dev.vars
-			        Your worker has access to the following bindings:
-			        - Vars:
-			          - variable: \\"123\\"
-			          - overriden: \\"(hidden)\\"
-			          - SECRET: \\"(hidden)\\"",
-			          "warn": "",
-			        }
-		      `);
+			Object {
+			  "debug": "",
+			  "err": "",
+			  "out": "Using vars defined in .dev.vars
+			Your worker has access to the following bindings:
+			- Vars:
+			  - variable: 123
+			  - overriden: \\"(hidden)\\"
+			  - SECRET: \\"(hidden)\\"",
+			  "warn": "",
+			}
+		`);
 		});
 	});
 });

package/src/__tests__/init.test.ts

@@ -2608,6 +2608,105 @@ describe("init", () => {
 			).rejects.toThrowError();
 		});
 
+		it("should not inlcude migrations in config file when none are necessary", async () => {
+			const mockDate = "1988-08-07";
+			jest
+				.spyOn(Date.prototype, "toISOString")
+				.mockImplementation(() => `${mockDate}T00:00:00.000Z`);
+			const mockData = {
+				id: "memory-crystal",
+				default_environment: {
+					environment: "test",
+					created_on: "1988-08-07",
+					modified_on: "1988-08-07",
+					script: {
+						id: "memory-crystal",
+						tag: "test-tag",
+						etag: "some-etag",
+						handlers: [],
+						modified_on: "1988-08-07",
+						created_on: "1988-08-07",
+						usage_model: "bundled",
+						compatibility_date: "1988-08-07",
+					},
+				},
+				environments: [],
+			};
+
+			setMockResponse(
+				`/accounts/:accountId/workers/services/:scriptName`,
+				"GET",
+				() => mockData
+			);
+			setMockResponse(
+				`/accounts/:accountId/workers/services/:scriptName/environments/:environment/bindings`,
+				"GET",
+				() => []
+			);
+			setMockResponse(
+				`/accounts/:accountId/workers/services/:scriptName/environments/:environment/routes`,
+				"GET",
+				() => []
+			);
+			setMockResponse(
+				`/accounts/:accountId/workers/services/:scriptName/environments/:environment`,
+				"GET",
+				() => mockServiceMetadata.default_environment
+			);
+			setMockResponse(
+				`/accounts/:accountId/workers/scripts/:scriptName/schedules`,
+				"GET",
+				() => {
+					return {
+						schedules: [],
+					};
+				}
+			);
+
+			setMockFetchDashScript({
+				accountId: "LCARS",
+				fromDashScriptName: "isolinear-optical-chip",
+				environment: mockServiceMetadata.default_environment.environment,
+				mockResponse: mockDashboardScript,
+			});
+
+			mockConfirm(
+				{
+					text: "Would you like to use git to manage this Worker?",
+					result: false,
+				},
+				{
+					text: "Would you like to use TypeScript?",
+					result: true,
+				},
+				{
+					text: "No package.json found. Would you like to create one?",
+					result: true,
+				},
+				{
+					text: "Would you like to install the type definitions for Workers into your package.json?",
+					result: true,
+				}
+			);
+
+			await runWrangler("init  --from-dash isolinear-optical-chip");
+
+			checkFiles({
+				items: {
+					"isolinear-optical-chip/wrangler.toml": wranglerToml({
+						compatibility_date: "1988-08-07",
+						env: {},
+						main: "src/index.ts",
+						triggers: {
+							crons: [],
+						},
+						usage_model: "bundled",
+						name: "isolinear-optical-chip",
+					}),
+				},
+			});
+		});
+
 		it("should not continue if no worker name is provided", async () => {
 			await expect(
 				runWrangler("init  --from-dash")

package/src/__tests__/publish.test.ts

@@ -512,7 +512,7 @@ describe("publish", () => {
 		"Total Upload: xx KiB / gzip: xx KiB
 		Your worker has access to the following bindings:
 		- Vars:
-		  - xyz: \\"123\\"
+		  - xyz: 123
 		Uploaded test-name (TIMINGS)
 		Published test-name (TIMINGS)
 		  https://test-name.test-sub-domain.workers.dev"
@@ -4527,7 +4527,7 @@ addEventListener('fetch', event => {});`
 			  - some unsafe thing: UNSAFE_BINDING_ONE
 			  - another unsafe thing: UNSAFE_BINDING_TWO
 			- Vars:
-			  - ENV_VAR_ONE: \\"123\\"
+			  - ENV_VAR_ONE: 123
 			  - ENV_VAR_TWO: \\"Hello, I'm an environment variable\\"
 			- Wasm Modules:
 			  - WASM_MODULE_ONE: some_wasm.wasm
@@ -5275,8 +5275,11 @@ addEventListener('fetch', event => {});`
 			Your worker has access to the following bindings:
 			- Vars:
 			  - text: \\"plain ol' string\\"
-			  - count: \\"1\\"
-			  - complex: \\"[object Object]\\"
+			  - count: 1
+			  - complex: {
+			 \\"enabled\\": true,
+			 \\"id\\": 123
+			}
 			Uploaded test-name (TIMINGS)
 			Published test-name (TIMINGS)
 			  https://test-name.test-sub-domain.workers.dev"

package/src/api/dev.ts

@@ -54,6 +54,7 @@ interface DevOptions {
 	_?: (string | number)[]; //yargs wants this
 	$0?: string; //yargs wants this
 	testScheduled?: boolean;
+	experimentalLocal?: boolean;
 }
 
 interface DevApiOptions {

package/src/config/index.ts

@@ -219,10 +219,20 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 	if (vars !== undefined && Object.keys(vars).length > 0) {
 		output.push({
 			type: "Vars",
-			entries: Object.entries(vars).map(([key, value]) => ({
-				key,
-				value: `"${truncate(`${value}`)}"`,
-			})),
+			entries: Object.entries(vars).map(([key, value]) => {
+				let parsedValue;
+				if (typeof value === "string") {
+					parsedValue = `"${truncate(value)}"`;
+				} else if (typeof value === "object") {
+					parsedValue = JSON.stringify(value, null, 1);
+				} else {
+					parsedValue = `${truncate(`${value}`)}`;
+				}
+				return {
+					key,
+					value: parsedValue,
+				};
+			}),
 		});
 	}
 

package/src/dev/local.tsx

@@ -1,6 +1,7 @@
+import assert from "node:assert";
 import { fork } from "node:child_process";
 import { realpathSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
+import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { npxImport } from "npx-import";
 import { useState, useEffect, useRef } from "react";
@@ -8,7 +9,10 @@ import onExit from "signal-exit";
 import { registerWorker } from "../dev-registry";
 import useInspector from "../inspect";
 import { logger } from "../logger";
-import { DEFAULT_MODULE_RULES } from "../module-collection";
+import {
+	DEFAULT_MODULE_RULES,
+	ModuleTypeToRuleType,
+} from "../module-collection";
 import { getBasePath } from "../paths";
 import { waitForPortToBeAvailable } from "../proxy";
 import type { Config } from "../config";
@@ -35,10 +39,6 @@ import type {
 import type { MiniflareOptions } from "miniflare";
 import type { ChildProcess } from "node:child_process";
 
-// caching of the miniflare package
-// eslint-disable-next-line @typescript-eslint/consistent-type-imports
-let Miniflare: typeof import("@miniflare/tre")["Miniflare"];
-
 export interface LocalProps {
 	name: string | undefined;
 	bundle: EsbuildBundle | undefined;
@@ -76,10 +76,6 @@ export function Local(props: LocalProps) {
 	return null;
 }
 
-function arrayToObject(values: string[] = []): Record<string, string> {
-	return Object.fromEntries(values.map((value) => [value, value]));
-}
-
 function useLocalWorker({
 	name: workerName,
 	bundle,
@@ -206,35 +202,15 @@ function useLocalWorker({
 
 			if (experimentalLocal) {
 				// TODO: refactor setupMiniflareOptions so we don't need to parse here
-				const miniflare2Options: MiniflareOptions = JSON.parse(forkOptions[0]);
-				const options: Miniflare3Options = {
-					...miniflare2Options,
-					// Miniflare 3 distinguishes between binding name and namespace/bucket
-					// IDs. For now, just use the same value as we did in Miniflare 2.
-					// TODO: use defined KV preview ID if any
-					kvNamespaces: arrayToObject(miniflare2Options.kvNamespaces),
-					r2Buckets: arrayToObject(miniflare2Options.r2Buckets),
-					// TODO: pass-through collected modules instead of getting Miniflare
-					//  to collect them again
-				};
-
-				logger.log("⎔ Starting an experimental local server...");
-
-				if (Miniflare === undefined) {
-					({ Miniflare } = await npxImport<
-						// eslint-disable-next-line @typescript-eslint/consistent-type-imports
-						typeof import("@miniflare/tre")
-					>("@miniflare/tre"));
-				}
-
-				const mf = new Miniflare(options);
+				const mf2Options: MiniflareOptions = JSON.parse(forkOptions[0]);
+				const mf = await setupExperimentalLocal(mf2Options, format, bundle);
+				await mf.ready;
 				experimentalLocalRef.current = mf;
-				removeSignalExitListener.current = onExit((_code, _signal) => {
+				removeSignalExitListener.current = onExit(() => {
 					logger.log("⎔ Shutting down experimental local server.");
 					mf.dispose();
 					experimentalLocalRef.current = undefined;
 				});
-				await mf.ready;
 				return;
 			}
 
@@ -648,3 +624,63 @@ export function setupNodeOptions({
 	}
 	return nodeOptions;
 }
+
+// Caching of the `npx-import`ed `@miniflare/tre` package
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+let Miniflare: typeof import("@miniflare/tre").Miniflare;
+
+function arrayToObject(values: string[] = []): Record<string, string> {
+	return Object.fromEntries(values.map((value) => [value, value]));
+}
+
+export async function setupExperimentalLocal(
+	mf2Options: MiniflareOptions,
+	format: CfScriptFormat,
+	bundle: EsbuildBundle
+): Promise<Miniflare3Type> {
+	const options: Miniflare3Options = {
+		...mf2Options,
+		// Miniflare 3 distinguishes between binding name and namespace/bucket IDs.
+		// For now, just use the same value as we did in Miniflare 2.
+		// TODO: use defined KV preview ID if any
+		kvNamespaces: arrayToObject(mf2Options.kvNamespaces),
+		r2Buckets: arrayToObject(mf2Options.r2Buckets),
+	};
+
+	if (format === "modules") {
+		// Manually specify all modules from the bundle. If we didn't do this,
+		// Miniflare 3 would try collect them automatically again itself.
+
+		// Resolve entrypoint relative to the temporary directory, ensuring
+		// path doesn't start with `..`, which causes issues in `workerd`.
+		// Also ensures other modules with relative names can be resolved.
+		const root = path.dirname(bundle.path);
+
+		assert.strictEqual(bundle.type, "esm");
+		options.modules = [
+			// Entrypoint
+			{
+				type: "ESModule",
+				path: path.relative(root, bundle.path),
+				contents: await readFile(bundle.path, "utf-8"),
+			},
+			// Misc (WebAssembly, etc, ...)
+			...bundle.modules.map((module) => ({
+				type: ModuleTypeToRuleType[module.type ?? "esm"],
+				path: module.name,
+				contents: module.content,
+			})),
+		];
+	}
+
+	logger.log("⎔ Starting an experimental local server...");
+
+	if (Miniflare === undefined) {
+		({ Miniflare } = await npxImport<
+			// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+			typeof import("@miniflare/tre")
+		>("@miniflare/tre@next"));
+	}
+
+	return new Miniflare(options);
+}

package/src/dev/start-server.ts

@@ -17,6 +17,7 @@ import { logger } from "../logger";
 import { waitForPortToBeAvailable } from "../proxy";
 import {
 	setupBindings,
+	setupExperimentalLocal,
 	setupMiniflareOptions,
 	setupNodeOptions,
 } from "./local";
@@ -28,6 +29,8 @@ import type { Entry } from "../entry";
 import type { DevProps, DirectorySyncResult } from "./dev";
 import type { LocalProps } from "./local";
 import type { EsbuildBundle } from "./use-esbuild";
+import type { Miniflare as Miniflare3Type } from "@miniflare/tre";
+import type { MiniflareOptions } from "miniflare";
 
 import type { ChildProcess } from "node:child_process";
 
@@ -118,6 +121,7 @@ export async function startDevServer(
 			enablePagesAssetsServiceBinding: props.enablePagesAssetsServiceBinding,
 			usageModel: props.usageModel,
 			workerDefinitions,
+			experimentalLocal: props.experimentalLocal,
 		});
 
 		return {
@@ -252,8 +256,10 @@ export async function startLocalServer({
 	onReady,
 	logPrefix,
 	enablePagesAssetsServiceBinding,
+	experimentalLocal,
 }: LocalProps) {
 	let local: ChildProcess | undefined;
+	let experimentalLocalRef: Miniflare3Type | undefined;
 	let removeSignalExitListener: (() => void) | undefined;
 	let inspectorUrl: string | undefined;
 	const setInspectorUrl = (url: string) => {
@@ -341,6 +347,21 @@ export async function startLocalServer({
 			enablePagesAssetsServiceBinding,
 		});
 
+		if (experimentalLocal) {
+			// TODO: refactor setupMiniflareOptions so we don't need to parse here
+			const mf2Options: MiniflareOptions = JSON.parse(forkOptions[0]);
+			const mf = await setupExperimentalLocal(mf2Options, format, bundle);
+			const runtimeURL = await mf.ready;
+			experimentalLocalRef = mf;
+			removeSignalExitListener = onExit((_code, _signal) => {
+				logger.log("⎔ Shutting down experimental local server.");
+				mf.dispose();
+				experimentalLocalRef = undefined;
+			});
+			onReady?.(runtimeURL.hostname, parseInt(runtimeURL.port ?? 8787));
+			return;
+		}
+
 		const nodeOptions = setupNodeOptions({ inspect, ip, inspectorPort });
 		logger.log("⎔ Starting a local server...");
 
@@ -435,9 +456,16 @@ export async function startLocalServer({
 				logger.log("⎔ Shutting down local server.");
 				local.kill();
 				local = undefined;
-				removeSignalExitListener && removeSignalExitListener();
-				removeSignalExitListener = undefined;
 			}
+			if (experimentalLocalRef) {
+				logger.log("⎔ Shutting down experimental local server.");
+				// Initialisation errors are also thrown asynchronously by dispose().
+				// The catch() above should've caught them though.
+				experimentalLocalRef?.dispose().catch(() => {});
+				experimentalLocalRef = undefined;
+			}
+			removeSignalExitListener?.();
+			removeSignalExitListener = undefined;
 		},
 	};
 }

package/src/dev.tsx

@@ -561,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,
@@ -578,7 +581,7 @@ export async function startApiDev(args: StartDevOptions) {
 			firstPartyWorker: configParam.first_party_worker,
 			sendMetrics: configParam.send_metrics,
 			testScheduled: args.testScheduled,
-			experimentalLocal: undefined,
+			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/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 {