wrangler 2.13.0 → 2.14.0

package/src/__tests__/traverse-module-graph.test.ts

@@ -0,0 +1,220 @@
+import { mkdir, writeFile } from "fs/promises";
+import path from "path";
+import dedent from "ts-dedent";
+import traverseModuleGraph from "../traverse-module-graph";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import type { ConfigModuleRuleType } from "../config";
+
+/*
+ * This file contains inline comments with the word "javascript"
+ * This signals to a compatible editor extension that the template string
+ * contents should be syntax-highlighted as JavaScript. One such extension
+ * is zjcompt.es6-string-javascript, but there are others.
+ */
+
+describe("traverse module graph", () => {
+	runInTempDir();
+
+	it("should not detect JS without module rules", async () => {
+		await writeFile(
+			"./index.js",
+			dedent/* javascript */ `
+			import { HELLO } from "./other.js"
+			export default {
+				async fetch(request) {
+					return new Response(HELLO)
+				}
+			}
+			`
+		);
+		await writeFile(
+			"./other.js",
+			dedent/* javascript */ `
+			export const HELLO = "WORLD"
+			`
+		);
+
+		const bundle = await traverseModuleGraph(
+			{
+				file: path.join(process.cwd(), "./index.js"),
+				directory: process.cwd(),
+				format: "modules",
+				moduleRoot: process.cwd(),
+			},
+			[]
+		);
+
+		expect(bundle.modules).toStrictEqual([]);
+	});
+
+	it.each([
+		["ESModule", "esm"],
+		["CommonJS", "commonjs"],
+	])("should detect JS as %s", async (type, format) => {
+		await writeFile(
+			"./index.js",
+			dedent/* javascript */ `
+			import { HELLO } from "./other.js"
+			export default {
+				async fetch(request) {
+					return new Response(HELLO)
+				}
+			}
+			`
+		);
+		await writeFile(
+			"./other.js",
+			dedent/* javascript */ `
+			export const HELLO = "WORLD"
+			`
+		);
+
+		const bundle = await traverseModuleGraph(
+			{
+				file: path.join(process.cwd(), "./index.js"),
+				directory: process.cwd(),
+				format: "modules",
+				moduleRoot: process.cwd(),
+			},
+			[{ type: type as ConfigModuleRuleType, globs: ["**/*.js"] }]
+		);
+
+		expect(bundle.modules[0].type).toStrictEqual(format);
+	});
+
+	it("should not resolve JS outside the module root", async () => {
+		await mkdir("./src/nested", { recursive: true });
+		await writeFile(
+			"./src/nested/index.js",
+			dedent/* javascript */ `
+			import { HELLO } from "../other.js"
+			export default {
+				async fetch(request) {
+					return new Response(HELLO)
+				}
+			}
+			`
+		);
+		await writeFile(
+			"./src/other.js",
+			dedent/* javascript */ `
+			export const HELLO = "WORLD"
+			`
+		);
+
+		const bundle = await traverseModuleGraph(
+			{
+				file: path.join(process.cwd(), "./src/nested/index.js"),
+				directory: path.join(process.cwd(), "./src/nested"),
+				format: "modules",
+				// The default module root is dirname(file)
+				moduleRoot: path.join(process.cwd(), "./src/nested"),
+			},
+			[{ type: "ESModule", globs: ["**/*.js"] }]
+		);
+
+		expect(bundle.modules).toStrictEqual([]);
+	});
+
+	it("should resolve JS with module root", async () => {
+		await mkdir("./src/nested", { recursive: true });
+		await writeFile(
+			"./src/nested/index.js",
+			dedent/* javascript */ `
+			import { HELLO } from "../other.js"
+			export default {
+				async fetch(request) {
+					return new Response(HELLO)
+				}
+			}
+			`
+		);
+		await writeFile(
+			"./src/other.js",
+			dedent/* javascript */ `
+			export const HELLO = "WORLD"
+			`
+		);
+
+		const bundle = await traverseModuleGraph(
+			{
+				file: path.join(process.cwd(), "./src/nested/index.js"),
+				directory: path.join(process.cwd(), "./src/nested"),
+				format: "modules",
+				// The default module root is dirname(file)
+				moduleRoot: path.join(process.cwd(), "./src"),
+			},
+			[{ type: "ESModule", globs: ["**/*.js"] }]
+		);
+
+		expect(bundle.modules[0].name).toStrictEqual("other.js");
+	});
+
+	it("should ignore files not matched by glob", async () => {
+		await mkdir("./src/nested", { recursive: true });
+		await writeFile(
+			"./src/nested/index.js",
+			dedent/* javascript */ `
+			import { HELLO } from "../other.js"
+			export default {
+				async fetch(request) {
+					return new Response(HELLO)
+				}
+			}
+			`
+		);
+		await writeFile(
+			"./src/other.js",
+			dedent/* javascript */ `
+			export const HELLO = "WORLD"
+			`
+		);
+
+		const bundle = await traverseModuleGraph(
+			{
+				file: path.join(process.cwd(), "./src/nested/index.js"),
+				directory: path.join(process.cwd(), "./src/nested"),
+				format: "modules",
+				// The default module root is dirname(file)
+				moduleRoot: path.join(process.cwd(), "./src"),
+			},
+			[{ type: "ESModule", globs: ["**/*.mjs"] }]
+		);
+
+		expect(bundle.modules.length).toStrictEqual(0);
+	});
+
+	it("should resolve files that match the default rules", async () => {
+		await mkdir("./src", { recursive: true });
+		await writeFile(
+			"./src/index.js",
+			dedent/* javascript */ `
+			import HELLO from "../other.txt"
+			export default {
+				async fetch(request) {
+					return new Response(HELLO)
+				}
+			}
+			`
+		);
+		await writeFile(
+			"./src/other.txt",
+			dedent/* javascript */ `
+			export const HELLO = "WORLD"
+			`
+		);
+
+		const bundle = await traverseModuleGraph(
+			{
+				file: path.join(process.cwd(), "./src/index.js"),
+				directory: path.join(process.cwd(), "./src"),
+				format: "modules",
+				// The default module root is dirname(file)
+				moduleRoot: path.join(process.cwd(), "./src"),
+			},
+			[]
+		);
+
+		expect(bundle.modules[0].name).toStrictEqual("other.txt");
+	});
+});

package/src/api/dev.ts

@@ -143,7 +143,6 @@ export async function unstable_dev(
 					enablePagesAssetsServiceBinding,
 					liveReload,
 					showInteractiveDevSession,
-					forceLocal,
 					onReady: (address, port) => {
 						readyPort = port;
 						readyAddress = address;
@@ -232,6 +231,7 @@ export async function unstable_dev(
 					experimentalLocal: experimentalLocal ?? false,
 					experimentalLocalRemoteKv: experimentalLocalRemoteKv ?? false,
 					enablePagesAssetsServiceBinding,
+					forceLocal,
 					liveReload,
 					onReady: (address, port) => {
 						readyPort = port;
@@ -301,27 +301,16 @@ export async function unstable_dev(
 export function parseRequestInput(
 	readyAddress: string,
 	readyPort: number,
-	input?: RequestInfo,
+	input: RequestInfo = "/",
 	init?: RequestInit,
 	protocol: "http" | "https" = "http"
 ): [RequestInfo, RequestInit | undefined] {
 	if (input instanceof Request) {
 		return [input, undefined];
-	} else if (input instanceof URL) {
-		input = `${protocol}://${readyAddress}:${readyPort}${input.pathname}`;
-	} else if (typeof input === "string") {
-		try {
-			// Want to strip the URL to only get the pathname, but the user could pass in only the pathname
-			// Will error if we try and pass "/something" into new URL("/something")
-			input = `${protocol}://${readyAddress}:${readyPort}${
-				new URL(input).pathname
-			}`;
-		} catch {
-			input = `${protocol}://${readyAddress}:${readyPort}${input}`;
-		}
-	} else {
-		input = `${protocol}://${readyAddress}:${readyPort}`;
 	}
-
-	return [input, init];
+	const url = new URL(`${input}`, `${protocol}://${readyAddress}:${readyPort}`);
+	url.protocol = protocol;
+	url.hostname = readyAddress;
+	url.port = readyPort.toString();
+	return [url, init];
 }

package/src/api/pages/create-worker-bundle-contents.ts

@@ -49,6 +49,7 @@ function createWorkerBundleFormData(workerBundle: BundleResult): FormData {
 		bindings: {
 			vars: undefined,
 			kv_namespaces: undefined,
+			send_email: undefined,
 			wasm_modules: undefined,
 			text_blobs: undefined,
 			data_blobs: undefined,

package/src/bundle.ts

@@ -13,6 +13,13 @@ import type { DurableObjectBindings } from "./config/environment";
 import type { WorkerRegistry } from "./dev-registry";
 import type { Entry } from "./entry";
 import type { CfModule } from "./worker";
+
+export const COMMON_ESBUILD_OPTIONS = {
+	// Our workerd runtime uses the same V8 version as recent Chrome, which is highly ES2022 compliant: https://kangax.github.io/compat-table/es2016plus/
+	target: "es2022",
+	loader: { ".js": "jsx", ".mjs": "jsx", ".cjs": "jsx" },
+} as const;
+
 export type BundleResult = {
 	modules: CfModule[];
 	dependencies: esbuild.Metafile["outputs"][string]["inputs"];
@@ -357,8 +364,7 @@ export async function bundleWorker(
 		inject,
 		external: ["__STATIC_CONTENT_MANIFEST"],
 		format: entry.format === "modules" ? "esm" : "iife",
-		// Our workerd runtime uses the same V8 version as recent Chrome, which is highly ES2022 compliant: https://kangax.github.io/compat-table/es2016plus/
-		target: "es2022",
+		target: COMMON_ESBUILD_OPTIONS.target,
 		sourcemap: sourcemap ?? true, // this needs to use ?? to accept false
 		// Include a reference to the output folder in the sourcemap.
 		// This is omitted by default, but we need it to properly resolve source paths in error output.
@@ -377,9 +383,7 @@ export async function bundleWorker(
 			},
 		}),
 		loader: {
-			".js": "jsx",
-			".mjs": "jsx",
-			".cjs": "jsx",
+			...COMMON_ESBUILD_OPTIONS.loader,
 			...(loader || {}),
 		},
 		plugins: [

package/src/config/environment.ts

@@ -74,6 +74,12 @@ interface EnvironmentInheritable {
 	 */
 	main: string | undefined;
 
+	/**
+	 * The directory in which module rules should be evaluated in a `--no-bundle` worker
+	 * This defaults to dirname(main) when left undefined
+	 */
+	base_dir: string | undefined;
+
 	/**
 	 * Whether we use <name>.<subdomain>.workers.dev to
 	 * test and deploy your worker.
@@ -339,6 +345,24 @@ interface EnvironmentNonInheritable {
 		preview_id?: string;
 	}[];
 
+	/**
+	 * These specify bindings to send email from inside your Worker.
+	 *
+	 * NOTE: This field is not automatically inherited from the top level environment,
+	 * and so must be specified in every named environment.
+	 *
+	 * @default `[]`
+	 * @nonInheritable
+	 */
+	send_email: {
+		/** The binding name used to refer to the this binding */
+		name: string;
+		/** If this binding should be restricted to a specific verified address */
+		destination_address?: string;
+		/** If this binding should be restricted to a set of verified addresses */
+		allowed_destination_addresses?: string[];
+	}[];
+
 	/**
 	 * Specifies Queues that are bound to this Worker environment.
 	 *

package/src/config/index.ts

@@ -97,6 +97,7 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		data_blobs,
 		durable_objects,
 		kv_namespaces,
+		send_email,
 		queues,
 		d1_databases,
 		r2_buckets,
@@ -155,6 +156,23 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
+	if (send_email !== undefined && send_email.length > 0) {
+		output.push({
+			type: "Send Email",
+			entries: send_email.map(
+				({ name, destination_address, allowed_destination_addresses }) => {
+					return {
+						key: name,
+						value:
+							destination_address ||
+							allowed_destination_addresses?.join(", ") ||
+							"unrestricted",
+					};
+				}
+			),
+		});
+	}
+
 	if (queues !== undefined && queues.length > 0) {
 		output.push({
 			type: "Queues",

package/src/config/validation.ts

@@ -358,6 +358,26 @@ function normalizeAndValidateMainField(
 	}
 }
 
+/**
+ * Validate the `base_dir` field and return the normalized values.
+ */
+function normalizeAndValidateBaseDirField(
+	configPath: string | undefined,
+	rawDir: string | undefined
+): string | undefined {
+	const configDir = path.dirname(configPath ?? "wrangler.toml");
+	if (rawDir !== undefined) {
+		if (typeof rawDir === "string") {
+			const directory = path.resolve(configDir);
+			return path.resolve(directory, rawDir);
+		} else {
+			return rawDir;
+		}
+	} else {
+		return;
+	}
+}
+
 /**
  * Validate the `dev` configuration and return the normalized values.
  */
@@ -1011,6 +1031,17 @@ function normalizeAndValidateEnvironment(
 			),
 			deprecatedUpload
 		),
+		base_dir: normalizeAndValidateBaseDirField(
+			configPath,
+			inheritable(
+				diagnostics,
+				topLevelEnv,
+				rawEnv,
+				"base_dir",
+				isString,
+				undefined
+			)
+		),
 		route,
 		routes,
 		triggers: inheritable(
@@ -1074,6 +1105,16 @@ function normalizeAndValidateEnvironment(
 			validateBindingArray(envName, validateKVBinding),
 			[]
 		),
+		send_email: notInheritable(
+			diagnostics,
+			topLevelEnv,
+			rawConfig,
+			rawEnv,
+			envName,
+			"send_email",
+			validateBindingArray(envName, validateSendEmailBinding),
+			[]
+		),
 		queues: notInheritable(
 			diagnostics,
 			topLevelEnv,
@@ -1765,6 +1806,53 @@ const validateKVBinding: ValidatorFn = (diagnostics, field, value) => {
 	return isValid;
 };
 
+const validateSendEmailBinding: ValidatorFn = (diagnostics, field, value) => {
+	if (typeof value !== "object" || value === null) {
+		diagnostics.errors.push(
+			`"send_email" bindings should be objects, but got ${JSON.stringify(
+				value
+			)}`
+		);
+		return false;
+	}
+	let isValid = true;
+	// send email bindings must have a name.
+	if (!isRequiredProperty(value, "name", "string")) {
+		diagnostics.errors.push(
+			`"${field}" bindings should have a string "name" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (!isOptionalProperty(value, "destination_address", "string")) {
+		diagnostics.errors.push(
+			`"${field}" bindings should, optionally, have a string "destination_address" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (!isOptionalProperty(value, "allowed_destination_addresses", "object")) {
+		diagnostics.errors.push(
+			`"${field}" bindings should, optionally, have a []string "allowed_destination_addresses" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (
+		"destination_address" in value &&
+		"allowed_destination_addresses" in value
+	) {
+		diagnostics.errors.push(
+			`"${field}" bindings should have either a "destination_address" or "allowed_destination_addresses" field, but not both.`
+		);
+		isValid = false;
+	}
+	return isValid;
+};
+
 const validateQueueBinding: ValidatorFn = (diagnostics, field, value) => {
 	if (typeof value !== "object" || value === null) {
 		diagnostics.errors.push(

package/src/create-worker-upload-form.ts

@@ -32,6 +32,12 @@ export type WorkerMetadataBinding =
 	| { type: "text_blob"; name: string; part: string }
 	| { type: "data_blob"; name: string; part: string }
 	| { type: "kv_namespace"; name: string; namespace_id: string }
+	| {
+			type: "send_email";
+			name: string;
+			destination_address?: string;
+			allowed_destination_addresses?: string[];
+	  }
 	| {
 			type: "durable_object_namespace";
 			name: string;
@@ -105,6 +111,17 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		});
 	});
 
+	bindings.send_email?.forEach(
+		({ name, destination_address, allowed_destination_addresses }) => {
+			metadataBindings.push({
+				name: name,
+				type: "send_email",
+				destination_address,
+				allowed_destination_addresses,
+			});
+		}
+	);
+
 	bindings.durable_objects?.bindings.forEach(
 		({ name, class_name, script_name, environment }) => {
 			metadataBindings.push({

package/src/d1/execute.tsx

@@ -37,7 +37,7 @@ export type QueryResult = {
 	};
 	query?: string;
 };
-// Max number of bytes to send in a single /execute call
+// Max number of statements to send in a single /execute call
 const QUERY_LIMIT = 10_000;
 
 export function Options(yargs: CommonYargsArgv) {

package/src/dev/start-server.ts

@@ -14,6 +14,7 @@ import {
 import { runCustomBuild } from "../entry";
 import { logger } from "../logger";
 import { waitForPortToBeAvailable } from "../proxy";
+import traverseModuleGraph from "../traverse-module-graph";
 import {
 	setupBindings,
 	getMiniflare3,
@@ -253,14 +254,7 @@ async function runEsbuild({
 		dependencies,
 		sourceMapPath,
 	}: Awaited<ReturnType<typeof bundleWorker>> = noBundle
-		? {
-				modules: [],
-				dependencies: {},
-				resolvedEntryPointPath: entry.file,
-				bundleType: entry.format === "modules" ? "esm" : "commonjs",
-				stop: undefined,
-				sourceMapPath: undefined,
-		  }
+		? await traverseModuleGraph(entry, rules)
 		: await bundleWorker(entry, destination, {
 				serveAssetsFromWorker,
 				jsxFactory,

package/src/dev/use-esbuild.ts

@@ -4,6 +4,7 @@ import { useApp } from "ink";
 import { useState, useEffect } from "react";
 import { bundleWorker, rewriteNodeCompatBuildFailure } from "../bundle";
 import { logBuildFailure, logger } from "../logger";
+import traverseModuleGraph from "../traverse-module-graph";
 import type { Config } from "../config";
 import type { WorkerRegistry } from "../dev-registry";
 import type { Entry } from "../entry";
@@ -107,14 +108,7 @@ export function useEsbuild({
 				stop,
 				sourceMapPath,
 			}: Awaited<ReturnType<typeof bundleWorker>> = noBundle
-				? {
-						modules: [],
-						dependencies: {},
-						resolvedEntryPointPath: entry.file,
-						bundleType: entry.format === "modules" ? "esm" : "commonjs",
-						stop: undefined,
-						sourceMapPath: undefined,
-				  }
+				? await traverseModuleGraph(entry, rules)
 				: await bundleWorker(entry, destination, {
 						serveAssetsFromWorker,
 						jsxFactory,

package/src/dev-registry.ts

@@ -13,7 +13,7 @@ import type { HttpTerminator } from "http-terminator";
 const DEV_REGISTRY_PORT = "6284";
 const DEV_REGISTRY_HOST = `http://localhost:${DEV_REGISTRY_PORT}`;
 
-let server: Server;
+let server: Server | null;
 let terminator: HttpTerminator;
 
 export type WorkerRegistry = Record<string, WorkerDefinition>;
@@ -102,6 +102,7 @@ export async function startWorkerRegistry() {
  */
 export async function stopWorkerRegistry() {
 	await terminator?.terminate();
+	server = null;
 }
 
 /**

package/src/dev.tsx

@@ -852,6 +852,7 @@ function getBindings(
 			),
 			...(args.kv || []),
 		],
+		send_email: configParam.send_email,
 		// Use a copy of combinedVars since we're modifying it later
 		vars: {
 			...getVarsForDev(configParam, env),

package/src/entry.ts

@@ -3,6 +3,7 @@ import { existsSync, statSync } from "node:fs";
 import path from "node:path";
 import * as esbuild from "esbuild";
 import { execaCommand } from "execa";
+import { COMMON_ESBUILD_OPTIONS } from "./bundle";
 import { logger } from "./logger";
 import { getBasePath } from "./paths";
 import type { Config } from "./config";
@@ -15,7 +16,16 @@ import type { Metafile } from "esbuild";
  *
  * It consists not just of a `file`, but also of a `directory` that is used to resolve relative paths.
  */
-export type Entry = { file: string; directory: string; format: CfScriptFormat };
+export type Entry = {
+	/** A worker's entrypoint */
+	file: string;
+	/** A worker's directory. Usually where the wrangler.toml file is located */
+	directory: string;
+	/** Is this a module worker or a service worker? */
+	format: CfScriptFormat;
+	/** The directory that contains all of a `--no-bundle` worker's modules. Usually `${directory}/src`. Defaults to path.dirname(file) */
+	moduleRoot: string;
+};
 
 /**
  * Compute the entry-point for the Worker.
@@ -99,7 +109,12 @@ export async function getEntry(
 		);
 	}
 
-	return { file, directory, format };
+	return {
+		file,
+		directory,
+		format,
+		moduleRoot: config.base_dir ?? path.dirname(file),
+	};
 }
 
 export async function runCustomBuild(
@@ -147,17 +162,12 @@ export default async function guessWorkerFormat(
 	tsconfig?: string | undefined
 ): Promise<CfScriptFormat> {
 	const result = await esbuild.build({
+		...COMMON_ESBUILD_OPTIONS,
 		entryPoints: [entryFile],
 		absWorkingDir: entryWorkingDirectory,
 		metafile: true,
 		bundle: false,
-		target: "es2022",
 		write: false,
-		loader: {
-			".js": "jsx",
-			".mjs": "jsx",
-			".cjs": "jsx",
-		},
 		...(tsconfig && { tsconfig }),
 	});
 	// result.metafile is defined because of the `metafile: true` option above.