wrangler 2.0.22 → 2.0.25

package/src/miniflare-cli/index.ts

@@ -1,8 +1,28 @@
-import { Log, LogLevel, Miniflare } from "miniflare";
+import { fetch } from "@miniflare/core";
+import {
+	DurableObjectNamespace,
+	DurableObjectStub,
+} from "@miniflare/durable-objects";
+import {
+	Log,
+	LogLevel,
+	Miniflare,
+	Response as MiniflareResponse,
+	Request as MiniflareRequest,
+} from "miniflare";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
+import { FatalError } from "../errors";
+import generateASSETSBinding from "./assets";
 import { enumKeys } from "./enum-keys";
 import { getRequestContextCheckOptions } from "./request-context";
+import type { Options } from "./assets";
+import type { AddressInfo } from "net";
+
+export interface EnablePagesAssetsServiceBindingOptions {
+	proxyPort?: number;
+	directory?: string;
+}
 
 // miniflare defines this but importing it throws:
 // Dynamic require of "path" is not supported
@@ -29,24 +49,155 @@ async function main() {
 		...requestContextCheckOptions,
 	};
 	//miniflare's logLevel 0 still logs routes, so lets override the logger
-	config.log = config.disableLogs ? new NoOpLog() : new Log(logLevel);
+	config.log = config.disableLogs
+		? new NoOpLog()
+		: new Log(logLevel, config.logOptions);
 
 	if (logLevel > LogLevel.INFO) {
 		console.log("OPTIONS:\n", JSON.stringify(config, null, 2));
 	}
 
-	const mf = new Miniflare(config);
+	config.bindings = {
+		...config.bindings,
+		...Object.fromEntries(
+			Object.entries(
+				config.externalDurableObjects as Record<
+					string,
+					{ name: string; host: string; port: number }
+				>
+			).map(([binding, { name, host, port }]) => {
+				const factory = () => {
+					throw new FatalError(
+						"An external Durable Object instance's state has somehow been attempted to be accessed.",
+						1
+					);
+				};
+				const namespace = new DurableObjectNamespace(name as string, factory);
+				namespace.get = (id) => {
+					const stub = new DurableObjectStub(factory, id);
+					stub.fetch = (...reqArgs) => {
+						const url = `http://${host}${port ? `:${port}` : ""}`;
+						const request = new MiniflareRequest(
+							url,
+							new MiniflareRequest(...reqArgs)
+						);
+						request.headers.set("x-miniflare-durable-object-name", name);
+						request.headers.set("x-miniflare-durable-object-id", id.toString());
+
+						return fetch(request);
+					};
+					return stub;
+				};
+				return [binding, namespace];
+			})
+		),
+	};
+
+	let mf: Miniflare | undefined;
+	let durableObjectsMf: Miniflare | undefined = undefined;
+	let durableObjectsMfPort: number | undefined = undefined;
 
 	try {
+		if (args._[1]) {
+			const opts: EnablePagesAssetsServiceBindingOptions = JSON.parse(
+				args._[1] as string
+			);
+
+			if (isNaN(opts.proxyPort || NaN) && !opts.directory) {
+				throw new Error(
+					"MiniflareCLIOptions: built in service bindings set to true, but no port or directory provided"
+				);
+			}
+
+			const options: Options = {
+				log: config.log,
+				proxyPort: opts.proxyPort,
+				directory: opts.directory,
+			};
+
+			config.serviceBindings = {
+				...config.serviceBindings,
+				ASSETS: await generateASSETSBinding(options),
+			};
+		}
+		mf = new Miniflare(config);
 		// Start Miniflare development server
 		await mf.startServer();
 		await mf.startScheduler();
-		process.send && process.send("ready");
+
+		const internalDurableObjectClassNames = Object.values(
+			config.durableObjects as Record<string, string>
+		);
+
+		if (internalDurableObjectClassNames.length > 0) {
+			durableObjectsMf = new Miniflare({
+				host: config.host,
+				port: 0,
+				script: `
+				export default {
+					fetch(request, env) {
+						return env.DO.fetch(request)
+					}
+				}`,
+				serviceBindings: {
+					DO: async (request: MiniflareRequest) => {
+						request = new MiniflareRequest(request);
+
+						const name = request.headers.get("x-miniflare-durable-object-name");
+						const idString = request.headers.get(
+							"x-miniflare-durable-object-id"
+						);
+						request.headers.delete("x-miniflare-durable-object-name");
+						request.headers.delete("x-miniflare-durable-object-id");
+
+						if (!name || !idString) {
+							return new MiniflareResponse(
+								"[durable-object-proxy-err] Missing `x-miniflare-durable-object-name` or `x-miniflare-durable-object-id` headers.",
+								{ status: 400 }
+							);
+						}
+
+						const namespace = await mf?.getDurableObjectNamespace(name);
+						const id = namespace?.idFromString(idString);
+
+						if (!id) {
+							return new MiniflareResponse(
+								"[durable-object-proxy-err] Could not generate an ID. Possibly due to a mismatched DO name and ID?",
+								{ status: 500 }
+							);
+						}
+
+						const stub = namespace?.get(id);
+
+						if (!stub) {
+							return new MiniflareResponse(
+								"[durable-object-proxy-err] Could not generate a stub. Possibly due to a mismatched DO name and ID?",
+								{ status: 500 }
+							);
+						}
+
+						return stub.fetch(request);
+					},
+				},
+				modules: true,
+			});
+			const server = await durableObjectsMf.startServer();
+			durableObjectsMfPort = (server.address() as AddressInfo).port;
+		}
+
+		process.send &&
+			process.send(
+				JSON.stringify({
+					ready: true,
+					durableObjectsPort: durableObjectsMfPort,
+				})
+			);
 	} catch (e) {
-		mf.log.error(e as Error);
+		mf?.log.error(e as Error);
 		process.exitCode = 1;
 		// Unmount any mounted workers
-		await mf.dispose();
+		await mf?.dispose();
+		await durableObjectsMf?.dispose();
 	}
 }
 

package/src/module-collection.ts

@@ -123,9 +123,9 @@ export default function createModuleCollector(props: {
 						{
 							filter: new RegExp(
 								"^(" +
-									[...props.wrangler1xlegacyModuleReferences.fileNames].join(
-										"|"
-									) +
+									[...props.wrangler1xlegacyModuleReferences.fileNames]
+										.map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+										.join("|") +
 									")$"
 							),
 						},

package/src/pages/build.tsx

@@ -9,24 +9,15 @@ import { buildPlugin } from "./functions/buildPlugin";
 import { buildWorker } from "./functions/buildWorker";
 import { generateConfigFromFileTree } from "./functions/filepath-routing";
 import { writeRoutesModule } from "./functions/routes";
+import { convertRoutesToRoutesJSONSpec } from "./functions/routes-transformation";
 import { pagesBetaWarning, RUNNING_BUILDERS } from "./utils";
 import type { Config } from "./functions/routes";
-import type { ArgumentsCamelCase, Argv } from "yargs";
+import type { YargsOptionsToInterface } from "./types";
+import type { Argv } from "yargs";
 
-type PagesBuildArgs = {
-	directory: string;
-	outfile: string;
-	"output-config-path"?: string;
-	minify: boolean;
-	sourcemap: boolean;
-	"fallback-service": string;
-	watch: boolean;
-	plugin: boolean;
-	"build-output-directory"?: string;
-	"node-compat": boolean;
-};
+type PagesBuildArgs = YargsOptionsToInterface<typeof Options>;
 
-export function Options(yargs: Argv): Argv<PagesBuildArgs> {
+export function Options(yargs: Argv) {
 	return yargs
 		.positional("directory", {
 			type: "string",
@@ -43,6 +34,10 @@ export function Options(yargs: Argv): Argv<PagesBuildArgs> {
 				type: "string",
 				description: "The location for the output config file",
 			},
+			"output-routes-path": {
+				type: "string",
+				description: "The location for the output _routes.json file",
+			},
 			minify: {
 				type: "boolean",
 				default: false,
@@ -87,15 +82,16 @@ export function Options(yargs: Argv): Argv<PagesBuildArgs> {
 export const Handler = async ({
 	directory,
 	outfile,
-	"output-config-path": outputConfigPath,
+	outputConfigPath,
+	outputRoutesPath: routesOutputPath,
 	minify,
 	sourcemap,
 	fallbackService,
 	watch,
 	plugin,
-	"build-output-directory": buildOutputDirectory,
-	"node-compat": nodeCompat,
-}: ArgumentsCamelCase<PagesBuildArgs>) => {
+	buildOutputDirectory,
+	nodeCompat,
+}: PagesBuildArgs) => {
 	if (!isInPagesCI) {
 		// Beta message for `wrangler pages <commands>` usage
 		logger.log(pagesBetaWarning);
@@ -120,6 +116,7 @@ export const Handler = async ({
 		plugin,
 		buildOutputDirectory,
 		nodeCompat,
+		routesOutputPath,
 	});
 	await metrics.sendMetricsEvent("build pages functions");
 };
@@ -135,19 +132,25 @@ export async function buildFunctions({
 	onEnd,
 	plugin = false,
 	buildOutputDirectory,
+	routesOutputPath,
 	nodeCompat,
-}: {
-	outfile: string;
-	outputConfigPath?: string;
+}: Partial<
+	Pick<
+		PagesBuildArgs,
+		| "outputConfigPath"
+		| "minify"
+		| "sourcemap"
+		| "fallbackService"
+		| "watch"
+		| "plugin"
+		| "buildOutputDirectory"
+		| "nodeCompat"
+	>
+> & {
 	functionsDirectory: string;
-	minify?: boolean;
-	sourcemap?: boolean;
-	fallbackService?: string;
-	watch?: boolean;
 	onEnd?: () => void;
-	plugin?: boolean;
-	buildOutputDirectory?: string;
-	nodeCompat?: boolean;
+	outfile: Required<PagesBuildArgs>["outfile"];
+	routesOutputPath?: PagesBuildArgs["outputRoutesPath"];
 }) {
 	RUNNING_BUILDERS.forEach(
 		(runningBuilder) => runningBuilder.stop && runningBuilder.stop()
@@ -161,6 +164,11 @@ export async function buildFunctions({
 		baseURL,
 	});
 
+	if (config.routes && routesOutputPath) {
+		const routesJSON = convertRoutesToRoutesJSONSpec(config.routes);
+		writeFileSync(routesOutputPath, JSON.stringify(routesJSON, null, 2));
+	}
+
 	if (outputConfigPath) {
 		writeFileSync(
 			outputConfigPath,

package/src/pages/constants.ts

@@ -3,5 +3,9 @@ export const MAX_BUCKET_SIZE = 50 * 1024 * 1024;
 export const MAX_BUCKET_FILE_COUNT = 5000;
 export const BULK_UPLOAD_CONCURRENCY = 3;
 export const MAX_UPLOAD_ATTEMPTS = 5;
+export const MAX_CHECK_MISSING_ATTEMPTS = 5;
 export const SECONDS_TO_WAIT_FOR_PROXY = 5;
 export const isInPagesCI = !!process.env.CF_PAGES;
+/** The max number of rules in _routes.json */
+export const MAX_FUNCTIONS_ROUTES_RULES = 100;
+export const ROUTES_SPEC_VERSION = 1;

package/src/pages/deployments.tsx

@@ -11,14 +11,16 @@ import { requireAuth } from "../user";
 import { PAGES_CONFIG_CACHE_FILENAME } from "./constants";
 import { listProjects } from "./projects";
 import { pagesBetaWarning } from "./utils";
-import type { Deployment, PagesConfigCache } from "./types";
-import type { ArgumentsCamelCase, Argv } from "yargs";
+import type {
+	Deployment,
+	PagesConfigCache,
+	YargsOptionsToInterface,
+} from "./types";
+import type { Argv } from "yargs";
 
-type ListArgs = {
-	"project-name"?: string;
-};
+type ListArgs = YargsOptionsToInterface<typeof ListOptions>;
 
-export function ListOptions(yargs: Argv): Argv<ListArgs> {
+export function ListOptions(yargs: Argv) {
 	return yargs
 		.options({
 			"project-name": {
@@ -30,9 +32,7 @@ export function ListOptions(yargs: Argv): Argv<ListArgs> {
 		.epilogue(pagesBetaWarning);
 }
 
-export async function ListHandler({
-	projectName,
-}: ArgumentsCamelCase<ListArgs>) {
+export async function ListHandler({ projectName }: ListArgs) {
 	const config = getConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME);
 	const accountId = await requireAuth(config);
 
@@ -102,5 +102,5 @@ export async function ListHandler({
 		patchConsole: false,
 	});
 	unmount();
-	await metrics.sendMetricsEvent("list pages projects deployments");
+	await metrics.sendMetricsEvent("list pages deployments");
 }