create-jst 0.4.4 → 0.4.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-jst",
-  "version": "0.4.4",
+  "version": "0.4.8",
   "description": "Create a web application from the JST template.",
   "type": "module",
   "packageManager": "npm@11.6.2",

package/src/application/projectInitializer.mjs

@@ -4,6 +4,7 @@ export function createProjectInitializer({ onProgress = () => undefined, project
 			await projectGateway.assertDestinationIsEmpty(specification.destination)
 			const temporaryDestination = await projectGateway.prepareDestination(specification.destination)
 			const temporarySpecification = Object.freeze({ ...specification, destination: temporaryDestination })
+			let rollbackDestination = temporaryDestination
 
 			try {
 			onProgress({ type: 'template.download.started', specification })
@@ -28,16 +29,17 @@ export function createProjectInitializer({ onProgress = () => undefined, project
 					onProgress({ type: 'git.initialization.started', specification })
 					await projectGateway.initializeGit(temporaryDestination)
 				}
+				await projectGateway.commitDestination(temporaryDestination, specification.destination)
+				rollbackDestination = specification.destination
 				if (specification.install) {
 					onProgress({ type: 'dependencies.installation.started', specification })
-					await projectGateway.installDependencies(temporaryDestination, specification.packageManager)
+					await projectGateway.installDependencies(specification.destination, specification.packageManager)
 				}
 
-				await projectGateway.commitDestination(temporaryDestination, specification.destination)
 				onProgress({ type: 'project.initialized', specification })
 			}
 			catch (error) {
-				await projectGateway.cleanupDestination(temporaryDestination)
+				await projectGateway.cleanupDestination(rollbackDestination)
 				throw error
 			}
 		},

package/src/infrastructure/nodeMigrationGateway.mjs

@@ -1,6 +1,7 @@
 import { execFile } from 'node:child_process'
 import { readFile, rm, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
+import process from 'node:process'
 import { promisify } from 'node:util'
 
 const executeFile = promisify(execFile)
@@ -32,7 +33,10 @@ export function createNodeMigrationGateway() {
 		async verify(directory) {
 			const manifest = JSON.parse(await readFile(join(directory, 'package.json'), 'utf8'))
 			const packageManager = manifest.packageManager?.startsWith('pnpm@') ? 'pnpm' : 'npm'
-			return executeFile(packageManager, ['run', 'check'], { cwd: directory })
+			return executeFile(packageManager, ['run', 'check'], {
+				cwd: directory,
+				shell: process.platform === 'win32',
+			})
 		},
 		async writeTransaction(directory, files, verify) {
 			const originals = new Map()

package/src/infrastructure/nodeProjectGateway.mjs

@@ -1,7 +1,7 @@
 import { spawn, execFile } from 'node:child_process'
 import { existsSync } from 'node:fs'
 import { lstat, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises'
-import { basename, dirname, join } from 'node:path'
+import { basename, dirname, extname, join } from 'node:path'
 import process from 'node:process'
 import { promisify } from 'node:util'
 
@@ -10,6 +10,8 @@ const installCommands = {
 	npm: ['install', '--no-audit', '--no-fund'],
 	pnpm: ['install'],
 }
+const pnpmAction = 'pnpm/action-setup@ea17c68df8912ef543352723c149a84f56e3d413 # v6.1.0'
+const textExtensions = new Set(['.md', '.mjs', '.yaml', '.yml'])
 
 export function createNodeProjectGateway({ nodeExecutable, signal }) {
 	return {
@@ -58,7 +60,7 @@ export function createNodeProjectGateway({ nodeExecutable, signal }) {
 			'--color-scheme', specification.colorScheme,
 			'--primary-color', specification.primaryColor,
 			'--style', specification.style,
-		], specification.destination, signal)
+		], specification.destination, { signal })
 	}
 
 	async function configureExample(specification) {
@@ -69,11 +71,14 @@ export function createNodeProjectGateway({ nodeExecutable, signal }) {
 	}
 
 	function initializeGit(destination) {
-		return run('git', ['init', '--initial-branch=main'], destination, signal)
+		return run('git', ['init', '--initial-branch=main'], destination, { signal })
 	}
 
 	function installDependencies(destination, packageManager) {
-		return run(packageManager, installCommands[packageManager], destination, signal)
+		return run(packageManager, installCommands[packageManager], destination, {
+			shell: process.platform === 'win32',
+			signal,
+		})
 	}
 
 	async function validateTemplate(specification) {
@@ -112,6 +117,9 @@ async function configurePackageManager(destination, packageManager, signal) {
 	catch {
 		throw new Error(`Could not run ${packageManager}. Install it or choose another package manager.`)
 	}
+	if (packageManager === 'pnpm') {
+		manifest.scripts = replaceManifestCommands(manifest.scripts)
+	}
 	const packageManagerEntry = ['packageManager', `${packageManager}@${version.trim()}`]
 	const entries = Object.entries(manifest).flatMap(entry => entry[0] === 'engines' ? [packageManagerEntry, entry] : [entry])
 	if (!manifest.engines) {
@@ -129,34 +137,67 @@ minimumReleaseAgeExclude:
 trustPolicy: no-downgrade
 trustPolicyIgnoreAfter: 10080
 shellEmulator: true
+
+packages:
+  - .
 `,
 		)
-		await replaceReadmeCommands(destination, 'pnpm')
+		await replaceProjectCommands(destination)
 	}
 }
 
-async function replaceReadmeCommands(destination, packageManager) {
-	const path = join(destination, 'README.md')
-	try {
-		const readme = await readFile(path, 'utf8')
-		await writeFile(path, readme.replaceAll('npm run ', `${packageManager} run `).replaceAll('npm ci', `${packageManager} install --frozen-lockfile`))
-	}
-	catch (error) {
-		if (error?.code !== 'ENOENT') {
-			throw error
+function replaceManifestCommands(scripts = {}) {
+	return Object.fromEntries(Object.entries(scripts).map(([name, command]) => [name, replacePnpmCommands(command)]))
+}
+
+async function replaceProjectCommands(directory) {
+	for (const entry of await readdir(directory, { withFileTypes: true })) {
+		const path = join(directory, entry.name)
+		if (entry.isDirectory()) {
+			await replaceProjectCommands(path)
+		}
+		else if (textExtensions.has(extname(entry.name)) || entry.name === 'Dockerfile') {
+			const source = await readFile(path, 'utf8')
+			const converted = entry.name === 'Dockerfile' ? replacePnpmDockerfile(source) : replacePnpmText(source)
+			if (converted !== source) {
+				await writeFile(path, converted)
+			}
 		}
 	}
 }
 
+function replacePnpmText(source) {
+	let result = replacePnpmCommands(source)
+	result = result.replaceAll('cache: npm', 'cache: pnpm')
+	result = result.replace(/^([ \t]*)- uses: actions\/setup-node@/mu, `$1- uses: ${pnpmAction}\n$&`)
+	return result.replace(/^\s*- run: npm install -g npm@[^\n]+\n/mu, '')
+}
+
+function replacePnpmCommands(source) {
+	return source
+		.replaceAll('npm ci', 'pnpm install --frozen-lockfile')
+		.replaceAll('npm run ', 'pnpm run ')
+		.replaceAll('npx ', 'pnpm exec ')
+}
+
+function replacePnpmDockerfile(source) {
+	return replacePnpmCommands(source)
+		.replaceAll(/^(FROM [^\n]+)$/gmu, '$1\nRUN corepack enable')
+		.replaceAll('COPY package.json package-lock.json ./', 'COPY package.json pnpm-lock.yaml pnpm-workspace.yaml ./')
+		.replaceAll('pnpm install --frozen-lockfile --omit=dev', 'pnpm install --prod --frozen-lockfile')
+		.replaceAll('npm cache clean --force', 'pnpm store prune')
+		.replaceAll('CMD ["npm", "start"]', 'CMD ["pnpm", "start"]')
+}
+
 async function prepareDestination(destination) {
 	const temporaryDestination = join(dirname(destination), `.${basename(destination)}-${process.pid}-${Date.now()}.tmp`)
 	await rm(temporaryDestination, { force: true, recursive: true })
 	return temporaryDestination
 }
 
-function run(command, args, cwd, signal) {
+function run(command, args, cwd, { shell = false, signal } = {}) {
 	return new Promise((resolve, reject) => {
-		const child = spawn(command, args, { cwd, signal, stdio: 'inherit' })
+		const child = spawn(command, args, { cwd, shell, signal, stdio: 'inherit' })
 		child.once('error', error => reject(new Error(`Could not run ${command}: ${error.message}`)))
 		child.once('close', code => {
 			if (code === 0) {