@friggframework/devtools 2.0.0-next.61 → 2.0.0-next.62

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

@@ -1,87 +0,0 @@
-/**
- * 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

@@ -1,188 +0,0 @@
-/**
- * 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

@@ -1,210 +0,0 @@
-/**
- * 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;