@geekmidas/cli 9.0.2 → 10.0.0-alpha.0

package/src/workspace/__tests__/type-inference.spec.ts

@@ -1,251 +0,0 @@
-import { describe, expect, expectTypeOf, it } from 'vitest';
-import { defineWorkspace } from '../index.js';
-import type { InferAppNames, InferredWorkspaceConfig } from '../types.js';
-
-describe('Type Inference', () => {
-	describe('defineWorkspace type inference', () => {
-		it('should infer app names as literal types', () => {
-			const config = defineWorkspace({
-				apps: {
-					api: {
-						type: 'backend',
-						path: 'apps/api',
-						port: 3000,
-						routes: './src/**/*.ts',
-					},
-					web: {
-						type: 'web',
-						path: 'apps/web',
-						port: 3001,
-						framework: 'nextjs',
-					},
-				},
-			});
-
-			// Type-level test: apps should have 'api' and 'web' as keys
-			expectTypeOf(config.apps).toHaveProperty('api');
-			expectTypeOf(config.apps).toHaveProperty('web');
-
-			// Runtime test
-			expect(Object.keys(config.apps)).toEqual(['api', 'web']);
-		});
-
-		it('should allow valid dependencies', () => {
-			const config = defineWorkspace({
-				apps: {
-					api: {
-						type: 'backend',
-						path: 'apps/api',
-						port: 3000,
-						routes: './src/**/*.ts',
-					},
-					auth: {
-						type: 'backend',
-						path: 'apps/auth',
-						port: 3001,
-						routes: './src/**/*.ts',
-					},
-					web: {
-						type: 'web',
-						path: 'apps/web',
-						port: 3002,
-						framework: 'nextjs',
-						dependencies: ['api', 'auth'],
-					},
-				},
-			});
-
-			expect(config.apps.web.dependencies).toEqual(['api', 'auth']);
-		});
-
-		it('should throw error for invalid dependency at runtime', () => {
-			expect(() =>
-				defineWorkspace({
-					apps: {
-						api: {
-							type: 'backend',
-							path: 'apps/api',
-							port: 3000,
-							routes: './src/**/*.ts',
-						},
-						web: {
-							type: 'web',
-							path: 'apps/web',
-							port: 3001,
-							framework: 'nextjs',
-							dependencies: ['nonexistent'],
-						},
-					},
-				}),
-			).toThrow(/Invalid dependency.*"nonexistent"/);
-		});
-
-		it('should throw error for self-dependency at runtime', () => {
-			expect(() =>
-				defineWorkspace({
-					apps: {
-						api: {
-							type: 'backend',
-							path: 'apps/api',
-							port: 3000,
-							routes: './src/**/*.ts',
-							dependencies: ['api'],
-						},
-					},
-				}),
-			).toThrow(/cannot depend on itself/);
-		});
-
-		it('should preserve all config properties with inference', () => {
-			const config = defineWorkspace({
-				name: 'my-workspace',
-				apps: {
-					api: {
-						type: 'backend',
-						path: 'apps/api',
-						port: 3000,
-						routes: './src/**/*.ts',
-						envParser: './src/env',
-						logger: './src/logger',
-						telescope: { enabled: true, port: 9000 },
-					},
-				},
-				services: {
-					db: true,
-					cache: { version: '7.2' },
-				},
-				deploy: {
-					default: 'dokploy',
-				},
-			});
-
-			expect(config.name).toBe('my-workspace');
-			expect(config.apps.api.envParser).toBe('./src/env');
-			expect(config.apps.api.telescope).toEqual({ enabled: true, port: 9000 });
-			expect(config.services?.db).toBe(true);
-			expect(config.deploy?.default).toBe('dokploy');
-		});
-	});
-
-	describe('InferAppNames type utility', () => {
-		it('should extract app names as union type', () => {
-			type TestApps = {
-				api: { path: string; port: number };
-				web: { path: string; port: number };
-				worker: { path: string; port: number };
-			};
-
-			type AppNames = InferAppNames<TestApps>;
-
-			// Type-level assertion: AppNames should be 'api' | 'web' | 'worker'
-			expectTypeOf<AppNames>().toEqualTypeOf<'api' | 'web' | 'worker'>();
-		});
-	});
-
-	describe('InferredWorkspaceConfig type utility', () => {
-		it('should create correct inferred config type', () => {
-			type TestApps = {
-				api: { path: string; port: number; routes: string };
-				web: { path: string; port: number; framework: 'nextjs' };
-			};
-
-			type Inferred = InferredWorkspaceConfig<TestApps>;
-
-			// The inferred type should have the same structure
-			expectTypeOf<Inferred['apps']['api']>().toHaveProperty('path');
-			expectTypeOf<Inferred['apps']['web']>().toHaveProperty('framework');
-
-			// Dependencies should be typed as 'api' | 'web'
-			type WebDeps = NonNullable<Inferred['apps']['web']['dependencies']>;
-			expectTypeOf<WebDeps>().toEqualTypeOf<('api' | 'web')[]>();
-		});
-	});
-
-	describe('Complex workspace scenarios', () => {
-		it('should handle workspace with multiple backend and frontend apps', () => {
-			const config = defineWorkspace({
-				name: 'complex-saas',
-				apps: {
-					'api-gateway': {
-						type: 'backend',
-						path: 'apps/api-gateway',
-						port: 3000,
-						routes: './src/**/*.ts',
-					},
-					'user-service': {
-						type: 'backend',
-						path: 'apps/user-service',
-						port: 3001,
-						routes: './src/**/*.ts',
-					},
-					'payment-service': {
-						type: 'backend',
-						path: 'apps/payment-service',
-						port: 3002,
-						routes: './src/**/*.ts',
-						dependencies: ['user-service'],
-					},
-					'web-app': {
-						type: 'web',
-						path: 'apps/web',
-						port: 3003,
-						framework: 'nextjs',
-						dependencies: ['api-gateway'],
-					},
-					'admin-dashboard': {
-						type: 'web',
-						path: 'apps/admin',
-						port: 3004,
-						framework: 'nextjs',
-						dependencies: ['api-gateway', 'user-service'],
-					},
-				},
-				services: {
-					db: { version: '16-alpine' },
-					cache: true,
-					mail: { smtp: { host: 'smtp.example.com', port: 587 } },
-				},
-			});
-
-			expect(Object.keys(config.apps)).toHaveLength(5);
-			expect(config.apps['payment-service'].dependencies).toEqual([
-				'user-service',
-			]);
-			expect(config.apps['admin-dashboard'].dependencies).toEqual([
-				'api-gateway',
-				'user-service',
-			]);
-		});
-
-		it('should handle empty dependencies array', () => {
-			const config = defineWorkspace({
-				apps: {
-					api: {
-						type: 'backend',
-						path: 'apps/api',
-						port: 3000,
-						routes: './src/**/*.ts',
-						dependencies: [],
-					},
-				},
-			});
-
-			expect(config.apps.api.dependencies).toEqual([]);
-		});
-
-		it('should handle undefined dependencies', () => {
-			const config = defineWorkspace({
-				apps: {
-					api: {
-						type: 'backend',
-						path: 'apps/api',
-						port: 3000,
-						routes: './src/**/*.ts',
-					},
-				},
-			});
-
-			expect(config.apps.api.dependencies).toBeUndefined();
-		});
-	});
-});

package/src/workspace/client-generator.ts

@@ -1,109 +0,0 @@
-import { join } from 'node:path';
-import { isPartitionedRoutes, type Routes } from '../types.js';
-import type { NormalizedWorkspace } from './types.js';
-
-/**
- * Normalize routes to an array of patterns.
- * Handles string, string[], and PartitionedRoutes (extracts paths).
- * @internal Exported for use in dev command
- */
-export function normalizeRoutes(routes: Routes | undefined): string[] {
-	if (!routes) return [];
-	if (isPartitionedRoutes(routes)) {
-		return Array.isArray(routes.paths) ? routes.paths : [routes.paths];
-	}
-	return Array.isArray(routes) ? routes : [routes];
-}
-
-/**
- * Get the first routes pattern as a string (for simple cases).
- * @internal Exported for use in dev command
- */
-export function getFirstRoute(
-	routes: string | string[] | undefined,
-): string | null {
-	const normalized = normalizeRoutes(routes);
-	return normalized[0] || null;
-}
-
-/**
- * Check if a file path matches endpoint patterns that could affect OpenAPI schema.
- * Returns true for changes that should trigger client regeneration.
- */
-export function shouldRegenerateClient(
-	filePath: string,
-	routesPattern: string,
-): boolean {
-	// Normalize path separators
-	const normalizedPath = filePath.replace(/\\/g, '/');
-	const normalizedPattern = routesPattern.replace(/\\/g, '/');
-
-	// Check if the file matches the routes pattern
-	// This is a simple check - the file should be within the routes directory
-	const patternDir = normalizedPattern.split('*')[0] || '';
-
-	if (!normalizedPath.includes(patternDir.replace('./', ''))) {
-		return false;
-	}
-
-	// Check file extension - only TypeScript endpoint files
-	if (!normalizedPath.endsWith('.ts') && !normalizedPath.endsWith('.tsx')) {
-		return false;
-	}
-
-	return true;
-}
-
-/**
- * Get backend apps that a web/mobile client depends on.
- */
-export function getBackendDependencies(
-	workspace: NormalizedWorkspace,
-	clientAppName: string,
-): string[] {
-	const clientApp = workspace.apps[clientAppName];
-	if (!clientApp || (clientApp.type !== 'web' && clientApp.type !== 'mobile')) {
-		return [];
-	}
-
-	return clientApp.dependencies.filter((dep) => {
-		const depApp = workspace.apps[dep];
-		return depApp?.type === 'backend' && depApp.routes;
-	});
-}
-
-/**
- * Get web/mobile apps that depend on a backend app.
- */
-export function getDependentFrontends(
-	workspace: NormalizedWorkspace,
-	backendAppName: string,
-): string[] {
-	const dependentApps: string[] = [];
-
-	for (const [appName, app] of Object.entries(workspace.apps)) {
-		if (
-			(app.type === 'web' || app.type === 'mobile') &&
-			app.dependencies.includes(backendAppName)
-		) {
-			dependentApps.push(appName);
-		}
-	}
-
-	return dependentApps;
-}
-
-/**
- * Get the path to a backend's OpenAPI spec file.
- */
-export function getBackendOpenApiPath(
-	workspace: NormalizedWorkspace,
-	backendAppName: string,
-): string | null {
-	const app = workspace.apps[backendAppName];
-	if (!app || app.type !== 'backend') {
-		return null;
-	}
-
-	return join(workspace.root, app.path, '.gkm', 'openapi.ts');
-}