@friggframework/devtools 2.0.0--canary.461.ec909cf.0 → 2.0.0--canary.461.7b36f0f.0

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

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

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

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

@@ -0,0 +1,82 @@
+/**
+ * FUTURE: Google Cloud Platform Provider Adapter
+ * 
+ * This file serves as a placeholder for future GCP support.
+ * 
+ * Implementation will use:
+ * - @google-cloud/compute for VPC/network discovery
+ * - @google-cloud/kms for encryption key management
+ * - @google-cloud/sql for Cloud SQL database discovery
+ * - @google-cloud/secret-manager for secrets management
+ * 
+ * Resources:
+ * - GCP Node.js SDK: https://cloud.google.com/nodejs/docs/reference
+ * - Compute Engine API: https://cloud.google.com/compute/docs/reference/rest/v1
+ * - Cloud KMS API: https://cloud.google.com/kms/docs/reference/rest
+ * - Cloud SQL API: https://cloud.google.com/sql/docs/mysql/admin-api
+ * 
+ * Architecture mapping:
+ * - AWS VPC → GCP VPC Network
+ * - AWS KMS → GCP Cloud KMS
+ * - AWS RDS Aurora → GCP Cloud SQL
+ * - AWS SSM Parameter Store → GCP Secret Manager
+ * - AWS Lambda → GCP Cloud Functions / Cloud Run
+ * 
+ * Example structure:
+ * 
+ * const { Compute } = require('@google-cloud/compute');
+ * const { KeyManagementServiceClient } = require('@google-cloud/kms');
+ * const { CloudProviderAdapter } = require('./cloud-provider-adapter');
+ * 
+ * class GCPProviderAdapter extends CloudProviderAdapter {
+ *     constructor(region, credentials = {}) {
+ *         super();
+ *         this.region = region || 'us-central1';
+ *         this.projectId = credentials.projectId || process.env.GCP_PROJECT_ID;
+ *         
+ *         this.compute = new Compute({ projectId: this.projectId });
+ *         this.kms = new KeyManagementServiceClient();
+ *     }
+ * 
+ *     getName() {
+ *         return 'gcp';
+ *     }
+ * 
+ *     getSupportedRegions() {
+ *         return [
+ *             'us-central1', 'us-east1', 'us-west1',
+ *             'europe-west1', 'asia-east1', 'asia-northeast1'
+ *         ];
+ *     }
+ * 
+ *     async discoverVpc(config) {
+ *         // Discover GCP VPC networks
+ *         const [networks] = await this.compute.getNetworks();
+ *         // ... implementation
+ *     }
+ * 
+ *     async discoverKmsKeys(config) {
+ *         // Discover GCP Cloud KMS keys
+ *         const [keyRings] = await this.kms.listKeyRings({
+ *             parent: `projects/${this.projectId}/locations/${this.region}`
+ *         });
+ *         // ... implementation
+ *     }
+ * 
+ *     async discoverDatabase(config) {
+ *         // Discover GCP Cloud SQL instances
+ *         // ... implementation
+ *     }
+ * 
+ *     async discoverParameters(config) {
+ *         // Discover GCP Secret Manager secrets
+ *         // ... implementation
+ *     }
+ * }
+ * 
+ * module.exports = { GCPProviderAdapter };
+ */
+
+// Placeholder export to prevent import errors
+module.exports = {};
+

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