@geekmidas/cli 1.3.0 → 1.5.0

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

@@ -3,11 +3,17 @@ import { setupServer } from 'msw/node';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type { NormalizedWorkspace } from '../../workspace/types.js';
 import { DokployApi } from '../dokploy-api';
+import {
+	type EnvResolverContext,
+	resolveEnvVar,
+	resolveEnvVars,
+} from '../env-resolver';
 import {
 	generateTag,
 	provisionServices,
 	workspaceDeployCommand,
 } from '../index';
+import { createEmptyState } from '../state';
 import type { DeployOptions } from '../types';
 
 const BASE_URL = 'https://dokploy.example.com';
@@ -77,7 +83,7 @@ describe('provisionServices', () => {
 		expect(result).toBeUndefined();
 	});
 
-	it('should skip postgres when DATABASE_URL already exists', async () => {
+	it('should skip postgres when already provisioned', async () => {
 		const api = new DokployApi({ baseUrl: BASE_URL, token: 'test-token' });
 
 		const result = await provisionServices(
@@ -86,14 +92,14 @@ describe('provisionServices', () => {
 			'env_1',
 			'myapp',
 			{ postgres: true },
-			{ DATABASE_URL: 'postgresql://existing:5432/db' },
+			{ postgresId: 'pg_existing' },
 		);
 
 		// Should return undefined since nothing new was provisioned
 		expect(result).toBeUndefined();
 	});
 
-	it('should skip redis when REDIS_URL already exists', async () => {
+	it('should skip redis when already provisioned', async () => {
 		const api = new DokployApi({ baseUrl: BASE_URL, token: 'test-token' });
 
 		const result = await provisionServices(
@@ -102,7 +108,7 @@ describe('provisionServices', () => {
 			'env_1',
 			'myapp',
 			{ redis: true },
-			{ REDIS_URL: 'redis://existing:6379' },
+			{ redisId: 'redis_existing' },
 		);
 
 		expect(result).toBeUndefined();
@@ -420,6 +426,7 @@ describe('workspaceDeployCommand', () => {
 					path: 'apps/api',
 					port: 3000,
 					dependencies: [],
+					resolvedDeployTarget: 'dokploy',
 				},
 				web: {
 					type: 'frontend',
@@ -427,6 +434,7 @@ describe('workspaceDeployCommand', () => {
 					port: 3001,
 					dependencies: ['api'],
 					framework: 'nextjs',
+					resolvedDeployTarget: 'dokploy',
 				},
 			},
 			services: {},
@@ -508,12 +516,14 @@ describe('workspaceDeployCommand', () => {
 						path: 'apps/api',
 						port: 3000,
 						dependencies: [],
+						resolvedDeployTarget: 'dokploy',
 					},
 					auth: {
 						type: 'backend',
 						path: 'apps/auth',
 						port: 3001,
 						dependencies: [],
+						resolvedDeployTarget: 'dokploy',
 					},
 					web: {
 						type: 'frontend',
@@ -521,6 +531,7 @@ describe('workspaceDeployCommand', () => {
 						port: 3002,
 						dependencies: ['api', 'auth'],
 						framework: 'nextjs',
+						resolvedDeployTarget: 'dokploy',
 					},
 				},
 			});
@@ -546,12 +557,14 @@ describe('workspaceDeployCommand', () => {
 						path: 'apps/db',
 						port: 3000,
 						dependencies: [],
+						resolvedDeployTarget: 'dokploy',
 					},
 					api: {
 						type: 'backend',
 						path: 'apps/api',
 						port: 3001,
 						dependencies: ['db'],
+						resolvedDeployTarget: 'dokploy',
 					},
 					web: {
 						type: 'frontend',
@@ -559,6 +572,7 @@ describe('workspaceDeployCommand', () => {
 						port: 3002,
 						dependencies: ['api'],
 						framework: 'nextjs',
+						resolvedDeployTarget: 'dokploy',
 					},
 				},
 			});
@@ -594,6 +608,116 @@ describe('workspaceDeployCommand', () => {
 			expect(envVars).toContain('AUTH_URL=http://test-workspace-auth:3001');
 		});
 
+		it('should build dependencyUrls from publicUrls for deployed apps', () => {
+			// Test the dependencyUrls building logic used in workspaceDeployCommand
+			const publicUrls: Record<string, string> = {
+				api: 'https://api.example.com',
+				auth: 'https://auth.example.com',
+			};
+
+			const app = {
+				type: 'frontend' as const,
+				path: 'apps/web',
+				port: 3000,
+				dependencies: ['api', 'auth'],
+				framework: 'nextjs' as const,
+			};
+
+			// Build dependency URLs from already-deployed apps (mimics workspaceDeployCommand logic)
+			const dependencyUrls: Record<string, string> = {};
+			if (app.dependencies) {
+				for (const dep of app.dependencies) {
+					if (publicUrls[dep]) {
+						dependencyUrls[dep] = publicUrls[dep];
+					}
+				}
+			}
+
+			expect(dependencyUrls).toEqual({
+				api: 'https://api.example.com',
+				auth: 'https://auth.example.com',
+			});
+		});
+
+		it('should only include dependencies that have been deployed', () => {
+			// Test that dependencyUrls only includes apps that exist in publicUrls
+			const publicUrls: Record<string, string> = {
+				api: 'https://api.example.com',
+				// auth is NOT deployed yet
+			};
+
+			const app = {
+				type: 'frontend' as const,
+				path: 'apps/web',
+				port: 3000,
+				dependencies: ['api', 'auth'], // wants both api and auth
+				framework: 'nextjs' as const,
+			};
+
+			const dependencyUrls: Record<string, string> = {};
+			if (app.dependencies) {
+				for (const dep of app.dependencies) {
+					if (publicUrls[dep]) {
+						dependencyUrls[dep] = publicUrls[dep];
+					}
+				}
+			}
+
+			// Only api should be included, auth is not yet deployed
+			expect(dependencyUrls).toEqual({
+				api: 'https://api.example.com',
+			});
+			expect(dependencyUrls.auth).toBeUndefined();
+		});
+
+		it('should handle apps with no dependencies', () => {
+			const publicUrls: Record<string, string> = {
+				api: 'https://api.example.com',
+			};
+
+			const app = {
+				type: 'backend' as const,
+				path: 'apps/api',
+				port: 3000,
+				dependencies: [], // no dependencies
+			};
+
+			const dependencyUrls: Record<string, string> = {};
+			if (app.dependencies) {
+				for (const dep of app.dependencies) {
+					if (publicUrls[dep]) {
+						dependencyUrls[dep] = publicUrls[dep];
+					}
+				}
+			}
+
+			expect(dependencyUrls).toEqual({});
+		});
+
+		it('should handle apps with undefined dependencies', () => {
+			const publicUrls: Record<string, string> = {
+				api: 'https://api.example.com',
+			};
+
+			const app = {
+				type: 'backend' as const,
+				path: 'apps/api',
+				port: 3000,
+				dependencies: undefined as unknown as string[],
+			};
+
+			const dependencyUrls: Record<string, string> = {};
+			if (app.dependencies) {
+				for (const dep of app.dependencies) {
+					if (publicUrls[dep]) {
+						dependencyUrls[dep] = publicUrls[dep];
+					}
+				}
+			}
+
+			expect(dependencyUrls).toEqual({});
+		});
+
 		it('should inject DATABASE_URL for backend apps', () => {
 			const workspaceName = 'test-workspace';
 			const hasPostgres = true;
@@ -613,7 +737,7 @@ describe('workspaceDeployCommand', () => {
 
 		it('should not inject DATABASE_URL for frontend apps', () => {
 			const hasPostgres = true;
-			const appType: 'backend' | 'frontend' = 'frontend';
+			const appType = 'frontend' as 'backend' | 'frontend';
 
 			const envVars: string[] = [];
 
@@ -702,4 +826,268 @@ describe('workspaceDeployCommand', () => {
 			expect(result.failedCount).toBe(1);
 		});
 	});
+
+	describe('workspace dependencyUrls integration with env resolver', () => {
+		it('should resolve dependency URLs when building env context for an app', () => {
+			// Simulate the scenario where api and auth are deployed, then web needs their URLs
+			const publicUrls: Record<string, string> = {
+				api: 'https://api.myapp.com',
+				auth: 'https://auth.myapp.com',
+			};
+
+			const webApp = {
+				type: 'frontend' as const,
+				path: 'apps/web',
+				port: 3000,
+				dependencies: ['api', 'auth'],
+				framework: 'nextjs' as const,
+				resolvedDeployTarget: 'dokploy' as const,
+			};
+
+			// Build dependencyUrls (as done in workspaceDeployCommand)
+			const dependencyUrls: Record<string, string> = {};
+			for (const dep of webApp.dependencies) {
+				if (publicUrls[dep]) {
+					dependencyUrls[dep] = publicUrls[dep];
+				}
+			}
+
+			// Create env context with dependencyUrls
+			const context: EnvResolverContext = {
+				app: webApp,
+				appName: 'web',
+				stage: 'production',
+				state: createEmptyState('production', 'proj_test', 'env-123'),
+				appHostname: 'web.myapp.com',
+				frontendUrls: [],
+				dependencyUrls,
+			};
+
+			// Resolve API_URL and AUTH_URL
+			expect(resolveEnvVar('API_URL', context)).toBe('https://api.myapp.com');
+			expect(resolveEnvVar('AUTH_URL', context)).toBe('https://auth.myapp.com');
+		});
+
+		it('should resolve multiple env vars including dependency URLs', () => {
+			const publicUrls: Record<string, string> = {
+				api: 'https://api.example.com',
+				payments: 'https://payments.example.com',
+			};
+
+			const webApp = {
+				type: 'frontend' as const,
+				path: 'apps/web',
+				port: 3001,
+				dependencies: ['api', 'payments'],
+				framework: 'nextjs' as const,
+				resolvedDeployTarget: 'dokploy' as const,
+			};
+
+			// Build dependencyUrls
+			const dependencyUrls: Record<string, string> = {};
+			for (const dep of webApp.dependencies) {
+				if (publicUrls[dep]) {
+					dependencyUrls[dep] = publicUrls[dep];
+				}
+			}
+
+			const context: EnvResolverContext = {
+				app: webApp,
+				appName: 'web',
+				stage: 'production',
+				state: createEmptyState('production', 'proj_test', 'env-123'),
+				appHostname: 'web.example.com',
+				frontendUrls: [],
+				dependencyUrls,
+			};
+
+			// Resolve all required vars including dependency URLs
+			const result = resolveEnvVars(
+				['PORT', 'NODE_ENV', 'API_URL', 'PAYMENTS_URL'],
+				context,
+			);
+
+			expect(result.resolved).toEqual({
+				PORT: '3001',
+				NODE_ENV: 'production',
+				API_URL: 'https://api.example.com',
+				PAYMENTS_URL: 'https://payments.example.com',
+			});
+			expect(result.missing).toEqual([]);
+		});
+
+		it('should report missing dependency URLs when dependency not yet deployed', () => {
+			// Scenario: web depends on api and auth, but only api is deployed
+			const publicUrls: Record<string, string> = {
+				api: 'https://api.example.com',
+				// auth is NOT deployed
+			};
+
+			const webApp = {
+				type: 'frontend' as const,
+				path: 'apps/web',
+				port: 3001,
+				dependencies: ['api', 'auth'],
+				framework: 'nextjs' as const,
+				resolvedDeployTarget: 'dokploy' as const,
+			};
+
+			// Build dependencyUrls (auth will be missing)
+			const dependencyUrls: Record<string, string> = {};
+			for (const dep of webApp.dependencies) {
+				if (publicUrls[dep]) {
+					dependencyUrls[dep] = publicUrls[dep];
+				}
+			}
+
+			const context: EnvResolverContext = {
+				app: webApp,
+				appName: 'web',
+				stage: 'production',
+				state: createEmptyState('production', 'proj_test', 'env-123'),
+				appHostname: 'web.example.com',
+				frontendUrls: [],
+				dependencyUrls,
+			};
+
+			const result = resolveEnvVars(['API_URL', 'AUTH_URL'], context);
+
+			expect(result.resolved).toEqual({
+				API_URL: 'https://api.example.com',
+			});
+			expect(result.missing).toEqual(['AUTH_URL']);
+		});
+
+		it('should correctly resolve chain of dependencies (db -> api -> web)', () => {
+			// Simulate deploying in order: db (no deps), api (depends on nothing but needs DATABASE_URL),
+			// then web (depends on api)
+			const publicUrls: Record<string, string> = {};
+			const state = createEmptyState('production', 'proj_test', 'env-123');
+
+			// Step 1: Deploy api first
+			const apiApp = {
+				type: 'backend' as const,
+				path: 'apps/api',
+				port: 3000,
+				dependencies: [],
+				resolvedDeployTarget: 'dokploy' as const,
+			};
+
+			const apiContext: EnvResolverContext = {
+				app: apiApp,
+				appName: 'api',
+				stage: 'production',
+				state,
+				appHostname: 'api.example.com',
+				frontendUrls: [],
+				appCredentials: { dbUser: 'api', dbPassword: 'secret' },
+				postgres: { host: 'db', port: 5432, database: 'myapp' },
+				dependencyUrls: {}, // api has no dependencies
+			};
+
+			const apiResult = resolveEnvVars(
+				['PORT', 'NODE_ENV', 'DATABASE_URL'],
+				apiContext,
+			);
+			expect(apiResult.missing).toEqual([]);
+			expect(apiResult.resolved.DATABASE_URL).toBe(
+				'postgresql://api:secret@db:5432/myapp',
+			);
+
+			// Simulate api is now deployed
+			publicUrls.api = 'https://api.example.com';
+
+			// Step 2: Deploy web (depends on api)
+			const webApp = {
+				type: 'frontend' as const,
+				path: 'apps/web',
+				port: 3001,
+				dependencies: ['api'],
+				framework: 'nextjs' as const,
+				resolvedDeployTarget: 'dokploy' as const,
+			};
+
+			const webDependencyUrls: Record<string, string> = {};
+			for (const dep of webApp.dependencies) {
+				if (publicUrls[dep]) {
+					webDependencyUrls[dep] = publicUrls[dep];
+				}
+			}
+
+			const webContext: EnvResolverContext = {
+				app: webApp,
+				appName: 'web',
+				stage: 'production',
+				state,
+				appHostname: 'web.example.com',
+				frontendUrls: [],
+				dependencyUrls: webDependencyUrls,
+			};
+
+			const webResult = resolveEnvVars(
+				['PORT', 'NODE_ENV', 'API_URL'],
+				webContext,
+			);
+
+			expect(webResult.missing).toEqual([]);
+			expect(webResult.resolved).toEqual({
+				PORT: '3001',
+				NODE_ENV: 'production',
+				API_URL: 'https://api.example.com',
+			});
+		});
+
+		it('should handle microservices topology with multiple inter-dependencies', () => {
+			// Scenario:
+			// - auth service (no deps)
+			// - api service (depends on auth)
+			// - notifications service (depends on api)
+			// - web (depends on api, auth, notifications)
+			const publicUrls: Record<string, string> = {
+				auth: 'https://auth.example.com',
+				api: 'https://api.example.com',
+				notifications: 'https://notifications.example.com',
+			};
+
+			const webApp = {
+				type: 'frontend' as const,
+				path: 'apps/web',
+				port: 3000,
+				dependencies: ['api', 'auth', 'notifications'],
+				framework: 'nextjs' as const,
+				resolvedDeployTarget: 'dokploy' as const,
+			};
+
+			// Build dependencyUrls for web
+			const dependencyUrls: Record<string, string> = {};
+			for (const dep of webApp.dependencies) {
+				if (publicUrls[dep]) {
+					dependencyUrls[dep] = publicUrls[dep];
+				}
+			}
+
+			const context: EnvResolverContext = {
+				app: webApp,
+				appName: 'web',
+				stage: 'production',
+				state: createEmptyState('production', 'proj_test', 'env-123'),
+				appHostname: 'web.example.com',
+				frontendUrls: [],
+				dependencyUrls,
+			};
+
+			const result = resolveEnvVars(
+				['PORT', 'API_URL', 'AUTH_URL', 'NOTIFICATIONS_URL'],
+				context,
+			);
+
+			expect(result.missing).toEqual([]);
+			expect(result.resolved).toEqual({
+				PORT: '3000',
+				API_URL: 'https://api.example.com',
+				AUTH_URL: 'https://auth.example.com',
+				NOTIFICATIONS_URL: 'https://notifications.example.com',
+			});
+		});
+	});
 });