wrangler 0.0.0-e7cf0caa → 0.0.0-e87ad068

package/src/__tests__/unstableDev.test.ts

@@ -0,0 +1,61 @@
+import { fetch } from "undici";
+import {
+	stopWorkerRegistry,
+	registerWorker,
+	startWorkerRegistry,
+} from "../dev-registry";
+
+jest.unmock("undici");
+
+/**
+ * Sometimes the devRegistry killed by some reason, the register worker will to restart it.
+ */
+describe("unstable devRegistry testing", () => {
+	afterAll(async () => {
+		await stopWorkerRegistry();
+	});
+
+	it("should start the devRegistry if the devRegistry not start", async () => {
+		await registerWorker("test", {
+			port: 6789,
+			protocol: "http",
+			host: "localhost",
+			mode: "local",
+			durableObjects: [{ name: "testing", className: "testing" }],
+		});
+		const resp = await fetch("http://localhost:6284/workers");
+		if (resp) {
+			const parsedResp = (await resp.json()) as {
+				test: unknown;
+			};
+			expect(parsedResp.test).toBeTruthy();
+		}
+	});
+
+	it("should not restart the devRegistry if the devRegistry already start", async () => {
+		await startWorkerRegistry();
+
+		await fetch("http://localhost:6284/workers/init", {
+			method: "POST",
+			body: JSON.stringify({}),
+		});
+
+		await registerWorker("test", {
+			port: 6789,
+			protocol: "http",
+			host: "localhost",
+			mode: "local",
+			durableObjects: [{ name: "testing", className: "testing" }],
+		});
+
+		const resp = await fetch("http://localhost:6284/workers");
+		if (resp) {
+			const parsedResp = (await resp.json()) as {
+				test: unknown;
+				init: unknown;
+			};
+			expect(parsedResp.init).toBeTruthy();
+			expect(parsedResp.test).toBeTruthy();
+		}
+	});
+});

package/src/__tests__/user.test.ts

@@ -60,7 +60,7 @@ describe("User", () => {
 			expect(counter).toBe(1);
 			expect(std.out).toMatchInlineSnapshot(`
 			"Attempting to login via OAuth...
-			Opening a link in your default browser: https://dash.cloudflare.com/oauth2/auth?response_type=code&client_id=54d11594-84e4-41aa-b438-e81b8fa78ee7&redirect_uri=http%3A%2F%2Flocalhost%3A8976%2Foauth%2Fcallback&scope=account%3Aread%20user%3Aread%20workers%3Awrite%20workers_kv%3Awrite%20workers_routes%3Awrite%20workers_scripts%3Awrite%20workers_tail%3Aread%20d1%3Awrite%20pages%3Awrite%20zone%3Aread%20ssl_certs%3Awrite%20offline_access&state=MOCK_STATE_PARAM&code_challenge=MOCK_CODE_CHALLENGE&code_challenge_method=S256
+			Opening a link in your default browser: https://dash.cloudflare.com/oauth2/auth?response_type=code&client_id=54d11594-84e4-41aa-b438-e81b8fa78ee7&redirect_uri=http%3A%2F%2Flocalhost%3A8976%2Foauth%2Fcallback&scope=account%3Aread%20user%3Aread%20workers%3Awrite%20workers_kv%3Awrite%20workers_routes%3Awrite%20workers_scripts%3Awrite%20workers_tail%3Aread%20d1%3Awrite%20pages%3Awrite%20zone%3Aread%20ssl_certs%3Awrite%20constellation%3Awrite%20offline_access&state=MOCK_STATE_PARAM&code_challenge=MOCK_CODE_CHALLENGE&code_challenge_method=S256
 			Successfully logged in."
 		`);
 			expect(readAuthConfigFile()).toEqual<UserAuthConfig>({

package/src/api/dev.ts

@@ -3,7 +3,9 @@ import { startApiDev, startDev } from "../dev";
 import { logger } from "../logger";
 
 import type { Environment } from "../config";
+import type { Rule } from "../config/environment";
 import type { EnablePagesAssetsServiceBindingOptions } from "../miniflare-cli/types";
+import type { CfModule } from "../worker";
 import type { RequestInit, Response, RequestInfo } from "undici";
 
 export interface UnstableDevOptions {
@@ -42,11 +44,15 @@ export interface UnstableDevOptions {
 		bucket_name: string;
 		preview_bucket_name?: string;
 	}[];
+	moduleRoot?: string;
+	rules?: Rule[];
 	logLevel?: "none" | "info" | "error" | "log" | "warn" | "debug"; // Specify logging level  [choices: "debug", "info", "log", "warn", "error", "none"] [default: "log"]
 	inspect?: boolean;
 	local?: boolean;
 	accountId?: string;
 	experimental?: {
+		processEntrypoint?: boolean;
+		additionalModules?: CfModule[];
 		d1Databases?: Environment["d1_databases"];
 		disableExperimentalWarning?: boolean; // Disables wrangler's warning when unstable APIs are used.
 		disableDevRegistry?: boolean; // Disables wrangler's support multi-worker setups. May reduce flakiness when used in tests in CI.
@@ -92,6 +98,8 @@ export async function unstable_dev(
 	const {
 		// there are two types of "experimental" options:
 		// 1. options to unstable_dev that we're still testing or are unsure of
+		processEntrypoint = false,
+		additionalModules,
 		disableDevRegistry,
 		disableExperimentalWarning,
 		forceLocal,
@@ -150,6 +158,8 @@ export async function unstable_dev(
 					},
 					config: options?.config,
 					env: options?.env,
+					processEntrypoint,
+					additionalModules,
 					bundle: options?.bundle,
 					compatibilityDate: options?.compatibilityDate,
 					compatibilityFlags: options?.compatibilityFlags,
@@ -240,6 +250,8 @@ export async function unstable_dev(
 					},
 					config: options?.config,
 					env: options?.env,
+					processEntrypoint,
+					additionalModules,
 					bundle: options?.bundle,
 					compatibilityDate: options?.compatibilityDate,
 					compatibilityFlags: options?.compatibilityFlags,

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

@@ -52,11 +52,13 @@ function createWorkerBundleFormData(workerBundle: BundleResult): FormData {
 			send_email: undefined,
 			wasm_modules: undefined,
 			text_blobs: undefined,
+			browser: undefined,
 			data_blobs: undefined,
 			durable_objects: undefined,
 			queues: undefined,
 			r2_buckets: undefined,
 			d1_databases: undefined,
+			constellation: undefined,
 			services: undefined,
 			analytics_engine_datasets: undefined,
 			dispatch_namespaces: undefined,
@@ -70,6 +72,8 @@ function createWorkerBundleFormData(workerBundle: BundleResult): FormData {
 		usage_model: undefined,
 		keepVars: undefined,
 		logpush: undefined,
+		placement: undefined,
+		tail_consumers: undefined,
 	};
 
 	return createWorkerUploadForm(worker);

package/src/api/pages/publish.tsx

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, lstatSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve as resolvePath } from "node:path";
 import { cwd } from "node:process";
@@ -14,6 +14,7 @@ import {
 import {
 	buildRawWorker,
 	checkRawWorker,
+	traverseAndBuildWorkerJSDirectory,
 } from "../../pages/functions/buildWorker";
 import { validateRoutes } from "../../pages/functions/routes-validation";
 import { upload } from "../../pages/upload";
@@ -65,7 +66,7 @@ interface PagesPublishOptions {
 
 	/**
 	 * Whether to run bundling on `_worker.js` before deploying.
-	 * Default: false
+	 * Default: true
 	 */
 	bundle?: boolean;
 
@@ -95,9 +96,12 @@ export async function publish({
 		_redirects: string | undefined,
 		_routesGenerated: string | undefined,
 		_routesCustom: string | undefined,
+		_workerJSIsDirectory = false,
 		_workerJS: string | undefined;
 
-	const workerScriptPath = resolvePath(directory, "_worker.js");
+	bundle = bundle ?? true;
+
+	const _workerPath = resolvePath(directory, "_worker.js");
 
 	try {
 		_headers = readFileSync(join(directory, "_headers"), "utf-8");
@@ -116,7 +120,10 @@ export async function publish({
 	} catch {}
 
 	try {
-		_workerJS = readFileSync(workerScriptPath, "utf-8");
+		_workerJSIsDirectory = lstatSync(_workerPath).isDirectory();
+		if (!_workerJSIsDirectory) {
+			_workerJS = readFileSync(_workerPath, "utf-8");
+		}
 	} catch {}
 
 	// Grab the bindings from the API, we need these for shims and other such hacky inserts
@@ -240,16 +247,23 @@ export async function publish({
 	 * Advanced Mode
 	 * https://developers.cloudflare.com/pages/platform/functions/#advanced-mode
 	 *
-	 * When using a _worker.js file, the entire /functions directory is ignored
+	 * When using a _worker.js file or _worker.js/ directory, the entire /functions directory is ignored
 	 * – this includes its routing and middleware characteristics.
 	 */
-	if (_workerJS) {
+	if (_workerJSIsDirectory) {
+		workerBundle = await traverseAndBuildWorkerJSDirectory({
+			workerJSDirectory: _workerPath,
+			buildOutputDirectory: directory,
+			d1Databases,
+			nodejsCompat,
+		});
+	} else if (_workerJS) {
 		if (bundle) {
 			const outfile = join(tmpdir(), `./bundledWorker-${Math.random()}.mjs`);
 			workerBundle = await buildRawWorker({
-				workerScriptPath,
+				workerScriptPath: _workerPath,
 				outfile,
-				directory: directory ?? ".",
+				directory,
 				local: false,
 				sourcemap: true,
 				watch: false,
@@ -258,17 +272,19 @@ export async function publish({
 				nodejsCompat,
 			});
 		} else {
-			await checkRawWorker(workerScriptPath, () => {});
-			// TODO: Replace this with the cool new no-bundle stuff when that lands: https://github.com/cloudflare/workers-sdk/pull/2769
+			await checkRawWorker(_workerPath, () => {});
+			// TODO: Let users configure this in the future.
 			workerBundle = {
 				modules: [],
 				dependencies: {},
 				stop: undefined,
-				resolvedEntryPointPath: workerScriptPath,
+				resolvedEntryPointPath: _workerPath,
 				bundleType: "esm",
 			};
 		}
+	}
 
+	if (_workerJS || _workerJSIsDirectory) {
 		const workerBundleContents = await createUploadWorkerBundleContents(
 			workerBundle as BundleResult
 		);
@@ -302,7 +318,7 @@ export async function publish({
 	 * Pages Functions
 	 * https://developers.cloudflare.com/pages/platform/functions/
 	 */
-	if (builtFunctions && !_workerJS) {
+	if (builtFunctions && !_workerJS && !_workerJSIsDirectory) {
 		const workerBundleContents = await createUploadWorkerBundleContents(
 			workerBundle as BundleResult
 		);

package/src/bundle.ts

@@ -7,11 +7,12 @@ import NodeModulesPolyfills from "@esbuild-plugins/node-modules-polyfill";
 import * as esbuild from "esbuild";
 import tmp from "tmp-promise";
 import createModuleCollector from "./module-collection";
-import { getBasePath, toUrlPath } from "./paths";
+import { getBasePath } from "./paths";
 import type { Config } from "./config";
 import type { DurableObjectBindings } from "./config/environment";
 import type { WorkerRegistry } from "./dev-registry";
 import type { Entry } from "./entry";
+import type { SourceMapMetadata } from "./inspect";
 import type { CfModule } from "./worker";
 
 export const COMMON_ESBUILD_OPTIONS = {
@@ -27,6 +28,7 @@ export type BundleResult = {
 	bundleType: "esm" | "commonjs";
 	stop: (() => void) | undefined;
 	sourceMapPath?: string | undefined;
+	sourceMapMetadata?: SourceMapMetadata | undefined;
 };
 
 type StaticAssetsConfig =
@@ -77,15 +79,25 @@ export function isBuildFailure(err: unknown): err is esbuild.BuildFailure {
  * 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) {
+export function rewriteNodeCompatBuildFailure(
+	err: esbuild.BuildFailure,
+	forPages = false
+) {
 	for (const error of err.errors) {
 		const match = nodeBuiltinResolveErrorText.exec(error.text);
 		if (match !== null) {
+			const issue = `The package "${match[1]}" wasn't found on the file system but is built into node.`;
+
+			const instructionForUser = `${
+				forPages
+					? 'Add the "nodejs_compat" compatibility flag to your Pages project'
+					: 'Add "node_compat = true" to your wrangler.toml file'
+			} to enable Node.js compatibility.`;
+
 			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.`,
+					text: `${issue}\n${instructionForUser}`,
 				},
 			];
 		}
@@ -117,6 +129,8 @@ export async function bundleWorker(
 	entry: Entry,
 	destination: string,
 	options: {
+		// When `bundle` is set to false, we apply shims to the Worker, but won't pull in any imports
+		bundle?: boolean;
 		serveAssetsFromWorker: boolean;
 		assets?: StaticAssetsConfig;
 		betaD1Shims?: string[];
@@ -143,12 +157,15 @@ export async function bundleWorker(
 		loader?: Record<string, string>;
 		sourcemap?: esbuild.CommonOptions["sourcemap"];
 		plugins?: esbuild.Plugin[];
+		additionalModules?: CfModule[];
 		// TODO: Rip these out https://github.com/cloudflare/workers-sdk/issues/2153
 		disableModuleCollection?: boolean;
 		isOutfile?: boolean;
+		forPages?: boolean;
 	}
 ): Promise<BundleResult> {
 	const {
+		bundle = true,
 		serveAssetsFromWorker,
 		betaD1Shims,
 		doBindings,
@@ -176,6 +193,8 @@ export async function bundleWorker(
 		plugins,
 		disableModuleCollection,
 		isOutfile,
+		forPages,
+		additionalModules = [],
 	} = options;
 
 	// We create a temporary directory for any oneoff files we
@@ -350,7 +369,7 @@ export async function bundleWorker(
 
 	const buildOptions: esbuild.BuildOptions & { metafile: true } = {
 		entryPoints: [inputEntry.file],
-		bundle: true,
+		bundle,
 		absWorkingDir: entry.directory,
 		outdir: destination,
 		entryNames: entryName || path.parse(entry.file).name,
@@ -362,10 +381,10 @@ export async function bundleWorker(
 			  }
 			: {}),
 		inject,
-		external: ["__STATIC_CONTENT_MANIFEST"],
+		external: bundle ? ["__STATIC_CONTENT_MANIFEST"] : undefined,
 		format: entry.format === "modules" ? "esm" : "iife",
 		target: COMMON_ESBUILD_OPTIONS.target,
-		sourcemap: sourcemap ?? true, // this needs to use ?? to accept false
+		sourcemap: sourcemap ?? true,
 		// 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,
@@ -409,7 +428,7 @@ export async function bundleWorker(
 		result = await esbuild.build(buildOptions);
 	} catch (e) {
 		if (!legacyNodeCompat && isBuildFailure(e))
-			rewriteNodeCompatBuildFailure(e);
+			rewriteNodeCompatBuildFailure(e, forPages);
 		throw e;
 	}
 
@@ -440,21 +459,34 @@ export async function bundleWorker(
 		entryPointOutputs[0][0]
 	);
 
+	// A collision between additionalModules and moduleCollector.modules is incredibly unlikely because moduleCollector hashes the modules it collects.
+	// However, if it happens, let's trust the explicitly provided additionalModules over the ones we discovered.
+	const modules = dedupeModulesByName([
+		...moduleCollector.modules,
+		...additionalModules,
+	]);
+
 	// copy all referenced modules into the output bundle directory
-	for (const module of moduleCollector.modules) {
-		fs.writeFileSync(
-			path.join(path.dirname(resolvedEntryPointPath), module.name),
-			module.content
+	for (const module of modules) {
+		const modulePath = path.join(
+			path.dirname(resolvedEntryPointPath),
+			module.name
 		);
+		fs.mkdirSync(path.dirname(modulePath), { recursive: true });
+		fs.writeFileSync(modulePath, module.content);
 	}
 
 	return {
-		modules: moduleCollector.modules,
+		modules,
 		dependencies,
 		resolvedEntryPointPath,
 		bundleType,
 		stop: result.stop,
 		sourceMapPath,
+		sourceMapMetadata: {
+			tmpDir: tmpDir.path,
+			entryDirectory: entry.directory,
+		},
 	};
 }
 
@@ -599,7 +631,7 @@ async function applyMiddlewareLoaderFacade(
 					...Object.fromEntries(
 						middleware.map((val, index) => [
 							middlewareIdentifiers[index],
-							toUrlPath(path.resolve(getBasePath(), val.path)),
+							path.resolve(getBasePath(), val.path),
 						])
 					),
 				}),
@@ -905,4 +937,16 @@ function listEntryPoints(
 	return outputs.map(([_input, output]) => output.entryPoint).join("\n");
 }
 
+/**
+ * Prefer modules towards the end of the array in the case of a collision by name.
+ */
+export function dedupeModulesByName(modules: CfModule[]): CfModule[] {
+	return Object.values(
+		modules.reduce((moduleMap, module) => {
+			moduleMap[module.name] = module;
+			return moduleMap;
+		}, {} as Record<string, CfModule>)
+	);
+}
+
 type ValueOf<T> = T[keyof T];

package/src/cfetch/internal.ts

@@ -1,5 +1,6 @@
 import assert from "node:assert";
 import { fetch, File, Headers } from "undici";
+import { Response } from "undici";
 import { version as wranglerVersion } from "../../package.json";
 import { getCloudflareApiBaseUrl } from "../environment-variables/misc-variables";
 import { logger } from "../logger";
@@ -7,7 +8,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, Response } from "undici";
+import type { RequestInit, HeadersInit } from "undici";
 
 /*
  * performApiFetch does everything required to make a CF API request,
@@ -217,19 +218,20 @@ export async function fetchR2Objects(
 export async function fetchDashboardScript(
 	resource: string,
 	bodyInit: RequestInit = {}
-): Promise<string> {
+): Promise<File[]> {
 	await requireLoggedIn();
 	const auth = requireApiToken();
 	const headers = cloneHeaders(bodyInit.headers);
 	addAuthorizationHeaderIfUnspecified(headers, auth);
 	addUserAgent(headers);
 
-	const response = await fetch(`${getCloudflareApiBaseUrl()}${resource}`, {
+	let response = await fetch(`${getCloudflareApiBaseUrl()}${resource}`, {
 		...bodyInit,
 		headers,
 	});
 
 	if (!response.ok || !response.body) {
+		console.error(response.ok, response.body);
 		throw new Error(
 			`Failed to fetch ${resource} - ${response.status}: ${response.statusText});`
 		);
@@ -240,19 +242,22 @@ export async function fetchDashboardScript(
 		?.startsWith("multipart");
 
 	if (usesModules) {
-		// Response from edge contains generic "name = worker.js" for dashboard created scripts
-		const form = await response.formData();
-		const entries = Array.from(form.entries());
-		if (entries.length > 1)
-			throw new RangeError("Expected only one entry in multipart response");
-		const [_, file] = entries[0];
-
-		if (file instanceof File) {
-			return await file.text();
+		// For testing purposes only, sorry not sorry -- msw doesn't implement Response#formData
+		if (!response.formData) {
+			response = new Response(await response.text(), response);
 		}
 
-		return file ?? "";
+		const form = await response.formData();
+		const files = Array.from(form.entries()).map(([filename, contents]) =>
+			contents instanceof File ? contents : new File([contents], filename)
+		);
+
+		return files;
 	} else {
-		return response.text();
+		const contents = await response.text();
+		const filename = response.headers.get("cf-entrypoint") ?? "index.js";
+		const file = new File([contents], filename, { type: "text" });
+
+		return [file];
 	}
 }

package/src/config/environment.ts

@@ -265,6 +265,13 @@ interface EnvironmentInheritable {
 	 * @inheritable
 	 */
 	logpush: boolean | undefined;
+
+	/**
+	 * Specify how the worker should be located to minimize round-trip time.
+	 *
+	 * More details: https://developers.cloudflare.com/workers/platform/smart-placement/
+	 */
+	placement: { mode: "off" | "smart" } | undefined;
 }
 
 export type DurableObjectBindings = {
@@ -448,6 +455,22 @@ interface EnvironmentNonInheritable {
 		database_internal_env?: string;
 	}[];
 
+	/**
+	 * Specifies Constellation projects 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
+	 */
+	constellation: {
+		/** The binding name used to refer to the project in the worker. */
+		binding: string;
+		/** The id of the project. */
+		project_id: string;
+	}[];
+
 	/**
 	 * Specifies service bindings (worker-to-worker) that are bound to this Worker environment.
 	 *
@@ -484,6 +507,15 @@ interface EnvironmentNonInheritable {
 		dataset?: string;
 	}[];
 
+	/**
+	 * A browser that will be usable from the worker.
+	 */
+	browser:
+		| {
+				binding: string;
+		  }
+		| undefined;
+
 	/**
 	 * "Unsafe" tables for features that aren't directly supported by wrangler.
 	 *
@@ -519,6 +551,8 @@ interface EnvironmentNonInheritable {
 		/** The uuid of the uploaded mTLS certificate */
 		certificate_id: string;
 	}[];
+
+	tail_consumers?: TailConsumer[];
 }
 
 /**
@@ -616,3 +650,10 @@ export type ConfigModuleRuleType =
 	| "CompiledWasm"
 	| "Text"
 	| "Data";
+
+export type TailConsumer = {
+	/** The name of the service tail events will be forwarded to. */
+	service: string;
+	/** (Optional) The environt of the service. */
+	environment?: string;
+};

package/src/config/index.ts

@@ -100,11 +100,13 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		send_email,
 		queues,
 		d1_databases,
+		constellation,
 		r2_buckets,
 		logfwdr,
 		services,
 		analytics_engine_datasets,
 		text_blobs,
+		browser,
 		unsafe,
 		vars,
 		wasm_modules,
@@ -207,6 +209,18 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
+	if (constellation !== undefined && constellation.length > 0) {
+		output.push({
+			type: "Constellation Projects",
+			entries: constellation.map(({ binding, project_id }) => {
+				return {
+					key: binding,
+					value: project_id,
+				};
+			}),
+		});
+	}
+
 	if (r2_buckets !== undefined && r2_buckets.length > 0) {
 		output.push({
 			type: "R2 Buckets",
@@ -273,6 +287,13 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
+	if (browser !== undefined) {
+		output.push({
+			type: "Browser",
+			entries: [{ key: "Name", value: browser.binding }],
+		});
+	}
+
 	if (unsafe?.bindings !== undefined && unsafe.bindings.length > 0) {
 		output.push({
 			type: "Unsafe",