wrangler 0.0.0-e043479 → 0.0.0-e09abbc

package/src/bundle.ts

@@ -1,95 +1,192 @@
 import assert from "node:assert";
 import * as fs from "node:fs";
+import { builtinModules } from "node:module";
 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 makeModuleCollector from "./module-collection";
-import type { CfModule, CfScriptFormat } from "./api/worker";
+import createModuleCollector from "./module-collection";
 import type { Config } from "./config";
 import type { Entry } from "./entry";
+import type { CfModule } from "./worker";
 
 type BundleResult = {
-  modules: CfModule[];
-  resolvedEntryPointPath: string;
-  bundleType: "esm" | "commonjs";
-  stop: (() => void) | undefined;
+	modules: CfModule[];
+	resolvedEntryPointPath: string;
+	bundleType: "esm" | "commonjs";
+	stop: (() => void) | 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.
+ */
+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.`
+				);
+			}
+		);
+	},
 };
 
 /**
  * Generate a bundle for the worker identified by the arguments passed in.
  */
 export async function bundleWorker(
-  entry: Entry,
-  destination: string,
-  options: {
-    serveAssetsFromWorker: boolean;
-    jsxFactory: string | undefined;
-    jsxFragment: string | undefined;
-    format: CfScriptFormat;
-    rules: Config["rules"];
-    watch?: esbuild.WatchMode;
-  }
+	entry: Entry,
+	destination: string,
+	options: {
+		serveAssetsFromWorker: boolean;
+		jsxFactory: string | undefined;
+		jsxFragment: string | undefined;
+		rules: Config["rules"];
+		watch?: esbuild.WatchMode;
+		tsconfig: string | undefined;
+		minify: boolean | undefined;
+		nodeCompat: boolean | undefined;
+		define: Config["define"];
+		checkFetch: boolean;
+	}
 ): Promise<BundleResult> {
-  const {
-    serveAssetsFromWorker,
-    jsxFactory,
-    jsxFragment,
-    format,
-    rules,
-    watch,
-  } = options;
-  const moduleCollector = makeModuleCollector({ format, rules });
-  const result = await esbuild.build({
-    ...getEntryPoint(entry.file, serveAssetsFromWorker),
-    bundle: true,
-    absWorkingDir: entry.directory,
-    outdir: destination,
-    external: ["__STATIC_CONTENT_MANIFEST"],
-    format: "esm",
-    sourcemap: true,
-    metafile: true,
-    conditions: ["worker", "browser"],
-    loader: {
-      ".js": "jsx",
-      ".mjs": "jsx",
-      ".cjs": "jsx",
-    },
-    plugins: [moduleCollector.plugin],
-    ...(jsxFactory && { jsxFactory }),
-    ...(jsxFragment && { jsxFragment }),
-    watch,
-  });
+	const {
+		serveAssetsFromWorker,
+		jsxFactory,
+		jsxFragment,
+		rules,
+		watch,
+		tsconfig,
+		minify,
+		nodeCompat,
+		checkFetch,
+	} = options;
+	const entryDirectory = path.dirname(entry.file);
+	const moduleCollector = createModuleCollector({
+		wrangler1xlegacyModuleReferences: {
+			rootDirectory: entryDirectory,
+			fileNames: new Set(
+				fs
+					.readdirSync(entryDirectory, { withFileTypes: true })
+					.filter(
+						(dirEntry) =>
+							dirEntry.isFile() && dirEntry.name !== path.basename(entry.file)
+					)
+					.map((dirEnt) => dirEnt.name)
+			),
+		},
+		format: entry.format,
+		rules,
+	});
+
+	// 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
+	// `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 checkedFetchFileToInject = path.join(
+		destination,
+		"--temp-wrangler-files--",
+		"checked-fetch.js"
+	);
+
+	if (checkFetch) {
+		fs.mkdirSync(path.join(destination, "--temp-wrangler-files--"), {
+			recursive: true,
+		});
+		fs.writeFileSync(
+			checkedFetchFileToInject,
+			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.
+
+	const result = await esbuild.build({
+		...getEntryPoint(entry.file, serveAssetsFromWorker),
+		bundle: true,
+		absWorkingDir: entry.directory,
+		outdir: destination,
+		inject: checkFetch ? [checkedFetchFileToInject] : [],
+		external: ["__STATIC_CONTENT_MANIFEST"],
+		format: entry.format === "modules" ? "esm" : "iife",
+		target: "es2020",
+		sourcemap: true,
+		minify,
+		metafile: true,
+		conditions: ["worker", "browser"],
+		...(process.env.NODE_ENV && {
+			define: {
+				// use process.env["NODE_ENV" + ""] so that esbuild doesn't replace it
+				// when we do a build of wrangler. (re: https://github.com/cloudflare/wrangler2/issues/1477)
+				"process.env.NODE_ENV": `"${process.env["NODE_ENV" + ""]}"`,
+				...(nodeCompat ? { global: "globalThis" } : {}),
+				...(checkFetch ? { fetch: "checkedFetch" } : {}),
+				...options.define,
+			},
+		}),
+		loader: {
+			".js": "jsx",
+			".mjs": "jsx",
+			".cjs": "jsx",
+		},
+		plugins: [
+			moduleCollector.plugin,
+			...(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]),
+		],
+		...(jsxFactory && { jsxFactory }),
+		...(jsxFragment && { jsxFragment }),
+		...(tsconfig && { tsconfig }),
+		watch,
+	});
 
-  const entryPointOutputs = Object.entries(result.metafile.outputs).filter(
-    ([_path, output]) => output.entryPoint !== undefined
-  );
-  assert(
-    entryPointOutputs.length > 0,
-    `Cannot find entry-point "${entry.file}" in generated bundle.` +
-      listEntryPoints(entryPointOutputs)
-  );
-  assert(
-    entryPointOutputs.length < 2,
-    "More than one entry-point found for generated bundle." +
-      listEntryPoints(entryPointOutputs)
-  );
+	const entryPointOutputs = Object.entries(result.metafile.outputs).filter(
+		([_path, output]) => output.entryPoint !== undefined
+	);
+	assert(
+		entryPointOutputs.length > 0,
+		`Cannot find entry-point "${entry.file}" in generated bundle.` +
+			listEntryPoints(entryPointOutputs)
+	);
+	assert(
+		entryPointOutputs.length < 2,
+		"More than one entry-point found for generated bundle." +
+			listEntryPoints(entryPointOutputs)
+	);
 
-  const entryPointExports = entryPointOutputs[0][1].exports;
-  const bundleType = entryPointExports.length > 0 ? "esm" : "commonjs";
+	const entryPointExports = entryPointOutputs[0][1].exports;
+	const bundleType = entryPointExports.length > 0 ? "esm" : "commonjs";
 
-  return {
-    modules: moduleCollector.modules,
-    resolvedEntryPointPath: path.resolve(
-      entry.directory,
-      entryPointOutputs[0][0]
-    ),
-    bundleType,
-    stop: result.stop,
-  };
+	return {
+		modules: moduleCollector.modules,
+		resolvedEntryPointPath: path.resolve(
+			entry.directory,
+			entryPointOutputs[0][0]
+		),
+		bundleType,
+		stop: result.stop,
+	};
 }
 
-type EntryPoint =
-  | { stdin: esbuild.StdinOptions; nodePaths: string[] }
-  | { entryPoints: string[] };
+type EntryPoint = { stdin: esbuild.StdinOptions } | { entryPoints: string[] };
 
 /**
  * Create an object that describes the entry point for esbuild.
@@ -99,35 +196,41 @@ type EntryPoint =
  * or delegate to the actual worker.
  */
 function getEntryPoint(
-  entryFile: string,
-  serveAssetsFromWorker: boolean
+	entryFile: string,
+	serveAssetsFromWorker: boolean
 ): EntryPoint {
-  if (serveAssetsFromWorker) {
-    return {
-      stdin: {
-        contents: fs
-          .readFileSync(
-            path.join(__dirname, "../templates/static-asset-facade.js"),
-            "utf8"
-          )
-          .replace("__ENTRY_POINT__", entryFile),
-        sourcefile: "static-asset-facade.js",
-        resolveDir: path.dirname(entryFile),
-      },
-      nodePaths: [path.join(__dirname, "../vendor")],
-    };
-  } else {
-    return { entryPoints: [entryFile] };
-  }
+	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] };
+	}
 }
 
 /**
  * Generate a string that describes the entry-points that were identified by esbuild.
  */
 function listEntryPoints(
-  outputs: [string, ValueOf<esbuild.Metafile["outputs"]>][]
+	outputs: [string, ValueOf<esbuild.Metafile["outputs"]>][]
 ): string {
-  return outputs.map(([_input, output]) => output.entryPoint).join("\n");
+	return outputs.map(([_input, output]) => output.entryPoint).join("\n");
 }
 
 type ValueOf<T> = T[keyof T];

package/src/cfetch/index.ts

@@ -8,15 +8,16 @@ import type { RequestInit } from "undici";
 export { getCloudflareAPIBaseURL as getCloudflareApiBaseUrl } from "./internal";
 
 export interface FetchError {
-  code: number;
-  message: string;
+	code: number;
+	message: string;
+	error_chain?: FetchError[];
 }
 export interface FetchResult<ResponseType = unknown> {
-  success: boolean;
-  result: ResponseType;
-  errors: FetchError[];
-  messages: string[];
-  result_info?: unknown;
+	success: boolean;
+	result: ResponseType;
+	errors: FetchError[];
+	messages: string[];
+	result_info?: unknown;
 }
 
 export { fetchKVGetValue } from "./internal";
@@ -25,20 +26,22 @@ export { fetchKVGetValue } from "./internal";
  * Make a fetch request, and extract the `result` from the JSON response.
  */
 export async function fetchResult<ResponseType>(
-  resource: string,
-  init: RequestInit = {},
-  queryParams?: URLSearchParams
+	resource: string,
+	init: RequestInit = {},
+	queryParams?: URLSearchParams,
+	abortSignal?: AbortSignal
 ): Promise<ResponseType> {
-  const json = await fetchInternal<FetchResult<ResponseType>>(
-    resource,
-    init,
-    queryParams
-  );
-  if (json.success) {
-    return json.result;
-  } else {
-    throwFetchError(resource, json);
-  }
+	const json = await fetchInternal<FetchResult<ResponseType>>(
+		resource,
+		init,
+		queryParams,
+		abortSignal
+	);
+	if (json.success) {
+		return json.result;
+	} else {
+		throwFetchError(resource, json);
+	}
 }
 
 /**
@@ -47,58 +50,72 @@ export async function fetchResult<ResponseType>(
  * and repeating the request if the results are paginated.
  */
 export async function fetchListResult<ResponseType>(
-  resource: string,
-  init: RequestInit = {},
-  queryParams?: URLSearchParams
+	resource: string,
+	init: RequestInit = {},
+	queryParams?: URLSearchParams
 ): Promise<ResponseType[]> {
-  const results: ResponseType[] = [];
-  let getMoreResults = true;
-  let cursor: string | undefined;
-  while (getMoreResults) {
-    if (cursor) {
-      queryParams = new URLSearchParams(queryParams);
-      queryParams.set("cursor", cursor);
-    }
-    const json = await fetchInternal<FetchResult<ResponseType[]>>(
-      resource,
-      init,
-      queryParams
-    );
-    if (json.success) {
-      results.push(...json.result);
-      if (hasCursor(json.result_info)) {
-        cursor = json.result_info?.cursor;
-      } else {
-        getMoreResults = false;
-      }
-    } else {
-      throwFetchError(resource, json);
-    }
-  }
-  return results;
+	const results: ResponseType[] = [];
+	let getMoreResults = true;
+	let cursor: string | undefined;
+	while (getMoreResults) {
+		if (cursor) {
+			queryParams = new URLSearchParams(queryParams);
+			queryParams.set("cursor", cursor);
+		}
+		const json = await fetchInternal<FetchResult<ResponseType[]>>(
+			resource,
+			init,
+			queryParams
+		);
+		if (json.success) {
+			results.push(...json.result);
+			if (hasCursor(json.result_info)) {
+				cursor = json.result_info?.cursor;
+			} else {
+				getMoreResults = false;
+			}
+		} else {
+			throwFetchError(resource, json);
+		}
+	}
+	return results;
 }
 
 function throwFetchError(
-  resource: string,
-  response: FetchResult<unknown>
+	resource: string,
+	response: FetchResult<unknown>
 ): never {
-  const error = new ParseError({
-    text: "Received a bad response from the API",
-    notes: response.errors.map((err) => ({
-      text: err.code ? `${err.message} [code: ${err.code}]` : err.message,
-    })),
-  });
-  // add the first error code directly to this error
-  // so consumers can use it for specific behaviour
-  const code = response.errors[0]?.code;
-  if (code) {
-    //@ts-expect-error non-standard property on Error
-    error.code = code;
-  }
-  throw error;
+	const error = new ParseError({
+		text: `A request to the Cloudflare API (${resource}) failed.`,
+		notes: response.errors.map((err) => ({
+			text: renderError(err),
+		})),
+	});
+	// add the first error code directly to this error
+	// so consumers can use it for specific behaviour
+	const code = response.errors[0]?.code;
+	if (code) {
+		//@ts-expect-error non-standard property on Error
+		error.code = code;
+	}
+	throw error;
 }
 
 function hasCursor(result_info: unknown): result_info is { cursor: string } {
-  const cursor = (result_info as { cursor: string } | undefined)?.cursor;
-  return cursor !== undefined && cursor !== null && cursor !== "";
+	const cursor = (result_info as { cursor: string } | undefined)?.cursor;
+	return cursor !== undefined && cursor !== null && cursor !== "";
+}
+
+function renderError(err: FetchError, level = 0): string {
+	const chainedMessages =
+		err.error_chain
+			?.map(
+				(chainedError) =>
+					`\n${"  ".repeat(level)}- ${renderError(chainedError, level + 1)}`
+			)
+			.join("\n") ?? "";
+	return (
+		(err.code ? `${err.message} [code: ${err.code}]` : err.message) +
+		chainedMessages
+	);
 }