wrangler 2.0.23 → 2.0.24

package/src/bundle.ts

@@ -1,13 +1,14 @@
 import assert from "node:assert";
 import * as fs from "node:fs";
 import { builtinModules } from "node:module";
-import * as os from "node:os";
 import * as path from "node:path";
 import NodeGlobalsPolyfills from "@esbuild-plugins/node-globals-polyfill";
 import NodeModulesPolyfills from "@esbuild-plugins/node-modules-polyfill";
 import * as esbuild from "esbuild";
+import tmp from "tmp-promise";
 import createModuleCollector from "./module-collection";
 import type { Config } from "./config";
+import type { WorkerRegistry } from "./dev-registry";
 import type { Entry } from "./entry";
 import type { CfModule } from "./worker";
 
@@ -16,8 +17,15 @@ type BundleResult = {
 	resolvedEntryPointPath: string;
 	bundleType: "esm" | "commonjs";
 	stop: (() => void) | undefined;
+	sourceMapPath?: string | undefined;
 };
 
+type StaticAssetsConfig =
+	| (Config["assets"] & {
+			bypassCache: boolean | undefined;
+	  })
+	| 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.
@@ -53,6 +61,7 @@ export async function bundleWorker(
 	destination: string,
 	options: {
 		serveAssetsFromWorker: boolean;
+		assets: StaticAssetsConfig;
 		jsxFactory: string | undefined;
 		jsxFragment: string | undefined;
 		rules: Config["rules"];
@@ -62,6 +71,9 @@ export async function bundleWorker(
 		nodeCompat: boolean | undefined;
 		define: Config["define"];
 		checkFetch: boolean;
+		services: Config["services"];
+		workerDefinitions: WorkerRegistry | undefined;
+		firstPartyWorkerDevFacade: boolean | undefined;
 	}
 ): Promise<BundleResult> {
 	const {
@@ -74,7 +86,17 @@ export async function bundleWorker(
 		minify,
 		nodeCompat,
 		checkFetch,
+		assets,
+		workerDefinitions,
+		services,
+		firstPartyWorkerDevFacade,
 	} = options;
+
+	// We create a temporary directory for any oneoff files we
+	// need to create. This is separate from the main build
+	// directory (`destination`).
+	const tmpDir = await tmp.dir({ unsafeCleanup: true });
+
 	const entryDirectory = path.dirname(entry.file);
 	const moduleCollector = createModuleCollector({
 		wrangler1xlegacyModuleReferences: {
@@ -98,15 +120,11 @@ export async function bundleWorker(
 	// `checked-fetch.js` to do so. However, with yarn 3 style pnp,
 	// we need to extract that file to an accessible place before injecting
 	// it in, hence this code here.
-	const osTempDir = os.tmpdir();
-	const checkedFetchFileToInject = path.join(
-		osTempDir,
-		"--temp-wrangler-files--",
-		"checked-fetch.js"
-	);
+
+	const checkedFetchFileToInject = path.join(tmpDir.path, "checked-fetch.js");
 
 	if (checkFetch && !fs.existsSync(checkedFetchFileToInject)) {
-		fs.mkdirSync(path.join(osTempDir, "--temp-wrangler-files--"), {
+		fs.mkdirSync(tmpDir.path, {
 			recursive: true,
 		});
 		fs.writeFileSync(
@@ -114,12 +132,58 @@ export async function bundleWorker(
 			fs.readFileSync(path.resolve(__dirname, "../templates/checked-fetch.js"))
 		);
 	}
-	// TODO: we need to have similar logic like above for other files
-	// like the static asset facade, and other middleware that we
-	// plan on injecting/referencing.
+
+	// At this point, we take the opportunity to "wrap" any input workers
+	// with any extra functionality we may want to add. This is done by
+	// passing the entry point through a pipeline of functions that return
+	// a new entry point, that we call "middleware" or "facades".
+	// Look at implementations of these functions to learn more.
+
+	type MiddlewareFn = (arg0: Entry) => Promise<Entry>;
+	const middleware: (false | undefined | MiddlewareFn)[] = [
+		// serve static assets
+		serveAssetsFromWorker &&
+			((currentEntry: Entry) => {
+				return applyStaticAssetFacade(currentEntry, tmpDir.path, assets);
+			}),
+		// format errors nicely
+		// We use an env var here because we don't actually
+		// want to expose this to the user. It's only used internally to
+		// experiment with middleware as a teaching exercise.
+		process.env.FORMAT_WRANGLER_ERRORS === "true" &&
+			((currentEntry: Entry) => {
+				return applyFormatDevErrorsFacade(currentEntry, tmpDir.path);
+			}),
+		// bind to other dev instances/service bindings
+		workerDefinitions &&
+			Object.keys(workerDefinitions).length > 0 &&
+			services &&
+			services.length > 0 &&
+			((currentEntry: Entry) => {
+				return applyMultiWorkerDevFacade(
+					currentEntry,
+					tmpDir.path,
+					services,
+					workerDefinitions
+				);
+			}),
+		// Simulate internal environment when using first party workers in dev
+		firstPartyWorkerDevFacade === true &&
+			((currentEntry: Entry) => {
+				return applyFirstPartyWorkerDevFacade(currentEntry, tmpDir.path);
+			}),
+	].filter(Boolean);
+
+	let inputEntry = entry;
+
+	for (const middlewareFn of middleware as MiddlewareFn[]) {
+		inputEntry = await middlewareFn(inputEntry);
+	}
+
+	// At this point, inputEntry points to the entry point we want to build.
 
 	const result = await esbuild.build({
-		...getEntryPoint(entry.file, serveAssetsFromWorker),
+		entryPoints: [inputEntry.file],
 		bundle: true,
 		absWorkingDir: entry.directory,
 		outdir: destination,
@@ -128,6 +192,8 @@ export async function bundleWorker(
 		format: entry.format === "modules" ? "esm" : "iife",
 		target: "es2020",
 		sourcemap: true,
+		// The root included, as the sources are relative paths to tmpDir
+		sourceRoot: entryDirectory,
 		minify,
 		metafile: true,
 		conditions: ["worker", "browser"],
@@ -177,6 +243,10 @@ export async function bundleWorker(
 	const entryPointExports = entryPointOutputs[0][1].exports;
 	const bundleType = entryPointExports.length > 0 ? "esm" : "commonjs";
 
+	const sourceMapPath = Object.keys(result.metafile.outputs).filter((_path) =>
+		_path.includes(".map")
+	)[0];
+
 	return {
 		modules: moduleCollector.modules,
 		resolvedEntryPointPath: path.resolve(
@@ -185,45 +255,209 @@ export async function bundleWorker(
 		),
 		bundleType,
 		stop: result.stop,
+		sourceMapPath,
 	};
 }
 
-type EntryPoint = { stdin: esbuild.StdinOptions } | { entryPoints: string[] };
+/**
+ * A simple plugin to alias modules and mark them as external
+ */
+function esbuildAliasExternalPlugin(
+	aliases: Record<string, string>
+): esbuild.Plugin {
+	return {
+		name: "alias",
+		setup(build) {
+			build.onResolve({ filter: /.*/g }, (args) => {
+				// If it's the entrypoint, let it be as is
+				if (args.kind === "entry-point") {
+					return {
+						path: args.path,
+					};
+				}
+				// If it's not a recognised alias, then throw an error
+				if (!Object.keys(aliases).includes(args.path)) {
+					throw new Error("unrecognized module: " + args.path);
+				}
+
+				// Otherwise, return the alias
+				return {
+					path: aliases[args.path as keyof typeof aliases],
+					external: true,
+				};
+			});
+		},
+	};
+}
 
 /**
- * Create an object that describes the entry point for esbuild.
- *
- * If we are using the experimental asset handling, then the entry point is
- * actually a shim worker that will either return an asset from a KV store,
- * or delegate to the actual worker.
+ * A middleware that catches any thrown errors, and instead formats
+ * them to be rendered in a browser. This middleware is for demonstration
+ * purposes only, and is not intended to be used in production (or even dev!)
  */
-function getEntryPoint(
-	entryFile: string,
-	serveAssetsFromWorker: boolean
-): EntryPoint {
-	if (serveAssetsFromWorker) {
-		return {
-			stdin: {
-				contents: fs
-					.readFileSync(
-						path.join(__dirname, "../templates/static-asset-facade.js"),
-						"utf8"
-					)
-					// on windows, escape backslashes in the path (`\`)
-					.replace("__ENTRY_POINT__", entryFile.replaceAll("\\", "\\\\"))
-					.replace(
-						"__KV_ASSET_HANDLER__",
-						path
-							.join(__dirname, "../kv-asset-handler.js")
-							.replaceAll("\\", "\\\\")
-					),
-				sourcefile: "static-asset-facade.js",
-				resolveDir: path.dirname(entryFile),
-			},
-		};
-	} else {
-		return { entryPoints: [entryFile] };
+async function applyFormatDevErrorsFacade(
+	entry: Entry,
+	tmpDirPath: string
+): Promise<Entry> {
+	const targetPath = path.join(tmpDirPath, "format-dev-errors.entry.js");
+	await esbuild.build({
+		entryPoints: [path.resolve(__dirname, "../templates/format-dev-errors.ts")],
+		bundle: true,
+		sourcemap: true,
+		format: "esm",
+		plugins: [
+			esbuildAliasExternalPlugin({
+				__ENTRY_POINT__: entry.file,
+			}),
+		],
+		outfile: targetPath,
+	});
+
+	return {
+		...entry,
+		file: targetPath,
+	};
+}
+
+/**
+ * A middleware that serves static assets from a worker.
+ * This powers --assets / config.assets
+ */
+
+async function applyStaticAssetFacade(
+	entry: Entry,
+	tmpDirPath: string,
+	assets: StaticAssetsConfig
+): Promise<Entry> {
+	const targetPath = path.join(tmpDirPath, "serve-static-assets.entry.js");
+
+	await esbuild.build({
+		entryPoints: [
+			path.resolve(__dirname, "../templates/serve-static-assets.ts"),
+		],
+		bundle: true,
+		format: "esm",
+		sourcemap: true,
+		plugins: [
+			esbuildAliasExternalPlugin({
+				__ENTRY_POINT__: entry.file,
+				__KV_ASSET_HANDLER__: path.join(__dirname, "../kv-asset-handler.js"),
+				__STATIC_CONTENT_MANIFEST: "__STATIC_CONTENT_MANIFEST",
+			}),
+		],
+		define: {
+			__CACHE_CONTROL_OPTIONS__: JSON.stringify(
+				typeof assets === "object"
+					? {
+							browserTTL:
+								assets.browser_TTL || 172800 /* 2 days: 2* 60 * 60 * 24 */,
+							bypassCache: assets.bypassCache,
+					  }
+					: {}
+			),
+			__SERVE_SINGLE_PAGE_APP__: JSON.stringify(
+				typeof assets === "object" ? assets.serve_single_page_app : false
+			),
+		},
+		outfile: targetPath,
+	});
+
+	return {
+		...entry,
+		file: targetPath,
+	};
+}
+
+/**
+ * A middleware that enables service bindings to be used in dev,
+ * binding to other love wrangler dev instances
+ */
+
+async function applyMultiWorkerDevFacade(
+	entry: Entry,
+	tmpDirPath: string,
+	services: Config["services"],
+	workerDefinitions: WorkerRegistry
+) {
+	const targetPath = path.join(tmpDirPath, "serve-static-assets.entry.js");
+	const serviceMap = Object.fromEntries(
+		(services || []).map((serviceBinding) => [
+			serviceBinding.binding,
+			workerDefinitions[serviceBinding.service] || null,
+		])
+	);
+
+	await esbuild.build({
+		entryPoints: [
+			path.join(
+				__dirname,
+				entry.format === "modules"
+					? "../templates/service-bindings-module-facade.js"
+					: "../templates/service-bindings-sw-facade.js"
+			),
+		],
+		bundle: true,
+		sourcemap: true,
+		format: "esm",
+		plugins: [
+			esbuildAliasExternalPlugin({
+				__ENTRY_POINT__: entry.file,
+			}),
+		],
+		define: {
+			__WORKERS__: JSON.stringify(serviceMap),
+		},
+		outfile: targetPath,
+	});
+
+	return {
+		...entry,
+		file: targetPath,
+	};
+}
+
+/**
+ * A middleware that makes first party workers "work" in
+ * our dev environments. Is applied during wrangler dev
+ * when config.first_party_worker is true
+ */
+async function applyFirstPartyWorkerDevFacade(
+	entry: Entry,
+	tmpDirPath: string
+) {
+	if (entry.format !== "modules") {
+		throw new Error(
+			"First party workers must be in the modules format. See https://developers.cloudflare.com/workers/learning/migrating-to-module-workers/"
+		);
 	}
+
+	const targetPath = path.join(
+		tmpDirPath,
+		"first-party-worker-module-facade.entry.js"
+	);
+
+	await esbuild.build({
+		entryPoints: [
+			path.resolve(
+				__dirname,
+				"../templates/first-party-worker-module-facade.ts"
+			),
+		],
+		bundle: true,
+		format: "esm",
+		sourcemap: true,
+		plugins: [
+			esbuildAliasExternalPlugin({
+				__ENTRY_POINT__: entry.file,
+			}),
+		],
+		outfile: targetPath,
+	});
+
+	return {
+		...entry,
+		file: targetPath,
+	};
 }
 
 /**

package/src/cfetch/internal.ts

@@ -6,7 +6,7 @@ import { ParseError, parseJSON } from "../parse";
 import { loginOrRefreshIfRequired, requireApiToken } from "../user";
 import type { ApiCredentials } from "../user";
 import type { URLSearchParams } from "node:url";
-import type { RequestInit, HeadersInit } from "undici";
+import type { RequestInit, HeadersInit, Response } from "undici";
 
 /**
  * Get the URL to use to access the Cloudflare API.
@@ -124,7 +124,6 @@ function addUserAgent(headers: Record<string, string>): void {
  * Note: any calls to fetchKVGetValue must call encodeURIComponent on key
  * before passing it
  */
-
 export async function fetchKVGetValue(
 	accountId: string,
 	namespaceId: string,
@@ -147,3 +146,36 @@ export async function fetchKVGetValue(
 		);
 	}
 }
+
+/**
+ * The implementation for fetching a R2 object from Cloudflare API.
+ * We have a special implementation to handle the non-standard API response
+ * that doesn't return JSON, likely due to the streaming nature.
+ *
+ * note: The implementation should be called from light wrappers for
+ * different methods (GET, PUT)
+ */
+type ResponseWithBody = Response & { body: NonNullable<Response["body"]> };
+export async function fetchR2Objects(
+	resource: string,
+	bodyInit: RequestInit = {}
+): Promise<ResponseWithBody> {
+	await requireLoggedIn();
+	const auth = requireApiToken();
+	const headers = cloneHeaders(bodyInit.headers);
+	addAuthorizationHeaderIfUnspecified(headers, auth);
+	addUserAgent(headers);
+
+	const response = await fetch(`${getCloudflareAPIBaseURL()}${resource}`, {
+		...bodyInit,
+		headers,
+	});
+
+	if (response.ok && response.body) {
+		return response as ResponseWithBody;
+	} else {
+		throw new Error(
+			`Failed to fetch ${resource} - ${response.status}: ${response.statusText});`
+		);
+	}
+}

package/src/config/config.ts

@@ -127,8 +127,13 @@ export interface ConfigFields<Dev extends RawDevConfig> {
 	 * This can either be a string, or an object with additional config fields.
 	 */
 	assets:
-		| string
-		| { bucket: string; include: string[]; exclude: string[] }
+		| {
+				bucket: string;
+				include: string[];
+				exclude: string[];
+				browser_TTL: number | undefined;
+				serve_single_page_app: boolean;
+		  }
 		| undefined;
 
 	/**

package/src/config/environment.ts

@@ -217,6 +217,11 @@ interface EnvironmentInheritable {
 		namespace: string;
 	}[];
 
+	/**
+	 *	Designates this worker as an internal-only "first-party" worker.
+	 */
+	first_party_worker: boolean | undefined;
+
 	/**
 	 * TODO: remove this as it has been deprecated.
 	 *
@@ -224,6 +229,24 @@ interface EnvironmentInheritable {
 	 * So we need to include it in this type so it is available.
 	 */
 	zone_id?: string;
+
+	/**
+	 * Specify a compiled capnp schema to use
+	 * Then add a binding per field in the top level message that you will send to logfwdr
+	 *
+	 * @default `{schema:undefined,bindings:[]}`
+	 * @inheritable
+	 */
+	logfwdr: {
+		/** capnp schema filename */
+		schema: string | undefined;
+		bindings: {
+			/** The binding name used to refer to logfwdr */
+			name: string;
+			/** The destination for this logged message */
+			destination: string;
+		}[];
+	};
 }
 
 /**
@@ -329,14 +352,16 @@ interface EnvironmentNonInheritable {
 	 * @default `[]`
 	 * @nonInheritable
 	 */
-	services: {
-		/** The binding name used to refer to the bound service. */
-		binding: string;
-		/** The name of the service. */
-		service: string;
-		/** The environment of the service (e.g. production, staging, etc). */
-		environment?: string;
-	}[];
+	services:
+		| {
+				/** The binding name used to refer to the bound service. */
+				binding: string;
+				/** The name of the service. */
+				service: string;
+				/** The environment of the service (e.g. production, staging, etc). */
+				environment?: string;
+		  }[]
+		| undefined;
 
 	/**
 	 * "Unsafe" tables for features that aren't directly supported by wrangler.
@@ -375,6 +400,13 @@ interface EnvironmentDeprecated {
 	 */
 	zone_id?: string;
 
+	/**
+	 * Legacy way of defining KVNamespaces that is no longer supported.
+	 *
+	 * @deprecated DO NOT USE. This was a legacy bug from wrangler 1, that we do not want to support.
+	 */
+	"kv-namespaces"?: string;
+
 	/**
 	 * A list of services that your worker should be bound to.
 	 *

package/src/config/index.ts

@@ -85,6 +85,7 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		durable_objects,
 		kv_namespaces,
 		r2_buckets,
+		logfwdr,
 		services,
 		text_blobs,
 		unsafe,
@@ -149,6 +150,18 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
+	if (logfwdr !== undefined && logfwdr.bindings.length > 0) {
+		output.push({
+			type: "logfwdr",
+			entries: logfwdr.bindings.map((binding) => {
+				return {
+					key: binding.name,
+					value: binding.destination,
+				};
+			}),
+		});
+	}
+
 	if (services !== undefined && services.length > 0) {
 		output.push({
 			type: "Services",