wrangler 2.1.7 → 2.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrangler",
-	"version": "2.1.7",
+	"version": "2.1.9",
 	"description": "Command-line interface for all things Cloudflare Workers",
 	"keywords": [
 		"wrangler",
@@ -112,6 +112,7 @@
 		"@databases/sql": "^3.2.0",
 		"@iarna/toml": "^3.0.0",
 		"@microsoft/api-extractor": "^7.28.3",
+		"@miniflare/tre": "3.0.0-next.2",
 		"@types/better-sqlite3": "^7.6.0",
 		"@types/busboy": "^1.5.0",
 		"@types/command-exists": "^1.2.0",
@@ -138,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",
@@ -157,7 +157,7 @@
 		"jest-websocket-mock": "^2.3.0",
 		"mime": "^3.0.0",
 		"msw": "^0.47.1",
-		"npx-import": "^1.0.2",
+		"npx-import": "^1.1.3",
 		"open": "^8.4.0",
 		"p-queue": "^7.2.0",
 		"pretty-bytes": "^6.0.0",

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/bundle.ts

@@ -79,6 +79,7 @@ export async function bundleWorker(
 		targetConsumer: "dev" | "publish";
 		local: boolean;
 		testScheduled?: boolean | undefined;
+		experimentalLocalStubCache: boolean | undefined;
 	}
 ): Promise<BundleResult> {
 	const {
@@ -99,6 +100,7 @@ export async function bundleWorker(
 		firstPartyWorkerDevFacade,
 		targetConsumer,
 		testScheduled,
+		experimentalLocalStubCache,
 	} = options;
 
 	// We create a temporary directory for any oneoff files we
@@ -233,12 +235,20 @@ export async function bundleWorker(
 
 	// At this point, inputEntry points to the entry point we want to build.
 
+	const inject: string[] = [];
+	if (checkFetch) inject.push(checkedFetchFileToInject);
+	if (experimentalLocalStubCache) {
+		inject.push(
+			path.resolve(getBasePath(), "templates/experimental-local-cache-stubs.js")
+		);
+	}
+
 	const result = await esbuild.build({
 		entryPoints: [inputEntry.file],
 		bundle: true,
 		absWorkingDir: entry.directory,
 		outdir: destination,
-		inject: checkFetch ? [checkedFetchFileToInject] : [],
+		inject,
 		external: ["__STATIC_CONTENT_MANIFEST"],
 		format: entry.format === "modules" ? "esm" : "iife",
 		target: "es2020",

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/dev.tsx

@@ -153,6 +153,7 @@ export type DevProps = {
 	firstPartyWorker: boolean | undefined;
 	sendMetrics: boolean | undefined;
 	testScheduled: boolean | undefined;
+	experimentalLocal: boolean | undefined;
 };
 
 export function DevImplementation(props: DevProps): JSX.Element {
@@ -213,6 +214,7 @@ function InteractiveDevSession(props: DevProps) {
 
 type DevSessionProps = DevProps & {
 	local: boolean;
+	experimentalLocal?: boolean;
 };
 
 function DevSession(props: DevSessionProps) {
@@ -274,6 +276,7 @@ function DevSession(props: DevSessionProps) {
 		// Enable the bundling to know whether we are using dev or publish
 		targetConsumer: "dev",
 		testScheduled: props.testScheduled ?? false,
+		experimentalLocalStubCache: props.local && props.experimentalLocal,
 	});
 
 	return props.local ? (
@@ -300,6 +303,7 @@ function DevSession(props: DevSessionProps) {
 			inspect={props.inspect}
 			onReady={props.onReady}
 			enablePagesAssetsServiceBinding={props.enablePagesAssetsServiceBinding}
+			experimentalLocal={props.experimentalLocal}
 		/>
 	) : (
 		<Remote

package/src/dev/local.tsx

@@ -1,13 +1,18 @@
+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";
 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";
@@ -27,8 +32,13 @@ import type {
 	CfD1Database,
 } from "../worker";
 import type { EsbuildBundle } from "./use-esbuild";
+import type {
+	Miniflare as Miniflare3Type,
+	MiniflareOptions as Miniflare3Options,
+} from "@miniflare/tre";
 import type { MiniflareOptions } from "miniflare";
 import type { ChildProcess } from "node:child_process";
+
 export interface LocalProps {
 	name: string | undefined;
 	bundle: EsbuildBundle | undefined;
@@ -53,6 +63,7 @@ export interface LocalProps {
 	logPrefix?: string;
 	enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
 	testScheduled?: boolean;
+	experimentalLocal?: boolean;
 }
 
 export function Local(props: LocalProps) {
@@ -88,9 +99,11 @@ function useLocalWorker({
 	onReady,
 	logPrefix,
 	enablePagesAssetsServiceBinding,
+	experimentalLocal,
 }: LocalProps) {
 	// TODO: pass vars via command line
 	const local = useRef<ChildProcess>();
+	const experimentalLocalRef = useRef<Miniflare3Type>();
 	const removeSignalExitListener = useRef<() => void>();
 	const [inspectorUrl, setInspectorUrl] = useState<string | undefined>();
 
@@ -187,6 +200,20 @@ function useLocalWorker({
 				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);
+				await mf.ready;
+				experimentalLocalRef.current = mf;
+				removeSignalExitListener.current = onExit(() => {
+					logger.log("⎔ Shutting down experimental local server.");
+					mf.dispose();
+					experimentalLocalRef.current = undefined;
+				});
+				return;
+			}
+
 			const nodeOptions = setupNodeOptions({ inspect, ip, inspectorPort });
 			logger.log("⎔ Starting a local server...");
 
@@ -279,9 +306,16 @@ function useLocalWorker({
 				logger.log("⎔ Shutting down local server.");
 				local.current?.kill();
 				local.current = undefined;
-				removeSignalExitListener.current && removeSignalExitListener.current();
-				removeSignalExitListener.current = undefined;
 			}
+			if (experimentalLocalRef.current) {
+				logger.log("⎔ Shutting down experimental local server.");
+				// Initialisation errors are also thrown asynchronously by dispose().
+				// The catch() above should've caught them though.
+				experimentalLocalRef.current?.dispose().catch(() => {});
+				experimentalLocalRef.current = undefined;
+			}
+			removeSignalExitListener.current?.();
+			removeSignalExitListener.current = undefined;
 		};
 	}, [
 		bundle,
@@ -314,6 +348,7 @@ function useLocalWorker({
 		logPrefix,
 		onReady,
 		enablePagesAssetsServiceBinding,
+		experimentalLocal,
 	]);
 	return { inspectorUrl };
 }
@@ -458,7 +493,10 @@ export function setupMiniflareOptions({
 	logPrefix,
 	workerDefinitions,
 	enablePagesAssetsServiceBinding,
-}: SetupMiniflareOptionsProps): MiniflareOptions {
+}: SetupMiniflareOptionsProps): {
+	miniflareCLIPath: string;
+	forkOptions: string[];
+} {
 	// It's now getting _really_ messy now with Pages ASSETS binding outside and the external Durable Objects inside.
 	const options = {
 		name: workerName,
@@ -586,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";
 
@@ -91,6 +94,7 @@ export async function startDevServer(
 			services: props.bindings.services,
 			firstPartyWorkerDevFacade: props.firstPartyWorker,
 			testScheduled: props.testScheduled,
+			experimentalLocalStubCache: props.experimentalLocal,
 		});
 
 		//run local now
@@ -117,6 +121,7 @@ export async function startDevServer(
 			enablePagesAssetsServiceBinding: props.enablePagesAssetsServiceBinding,
 			usageModel: props.usageModel,
 			workerDefinitions,
+			experimentalLocal: props.experimentalLocal,
 		});
 
 		return {
@@ -159,6 +164,7 @@ async function runEsbuild({
 	services,
 	firstPartyWorkerDevFacade,
 	testScheduled,
+	experimentalLocalStubCache,
 }: {
 	entry: Entry;
 	destination: string | undefined;
@@ -176,6 +182,7 @@ async function runEsbuild({
 	workerDefinitions: WorkerRegistry;
 	firstPartyWorkerDevFacade: boolean | undefined;
 	testScheduled?: boolean;
+	experimentalLocalStubCache: boolean | undefined;
 }): Promise<EsbuildBundle | undefined> {
 	if (!destination) return;
 
@@ -213,6 +220,7 @@ async function runEsbuild({
 				targetConsumer: "dev", // We are starting a dev server
 				local: false,
 				testScheduled,
+				experimentalLocalStubCache,
 		  });
 
 	return {
@@ -248,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) => {
@@ -337,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...");
 
@@ -431,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/use-esbuild.ts

@@ -40,6 +40,7 @@ export function useEsbuild({
 	local,
 	targetConsumer,
 	testScheduled,
+	experimentalLocalStubCache,
 }: {
 	entry: Entry;
 	destination: string | undefined;
@@ -61,6 +62,7 @@ export function useEsbuild({
 	local: boolean;
 	targetConsumer: "dev" | "publish";
 	testScheduled: boolean;
+	experimentalLocalStubCache: boolean | undefined;
 }): EsbuildBundle | undefined {
 	const [bundle, setBundle] = useState<EsbuildBundle>();
 	const { exit } = useApp();
@@ -128,6 +130,7 @@ export function useEsbuild({
 						local,
 						targetConsumer,
 						testScheduled,
+						experimentalLocalStubCache,
 				  });
 
 			// Capture the `stop()` method to use as the `useEffect()` destructor.
@@ -188,6 +191,7 @@ export function useEsbuild({
 		local,
 		targetConsumer,
 		testScheduled,
+		experimentalLocalStubCache,
 	]);
 	return bundle;
 }