wrangler 2.1.15 → 2.2.1

package/src/bundle.ts

@@ -13,8 +13,9 @@ import type { WorkerRegistry } from "./dev-registry";
 import type { Entry } from "./entry";
 import type { CfModule } from "./worker";
 
-type BundleResult = {
+export type BundleResult = {
 	modules: CfModule[];
+	dependencies: esbuild.Metafile["outputs"][string]["inputs"];
 	resolvedEntryPointPath: string;
 	bundleType: "esm" | "commonjs";
 	stop: (() => void) | undefined;
@@ -28,31 +29,48 @@ type StaticAssetsConfig =
 	| undefined;
 
 /**
- * Searches for any uses of node's builtin modules, and throws an error if it
- * finds anything. This plugin is only used when nodeCompat is not enabled.
- * Supports both regular node builtins, and the new "node:<MODULE>" format.
+ * RegExp matching against esbuild's error text when it is unable to resolve
+ * a Node built-in module. If we detect this when node_compat is disabled,
+ * we'll rewrite the error to suggest enabling it.
  */
-const checkForNodeBuiltinsPlugin = {
-	name: "checkForNodeBuiltins",
-	setup(build: esbuild.PluginBuild) {
-		build.onResolve(
-			{
-				filter: new RegExp(
-					"^(" +
-						builtinModules.join("|") +
-						"|" +
-						builtinModules.map((module) => "node:" + module).join("|") +
-						")$"
-				),
-			},
-			() => {
-				throw new Error(
-					`Detected a Node builtin module import while Node compatibility is disabled.\nAdd node_compat = true to your wrangler.toml file to enable Node compatibility.`
-				);
-			}
-		);
-	},
-};
+const nodeBuiltinResolveErrorText = new RegExp(
+	'^Could not resolve "(' +
+		builtinModules.join("|") +
+		"|" +
+		builtinModules.map((module) => "node:" + module).join("|") +
+		')"$'
+);
+
+/**
+ * Returns true if the passed value looks like an esbuild BuildFailure object
+ */
+export function isBuildFailure(err: unknown): err is esbuild.BuildFailure {
+	return (
+		typeof err === "object" &&
+		err !== null &&
+		"errors" in err &&
+		"warnings" in err
+	);
+}
+
+/**
+ * Rewrites esbuild BuildFailures for failing to resolve Node built-in modules
+ * to suggest enabling Node compat as opposed to `platform: "node"`.
+ */
+export function rewriteNodeCompatBuildFailure(err: esbuild.BuildFailure) {
+	for (const error of err.errors) {
+		const match = nodeBuiltinResolveErrorText.exec(error.text);
+		if (match !== null) {
+			error.notes = [
+				{
+					location: null,
+					text: `The package "${match[1]}" wasn't found on the file system but is built into node.
+Add "node_compat = true" to your wrangler.toml file to enable Node compatibility.`,
+				},
+			];
+		}
+	}
+}
 
 /**
  * Generate a bundle for the worker identified by the arguments passed in.
@@ -62,24 +80,31 @@ export async function bundleWorker(
 	destination: string,
 	options: {
 		serveAssetsFromWorker: boolean;
-		assets: StaticAssetsConfig;
+		assets?: StaticAssetsConfig;
 		betaD1Shims?: string[];
-		jsxFactory: string | undefined;
-		jsxFragment: string | undefined;
+		jsxFactory?: string;
+		jsxFragment?: string;
 		rules: Config["rules"];
-		watch?: esbuild.WatchMode;
-		tsconfig: string | undefined;
-		minify: boolean | undefined;
-		nodeCompat: boolean | undefined;
+		watch?: esbuild.WatchMode | boolean;
+		tsconfig?: string;
+		minify?: boolean;
+		nodeCompat?: boolean;
 		define: Config["define"];
 		checkFetch: boolean;
-		services: Config["services"] | undefined;
-		workerDefinitions: WorkerRegistry | undefined;
-		firstPartyWorkerDevFacade: boolean | undefined;
+		services?: Config["services"];
+		workerDefinitions?: WorkerRegistry;
+		firstPartyWorkerDevFacade?: boolean;
 		targetConsumer: "dev" | "publish";
 		local: boolean;
-		testScheduled?: boolean | undefined;
-		experimentalLocalStubCache: boolean | undefined;
+		testScheduled?: boolean;
+		experimentalLocalStubCache?: boolean;
+		inject?: string[];
+		loader?: Record<string, string>;
+		sourcemap?: esbuild.CommonOptions["sourcemap"];
+		plugins?: esbuild.Plugin[];
+		// TODO: Rip these out https://github.com/cloudflare/wrangler2/issues/2153
+		disableModuleCollection?: boolean;
+		isOutfile?: boolean;
 	}
 ): Promise<BundleResult> {
 	const {
@@ -101,6 +126,12 @@ export async function bundleWorker(
 		targetConsumer,
 		testScheduled,
 		experimentalLocalStubCache,
+		inject: injectOption,
+		loader,
+		sourcemap,
+		plugins,
+		disableModuleCollection,
+		isOutfile,
 	} = options;
 
 	// We create a temporary directory for any oneoff files we
@@ -109,7 +140,7 @@ export async function bundleWorker(
 	const tmpDir = await tmp.dir({ unsafeCleanup: true });
 
 	const entryDirectory = path.dirname(entry.file);
-	const moduleCollector = createModuleCollector({
+	let moduleCollector = createModuleCollector({
 		wrangler1xlegacyModuleReferences: {
 			rootDirectory: entryDirectory,
 			fileNames: new Set(
@@ -125,6 +156,15 @@ export async function bundleWorker(
 		format: entry.format,
 		rules,
 	});
+	if (disableModuleCollection) {
+		moduleCollector = {
+			modules: [],
+			plugin: {
+				name: moduleCollector.plugin.name,
+				setup: () => {},
+			},
+		};
+	}
 
 	// In dev, we want to patch `fetch()` with a special version that looks
 	// for bad usages and can warn the user about them; so we inject
@@ -235,7 +275,7 @@ export async function bundleWorker(
 
 	// At this point, inputEntry points to the entry point we want to build.
 
-	const inject: string[] = [];
+	const inject: string[] = injectOption ?? [];
 	if (checkFetch) inject.push(checkedFetchFileToInject);
 	if (experimentalLocalStubCache) {
 		inject.push(
@@ -243,16 +283,22 @@ export async function bundleWorker(
 		);
 	}
 
-	const result = await esbuild.build({
+	const buildOptions: esbuild.BuildOptions & { metafile: true } = {
 		entryPoints: [inputEntry.file],
 		bundle: true,
 		absWorkingDir: entry.directory,
 		outdir: destination,
+		...(isOutfile
+			? {
+					outdir: undefined,
+					outfile: destination,
+			  }
+			: {}),
 		inject,
 		external: ["__STATIC_CONTENT_MANIFEST"],
 		format: entry.format === "modules" ? "esm" : "iife",
 		target: "es2020",
-		sourcemap: true,
+		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.
 		sourceRoot: destination,
@@ -273,6 +319,7 @@ export async function bundleWorker(
 			".js": "jsx",
 			".mjs": "jsx",
 			".cjs": "jsx",
+			...(loader || {}),
 		},
 		plugins: [
 			// We run the moduleCollector plugin for service workers as part of the middleware loader
@@ -282,15 +329,25 @@ export async function bundleWorker(
 				: []),
 			...(nodeCompat
 				? [NodeGlobalsPolyfills({ buffer: true }), NodeModulesPolyfills()]
-				: // we use checkForNodeBuiltinsPlugin to throw a nicer error
-				  // if we find node builtins when nodeCompat isn't turned on
-				  [checkForNodeBuiltinsPlugin]),
+				: []),
+			...(plugins || []),
 		],
 		...(jsxFactory && { jsxFactory }),
 		...(jsxFragment && { jsxFragment }),
 		...(tsconfig && { tsconfig }),
 		watch,
-	});
+		// The default logLevel is "warning". So that we can rewrite errors before
+		// logging, we disable esbuild's default logging, and log build failures
+		// ourselves.
+		logLevel: "silent",
+	};
+	let result;
+	try {
+		result = await esbuild.build(buildOptions);
+	} catch (e) {
+		if (!nodeCompat && isBuildFailure(e)) rewriteNodeCompatBuildFailure(e);
+		throw e;
+	}
 
 	const entryPointOutputs = Object.entries(result.metafile.outputs).filter(
 		([_path, output]) => output.entryPoint !== undefined
@@ -306,7 +363,8 @@ export async function bundleWorker(
 			listEntryPoints(entryPointOutputs)
 	);
 
-	const entryPointExports = entryPointOutputs[0][1].exports;
+	const { exports: entryPointExports, inputs: dependencies } =
+		entryPointOutputs[0][1];
 	const bundleType = entryPointExports.length > 0 ? "esm" : "commonjs";
 
 	const sourceMapPath = Object.keys(result.metafile.outputs).filter((_path) =>
@@ -315,6 +373,7 @@ export async function bundleWorker(
 
 	return {
 		modules: moduleCollector.modules,
+		dependencies,
 		resolvedEntryPointPath: path.resolve(
 			entry.directory,
 			entryPointOutputs[0][0]

package/src/cli.ts

@@ -1,4 +1,3 @@
-import "dotenv/config"; // Grab locally specified env params from a `.env` file.
 import process from "process";
 import { hideBin } from "yargs/helpers";
 import { unstable_dev } from "./api";

package/src/config/environment.ts

@@ -247,6 +247,18 @@ interface EnvironmentInheritable {
 			destination: string;
 		}[];
 	};
+
+	/**
+	 * Send Trace Events from this worker to Workers Logpush.
+	 *
+	 * This will not configure a corresponding Logpush job automatically.
+	 *
+	 * For more information about Workers Logpush, see:
+	 * https://blog.cloudflare.com/logpush-for-workers/
+	 *
+	 * @inheritable
+	 */
+	logpush: boolean | undefined;
 }
 
 /**
@@ -325,6 +337,44 @@ interface EnvironmentNonInheritable {
 		preview_id?: string;
 	}[];
 
+	/**
+	 * Specifies Queues that are bound to this Worker environment.
+	 *
+	 * NOTE: This field is not automatically inherited from the top level environment,
+	 * and so must be specified in every named environment.
+	 *
+	 * @default `{}`
+	 * @nonInheritable
+	 */
+	queues: {
+		/** Producer bindings */
+		producers?: {
+			/** The binding name used to refer to the Queue in the worker. */
+			binding: string;
+
+			/** The name of this Queue. */
+			queue: string;
+		}[];
+
+		/** Consumer configuration */
+		consumers?: {
+			/** The name of the queue from which this script should consume. */
+			queue: string;
+
+			/** The maximum number of messages per batch */
+			max_batch_size?: number;
+
+			/** The maximum number of seconds to wait to fill a batch with messages. */
+			max_batch_timeout?: number;
+
+			/** The maximum number of retries for each message. */
+			max_retries?: number;
+
+			/** The queue to send messages that failed to be consumed. */
+			dead_letter_queue?: string;
+		}[];
+	};
+
 	/**
 	 * Specifies R2 buckets that are bound to this Worker environment.
 	 *

package/src/config/index.ts

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import dotenv from "dotenv";
 import { findUpSync } from "find-up";
 import { logger } from "../logger";
 import { parseTOML, readFileSync } from "../parse";
@@ -86,6 +88,7 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		data_blobs,
 		durable_objects,
 		kv_namespaces,
+		queues,
 		d1_databases,
 		r2_buckets,
 		logfwdr,
@@ -141,6 +144,18 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
+	if (queues !== undefined && queues.length > 0) {
+		output.push({
+			type: "Queues",
+			entries: queues.map(({ binding, queue_name }) => {
+				return {
+					key: binding,
+					value: queue_name,
+				};
+			}),
+		});
+	}
+
 	if (d1_databases !== undefined && d1_databases.length > 0) {
 		output.push({
 			type: "D1 Databases",
@@ -291,3 +306,29 @@ export function withConfig<T extends { config?: string }>(
 		return handler({ ...rest, config: readConfig(configPath, rest) });
 	};
 }
+
+export interface DotEnv {
+	path: string;
+	parsed: dotenv.DotenvParseOutput;
+}
+
+function tryLoadDotEnv(path: string): DotEnv | undefined {
+	try {
+		const parsed = dotenv.parse(fs.readFileSync(path));
+		return { path, parsed };
+	} catch (e) {
+		logger.debug(`Failed to load .env file "${path}":`, e);
+	}
+}
+
+/**
+ * Loads a dotenv file from <path>, preferring to read <path>.<environment> if
+ * <environment> is defined and that file exists.
+ */
+export function loadDotEnv(path: string, env?: string): DotEnv | undefined {
+	if (env === undefined) {
+		return tryLoadDotEnv(path);
+	} else {
+		return tryLoadDotEnv(`${path}.${env}`) ?? tryLoadDotEnv(path);
+	}
+}

package/src/config/validation.ts

@@ -1075,6 +1075,16 @@ function normalizeAndValidateEnvironment(
 			validateBindingArray(envName, validateKVBinding),
 			[]
 		),
+		queues: notInheritable(
+			diagnostics,
+			topLevelEnv,
+			rawConfig,
+			rawEnv,
+			envName,
+			"queues",
+			validateQueues(envName),
+			{ producers: [], consumers: [] }
+		),
 		r2_buckets: notInheritable(
 			diagnostics,
 			topLevelEnv,
@@ -1171,6 +1181,14 @@ function normalizeAndValidateEnvironment(
 			isBoolean,
 			undefined
 		),
+		logpush: inheritable(
+			diagnostics,
+			topLevelEnv,
+			rawEnv,
+			"logpush",
+			isBoolean,
+			undefined
+		),
 	};
 
 	return environment;
@@ -1673,6 +1691,47 @@ const validateKVBinding: ValidatorFn = (diagnostics, field, value) => {
 	return isValid;
 };
 
+const validateQueueBinding: ValidatorFn = (diagnostics, field, value) => {
+	if (typeof value !== "object" || value === null) {
+		diagnostics.errors.push(
+			`"queue" bindings should be objects, but got ${JSON.stringify(value)}`
+		);
+		return false;
+	}
+
+	if (
+		!validateAdditionalProperties(diagnostics, field, Object.keys(value), [
+			"binding",
+			"queue",
+		])
+	) {
+		return false;
+	}
+
+	// Queue bindings must have a binding and queue.
+	let isValid = true;
+	if (!isRequiredProperty(value, "binding", "string")) {
+		diagnostics.errors.push(
+			`"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (
+		!isRequiredProperty(value, "queue", "string") ||
+		(value as { queue: string }).queue.length === 0
+	) {
+		diagnostics.errors.push(
+			`"${field}" bindings should have a string "queue" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	return isValid;
+};
+
 const validateR2Binding: ValidatorFn = (diagnostics, field, value) => {
 	if (typeof value !== "object" || value === null) {
 		diagnostics.errors.push(
@@ -1928,3 +1987,117 @@ const validateWorkerNamespaceBinding: ValidatorFn = (
 	}
 	return isValid;
 };
+
+function validateQueues(envName: string): ValidatorFn {
+	return (diagnostics, field, value, config) => {
+		const fieldPath =
+			config === undefined ? `${field}` : `env.${envName}.${field}`;
+
+		if (typeof value !== "object" || Array.isArray(value) || value === null) {
+			diagnostics.errors.push(
+				`The field "${fieldPath}" should be an object but got ${JSON.stringify(
+					value
+				)}.`
+			);
+			return false;
+		}
+
+		let isValid = true;
+		if (
+			!validateAdditionalProperties(
+				diagnostics,
+				fieldPath,
+				Object.keys(value),
+				["consumers", "producers"]
+			)
+		) {
+			isValid = false;
+		}
+
+		if (hasProperty(value, "consumers")) {
+			const consumers = value.consumers;
+			if (!Array.isArray(consumers)) {
+				diagnostics.errors.push(
+					`The field "${fieldPath}.consumers" should be an array but got ${JSON.stringify(
+						consumers
+					)}.`
+				);
+				isValid = false;
+			}
+
+			for (let i = 0; i < consumers.length; i++) {
+				const consumer = consumers[i];
+				const consumerPath = `${fieldPath}.consumers[${i}]`;
+				if (!validateConsumer(diagnostics, consumerPath, consumer, config)) {
+					isValid = false;
+				}
+			}
+		}
+
+		if (hasProperty(value, "producers")) {
+			if (
+				!validateBindingArray(envName, validateQueueBinding)(
+					diagnostics,
+					`${field}.producers`,
+					value.producers,
+					config
+				)
+			) {
+				isValid = false;
+			}
+		}
+		return isValid;
+	};
+}
+
+const validateConsumer: ValidatorFn = (diagnostics, field, value, _config) => {
+	if (typeof value !== "object" || value === null) {
+		diagnostics.errors.push(
+			`"${field}" should be a objects, but got ${JSON.stringify(value)}`
+		);
+		return false;
+	}
+
+	let isValid = true;
+	if (
+		!validateAdditionalProperties(diagnostics, field, Object.keys(value), [
+			"queue",
+			"max_batch_size",
+			"max_batch_timeout",
+			"max_retries",
+			"dead_letter_queue",
+		])
+	) {
+		isValid = false;
+	}
+
+	if (!isRequiredProperty(value, "queue", "string")) {
+		diagnostics.errors.push(
+			`"${field}" should have a string "queue" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+	}
+
+	const options: {
+		key: string;
+		type: "number" | "string";
+	}[] = [
+		{ key: "max_batch_size", type: "number" },
+		{ key: "max_batch_timeout", type: "number" },
+		{ key: "max_retries", type: "number" },
+		{ key: "dead_letter_queue", type: "string" },
+	];
+	for (const optionalOpt of options) {
+		if (!isOptionalProperty(value, optionalOpt.key, optionalOpt.type)) {
+			diagnostics.errors.push(
+				`"${field}" should, optionally, have a ${optionalOpt.type} "${
+					optionalOpt.key
+				}" field but got ${JSON.stringify(value)}.`
+			);
+			isValid = false;
+		}
+	}
+
+	return isValid;
+};

package/src/create-worker-preview.ts

@@ -4,7 +4,9 @@ import { fetchResult } from "./cfetch";
 import { createWorkerUploadForm } from "./create-worker-upload-form";
 import { logger } from "./logger";
 import { parseJSON } from "./parse";
+import { getAccessToken } from "./user/access";
 import type { CfAccount, CfWorkerContext, CfWorkerInit } from "./worker";
+import type { HeadersInit } from "undici";
 
 /**
  * A Preview Session on the edge
@@ -251,13 +253,18 @@ export async function createWorkerPreview(
 		session,
 		abortSignal
 	);
+	const accessToken = await getAccessToken(token.prewarmUrl.hostname);
+
+	const headers: HeadersInit = { "cf-workers-preview-token": token.value };
+	if (accessToken) {
+		headers.cookie = `CF_Authorization=${accessToken}`;
+	}
+
 	// fire and forget the prewarm call
 	fetch(token.prewarmUrl.href, {
 		method: "POST",
 		signal: abortSignal,
-		headers: {
-			"cf-workers-preview-token": token.value,
-		},
+		headers,
 	}).then(
 		(response) => {
 			if (!response.ok) {

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

@@ -39,6 +39,7 @@ type WorkerMetadataBinding =
 			script_name?: string;
 			environment?: string;
 	  }
+	| { type: "queue"; name: string; queue_name: string }
 	| { type: "r2_bucket"; name: string; bucket_name: string }
 	| { type: "d1"; name: string; id: string }
 	| { type: "service"; name: string; service: string; environment?: string }
@@ -61,6 +62,7 @@ export interface WorkerMetadata {
 	capnp_schema?: string;
 	bindings: WorkerMetadataBinding[];
 	keep_bindings?: WorkerMetadataBinding["type"][];
+	logpush?: boolean;
 }
 
 /**
@@ -76,6 +78,7 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		compatibility_date,
 		compatibility_flags,
 		keepVars,
+		logpush,
 	} = worker;
 
 	let { modules } = worker;
@@ -110,6 +113,14 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		}
 	);
 
+	bindings.queues?.forEach(({ binding, queue_name }) => {
+		metadataBindings.push({
+			type: "queue",
+			name: binding,
+			queue_name,
+		});
+	});
+
 	bindings.r2_buckets?.forEach(({ binding, bucket_name }) => {
 		metadataBindings.push({
 			name: binding,
@@ -268,6 +279,7 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		...(migrations && { migrations }),
 		capnp_schema: bindings.logfwdr?.schema,
 		...(keepVars && { keep_bindings: ["plain_text", "json"] }),
+		...(logpush !== undefined && { logpush }),
 	};
 
 	formData.set("metadata", JSON.stringify(metadata));

package/src/d1/backups.tsx

@@ -1,4 +1,5 @@
 import fs from "node:fs/promises";
+import * as path from "path";
 import { render } from "ink";
 import Table from "ink-table";
 import React from "react";
@@ -189,15 +190,20 @@ export const DownloadHandler = withConfig<BackupDownloadArgs>(
 			accountId,
 			name
 		);
-		const filename = output || `./${name}.${backupId.slice(0, 8)}.sqlite3`;
-
-		console.log(`Downloading backup ${backupId} of ${name} to: ${filename}`);
+		const filename =
+			output ||
+			path.join(
+				process.env.INIT_CWD as string,
+				`${name}.${backupId.slice(0, 8)}.sqlite3`
+			);
+
+		logger.log(`🌀 Downloading backup ${backupId} from '${name}'`);
 		const response = await getBackupResponse(accountId, db.uuid, backupId);
-		console.log(`Got file. Saving...`);
+		logger.log(`🌀 Saving to ${filename}`);
 		// TODO: stream this once we upgrade to Node18 and can use Writable.fromWeb
 		const buffer = await response.arrayBuffer();
 		await fs.writeFile(filename, new Buffer(buffer));
-		console.log(`Done! Wrote ${filename} (${formatBytes(buffer.byteLength)})`);
+		logger.log(`🌀 Done!`);
 	}
 );