@geekmidas/cli 1.2.3 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "1.2.3",
+  "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/SSMStateProvider.ts

@@ -22,6 +22,8 @@ export interface SSMStateProviderOptions {
 	workspaceName: string;
 	/** AWS region */
 	region?: AwsRegion;
+	/** AWS profile name (optional - uses default credential chain if not provided) */
+	profile?: string;
 	/** AWS credentials (optional - uses default credential chain if not provided) */
 	credentials?: SSMClientConfig['credentials'];
 	/** Custom endpoint (for LocalStack or other S3-compatible services) */
@@ -44,12 +46,21 @@ export class SSMStateProvider implements StateProvider {
 	 * Create an SSMStateProvider with a new SSMClient.
 	 */
 	static create(options: SSMStateProviderOptions): SSMStateProvider {
-		const client = new SSMClient({
+		const clientConfig: SSMClientConfig = {
 			region: options.region,
-			credentials: options.credentials,
 			endpoint: options.endpoint,
-		});
+		};
 
+		// Use profile credentials if specified, otherwise use provided credentials or default chain
+		if (options.profile) {
+			// Dynamic import to avoid requiring @aws-sdk/credential-providers when not using profiles
+			const { fromIni } = require('@aws-sdk/credential-providers');
+			clientConfig.credentials = fromIni({ profile: options.profile });
+		} else if (options.credentials) {
+			clientConfig.credentials = options.credentials;
+		}
+
+		const client = new SSMClient(clientConfig);
 		return new SSMStateProvider(options.workspaceName, client);
 	}
 

package/src/deploy/StateProvider.ts

@@ -79,6 +79,8 @@ export interface SSMStateConfig {
 	provider: 'ssm';
 	/** AWS region (required for SSM provider) */
 	region: AwsRegion;
+	/** AWS profile name (optional - uses default credential chain if not provided) */
+	profile?: string;
 }
 
 /**
@@ -157,10 +159,12 @@ export async function createStateProvider(
 		const { SSMStateProvider } = await import('./SSMStateProvider');
 		const { CachedStateProvider } = await import('./CachedStateProvider');
 
+		const ssmConfig = config as SSMStateConfig;
 		const local = new LocalStateProvider(workspaceRoot);
 		const ssm = SSMStateProvider.create({
 			workspaceName,
-			region: (config as SSMStateConfig).region,
+			region: ssmConfig.region,
+			profile: ssmConfig.profile,
 		});
 
 		return new CachedStateProvider(ssm, local);

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

@@ -75,6 +75,18 @@ describe('SSMStateProvider', () => {
 			expect(provider).toBeInstanceOf(SSMStateProvider);
 			expect(provider.workspaceName).toBe('my-workspace');
 		});
+
+		it('should create provider with profile option', () => {
+			const provider = SSMStateProvider.create({
+				workspaceName: 'my-workspace',
+				region: 'us-west-2',
+				profile: 'my-profile',
+				endpoint: LOCALSTACK_ENDPOINT,
+			});
+
+			expect(provider).toBeInstanceOf(SSMStateProvider);
+			expect(provider.workspaceName).toBe('my-workspace');
+		});
 	});
 
 	describe('read', () => {

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

@@ -93,6 +93,16 @@ describe('createStateProvider', () => {
 
 			expect(provider).toBeInstanceOf(CachedStateProvider);
 		});
+
+		it('should create CachedStateProvider for ssm config with profile', async () => {
+			const provider = await createStateProvider({
+				config: { provider: 'ssm', region: 'us-east-1', profile: 'my-profile' },
+				workspaceRoot: testDir,
+				workspaceName: 'test-workspace',
+			});
+
+			expect(provider).toBeInstanceOf(CachedStateProvider);
+		});
 	});
 
 	describe('custom provider', () => {

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