@geekmidas/cli 2.0.2 → 10.0.0-alpha.0

package/src/upgrade/index.ts

@@ -1,253 +0,0 @@
-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.',
-		);
-	}
-}

package/src/workspace/__tests__/client-generator.spec.ts

@@ -1,326 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-	getBackendDependencies,
-	getBackendOpenApiPath,
-	getDependentFrontends,
-	getFirstRoute,
-	normalizeRoutes,
-	shouldRegenerateClient,
-} from '../client-generator.js';
-import type { NormalizedWorkspace } from '../types.js';
-
-describe('Client Generator', () => {
-	describe('normalizeRoutes', () => {
-		it('should return empty array for undefined', () => {
-			expect(normalizeRoutes(undefined)).toEqual([]);
-		});
-
-		it('should return array as-is', () => {
-			expect(normalizeRoutes(['./src/**/*.ts', './api/**/*.ts'])).toEqual([
-				'./src/**/*.ts',
-				'./api/**/*.ts',
-			]);
-		});
-
-		it('should wrap string in array', () => {
-			expect(normalizeRoutes('./src/**/*.ts')).toEqual(['./src/**/*.ts']);
-		});
-	});
-
-	describe('getFirstRoute', () => {
-		it('should return null for undefined', () => {
-			expect(getFirstRoute(undefined)).toBeNull();
-		});
-
-		it('should return first element of array', () => {
-			expect(getFirstRoute(['./src/**/*.ts', './api/**/*.ts'])).toBe(
-				'./src/**/*.ts',
-			);
-		});
-
-		it('should return string directly', () => {
-			expect(getFirstRoute('./src/**/*.ts')).toBe('./src/**/*.ts');
-		});
-
-		it('should return null for empty array', () => {
-			expect(getFirstRoute([])).toBeNull();
-		});
-	});
-
-	describe('shouldRegenerateClient', () => {
-		it('should return true for TypeScript files in routes directory', () => {
-			expect(
-				shouldRegenerateClient(
-					'apps/api/src/endpoints/users.ts',
-					'./src/endpoints/**/*.ts',
-				),
-			).toBe(true);
-		});
-
-		it('should return false for non-TypeScript files', () => {
-			expect(
-				shouldRegenerateClient(
-					'apps/api/src/endpoints/README.md',
-					'./src/endpoints/**/*.ts',
-				),
-			).toBe(false);
-		});
-
-		it('should return false for files outside routes pattern', () => {
-			expect(
-				shouldRegenerateClient(
-					'apps/api/src/utils/helpers.ts',
-					'./src/endpoints/**/*.ts',
-				),
-			).toBe(false);
-		});
-
-		it('should return true for .tsx files', () => {
-			expect(
-				shouldRegenerateClient(
-					'apps/api/src/endpoints/users.tsx',
-					'./src/endpoints/**/*.ts',
-				),
-			).toBe(true);
-		});
-	});
-
-	describe('getBackendDependencies', () => {
-		it('should return backend dependencies with routes', () => {
-			const workspace: NormalizedWorkspace = {
-				name: 'test',
-				root: '/test',
-				apps: {
-					api: {
-						type: 'backend',
-						path: 'apps/api',
-						port: 3000,
-						dependencies: [],
-						routes: './src/**/*.ts',
-						resolvedDeployTarget: 'dokploy',
-					},
-					auth: {
-						type: 'backend',
-						path: 'apps/auth',
-						port: 3001,
-						dependencies: [],
-						routes: './src/**/*.ts',
-						resolvedDeployTarget: 'dokploy',
-					},
-					web: {
-						type: 'web',
-						path: 'apps/web',
-						port: 3002,
-						dependencies: ['api', 'auth'],
-						resolvedDeployTarget: 'dokploy',
-					},
-				},
-				services: {},
-				deploy: { default: 'dokploy' },
-				shared: { packages: [] },
-				secrets: {},
-			};
-
-			const deps = getBackendDependencies(workspace, 'web');
-			expect(deps).toEqual(['api', 'auth']);
-		});
-
-		it('should filter out backends without routes', () => {
-			const workspace: NormalizedWorkspace = {
-				name: 'test',
-				root: '/test',
-				apps: {
-					api: {
-						type: 'backend',
-						path: 'apps/api',
-						port: 3000,
-						dependencies: [],
-						routes: './src/**/*.ts',
-						resolvedDeployTarget: 'dokploy',
-					},
-					worker: {
-						type: 'backend',
-						path: 'apps/worker',
-						port: 3001,
-						dependencies: [],
-						resolvedDeployTarget: 'dokploy',
-						// No routes - not an HTTP backend
-					},
-					web: {
-						type: 'web',
-						path: 'apps/web',
-						port: 3002,
-						dependencies: ['api', 'worker'],
-						resolvedDeployTarget: 'dokploy',
-					},
-				},
-				services: {},
-				deploy: { default: 'dokploy' },
-				shared: { packages: [] },
-				secrets: {},
-			};
-
-			const deps = getBackendDependencies(workspace, 'web');
-			expect(deps).toEqual(['api']);
-		});
-
-		it('should return empty array for non-frontend app', () => {
-			const workspace: NormalizedWorkspace = {
-				name: 'test',
-				root: '/test',
-				apps: {
-					api: {
-						type: 'backend',
-						path: 'apps/api',
-						port: 3000,
-						dependencies: [],
-						routes: './src/**/*.ts',
-						resolvedDeployTarget: 'dokploy',
-					},
-				},
-				services: {},
-				deploy: { default: 'dokploy' },
-				shared: { packages: [] },
-				secrets: {},
-			};
-
-			const deps = getBackendDependencies(workspace, 'api');
-			expect(deps).toEqual([]);
-		});
-	});
-
-	describe('getDependentFrontends', () => {
-		it('should find frontends that depend on a backend', () => {
-			const workspace: NormalizedWorkspace = {
-				name: 'test',
-				root: '/test',
-				apps: {
-					api: {
-						type: 'backend',
-						path: 'apps/api',
-						port: 3000,
-						dependencies: [],
-						routes: './src/**/*.ts',
-						resolvedDeployTarget: 'dokploy',
-					},
-					web: {
-						type: 'web',
-						path: 'apps/web',
-						port: 3001,
-						dependencies: ['api'],
-						resolvedDeployTarget: 'dokploy',
-					},
-					admin: {
-						type: 'web',
-						path: 'apps/admin',
-						port: 3002,
-						dependencies: ['api'],
-						resolvedDeployTarget: 'dokploy',
-					},
-					docs: {
-						type: 'web',
-						path: 'apps/docs',
-						port: 3003,
-						dependencies: [], // No API dependency
-						resolvedDeployTarget: 'dokploy',
-					},
-				},
-				services: {},
-				deploy: { default: 'dokploy' },
-				shared: { packages: [] },
-				secrets: {},
-			};
-
-			const dependents = getDependentFrontends(workspace, 'api');
-			expect(dependents).toEqual(['web', 'admin']);
-		});
-
-		it('should return empty array for backend with no dependents', () => {
-			const workspace: NormalizedWorkspace = {
-				name: 'test',
-				root: '/test',
-				apps: {
-					api: {
-						type: 'backend',
-						path: 'apps/api',
-						port: 3000,
-						dependencies: [],
-						routes: './src/**/*.ts',
-						resolvedDeployTarget: 'dokploy',
-					},
-				},
-				services: {},
-				deploy: { default: 'dokploy' },
-				shared: { packages: [] },
-				secrets: {},
-			};
-
-			const dependents = getDependentFrontends(workspace, 'api');
-			expect(dependents).toEqual([]);
-		});
-	});
-
-	describe('getBackendOpenApiPath', () => {
-		it('should return correct path for backend app', () => {
-			const workspace: NormalizedWorkspace = {
-				name: 'test',
-				root: '/project',
-				apps: {
-					api: {
-						type: 'backend',
-						path: 'apps/api',
-						port: 3000,
-						dependencies: [],
-						routes: './src/**/*.ts',
-						resolvedDeployTarget: 'dokploy',
-					},
-				},
-				services: {},
-				deploy: { default: 'dokploy' },
-				shared: { packages: [] },
-				secrets: {},
-			};
-
-			const path = getBackendOpenApiPath(workspace, 'api');
-			expect(path).toBe('/project/apps/api/.gkm/openapi.ts');
-		});
-
-		it('should return null for non-backend app', () => {
-			const workspace: NormalizedWorkspace = {
-				name: 'test',
-				root: '/project',
-				apps: {
-					web: {
-						type: 'web',
-						path: 'apps/web',
-						port: 3000,
-						dependencies: [],
-						resolvedDeployTarget: 'dokploy',
-					},
-				},
-				services: {},
-				deploy: { default: 'dokploy' },
-				shared: { packages: [] },
-				secrets: {},
-			};
-
-			const path = getBackendOpenApiPath(workspace, 'web');
-			expect(path).toBeNull();
-		});
-
-		it('should return null for non-existent app', () => {
-			const workspace: NormalizedWorkspace = {
-				name: 'test',
-				root: '/project',
-				apps: {},
-				services: {},
-				deploy: { default: 'dokploy' },
-				shared: { packages: [] },
-				secrets: {},
-			};
-
-			const path = getBackendOpenApiPath(workspace, 'nonexistent');
-			expect(path).toBeNull();
-		});
-	});
-});