fix: refactor Base options to (mostly) properly use Bingo Inputs (#1985)

<!-- 👋 Hi, thanks for sending a PR to create-typescript-app! 🎁.
Please fill out all fields below and make sure each item is true and [x]
checked.
Otherwise we may not be able to review your PR. -->

## PR Checklist

- [x] Addresses an existing open issue: fixes #1973
- [x] That issue was marked as [`status: accepting
prs`](https://github.com/JoshuaKGoldberg/create-typescript-app/issues?q=is%3Aopen+is%3Aissue+label%3A%22status%3A+accepting+prs%22)
- [x] Steps in
[CONTRIBUTING.md](https://github.com/JoshuaKGoldberg/create-typescript-app/blob/main/.github/CONTRIBUTING.md)
were taken

## Overview

Migrates the existing options over when possible. A couple are based on
external packages that aren't easy to stub out external dependencies
for. Those can be followup issues.

Now, `base.ts` generally contains a more consistent pattern with naming:

* `get*` are `lazyValue(async () => await read*(...))` functions for
each value
* `read*` are async functions that take in any number of `get*`s to
compute a value

Also removes an unused `logic` field while I'm here.

This is a `fix:` because it adds better handling for running without a
reliable internet connection:

* `npm whoami --offline` to stop a minute of internal retries
* `request: { retries: 0 }` on `inputFromOctkit` to stop its retries too

🎁

Author: JoshuaKGoldberg

src/base.test.ts

@@ -36,7 +36,6 @@ describe("base", () => {
 				href: "https://www.joshuakgoldberg.com/blog/contributing-to-a-create-typescript-app-repository",
 				title: "Contributing to a create-typescript-app Repository",
 			},
-			login: "Josh Goldberg ✨",
 			logo: {
 				alt: "Project logo: the TypeScript blue square with rounded corners, but a plus sign instead of 'TS'",
 				height: 128,

src/base.ts

@@ -1,29 +1,36 @@
 import { BaseOptionsFor, createBase } from "bingo-stratum";
-import { execaCommand } from "execa";
-import gitRemoteOriginUrl from "git-remote-origin-url";
-import gitUrlParse from "git-url-parse";
 import { inputFromFile } from "input-from-file";
 import { inputFromScript } from "input-from-script";
 import lazyValue from "lazy-value";
-import npmUser from "npm-user";
 import { z } from "zod";
 
-import { inputFromOctokit } from "./inputs/inputFromOctokit.js";
-import { getExistingLabels } from "./options/getExistingLabels.js";
-import { parseEmojiFromDescription } from "./options/parseEmojiFromDescription.js";
-import { parsePackageAuthor } from "./options/parsePackageAuthor.js";
 import { readAllContributors } from "./options/readAllContributors.js";
-import { readDefaultsFromReadme } from "./options/readDefaultsFromReadme.js";
+import { readAuthor } from "./options/readAuthor.js";
 import { readDescription } from "./options/readDescription.js";
 import { readDocumentation } from "./options/readDocumentation.js";
+import { readEmailFromCodeOfConduct } from "./options/readEmailFromCodeOfConduct.js";
+import { readEmailFromGit } from "./options/readEmailFromGit.js";
+import { readEmailFromNpm } from "./options/readEmailFromNpm.js";
 import { readEmails } from "./options/readEmails.js";
+import { readEmoji } from "./options/readEmoji.js";
+import { readExistingLabels } from "./options/readExistingLabels.js";
+import { readExplainer } from "./options/readExplainer.js";
 import { readFileSafe } from "./options/readFileSafe.js";
 import { readFunding } from "./options/readFunding.js";
+import { readGitDefaults } from "./options/readGitDefaults.js";
 import { readGuide } from "./options/readGuide.js";
+import { readLogo } from "./options/readLogo.js";
+import { readNode } from "./options/readNode.js";
+import { readNpmDefaults } from "./options/readNpmDefaults.js";
+import { readOwner } from "./options/readOwner.js";
+import { readPackageAuthor } from "./options/readPackageAuthor.js";
 import { readPackageData } from "./options/readPackageData.js";
+import { readPackageDataFull } from "./options/readPackageDataFull.js";
 import { readPnpm } from "./options/readPnpm.js";
-import { swallowError } from "./utils/swallowError.js";
-import { tryCatchLazyValueAsync } from "./utils/tryCatchLazyValueAsync.js";
+import { readRepository } from "./options/readRepository.js";
+import { readRulesetId } from "./options/readRulesetId.js";
+import { readTitle } from "./options/readTitle.js";
+import { readUsage } from "./options/readUsage.js";
 
 const zContributor = z.object({
 	avatar_url: z.string(),
@@ -69,6 +76,7 @@ export const base = createBase({
 					npm: z.string(),
 				}),
 			])
+			// TODO: Test this? Is it still working?
 			.transform((email) =>
 				typeof email === "string" ? { github: email, npm: email } : email,
 			)
@@ -159,131 +167,146 @@ export const base = createBase({
 			.describe("package version to publish as and store in `package.json`"),
 	},
 	prepare({ options, take }) {
-		const allContributors = lazyValue(async () => readAllContributors(take));
-		const documentation = lazyValue(async () => readDocumentation(take));
+		const getAllContributors = lazyValue(
+			async () => await readAllContributors(take),
+		);
 
-		const nvmrc = lazyValue(
+		const getAuthor = lazyValue(
 			async () =>
-				await take(inputFromFile, {
-					filePath: ".nvmrc",
-				}),
+				await readAuthor(getPackageAuthor, getNpmDefaults, options.owner),
 		);
 
-		const existingLabels = lazyValue(async () =>
-			getExistingLabels(take, await owner(), await repository()),
+		const getBin = lazyValue(async () => (await getPackageDataFull()).bin);
+
+		const getEmoji = lazyValue(async () => await readEmoji(getDescription));
+
+		const getDescription = lazyValue(
+			async () => await readDescription(getPackageDataFull, getReadme),
 		);
 
-		const githubCliUser = lazyValue(async () => {
-			return swallowError(
-				await take(inputFromScript, {
-					command: "gh config get user -h github.com",
-				}),
-			)?.stdout?.toString();
-		});
+		const getDocumentation = lazyValue(
+			async () => await readDocumentation(take),
+		);
+
+		const getEmail = lazyValue(
+			async () =>
+				await readEmails(
+					getEmailFromCodeOfConduct,
+					getEmailFromGit,
+					getEmailFromNpm,
+				),
+		);
 
-		const readme = lazyValue(async () => await readFileSafe("README.md", ""));
+		const getEmailFromCodeOfConduct = lazyValue(
+			async () => await readEmailFromCodeOfConduct(take),
+		);
 
-		const rulesetId = lazyValue(async () => {
-			const rulesets = (await take(inputFromOctokit, {
-				endpoint: "GET /repos/{owner}/{repo}/rulesets",
-				options: {
-					owner: await owner(),
-					repo: await repository(),
-				},
-			})) as undefined | { id: string; name: string }[];
+		const getEmailFromGit = lazyValue(async () => await readEmailFromGit(take));
 
-			return rulesets?.find(
-				(ruleset) => ruleset.name === "Branch protection for main",
-			)?.id;
-		});
+		const getEmailFromNpm = lazyValue(
+			async () => await readEmailFromNpm(getNpmDefaults, getPackageAuthor),
+		);
 
-		// TODO: Make these all use take
+		const getExistingLabels = lazyValue(
+			async () => await readExistingLabels(take, getOwner, getRepository),
+		);
 
-		const emoji = async () => parseEmojiFromDescription(description);
+		const getExplainer = lazyValue(async () => await readExplainer(getReadme));
 
-		const description = async () => await readDescription(packageData, readme);
+		const getFunding = lazyValue(async () => await readFunding(take));
 
-		const gitDefaults = tryCatchLazyValueAsync(async () =>
-			gitUrlParse(await gitRemoteOriginUrl()),
+		const getGitDefaults = lazyValue(async () => await readGitDefaults());
+
+		const getGuide = lazyValue(async () => await readGuide(take));
+
+		const getLogo = lazyValue(async () => await readLogo(getReadme));
+
+		const getPackageData = lazyValue(
+			async () => await readPackageData(getPackageDataFull),
 		);
 
-		const npmDefaults = tryCatchLazyValueAsync(async () => {
-			const whoami = (await execaCommand(`npm whoami`)).stdout;
-			return whoami ? await npmUser(whoami) : undefined;
-		});
+		const getPackageDataFull = lazyValue(
+			async () => await readPackageDataFull(take),
+		);
 
-		const packageData = lazyValue(readPackageData);
-		const packageAuthor = lazyValue(async () =>
-			parsePackageAuthor(await packageData()),
+		const getNode = lazyValue(
+			async () => await readNode(getNvmrc, getPackageDataFull),
 		);
 
-		const author = lazyValue(
+		const getNpmDefaults = lazyValue(
+			async () => await readNpmDefaults(getNpmWhoami),
+		);
+
+		const getNpmWhoami = lazyValue(
 			async () =>
-				(await packageAuthor()).author ??
-				(await npmDefaults())?.name ??
-				options.owner,
+				await take(inputFromScript, { command: "npm whoami --offline" }),
 		);
 
-		const node = lazyValue(async () => {
-			const { engines } = await packageData();
+		const getNvmrc = lazyValue(
+			async () =>
+				await take(inputFromFile, {
+					filePath: ".nvmrc",
+				}),
+		);
 
-			return {
-				minimum:
-					(engines?.node && /[\d+.]+/.exec(engines.node))?.[0] ?? "18.3.0",
-				pinned: swallowError(await nvmrc())?.trim() ?? "20.18.0",
-			};
-		});
+		const getOwner = lazyValue(
+			async () => await readOwner(take, getGitDefaults, getPackageAuthor),
+		);
 
-		const pnpm = lazyValue(async () => readPnpm(packageData));
+		const getPackageAuthor = lazyValue(
+			async () => await readPackageAuthor(getPackageDataFull),
+		);
 
-		const version = lazyValue(async () => (await packageData()).version);
+		const getPnpm = lazyValue(async () => await readPnpm(getPackageDataFull));
 
-		const owner = lazyValue(
-			async () =>
-				(await gitDefaults())?.organization ??
-				(await packageAuthor()).author ??
-				(await githubCliUser()),
+		const getReadme = lazyValue(
+			async () => await readFileSafe("README.md", ""),
 		);
 
-		const repository = lazyValue(
+		const getRepository = lazyValue(
 			async () =>
-				options.repository ??
-				(await gitDefaults())?.name ??
-				(await packageData()).name ??
-				options.directory,
+				await readRepository(getGitDefaults, getPackageDataFull, options),
+		);
+
+		const getRulesetId = lazyValue(
+			async () => await readRulesetId(take, getOwner, getRepository),
+		);
+
+		const getTitle = lazyValue(
+			async () => await readTitle(getReadme, getRepository),
+		);
+
+		const getUsage = lazyValue(
+			async () => await readUsage(getEmoji, getReadme, getRepository),
 		);
 
-		const email = lazyValue(async () => readEmails(npmDefaults, packageAuthor));
+		const getVersion = lazyValue(
+			async () => (await getPackageDataFull()).version,
+		);
 
 		return {
 			access: "public" as const,
-			author,
-			bin: async () => (await packageData()).bin,
-			contributors: allContributors,
-			description,
-			documentation,
-			email,
-			emoji,
-			existingLabels,
-			funding: readFunding,
-			guide: readGuide,
-			login: author,
-			node,
-			owner,
-			packageData: async () => {
-				const original = await packageData();
-
-				return {
-					dependencies: original.dependencies,
-					devDependencies: original.devDependencies,
-					scripts: original.scripts,
-				};
-			},
-			pnpm,
-			repository,
-			rulesetId,
-			...readDefaultsFromReadme(emoji, readme, repository),
-			version,
+			author: getAuthor,
+			bin: getBin,
+			contributors: getAllContributors,
+			description: getDescription,
+			documentation: getDocumentation,
+			email: getEmail,
+			emoji: getEmoji,
+			existingLabels: getExistingLabels,
+			explainer: getExplainer,
+			funding: getFunding,
+			guide: getGuide,
+			logo: getLogo,
+			node: getNode,
+			owner: getOwner,
+			packageData: getPackageData,
+			pnpm: getPnpm,
+			repository: getRepository,
+			rulesetId: getRulesetId,
+			title: getTitle,
+			usage: getUsage,
+			version: getVersion,
 		};
 	},
 });

src/constants.ts

@@ -0,0 +1,6 @@
+export const defaults = {
+	node: {
+		minimum: "18.3.0",
+		pinned: "20.18.0",
+	},
+};

src/inputs/inputFromOctokit.ts

@@ -15,6 +15,7 @@ export const inputFromOctokit = createInput({
 				headers: {
 					"X-GitHub-Api-Version": "2022-11-28",
 				},
+				request: { retries: 0 },
 				...args.options,
 			});
 

src/options/readAuthor.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { readAuthor } from "./readAuthor.js";
+
+describe(readAuthor, () => {
+	it("returns package author when it exists", async () => {
+		const author = "test-author";
+		const getNpmDefaults = vi.fn();
+
+		const actual = await readAuthor(
+			() => Promise.resolve({ author }),
+			getNpmDefaults,
+			undefined,
+		);
+
+		expect(actual).toBe(author);
+		expect(getNpmDefaults).not.toHaveBeenCalled();
+	});
+
+	it("returns npm defaults name when only it exists", async () => {
+		const name = "test-name";
+
+		const actual = await readAuthor(
+			() => Promise.resolve({}),
+			() => Promise.resolve({ name }),
+			undefined,
+		);
+
+		expect(actual).toBe(name);
+	});
+
+	it("returns owner when only it exists", async () => {
+		const owner = "test-owner";
+
+		const actual = await readAuthor(
+			() => Promise.resolve({}),
+			() => Promise.resolve(undefined),
+			owner,
+		);
+
+		expect(actual).toBe(owner);
+	});
+
+	it("returns undefined when no sources provide a value", async () => {
+		const actual = await readAuthor(
+			() => Promise.resolve({}),
+			() => Promise.resolve(undefined),
+			undefined,
+		);
+
+		expect(actual).toBeUndefined();
+	});
+});

src/options/readAuthor.ts

@@ -0,0 +1,9 @@
+export async function readAuthor(
+	getPackageAuthor: () => Promise<{ author?: string }>,
+	getNpmDefaults: () => Promise<undefined | { name?: string }>,
+	owner: string | undefined,
+) {
+	return (
+		(await getPackageAuthor()).author ?? (await getNpmDefaults())?.name ?? owner
+	);
+}