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

package/infrastructure/domains/shared/providers/aws-provider-adapter.test.js

@@ -1,416 +0,0 @@
-/**
- * Tests for AWS Provider Adapter
- * 
- * Tests AWS-specific cloud resource discovery
- */
-
-const { AWSProviderAdapter } = require('./aws-provider-adapter');
-
-// Mock AWS SDK v3 clients
-jest.mock('@aws-sdk/client-ec2');
-jest.mock('@aws-sdk/client-kms');
-jest.mock('@aws-sdk/client-rds');
-jest.mock('@aws-sdk/client-ssm');
-jest.mock('@aws-sdk/client-secrets-manager');
-
-describe('AWSProviderAdapter', () => {
-    describe('listStackResources', () => {
-        it.skip('should handle pagination and return all resources across multiple pages', async () => {
-            const mockCfClient = {
-                send: jest.fn()
-                    .mockResolvedValueOnce({
-                        StackResourceSummaries: [
-                            { LogicalResourceId: 'Resource1', PhysicalResourceId: 'res-1', ResourceType: 'AWS::EC2::VPC' },
-                            { LogicalResourceId: 'Resource2', PhysicalResourceId: 'res-2', ResourceType: 'AWS::EC2::Subnet' }
-                        ],
-                        NextToken: 'token-page-2'  // More pages available
-                    })
-                    .mockResolvedValueOnce({
-                        StackResourceSummaries: [
-                            { LogicalResourceId: 'VPCEndpointS3', PhysicalResourceId: 'vpce-s3', ResourceType: 'AWS::EC2::VPCEndpoint' },
-                            { LogicalResourceId: 'VPCEndpointDynamoDB', PhysicalResourceId: 'vpce-ddb', ResourceType: 'AWS::EC2::VPCEndpoint' }
-                        ],
-                        NextToken: null  // Last page
-                    })
-            };
-
-            const provider = new AWSProviderAdapter('us-east-1');
-            provider.getCloudFormationClient = jest.fn().mockReturnValue(mockCfClient);
-
-            const resources = await provider.listStackResources('test-stack');
-
-            // Should have ALL resources from ALL pages
-            expect(resources).toHaveLength(4);
-            expect(resources.map(r => r.LogicalResourceId)).toEqual([
-                'Resource1',
-                'Resource2',
-                'VPCEndpointS3',
-                'VPCEndpointDynamoDB'
-            ]);
-
-            // Should have called CloudFormation twice (once for each page)
-            expect(mockCfClient.send).toHaveBeenCalledTimes(2);
-        });
-    });
-
-    let provider;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        delete process.env.AWS_REGION;
-    });
-
-    describe('constructor()', () => {
-        it('should initialize with provided region', () => {
-            provider = new AWSProviderAdapter('eu-west-1');
-
-            expect(provider.region).toBe('eu-west-1');
-        });
-
-        it('should default to us-east-1 if no region provided', () => {
-            provider = new AWSProviderAdapter();
-
-            expect(provider.region).toBe('us-east-1');
-        });
-
-        it('should use AWS_REGION environment variable', () => {
-            process.env.AWS_REGION = 'ap-southeast-1';
-            provider = new AWSProviderAdapter();
-
-            expect(provider.region).toBe('ap-southeast-1');
-        });
-
-        it('should prefer provided region over environment variable', () => {
-            process.env.AWS_REGION = 'us-west-2';
-            provider = new AWSProviderAdapter('eu-central-1');
-
-            expect(provider.region).toBe('eu-central-1');
-        });
-
-        it('should store credentials if provided', () => {
-            const credentials = {
-                accessKeyId: 'test-key',
-                secretAccessKey: 'test-secret',
-            };
-
-            provider = new AWSProviderAdapter('us-east-1', credentials);
-
-            expect(provider.credentials).toEqual(credentials);
-        });
-
-        it('should lazy-load clients (not instantiated on construction)', () => {
-            provider = new AWSProviderAdapter('us-east-1');
-
-            expect(provider.ec2).toBeNull();
-            expect(provider.kms).toBeNull();
-            expect(provider.rds).toBeNull();
-            expect(provider.ssm).toBeNull();
-            expect(provider.secretsManager).toBeNull();
-        });
-    });
-
-    describe('getName()', () => {
-        it('should return "aws"', () => {
-            provider = new AWSProviderAdapter();
-
-            expect(provider.getName()).toBe('aws');
-        });
-    });
-
-    describe('getSupportedRegions()', () => {
-        it('should return array of AWS regions', () => {
-            provider = new AWSProviderAdapter();
-
-            const regions = provider.getSupportedRegions();
-
-            expect(Array.isArray(regions)).toBe(true);
-            expect(regions.length).toBeGreaterThan(0);
-        });
-
-        it('should include common US regions', () => {
-            provider = new AWSProviderAdapter();
-
-            const regions = provider.getSupportedRegions();
-
-            expect(regions).toContain('us-east-1');
-            expect(regions).toContain('us-east-2');
-            expect(regions).toContain('us-west-1');
-            expect(regions).toContain('us-west-2');
-        });
-
-        it('should include common EU regions', () => {
-            provider = new AWSProviderAdapter();
-
-            const regions = provider.getSupportedRegions();
-
-            expect(regions).toContain('eu-west-1');
-            expect(regions).toContain('eu-central-1');
-        });
-
-        it('should include common APAC regions', () => {
-            provider = new AWSProviderAdapter();
-
-            const regions = provider.getSupportedRegions();
-
-            expect(regions).toContain('ap-southeast-1');
-            expect(regions).toContain('ap-northeast-1');
-        });
-    });
-
-    describe('Lazy loading clients', () => {
-        beforeEach(() => {
-            provider = new AWSProviderAdapter('us-east-1');
-        });
-
-        it('should lazy-load EC2 client', () => {
-            expect(provider.ec2).toBeNull();
-
-            const client = provider.getEC2Client();
-
-            expect(provider.ec2).not.toBeNull();
-            expect(client).toBe(provider.ec2);
-        });
-
-        it('should lazy-load KMS client', () => {
-            expect(provider.kms).toBeNull();
-
-            const client = provider.getKMSClient();
-
-            expect(provider.kms).not.toBeNull();
-            expect(client).toBe(provider.kms);
-        });
-
-        it('should lazy-load RDS client', () => {
-            expect(provider.rds).toBeNull();
-
-            const client = provider.getRDSClient();
-
-            expect(provider.rds).not.toBeNull();
-            expect(client).toBe(provider.rds);
-        });
-
-        it('should lazy-load SSM client', () => {
-            expect(provider.ssm).toBeNull();
-
-            const client = provider.getSSMClient();
-
-            expect(provider.ssm).not.toBeNull();
-            expect(client).toBe(provider.ssm);
-        });
-
-        it('should lazy-load Secrets Manager client', () => {
-            expect(provider.secretsManager).toBeNull();
-
-            const client = provider.getSecretsManagerClient();
-
-            expect(provider.secretsManager).not.toBeNull();
-            expect(client).toBe(provider.secretsManager);
-        });
-
-        it('should lazy-load CloudFormation client', () => {
-            expect(provider.cloudformation).toBeNull();
-
-            const client = provider.getCloudFormationClient();
-
-            expect(provider.cloudformation).not.toBeNull();
-            expect(client).toBe(provider.cloudformation);
-        });
-
-        it('should reuse client on subsequent calls', () => {
-            const client1 = provider.getEC2Client();
-            const client2 = provider.getEC2Client();
-
-            expect(client1).toBe(client2);
-        });
-    });
-
-    describe('discoverVpc()', () => {
-        beforeEach(() => {
-            provider = new AWSProviderAdapter('us-east-1');
-            const { EC2Client } = require('@aws-sdk/client-ec2');
-            EC2Client.mockImplementation(() => ({
-                send: jest.fn(),
-            }));
-        });
-
-        it('should return VPC discovery results', async () => {
-            const mockSend = jest.fn()
-                .mockResolvedValueOnce({ // VPCs
-                    Vpcs: [
-                        { VpcId: 'vpc-123', CidrBlock: '172.31.0.0/16' },
-                    ],
-                })
-                .mockResolvedValueOnce({ Subnets: [] }) // Subnets
-                .mockResolvedValueOnce({ SecurityGroups: [] }) // Security Groups
-                .mockResolvedValueOnce({ RouteTables: [] }) // Route Tables
-                .mockResolvedValueOnce({ NatGateways: [] }) // NAT Gateways
-                .mockResolvedValueOnce({ InternetGateways: [] }) // Internet Gateways
-                .mockResolvedValueOnce({ VpcEndpoints: [] }); // VPC Endpoints
-
-            provider.getEC2Client = jest.fn().mockReturnValue({ send: mockSend });
-
-            const result = await provider.discoverVpc({});
-
-            expect(result.vpcId).toBe('vpc-123');
-            expect(result.vpcCidr).toBe('172.31.0.0/16');
-        });
-
-        it('should handle discovery errors', async () => {
-            provider.getEC2Client = jest.fn().mockReturnValue({
-                send: jest.fn().mockRejectedValue(new Error('EC2 API Error')),
-            });
-
-            await expect(provider.discoverVpc({})).rejects.toThrow('Failed to discover AWS VPC');
-        });
-
-        it('should discover default VPC when no vpcId specified', async () => {
-            const mockSend = jest.fn();
-            provider.getEC2Client = jest.fn().mockReturnValue({ send: mockSend });
-
-            await provider.discoverVpc({}).catch(() => { });
-
-            // First call should filter for default VPC
-            expect(mockSend).toHaveBeenCalled();
-        });
-    });
-
-    describe('discoverKmsKeys()', () => {
-        beforeEach(() => {
-            provider = new AWSProviderAdapter('us-east-1');
-            const { KMSClient } = require('@aws-sdk/client-kms');
-            KMSClient.mockImplementation(() => ({
-                send: jest.fn(),
-            }));
-        });
-
-        it('should return KMS discovery results', async () => {
-            const mockSend = jest.fn()
-                .mockResolvedValueOnce({ // ListKeys
-                    Keys: [{ KeyId: 'key-123' }],
-                })
-                .mockResolvedValueOnce({ // DescribeKey
-                    KeyMetadata: {
-                        KeyId: 'key-123',
-                        Arn: 'arn:aws:kms:us-east-1:123:key/abc',
-                        Enabled: true,
-                    },
-                })
-                .mockResolvedValueOnce({ // ListAliases
-                    Aliases: [
-                        { AliasName: 'alias/my-key', TargetKeyId: 'key-123' },
-                    ],
-                });
-
-            provider.getKMSClient = jest.fn().mockReturnValue({ send: mockSend });
-
-            const result = await provider.discoverKmsKeys({});
-
-            expect(result.keys.length).toBeGreaterThan(0);
-            expect(result.defaultKey).toBeDefined();
-        });
-
-        it('should handle discovery errors', async () => {
-            provider.getKMSClient = jest.fn().mockReturnValue({
-                send: jest.fn().mockRejectedValue(new Error('KMS API Error')),
-            });
-
-            await expect(provider.discoverKmsKeys({})).rejects.toThrow('Failed to discover AWS KMS keys');
-        });
-    });
-
-    describe('discoverDatabase()', () => {
-        beforeEach(() => {
-            provider = new AWSProviderAdapter('us-east-1');
-            const { RDSClient } = require('@aws-sdk/client-rds');
-            RDSClient.mockImplementation(() => ({
-                send: jest.fn(),
-            }));
-        });
-
-        it('should return database discovery results', async () => {
-            const mockSend = jest.fn()
-                .mockResolvedValueOnce({ // Clusters
-                    DBClusters: [
-                        {
-                            DBClusterIdentifier: 'cluster-1',
-                            Endpoint: 'cluster-1.example.com',
-                            Port: 5432,
-                            Engine: 'aurora-postgresql',
-                        },
-                    ],
-                })
-                .mockResolvedValueOnce({ DBInstances: [] }); // Instances
-
-            provider.getRDSClient = jest.fn().mockReturnValue({ send: mockSend });
-
-            const result = await provider.discoverDatabase({});
-
-            expect(result.endpoint).toBe('cluster-1.example.com');
-            expect(result.port).toBe(5432);
-            expect(result.engine).toBe('aurora-postgresql');
-        });
-
-        it('should handle discovery errors', async () => {
-            provider.getRDSClient = jest.fn().mockReturnValue({
-                send: jest.fn().mockRejectedValue(new Error('RDS API Error')),
-            });
-
-            await expect(provider.discoverDatabase({})).rejects.toThrow('Failed to discover AWS databases');
-        });
-    });
-
-    describe('discoverParameters()', () => {
-        beforeEach(() => {
-            provider = new AWSProviderAdapter('us-east-1');
-        });
-
-        it('should return parameter discovery results', async () => {
-            const mockSSMSend = jest.fn().mockResolvedValue({
-                Parameters: [
-                    { Name: '/my-app/api-key', Value: 'encrypted' },
-                ],
-            });
-
-            const mockSMSend = jest.fn().mockResolvedValue({
-                SecretList: [
-                    { Name: 'my-app/secret', ARN: 'arn:aws:secretsmanager:us-east-1:123:secret:my-app/secret' },
-                ],
-            });
-
-            provider.getSSMClient = jest.fn().mockReturnValue({ send: mockSSMSend });
-            provider.getSecretsManagerClient = jest.fn().mockReturnValue({ send: mockSMSend });
-
-            const result = await provider.discoverParameters({
-                parameterPath: '/my-app',
-                includeSecrets: true,
-            });
-
-            expect(result.parameters).toHaveLength(1);
-            expect(result.secrets).toHaveLength(1);
-        });
-
-        it('should handle discovery errors', async () => {
-            provider.getSSMClient = jest.fn().mockReturnValue({
-                send: jest.fn().mockRejectedValue(new Error('SSM API Error')),
-            });
-
-            await expect(provider.discoverParameters({ parameterPath: '/test' })).rejects.toThrow('Failed to discover AWS parameters');
-        });
-
-        it('should skip secrets when includeSecrets is false', async () => {
-            const mockSSMSend = jest.fn().mockResolvedValue({ Parameters: [] });
-
-            provider.getSSMClient = jest.fn().mockReturnValue({ send: mockSSMSend });
-
-            const result = await provider.discoverParameters({
-                includeSecrets: false,
-            });
-
-            expect(result.parameters).toEqual([]);
-            expect(result.secrets).toEqual([]);
-            // Behavior-based test: secrets should be empty when includeSecrets is false
-            // (Implementation detail: getSecretsManagerClient shouldn't be called)
-        });
-    });
-});
-

package/infrastructure/domains/shared/providers/azure-provider-adapter.stub.js

@@ -1,93 +0,0 @@
-/**
- * FUTURE: Microsoft Azure Provider Adapter
- * 
- * This file serves as a placeholder for future Azure support.
- * 
- * Implementation will use:
- * - @azure/arm-network for Virtual Network discovery
- * - @azure/keyvault-keys for Key Vault key management
- * - @azure/arm-sql for Azure SQL database discovery
- * - @azure/keyvault-secrets for secrets management
- * - @azure/arm-resources for resource group management
- * 
- * Resources:
- * - Azure SDK for JavaScript: https://docs.microsoft.com/en-us/javascript/azure/
- * - ARM Network API: https://docs.microsoft.com/en-us/javascript/api/@azure/arm-network
- * - Key Vault API: https://docs.microsoft.com/en-us/javascript/api/@azure/keyvault-keys
- * - Azure SQL API: https://docs.microsoft.com/en-us/javascript/api/@azure/arm-sql
- * 
- * Architecture mapping:
- * - AWS VPC → Azure Virtual Network (VNet)
- * - AWS KMS → Azure Key Vault
- * - AWS RDS Aurora → Azure SQL Database / Azure Database for PostgreSQL
- * - AWS SSM Parameter Store → Azure Key Vault Secrets
- * - AWS Lambda → Azure Functions
- * 
- * Example structure:
- * 
- * const { NetworkManagementClient } = require('@azure/arm-network');
- * const { KeyClient } = require('@azure/keyvault-keys');
- * const { DefaultAzureCredential } = require('@azure/identity');
- * const { CloudProviderAdapter } = require('./cloud-provider-adapter');
- * 
- * class AzureProviderAdapter extends CloudProviderAdapter {
- *     constructor(region, credentials = {}) {
- *         super();
- *         this.region = region || 'eastus';
- *         this.subscriptionId = credentials.subscriptionId || process.env.AZURE_SUBSCRIPTION_ID;
- *         this.credential = new DefaultAzureCredential();
- *         
- *         this.networkClient = new NetworkManagementClient(
- *             this.credential,
- *             this.subscriptionId
- *         );
- *     }
- * 
- *     getName() {
- *         return 'azure';
- *     }
- * 
- *     getSupportedRegions() {
- *         return [
- *             'eastus', 'eastus2', 'westus', 'westus2',
- *             'northeurope', 'westeurope', 'southeastasia'
- *         ];
- *     }
- * 
- *     async discoverVpc(config) {
- *         // Discover Azure Virtual Networks
- *         const vnets = [];
- *         for await (const vnet of this.networkClient.virtualNetworks.listAll()) {
- *             vnets.push(vnet);
- *         }
- *         // ... implementation
- *     }
- * 
- *     async discoverKmsKeys(config) {
- *         // Discover Azure Key Vault keys
- *         const keyVaultUrl = `https://${config.keyVaultName}.vault.azure.net`;
- *         const keyClient = new KeyClient(keyVaultUrl, this.credential);
- *         const keys = [];
- *         for await (const key of keyClient.listPropertiesOfKeys()) {
- *             keys.push(key);
- *         }
- *         // ... implementation
- *     }
- * 
- *     async discoverDatabase(config) {
- *         // Discover Azure SQL databases
- *         // ... implementation
- *     }
- * 
- *     async discoverParameters(config) {
- *         // Discover Azure Key Vault secrets
- *         // ... implementation
- *     }
- * }
- * 
- * module.exports = { AzureProviderAdapter };
- */
-
-// Placeholder export to prevent import errors
-module.exports = {};
-

package/infrastructure/domains/shared/providers/cloud-provider-adapter.js

@@ -1,136 +0,0 @@
-/**
- * Cloud Provider Adapter (Abstract Base Class)
- * 
- * Port - Hexagonal Architecture
- * 
- * Defines the contract for cloud provider implementations.
- * This abstraction enables multi-cloud support by providing a consistent
- * interface for AWS, GCP, Azure, and other cloud providers.
- * 
- * Benefits:
- * - Cloud-agnostic infrastructure code
- * - Easy to add new providers (just implement this interface)
- * - Testable with mock providers
- * - Clear separation between cloud-specific and business logic
- */
-
-class CloudProviderAdapter {
-    /**
-     * Get provider name
-     * @returns {string} Provider name ('aws', 'gcp', 'azure', etc.)
-     */
-    getName() {
-        throw new Error('CloudProviderAdapter.getName() must be implemented by subclass');
-    }
-
-    /**
-     * Get supported regions for this provider
-     * @returns {Array<string>} List of supported region identifiers
-     */
-    getSupportedRegions() {
-        throw new Error('CloudProviderAdapter.getSupportedRegions() must be implemented by subclass');
-    }
-
-    // ==================== Discovery Methods ====================
-
-    /**
-     * Discover VPC/network resources
-     * 
-     * @param {Object} config - Discovery configuration
-     * @param {string} [config.vpcId] - Specific VPC ID to discover
-     * @param {string} [config.vpcName] - VPC name pattern to search for
-     * @param {boolean} [config.includeSubnets] - Whether to include subnet details
-     * @returns {Promise<Object>} Discovered VPC resources
-     * @returns {Promise<Object>} result.vpcId - VPC identifier
-     * @returns {Promise<Object>} result.vpcCidr - VPC CIDR block
-     * @returns {Promise<Object>} result.subnets - Array of subnet objects
-     * @returns {Promise<Object>} result.securityGroups - Array of security group objects
-     * @returns {Promise<Object>} result.routeTables - Array of route table objects
-     */
-    async discoverVpc(config) {
-        throw new Error('CloudProviderAdapter.discoverVpc() must be implemented by subclass');
-    }
-
-    /**
-     * Discover encryption keys (KMS, Cloud KMS, Azure Key Vault, etc.)
-     * 
-     * @param {Object} config - Discovery configuration
-     * @param {string} [config.keyId] - Specific key ID to discover
-     * @param {string} [config.keyAlias] - Key alias to search for
-     * @returns {Promise<Object>} Discovered encryption key resources
-     * @returns {Promise<Object>} result.keyId - Key identifier
-     * @returns {Promise<Object>} result.keyArn - Key ARN/resource name
-     * @returns {Promise<Object>} result.aliases - Array of key aliases
-     */
-    async discoverKmsKeys(config) {
-        throw new Error('CloudProviderAdapter.discoverKmsKeys() must be implemented by subclass');
-    }
-
-    /**
-     * Discover database resources (RDS, Cloud SQL, Azure SQL, etc.)
-     * 
-     * @param {Object} config - Discovery configuration
-     * @param {string} [config.databaseId] - Specific database instance/cluster ID
-     * @param {string} [config.engine] - Database engine filter ('postgresql', 'mysql', etc.)
-     * @returns {Promise<Object>} Discovered database resources
-     * @returns {Promise<Object>} result.endpoint - Database connection endpoint
-     * @returns {Promise<Object>} result.port - Database port
-     * @returns {Promise<Object>} result.engine - Database engine type
-     * @returns {Promise<Object>} result.version - Database version
-     */
-    async discoverDatabase(config) {
-        throw new Error('CloudProviderAdapter.discoverDatabase() must be implemented by subclass');
-    }
-
-    /**
-     * Discover parameter store/secret manager resources
-     * 
-     * @param {Object} config - Discovery configuration
-     * @param {string} [config.parameterPath] - Parameter path prefix to search
-     * @param {string} [config.secretName] - Specific secret name to discover
-     * @returns {Promise<Object>} Discovered parameter/secret resources
-     * @returns {Promise<Object>} result.parameters - Array of parameter objects
-     * @returns {Promise<Object>} result.secrets - Array of secret objects
-     */
-    async discoverParameters(config) {
-        throw new Error('CloudProviderAdapter.discoverParameters() must be implemented by subclass');
-    }
-
-    // ==================== Provisioning Methods (Future) ====================
-    // These will be used for Terraform/Pulumi/CloudFormation generation
-
-    /**
-     * Generate VPC provisioning configuration
-     * 
-     * @param {Object} config - VPC configuration
-     * @returns {Promise<Object>} Infrastructure-as-code configuration
-     */
-    async provisionVpc(config) {
-        throw new Error('CloudProviderAdapter.provisionVpc() not yet implemented. Future feature for IaC generation.');
-    }
-
-    /**
-     * Generate encryption key provisioning configuration
-     * 
-     * @param {Object} config - Key configuration
-     * @returns {Promise<Object>} Infrastructure-as-code configuration
-     */
-    async provisionKmsKey(config) {
-        throw new Error('CloudProviderAdapter.provisionKmsKey() not yet implemented. Future feature for IaC generation.');
-    }
-
-    /**
-     * Generate database provisioning configuration
-     * 
-     * @param {Object} config - Database configuration
-     * @returns {Promise<Object>} Infrastructure-as-code configuration
-     */
-    async provisionDatabase(config) {
-        throw new Error('CloudProviderAdapter.provisionDatabase() not yet implemented. Future feature for IaC generation.');
-    }
-}
-
-module.exports = {
-    CloudProviderAdapter,
-};
-