@geekmidas/cli 1.3.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs",
   "private": false,
   "type": "module",
@@ -56,8 +56,8 @@
     "@geekmidas/constructs": "~1.0.0",
     "@geekmidas/envkit": "~1.0.0",
     "@geekmidas/errors": "~1.0.0",
-    "@geekmidas/logger": "~1.0.0",
-    "@geekmidas/schema": "~1.0.0"
+    "@geekmidas/schema": "~1.0.0",
+    "@geekmidas/logger": "~1.0.0"
   },
   "devDependencies": {
     "@types/lodash.kebabcase": "^4.1.9",

package/src/deploy/__tests__/env-resolver.spec.ts

@@ -295,6 +295,9 @@ describe('resolveEnvVar', () => {
 	it('should resolve custom variable from userSecrets.custom', () => {
 		const context = createContext({
 			userSecrets: {
+				stage: 'production',
+				createdAt: '2024-01-01T00:00:00Z',
+				updatedAt: '2024-01-01T00:00:00Z',
 				custom: { MY_API_KEY: 'secret-api-key' },
 				urls: {},
 				services: {},
@@ -307,6 +310,9 @@ describe('resolveEnvVar', () => {
 	it('should resolve URL variables from userSecrets.urls', () => {
 		const context = createContext({
 			userSecrets: {
+				stage: 'production',
+				createdAt: '2024-01-01T00:00:00Z',
+				updatedAt: '2024-01-01T00:00:00Z',
 				custom: {},
 				urls: { DATABASE_URL: 'postgresql://external:5432/db' },
 				services: {},
@@ -321,9 +327,19 @@ describe('resolveEnvVar', () => {
 	it('should resolve POSTGRES_PASSWORD from userSecrets.services', () => {
 		const context = createContext({
 			userSecrets: {
+				stage: 'production',
+				createdAt: '2024-01-01T00:00:00Z',
+				updatedAt: '2024-01-01T00:00:00Z',
 				custom: {},
 				urls: {},
-				services: { postgres: { password: 'pg-password' } },
+				services: {
+					postgres: {
+						host: 'localhost',
+						port: 5432,
+						username: 'postgres',
+						password: 'pg-password',
+					},
+				},
 			},
 		});
 
@@ -333,9 +349,19 @@ describe('resolveEnvVar', () => {
 	it('should resolve REDIS_PASSWORD from userSecrets.services', () => {
 		const context = createContext({
 			userSecrets: {
+				stage: 'production',
+				createdAt: '2024-01-01T00:00:00Z',
+				updatedAt: '2024-01-01T00:00:00Z',
 				custom: {},
 				urls: {},
-				services: { redis: { password: 'redis-password' } },
+				services: {
+					redis: {
+						host: 'localhost',
+						port: 6379,
+						username: 'default',
+						password: 'redis-password',
+					},
+				},
 			},
 		});
 
@@ -347,6 +373,86 @@ describe('resolveEnvVar', () => {
 
 		expect(resolveEnvVar('UNKNOWN_VAR', context)).toBeUndefined();
 	});
+
+	describe('dependency URLs', () => {
+		it('should resolve AUTH_URL from dependencyUrls', () => {
+			const context = createContext({
+				dependencyUrls: { auth: 'https://auth.example.com' },
+			});
+
+			expect(resolveEnvVar('AUTH_URL', context)).toBe(
+				'https://auth.example.com',
+			);
+		});
+
+		it('should resolve API_URL from dependencyUrls', () => {
+			const context = createContext({
+				dependencyUrls: { api: 'https://api.example.com' },
+			});
+
+			expect(resolveEnvVar('API_URL', context)).toBe('https://api.example.com');
+		});
+
+		it('should resolve any {DEP}_URL pattern from dependencyUrls', () => {
+			const context = createContext({
+				dependencyUrls: {
+					payments: 'https://payments.example.com',
+					notifications: 'https://notifications.example.com',
+				},
+			});
+
+			expect(resolveEnvVar('PAYMENTS_URL', context)).toBe(
+				'https://payments.example.com',
+			);
+			expect(resolveEnvVar('NOTIFICATIONS_URL', context)).toBe(
+				'https://notifications.example.com',
+			);
+		});
+
+		it('should return undefined for missing dependency URL', () => {
+			const context = createContext({
+				dependencyUrls: { auth: 'https://auth.example.com' },
+			});
+
+			expect(resolveEnvVar('API_URL', context)).toBeUndefined();
+		});
+
+		it('should return undefined when dependencyUrls is not provided', () => {
+			const context = createContext();
+
+			expect(resolveEnvVar('AUTH_URL', context)).toBeUndefined();
+		});
+
+		it('should handle custom domain from config', () => {
+			const context = createContext({
+				dependencyUrls: { auth: 'https://login.myapp.com' },
+			});
+
+			expect(resolveEnvVar('AUTH_URL', context)).toBe(
+				'https://login.myapp.com',
+			);
+		});
+
+		it('should prefer user secrets over dependency URLs', () => {
+			const context = createContext({
+				dependencyUrls: { auth: 'https://auth.example.com' },
+				userSecrets: {
+					stage: 'production',
+					createdAt: '2024-01-01T00:00:00Z',
+					updatedAt: '2024-01-01T00:00:00Z',
+					custom: { AUTH_URL: 'https://custom-auth.example.com' },
+					urls: {},
+					services: {},
+				},
+			});
+
+			// User secrets are checked after dependency URLs, so dependency URL wins
+			// If you want user secrets to override, the order in resolveEnvVar should change
+			expect(resolveEnvVar('AUTH_URL', context)).toBe(
+				'https://auth.example.com',
+			);
+		});
+	});
 });
 
 describe('resolveEnvVars', () => {
@@ -490,4 +596,41 @@ describe('validateEnvVars', () => {
 		expect(result.missing).toEqual([]);
 		expect(result.resolved).toEqual({});
 	});
+
+	it('should resolve dependency URLs in validation', () => {
+		const context = createContext({
+			dependencyUrls: {
+				auth: 'https://auth.example.com',
+				api: 'https://api.example.com',
+			},
+		});
+
+		const result = validateEnvVars(['PORT', 'AUTH_URL', 'API_URL'], context);
+
+		expect(result.valid).toBe(true);
+		expect(result.missing).toEqual([]);
+		expect(result.resolved).toEqual({
+			PORT: '3000',
+			AUTH_URL: 'https://auth.example.com',
+			API_URL: 'https://api.example.com',
+		});
+	});
+
+	it('should report missing dependency URLs', () => {
+		const context = createContext({
+			dependencyUrls: { auth: 'https://auth.example.com' },
+		});
+
+		const result = validateEnvVars(
+			['PORT', 'AUTH_URL', 'PAYMENTS_URL'],
+			context,
+		);
+
+		expect(result.valid).toBe(false);
+		expect(result.missing).toEqual(['PAYMENTS_URL']);
+		expect(result.resolved).toEqual({
+			PORT: '3000',
+			AUTH_URL: 'https://auth.example.com',
+		});
+	});
 });

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',
+			});
+		});
+	});
 });