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

package/infrastructure/domains/database/aurora-discovery.js

@@ -0,0 +1,87 @@
+/**
+ * Aurora Discovery Service
+ * 
+ * Domain Service - Hexagonal Architecture
+ * 
+ * Discovers Aurora/RDS database resources using the cloud provider adapter.
+ * Adds domain-specific validation and connection string generation.
+ */
+
+class AuroraDiscovery {
+    /**
+     * @param {CloudProviderAdapter} provider - Cloud provider adapter instance
+     */
+    constructor(provider) {
+        this.provider = provider;
+    }
+
+    /**
+     * Discover Aurora/RDS database resources
+     * 
+     * @param {Object} config - Discovery configuration
+     * @param {string} [config.databaseId] - Specific database cluster/instance ID
+     * @param {string} [config.serviceName] - Service name for filtering
+     * @param {string} [config.stage] - Deployment stage
+     * @returns {Promise<Object>} Discovered database resources
+     */
+    async discover(config) {
+        console.log('🔍 Discovering Aurora/RDS databases...');
+
+        try {
+            const rawResources = await this.provider.discoverDatabase(config);
+
+            const result = {
+                auroraClusterEndpoint: null,
+                auroraPort: null,
+                auroraEngine: null,
+                databaseEndpoint: null,
+                databasePort: null,
+                databaseEngine: null,
+                clusters: rawResources.clusters,
+                instances: rawResources.instances,
+            };
+
+            // Set discovered endpoint
+            if (rawResources.endpoint) {
+                result.auroraClusterEndpoint = rawResources.endpoint;
+                result.databaseEndpoint = rawResources.endpoint;
+                result.auroraPort = rawResources.port || 5432;
+                result.databasePort = rawResources.port || 5432;
+                result.auroraEngine = rawResources.engine || 'aurora-postgresql';
+                result.databaseEngine = rawResources.engine || 'aurora-postgresql';
+
+                // Capture security group IDs
+                if (rawResources.securityGroupIds && rawResources.securityGroupIds.length > 0) {
+                    result.auroraSecurityGroupId = rawResources.securityGroupIds[0]; // Use first security group
+                    console.log(`  ✓ Found security group: ${result.auroraSecurityGroupId}`);
+                }
+
+                console.log(`  ✓ Found database: ${result.auroraClusterEndpoint}:${result.auroraPort}`);
+                console.log(`  ✓ Engine: ${result.auroraEngine}`);
+            } else {
+                console.log('  ℹ No database found');
+            }
+
+            // Look for associated secrets in Secrets Manager
+            // This would be discovered via the provider's discoverParameters method
+            // with includeSecrets flag if needed
+
+            return result;
+        } catch (error) {
+            console.error('  ✗ Database discovery failed:', error.message);
+            return {
+                auroraClusterEndpoint: null,
+                auroraPort: null,
+                auroraEngine: null,
+                databaseEndpoint: null,
+                databasePort: null,
+                databaseEngine: null,
+            };
+        }
+    }
+}
+
+module.exports = {
+    AuroraDiscovery,
+};
+

package/infrastructure/domains/database/aurora-discovery.test.js

@@ -0,0 +1,188 @@
+/**
+ * Tests for Aurora Discovery Service
+ * 
+ * Tests Aurora/RDS database discovery with mocked cloud provider
+ */
+
+const { AuroraDiscovery } = require('./aurora-discovery');
+
+describe('AuroraDiscovery', () => {
+    let mockProvider;
+    let auroraDiscovery;
+
+    beforeEach(() => {
+        mockProvider = {
+            discoverDatabase: jest.fn(),
+            getName: jest.fn().mockReturnValue('aws'),
+        };
+        auroraDiscovery = new AuroraDiscovery(mockProvider);
+    });
+
+    describe('discover()', () => {
+        it('should delegate to provider and transform results', async () => {
+            const mockProviderResponse = {
+                clusters: [
+                    {
+                        DBClusterIdentifier: 'aurora-cluster-1',
+                        Endpoint: 'aurora-cluster-1.cluster-xyz.us-east-1.rds.amazonaws.com',
+                        Port: 5432,
+                        Engine: 'aurora-postgresql',
+                    },
+                ],
+                instances: [],
+                endpoint: 'aurora-cluster-1.cluster-xyz.us-east-1.rds.amazonaws.com',
+                port: 5432,
+                engine: 'aurora-postgresql',
+            };
+
+            mockProvider.discoverDatabase.mockResolvedValue(mockProviderResponse);
+
+            const result = await auroraDiscovery.discover({});
+
+            expect(mockProvider.discoverDatabase).toHaveBeenCalledWith({});
+            expect(result.auroraClusterEndpoint).toBe('aurora-cluster-1.cluster-xyz.us-east-1.rds.amazonaws.com');
+            expect(result.databaseEndpoint).toBe('aurora-cluster-1.cluster-xyz.us-east-1.rds.amazonaws.com');
+            expect(result.auroraPort).toBe(5432);
+            expect(result.databasePort).toBe(5432);
+            expect(result.auroraEngine).toBe('aurora-postgresql');
+            expect(result.databaseEngine).toBe('aurora-postgresql');
+        });
+
+        it('should handle no database found', async () => {
+            mockProvider.discoverDatabase.mockResolvedValue({
+                clusters: [],
+                instances: [],
+                endpoint: null,
+                port: null,
+                engine: null,
+            });
+
+            const result = await auroraDiscovery.discover({});
+
+            expect(result.auroraClusterEndpoint).toBeNull();
+            expect(result.databaseEndpoint).toBeNull();
+            expect(result.auroraPort).toBeNull();
+            expect(result.databasePort).toBeNull();
+        });
+
+        it('should default to port 5432 if not specified', async () => {
+            mockProvider.discoverDatabase.mockResolvedValue({
+                clusters: [],
+                instances: [],
+                endpoint: 'db.example.com',
+                port: null,
+                engine: 'aurora-postgresql',
+            });
+
+            const result = await auroraDiscovery.discover({});
+
+            expect(result.auroraPort).toBe(5432);
+            expect(result.databasePort).toBe(5432);
+        });
+
+        it('should default to aurora-postgresql engine if not specified', async () => {
+            mockProvider.discoverDatabase.mockResolvedValue({
+                clusters: [],
+                instances: [],
+                endpoint: 'db.example.com',
+                port: 5432,
+                engine: null,
+            });
+
+            const result = await auroraDiscovery.discover({});
+
+            expect(result.auroraEngine).toBe('aurora-postgresql');
+            expect(result.databaseEngine).toBe('aurora-postgresql');
+        });
+
+        it('should handle MySQL Aurora', async () => {
+            mockProvider.discoverDatabase.mockResolvedValue({
+                clusters: [],
+                instances: [],
+                endpoint: 'mysql-cluster.example.com',
+                port: 3306,
+                engine: 'aurora-mysql',
+            });
+
+            const result = await auroraDiscovery.discover({});
+
+            expect(result.auroraPort).toBe(3306);
+            expect(result.auroraEngine).toBe('aurora-mysql');
+        });
+
+        it('should pass config to provider', async () => {
+            mockProvider.discoverDatabase.mockResolvedValue({
+                clusters: [],
+                instances: [],
+                endpoint: null,
+                port: null,
+                engine: null,
+            });
+
+            const config = {
+                databaseId: 'my-cluster',
+                serviceName: 'test-service',
+                stage: 'prod',
+            };
+
+            await auroraDiscovery.discover(config);
+
+            expect(mockProvider.discoverDatabase).toHaveBeenCalledWith(config);
+        });
+
+        it('should handle discovery errors gracefully', async () => {
+            mockProvider.discoverDatabase.mockRejectedValue(new Error('RDS API Error'));
+
+            const result = await auroraDiscovery.discover({});
+
+            expect(result.auroraClusterEndpoint).toBeNull();
+            expect(result.auroraPort).toBeNull();
+            expect(result.auroraEngine).toBeNull();
+        });
+
+        it('should preserve cluster and instance lists for reference', async () => {
+            const mockClusters = [
+                { DBClusterIdentifier: 'cluster-1', Endpoint: 'endpoint-1' },
+                { DBClusterIdentifier: 'cluster-2', Endpoint: 'endpoint-2' },
+            ];
+            const mockInstances = [
+                { DBInstanceIdentifier: 'instance-1' },
+            ];
+
+            mockProvider.discoverDatabase.mockResolvedValue({
+                clusters: mockClusters,
+                instances: mockInstances,
+                endpoint: 'endpoint-1',
+                port: 5432,
+                engine: 'aurora-postgresql',
+            });
+
+            const result = await auroraDiscovery.discover({});
+
+            expect(result.clusters).toEqual(mockClusters);
+            expect(result.instances).toEqual(mockInstances);
+        });
+
+        it('should handle RDS instances (non-Aurora)', async () => {
+            mockProvider.discoverDatabase.mockResolvedValue({
+                clusters: [],
+                instances: [
+                    {
+                        DBInstanceIdentifier: 'rds-instance',
+                        Endpoint: { Address: 'rds.example.com', Port: 5432 },
+                        Engine: 'postgres',
+                    },
+                ],
+                endpoint: 'rds.example.com',
+                port: 5432,
+                engine: 'postgres',
+            });
+
+            const result = await auroraDiscovery.discover({});
+
+            expect(result.databaseEndpoint).toBe('rds.example.com');
+            expect(result.databaseEngine).toBe('postgres');
+        });
+    });
+});
+

package/infrastructure/domains/database/aurora-resolver.js

@@ -0,0 +1,210 @@
+/**
+ * Aurora Resource Resolver
+ *
+ * Resolves ownership for Aurora PostgreSQL resources following the ownership-based architecture.
+ *
+ * Resources managed:
+ * - Aurora Cluster (RDS::DBCluster)
+ * - Aurora Instance (RDS::DBInstance)
+ * - DB Subnet Group (RDS::DBSubnetGroup)
+ * - DB Secret (SecretsManager::Secret)
+ *
+ * Ownership types:
+ * - STACK: Resource defined in our CloudFormation template (use Refs)
+ * - EXTERNAL: Resource outside our stack (use physical IDs)
+ * - AUTO: System decides based on discovery
+ */
+
+const BaseResourceResolver = require('../shared/base-resolver');
+const { ResourceOwnership } = require('../shared/types/resource-ownership');
+
+class AuroraResourceResolver extends BaseResourceResolver {
+    /**
+     * Resolve Aurora Cluster ownership
+     * @param {Object} appDefinition - App definition
+     * @param {Object} discovery - Discovery result
+     * @returns {Object} Resource decision
+     */
+    resolveCluster(appDefinition, discovery) {
+        const userIntent = appDefinition.database?.postgres?.ownership?.cluster || 'auto';
+
+        // Explicit external - use provided cluster identifier
+        if (userIntent === 'external') {
+            this.requireExternalIds(
+                appDefinition.database?.postgres?.external?.clusterIdentifier,
+                'clusterIdentifier'
+            );
+            return this.createExternalDecision(
+                appDefinition.database.postgres.external.clusterIdentifier,
+                'User specified ownership=external for Aurora cluster'
+            );
+        }
+
+        // For stack or auto: check if cluster exists in stack
+        const inStack = this.findInStack('FriggAuroraCluster', discovery);
+
+        if (inStack) {
+            return this.createStackDecision(
+                inStack.physicalId,
+                'Found FriggAuroraCluster in CloudFormation stack'
+            );
+        }
+
+        // Check for external cluster
+        const external = this.findExternal('AWS::RDS::DBCluster', discovery);
+        if (external && userIntent === 'auto') {
+            return this.createExternalDecision(
+                external.physicalId,
+                'Found external Aurora cluster via discovery'
+            );
+        }
+
+        // Create new cluster in stack
+        return this.createStackDecision(
+            null,
+            'No existing Aurora cluster - will create in stack'
+        );
+    }
+
+    /**
+     * Resolve Aurora Instance ownership
+     * @param {Object} appDefinition - App definition
+     * @param {Object} discovery - Discovery result
+     * @returns {Object} Resource decision
+     */
+    resolveInstance(appDefinition, discovery) {
+        const userIntent = appDefinition.database?.postgres?.ownership?.instance || 'auto';
+
+        // Explicit external
+        if (userIntent === 'external') {
+            this.requireExternalIds(
+                appDefinition.database?.postgres?.external?.instanceIdentifier,
+                'instanceIdentifier'
+            );
+            return this.createExternalDecision(
+                appDefinition.database.postgres.external.instanceIdentifier,
+                'User specified ownership=external for Aurora instance'
+            );
+        }
+
+        // Check if instance exists in stack
+        const inStack = this.findInStack('FriggAuroraInstance', discovery);
+
+        if (inStack) {
+            return this.createStackDecision(
+                inStack.physicalId,
+                'Found FriggAuroraInstance in CloudFormation stack'
+            );
+        }
+
+        // Check for external instance
+        const external = this.findExternal('AWS::RDS::DBInstance', discovery);
+        if (external && userIntent === 'auto') {
+            return this.createExternalDecision(
+                external.physicalId,
+                'Found external Aurora instance via discovery'
+            );
+        }
+
+        // Create new instance in stack
+        return this.createStackDecision(
+            null,
+            'No existing Aurora instance - will create in stack'
+        );
+    }
+
+    /**
+     * Resolve DB Subnet Group ownership
+     * @param {Object} appDefinition - App definition
+     * @param {Object} discovery - Discovery result
+     * @returns {Object} Resource decision
+     */
+    resolveSubnetGroup(appDefinition, discovery) {
+        const userIntent = appDefinition.database?.postgres?.ownership?.subnetGroup || 'auto';
+
+        // Explicit external
+        if (userIntent === 'external') {
+            this.requireExternalIds(
+                appDefinition.database?.postgres?.external?.subnetGroupName,
+                'subnetGroupName'
+            );
+            return this.createExternalDecision(
+                appDefinition.database.postgres.external.subnetGroupName,
+                'User specified ownership=external for DB subnet group'
+            );
+        }
+
+        // Check if subnet group exists in stack
+        const inStack = this.findInStack('FriggDBSubnetGroup', discovery);
+
+        if (inStack) {
+            return this.createStackDecision(
+                inStack.physicalId,
+                'Found FriggDBSubnetGroup in CloudFormation stack'
+            );
+        }
+
+        // For subnet groups, always create in stack (they're cheap and cluster-specific)
+        return this.createStackDecision(
+            null,
+            'No existing DB subnet group - will create in stack'
+        );
+    }
+
+    /**
+     * Resolve DB Secret ownership
+     * @param {Object} appDefinition - App definition
+     * @param {Object} discovery - Discovery result
+     * @returns {Object} Resource decision
+     */
+    resolveSecret(appDefinition, discovery) {
+        const userIntent = appDefinition.database?.postgres?.ownership?.secret || 'auto';
+
+        // Explicit external - use provided secret ARN
+        if (userIntent === 'external') {
+            this.requireExternalIds(
+                appDefinition.database?.postgres?.external?.secretArn,
+                'secretArn'
+            );
+            return this.createExternalDecision(
+                appDefinition.database.postgres.external.secretArn,
+                'User specified ownership=external for DB secret'
+            );
+        }
+
+        // Check if secret exists in stack
+        const inStack = this.findInStack('FriggDBSecret', discovery);
+
+        if (inStack) {
+            return this.createStackDecision(
+                inStack.physicalId,
+                'Found FriggDBSecret in CloudFormation stack'
+            );
+        }
+
+        // For secrets tied to the cluster, always create in stack
+        return this.createStackDecision(
+            null,
+            'No existing DB secret - will create in stack'
+        );
+    }
+
+    /**
+     * Resolve all Aurora resources at once
+     * Convenience method that returns decisions for all Aurora resources
+     *
+     * @param {Object} appDefinition - App definition
+     * @param {Object} discovery - Discovery result
+     * @returns {Object} Decisions for all Aurora resources
+     */
+    resolveAll(appDefinition, discovery) {
+        return {
+            cluster: this.resolveCluster(appDefinition, discovery),
+            instance: this.resolveInstance(appDefinition, discovery),
+            subnetGroup: this.resolveSubnetGroup(appDefinition, discovery),
+            secret: this.resolveSecret(appDefinition, discovery)
+        };
+    }
+}
+
+module.exports = AuroraResourceResolver;