create-harper 0.0.2 → 0.0.3

package/README.md

@@ -78,3 +78,8 @@ Currently supported template presets include:
 - `qwik-ts`
 
 You can use `.` for the project name to scaffold in the current directory.
+
+## Shout Out
+
+This project is based largely on the prior work of the Vite team on Create Vite:
+https://github.com/vitejs/vite/tree/main/packages/create-vite

package/index.js

@@ -1,43 +1,31 @@
 #!/usr/bin/env node
 import * as prompts from '@clack/prompts';
 import { determineAgent } from '@vercel/detect-agent';
-import spawn from 'cross-spawn';
 import mri from 'mri';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { defaultTargetDir } from './lib/constants/defaultTargetDir.js';
-import { FRAMEWORKS } from './lib/constants/frameworks.js';
 import { helpMessage } from './lib/constants/helpMessage.js';
-import { TEMPLATES } from './lib/constants/templates.js';
-import { crawlTemplateDir } from './lib/fs/crawlTemplateDir.js';
-import { emptyDir } from './lib/fs/emptyDir.js';
 import { formatTargetDir } from './lib/fs/formatTargetDir.js';
-import { isEmpty } from './lib/fs/isEmpty.js';
-import { install } from './lib/install.js';
-import { getFullCustomCommand } from './lib/pkg/getFullCustomCommand.js';
-import { getInstallCommand } from './lib/pkg/getInstallCommand.js';
-import { getRunCommand } from './lib/pkg/getRunCommand.js';
-import { isValidPackageName } from './lib/pkg/isValidPackageName.js';
 import { pkgFromUserAgent } from './lib/pkg/pkgFromUserAgent.js';
-import { toValidPackageName } from './lib/pkg/toValidPackageName.js';
-import { start } from './lib/start.js';
+import { getEnvVars } from './lib/steps/getEnvVars.js';
+import { getImmediate } from './lib/steps/getImmediate.js';
+import { getPackageName } from './lib/steps/getPackageName.js';
+import { getProjectName } from './lib/steps/getProjectName.js';
+import { getTemplate } from './lib/steps/getTemplate.js';
+import { handleExistingDir } from './lib/steps/handleExistingDir.js';
+import { scaffoldProject } from './lib/steps/scaffoldProject.js';
+import { showOutro } from './lib/steps/showOutro.js';
 
 const argv = mri(process.argv.slice(2), {
 	boolean: ['help', 'overwrite', 'immediate', 'interactive'],
 	alias: { h: 'help', t: 'template', i: 'immediate' },
-	string: ['template'],
+	string: ['template', 'cli-target-username', 'cli-target'],
 });
-const cwd = process.cwd();
 
 init().catch((e) => {
 	console.error(e);
 });
 
 async function init() {
-	const argTargetDir = argv._[0]
-		? formatTargetDir(String(argv._[0]))
-		: undefined;
+	const argTargetDir = argv._[0] ? formatTargetDir(String(argv._[0])) : undefined;
 	const argTemplate = argv.template;
 	const argOverwrite = argv.overwrite;
 	const argImmediate = argv.immediate;
@@ -59,207 +47,42 @@ async function init() {
 		);
 	}
 
-	const pkgInfo = pkgFromUserAgent(process.env.npm_config_user_agent);
 	const cancel = () => prompts.cancel('Operation cancelled');
 
-	// 1. Get project name and target dir
-	let targetDir = argTargetDir;
-	let projectName = targetDir;
-	if (!targetDir) {
-		if (interactive) {
-			projectName = await prompts.text({
-				message: 'Project name:',
-				defaultValue: defaultTargetDir,
-				placeholder: defaultTargetDir,
-				validate: (value) => {
-					return !value || formatTargetDir(value).length > 0
-						? undefined
-						: 'Invalid project name';
-				},
-			});
-			if (prompts.isCancel(projectName)) { return cancel(); }
-			targetDir = formatTargetDir(projectName);
-		} else {
-			targetDir = defaultTargetDir;
-		}
-	}
+	// 1. Get the project name and target directory
+	const projectNameResult = await getProjectName(argTargetDir, interactive);
+	if (projectNameResult.cancelled) { return cancel(); }
+	const { projectName, targetDir } = projectNameResult;
 
-	// 2. Handle directory if exist and not empty
-	if (fs.existsSync(targetDir) && !isEmpty(targetDir)) {
-		let overwrite = argOverwrite
-			? 'yes'
-			: undefined;
-		if (!overwrite) {
-			if (interactive) {
-				const res = await prompts.select({
-					message: (targetDir === '.'
-						? 'Current directory'
-						: `Target directory "${targetDir}"`)
-						+ ` is not empty. Please choose how to proceed:`,
-					options: [
-						{
-							label: 'Cancel operation',
-							value: 'no',
-						},
-						{
-							label: 'Remove existing files and continue',
-							value: 'yes',
-						},
-						{
-							label: 'Ignore files and continue',
-							value: 'ignore',
-						},
-					],
-				});
-				if (prompts.isCancel(res)) { return cancel(); }
-				overwrite = res;
-			} else {
-				overwrite = 'no';
-			}
-		}
+	// 2. Handle if the directory exists and isn't empty
+	const handleExistingDirResult = await handleExistingDir(targetDir, argOverwrite, interactive);
+	if (handleExistingDirResult.cancelled) { return cancel(); }
 
-		switch (overwrite) {
-			case 'yes':
-				emptyDir(targetDir);
-				break;
-			case 'no':
-				cancel();
-				return;
-		}
-	}
-
-	// 3. Get package name
-	let packageName = path.basename(path.resolve(targetDir));
-	if (!isValidPackageName(packageName)) {
-		if (interactive) {
-			const packageNameResult = await prompts.text({
-				message: 'Package name:',
-				defaultValue: toValidPackageName(packageName),
-				placeholder: toValidPackageName(packageName),
-				validate(dir) {
-					if (dir && !isValidPackageName(dir)) {
-						return 'Invalid package.json name';
-					}
-				},
-			});
-			if (prompts.isCancel(packageNameResult)) { return cancel(); }
-			packageName = packageNameResult;
-		} else {
-			packageName = toValidPackageName(packageName);
-		}
-	}
+	// 3. Get the package name
+	const packageNameResult = await getPackageName(targetDir, interactive);
+	if (packageNameResult.cancelled) { return cancel(); }
+	const { packageName } = packageNameResult;
 
 	// 4. Choose a framework and variant
-	let template = argTemplate;
-	let hasInvalidArgTemplate = false;
-	if (argTemplate && !TEMPLATES.includes(argTemplate)) {
-		template = undefined;
-		hasInvalidArgTemplate = true;
-	}
-	if (!template) {
-		if (interactive) {
-			const framework = await prompts.select({
-				message: hasInvalidArgTemplate
-					? `"${argTemplate}" isn't a valid template. Please choose from below: `
-					: 'Select a framework:',
-				options: FRAMEWORKS
-					.filter(framework => !framework.hidden)
-					.map((framework) => {
-						const frameworkColor = framework.color;
-						return {
-							label: frameworkColor(framework.display || framework.name),
-							value: framework,
-						};
-					}),
-			});
-			if (prompts.isCancel(framework)) { return cancel(); }
-
-			const variant = framework.variants.length === 1
-				? framework.variants[0].name
-				: await prompts.select({
-					message: 'Select a variant:',
-					options: framework.variants.map((variant) => {
-						const variantColor = variant.color;
-						const command = variant.customCommand
-							? getFullCustomCommand(variant.customCommand, pkgInfo).replace(
-								/ TARGET_DIR$/,
-								'',
-							)
-							: undefined;
-						return {
-							label: variantColor(variant.display || variant.name),
-							value: variant.name,
-							hint: command,
-						};
-					}),
-				});
-			if (prompts.isCancel(variant)) { return cancel(); }
-
-			template = variant;
-		} else {
-			template = 'vanilla-ts';
-		}
-	}
+	const templateResult = await getTemplate(argTemplate, interactive);
+	if (templateResult.cancelled) { return cancel(); }
+	const { template } = templateResult;
 
+	// 5. Should we do a package manager installation?
+	const pkgInfo = pkgFromUserAgent(process.env.npm_config_user_agent);
 	const pkgManager = pkgInfo ? pkgInfo.name : 'npm';
+	const immediateResult = await getImmediate(argImmediate, interactive, pkgManager);
+	if (immediateResult.cancelled) { return cancel(); }
+	const { immediate } = immediateResult;
 
-	const root = path.join(cwd, targetDir);
+	// 6. Get environment variables for .env file
+	const envVarsResult = await getEnvVars(argv, interactive, template);
+	if (envVarsResult.cancelled) { return cancel(); }
+	const { envVars } = envVarsResult;
 
-	const { customCommand } = FRAMEWORKS.flatMap((f) => f.variants).find((v) => v.name === template) ?? {};
+	// 7. Write out the contents based on all prior steps.
+	const root = scaffoldProject(targetDir, projectName, packageName, template, envVars);
 
-	if (customCommand) {
-		const fullCustomCommand = getFullCustomCommand(customCommand, pkgInfo);
-
-		const [command, ...args] = fullCustomCommand.split(' ');
-		// we replace TARGET_DIR here because targetDir may include a space
-		const replacedArgs = args.map((arg) => arg.replace('TARGET_DIR', () => targetDir));
-		const { status } = spawn.sync(command, replacedArgs, {
-			stdio: 'inherit',
-		});
-		process.exit(status ?? 0);
-	}
-
-	// 5. Ask about immediate install and package manager
-	let immediate = argImmediate;
-	if (immediate === undefined) {
-		if (interactive) {
-			const immediateResult = await prompts.confirm({
-				message: `Install with ${pkgManager} and start now?`,
-			});
-			if (prompts.isCancel(immediateResult)) { return cancel(); }
-			immediate = immediateResult;
-		} else {
-			immediate = false;
-		}
-	}
-
-	// Only create a directory for built-in templates, not for customCommand
-	fs.mkdirSync(root, { recursive: true });
-	prompts.log.step(`Scaffolding project in ${root}...`);
-
-	const context = {
-		projectName,
-		packageName,
-	};
-
-	const templateSharedDir = path.resolve(fileURLToPath(import.meta.url), '..', `template-shared`);
-	crawlTemplateDir(root, templateSharedDir, context);
-
-	const templateDir = path.resolve(fileURLToPath(import.meta.url), '..', `template-${template}`);
-	crawlTemplateDir(root, templateDir, context);
-
-	if (immediate) {
-		install(root, pkgManager);
-		start(root, pkgManager);
-	} else {
-		let doneMessage = '';
-		const cdProjectName = path.relative(cwd, root);
-		doneMessage += `Done. Now run:\n`;
-		if (root !== cwd) {
-			doneMessage += `\n  cd ${cdProjectName.includes(' ') ? `"${cdProjectName}"` : cdProjectName}`;
-		}
-		doneMessage += `\n  ${getInstallCommand(pkgManager).join(' ')}`;
-		doneMessage += `\n  ${getRunCommand(pkgManager, 'dev').join(' ')}`;
-		prompts.outro(doneMessage);
-	}
+	// 8. Log out the next steps.
+	showOutro(root, pkgManager, immediate);
 }

package/lib/constants/renameFiles.js

@@ -3,4 +3,5 @@ export const renameFiles = {
 	_gitignore: '.gitignore',
 	_github: '.github',
 	'_env.example': '.env.example',
+	'_env': '.env',
 };

package/lib/fs/applyAndWriteTemplateFile.js

@@ -1,9 +1,9 @@
-import template from 'lodash/template.js';
 import fs from 'node:fs';
 
-export function applyAndWriteTemplateFile(targetPath, templatePath, context) {
-	const templateContent = fs.readFileSync(templatePath, 'utf-8');
-	const templateFn = template(templateContent, { interpolate: /<<([\s\S]+?)>>/g });
-	const updatedContent = templateFn(context);
+export function applyAndWriteTemplateFile(targetPath, templatePath, substitutions) {
+	let updatedContent = fs.readFileSync(templatePath, 'utf-8');
+	for (const variableName in substitutions) {
+		updatedContent = updatedContent.replaceAll(variableName, substitutions[variableName]);
+	}
 	fs.writeFileSync(targetPath, updatedContent);
 }

package/lib/fs/crawlTemplateDir.js

@@ -3,16 +3,16 @@ import path from 'node:path';
 import { renameFiles } from '../constants/renameFiles.js';
 import { applyAndWriteTemplateFile } from './applyAndWriteTemplateFile.js';
 
-export function crawlTemplateDir(root, dir, context) {
+export function crawlTemplateDir(root, dir, substitutions) {
 	const files = fs.readdirSync(dir);
 	for (const file of files) {
 		const targetPath = path.join(root, renameFiles[file] ?? file);
 		const templatePath = path.join(dir, file);
 		if (fs.lstatSync(templatePath).isDirectory()) {
 			fs.mkdirSync(targetPath, { recursive: true });
-			crawlTemplateDir(targetPath, templatePath, context);
+			crawlTemplateDir(targetPath, templatePath, substitutions);
 		} else {
-			applyAndWriteTemplateFile(targetPath, templatePath, context);
+			applyAndWriteTemplateFile(targetPath, templatePath, substitutions);
 		}
 	}
 }

package/lib/pkg/toValidPackageName.js

@@ -4,5 +4,6 @@ export function toValidPackageName(projectName) {
 		.toLowerCase()
 		.replace(/\s+/g, '-')
 		.replace(/^[._]/, '')
-		.replace(/[^a-z\d\-~]+/g, '-');
+		.replace(/[^a-z\d\-~]+/g, '-')
+		.replace(/-+$/, '');
 }

package/lib/steps/getEnvVars.js

@@ -0,0 +1,79 @@
+import * as prompts from '@clack/prompts';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/**
+ * Step 5: Get environment variables for .env file
+ * @param {any} argv
+ * @param {boolean} interactive
+ * @param {string} template
+ * @returns {Promise<{envVars: {username: string, target: string, password?: string}, cancelled: boolean}>}
+ */
+export async function getEnvVars(argv, interactive, template) {
+	const templateDir = path.resolve(
+		fileURLToPath(import.meta.url),
+		'..',
+		'..',
+		'..',
+		`template-${template}`,
+	);
+	const hasEnvFile = fs.existsSync(path.join(templateDir, '_env'));
+
+	if (!hasEnvFile) {
+		return {
+			envVars: {},
+			cancelled: false,
+		};
+	}
+
+	let username = argv['cli-target-username'];
+	let target = argv['cli-target'];
+	let password = '';
+
+	if (interactive) {
+		if (!username) {
+			const usernameResult = await prompts.text({
+				message: 'CLI Target Username:',
+				placeholder: 'YOUR_CLUSTER_USERNAME',
+			});
+
+			if (prompts.isCancel(usernameResult)) {
+				return { envVars: {}, cancelled: true };
+			}
+			username = usernameResult;
+		}
+
+		if (!target) {
+			const targetResult = await prompts.text({
+				message: 'CLI Target URL:',
+				placeholder: 'YOUR_FABRIC.HARPER.FAST_CLUSTER_URL_HERE',
+			});
+
+			if (prompts.isCancel(targetResult)) {
+				return { envVars: {}, cancelled: true };
+			}
+			target = targetResult;
+		}
+
+		const passwordResult = await prompts.password({
+			message: 'CLI Target Password:',
+		});
+
+		if (prompts.isCancel(passwordResult)) {
+			return { envVars: {}, cancelled: true };
+		}
+		password = passwordResult;
+	} else {
+		prompts.log.warn('Non-interactive mode: Please update your .env to add your CLI_TARGET_PASSWORD on your own.');
+	}
+
+	return {
+		envVars: {
+			username: username || 'YOUR_CLUSTER_USERNAME',
+			target: target || 'YOUR_FABRIC.HARPER.FAST_CLUSTER_URL_HERE',
+			password: password || 'YOUR_CLUSTER_PASSWORD',
+		},
+		cancelled: false,
+	};
+}

package/lib/steps/getImmediate.js

@@ -0,0 +1,29 @@
+import * as prompts from '@clack/prompts';
+
+/**
+ * Step 5: Ask about immediate install and package manager
+ * @param {boolean | undefined} argImmediate
+ * @param {boolean} interactive
+ * @param {string} pkgManager
+ * @returns {Promise<{immediate: boolean, cancelled: boolean}>}
+ */
+export async function getImmediate(argImmediate, interactive, pkgManager) {
+	let immediate = argImmediate;
+
+	if (immediate === undefined) {
+		if (interactive) {
+			const immediateResult = await prompts.confirm({
+				message: `Install with ${pkgManager} and start now?`,
+			});
+
+			if (prompts.isCancel(immediateResult)) {
+				return { immediate: false, cancelled: true };
+			}
+			immediate = immediateResult;
+		} else {
+			immediate = false;
+		}
+	}
+
+	return { immediate, cancelled: false };
+}

package/lib/steps/getPackageName.js

@@ -0,0 +1,38 @@
+import * as prompts from '@clack/prompts';
+import path from 'node:path';
+import { isValidPackageName } from '../pkg/isValidPackageName.js';
+import { toValidPackageName } from '../pkg/toValidPackageName.js';
+
+/**
+ * Step 3: Get package name
+ * @param {string} targetDir
+ * @param {boolean} interactive
+ * @returns {Promise<{packageName: string, cancelled: boolean}>}
+ */
+export async function getPackageName(targetDir, interactive) {
+	let packageName = path.basename(path.resolve(targetDir));
+
+	if (!isValidPackageName(packageName)) {
+		if (interactive) {
+			const packageNameResult = await prompts.text({
+				message: 'Package name:',
+				defaultValue: toValidPackageName(packageName),
+				placeholder: toValidPackageName(packageName),
+				validate(dir) {
+					if (dir && !isValidPackageName(dir)) {
+						return 'Invalid package.json name';
+					}
+				},
+			});
+
+			if (prompts.isCancel(packageNameResult)) {
+				return { packageName: '', cancelled: true };
+			}
+			packageName = packageNameResult;
+		} else {
+			packageName = toValidPackageName(packageName);
+		}
+	}
+
+	return { packageName, cancelled: false };
+}

package/lib/steps/getProjectName.js

@@ -0,0 +1,40 @@
+import * as prompts from '@clack/prompts';
+import { defaultTargetDir } from '../constants/defaultTargetDir.js';
+import { formatTargetDir } from '../fs/formatTargetDir.js';
+
+/**
+ * Step 1: Get project name and target directory
+ * @param {string | undefined} argTargetDir
+ * @param {boolean} interactive
+ * @returns {Promise<{projectName: string, targetDir: string, cancelled: boolean}>}
+ */
+export async function getProjectName(argTargetDir, interactive) {
+	let targetDir = argTargetDir;
+	let projectName = targetDir;
+
+	if (!targetDir) {
+		if (interactive) {
+			projectName = await prompts.text({
+				message: 'Project name:',
+				defaultValue: defaultTargetDir,
+				placeholder: defaultTargetDir,
+				validate: (value) => {
+					return !value || formatTargetDir(value).length > 0
+						? undefined
+						: 'Invalid project name';
+				},
+			});
+
+			if (prompts.isCancel(projectName)) {
+				return { projectName: '', targetDir: '', cancelled: true };
+			}
+
+			targetDir = formatTargetDir(projectName);
+		} else {
+			targetDir = defaultTargetDir;
+			projectName = targetDir;
+		}
+	}
+
+	return { projectName, targetDir, cancelled: false };
+}

package/lib/steps/getTemplate.js

@@ -0,0 +1,65 @@
+import * as prompts from '@clack/prompts';
+import { FRAMEWORKS } from '../constants/frameworks.js';
+import { TEMPLATES } from '../constants/templates.js';
+
+/**
+ * Step 4: Choose a framework and variant
+ * @param {string | undefined} argTemplate
+ * @param {boolean} interactive
+ * @returns {Promise<{template: string, cancelled: boolean}>}
+ */
+export async function getTemplate(argTemplate, interactive) {
+	let template = argTemplate;
+	let hasInvalidArgTemplate = false;
+
+	if (argTemplate && !TEMPLATES.includes(argTemplate)) {
+		template = undefined;
+		hasInvalidArgTemplate = true;
+	}
+
+	if (!template) {
+		if (interactive) {
+			const framework = await prompts.select({
+				message: hasInvalidArgTemplate
+					? `"${argTemplate}" isn't a valid template. Please choose from below: `
+					: 'Select a framework:',
+				options: FRAMEWORKS
+					.filter(framework => !framework.hidden)
+					.map((framework) => {
+						const frameworkColor = framework.color;
+						return {
+							label: frameworkColor(framework.display),
+							value: framework,
+						};
+					}),
+			});
+
+			if (prompts.isCancel(framework)) {
+				return { template: '', cancelled: true };
+			}
+
+			const variant = framework.variants.length === 1
+				? framework.variants[0].name
+				: await prompts.select({
+					message: 'Select a variant:',
+					options: framework.variants.map((variant) => {
+						const variantColor = variant.color;
+						return {
+							label: variantColor(variant.display || variant.name),
+							value: variant.name,
+						};
+					}),
+				});
+
+			if (prompts.isCancel(variant)) {
+				return { template: '', cancelled: true };
+			}
+
+			template = variant;
+		} else {
+			template = 'vanilla-ts';
+		}
+	}
+
+	return { template, cancelled: false };
+}

package/lib/steps/handleExistingDir.js

@@ -0,0 +1,61 @@
+import * as prompts from '@clack/prompts';
+import fs from 'node:fs';
+import { emptyDir } from '../fs/emptyDir.js';
+import { isEmpty } from '../fs/isEmpty.js';
+
+/**
+ * Step 2: Handle directory if exist and not empty
+ * @param {string} targetDir
+ * @param {boolean | undefined} argOverwrite
+ * @param {boolean} interactive
+ * @returns {Promise<{cancelled: boolean}>}
+ */
+export async function handleExistingDir(targetDir, argOverwrite, interactive) {
+	if (fs.existsSync(targetDir) && !isEmpty(targetDir)) {
+		let overwrite = argOverwrite
+			? 'yes'
+			: undefined;
+
+		if (!overwrite) {
+			if (interactive) {
+				const res = await prompts.select({
+					message: (targetDir === '.'
+						? 'Current directory'
+						: `Target directory "${targetDir}"`)
+						+ ` is not empty. Please choose how to proceed:`,
+					options: [
+						{
+							label: 'Cancel operation',
+							value: 'no',
+						},
+						{
+							label: 'Remove existing files and continue',
+							value: 'yes',
+						},
+						{
+							label: 'Ignore files and continue',
+							value: 'ignore',
+						},
+					],
+				});
+
+				if (prompts.isCancel(res)) {
+					return { cancelled: true };
+				}
+				overwrite = res;
+			} else {
+				overwrite = 'no';
+			}
+		}
+
+		switch (overwrite) {
+			case 'yes':
+				emptyDir(targetDir);
+				break;
+			case 'no':
+				return { cancelled: true };
+		}
+	}
+
+	return { cancelled: false };
+}