@geekmidas/cli 1.2.2 → 1.2.3

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

@@ -1,11 +1,18 @@
-import { existsSync, mkdirSync, rmSync } from 'node:fs';
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import {
-	clearSpecHashCache,
-	generateClientForFrontend,
+	copyAllClients,
+	copyClientToFrontends,
 	getBackendDependencies,
+	getBackendOpenApiPath,
 	getDependentFrontends,
 	getFirstRoute,
 	normalizeRoutes,
@@ -264,7 +271,71 @@ describe('Client Generator', () => {
 		});
 	});
 
-	describe('generateClientForFrontend', () => {
+	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: 'frontend',
+						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();
+		});
+	});
+
+	describe('copyClientToFrontends', () => {
 		let testDir: string;
 
 		beforeEach(() => {
@@ -273,7 +344,6 @@ describe('Client Generator', () => {
 				`gkm-client-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
 			);
 			mkdirSync(testDir, { recursive: true });
-			clearSpecHashCache();
 		});
 
 		afterEach(() => {
@@ -282,16 +352,57 @@ describe('Client Generator', () => {
 			}
 		});
 
-		it('should return empty array for frontend with no backend dependencies', async () => {
+		function createOpenApiFile(
+			appDir: string,
+			endpoints: Array<{ method: string; path: string }>,
+		): void {
+			const endpointAuthEntries = endpoints
+				.map((ep) => `  '${ep.method.toUpperCase()} ${ep.path}': null,`)
+				.join('\n');
+
+			const content = `// Auto-generated by @geekmidas/cli - DO NOT EDIT
+
+export const endpointAuth = {
+${endpointAuthEntries}
+} as const;
+
+export const paths = {};
+export function createApi() { return {}; }
+`;
+
+			const gkmDir = join(appDir, '.gkm');
+			mkdirSync(gkmDir, { recursive: true });
+			writeFileSync(join(gkmDir, 'openapi.ts'), content);
+		}
+
+		it('should copy client to dependent frontends', async () => {
+			const apiDir = join(testDir, 'apps/api');
+			const webDir = join(testDir, 'apps/web');
+			mkdirSync(webDir, { recursive: true });
+
+			createOpenApiFile(apiDir, [
+				{ method: 'GET', path: '/users' },
+				{ method: 'POST', path: '/users' },
+			]);
+
 			const workspace: NormalizedWorkspace = {
 				name: 'test',
 				root: testDir,
 				apps: {
+					api: {
+						type: 'backend',
+						path: 'apps/api',
+						port: 3000,
+						dependencies: [],
+						routes: './src/endpoints/**/*.ts',
+						resolvedDeployTarget: 'dokploy',
+					},
 					web: {
 						type: 'frontend',
 						path: 'apps/web',
 						port: 3001,
-						dependencies: [],
+						dependencies: ['api'],
+						client: { output: 'src/api' },
 						resolvedDeployTarget: 'dokploy',
 					},
 				},
@@ -301,11 +412,25 @@ describe('Client Generator', () => {
 				secrets: {},
 			};
 
-			const results = await generateClientForFrontend(workspace, 'web');
-			expect(results).toEqual([]);
+			const results = await copyClientToFrontends(workspace, 'api', {
+				silent: true,
+			});
+
+			expect(results).toHaveLength(1);
+			expect(results[0]?.success).toBe(true);
+			expect(results[0]?.frontendApp).toBe('web');
+			expect(results[0]?.backendApp).toBe('api');
+			expect(results[0]?.endpointCount).toBe(2);
+			expect(existsSync(join(webDir, 'src/api/api.ts'))).toBe(true);
 		});
 
-		it('should return empty array for non-frontend app', async () => {
+		it('should skip frontends without client.output configured', async () => {
+			const apiDir = join(testDir, 'apps/api');
+			const webDir = join(testDir, 'apps/web');
+			mkdirSync(webDir, { recursive: true });
+
+			createOpenApiFile(apiDir, [{ method: 'GET', path: '/users' }]);
+
 			const workspace: NormalizedWorkspace = {
 				name: 'test',
 				root: testDir,
@@ -315,7 +440,15 @@ describe('Client Generator', () => {
 						path: 'apps/api',
 						port: 3000,
 						dependencies: [],
-						routes: './src/**/*.ts',
+						routes: './src/endpoints/**/*.ts',
+						resolvedDeployTarget: 'dokploy',
+					},
+					web: {
+						type: 'frontend',
+						path: 'apps/web',
+						port: 3001,
+						dependencies: ['api'],
+						// No client.output configured
 						resolvedDeployTarget: 'dokploy',
 					},
 				},
@@ -325,16 +458,45 @@ describe('Client Generator', () => {
 				secrets: {},
 			};
 
-			const results = await generateClientForFrontend(workspace, 'api');
+			const results = await copyClientToFrontends(workspace, 'api', {
+				silent: true,
+			});
+
+			expect(results).toHaveLength(0);
+		});
+
+		it('should return empty results for non-backend app', async () => {
+			const workspace: NormalizedWorkspace = {
+				name: 'test',
+				root: testDir,
+				apps: {
+					web: {
+						type: 'frontend',
+						path: 'apps/web',
+						port: 3001,
+						dependencies: [],
+						resolvedDeployTarget: 'dokploy',
+					},
+				},
+				services: {},
+				deploy: { default: 'dokploy' },
+				shared: { packages: [] },
+				secrets: {},
+			};
+
+			const results = await copyClientToFrontends(workspace, 'web', {
+				silent: true,
+			});
+
 			expect(results).toEqual([]);
 		});
 
-		it('should use configured client output path', async () => {
-			// Create minimal workspace structure
+		it('should return empty results when openapi file does not exist', async () => {
 			const apiDir = join(testDir, 'apps/api');
 			const webDir = join(testDir, 'apps/web');
-			mkdirSync(join(apiDir, 'src/endpoints'), { recursive: true });
+			mkdirSync(apiDir, { recursive: true });
 			mkdirSync(webDir, { recursive: true });
+			// Don't create openapi file
 
 			const workspace: NormalizedWorkspace = {
 				name: 'test',
@@ -353,7 +515,7 @@ describe('Client Generator', () => {
 						path: 'apps/web',
 						port: 3001,
 						dependencies: ['api'],
-						client: { output: 'lib/api' },
+						client: { output: 'src/api' },
 						resolvedDeployTarget: 'dokploy',
 					},
 				},
@@ -363,58 +525,25 @@ describe('Client Generator', () => {
 				secrets: {},
 			};
 
-			// This will fail to generate because there are no endpoints,
-			// but we can verify the output path would be correct
-			const results = await generateClientForFrontend(workspace, 'web');
-			expect(results).toHaveLength(1);
-			expect(results[0]?.reason).toBe('No endpoints found in backend');
-		});
-	});
-
-	describe('hot reload - hash-based change detection', () => {
-		let testDir: string;
+			const results = await copyClientToFrontends(workspace, 'api', {
+				silent: true,
+			});
 
-		beforeEach(() => {
-			testDir = join(
-				tmpdir(),
-				`gkm-hotreload-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-			);
-			mkdirSync(testDir, { recursive: true });
-			clearSpecHashCache();
+			expect(results).toEqual([]);
 		});
 
-		afterEach(() => {
-			if (existsSync(testDir)) {
-				rmSync(testDir, { recursive: true, force: true });
-			}
-		});
+		it('should copy to multiple frontends', async () => {
+			const apiDir = join(testDir, 'apps/api');
+			const webDir = join(testDir, 'apps/web');
+			const adminDir = join(testDir, 'apps/admin');
+			mkdirSync(webDir, { recursive: true });
+			mkdirSync(adminDir, { recursive: true });
 
-		function createEndpointFile(
-			dir: string,
-			filename: string,
-			exportName: string,
-			path: string,
-			method: string,
-		): void {
-			const content = `
-import { e } from '@geekmidas/constructs/endpoints';
-import { z } from 'zod';
-
-export const ${exportName} = e
-  .${method.toLowerCase()}('${path}')
-  .output(z.object({ message: z.string() }))
-  .handle(async () => ({ message: 'Hello' }));
-`;
-			const { writeFileSync } = require('node:fs');
-			const { dirname } = require('node:path');
-			mkdirSync(dirname(join(dir, filename)), { recursive: true });
-			writeFileSync(join(dir, filename), content);
-		}
+			createOpenApiFile(apiDir, [{ method: 'GET', path: '/users' }]);
 
-		function createWorkspace(root: string): NormalizedWorkspace {
-			return {
+			const workspace: NormalizedWorkspace = {
 				name: 'test',
-				root,
+				root: testDir,
 				apps: {
 					api: {
 						type: 'backend',
@@ -432,202 +561,80 @@ export const ${exportName} = e
 						client: { output: 'src/api' },
 						resolvedDeployTarget: 'dokploy',
 					},
+					admin: {
+						type: 'frontend',
+						path: 'apps/admin',
+						port: 3002,
+						dependencies: ['api'],
+						client: { output: 'lib/client' },
+						resolvedDeployTarget: 'dokploy',
+					},
 				},
 				services: {},
 				deploy: { default: 'dokploy' },
 				shared: { packages: [] },
 				secrets: {},
 			};
-		}
 
-		it('should generate client on first call', async () => {
-			const apiDir = join(testDir, 'apps/api');
-			const webDir = join(testDir, 'apps/web');
-			mkdirSync(webDir, { recursive: true });
-
-			createEndpointFile(
-				apiDir,
-				'src/endpoints/users.ts',
-				'getUsers',
-				'/users',
-				'GET',
-			);
-
-			const workspace = createWorkspace(testDir);
-			const results = await generateClientForFrontend(workspace, 'web', {
-				force: true,
+			const results = await copyClientToFrontends(workspace, 'api', {
+				silent: true,
 			});
 
-			expect(results).toHaveLength(1);
-			expect(results[0]?.generated).toBe(true);
-			expect(results[0]?.endpointCount).toBe(1);
-			expect(existsSync(join(webDir, 'src/api/openapi.ts'))).toBe(true);
-		});
-
-		it('should skip regeneration when schema has not changed', async () => {
-			const apiDir = join(testDir, 'apps/api');
-			const webDir = join(testDir, 'apps/web');
-			mkdirSync(webDir, { recursive: true });
-
-			createEndpointFile(
-				apiDir,
-				'src/endpoints/users.ts',
-				'getUsers',
-				'/users',
-				'GET',
-			);
-
-			const workspace = createWorkspace(testDir);
-
-			// First call - should generate
-			const firstResults = await generateClientForFrontend(workspace, 'web', {
-				force: true,
-			});
-			expect(firstResults[0]?.generated).toBe(true);
-
-			// Second call - should skip (no changes)
-			const secondResults = await generateClientForFrontend(workspace, 'web');
-			expect(secondResults[0]?.generated).toBe(false);
-			expect(secondResults[0]?.reason).toBe('No schema changes detected');
-		});
-
-		it('should regenerate when endpoint schema changes', async () => {
-			const apiDir = join(testDir, 'apps/api');
-			const webDir = join(testDir, 'apps/web');
-			mkdirSync(webDir, { recursive: true });
-
-			createEndpointFile(
-				apiDir,
-				'src/endpoints/users.ts',
-				'getUsers',
-				'/users',
-				'GET',
-			);
-
-			const workspace = createWorkspace(testDir);
-
-			// First call - generate initial client
-			const firstResults = await generateClientForFrontend(workspace, 'web', {
-				force: true,
-			});
-			expect(firstResults[0]?.generated).toBe(true);
-
-			// Second call without changes - should skip
-			const secondResults = await generateClientForFrontend(workspace, 'web');
-			expect(secondResults[0]?.generated).toBe(false);
-
-			// Modify endpoint - add new route
-			createEndpointFile(
-				apiDir,
-				'src/endpoints/posts.ts',
-				'getPosts',
-				'/posts',
-				'GET',
-			);
-
-			// Third call - should regenerate due to schema change
-			const thirdResults = await generateClientForFrontend(workspace, 'web');
-			expect(thirdResults[0]?.generated).toBe(true);
-			expect(thirdResults[0]?.endpointCount).toBe(2);
+			expect(results).toHaveLength(2);
+			expect(results.every((r) => r.success)).toBe(true);
+			expect(existsSync(join(webDir, 'src/api/api.ts'))).toBe(true);
+			expect(existsSync(join(adminDir, 'lib/client/api.ts'))).toBe(true);
 		});
 
-		it('should regenerate when endpoint path changes (via new file)', async () => {
+		it('should add header comment to copied file', async () => {
 			const apiDir = join(testDir, 'apps/api');
 			const webDir = join(testDir, 'apps/web');
 			mkdirSync(webDir, { recursive: true });
 
-			createEndpointFile(
-				apiDir,
-				'src/endpoints/users.ts',
-				'getUsers',
-				'/users',
-				'GET',
-			);
-
-			const workspace = createWorkspace(testDir);
-
-			// First call
-			await generateClientForFrontend(workspace, 'web', { force: true });
-
-			// Second call - skip
-			const skipResult = await generateClientForFrontend(workspace, 'web');
-			expect(skipResult[0]?.generated).toBe(false);
-
-			// Add endpoint with different path (new file to avoid ESM cache)
-			// This simulates what happens when a developer changes a path -
-			// in real dev server, the watcher would reload the module
-			createEndpointFile(
-				apiDir,
-				'src/endpoints/api-users.ts',
-				'getApiUsers',
-				'/api/users',
-				'GET',
-			);
+			createOpenApiFile(apiDir, [{ method: 'GET', path: '/users' }]);
 
-			// Third call - should regenerate because schema changed
-			const regenerateResult = await generateClientForFrontend(
-				workspace,
-				'web',
-			);
-			expect(regenerateResult[0]?.generated).toBe(true);
-			expect(regenerateResult[0]?.endpointCount).toBe(2); // Now has 2 endpoints
-		});
-
-		it('should skip when only handler implementation changes', async () => {
-			const apiDir = join(testDir, 'apps/api');
-			const webDir = join(testDir, 'apps/web');
-			mkdirSync(webDir, { recursive: true });
-
-			createEndpointFile(
-				apiDir,
-				'src/endpoints/users.ts',
-				'getUsers',
-				'/users',
-				'GET',
-			);
+			const workspace: NormalizedWorkspace = {
+				name: 'test',
+				root: testDir,
+				apps: {
+					api: {
+						type: 'backend',
+						path: 'apps/api',
+						port: 3000,
+						dependencies: [],
+						routes: './src/endpoints/**/*.ts',
+						resolvedDeployTarget: 'dokploy',
+					},
+					web: {
+						type: 'frontend',
+						path: 'apps/web',
+						port: 3001,
+						dependencies: ['api'],
+						client: { output: 'src/api' },
+						resolvedDeployTarget: 'dokploy',
+					},
+				},
+				services: {},
+				deploy: { default: 'dokploy' },
+				shared: { packages: [] },
+				secrets: {},
+			};
 
-			const workspace = createWorkspace(testDir);
-
-			// First call
-			await generateClientForFrontend(workspace, 'web', { force: true });
-
-			// Change only the handler implementation (not the schema)
-			const { writeFileSync } = require('node:fs');
-			const modifiedContent = `
-import { e } from '@geekmidas/constructs/endpoints';
-import { z } from 'zod';
-
-export const getUsers = e
-  .get('/users')
-  .output(z.object({ message: z.string() }))
-  .handle(async () => {
-    // Different implementation - added a comment and console.log
-    console.log('Getting users');
-    return { message: 'Hello World' };
-  });
-`;
-			writeFileSync(join(apiDir, 'src/endpoints/users.ts'), modifiedContent);
+			await copyClientToFrontends(workspace, 'api', { silent: true });
 
-			// Second call - should skip (schema unchanged, only implementation changed)
-			const results = await generateClientForFrontend(workspace, 'web');
-			expect(results[0]?.generated).toBe(false);
-			expect(results[0]?.reason).toBe('No schema changes detected');
+			const content = readFileSync(join(webDir, 'src/api/api.ts'), 'utf-8');
+			expect(content).toContain('Auto-generated API client for api');
+			expect(content).toContain('DO NOT EDIT');
 		});
 
-		it('should regenerate for multiple frontends when backend changes', async () => {
+		it('should use backend name in filename when frontend has multiple backends', async () => {
 			const apiDir = join(testDir, 'apps/api');
+			const authDir = join(testDir, 'apps/auth');
 			const webDir = join(testDir, 'apps/web');
-			const adminDir = join(testDir, 'apps/admin');
 			mkdirSync(webDir, { recursive: true });
-			mkdirSync(adminDir, { recursive: true });
 
-			createEndpointFile(
-				apiDir,
-				'src/endpoints/users.ts',
-				'getUsers',
-				'/users',
-				'GET',
-			);
+			createOpenApiFile(apiDir, [{ method: 'GET', path: '/users' }]);
+			createOpenApiFile(authDir, [{ method: 'POST', path: '/login' }]);
 
 			const workspace: NormalizedWorkspace = {
 				name: 'test',
@@ -641,20 +648,20 @@ export const getUsers = e
 						routes: './src/endpoints/**/*.ts',
 						resolvedDeployTarget: 'dokploy',
 					},
-					web: {
-						type: 'frontend',
-						path: 'apps/web',
+					auth: {
+						type: 'backend',
+						path: 'apps/auth',
 						port: 3001,
-						dependencies: ['api'],
-						client: { output: 'src/api' },
+						dependencies: [],
+						routes: './src/endpoints/**/*.ts',
 						resolvedDeployTarget: 'dokploy',
 					},
-					admin: {
+					web: {
 						type: 'frontend',
-						path: 'apps/admin',
+						path: 'apps/web',
 						port: 3002,
-						dependencies: ['api'],
-						client: { output: 'src/client' },
+						dependencies: ['api', 'auth'], // Multiple backends
+						client: { output: 'src/api' },
 						resolvedDeployTarget: 'dokploy',
 					},
 				},
@@ -664,33 +671,56 @@ export const getUsers = e
 				secrets: {},
 			};
 
-			// Generate for both frontends
-			await generateClientForFrontend(workspace, 'web', { force: true });
-			await generateClientForFrontend(workspace, 'admin', { force: true });
-
-			// Both should skip
-			const webSkip = await generateClientForFrontend(workspace, 'web');
-			const adminSkip = await generateClientForFrontend(workspace, 'admin');
-			expect(webSkip[0]?.generated).toBe(false);
-			expect(adminSkip[0]?.generated).toBe(false);
-
-			// Add new endpoint
-			createEndpointFile(
-				apiDir,
-				'src/endpoints/products.ts',
-				'getProducts',
-				'/products',
-				'GET',
+			await copyClientToFrontends(workspace, 'api', { silent: true });
+			await copyClientToFrontends(workspace, 'auth', { silent: true });
+
+			// Should use {backend}.ts naming
+			expect(existsSync(join(webDir, 'src/api/api.ts'))).toBe(true);
+			expect(existsSync(join(webDir, 'src/api/auth.ts'))).toBe(true);
+		});
+	});
+
+	describe('copyAllClients', () => {
+		let testDir: string;
+
+		beforeEach(() => {
+			testDir = join(
+				tmpdir(),
+				`gkm-client-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
 			);
+			mkdirSync(testDir, { recursive: true });
+		});
 
-			// Both should regenerate
-			const webRegen = await generateClientForFrontend(workspace, 'web');
-			const adminRegen = await generateClientForFrontend(workspace, 'admin');
-			expect(webRegen[0]?.generated).toBe(true);
-			expect(adminRegen[0]?.generated).toBe(true);
+		afterEach(() => {
+			if (existsSync(testDir)) {
+				rmSync(testDir, { recursive: true, force: true });
+			}
 		});
 
-		it('should only regenerate affected frontend when specific backend changes', async () => {
+		function createOpenApiFile(
+			appDir: string,
+			endpoints: Array<{ method: string; path: string }>,
+		): void {
+			const endpointAuthEntries = endpoints
+				.map((ep) => `  '${ep.method.toUpperCase()} ${ep.path}': null,`)
+				.join('\n');
+
+			const content = `// Auto-generated by @geekmidas/cli - DO NOT EDIT
+
+export const endpointAuth = {
+${endpointAuthEntries}
+} as const;
+
+export const paths = {};
+export function createApi() { return {}; }
+`;
+
+			const gkmDir = join(appDir, '.gkm');
+			mkdirSync(gkmDir, { recursive: true });
+			writeFileSync(join(gkmDir, 'openapi.ts'), content);
+		}
+
+		it('should copy from all backends to their dependent frontends', async () => {
 			const apiDir = join(testDir, 'apps/api');
 			const authDir = join(testDir, 'apps/auth');
 			const webDir = join(testDir, 'apps/web');
@@ -698,20 +728,8 @@ export const getUsers = e
 			mkdirSync(webDir, { recursive: true });
 			mkdirSync(adminDir, { recursive: true });
 
-			createEndpointFile(
-				apiDir,
-				'src/endpoints/users.ts',
-				'getUsers',
-				'/users',
-				'GET',
-			);
-			createEndpointFile(
-				authDir,
-				'src/endpoints/login.ts',
-				'login',
-				'/login',
-				'POST',
-			);
+			createOpenApiFile(apiDir, [{ method: 'GET', path: '/users' }]);
+			createOpenApiFile(authDir, [{ method: 'POST', path: '/login' }]);
 
 			const workspace: NormalizedWorkspace = {
 				name: 'test',
@@ -737,7 +755,7 @@ export const getUsers = e
 						type: 'frontend',
 						path: 'apps/web',
 						port: 3002,
-						dependencies: ['api'], // Only depends on api
+						dependencies: ['api'],
 						client: { output: 'src/api' },
 						resolvedDeployTarget: 'dokploy',
 					},
@@ -745,8 +763,8 @@ export const getUsers = e
 						type: 'frontend',
 						path: 'apps/admin',
 						port: 3003,
-						dependencies: ['auth'], // Only depends on auth
-						client: { output: 'src/client' },
+						dependencies: ['auth'],
+						client: { output: 'lib/client' },
 						resolvedDeployTarget: 'dokploy',
 					},
 				},
@@ -756,26 +774,37 @@ export const getUsers = e
 				secrets: {},
 			};
 
-			// Initial generation
-			await generateClientForFrontend(workspace, 'web', { force: true });
-			await generateClientForFrontend(workspace, 'admin', { force: true });
-
-			// Change only the api backend
-			createEndpointFile(
-				apiDir,
-				'src/endpoints/products.ts',
-				'getProducts',
-				'/products',
-				'GET',
-			);
+			const results = await copyAllClients(workspace, { silent: true });
+
+			expect(results).toHaveLength(2);
+			expect(results.every((r) => r.success)).toBe(true);
+			expect(existsSync(join(webDir, 'src/api/api.ts'))).toBe(true);
+			expect(existsSync(join(adminDir, 'lib/client/auth.ts'))).toBe(true);
+		});
+
+		it('should return empty array when no backends have routes', async () => {
+			const workspace: NormalizedWorkspace = {
+				name: 'test',
+				root: testDir,
+				apps: {
+					worker: {
+						type: 'backend',
+						path: 'apps/worker',
+						port: 3000,
+						dependencies: [],
+						// No routes
+						resolvedDeployTarget: 'dokploy',
+					},
+				},
+				services: {},
+				deploy: { default: 'dokploy' },
+				shared: { packages: [] },
+				secrets: {},
+			};
 
-			// web should regenerate (depends on api)
-			const webResult = await generateClientForFrontend(workspace, 'web');
-			expect(webResult[0]?.generated).toBe(true);
+			const results = await copyAllClients(workspace, { silent: true });
 
-			// admin should skip (depends on auth, which didn't change)
-			const adminResult = await generateClientForFrontend(workspace, 'admin');
-			expect(adminResult[0]?.generated).toBe(false);
+			expect(results).toEqual([]);
 		});
 	});
 });