@friggframework/devtools 2.0.0-next.45 → 2.0.0-next.46

package/infrastructure/domains/shared/providers/provider-factory.js

@@ -0,0 +1,108 @@
+/**
+ * Cloud Provider Factory
+ * 
+ * Factory Pattern - Hexagonal Architecture
+ * 
+ * Creates appropriate cloud provider adapter instances based on configuration.
+ * This enables runtime provider selection and makes it easy to add new providers.
+ */
+
+const { CloudProviderAdapter } = require('./cloud-provider-adapter');
+const { AWSProviderAdapter } = require('./aws-provider-adapter');
+
+class CloudProviderFactory {
+    /**
+     * Create cloud provider adapter instance
+     * 
+     * @param {string} providerName - Provider name ('aws', 'gcp', 'azure')
+     * @param {string} region - Provider region
+     * @param {Object} [credentials] - Optional credential configuration
+     * @returns {CloudProviderAdapter} Provider adapter instance
+     * @throws {Error} If provider is not supported
+     */
+    static create(providerName, region, credentials = {}) {
+        const normalizedProvider = (providerName || 'aws').toLowerCase();
+
+        switch (normalizedProvider) {
+            case 'aws':
+                return new AWSProviderAdapter(region, credentials);
+
+            case 'gcp':
+            case 'google':
+                throw new Error(
+                    'GCP provider not yet implemented. ' +
+                    'AWS is currently the only supported cloud provider. ' +
+                    'GCP support is planned for future releases.'
+                );
+
+            case 'azure':
+            case 'microsoft':
+                throw new Error(
+                    'Azure provider not yet implemented. ' +
+                    'AWS is currently the only supported cloud provider. ' +
+                    'Azure support is planned for future releases.'
+                );
+
+            default:
+                throw new Error(
+                    `Unknown cloud provider: "${providerName}". ` +
+                    `Supported providers: aws (gcp and azure coming soon)`
+                );
+        }
+    }
+
+    /**
+     * Get list of supported providers
+     * 
+     * @returns {Array<Object>} List of provider metadata
+     */
+    static getSupportedProviders() {
+        return [
+            {
+                name: 'aws',
+                displayName: 'Amazon Web Services',
+                status: 'available',
+                description: 'AWS cloud provider with support for Lambda, VPC, RDS, KMS, etc.',
+            },
+            {
+                name: 'gcp',
+                displayName: 'Google Cloud Platform',
+                status: 'planned',
+                description: 'GCP cloud provider support coming soon',
+            },
+            {
+                name: 'azure',
+                displayName: 'Microsoft Azure',
+                status: 'planned',
+                description: 'Azure cloud provider support coming soon',
+            },
+        ];
+    }
+
+    /**
+     * Check if a provider is supported
+     * 
+     * @param {string} providerName - Provider name to check
+     * @returns {boolean} True if provider is supported
+     */
+    static isSupported(providerName) {
+        const normalized = (providerName || '').toLowerCase();
+        return ['aws', 'gcp', 'google', 'azure', 'microsoft'].includes(normalized);
+    }
+
+    /**
+     * Check if a provider is available (implemented)
+     * 
+     * @param {string} providerName - Provider name to check
+     * @returns {boolean} True if provider is implemented
+     */
+    static isAvailable(providerName) {
+        const normalized = (providerName || '').toLowerCase();
+        return normalized === 'aws';
+    }
+}
+
+module.exports = {
+    CloudProviderFactory,
+};
+

package/infrastructure/domains/shared/providers/provider-factory.test.js

@@ -0,0 +1,170 @@
+/**
+ * Tests for CloudProviderFactory
+ * 
+ * Verifies provider instantiation, error handling, and factory patterns
+ */
+
+const { CloudProviderFactory } = require('./provider-factory');
+const { AWSProviderAdapter } = require('./aws-provider-adapter');
+
+describe('CloudProviderFactory', () => {
+    describe('create()', () => {
+        it('should create AWS provider when provider is "aws"', () => {
+            const provider = CloudProviderFactory.create('aws', 'us-east-1');
+
+            expect(provider).toBeInstanceOf(AWSProviderAdapter);
+            expect(provider.getName()).toBe('aws');
+            expect(provider.region).toBe('us-east-1');
+        });
+
+        it('should default to AWS provider when no provider specified', () => {
+            const provider = CloudProviderFactory.create(null, 'us-west-2');
+
+            expect(provider).toBeInstanceOf(AWSProviderAdapter);
+            expect(provider.region).toBe('us-west-2');
+        });
+
+        it('should be case-insensitive for provider names', () => {
+            const provider = CloudProviderFactory.create('AWS', 'eu-west-1');
+
+            expect(provider).toBeInstanceOf(AWSProviderAdapter);
+        });
+
+        it('should throw error for GCP (not yet implemented)', () => {
+            expect(() => {
+                CloudProviderFactory.create('gcp', 'us-central1');
+            }).toThrow('GCP provider not yet implemented');
+        });
+
+        it('should throw error for Azure (not yet implemented)', () => {
+            expect(() => {
+                CloudProviderFactory.create('azure', 'eastus');
+            }).toThrow('Azure provider not yet implemented');
+        });
+
+        it('should handle "google" alias for GCP', () => {
+            expect(() => {
+                CloudProviderFactory.create('google', 'us-central1');
+            }).toThrow('GCP provider not yet implemented');
+        });
+
+        it('should handle "microsoft" alias for Azure', () => {
+            expect(() => {
+                CloudProviderFactory.create('microsoft', 'eastus');
+            }).toThrow('Azure provider not yet implemented');
+        });
+
+        it('should throw error for unknown provider', () => {
+            expect(() => {
+                CloudProviderFactory.create('unknown-cloud', 'region-1');
+            }).toThrow('Unknown cloud provider: "unknown-cloud"');
+        });
+
+        it('should pass credentials to provider', () => {
+            const credentials = {
+                accessKeyId: 'test-key',
+                secretAccessKey: 'test-secret',
+            };
+
+            const provider = CloudProviderFactory.create('aws', 'us-east-1', credentials);
+
+            expect(provider.credentials).toEqual(credentials);
+        });
+    });
+
+    describe('getSupportedProviders()', () => {
+        it('should return list of supported providers', () => {
+            const providers = CloudProviderFactory.getSupportedProviders();
+
+            expect(Array.isArray(providers)).toBe(true);
+            expect(providers.length).toBeGreaterThanOrEqual(3);
+        });
+
+        it('should include AWS as available', () => {
+            const providers = CloudProviderFactory.getSupportedProviders();
+            const aws = providers.find(p => p.name === 'aws');
+
+            expect(aws).toBeDefined();
+            expect(aws.status).toBe('available');
+            expect(aws.displayName).toBe('Amazon Web Services');
+        });
+
+        it('should include GCP as planned', () => {
+            const providers = CloudProviderFactory.getSupportedProviders();
+            const gcp = providers.find(p => p.name === 'gcp');
+
+            expect(gcp).toBeDefined();
+            expect(gcp.status).toBe('planned');
+            expect(gcp.displayName).toBe('Google Cloud Platform');
+        });
+
+        it('should include Azure as planned', () => {
+            const providers = CloudProviderFactory.getSupportedProviders();
+            const azure = providers.find(p => p.name === 'azure');
+
+            expect(azure).toBeDefined();
+            expect(azure.status).toBe('planned');
+            expect(azure.displayName).toBe('Microsoft Azure');
+        });
+    });
+
+    describe('isSupported()', () => {
+        it('should return true for aws', () => {
+            expect(CloudProviderFactory.isSupported('aws')).toBe(true);
+        });
+
+        it('should return true for gcp', () => {
+            expect(CloudProviderFactory.isSupported('gcp')).toBe(true);
+        });
+
+        it('should return true for azure', () => {
+            expect(CloudProviderFactory.isSupported('azure')).toBe(true);
+        });
+
+        it('should return true for google (gcp alias)', () => {
+            expect(CloudProviderFactory.isSupported('google')).toBe(true);
+        });
+
+        it('should return true for microsoft (azure alias)', () => {
+            expect(CloudProviderFactory.isSupported('microsoft')).toBe(true);
+        });
+
+        it('should return false for unknown provider', () => {
+            expect(CloudProviderFactory.isSupported('unknown')).toBe(false);
+        });
+
+        it('should be case-insensitive', () => {
+            expect(CloudProviderFactory.isSupported('AWS')).toBe(true);
+            expect(CloudProviderFactory.isSupported('GCP')).toBe(true);
+        });
+
+        it('should handle null/undefined gracefully', () => {
+            expect(CloudProviderFactory.isSupported(null)).toBe(false);
+            expect(CloudProviderFactory.isSupported(undefined)).toBe(false);
+        });
+    });
+
+    describe('isAvailable()', () => {
+        it('should return true only for aws', () => {
+            expect(CloudProviderFactory.isAvailable('aws')).toBe(true);
+        });
+
+        it('should return false for gcp (not yet implemented)', () => {
+            expect(CloudProviderFactory.isAvailable('gcp')).toBe(false);
+        });
+
+        it('should return false for azure (not yet implemented)', () => {
+            expect(CloudProviderFactory.isAvailable('azure')).toBe(false);
+        });
+
+        it('should return false for unknown provider', () => {
+            expect(CloudProviderFactory.isAvailable('unknown')).toBe(false);
+        });
+
+        it('should be case-insensitive', () => {
+            expect(CloudProviderFactory.isAvailable('AWS')).toBe(true);
+            expect(CloudProviderFactory.isAvailable('GCP')).toBe(false);
+        });
+    });
+});
+

package/infrastructure/domains/shared/resource-discovery.js

@@ -0,0 +1,192 @@
+/**
+ * Resource Discovery Service
+ * 
+ * Domain Service - Hexagonal Architecture
+ * 
+ * Orchestrates discovery of cloud resources (VPC, databases, encryption keys, etc.)
+ * using the cloud provider abstraction layer and domain-specific discovery services.
+ * 
+ * This service is cloud-agnostic and delegates to provider-specific implementations.
+ */
+
+const { CloudProviderFactory } = require('./providers/provider-factory');
+const { CloudFormationDiscovery } = require('./cloudformation-discovery');
+const { VpcDiscovery } = require('../networking/vpc-discovery');
+const { KmsDiscovery } = require('../security/kms-discovery');
+const { AuroraDiscovery } = require('../database/aurora-discovery');
+const { SsmDiscovery } = require('../parameters/ssm-discovery');
+
+/**
+ * Determine if AWS discovery should run
+ * 
+ * @param {Object} appDefinition - Application definition
+ * @returns {boolean} True if discovery is needed
+ */
+function shouldRunDiscovery(appDefinition) {
+    console.log(
+        '⚙️  Checking FRIGG_SKIP_AWS_DISCOVERY:',
+        process.env.FRIGG_SKIP_AWS_DISCOVERY
+    );
+
+    if (process.env.FRIGG_SKIP_AWS_DISCOVERY === 'true') {
+        console.log(
+            '⚙️  Skipping AWS discovery because FRIGG_SKIP_AWS_DISCOVERY is set.'
+        );
+        return false;
+    }
+
+    return (
+        appDefinition.vpc?.enable === true ||
+        appDefinition.encryption?.fieldLevelEncryptionMethod === 'kms' ||
+        appDefinition.ssm?.enable === true ||
+        appDefinition.database?.postgres?.enable === true
+    );
+}
+
+/**
+ * Gather discovered cloud resources
+ * 
+ * Uses cloud provider abstraction to discover resources in a provider-agnostic way.
+ * 
+ * @param {Object} appDefinition - Application definition
+ * @returns {Promise<Object>} Discovered cloud resources
+ */
+async function gatherDiscoveredResources(appDefinition) {
+    if (!shouldRunDiscovery(appDefinition)) {
+        console.log('⚙️  Skipping cloud resource discovery (not required for this configuration)');
+        return {};
+    }
+
+    console.log('🔍 Running cloud resource discovery...');
+
+    try {
+        // Get cloud provider (defaults to AWS, can be overridden via env var)
+        const providerName = process.env.CLOUD_PROVIDER || appDefinition.provider || 'aws';
+        const region = process.env.AWS_REGION || 'us-east-1';
+
+        console.log(`   Provider: ${providerName}`);
+        console.log(`   Region: ${region}`);
+
+        // Create provider adapter
+        const provider = CloudProviderFactory.create(providerName, region);
+
+        // Build discovery configuration
+        const stage = process.env.SLS_STAGE || 'dev';
+        const stackName = `${appDefinition.name || 'create-frigg-app'}-${stage}`;
+        const serviceName = appDefinition.name || 'create-frigg-app';
+
+        // Try CloudFormation-first discovery
+        const cfDiscovery = new CloudFormationDiscovery(provider, { serviceName, stage });
+        const stackResources = await cfDiscovery.discoverFromStack(stackName);
+
+        // Validate CF discovery results - only use if contains useful data
+        const hasVpcData = stackResources?.defaultVpcId;
+        const hasKmsData = stackResources?.defaultKmsKeyId;
+        const hasAuroraData = stackResources?.auroraClusterId;
+        const hasSomeUsefulData = hasVpcData || hasKmsData || hasAuroraData;
+
+        // Check if we're in isolated mode (each stage gets its own VPC/Aurora)
+        const isIsolatedMode = appDefinition.managementMode === 'managed' &&
+                               appDefinition.vpcIsolation === 'isolated';
+
+        if (stackResources && hasSomeUsefulData) {
+            console.log('  ✓ Discovered resources from existing CloudFormation stack');
+            console.log('✅ Cloud resource discovery completed successfully!');
+            return stackResources;
+        }
+
+        // In isolated mode, NEVER fall back to AWS discovery for VPC/Aurora
+        // These resources must be isolated per stage, so we either:
+        // 1. Use resources from THIS stage's CloudFormation stack (handled above)
+        // 2. Return empty to CREATE fresh isolated resources for this stage
+        if (isIsolatedMode) {
+            console.log('  ℹ Isolated mode: No CloudFormation stack or no VPC/Aurora in stack');
+            console.log('  ℹ Will create fresh isolated VPC/Aurora for this stage');
+            console.log('  ℹ Checking for shared KMS key...');
+
+            // KMS keys CAN be shared across stages (encryption keys are safe to reuse)
+            const kmsDiscovery = new KmsDiscovery(provider);
+            const kmsConfig = {
+                serviceName: appDefinition.name || 'create-frigg-app',
+                stage,
+                keyAlias: `alias/${appDefinition.name || 'create-frigg-app'}-${stage}-frigg-kms`,
+            };
+            const kmsResult = await kmsDiscovery.discover(kmsConfig);
+
+            if (kmsResult?.defaultKmsKeyId) {
+                console.log('  ✓ Found shared KMS key (can be reused across stages)');
+                console.log('✅ Cloud resource discovery completed - will create isolated VPC/Aurora!');
+                return kmsResult;
+            }
+
+            console.log('  ℹ No existing KMS key found - will create new one');
+            console.log('✅ Cloud resource discovery completed - will create fresh isolated resources!');
+            return {};
+        }
+
+        // Fallback to AWS API discovery (fresh deployment, stack not found, or stack has no useful data)
+        if (stackResources && !hasSomeUsefulData) {
+            console.log('  ℹ Stack found but contains no usable resources - running AWS API discovery...');
+        } else {
+            console.log('  ℹ No stack found - running AWS API discovery...');
+        }
+
+        // Create domain discovery services with provider
+        const vpcDiscovery = new VpcDiscovery(provider);
+        const kmsDiscovery = new KmsDiscovery(provider);
+        const auroraDiscovery = new AuroraDiscovery(provider);
+        const ssmDiscovery = new SsmDiscovery(provider);
+
+        const config = {
+            serviceName: appDefinition.name || 'create-frigg-app',
+            stage,
+            vpcId: appDefinition.vpc?.vpcId,
+            databaseId: appDefinition.database?.postgres?.clusterId ||
+                appDefinition.database?.postgres?.instanceId,
+            keyAlias: appDefinition.encryption?.keyAlias,
+            includeSecrets: true,
+        };
+
+        // Run discoveries in parallel for better performance
+        const [vpcResources, kmsResources, dbResources, ssmResources] =
+            await Promise.all([
+                appDefinition.vpc?.enable ? vpcDiscovery.discover(config) : Promise.resolve({}),
+                appDefinition.encryption?.fieldLevelEncryptionMethod === 'kms'
+                    ? kmsDiscovery.discover(config)
+                    : Promise.resolve({}),
+                appDefinition.database?.postgres?.enable
+                    ? auroraDiscovery.discover(config)
+                    : Promise.resolve({}),
+                appDefinition.ssm?.enable
+                    ? ssmDiscovery.discover(config)
+                    : Promise.resolve({}),
+            ]);
+
+        // Aggregate results
+        const discoveredResources = {
+            ...vpcResources,
+            ...kmsResources,
+            ...dbResources,
+            ...ssmResources,
+        };
+
+        console.log('✅ Cloud resource discovery completed successfully!');
+
+        return discoveredResources;
+    } catch (error) {
+        console.error('❌ Cloud resource discovery failed:', error.message);
+        console.error('Stack:', error.stack);
+
+        // Don't fail the build - return empty resources and let validation handle it
+        console.warn(
+            '⚠️  Continuing with empty discovered resources. This may cause deployment issues if resources are required.'
+        );
+        return {};
+    }
+}
+
+module.exports = {
+    shouldRunDiscovery,
+    gatherDiscoveredResources,
+};
+