wrangler 2.8.0 → 2.9.0

package/src/api/pages/publish.tsx

@@ -0,0 +1,324 @@
+import { existsSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve as resolvePath } from "node:path";
+import { cwd } from "node:process";
+import { File, FormData } from "undici";
+import { fetchResult } from "../../cfetch";
+import { FatalError } from "../../errors";
+import { logger } from "../../logger";
+import { buildFunctions } from "../../pages/buildFunctions";
+import {
+	FunctionsNoRoutesError,
+	getFunctionsNoRoutesWarning,
+} from "../../pages/errors";
+import {
+	buildRawWorker,
+	checkRawWorker,
+} from "../../pages/functions/buildWorker";
+import { validateRoutes } from "../../pages/functions/routes-validation";
+import { upload } from "../../pages/upload";
+import type { Project, Deployment } from "@cloudflare/types";
+
+interface PagesPublishOptions {
+	/**
+	 * Path to static assets to publish to Pages
+	 */
+	directory: string;
+	/**
+	 * The Cloudflare Account ID that owns the project that's
+	 * being published
+	 */
+	accountId: string;
+	/**
+	 * The name of the project to be published
+	 */
+	projectName: string;
+	/**
+	 * Branch name to use. Defaults to production branch
+	 */
+	branch?: string;
+	/**
+	 * Whether or not to skip local file upload result caching
+	 */
+	skipCaching?: boolean;
+	/**
+	 * Commit message associated to deployment
+	 */
+	commitMessage?: string;
+	/**
+	 * Commit hash associated to deployment
+	 */
+	commitHash?: string;
+	/**
+	 * Whether or not the deployment should be considered to be
+	 * in a dirty commit state
+	 */
+	commitDirty?: boolean;
+	/**
+	 * Path to the project's functions directory. Default uses
+	 * the current working directory + /functions since this is
+	 * typically called in a CLI
+	 */
+	functionsDirectory?: string;
+
+	/**
+	 * Whether to run bundling on `_worker.js` before deploying.
+	 * Default: false
+	 */
+	bundle?: boolean;
+
+	// TODO: Allow passing in the API key and plumb it through
+	// to the API calls so that the publish function does not
+	// rely on the `CLOUDFLARE_API_KEY` environment variable
+}
+
+/**
+ * Publish a directory to an account/project.
+ * NOTE: You will need the `CLOUDFLARE_API_KEY` environment
+ * variable set
+ */
+export async function publish({
+	directory,
+	accountId,
+	projectName,
+	branch,
+	skipCaching,
+	commitMessage,
+	commitHash,
+	commitDirty,
+	functionsDirectory: customFunctionsDirectory,
+	bundle,
+}: PagesPublishOptions) {
+	let _headers: string | undefined,
+		_redirects: string | undefined,
+		_routesGenerated: string | undefined,
+		_routesCustom: string | undefined,
+		_workerJS: string | undefined;
+
+	const workerScriptPath = resolvePath(directory, "_worker.js");
+
+	try {
+		_headers = readFileSync(join(directory, "_headers"), "utf-8");
+	} catch {}
+
+	try {
+		_redirects = readFileSync(join(directory, "_redirects"), "utf-8");
+	} catch {}
+
+	try {
+		/**
+		 * Developers can specify a custom _routes.json file, for projects with Pages
+		 * Functions or projects in Advanced Mode
+		 */
+		_routesCustom = readFileSync(join(directory, "_routes.json"), "utf-8");
+	} catch {}
+
+	try {
+		_workerJS = readFileSync(workerScriptPath, "utf-8");
+	} catch {}
+
+	// Grab the bindings from the API, we need these for shims and other such hacky inserts
+	const project = await fetchResult<Project>(
+		`/accounts/${accountId}/pages/projects/${projectName}`
+	);
+	let isProduction = true;
+	if (branch) {
+		isProduction = project.production_branch === branch;
+	}
+
+	/**
+	 * Evaluate if this is an Advanced Mode or Pages Functions project. If Advanced Mode, we'll
+	 * go ahead and upload `_worker.js` as is, but if Pages Functions, we need to attempt to build
+	 * Functions first and exit if it failed
+	 */
+	let builtFunctions: string | undefined = undefined;
+	const functionsDirectory =
+		customFunctionsDirectory || join(cwd(), "functions");
+	const routesOutputPath = !existsSync(join(directory, "_routes.json"))
+		? join(tmpdir(), `_routes-${Math.random()}.json`)
+		: undefined;
+
+	// Routing configuration displayed in the Functions tab of a deployment in Dash
+	let filepathRoutingConfig: string | undefined;
+
+	const d1Databases = Object.keys(
+		project.deployment_configs[isProduction ? "production" : "preview"]
+			.d1_databases ?? {}
+	);
+
+	if (!_workerJS && existsSync(functionsDirectory)) {
+		const outfile = join(tmpdir(), `./functionsWorker-${Math.random()}.js`);
+		const outputConfigPath = join(
+			tmpdir(),
+			`functions-filepath-routing-config-${Math.random()}.json`
+		);
+
+		try {
+			await buildFunctions({
+				outfile,
+				outputConfigPath,
+				functionsDirectory,
+				onEnd: () => {},
+				buildOutputDirectory: dirname(outfile),
+				routesOutputPath,
+				local: false,
+				d1Databases,
+			});
+
+			builtFunctions = readFileSync(outfile, "utf-8");
+			filepathRoutingConfig = readFileSync(outputConfigPath, "utf-8");
+		} catch (e) {
+			if (e instanceof FunctionsNoRoutesError) {
+				logger.warn(
+					getFunctionsNoRoutesWarning(functionsDirectory, "skipping")
+				);
+			} else {
+				throw e;
+			}
+		}
+	}
+
+	const manifest = await upload({
+		directory,
+		accountId,
+		projectName,
+		skipCaching: skipCaching ?? false,
+	});
+
+	const formData = new FormData();
+
+	formData.append("manifest", JSON.stringify(manifest));
+
+	if (branch) {
+		formData.append("branch", branch);
+	}
+
+	if (commitMessage) {
+		formData.append("commit_message", commitMessage);
+	}
+
+	if (commitHash) {
+		formData.append("commit_hash", commitHash);
+	}
+
+	if (commitDirty !== undefined) {
+		formData.append("commit_dirty", commitDirty);
+	}
+
+	if (_headers) {
+		formData.append("_headers", new File([_headers], "_headers"));
+		logger.log(`✨ Uploading _headers`);
+	}
+
+	if (_redirects) {
+		formData.append("_redirects", new File([_redirects], "_redirects"));
+		logger.log(`✨ Uploading _redirects`);
+	}
+
+	if (filepathRoutingConfig) {
+		formData.append(
+			"functions-filepath-routing-config.json",
+			new File(
+				[filepathRoutingConfig],
+				"functions-filepath-routing-config.json"
+			)
+		);
+	}
+
+	/**
+	 * Advanced Mode
+	 * https://developers.cloudflare.com/pages/platform/functions/#advanced-mode
+	 *
+	 * When using a _worker.js file, the entire /functions directory is ignored
+	 * – this includes its routing and middleware characteristics.
+	 */
+	if (_workerJS) {
+		let workerFileContents = _workerJS;
+		if (bundle) {
+			const outfile = join(tmpdir(), `./bundledWorker-${Math.random()}.mjs`);
+			await buildRawWorker({
+				workerScriptPath,
+				outfile,
+				directory: directory ?? ".",
+				local: false,
+				sourcemap: true,
+				watch: false,
+				onEnd: () => {},
+				betaD1Shims: d1Databases,
+			});
+			workerFileContents = readFileSync(outfile, "utf8");
+		} else {
+			await checkRawWorker(workerScriptPath, () => {});
+		}
+
+		formData.append("_worker.js", new File([workerFileContents], "_worker.js"));
+		logger.log(`✨ Uploading _worker.js`);
+
+		if (_routesCustom) {
+			// user provided a custom _routes.json file
+			try {
+				const routesCustomJSON = JSON.parse(_routesCustom);
+				validateRoutes(routesCustomJSON, join(directory, "_routes.json"));
+
+				formData.append(
+					"_routes.json",
+					new File([_routesCustom], "_routes.json")
+				);
+				logger.log(`✨ Uploading _routes.json`);
+			} catch (err) {
+				if (err instanceof FatalError) {
+					throw err;
+				}
+			}
+		}
+	}
+
+	/**
+	 * Pages Functions
+	 * https://developers.cloudflare.com/pages/platform/functions/
+	 */
+	if (builtFunctions && !_workerJS) {
+		// if Functions were build successfully, proceed to uploading the build file
+		formData.append("_worker.js", new File([builtFunctions], "_worker.js"));
+		logger.log(`✨ Uploading Functions`);
+
+		if (_routesCustom) {
+			// user provided a custom _routes.json file
+			try {
+				const routesCustomJSON = JSON.parse(_routesCustom);
+				validateRoutes(routesCustomJSON, join(directory, "_routes.json"));
+
+				formData.append(
+					"_routes.json",
+					new File([_routesCustom], "_routes.json")
+				);
+				logger.log(`✨ Uploading _routes.json`);
+			} catch (err) {
+				if (err instanceof FatalError) {
+					throw err;
+				}
+			}
+		} else if (routesOutputPath) {
+			// no custom _routes.json file found, so fallback to the generated one
+			try {
+				_routesGenerated = readFileSync(routesOutputPath, "utf-8");
+
+				if (_routesGenerated) {
+					formData.append(
+						"_routes.json",
+						new File([_routesGenerated], "_routes.json")
+					);
+				}
+			} catch {}
+		}
+	}
+
+	const deploymentResponse = await fetchResult<Deployment>(
+		`/accounts/${accountId}/pages/projects/${projectName}/deployments`,
+		{
+			method: "POST",
+			body: formData,
+		}
+	);
+	return deploymentResponse;
+}

package/src/bundle.ts

@@ -9,10 +9,10 @@ import tmp from "tmp-promise";
 import createModuleCollector from "./module-collection";
 import { getBasePath, toUrlPath } 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 type BundleResult = {
 	modules: CfModule[];
 	dependencies: esbuild.Metafile["outputs"][string]["inputs"];
@@ -95,6 +95,7 @@ export async function bundleWorker(
 		serveAssetsFromWorker: boolean;
 		assets?: StaticAssetsConfig;
 		betaD1Shims?: string[];
+		doBindings: DurableObjectBindings;
 		jsxFactory?: string;
 		jsxFragment?: string;
 		rules: Config["rules"];
@@ -123,6 +124,7 @@ export async function bundleWorker(
 	const {
 		serveAssetsFromWorker,
 		betaD1Shims,
+		doBindings,
 		jsxFactory,
 		jsxFragment,
 		rules,
@@ -271,7 +273,13 @@ export async function bundleWorker(
 		Array.isArray(betaD1Shims) &&
 			betaD1Shims.length > 0 &&
 			((currentEntry: Entry) => {
-				return applyD1BetaFacade(currentEntry, tmpDir.path, betaD1Shims, local);
+				return applyD1BetaFacade(
+					currentEntry,
+					tmpDir.path,
+					betaD1Shims,
+					local,
+					doBindings
+				);
 			}),
 
 		// Middleware loader: to add middleware, we add the path to the middleware
@@ -332,7 +340,7 @@ export async function bundleWorker(
 		sourceRoot: destination,
 		minify,
 		metafile: true,
-		conditions: ["worker", "browser"],
+		conditions: ["workerd", "worker", "browser"],
 		...(process.env.NODE_ENV && {
 			define: {
 				// use process.env["NODE_ENV" + ""] so that esbuild doesn't replace it
@@ -395,13 +403,23 @@ export async function bundleWorker(
 		_path.includes(".map")
 	)[0];
 
+	const resolvedEntryPointPath = path.resolve(
+		entry.directory,
+		entryPointOutputs[0][0]
+	);
+
+	// 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
+		);
+	}
+
 	return {
 		modules: moduleCollector.modules,
 		dependencies,
-		resolvedEntryPointPath: path.resolve(
-			entry.directory,
-			entryPointOutputs[0][0]
-		),
+		resolvedEntryPointPath,
 		bundleType,
 		stop: result.stop,
 		sourceMapPath,
@@ -779,17 +797,51 @@ async function applyFirstPartyWorkerDevFacade(
  * This code be removed from here when the API is in Workers core,
  * but moved inside Miniflare for simulating D1.
  */
-
 async function applyD1BetaFacade(
 	entry: Entry,
 	tmpDirPath: string,
 	betaD1Shims: string[],
-	local: boolean
+	local: boolean,
+	doBindings: DurableObjectBindings
 ): Promise<Entry> {
+	let entrypointPath = path.resolve(
+		getBasePath(),
+		"templates/d1-beta-facade.js"
+	);
+	if (Array.isArray(doBindings) && doBindings.length > 0) {
+		//we have DO bindings, so we need to shim them
+		const maskedDoBindings = doBindings
+			// Don't shim anything not local to this worker
+			.filter((b) => !b.script_name)
+			// Reexport the DO classnames
+			.map(
+				(b) =>
+					`export const ${b.class_name} = maskDurableObjectDefinition(OTHER_EXPORTS.${b.class_name});`
+			)
+			.join("\n");
+		const baseFile = fs.readFileSync(
+			path.resolve(getBasePath(), "templates/d1-beta-facade.js"),
+			"utf8"
+		);
+		//getMaskedEnv is already used to shim regular Workers
+		const contents = `
+		${baseFile}
+
+		var maskDurableObjectDefinition = (cls) =>
+		class extends cls {
+			constructor(state, env) {
+				super(state, getMaskedEnv(env));
+			}
+		};
+		${maskedDoBindings}`;
+		const doD1FacadePath = path.join(tmpDirPath, "d1-do-facade.js");
+		//write our shim so we can build it
+		fs.writeFileSync(doD1FacadePath, contents);
+		entrypointPath = doD1FacadePath;
+	}
 	const targetPath = path.join(tmpDirPath, "d1-beta-facade.entry.js");
-
 	await esbuild.build({
-		entryPoints: [path.resolve(getBasePath(), "templates/d1-beta-facade.js")],
+		entryPoints: [entrypointPath],
 		bundle: true,
 		format: "esm",
 		sourcemap: true,

package/src/cli.ts

@@ -1,6 +1,6 @@
 import process from "process";
 import { hideBin } from "yargs/helpers";
-import { unstable_dev } from "./api";
+import { unstable_dev, unstable_pages } from "./api";
 import { FatalError } from "./errors";
 import { main } from ".";
 
@@ -24,5 +24,5 @@ if (typeof jest === "undefined" && require.main === module) {
  * It makes it possible to import wrangler from 'wrangler',
  * and call wrangler.unstable_dev().
  */
-export { unstable_dev };
+export { unstable_dev, unstable_pages };
 export type { UnstableDevWorker, UnstableDevOptions };

package/src/config/config.ts

@@ -1,4 +1,5 @@
 import type { Environment, RawEnvironment } from "./environment";
+import type { CamelCaseKey } from "yargs";
 
 /**
  * This is the static type definition for the configuration object.
@@ -273,3 +274,9 @@ interface EnvironmentMap {
 		[envName: string]: RawEnvironment;
 	};
 }
+
+// API dev only passes in camel-cased versions of keys, so ensure
+// only camel-cased keys are used
+export type OnlyCamelCase<T = Record<string, never>> = {
+	[key in keyof T as CamelCaseKey<key>]: T[key];
+};

package/src/config/environment.ts

@@ -261,6 +261,17 @@ interface EnvironmentInheritable {
 	logpush: boolean | undefined;
 }
 
+export type DurableObjectBindings = {
+	/** The name of the binding used to refer to the Durable Object */
+	name: string;
+	/** The exported class name of the Durable Object */
+	class_name: string;
+	/** The script where the Durable Object is defined (if it's external to this worker) */
+	script_name?: string;
+	/** The service environment of the script_name to bind to */
+	environment?: string;
+}[];
+
 /**
  * The `EnvironmentNonInheritable` interface declares all the configuration fields for an environment
  * that cannot be inherited from the top-level environment, and must be defined specifically.
@@ -303,16 +314,7 @@ interface EnvironmentNonInheritable {
 	 * @nonInheritable
 	 */
 	durable_objects: {
-		bindings: {
-			/** The name of the binding used to refer to the Durable Object */
-			name: string;
-			/** The exported class name of the Durable Object */
-			class_name: string;
-			/** The script where the Durable Object is defined (if it's external to this worker) */
-			script_name?: string;
-			/** The service environment of the script_name to bind to */
-			environment?: string;
-		}[];
+		bindings: DurableObjectBindings;
 	};
 
 	/**

package/src/config/index.ts

@@ -2,12 +2,12 @@ import fs from "node:fs";
 import dotenv from "dotenv";
 import { findUpSync } from "find-up";
 import { logger } from "../logger";
-import { parseTOML, readFileSync } from "../parse";
+import { parseJSONC, parseTOML, readFileSync } from "../parse";
 import { removeD1BetaPrefix } from "../worker";
 import { normalizeAndValidateConfig } from "./validation";
 import type { CfWorkerInit } from "../worker";
-import type { Config, RawConfig } from "./config";
-import type { CamelCaseKey } from "yargs";
+import type { CommonYargsOptions } from "../yargs-types";
+import type { Config, OnlyCamelCase, RawConfig } from "./config";
 
 export type {
 	Config,
@@ -25,18 +25,21 @@ export type {
 /**
  * Get the Wrangler configuration; read it from the give `configPath` if available.
  */
-export function readConfig(
+
+export function readConfig<CommandArgs>(
 	configPath: string | undefined,
-	args: unknown
+	// Include command specific args as well as the wrangler global flags
+	args: CommandArgs & OnlyCamelCase<CommonYargsOptions>
 ): Config {
 	let rawConfig: RawConfig = {};
 	if (!configPath) {
-		configPath = findWranglerToml();
+		configPath = findWranglerToml(process.cwd(), args.experimentalJsonConfig);
 	}
-
 	// Load the configuration from disk if available
-	if (configPath) {
+	if (configPath?.endsWith("toml")) {
 		rawConfig = parseTOML(readFileSync(configPath), configPath);
+	} else if (configPath?.endsWith("json")) {
+		rawConfig = parseJSONC(readFileSync(configPath), configPath);
 	}
 
 	// Process the top-level configuration.
@@ -61,10 +64,16 @@ export function readConfig(
  * from the current working directory.
  */
 export function findWranglerToml(
-	referencePath: string = process.cwd()
+	referencePath: string = process.cwd(),
+	preferJson = false
 ): string | undefined {
-	const configPath = findUpSync("wrangler.toml", { cwd: referencePath });
-	return configPath;
+	if (preferJson) {
+		return (
+			findUpSync(`wrangler.json`, { cwd: referencePath }) ??
+			findUpSync(`wrangler.toml`, { cwd: referencePath })
+		);
+	}
+	return findUpSync(`wrangler.toml`, { cwd: referencePath });
 }
 
 /**
@@ -316,18 +325,13 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 	logger.log(message);
 }
 
-type CamelCase<T> = {
-	[key in keyof T as key | CamelCaseKey<key>]: T[key];
-};
-
-export function withConfig<T extends { config?: string }>(
+export function withConfig<T>(
 	handler: (
-		t: Omit<CamelCase<T>, "config"> & { config: Config }
+		t: OnlyCamelCase<T & CommonYargsOptions> & { config: Config }
 	) => Promise<void>
 ) {
-	return (t: CamelCase<T>) => {
-		const { config: configPath, ...rest } = t;
-		return handler({ ...rest, config: readConfig(configPath, rest) });
+	return (t: OnlyCamelCase<T & CommonYargsOptions>) => {
+		return handler({ ...t, config: readConfig(t.config, t) });
 	};
 }
 

package/src/d1/backups.tsx

@@ -11,17 +11,18 @@ import { requireAuth } from "../user";
 import { formatBytes, formatTimeAgo } from "./formatTimeAgo";
 import { Name } from "./options";
 import { d1BetaWarning, getDatabaseByNameOrBinding } from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
 import type { Backup, Database } from "./types";
 import type { Response } from "undici";
-import type { Argv } from "yargs";
 
-type BackupListArgs = { config?: string; name: string };
-
-export function ListOptions(yargs: Argv): Argv<BackupListArgs> {
+export function ListOptions(yargs: CommonYargsArgv) {
 	return Name(yargs);
 }
-
-export const ListHandler = withConfig<BackupListArgs>(
+type ListHandlerOptions = StrictYargsOptionsToInterface<typeof ListOptions>;
+export const ListHandler = withConfig<ListHandlerOptions>(
 	async ({ config, name }): Promise<void> => {
 		const accountId = await requireAuth({});
 		logger.log(d1BetaWarning);
@@ -77,13 +78,12 @@ export const listBackups = async (
 	return Object.values(results);
 };
 
-type BackupCreateArgs = BackupListArgs;
-
-export function CreateOptions(yargs: Argv): Argv<BackupCreateArgs> {
+export function CreateOptions(yargs: CommonYargsArgv) {
 	return ListOptions(yargs);
 }
+type CreateHandlerOptions = StrictYargsOptionsToInterface<typeof CreateOptions>;
 
-export const CreateHandler = withConfig<BackupCreateArgs>(
+export const CreateHandler = withConfig<CreateHandlerOptions>(
 	async ({ config, name }): Promise<void> => {
 		const accountId = await requireAuth({});
 		logger.log(d1BetaWarning);
@@ -119,19 +119,17 @@ export const createBackup = async (
 	};
 };
 
-type BackupRestoreArgs = BackupListArgs & {
-	"backup-id": string;
-};
-
-export function RestoreOptions(yargs: Argv): Argv<BackupRestoreArgs> {
+export function RestoreOptions(yargs: CommonYargsArgv) {
 	return ListOptions(yargs).positional("backup-id", {
 		describe: "The Backup ID to restore",
 		type: "string",
 		demandOption: true,
 	});
 }
-
-export const RestoreHandler = withConfig<BackupRestoreArgs>(
+type RestoreHandlerOptions = StrictYargsOptionsToInterface<
+	typeof RestoreOptions
+>;
+export const RestoreHandler = withConfig<RestoreHandlerOptions>(
 	async ({ config, name, backupId }): Promise<void> => {
 		const accountId = await requireAuth({});
 		logger.log(d1BetaWarning);
@@ -163,11 +161,7 @@ export const restoreBackup = async (
 	);
 };
 
-type BackupDownloadArgs = BackupRestoreArgs & {
-	output?: string;
-};
-
-export function DownloadOptions(yargs: Argv): Argv<BackupDownloadArgs> {
+export function DownloadOptions(yargs: CommonYargsArgv) {
 	return ListOptions(yargs)
 		.positional("backup-id", {
 			describe: "The Backup ID to download",
@@ -180,8 +174,10 @@ export function DownloadOptions(yargs: Argv): Argv<BackupDownloadArgs> {
 			type: "string",
 		});
 }
-
-export const DownloadHandler = withConfig<BackupDownloadArgs>(
+type DownloadHandlerOptions = StrictYargsOptionsToInterface<
+	typeof DownloadOptions
+>;
+export const DownloadHandler = withConfig<DownloadHandlerOptions>(
 	async ({ name, backupId, output, config }): Promise<void> => {
 		const accountId = await requireAuth({});
 		logger.log(d1BetaWarning);