@geekmidas/cli 1.7.0 → 1.9.0

package/src/upgrade/__tests__/index.spec.ts

@@ -0,0 +1,354 @@
+import { execSync } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+import { mkdir, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { HttpResponse, http } from 'msw';
+import { setupServer } from 'msw/node';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { upgradeCommand } from '../index';
+
+vi.mock('node:child_process', () => ({
+	execSync: vi.fn(),
+}));
+
+const NPM_REGISTRY = 'https://registry.npmjs.org';
+
+const server = setupServer();
+
+function writePackageJson(dir: string, content: Record<string, unknown>) {
+	writeFileSync(join(dir, 'package.json'), JSON.stringify(content, null, 2));
+}
+
+describe('upgradeCommand', () => {
+	let tempDir: string;
+	let originalCwd: string;
+
+	beforeEach(async () => {
+		tempDir = join(tmpdir(), `gkm-upgrade-test-${Date.now()}`);
+		await mkdir(tempDir, { recursive: true });
+		originalCwd = process.cwd();
+		process.chdir(tempDir);
+		server.listen({ onUnhandledRequest: 'bypass' });
+		vi.mocked(execSync).mockReset();
+	});
+
+	afterEach(async () => {
+		process.chdir(originalCwd);
+		server.resetHandlers();
+		server.close();
+		await rm(tempDir, { recursive: true, force: true });
+	});
+
+	it('should report no packages found when none exist', async () => {
+		writePackageJson(tempDir, {
+			name: 'test-project',
+			dependencies: { lodash: '^4.0.0' },
+		});
+		// Create a lockfile so detectPackageManager finds a root
+		writeFileSync(join(tempDir, 'package-lock.json'), '{}');
+
+		const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+		await upgradeCommand();
+
+		const output = logSpy.mock.calls.flat().join('\n');
+		expect(output).toContain('No @geekmidas packages found');
+
+		logSpy.mockRestore();
+	});
+
+	it('should detect workspace refs and mark them as workspace status', async () => {
+		writeFileSync(join(tempDir, 'package-lock.json'), '{}');
+		writePackageJson(tempDir, {
+			name: 'test-monorepo',
+			workspaces: ['packages/*'],
+			dependencies: {
+				'@geekmidas/constructs': 'workspace:*',
+			},
+		});
+
+		const pkgDir = join(tempDir, 'packages', 'api');
+		await mkdir(pkgDir, { recursive: true });
+		writePackageJson(pkgDir, {
+			name: '@test/api',
+			dependencies: {
+				'@geekmidas/auth': 'workspace:~',
+			},
+		});
+
+		server.use(
+			http.get(`${NPM_REGISTRY}/@geekmidas/constructs/latest`, () => {
+				return HttpResponse.json({ version: '1.1.1' });
+			}),
+			http.get(`${NPM_REGISTRY}/@geekmidas/auth/latest`, () => {
+				return HttpResponse.json({ version: '1.0.0' });
+			}),
+		);
+
+		const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+		await upgradeCommand();
+
+		const output = logSpy.mock.calls.flat().join('\n');
+		expect(output).toContain('workspace');
+		expect(output).toContain('All @geekmidas packages are up to date');
+
+		logSpy.mockRestore();
+	});
+
+	it('should identify packages that need upgrade', async () => {
+		writeFileSync(join(tempDir, 'package-lock.json'), '{}');
+		writePackageJson(tempDir, {
+			name: 'test-project',
+			dependencies: {
+				'@geekmidas/constructs': '^1.0.0',
+				'@geekmidas/auth': '~1.0.0',
+			},
+		});
+
+		server.use(
+			http.get(`${NPM_REGISTRY}/@geekmidas/constructs/latest`, () => {
+				return HttpResponse.json({ version: '1.2.0' });
+			}),
+			http.get(`${NPM_REGISTRY}/@geekmidas/auth/latest`, () => {
+				return HttpResponse.json({ version: '1.1.0' });
+			}),
+		);
+
+		const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+		await upgradeCommand({ dryRun: true });
+
+		const output = logSpy.mock.calls.flat().join('\n');
+		expect(output).toContain('⬆ upgrade');
+		expect(output).toContain('2 package(s) can be upgraded');
+		expect(output).toContain('--dry-run: No changes made');
+		expect(output).toContain('npm update');
+
+		logSpy.mockRestore();
+	});
+
+	it('should report up-to-date when versions match', async () => {
+		writeFileSync(join(tempDir, 'package-lock.json'), '{}');
+		writePackageJson(tempDir, {
+			name: 'test-project',
+			dependencies: {
+				'@geekmidas/errors': '1.0.0',
+			},
+		});
+
+		server.use(
+			http.get(`${NPM_REGISTRY}/@geekmidas/errors/latest`, () => {
+				return HttpResponse.json({ version: '1.0.0' });
+			}),
+		);
+
+		const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+		await upgradeCommand();
+
+		const output = logSpy.mock.calls.flat().join('\n');
+		expect(output).toContain('✓ up-to-date');
+		expect(output).toContain('All @geekmidas packages are up to date');
+
+		logSpy.mockRestore();
+	});
+
+	it('should execute upgrade command when not dry-run', async () => {
+		writeFileSync(join(tempDir, 'package-lock.json'), '{}');
+		writePackageJson(tempDir, {
+			name: 'test-project',
+			dependencies: {
+				'@geekmidas/errors': '^1.0.0',
+			},
+		});
+
+		server.use(
+			http.get(`${NPM_REGISTRY}/@geekmidas/errors/latest`, () => {
+				return HttpResponse.json({ version: '2.0.0' });
+			}),
+		);
+
+		const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+		await upgradeCommand();
+
+		expect(execSync).toHaveBeenCalledWith(
+			expect.stringContaining('npm update @geekmidas/errors'),
+			expect.objectContaining({ stdio: 'inherit' }),
+		);
+
+		logSpy.mockRestore();
+	});
+
+	it('should use pnpm update -r when pnpm is detected', async () => {
+		writeFileSync(join(tempDir, 'pnpm-lock.yaml'), '');
+		writePackageJson(tempDir, {
+			name: 'test-project',
+			dependencies: {
+				'@geekmidas/logger': '^1.0.0',
+			},
+		});
+
+		server.use(
+			http.get(`${NPM_REGISTRY}/@geekmidas/logger/latest`, () => {
+				return HttpResponse.json({ version: '2.0.0' });
+			}),
+		);
+
+		const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+		await upgradeCommand();
+
+		expect(execSync).toHaveBeenCalledWith(
+			expect.stringContaining('pnpm update -r @geekmidas/logger --latest'),
+			expect.anything(),
+		);
+
+		logSpy.mockRestore();
+	});
+
+	it('should scan all workspace packages in pnpm workspace', async () => {
+		writeFileSync(join(tempDir, 'pnpm-lock.yaml'), '');
+		writeFileSync(
+			join(tempDir, 'pnpm-workspace.yaml'),
+			'packages:\n  - "packages/*"\n  - "apps/*"\n',
+		);
+		writePackageJson(tempDir, {
+			name: 'test-monorepo',
+			devDependencies: {
+				'@geekmidas/cli': '^1.0.0',
+			},
+		});
+
+		const apiDir = join(tempDir, 'apps', 'api');
+		await mkdir(apiDir, { recursive: true });
+		writePackageJson(apiDir, {
+			name: '@test/api',
+			dependencies: {
+				'@geekmidas/constructs': '^1.0.0',
+			},
+		});
+
+		const libDir = join(tempDir, 'packages', 'shared');
+		await mkdir(libDir, { recursive: true });
+		writePackageJson(libDir, {
+			name: '@test/shared',
+			dependencies: {
+				'@geekmidas/errors': '^1.0.0',
+			},
+		});
+
+		server.use(
+			http.get(`${NPM_REGISTRY}/@geekmidas/cli/latest`, () => {
+				return HttpResponse.json({ version: '2.0.0' });
+			}),
+			http.get(`${NPM_REGISTRY}/@geekmidas/constructs/latest`, () => {
+				return HttpResponse.json({ version: '2.0.0' });
+			}),
+			http.get(`${NPM_REGISTRY}/@geekmidas/errors/latest`, () => {
+				return HttpResponse.json({ version: '2.0.0' });
+			}),
+		);
+
+		const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+		await upgradeCommand({ dryRun: true });
+
+		const output = logSpy.mock.calls.flat().join('\n');
+		expect(output).toContain('Found 3 package(s) in workspace');
+		expect(output).toContain('3 package(s) can be upgraded');
+
+		logSpy.mockRestore();
+	});
+
+	it('should handle npm registry errors gracefully', async () => {
+		writeFileSync(join(tempDir, 'package-lock.json'), '{}');
+		writePackageJson(tempDir, {
+			name: 'test-project',
+			dependencies: {
+				'@geekmidas/nonexistent': '^1.0.0',
+			},
+		});
+
+		server.use(
+			http.get(`${NPM_REGISTRY}/@geekmidas/nonexistent/latest`, () => {
+				return new HttpResponse(null, { status: 404 });
+			}),
+		);
+
+		const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+		await upgradeCommand();
+
+		const output = logSpy.mock.calls.flat().join('\n');
+		expect(output).toContain('unknown');
+
+		logSpy.mockRestore();
+	});
+
+	it('should throw when execSync fails', async () => {
+		writeFileSync(join(tempDir, 'package-lock.json'), '{}');
+		writePackageJson(tempDir, {
+			name: 'test-project',
+			dependencies: {
+				'@geekmidas/errors': '^1.0.0',
+			},
+		});
+
+		server.use(
+			http.get(`${NPM_REGISTRY}/@geekmidas/errors/latest`, () => {
+				return HttpResponse.json({ version: '2.0.0' });
+			}),
+		);
+
+		vi.mocked(execSync).mockImplementation(() => {
+			throw new Error('command failed');
+		});
+
+		const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+		await expect(upgradeCommand()).rejects.toThrow('Package upgrade failed');
+
+		logSpy.mockRestore();
+	});
+
+	it('should scan deps, devDeps, and peerDeps', async () => {
+		writeFileSync(join(tempDir, 'package-lock.json'), '{}');
+		writePackageJson(tempDir, {
+			name: 'test-project',
+			dependencies: {
+				'@geekmidas/constructs': '^1.0.0',
+			},
+			devDependencies: {
+				'@geekmidas/testkit': '^1.0.0',
+			},
+			peerDependencies: {
+				'@geekmidas/logger': '^1.0.0',
+			},
+		});
+
+		server.use(
+			http.get(`${NPM_REGISTRY}/@geekmidas/constructs/latest`, () => {
+				return HttpResponse.json({ version: '2.0.0' });
+			}),
+			http.get(`${NPM_REGISTRY}/@geekmidas/testkit/latest`, () => {
+				return HttpResponse.json({ version: '2.0.0' });
+			}),
+			http.get(`${NPM_REGISTRY}/@geekmidas/logger/latest`, () => {
+				return HttpResponse.json({ version: '2.0.0' });
+			}),
+		);
+
+		const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+		await upgradeCommand({ dryRun: true });
+
+		const output = logSpy.mock.calls.flat().join('\n');
+		expect(output).toContain('Checking 3 unique @geekmidas package(s)');
+		expect(output).toContain('3 package(s) can be upgraded');
+
+		logSpy.mockRestore();
+	});
+});

package/src/upgrade/index.ts

@@ -0,0 +1,253 @@
+import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import {
+	detectPackageManager,
+	findWorkspacePackages,
+	type PackageManager,
+} from '../init/utils.js';
+
+const logger = console;
+
+export interface UpgradeOptions {
+	dryRun?: boolean;
+}
+
+interface FoundDependency {
+	packageName: string;
+	currentVersion: string;
+	depType: 'dependencies' | 'devDependencies' | 'peerDependencies';
+	packageJsonPath: string;
+	workspaceName: string;
+}
+
+interface UpgradeInfo extends FoundDependency {
+	latestVersion: string;
+	isWorkspaceRef: boolean;
+	needsUpgrade: boolean;
+}
+
+export async function upgradeCommand(
+	options: UpgradeOptions = {},
+): Promise<void> {
+	const cwd = process.cwd();
+
+	logger.log('\n📦 Scanning workspace for @geekmidas packages...\n');
+
+	const pm = detectPackageManager(cwd);
+	logger.log(`  Package manager: ${pm}`);
+
+	const packageJsonPaths = findWorkspacePackages(cwd, pm);
+	logger.log(`  Found ${packageJsonPaths.length} package(s) in workspace\n`);
+
+	const dependencies = scanForGeekmidasDeps(packageJsonPaths);
+
+	if (dependencies.length === 0) {
+		logger.log('  No @geekmidas packages found.\n');
+		return;
+	}
+
+	const uniquePackages = [...new Set(dependencies.map((d) => d.packageName))];
+	logger.log(
+		`  Checking ${uniquePackages.length} unique @geekmidas package(s) on npm...\n`,
+	);
+
+	const latestVersions = await fetchLatestVersions(uniquePackages);
+
+	const upgradeInfos = dependencies.map((dep) =>
+		resolveUpgradeInfo(dep, latestVersions),
+	);
+
+	printUpgradeTable(upgradeInfos);
+
+	const upgradable = upgradeInfos.filter(
+		(info) => info.needsUpgrade && !info.isWorkspaceRef,
+	);
+
+	if (upgradable.length === 0) {
+		logger.log('\n  All @geekmidas packages are up to date!\n');
+		return;
+	}
+
+	logger.log(`\n  ${upgradable.length} package(s) can be upgraded.\n`);
+
+	if (options.dryRun) {
+		logger.log('  --dry-run: No changes made.\n');
+		printUpgradeCommands(upgradable, pm);
+		return;
+	}
+
+	executeUpgrade(upgradable, pm, cwd);
+
+	logger.log('\n  ✅ Upgrade complete! Run your tests to verify.\n');
+}
+
+function scanForGeekmidasDeps(packageJsonPaths: string[]): FoundDependency[] {
+	const results: FoundDependency[] = [];
+	const depTypes = [
+		'dependencies',
+		'devDependencies',
+		'peerDependencies',
+	] as const;
+
+	for (const pkgJsonPath of packageJsonPaths) {
+		const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+		const workspaceName = pkg.name ?? pkgJsonPath;
+
+		for (const depType of depTypes) {
+			const deps = pkg[depType];
+			if (!deps) continue;
+
+			for (const [name, version] of Object.entries(deps)) {
+				if (!name.startsWith('@geekmidas/')) continue;
+
+				results.push({
+					packageName: name,
+					currentVersion: version as string,
+					depType,
+					packageJsonPath: pkgJsonPath,
+					workspaceName,
+				});
+			}
+		}
+	}
+
+	return results;
+}
+
+async function fetchLatestVersions(
+	packageNames: string[],
+): Promise<Map<string, string>> {
+	const versions = new Map<string, string>();
+
+	const results = await Promise.allSettled(
+		packageNames.map(async (name) => {
+			const res = await fetch(`https://registry.npmjs.org/${name}/latest`);
+			if (!res.ok) throw new Error(`HTTP ${res.status}`);
+			const data = (await res.json()) as { version: string };
+			return { name, version: data.version };
+		}),
+	);
+
+	for (const result of results) {
+		if (result.status === 'fulfilled') {
+			versions.set(result.value.name, result.value.version);
+		}
+	}
+
+	return versions;
+}
+
+function resolveUpgradeInfo(
+	dep: FoundDependency,
+	latestVersions: Map<string, string>,
+): UpgradeInfo {
+	const isWorkspaceRef = dep.currentVersion.startsWith('workspace:');
+	const latestVersion = latestVersions.get(dep.packageName) ?? 'unknown';
+
+	const currentBare = dep.currentVersion.replace(/^[\^~>=<]*/g, '');
+	const needsUpgrade =
+		!isWorkspaceRef &&
+		latestVersion !== 'unknown' &&
+		currentBare !== latestVersion;
+
+	return {
+		...dep,
+		latestVersion,
+		isWorkspaceRef,
+		needsUpgrade,
+	};
+}
+
+function printUpgradeTable(infos: UpgradeInfo[]): void {
+	const byPackage = new Map<string, UpgradeInfo>();
+	for (const info of infos) {
+		if (!byPackage.has(info.packageName)) {
+			byPackage.set(info.packageName, info);
+		}
+	}
+
+	const nameWidth = 33;
+	const verWidth = 14;
+	const statusWidth = 14;
+
+	const hr = `  ${'─'.repeat(nameWidth + verWidth * 2 + statusWidth + 5)}`;
+
+	logger.log(hr);
+	logger.log(
+		`  ${'Package'.padEnd(nameWidth)} ${'Current'.padEnd(verWidth)} ${'Latest'.padEnd(verWidth)} ${'Status'.padEnd(statusWidth)}`,
+	);
+	logger.log(hr);
+
+	for (const [, info] of byPackage) {
+		const name = info.packageName.padEnd(nameWidth);
+		const current = info.currentVersion.padEnd(verWidth);
+		const latest = info.latestVersion.padEnd(verWidth);
+
+		let status: string;
+		if (info.isWorkspaceRef) {
+			status = 'workspace';
+		} else if (info.needsUpgrade) {
+			status = '⬆ upgrade';
+		} else {
+			status = '✓ up-to-date';
+		}
+
+		logger.log(`  ${name} ${current} ${latest} ${status}`);
+	}
+
+	logger.log(hr);
+}
+
+function printUpgradeCommands(
+	upgradable: UpgradeInfo[],
+	pm: PackageManager,
+): void {
+	logger.log('  Commands that would be run:\n');
+
+	const uniquePackages = [...new Set(upgradable.map((i) => i.packageName))];
+	const cmd = getWorkspaceUpgradeCommand(pm, uniquePackages);
+	logger.log(`    ${cmd}\n`);
+}
+
+function getWorkspaceUpgradeCommand(
+	pm: PackageManager,
+	packages: string[],
+): string {
+	const pkgList = packages.join(' ');
+
+	switch (pm) {
+		case 'pnpm':
+			return `pnpm update -r ${pkgList} --latest`;
+		case 'yarn':
+			return `yarn upgrade ${pkgList}`;
+		case 'bun':
+			return `bun update ${pkgList}`;
+		case 'npm':
+			return `npm update ${pkgList} --workspaces`;
+		default:
+			return `npm update ${pkgList}`;
+	}
+}
+
+function executeUpgrade(
+	upgradable: UpgradeInfo[],
+	pm: PackageManager,
+	cwd: string,
+): void {
+	const uniquePackages = [...new Set(upgradable.map((i) => i.packageName))];
+
+	const cmd = getWorkspaceUpgradeCommand(pm, uniquePackages);
+	logger.log(`  Running: ${cmd}\n`);
+
+	try {
+		execSync(cmd, {
+			cwd,
+			stdio: 'inherit',
+			timeout: 120_000,
+		});
+	} catch {
+		throw new Error(
+			'Package upgrade failed. Check the output above for details.',
+		);
+	}
+}