wrangler 2.13.0 → 2.14.0

package/src/module-collection.ts

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
+import chalk from "chalk";
 import globToRegExp from "glob-to-regexp";
 import { logger } from "./logger";
 import type { Config, ConfigModuleRuleType } from "./config";
@@ -38,28 +39,8 @@ export const DEFAULT_MODULE_RULES: Config["rules"] = [
 	{ type: "CompiledWasm", globs: ["**/*.wasm"] },
 ];
 
-export default function createModuleCollector(props: {
-	format: CfScriptFormat;
-	rules?: Config["rules"];
-	// a collection of "legacy" style module references, which are just file names
-	// we will eventually deprecate this functionality, hence the verbose greppable name
-	wrangler1xlegacyModuleReferences: {
-		rootDirectory: string;
-		fileNames: Set<string>;
-	};
-}): {
-	modules: CfModule[];
-	plugin: esbuild.Plugin;
-} {
-	const rules: Config["rules"] = [
-		...(props.rules || []),
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		...DEFAULT_MODULE_RULES!,
-	];
-
-	// First, we want to add some validations to the module rules
-	// We want to warn if rules are accidentally configured in such a way that
-	// subsequent rules will never match because `fallthrough` hasn't been set
+export function parseRules(userRules: Config["rules"] = []) {
+	const rules: Config["rules"] = [...userRules, ...DEFAULT_MODULE_RULES];
 
 	const completedRuleLocations: Record<string, number> = {};
 	let index = 0;
@@ -67,7 +48,7 @@ export default function createModuleCollector(props: {
 	for (const rule of rules) {
 		if (rule.type in completedRuleLocations) {
 			if (rules[completedRuleLocations[rule.type]].fallthrough !== false) {
-				if (index < (props.rules || []).length) {
+				if (index < userRules.length) {
 					logger.warn(
 						`The module rule at position ${index} (${JSON.stringify(
 							rule
@@ -101,6 +82,89 @@ export default function createModuleCollector(props: {
 	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 	rulesToRemove.forEach((rule) => rules!.splice(rules!.indexOf(rule), 1));
 
+	return { rules, removedRules: rulesToRemove };
+}
+
+export async function matchFiles(
+	files: string[],
+	relativeTo: string,
+	{
+		rules,
+		removedRules,
+	}: { rules: Config["rules"]; removedRules: Config["rules"] }
+) {
+	const modules: CfModule[] = [];
+
+	// Deduplicate modules. This is usually a poorly specified `wrangler.toml` configuration, but duplicate modules will cause a crash at runtime
+	const moduleNames = new Set<string>();
+	for (const rule of rules) {
+		for (const glob of rule.globs) {
+			const regexp = globToRegExp(glob, {
+				globstar: true,
+			});
+			const newModules = await Promise.all(
+				files
+					.filter((f) => regexp.test(f))
+					.map(async (name) => {
+						const filePath = name;
+						const fileContent = await readFile(path.join(relativeTo, filePath));
+
+						return {
+							name: filePath,
+							content: fileContent,
+							type: RuleTypeToModuleType[rule.type],
+						};
+					})
+			);
+			for (const module of newModules) {
+				if (!moduleNames.has(module.name)) {
+					moduleNames.add(module.name);
+					modules.push(module);
+				} else {
+					logger.warn(
+						`Ignoring duplicate module: ${chalk.blue(
+							module.name
+						)} (${chalk.green(module.type ?? "")})`
+					);
+				}
+			}
+		}
+	}
+
+	// This is just a sanity check verifying that no files match rules that were removed
+	for (const rule of removedRules) {
+		for (const glob of rule.globs) {
+			const regexp = globToRegExp(glob);
+			for (const file of files) {
+				if (regexp.test(file)) {
+					throw new Error(
+						`The file ${file} matched a module rule in your configuration (${JSON.stringify(
+							rule
+						)}), but was ignored because a previous rule with the same type was not marked as \`fallthrough = true\`.`
+					);
+				}
+			}
+		}
+	}
+	return modules;
+}
+
+export default function createModuleCollector(props: {
+	format: CfScriptFormat;
+	rules?: Config["rules"];
+	// a collection of "legacy" style module references, which are just file names
+	// we will eventually deprecate this functionality, hence the verbose greppable name
+	wrangler1xlegacyModuleReferences: {
+		rootDirectory: string;
+		fileNames: Set<string>;
+	};
+	preserveFileNames?: boolean;
+}): {
+	modules: CfModule[];
+	plugin: esbuild.Plugin;
+} {
+	const { rules, removedRules } = parseRules(props.rules);
+
 	const modules: CfModule[] = [];
 	return {
 		modules,
@@ -206,7 +270,9 @@ export default function createModuleCollector(props: {
 									.createHash("sha1")
 									.update(fileContent)
 									.digest("hex");
-								const fileName = `./${fileHash}-${path.basename(args.path)}`;
+								const fileName = props.preserveFileNames
+									? filePath
+									: `./${fileHash}-${path.basename(args.path)}`;
 
 								// add the module to the array
 								modules.push({
@@ -245,7 +311,7 @@ export default function createModuleCollector(props: {
 					});
 				});
 
-				rulesToRemove.forEach((rule) => {
+				removedRules.forEach((rule) => {
 					rule.globs.forEach((glob) => {
 						build.onResolve(
 							{ filter: globToRegExp(glob) },

package/src/pages/functions/buildPlugin.ts

@@ -28,6 +28,7 @@ export function buildPlugin({
 			file: resolve(getBasePath(), "templates/pages-template-plugin.ts"),
 			directory: functionsDirectory,
 			format: "modules",
+			moduleRoot: functionsDirectory,
 		},
 		resolve(outdir),
 		{

package/src/pages/functions/buildWorker.ts

@@ -48,6 +48,7 @@ export function buildWorker({
 			file: resolve(getBasePath(), "templates/pages-template-worker.ts"),
 			directory: functionsDirectory,
 			format: "modules",
+			moduleRoot: functionsDirectory,
 		},
 		outdir ? resolve(outdir) : resolve(outfile),
 		{
@@ -58,10 +59,6 @@ export function buildWorker({
 			watch,
 			legacyNodeCompat,
 			nodejsCompat,
-			loader: {
-				".txt": "text",
-				".html": "text",
-			},
 			define: {
 				__FALLBACK_SERVICE__: JSON.stringify(fallbackService),
 			},
@@ -202,6 +199,7 @@ export function buildRawWorker({
 			file: workerScriptPath,
 			directory: resolve(directory),
 			format: "modules",
+			moduleRoot: resolve(directory),
 		},
 		outdir ? resolve(outdir) : resolve(outfile),
 		{
@@ -210,10 +208,6 @@ export function buildRawWorker({
 			watch,
 			legacyNodeCompat,
 			nodejsCompat,
-			loader: {
-				".txt": "text",
-				".html": "text",
-			},
 			define: {},
 			betaD1Shims: (betaD1Shims || []).map(
 				(binding) => `${D1_BETA_PREFIX}${binding}`

package/src/publish/publish.ts

@@ -21,6 +21,7 @@ import { ParseError } from "../parse";
 import { getQueue, putConsumer } from "../queues/client";
 import { getWorkersDevSubdomain } from "../routes";
 import { syncAssets } from "../sites";
+import traverseModuleGraph from "../traverse-module-graph";
 import { identifyD1BindingsAsBeta } from "../worker";
 import { getZoneForRoute } from "../zones";
 import type { FetchError } from "../cfetch";
@@ -463,14 +464,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 			resolvedEntryPointPath,
 			bundleType,
 		}: Awaited<ReturnType<typeof bundleWorker>> = props.noBundle
-			? // we can skip the whole bundling step and mock a bundle here
-			  {
-					modules: [],
-					dependencies: {},
-					resolvedEntryPointPath: props.entry.file,
-					bundleType: props.entry.format === "modules" ? "esm" : "commonjs",
-					stop: undefined,
-			  }
+			? await traverseModuleGraph(props.entry, props.rules)
 			: await bundleWorker(
 					props.entry,
 					typeof destination === "string" ? destination : destination.path,
@@ -541,6 +535,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 					? { binding: "__STATIC_CONTENT", id: assets.namespace }
 					: []
 			),
+			send_email: config.send_email,
 			vars: { ...config.vars, ...props.vars },
 			wasm_modules: config.wasm_modules,
 			text_blobs: {

package/src/secret/index.ts

@@ -100,6 +100,7 @@ export const secret = (secretYargs: CommonYargsArgv) => {
 								},
 								bindings: {
 									kv_namespaces: [],
+									send_email: [],
 									vars: {},
 									durable_objects: { bindings: [] },
 									queues: [],

package/src/traverse-module-graph.ts

@@ -0,0 +1,53 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import chalk from "chalk";
+import { logger } from "./logger";
+import { matchFiles, parseRules } from "./module-collection";
+import type { BundleResult } from "./bundle";
+import type { Config } from "./config";
+import type { Entry } from "./entry";
+
+async function getFiles(root: string, relativeTo: string): Promise<string[]> {
+	const files = [];
+	for (const file of await readdir(root, { withFileTypes: true })) {
+		if (file.isDirectory()) {
+			files.push(...(await getFiles(path.join(root, file.name), relativeTo)));
+		} else {
+			files.push(path.relative(relativeTo, path.join(root, file.name)));
+		}
+	}
+	return files;
+}
+
+export default async function traverseModuleGraph(
+	entry: Entry,
+	rules: Config["rules"]
+): Promise<BundleResult> {
+	const files = await getFiles(entry.moduleRoot, entry.moduleRoot);
+	const relativeEntryPoint = path.relative(entry.moduleRoot, entry.file);
+
+	const modules = (await matchFiles(files, entry.moduleRoot, parseRules(rules)))
+		.filter((m) => m.name !== relativeEntryPoint)
+		.map((m) => ({
+			...m,
+			name: m.name,
+		}));
+
+	const bundleType = entry.format === "modules" ? "esm" : "commonjs";
+
+	if (modules.length > 0) {
+		logger.info(`Uploading additional modules:`);
+		modules.forEach(({ name, type }) => {
+			logger.info(`- ${chalk.blue(name)} (${chalk.green(type ?? "")})`);
+		});
+	}
+
+	return {
+		modules,
+		dependencies: {},
+		resolvedEntryPointPath: entry.file,
+		bundleType,
+		stop: undefined,
+		sourceMapPath: undefined,
+	};
+}

package/src/worker.ts

@@ -79,6 +79,15 @@ export interface CfKvNamespace {
 	id: string;
 }
 
+/**
+ * A binding to send email.
+ */
+export interface CfSendEmailBindings {
+	name: string;
+	destination_address?: string;
+	allowed_destination_addresses?: string[];
+}
+
 /**
  * A binding to a wasm module (in service-worker format)
  */
@@ -216,6 +225,7 @@ export interface CfWorkerInit {
 	bindings: {
 		vars: CfVars | undefined;
 		kv_namespaces: CfKvNamespace[] | undefined;
+		send_email: CfSendEmailBindings[] | undefined;
 		wasm_modules: CfWasmModuleBindings | undefined;
 		text_blobs: CfTextBlobBindings | undefined;
 		data_blobs: CfDataBlobBindings | undefined;

package/wrangler-dist/cli.d.ts

@@ -532,6 +532,11 @@ declare interface EnvironmentInheritable {
      * The entrypoint/path to the JavaScript file that will be executed.
      */
     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.
@@ -770,6 +775,23 @@ declare interface EnvironmentNonInheritable {
         /** The ID of the KV namespace used during `wrangler dev` */
         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.
      *