wrangler 0.0.0-e464fcdb → 0.0.0-e4716cc87

package/src/generate/index.ts

@@ -1,298 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { cloneIntoDirectory, initializeGit } from "../git-client";
-import { CommandLineArgsError, printWranglerBanner } from "../index";
-import { initHandler } from "../init";
-import { logger } from "../logger";
-import type {
-	CommonYargsArgv,
-	StrictYargsOptionsToInterface,
-} from "../yargs-types";
-
-export function generateOptions(yargs: CommonYargsArgv) {
-	return yargs
-		.positional("name", {
-			describe: "Name of the Workers project",
-			type: "string",
-			demandOption: true,
-		})
-		.positional("template", {
-			type: "string",
-			describe: "The URL of a GitHub template",
-		})
-		.option("type", {
-			alias: "t",
-			type: "string",
-			hidden: true,
-			deprecated: true,
-		})
-		.option("site", {
-			alias: "s",
-			type: "boolean",
-			hidden: true,
-			deprecated: true,
-		});
-}
-type GenerateArgs = StrictYargsOptionsToInterface<typeof generateOptions>;
-
-// Originally, generate was a rust function: https://github.com/cloudflare/wrangler-legacy/blob/master/src/cli/mod.rs#L106-L123
-export async function generateHandler(args: GenerateArgs) {
-	// somehow, `init` marks name as required but then also runs fine
-	// with the name omitted, and then substitutes it at runtime with ""
-	// delegate to `wrangler init` if no template is specified
-	if (args.template === undefined) {
-		return initHandler({
-			name: args.name,
-			site: undefined,
-			yes: undefined,
-			fromDash: undefined,
-			v: undefined,
-			config: undefined,
-			env: undefined,
-			type: undefined,
-			_: args._,
-			$0: args.$0,
-			experimentalJsonConfig: false,
-		});
-	}
-
-	// print down here cuz `init` prints it own its own
-	await printWranglerBanner();
-
-	if (args.type) {
-		let message = "The --type option is no longer supported.";
-		if (args.type === "webpack") {
-			message +=
-				"\nIf you wish to use webpack then you will need to create a custom build.";
-			// TODO: Add a link to docs
-		}
-		throw new CommandLineArgsError(message);
-	}
-
-	if (args.name && isRemote(args.name)) {
-		[args.template, args.name] = [args.name, args.template];
-	}
-
-	const creationDirectory = generateWorkerDirectoryName(args.name);
-
-	if (args.site) {
-		const gitDirectory =
-			creationDirectory !== process.cwd()
-				? path.basename(creationDirectory)
-				: "my-site";
-		const message =
-			"The --site option is no longer supported.\n" +
-			"If you wish to create a brand new Worker Sites project then clone the `worker-sites-template` starter repository:\n\n" +
-			"```\n" +
-			`git clone --depth=1 --branch=wrangler2 https://github.com/cloudflare/worker-sites-template ${gitDirectory}\n` +
-			`cd ${gitDirectory}\n` +
-			"```\n\n" +
-			"Find out more about how to create and maintain Sites projects at https://developers.cloudflare.com/workers/platform/sites.\n" +
-			"Have you considered using Cloudflare Pages instead? See https://pages.cloudflare.com/.";
-		throw new CommandLineArgsError(message);
-	}
-
-	logger.log(
-		`Creating a worker in ${path.basename(creationDirectory)} from ${
-			args.template
-		}`
-	);
-
-	const { remote, subdirectory } = parseTemplatePath(args.template);
-
-	await cloneIntoDirectory(remote, creationDirectory, subdirectory);
-	await initializeGit(creationDirectory);
-
-	logger.log("✨ Success!");
-}
-
-/**
- * Creates a path based on the current working directory and a worker name.
- * Automatically increments a counter when searching for an available directory.
- *
- * Running `wrangler generate worker https://some-git-repo` in a directory
- * with the structure:
- * ```
- * - workers
- * |
- * | - worker
- * | | - wrangler.toml
- * | | ...
- * |
- * | - worker-1
- * | | - wrangler.toml
- * | | ...
- * ```
- *
- * will result in a new worker called `worker-2` being generated.
- *
- * @param workerName the name of the generated worker
- * @returns an absolute path to the directory to generate the worker into
- */
-function generateWorkerDirectoryName(workerName: string): string {
-	let workerDirectoryPath = path.resolve(process.cwd(), workerName);
-	let i = 1;
-
-	while (fs.existsSync(workerDirectoryPath)) {
-		workerDirectoryPath = path.resolve(process.cwd(), `${workerName}-${i}`);
-		i++;
-	}
-
-	return workerDirectoryPath;
-}
-
-/**
- * Checks if an arg is a template, which can be useful if the order
- * of template & worker name args is switched
- *
- * @param arg a template to generate from, or a folder to generate into
- * @returns true if the given arg was remote (a template)
- */
-function isRemote(arg: string) {
-	return /^(https?|ftps?|file|git|ssh):\/\//.test(arg) || arg.includes(":");
-}
-
-/**
- * unreadable regex basically copied from degit. i put some named capture groups in,
- * but uhh...there's not much to do short of using pomsky or some other tool.
- *
- * notably: this only supports `https://` and `git@` urls,
- * and is missing support for:
- * - `http`
- * - `ftp(s)`
- * - `file`
- * - `ssh`
- */
-const TEMPLATE_REGEX =
-	/^(?:(?:https:\/\/)?(?<httpsUrl>[^:/]+\.[^:/]+)\/|git@(?<gitUrl>[^:/]+)[:/]|(?<shorthandUrl>[^/]+):)?(?<user>[^/\s]+)\/(?<repository>[^/\s#]+)(?:(?<subdirectoryPath>(?:\/[^/\s#]+)+))?(?:\/)?(?:#(?<tag>.+))?/;
-
-// there are a few URL formats we support:
-// - `user/repo` -> assume github, use "https://github.com/user/repo.git"
-// - `https://<httpsUrl>
-// - `git@<gitUrl>`
-// - `(bb|bitbucket|gh|github|gl|gitlab):user/repo` -> parse shorthand into https url
-
-/**
- * There's no URL, so assume a github repo
- */
-type NoUrl = {
-	httpsUrl: undefined;
-	gitUrl: undefined;
-	shorthandUrl: undefined;
-};
-
-/**
- * A https url (e.g. https://bitbucket.org/user/repo)
- */
-type HttpsUrl = Omit<NoUrl, "httpsUrl"> & { httpsUrl: string };
-
-/**
- * A git url (e.g. git@gitlab.com:user/repo)
- */
-type GitUrl = Omit<NoUrl, "gitUrl"> & { gitUrl: string };
-
-/**
- * A shorthand url (e.g. github:user/repo)
- */
-type ShorthandUrl = Omit<NoUrl, "shorthandUrl"> & { shorthandUrl: string };
-
-/**
- * Union of all possible URL groups. Exactly one will be present, the rest
- * will be `undefined`.
- */
-type TemplateRegexUrlGroup = NoUrl | HttpsUrl | GitUrl | ShorthandUrl;
-
-/**
- * Possible matches of `TEMPLATE_REGEX` against a passed-in template arg
- */
-type TemplateRegexGroups = {
-	/** The user the repo is under */
-	user: string;
-
-	/** The repo name */
-	repository: string;
-
-	/** Optional, path to subdirectory containing template. Begins with `/` */
-	subdirectoryPath?: string;
-
-	/** Optional tag (or branch, etc.) to clone */
-	tag?: string;
-} & TemplateRegexUrlGroup;
-
-/**
- * Parses a regex match on any of the URL groups into a URL base
- *
- * @param urlGroup a regex hit for a URL of any sort
- * @returns the protocol and domain name of the url to clone from
- */
-function toUrlBase({ httpsUrl, gitUrl, shorthandUrl }: TemplateRegexUrlGroup) {
-	if (httpsUrl !== undefined) {
-		return `https://${httpsUrl}`;
-	}
-
-	if (gitUrl !== undefined) {
-		return `git@${gitUrl}`;
-	}
-
-	if (shorthandUrl !== undefined) {
-		switch (shorthandUrl) {
-			case "github":
-			case "gh":
-				return "https://github.com";
-			case "gitlab":
-			case "gl":
-				return "https://gitlab.com";
-			case "bitbucket":
-			case "bb":
-				return "https://bitbucket.org";
-			default:
-				throw new Error(
-					`Unable to parse shorthand ${shorthandUrl}. Supported options are "bitbucket" ("bb"), "github" ("gh"), and "gitlab" ("gl")`
-				);
-		}
-	}
-
-	return "https://github.com";
-}
-
-/**
- * Parses a template string (e.g. "user/repo", "github:user/repo/path/to/subdirectory")
- * into a remote URL to clone from and an optional subdirectory to filter for
- *
- * @param templatePath the template string to parse
- * @returns an object containing the remote url and an optional subdirectory to clone
- */
-function parseTemplatePath(templatePath: string): {
-	remote: string;
-	subdirectory?: string;
-} {
-	if (!templatePath.includes("/")) {
-		// template is a cloudflare canonical template, it doesn't include a slash in the name
-		return {
-			remote: "https://github.com/cloudflare/workers-sdk.git",
-			subdirectory: `templates/${templatePath}`,
-		};
-	}
-
-	const groups = TEMPLATE_REGEX.exec(templatePath)?.groups as unknown as
-		| TemplateRegexGroups
-		| undefined;
-
-	if (!groups) {
-		throw new Error(`Unable to parse ${templatePath} as a template`);
-	}
-
-	const { user, repository, subdirectoryPath, tag, ...urlGroups } = groups;
-
-	const urlBase = toUrlBase(urlGroups);
-	const isHttp = urlBase.startsWith("http");
-
-	const remote = `${urlBase}${isHttp ? "/" : ":"}${user}/${repository}.git${
-		tag ? `#${tag}` : ""
-	}`;
-
-	// remove starting /
-	const subdirectory = subdirectoryPath?.slice(1);
-
-	return { remote, subdirectory };
-}

package/src/git-client.ts

@@ -1,135 +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 {
-		// Get the default init branch name
-		const { stdout: defaultBranchName } = await execa("git", [
-			"config",
-			"--get",
-			"init.defaultBranch",
-		]);
-
-		// Try to create the repository with the HEAD branch of defaultBranchName ?? `main`.
-		await execa(
-			"git",
-			["init", "--initial-branch", defaultBranchName.trim() ?? "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;
-}