wrangler 0.0.0-e33bea9b → 0.0.0-e351afcf

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/__tests__/worker-namespace.test.ts

@@ -27,6 +27,7 @@ describe("dispatch-namespace", () => {
 		Object {
 		  "debug": "",
 		  "err": "",
+		  "info": "",
 		  "out": "wrangler dispatch-namespace
 
 		📦 Interact with a dispatch namespace

package/src/api/dev.ts

@@ -3,6 +3,7 @@ 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 { RequestInit, Response, RequestInfo } from "undici";
 
@@ -42,6 +43,9 @@ export interface UnstableDevOptions {
 		bucket_name: string;
 		preview_bucket_name?: string;
 	}[];
+	processEntrypoint?: boolean;
+	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;
@@ -143,7 +147,6 @@ export async function unstable_dev(
 					enablePagesAssetsServiceBinding,
 					liveReload,
 					showInteractiveDevSession,
-					forceLocal,
 					onReady: (address, port) => {
 						readyPort = port;
 						readyAddress = address;
@@ -151,6 +154,7 @@ export async function unstable_dev(
 					},
 					config: options?.config,
 					env: options?.env,
+					processEntrypoint: !!options?.processEntrypoint,
 					bundle: options?.bundle,
 					compatibilityDate: options?.compatibilityDate,
 					compatibilityFlags: options?.compatibilityFlags,
@@ -232,6 +236,7 @@ export async function unstable_dev(
 					experimentalLocal: experimentalLocal ?? false,
 					experimentalLocalRemoteKv: experimentalLocalRemoteKv ?? false,
 					enablePagesAssetsServiceBinding,
+					forceLocal,
 					liveReload,
 					onReady: (address, port) => {
 						readyPort = port;
@@ -301,27 +306,16 @@ export async function unstable_dev(
 export function parseRequestInput(
 	readyAddress: string,
 	readyPort: number,
-	input?: RequestInfo,
+	input: RequestInfo = "/",
 	init?: RequestInit,
 	protocol: "http" | "https" = "http"
 ): [RequestInfo, RequestInit | undefined] {
 	if (input instanceof Request) {
 		return [input, undefined];
-	} else if (input instanceof URL) {
-		input = `${protocol}://${readyAddress}:${readyPort}${input.pathname}`;
-	} else if (typeof input === "string") {
-		try {
-			// Want to strip the URL to only get the pathname, but the user could pass in only the pathname
-			// Will error if we try and pass "/something" into new URL("/something")
-			input = `${protocol}://${readyAddress}:${readyPort}${
-				new URL(input).pathname
-			}`;
-		} catch {
-			input = `${protocol}://${readyAddress}:${readyPort}${input}`;
-		}
-	} else {
-		input = `${protocol}://${readyAddress}:${readyPort}`;
 	}
-
-	return [input, init];
+	const url = new URL(`${input}`, `${protocol}://${readyAddress}:${readyPort}`);
+	url.protocol = protocol;
+	url.hostname = readyAddress;
+	url.port = readyPort.toString();
+	return [url, init];
 }

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

@@ -49,6 +49,7 @@ function createWorkerBundleFormData(workerBundle: BundleResult): FormData {
 		bindings: {
 			vars: undefined,
 			kv_namespaces: undefined,
+			send_email: undefined,
 			wasm_modules: undefined,
 			text_blobs: undefined,
 			data_blobs: undefined,

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,12 +7,19 @@ 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 { CfModule } from "./worker";
+
+export const COMMON_ESBUILD_OPTIONS = {
+	// Our workerd runtime uses the same V8 version as recent Chrome, which is highly ES2022 compliant: https://kangax.github.io/compat-table/es2016plus/
+	target: "es2022",
+	loader: { ".js": "jsx", ".mjs": "jsx", ".cjs": "jsx" },
+} as const;
+
 export type BundleResult = {
 	modules: CfModule[];
 	dependencies: esbuild.Metafile["outputs"][string]["inputs"];
@@ -94,6 +101,15 @@ const nodejsCompatPlugin: esbuild.Plugin = {
 	},
 };
 
+const cloudflareJsPlugin: esbuild.Plugin = {
+	name: "cloudflare javascript Plugin",
+	setup(pluginBuild) {
+		pluginBuild.onResolve({ filter: /^cloudflare:.*/ }, () => {
+			return { external: true };
+		});
+	},
+};
+
 /**
  * Generate a bundle for the worker identified by the arguments passed in.
  */
@@ -101,6 +117,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[];
@@ -133,6 +151,7 @@ export async function bundleWorker(
 	}
 ): Promise<BundleResult> {
 	const {
+		bundle = true,
 		serveAssetsFromWorker,
 		betaD1Shims,
 		doBindings,
@@ -334,7 +353,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,
@@ -346,10 +365,9 @@ export async function bundleWorker(
 			  }
 			: {}),
 		inject,
-		external: ["__STATIC_CONTENT_MANIFEST"],
+		external: bundle ? ["__STATIC_CONTENT_MANIFEST"] : undefined,
 		format: entry.format === "modules" ? "esm" : "iife",
-		// Our workerd runtime uses the same V8 version as recent Chrome, which is highly ES2022 compliant: https://kangax.github.io/compat-table/es2016plus/
-		target: "es2022",
+		target: COMMON_ESBUILD_OPTIONS.target,
 		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.
@@ -368,9 +386,7 @@ export async function bundleWorker(
 			},
 		}),
 		loader: {
-			".js": "jsx",
-			".mjs": "jsx",
-			".cjs": "jsx",
+			...COMMON_ESBUILD_OPTIONS.loader,
 			...(loader || {}),
 		},
 		plugins: [
@@ -379,6 +395,7 @@ export async function bundleWorker(
 				? [NodeGlobalsPolyfills({ buffer: true }), NodeModulesPolyfills()]
 				: []),
 			...(nodejsCompat ? [nodejsCompatPlugin] : []),
+			...[cloudflareJsPlugin],
 			...(plugins || []),
 		],
 		...(jsxFactory && { jsxFactory }),
@@ -585,7 +602,7 @@ async function applyMiddlewareLoaderFacade(
 					...Object.fromEntries(
 						middleware.map((val, index) => [
 							middlewareIdentifiers[index],
-							toUrlPath(path.resolve(getBasePath(), val.path)),
+							path.resolve(getBasePath(), val.path),
 						])
 					),
 				}),

package/src/config/environment.ts

@@ -74,6 +74,12 @@ interface EnvironmentInheritable {
 	 */
 	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.
@@ -339,6 +345,24 @@ interface EnvironmentNonInheritable {
 		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.
 	 *
@@ -374,6 +398,9 @@ interface EnvironmentNonInheritable {
 
 			/** The queue to send messages that failed to be consumed. */
 			dead_letter_queue?: string;
+
+			/** The maximum number of concurrent consumer Worker invocations. Leaving this unset will allow your consumer to scale to the maximum concurrency needed to keep up with the message backlog. */
+			max_concurrency?: number | null;
 		}[];
 	};
 

package/src/config/index.ts

@@ -97,6 +97,7 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		data_blobs,
 		durable_objects,
 		kv_namespaces,
+		send_email,
 		queues,
 		d1_databases,
 		r2_buckets,
@@ -155,6 +156,23 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
+	if (send_email !== undefined && send_email.length > 0) {
+		output.push({
+			type: "Send Email",
+			entries: send_email.map(
+				({ name, destination_address, allowed_destination_addresses }) => {
+					return {
+						key: name,
+						value:
+							destination_address ||
+							allowed_destination_addresses?.join(", ") ||
+							"unrestricted",
+					};
+				}
+			),
+		});
+	}
+
 	if (queues !== undefined && queues.length > 0) {
 		output.push({
 			type: "Queues",

package/src/config/validation.ts

@@ -358,6 +358,26 @@ function normalizeAndValidateMainField(
 	}
 }
 
+/**
+ * Validate the `base_dir` field and return the normalized values.
+ */
+function normalizeAndValidateBaseDirField(
+	configPath: string | undefined,
+	rawDir: string | undefined
+): string | undefined {
+	const configDir = path.dirname(configPath ?? "wrangler.toml");
+	if (rawDir !== undefined) {
+		if (typeof rawDir === "string") {
+			const directory = path.resolve(configDir);
+			return path.resolve(directory, rawDir);
+		} else {
+			return rawDir;
+		}
+	} else {
+		return;
+	}
+}
+
 /**
  * Validate the `dev` configuration and return the normalized values.
  */
@@ -1011,6 +1031,17 @@ function normalizeAndValidateEnvironment(
 			),
 			deprecatedUpload
 		),
+		base_dir: normalizeAndValidateBaseDirField(
+			configPath,
+			inheritable(
+				diagnostics,
+				topLevelEnv,
+				rawEnv,
+				"base_dir",
+				isString,
+				undefined
+			)
+		),
 		route,
 		routes,
 		triggers: inheritable(
@@ -1074,6 +1105,16 @@ function normalizeAndValidateEnvironment(
 			validateBindingArray(envName, validateKVBinding),
 			[]
 		),
+		send_email: notInheritable(
+			diagnostics,
+			topLevelEnv,
+			rawConfig,
+			rawEnv,
+			envName,
+			"send_email",
+			validateBindingArray(envName, validateSendEmailBinding),
+			[]
+		),
 		queues: notInheritable(
 			diagnostics,
 			topLevelEnv,
@@ -1765,6 +1806,53 @@ const validateKVBinding: ValidatorFn = (diagnostics, field, value) => {
 	return isValid;
 };
 
+const validateSendEmailBinding: ValidatorFn = (diagnostics, field, value) => {
+	if (typeof value !== "object" || value === null) {
+		diagnostics.errors.push(
+			`"send_email" bindings should be objects, but got ${JSON.stringify(
+				value
+			)}`
+		);
+		return false;
+	}
+	let isValid = true;
+	// send email bindings must have a name.
+	if (!isRequiredProperty(value, "name", "string")) {
+		diagnostics.errors.push(
+			`"${field}" bindings should have a string "name" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (!isOptionalProperty(value, "destination_address", "string")) {
+		diagnostics.errors.push(
+			`"${field}" bindings should, optionally, have a string "destination_address" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (!isOptionalProperty(value, "allowed_destination_addresses", "object")) {
+		diagnostics.errors.push(
+			`"${field}" bindings should, optionally, have a []string "allowed_destination_addresses" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (
+		"destination_address" in value &&
+		"allowed_destination_addresses" in value
+	) {
+		diagnostics.errors.push(
+			`"${field}" bindings should have either a "destination_address" or "allowed_destination_addresses" field, but not both.`
+		);
+		isValid = false;
+	}
+	return isValid;
+};
+
 const validateQueueBinding: ValidatorFn = (diagnostics, field, value) => {
 	if (typeof value !== "object" || value === null) {
 		diagnostics.errors.push(
@@ -2215,6 +2303,7 @@ const validateConsumer: ValidatorFn = (diagnostics, field, value, _config) => {
 			"max_batch_timeout",
 			"max_retries",
 			"dead_letter_queue",
+			"max_concurrency",
 		])
 	) {
 		isValid = false;
@@ -2230,12 +2319,13 @@ const validateConsumer: ValidatorFn = (diagnostics, field, value, _config) => {
 
 	const options: {
 		key: string;
-		type: "number" | "string";
+		type: "number" | "string" | "boolean";
 	}[] = [
 		{ key: "max_batch_size", type: "number" },
 		{ key: "max_batch_timeout", type: "number" },
 		{ key: "max_retries", type: "number" },
 		{ key: "dead_letter_queue", type: "string" },
+		{ key: "max_concurrency", type: "number" },
 	];
 	for (const optionalOpt of options) {
 		if (!isOptionalProperty(value, optionalOpt.key, optionalOpt.type)) {

package/src/constellation/createProject.tsx

@@ -0,0 +1,51 @@
+import { fetchResult } from "../cfetch";
+import { withConfig } from "../config";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { takeName } from "./options";
+import { constellationBetaWarning } from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+import type { Project } from "./types";
+
+export function options(yargs: CommonYargsArgv) {
+	return takeName(yargs)
+		.positional("runtime", {
+			describe: "The name of the runtime to use",
+			type: "string",
+			demandOption: true,
+		})
+		.epilogue(constellationBetaWarning);
+}
+
+type HandlerOptions = StrictYargsOptionsToInterface<typeof options>;
+export const handler = withConfig<HandlerOptions>(
+	async ({ name, runtime, config }): Promise<void> => {
+		const accountId = await requireAuth(config);
+
+		logger.log(constellationBetaWarning);
+
+		let proj: Project;
+		try {
+			proj = await fetchResult(`/accounts/${accountId}/constellation/project`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify({
+					name,
+					runtime,
+				}),
+			});
+		} catch (e) {
+			if ((e as { code: number }).code === 7409) {
+				throw new Error("A project with that name already exists");
+			}
+			throw e;
+		}
+
+		logger.log(`✅ Successfully created Project "${proj.name}"!`);
+	}
+);

package/src/constellation/deleteProject.ts

@@ -0,0 +1,51 @@
+import { fetchResult } from "../cfetch";
+import { withConfig } from "../config";
+import { confirm } from "../dialogs";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { takeName } from "./options";
+import { constellationBetaWarning, getProjectByName } from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+
+export function options(yargs: CommonYargsArgv) {
+	return takeName(yargs)
+		.option("force", {
+			describe: "Skip confirmation",
+			type: "boolean",
+			alias: "f",
+			default: false,
+		})
+		.epilogue(constellationBetaWarning);
+}
+type HandlerOptions = StrictYargsOptionsToInterface<typeof options>;
+export const handler = withConfig<HandlerOptions>(
+	async ({ name, force, config }): Promise<void> => {
+		const accountId = await requireAuth(config);
+		logger.log(constellationBetaWarning);
+
+		const proj = await getProjectByName(config, accountId, name);
+
+		logger.log(`About to delete Project '${name}' (${proj.id}).`);
+		if (!force) {
+			const response = await confirm(`Ok to proceed?`);
+			if (!response) {
+				logger.log(`Not deleting.`);
+				return;
+			}
+
+			logger.log("Deleting...");
+		}
+
+		await fetchResult(
+			`/accounts/${accountId}/constellation/project/${proj.id}`,
+			{
+				method: "DELETE",
+			}
+		);
+
+		logger.log(`Deleted '${name}' successfully.`);
+	}
+);