wrangler 0.0.0-e7a0cd5b → 0.0.0-e7c7235fd

package/src/entry.ts

@@ -1,329 +0,0 @@
-import assert from "node:assert";
-import { existsSync, statSync } from "node:fs";
-import path from "node:path";
-import * as esbuild from "esbuild";
-import { execaCommand } from "execa";
-import { logger } from "./logger";
-import { getBasePath } from "./paths";
-import type { Config } from "./config";
-import type { CfScriptFormat } from "./worker";
-import type { Metafile } from "esbuild";
-
-/**
- * An entry point for the Worker.
- *
- * It consists not just of a `file`, but also of a `directory` that is used to resolve relative paths.
- */
-export type Entry = { file: string; directory: string; format: CfScriptFormat };
-
-/**
- * Compute the entry-point for the Worker.
- */
-export async function getEntry(
-	args: {
-		script?: string;
-		format?: CfScriptFormat | undefined;
-		assets?: string | undefined;
-	},
-	config: Config,
-	command: "dev" | "publish" | "types"
-): Promise<Entry> {
-	let file: string;
-	let directory = process.cwd();
-	if (args.script) {
-		// If the script name comes from the command line it is relative to the current working directory.
-		file = path.resolve(args.script);
-	} else if (config.main === undefined) {
-		if (config.site?.["entry-point"]) {
-			directory = path.resolve(path.dirname(config.configPath ?? "."));
-			file = path.extname(config.site?.["entry-point"])
-				? path.resolve(config.site?.["entry-point"])
-				: // site.entry-point could be a directory
-				  path.resolve(config.site?.["entry-point"], "index.js");
-		} else if (args.assets || config.assets) {
-			file = path.resolve(getBasePath(), "templates/no-op-worker.js");
-		} else {
-			throw new Error(
-				`Missing entry-point: The entry-point should be specified via the command line (e.g. \`wrangler ${command} path/to/script\`) or the \`main\` config field.`
-			);
-		}
-	} else {
-		directory = path.resolve(path.dirname(config.configPath ?? "."));
-		file = path.resolve(directory, config.main);
-	}
-
-	const relativeFile = path.relative(directory, file) || ".";
-	await runCustomBuild(file, relativeFile, config.build);
-
-	if (fileExists(file) === false) {
-		throw new Error(
-			getMissingEntryPointMessage(
-				`The entry-point file at "${relativeFile}" was not found.`,
-				file,
-				relativeFile
-			)
-		);
-	}
-	const format = await guessWorkerFormat(
-		file,
-		directory,
-		args.format ?? config.build?.upload?.format,
-		config.tsconfig
-	);
-
-	const { localBindings, remoteBindings } =
-		partitionDurableObjectBindings(config);
-
-	if (command === "dev" && remoteBindings.length > 0) {
-		logger.warn(
-			"WARNING: You have Durable Object bindings that are not defined locally in the worker being developed.\n" +
-				"Be aware that changes to the data stored in these Durable Objects will be permanent and affect the live instances.\n" +
-				"Remote Durable Objects that are affected:\n" +
-				remoteBindings.map((b) => `- ${JSON.stringify(b)}`).join("\n")
-		);
-	}
-
-	if (format === "service-worker" && localBindings.length > 0) {
-		const errorMessage =
-			"You seem to be trying to use Durable Objects in a Worker written as a service-worker.";
-		const addScriptName =
-			"You can use Durable Objects defined in other Workers by specifying a `script_name` in your wrangler.toml, where `script_name` is the name of the Worker that implements that Durable Object. For example:";
-		const addScriptNameExamples = generateAddScriptNameExamples(localBindings);
-		const migrateText =
-			"Alternatively, migrate your worker to ES Module syntax to implement a Durable Object in this Worker:";
-		const migrateUrl =
-			"https://developers.cloudflare.com/workers/learning/migrating-to-module-workers/";
-		throw new Error(
-			`${errorMessage}\n${addScriptName}\n${addScriptNameExamples}\n${migrateText}\n${migrateUrl}`
-		);
-	}
-
-	return { file, directory, format };
-}
-
-export async function runCustomBuild(
-	expectedEntryAbsolute: string,
-	expectedEntryRelative: string,
-	build: Config["build"]
-) {
-	if (build?.command) {
-		// TODO: add a deprecation message here?
-		logger.log("Running custom build:", build.command);
-		await execaCommand(build.command, {
-			shell: true,
-			// we keep these two as "inherit" so that
-			// logs are still visible.
-			stdout: "inherit",
-			stderr: "inherit",
-			...(build.cwd && { cwd: build.cwd }),
-		});
-
-		if (fileExists(expectedEntryAbsolute) === false) {
-			throw new Error(
-				getMissingEntryPointMessage(
-					`The expected output file at "${expectedEntryRelative}" was not found after running custom build: ${build.command}.\n` +
-						"The `main` property in wrangler.toml should point to the file generated by the custom build.",
-					expectedEntryAbsolute,
-					expectedEntryRelative
-				)
-			);
-		}
-	}
-}
-
-/**
- * A function to "guess" the type of worker.
- * We do this by running a lightweight build of the actual script,
- * and looking at the metafile generated by esbuild. If it has a default
- * export (or really, any exports), that means it's a "modules" worker.
- * Else, it's a "service-worker" worker. This seems hacky, but works remarkably
- * well in practice.
- */
-export default async function guessWorkerFormat(
-	entryFile: string,
-	entryWorkingDirectory: string,
-	hint: CfScriptFormat | undefined,
-	tsconfig?: string | undefined
-): Promise<CfScriptFormat> {
-	const result = await esbuild.build({
-		entryPoints: [entryFile],
-		absWorkingDir: entryWorkingDirectory,
-		metafile: true,
-		bundle: false,
-		format: "esm",
-		target: "es2020",
-		write: false,
-		loader: {
-			".js": "jsx",
-			".mjs": "jsx",
-			".cjs": "jsx",
-		},
-		...(tsconfig && { tsconfig }),
-	});
-	// result.metafile is defined because of the `metafile: true` option above.
-	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-	const metafile = result.metafile!;
-	const entryPoints = Object.entries(metafile.outputs).filter(
-		([_path, output]) => output.entryPoint !== undefined
-	);
-	assert(
-		entryPoints.length > 0,
-		`Cannot find entry-point "${entryFile}" in generated bundle.` +
-			listEntryPoints(entryPoints)
-	);
-	assert(
-		entryPoints.length < 2,
-		"More than one entry-point found for generated bundle." +
-			listEntryPoints(entryPoints)
-	);
-
-	let guessedWorkerFormat: CfScriptFormat;
-	const scriptExports = entryPoints[0][1].exports;
-	if (scriptExports.length > 0) {
-		if (scriptExports.includes("default")) {
-			guessedWorkerFormat = "modules";
-		} else {
-			logger.warn(
-				`The entrypoint ${path.relative(
-					process.cwd(),
-					entryFile
-				)} has exports like an ES Module, but hasn't defined a default export like a module worker normally would. Building the worker using "service-worker" format...`
-			);
-			guessedWorkerFormat = "service-worker";
-		}
-	} else {
-		guessedWorkerFormat = "service-worker";
-	}
-
-	if (hint) {
-		if (hint !== guessedWorkerFormat) {
-			if (hint === "service-worker") {
-				throw new Error(
-					"You configured this worker to be a 'service-worker', but the file you are trying to build appears to have a `default` export like a module worker. Please pass `--format modules`, or simply remove the configuration."
-				);
-			} else {
-				throw new Error(
-					"You configured this worker to be 'modules', but the file you are trying to build doesn't export a handler. Please pass `--format service-worker`, or simply remove the configuration."
-				);
-			}
-		}
-	}
-	return guessedWorkerFormat;
-}
-
-function listEntryPoints(
-	outputs: [string, ValueOf<Metafile["outputs"]>][]
-): string {
-	return outputs.map(([_input, output]) => output.entryPoint).join("\n");
-}
-
-type ValueOf<T> = T[keyof T];
-
-/**
- * Returns true if the given `filePath` exists as-is,
- * or if some version of it (by appending a common extension) exists.
- */
-export function fileExists(filePath: string): boolean {
-	if (path.extname(filePath) !== "") {
-		return existsSync(filePath);
-	}
-	const base = path.join(path.dirname(filePath), path.basename(filePath));
-	for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
-		if (existsSync(base + ext)) {
-			return true;
-		}
-	}
-	return false;
-}
-
-type DurableObjectBindings = Config["durable_objects"]["bindings"];
-
-/**
- * Groups the durable object bindings into two lists:
- * those that are defined locally and those that refer to a durable object defined in another script.
- */
-function partitionDurableObjectBindings(config: Config): {
-	localBindings: DurableObjectBindings;
-	remoteBindings: DurableObjectBindings;
-} {
-	const localBindings: DurableObjectBindings = [];
-	const remoteBindings: DurableObjectBindings = [];
-	for (const binding of config.durable_objects.bindings) {
-		if (binding.script_name === undefined) {
-			localBindings.push(binding);
-		} else {
-			remoteBindings.push(binding);
-		}
-	}
-	return { localBindings, remoteBindings };
-}
-
-/**
- * Generates some help text based on the Durable Object bindings in a given
- * config indicating how the user can add a `script_name` field to bind an
- * externally defined Durable Object.
- */
-function generateAddScriptNameExamples(
-	localBindings: DurableObjectBindings
-): string {
-	function exampleScriptName(binding_name: string): string {
-		return `${binding_name.toLowerCase().replaceAll("_", "-")}-worker`;
-	}
-
-	return localBindings
-		.map(({ name, class_name }) => {
-			const script_name = exampleScriptName(name);
-			const currentBinding = `{ name = ${name}, class_name = ${class_name} }`;
-			const fixedBinding = `{ name = ${name}, class_name = ${class_name}, script_name = ${script_name} }`;
-
-			return `${currentBinding} ==> ${fixedBinding}`;
-		})
-		.join("\n");
-}
-
-/**
- * Generate an appropriate message for when the entry-point is missing.
- *
- * To be more helpful to developers, we check whether there is a suitable file
- * nearby to the expected file path.
- */
-function getMissingEntryPointMessage(
-	message: string,
-	absoluteEntryPointPath: string,
-	relativeEntryPointPath: string
-): string {
-	if (
-		existsSync(absoluteEntryPointPath) &&
-		statSync(absoluteEntryPointPath).isDirectory()
-	) {
-		// The expected entry-point is a directory, so offer further guidance.
-		message += `\nThe provided entry-point path, "${relativeEntryPointPath}", points to a directory, rather than a file.\n`;
-
-		// Perhaps we can even guess what the correct path should be...
-		const possiblePaths: string[] = [];
-		for (const basenamePath of [
-			"worker",
-			"dist/worker",
-			"index",
-			"dist/index",
-		]) {
-			for (const extension of [".ts", ".tsx", ".js", ".jsx"]) {
-				const filePath = basenamePath + extension;
-				if (fileExists(path.resolve(absoluteEntryPointPath, filePath))) {
-					possiblePaths.push(path.join(relativeEntryPointPath, filePath));
-				}
-			}
-		}
-
-		if (possiblePaths.length > 0) {
-			message +=
-				`\nDid you mean to set the main field to${
-					possiblePaths.length > 1 ? " one of" : ""
-				}:\n` +
-				"```\n" +
-				possiblePaths.map((filePath) => `main = "./${filePath}"\n`).join("") +
-				"```";
-		}
-	}
-	return message;
-}

package/src/environment-variables.ts

@@ -1,50 +0,0 @@
-import { logger } from "./logger";
-
-type VariableNames =
-	| "CLOUDFLARE_ACCOUNT_ID"
-	| "CLOUDFLARE_API_TOKEN"
-	| "CLOUDFLARE_API_KEY"
-	| "CLOUDFLARE_EMAIL"
-	| "WRANGLER_SEND_METRICS"
-	| "CLOUDFLARE_API_BASE_URL"
-	| "WRANGLER_LOG";
-
-type DeprecatedNames =
-	| "CF_ACCOUNT_ID"
-	| "CF_API_TOKEN"
-	| "CF_API_KEY"
-	| "CF_EMAIL"
-	| "CF_API_BASE_URL";
-/**
- * Create a function used to access an environment variable.
- *
- * This is not memoized to allow us to change the value at runtime, such as in testing.
- * A warning is shown if the client is using a deprecated version - but only once.
- */
-export function getEnvironmentVariableFactory({
-	variableName,
-	deprecatedName,
-	defaultValue,
-}: {
-	variableName: VariableNames;
-	deprecatedName?: DeprecatedNames;
-	defaultValue?: string;
-}) {
-	let hasWarned = false;
-	return () => {
-		if (process.env[variableName]) {
-			return process.env[variableName];
-		} else if (deprecatedName && process.env[deprecatedName]) {
-			if (!hasWarned) {
-				// Only show the warning once.
-				hasWarned = true;
-				logger.warn(
-					`Using "${deprecatedName}" environment variable. This is deprecated. Please use "${variableName}", instead.`
-				);
-			}
-			return process.env[deprecatedName];
-		} else {
-			return defaultValue;
-		}
-	};
-}

package/src/errors.ts

@@ -1,11 +0,0 @@
-export class DeprecationError extends Error {
-	constructor(message: string) {
-		super(`Deprecation:\n${message}`);
-	}
-}
-
-export class FatalError extends Error {
-	constructor(message?: string, readonly code?: number) {
-		super(message);
-	}
-}

package/src/git-client.ts

@@ -1,124 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { execa } from "execa";
-import { findUp } from "find-up";
-import semiver from "semiver";
-
-/**
- * Check whether the given current working directory is within a git repository
- * by looking for a `.git` directory in this or an ancestor directory.
- */
-export async function isInsideGitRepo(cwd: string) {
-	const res = await findUp(".git", { cwd, type: "directory" });
-	return res !== undefined;
-}
-
-/**
- * Check whether git is installed by trying to run it.
- *
- * @returns a `string` containing the version of git that's installed, or `null` if git isn't installed
- */
-export async function getGitVersioon(): Promise<string | null> {
-	try {
-		const gitVersionExecutionResult = await execa("git", ["--version"]);
-		if (gitVersionExecutionResult.exitCode !== 0) {
-			return null;
-		}
-
-		const [gitVersion] =
-			/\d+.\d+.\d+/.exec(gitVersionExecutionResult.stdout) || [];
-		return gitVersion;
-	} catch (err) {
-		return null;
-	}
-}
-
-/**
- * Initialize a new Worker project with a git repository.
- *
- * We want the branch to be called `main` but earlier versions of git do not support `--initial-branch`.
- * If that is the case then we just fallback to the default initial branch name.
- */
-export async function initializeGit(cwd: string) {
-	try {
-		// Try to create the repository with the HEAD branch of `main`.
-		await execa("git", ["init", "--initial-branch", "main"], {
-			cwd,
-		});
-	} catch {
-		// Unable to create the repo with a HEAD branch name, so just fall back to the default.
-		await execa("git", ["init"], {
-			cwd,
-		});
-	}
-}
-
-/**
- * Clone a repository into a given directory, optionally applying a given filter for a sparse checkout.
- * Note: this does NOT initialize a git repository, that must be done separately.
- *
- * @param remote the remote repository to clone
- * @param targetDirectory the directory to clone into
- * @param subdirectory optional, clone a subdirectory instead of the whole repo
- */
-export async function cloneIntoDirectory(
-	remote: string,
-	targetDirectory: string,
-	subdirectory?: string
-) {
-	const args = ["clone", "--depth", "1"];
-
-	const gitVersion = await getGitVersioon();
-	if (!gitVersion) {
-		throw new Error("Failed to find git installation");
-	}
-
-	// sparse checkouts were added in git 2.26.0, and allow for...sparse...checkouts...
-	// basically it means you can checkout only certain files/folders/etc. instead of
-	// the whole repo. useful for monorepos that may, for example,
-	// contain multiple wrangler templates
-	const useSparseCheckout = subdirectory && semiver(gitVersion, "2.26.0") > -1;
-	if (useSparseCheckout) {
-		args.push("--filter=blob:none", "--sparse");
-	}
-
-	const tagIndex = remote.lastIndexOf("#");
-	if (tagIndex === -1) {
-		args.push(remote);
-	} else {
-		args.push("-b", remote.substring(tagIndex + 1));
-		args.push(remote.substring(0, tagIndex));
-	}
-
-	// we first clone into a temporary directory so that if something goes wrong,
-	// the user's filesystem isn't left in a messed-up state
-	const tempDir = fs.mkdtempSync(
-		path.join(os.tmpdir(), `wrangler-generate-repo-`)
-	);
-	args.push(tempDir);
-
-	await execa("git", args);
-
-	// if we can use sparse checkout, run it now.
-	// otherwise, the entire repo was cloned anyway, so skip this step
-	if (useSparseCheckout) {
-		await execa("git", [`sparse-checkout`, `set`, subdirectory], {
-			cwd: tempDir,
-		});
-	}
-
-	const templatePath =
-		subdirectory !== undefined ? path.join(tempDir, subdirectory) : tempDir;
-
-	// cleanup: move the template to the target directory and delete `.git`
-	try {
-		fs.renameSync(templatePath, targetDirectory);
-	} catch {
-		throw new Error(`Failed to find "${subdirectory}" in ${remote}`);
-	}
-	fs.rmSync(path.join(targetDirectory, ".git"), {
-		recursive: true,
-		force: true,
-	});
-}

package/src/global-wrangler-config-path.ts

@@ -1,26 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import xdgAppPaths from "xdg-app-paths";
-
-function isDirectory(configPath: string) {
-	try {
-		return fs.statSync(configPath).isDirectory();
-	} catch (error) {
-		// ignore error
-		return false;
-	}
-}
-
-export function getGlobalWranglerConfigPath() {
-	//TODO: We should implement a custom path --global-config and/or the WRANGLER_HOME type environment variable
-	const configDir = xdgAppPaths(".wrangler").config(); // New XDG compliant config path
-	const legacyConfigDir = path.join(os.homedir(), ".wrangler"); // Legacy config in user's home directory
-
-	// Check for the .wrangler directory in root if it is not there then use the XDG compliant path.
-	if (isDirectory(legacyConfigDir)) {
-		return legacyConfigDir;
-	} else {
-		return configDir;
-	}
-}

package/src/https-options.ts

@@ -1,127 +0,0 @@
-import * as fs from "node:fs";
-import os from "node:os";
-import * as path from "node:path";
-import { promisify } from "node:util";
-import { getGlobalWranglerConfigPath } from "./global-wrangler-config-path";
-import { logger } from "./logger";
-import type { Attributes, Options } from "selfsigned";
-
-// Most of this file has been borrowed from the implementation in Miniflare.
-// See https://github.com/cloudflare/miniflare/blob/870b401ef5/packages/http-server/src/plugin.ts#L313-L397
-// Thanks @mrbbot.
-const CERT_EXPIRY_DAYS = 30;
-const ONE_DAY_IN_MS = 86400000;
-
-/**
- * Get the options (i.e. SSL certificates) for running an HTTPS server.
- *
- * The certificates are self-signed and generated locally, and cached in the `CERT_ROOT` directory.
- */
-export async function getHttpsOptions() {
-	const certDirectory = path.join(getGlobalWranglerConfigPath(), "local-cert");
-	const keyPath = path.join(certDirectory, "key.pem");
-	const certPath = path.join(certDirectory, "cert.pem");
-
-	const regenerate =
-		!fs.existsSync(keyPath) ||
-		!fs.existsSync(certPath) ||
-		hasCertificateExpired(keyPath, certPath);
-
-	if (regenerate) {
-		logger.log("Generating new self-signed certificate...");
-		const { key, cert } = await generateCertificate();
-		try {
-			// Write certificate files so we can reuse them later.
-			fs.mkdirSync(certDirectory, { recursive: true });
-			fs.writeFileSync(keyPath, key, "utf8");
-			fs.writeFileSync(certPath, cert, "utf8");
-		} catch (e) {
-			const message = e instanceof Error ? e.message : `${e}`;
-			logger.warn(
-				`Unable to cache generated self-signed certificate in ${path.relative(
-					process.cwd(),
-					certDirectory
-				)}.\n${message}`
-			);
-		}
-		return { key, cert };
-	} else {
-		return {
-			key: fs.readFileSync(keyPath, "utf8"),
-			cert: fs.readFileSync(certPath, "utf8"),
-		};
-	}
-}
-
-/**
- * Determine if the certificate defined in `keyPath` and `certPath` files
- * have expired based on the date when they were last modified.
- */
-function hasCertificateExpired(keyPath: string, certPath: string): boolean {
-	const keyStat = fs.statSync(keyPath);
-	const certStat = fs.statSync(certPath);
-	const created = Math.max(keyStat.mtimeMs, certStat.mtimeMs);
-	return Date.now() - created > (CERT_EXPIRY_DAYS - 2) * ONE_DAY_IN_MS;
-}
-
-/**
- * Generate a new self-signed certificate and cache it in `CERT_ROOT` directory.
- */
-async function generateCertificate() {
-	// `selfsigned` imports `node-forge`, which is a pretty big library.
-	// To reduce startup time, only load this dynamically when needed.
-	// eslint-disable-next-line @typescript-eslint/consistent-type-imports
-	const generate: typeof import("selfsigned").generate = promisify(
-		// eslint-disable-next-line @typescript-eslint/no-var-requires
-		require("selfsigned").generate
-	);
-
-	const certAttrs: Attributes = [{ name: "commonName", value: "localhost" }];
-
-	const certOptions: Options = {
-		algorithm: "sha256",
-		days: CERT_EXPIRY_DAYS,
-		keySize: 2048,
-		extensions: [
-			{ name: "basicConstraints", cA: true },
-			{
-				name: "keyUsage",
-				keyCertSign: true,
-				digitalSignature: true,
-				nonRepudiation: true,
-				keyEncipherment: true,
-				dataEncipherment: true,
-			},
-			{
-				name: "extKeyUsage",
-				serverAuth: true,
-				clientAuth: true,
-				codeSigning: true,
-				timeStamping: true,
-			},
-			{
-				name: "subjectAltName",
-				altNames: [
-					{ type: 2, value: "localhost" },
-					...getAccessibleHosts().map((ip) => ({ type: 7, ip })),
-				],
-			},
-		],
-	};
-
-	const { private: key, cert } = await generate(certAttrs, certOptions);
-	return { key, cert };
-}
-
-/**
- * Ask the OS for the addresses of locally accessible hosts.
- */
-function getAccessibleHosts(ipv4 = false): string[] {
-	const hosts: string[] = [];
-	Object.values(os.networkInterfaces()).forEach((net) =>
-		net?.forEach(({ family, address }) => {
-			if (!ipv4 || family === "IPv4") hosts.push(address);
-		})
-	);
-	return hosts;
-}