wrangler 0.0.0-e043479 → 0.0.0-e0621809

package/src/api/pages/publish.tsx

@@ -0,0 +1,355 @@
+import { existsSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { 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 { createUploadWorkerBundleContents } from "./create-worker-bundle-contents";
+import type { BundleResult } from "../../bundle";
+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;
+	}
+
+	const deploymentConfig =
+		project.deployment_configs[isProduction ? "production" : "preview"];
+	const nodejsCompat =
+		deploymentConfig.compatibility_flags?.includes("nodejs_compat");
+
+	/**
+	 * 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;
+	let workerBundle: BundleResult | 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 outputConfigPath = join(
+			tmpdir(),
+			`functions-filepath-routing-config-${Math.random()}.json`
+		);
+
+		try {
+			workerBundle = await buildFunctions({
+				outputConfigPath,
+				functionsDirectory,
+				onEnd: () => {},
+				buildOutputDirectory: directory,
+				routesOutputPath,
+				local: false,
+				d1Databases,
+				nodejsCompat,
+			});
+
+			builtFunctions = readFileSync(
+				workerBundle.resolvedEntryPointPath,
+				"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) {
+		if (bundle) {
+			const outfile = join(tmpdir(), `./bundledWorker-${Math.random()}.mjs`);
+			workerBundle = await buildRawWorker({
+				workerScriptPath,
+				outfile,
+				directory: directory ?? ".",
+				local: false,
+				sourcemap: true,
+				watch: false,
+				onEnd: () => {},
+				betaD1Shims: d1Databases,
+				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
+			workerBundle = {
+				modules: [],
+				dependencies: {},
+				stop: undefined,
+				resolvedEntryPointPath: workerScriptPath,
+				bundleType: "esm",
+			};
+		}
+
+		const workerBundleContents = await createUploadWorkerBundleContents(
+			workerBundle as BundleResult
+		);
+
+		formData.append(
+			"_worker.bundle",
+			new File([workerBundleContents], "_worker.bundle")
+		);
+		logger.log(`✨ Uploading Worker bundle`);
+
+		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) {
+		const workerBundleContents = await createUploadWorkerBundleContents(
+			workerBundle as BundleResult
+		);
+
+		formData.append(
+			"_worker.bundle",
+			new File([workerBundleContents], "_worker.bundle")
+		);
+		logger.log(`✨ Uploading Functions bundle`);
+
+		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-reporter.ts

@@ -0,0 +1,68 @@
+import { Blob } from "node:buffer";
+import { gzipSync } from "node:zlib";
+import { logger } from "./logger";
+import type { CfModule } from "./worker";
+import type { Metafile } from "esbuild";
+
+const ONE_KIB_BYTES = 1024;
+const ONE_MIB_BYTES = ONE_KIB_BYTES * 1024;
+
+async function getSize(modules: CfModule[]) {
+	const gzipSize = gzipSync(
+		await new Blob(modules.map((file) => file.content)).arrayBuffer()
+	).byteLength;
+	const aggregateSize = new Blob(modules.map((file) => file.content)).size;
+
+	return { size: aggregateSize, gzipSize };
+}
+
+export async function printBundleSize(
+	main: {
+		name: string;
+		content: string;
+	},
+	modules: CfModule[]
+) {
+	const { size, gzipSize } = await getSize([...modules, main]);
+
+	const bundleReport = `${(size / ONE_KIB_BYTES).toFixed(2)} KiB / gzip: ${(
+		gzipSize / ONE_KIB_BYTES
+	).toFixed(2)} KiB`;
+
+	logger.log(`Total Upload: ${bundleReport}`);
+
+	if (gzipSize > ONE_MIB_BYTES && !process.env.NO_SCRIPT_SIZE_WARNING) {
+		logger.warn(
+			"We recommend keeping your script less than 1MiB (1024 KiB) after gzip. Exceeding past this can affect cold start time"
+		);
+	}
+}
+
+export function printOffendingDependencies(
+	dependencies: Metafile["outputs"][string]["inputs"]
+) {
+	const warning: string[] = [];
+
+	const dependenciesSorted = Object.entries(dependencies);
+	dependenciesSorted.sort(
+		([_adep, aData], [_bdep, bData]) =>
+			bData.bytesInOutput - aData.bytesInOutput
+	);
+	const topLargest = dependenciesSorted.slice(0, 5);
+
+	if (topLargest.length > 0) {
+		warning.push(
+			`Here are the ${topLargest.length} largest dependencies included in your script:`
+		);
+
+		for (const [dep, data] of topLargest) {
+			warning.push(
+				`- ${dep} - ${(data.bytesInOutput / ONE_KIB_BYTES).toFixed(2)} KiB`
+			);
+		}
+
+		warning.push("If these are unnecessary, consider removing them");
+
+		logger.warn(warning.join("\n"));
+	}
+}