@friggframework/devtools 2.0.0--canary.474.082077e.0 → 2.0.0--canary.474.4793186.0

package/infrastructure/domains/health/infrastructure/adapters/aws-resource-importer.js

@@ -0,0 +1,318 @@
+/**
+ * AWSResourceImporter - AWS CloudFormation Resource Import Adapter
+ *
+ * Infrastructure Adapter - Hexagonal Architecture
+ *
+ * Implements IResourceImporter port for AWS CloudFormation.
+ * Handles resource import operations using CloudFormation change sets.
+ *
+ * Lazy-loads AWS SDK to minimize cold start time and memory usage.
+ */
+
+const IResourceImporter = require('../../application/ports/IResourceImporter');
+
+// Lazy-loaded AWS SDK CloudFormation client
+let CloudFormationClient,
+    CreateChangeSetCommand,
+    DescribeChangeSetCommand,
+    ExecuteChangeSetCommand,
+    GetTemplateCommand;
+
+/**
+ * Lazy load CloudFormation SDK
+ */
+function loadCloudFormation() {
+    if (!CloudFormationClient) {
+        const cfModule = require('@aws-sdk/client-cloudformation');
+        CloudFormationClient = cfModule.CloudFormationClient;
+        CreateChangeSetCommand = cfModule.CreateChangeSetCommand;
+        DescribeChangeSetCommand = cfModule.DescribeChangeSetCommand;
+        ExecuteChangeSetCommand = cfModule.ExecuteChangeSetCommand;
+        GetTemplateCommand = cfModule.GetTemplateCommand;
+    }
+}
+
+class AWSResourceImporter extends IResourceImporter {
+    /**
+     * Resource types that support import
+     * Maps CloudFormation resource type to identifier property
+     * @private
+     */
+    static IMPORTABLE_TYPES = {
+        'AWS::EC2::VPC': 'VpcId',
+        'AWS::EC2::Subnet': 'SubnetId',
+        'AWS::EC2::SecurityGroup': 'GroupId',
+        'AWS::EC2::RouteTable': 'RouteTableId',
+        'AWS::RDS::DBCluster': 'DBClusterIdentifier',
+        'AWS::KMS::Key': 'KeyId',
+    };
+
+    /**
+     * Create AWS Resource Importer
+     *
+     * @param {Object} [config={}]
+     * @param {string} [config.region] - AWS region (defaults to AWS_REGION env var)
+     */
+    constructor(config = {}) {
+        super();
+        this.region = config.region || process.env.AWS_REGION || 'us-east-1';
+        this.client = null;
+    }
+
+    /**
+     * Get or create CloudFormation client
+     * @private
+     */
+    _getClient() {
+        if (!this.client) {
+            loadCloudFormation();
+            this.client = new CloudFormationClient({ region: this.region });
+        }
+        return this.client;
+    }
+
+    /**
+     * Check if a resource type supports import
+     */
+    async supportsImport(resourceType) {
+        return resourceType in AWSResourceImporter.IMPORTABLE_TYPES;
+    }
+
+    /**
+     * Get the identifier property for a resource type
+     */
+    async getIdentifierProperty(resourceType) {
+        if (!(await this.supportsImport(resourceType))) {
+            throw new Error(`Resource type ${resourceType} does not support import`);
+        }
+
+        return AWSResourceImporter.IMPORTABLE_TYPES[resourceType];
+    }
+
+    /**
+     * Validate that a resource can be imported
+     */
+    async validateImport({ resourceType, physicalId, region }) {
+        const canImport = await this.supportsImport(resourceType);
+
+        if (!canImport) {
+            return {
+                canImport: false,
+                reason: `Resource type ${resourceType} is not supported for import`,
+                warnings: [],
+            };
+        }
+
+        // Add resource-specific warnings
+        const warnings = [];
+        if (resourceType === 'AWS::RDS::DBCluster') {
+            warnings.push(
+                'Ensure DBCluster has required properties (Engine, MasterUsername, etc.)'
+            );
+        }
+
+        return {
+            canImport: true,
+            reason: '',
+            warnings,
+        };
+    }
+
+    /**
+     * Import a single resource into a stack
+     */
+    async importResource({ stackIdentifier, logicalId, resourceType, physicalId, properties }) {
+        // Validate resource type
+        if (!(await this.supportsImport(resourceType))) {
+            throw new Error(`Resource type ${resourceType} does not support import`);
+        }
+
+        const client = this._getClient();
+
+        // Get identifier property
+        const identifierProperty = await this.getIdentifierProperty(resourceType);
+
+        // Create change set for import
+        const changeSetName = `import-${logicalId}-${Date.now()}`;
+
+        const createChangeSetCommand = new CreateChangeSetCommand({
+            StackName: stackIdentifier.stackName,
+            ChangeSetName: changeSetName,
+            ChangeSetType: 'IMPORT',
+            ResourcesToImport: [
+                {
+                    ResourceType: resourceType,
+                    LogicalResourceId: logicalId,
+                    ResourceIdentifier: {
+                        [identifierProperty]: physicalId,
+                    },
+                },
+            ],
+            TemplateBody: JSON.stringify({
+                Resources: {
+                    [logicalId]: {
+                        Type: resourceType,
+                        Properties: properties,
+                    },
+                },
+            }),
+        });
+
+        const createResponse = await client.send(createChangeSetCommand);
+
+        // Execute the change set
+        const executeCommand = new ExecuteChangeSetCommand({
+            ChangeSetName: changeSetName,
+            StackName: stackIdentifier.stackName,
+        });
+
+        await client.send(executeCommand);
+
+        return {
+            operationId: createResponse.Id,
+            status: 'IN_PROGRESS',
+            message: `Resource import initiated via change set ${createResponse.Id}`,
+        };
+    }
+
+    /**
+     * Import multiple resources into a stack in a single operation
+     */
+    async importMultipleResources({ stackIdentifier, resources }) {
+        const client = this._getClient();
+
+        // Filter to only supported resources
+        const supportedResources = [];
+        const unsupportedResources = [];
+
+        for (const resource of resources) {
+            if (await this.supportsImport(resource.resourceType)) {
+                supportedResources.push(resource);
+            } else {
+                unsupportedResources.push(resource);
+            }
+        }
+
+        if (supportedResources.length === 0) {
+            return {
+                operationId: null,
+                status: 'FAILED',
+                importedCount: 0,
+                failedCount: resources.length,
+                message: 'No supported resources to import',
+                details: [],
+            };
+        }
+
+        // Build resources to import
+        const resourcesToImport = [];
+        const templateResources = {};
+
+        for (const resource of supportedResources) {
+            const identifierProperty = await this.getIdentifierProperty(resource.resourceType);
+
+            resourcesToImport.push({
+                ResourceType: resource.resourceType,
+                LogicalResourceId: resource.logicalId,
+                ResourceIdentifier: {
+                    [identifierProperty]: resource.physicalId,
+                },
+            });
+
+            templateResources[resource.logicalId] = {
+                Type: resource.resourceType,
+                Properties: resource.properties,
+            };
+        }
+
+        // Create change set for import
+        const changeSetName = `import-multi-${Date.now()}`;
+
+        const createChangeSetCommand = new CreateChangeSetCommand({
+            StackName: stackIdentifier.stackName,
+            ChangeSetName: changeSetName,
+            ChangeSetType: 'IMPORT',
+            ResourcesToImport: resourcesToImport,
+            TemplateBody: JSON.stringify({
+                Resources: templateResources,
+            }),
+        });
+
+        const createResponse = await client.send(createChangeSetCommand);
+
+        // Execute the change set
+        const executeCommand = new ExecuteChangeSetCommand({
+            ChangeSetName: changeSetName,
+            StackName: stackIdentifier.stackName,
+        });
+
+        await client.send(executeCommand);
+
+        return {
+            operationId: createResponse.Id,
+            status: 'IN_PROGRESS',
+            importedCount: supportedResources.length,
+            failedCount: unsupportedResources.length,
+            message: `Import operation initiated for ${supportedResources.length} resources`,
+            details: [],
+        };
+    }
+
+    /**
+     * Get status of an import operation
+     */
+    async getImportStatus(operationId) {
+        const client = this._getClient();
+
+        const command = new DescribeChangeSetCommand({
+            ChangeSetName: operationId,
+        });
+
+        const response = await client.send(command);
+
+        // Map CloudFormation status to our status
+        let status = 'IN_PROGRESS';
+        let progress = 0;
+
+        if (response.ExecutionStatus === 'EXECUTE_COMPLETE') {
+            status = 'COMPLETE';
+            progress = 100;
+        } else if (response.Status === 'FAILED' || response.ExecutionStatus === 'EXECUTE_FAILED') {
+            status = 'FAILED';
+            progress = 0;
+        } else if (response.Status === 'CREATE_COMPLETE') {
+            status = 'IN_PROGRESS';
+            progress = 50;
+        } else if (response.Status === 'CREATE_PENDING') {
+            status = 'IN_PROGRESS';
+            progress = 25;
+        }
+
+        return {
+            operationId,
+            status,
+            progress,
+            message: response.StatusReason || '',
+            completedTime: status === 'COMPLETE' ? response.CreationTime : null,
+        };
+    }
+
+    /**
+     * Generate CloudFormation template snippet for an imported resource
+     */
+    async generateTemplateSnippet({ logicalId, resourceType, properties }) {
+        // Validate resource type
+        if (!(await this.supportsImport(resourceType))) {
+            throw new Error(`Resource type ${resourceType} does not support import`);
+        }
+
+        return {
+            [logicalId]: {
+                Type: resourceType,
+                Properties: properties,
+            },
+        };
+    }
+}
+
+module.exports = AWSResourceImporter;

package/infrastructure/domains/health/infrastructure/adapters/aws-resource-importer.test.js

@@ -0,0 +1,398 @@
+/**
+ * Tests for AWSResourceImporter Adapter
+ *
+ * Tests CloudFormation resource import operations using mocked AWS SDK
+ */
+
+const AWSResourceImporter = require('./aws-resource-importer');
+const StackIdentifier = require('../../domain/value-objects/stack-identifier');
+
+// Mock AWS SDK
+jest.mock('@aws-sdk/client-cloudformation', () => ({
+    CloudFormationClient: jest.fn(),
+    CreateChangeSetCommand: jest.fn(),
+    DescribeChangeSetCommand: jest.fn(),
+    ExecuteChangeSetCommand: jest.fn(),
+    GetTemplateCommand: jest.fn(),
+}));
+
+describe('AWSResourceImporter', () => {
+    let importer;
+    let mockSend;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        mockSend = jest.fn();
+        const { CloudFormationClient } = require('@aws-sdk/client-cloudformation');
+        CloudFormationClient.mockImplementation(() => ({ send: mockSend }));
+
+        importer = new AWSResourceImporter({ region: 'us-east-1' });
+    });
+
+    describe('supportsImport', () => {
+        it('should return true for VPC', async () => {
+            const supports = await importer.supportsImport('AWS::EC2::VPC');
+            expect(supports).toBe(true);
+        });
+
+        it('should return true for RDS DBCluster', async () => {
+            const supports = await importer.supportsImport('AWS::RDS::DBCluster');
+            expect(supports).toBe(true);
+        });
+
+        it('should return true for KMS Key', async () => {
+            const supports = await importer.supportsImport('AWS::KMS::Key');
+            expect(supports).toBe(true);
+        });
+
+        it('should return false for unsupported type', async () => {
+            const supports = await importer.supportsImport('AWS::Lambda::Function');
+            expect(supports).toBe(false);
+        });
+    });
+
+    describe('getIdentifierProperty', () => {
+        it('should return VpcId for VPC', async () => {
+            const prop = await importer.getIdentifierProperty('AWS::EC2::VPC');
+            expect(prop).toBe('VpcId');
+        });
+
+        it('should return SubnetId for Subnet', async () => {
+            const prop = await importer.getIdentifierProperty('AWS::EC2::Subnet');
+            expect(prop).toBe('SubnetId');
+        });
+
+        it('should return DBClusterIdentifier for RDS DBCluster', async () => {
+            const prop = await importer.getIdentifierProperty('AWS::RDS::DBCluster');
+            expect(prop).toBe('DBClusterIdentifier');
+        });
+
+        it('should throw error for unsupported type', async () => {
+            await expect(
+                importer.getIdentifierProperty('AWS::Lambda::Function')
+            ).rejects.toThrow('Resource type AWS::Lambda::Function does not support import');
+        });
+    });
+
+    describe('validateImport', () => {
+        it('should validate VPC import', async () => {
+            const result = await importer.validateImport({
+                resourceType: 'AWS::EC2::VPC',
+                physicalId: 'vpc-123',
+                region: 'us-east-1',
+            });
+
+            expect(result).toEqual({
+                canImport: true,
+                reason: '',
+                warnings: [],
+            });
+        });
+
+        it('should fail validation for unsupported type', async () => {
+            const result = await importer.validateImport({
+                resourceType: 'AWS::Lambda::Function',
+                physicalId: 'my-function',
+                region: 'us-east-1',
+            });
+
+            expect(result.canImport).toBe(false);
+            expect(result.reason).toContain('not supported');
+        });
+
+        it('should warn about missing required properties', async () => {
+            const result = await importer.validateImport({
+                resourceType: 'AWS::RDS::DBCluster',
+                physicalId: 'my-cluster',
+                region: 'us-east-1',
+            });
+
+            expect(result.canImport).toBe(true);
+            expect(result.warnings).toContain(
+                'Ensure DBCluster has required properties (Engine, MasterUsername, etc.)'
+            );
+        });
+    });
+
+    describe('importResource', () => {
+        it('should import a single VPC resource', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            // Mock CreateChangeSet
+            mockSend.mockResolvedValueOnce({
+                Id: 'changeset-123',
+                StackId: 'arn:aws:cloudformation:us-east-1:123456789012:stack/my-app-prod/guid',
+            });
+
+            // Mock ExecuteChangeSet
+            mockSend.mockResolvedValueOnce({});
+
+            const result = await importer.importResource({
+                stackIdentifier,
+                logicalId: 'ImportedVPC',
+                resourceType: 'AWS::EC2::VPC',
+                physicalId: 'vpc-123',
+                properties: {
+                    CidrBlock: '10.0.0.0/16',
+                    EnableDnsSupport: true,
+                },
+            });
+
+            expect(result).toEqual({
+                operationId: 'changeset-123',
+                status: 'IN_PROGRESS',
+                message: 'Resource import initiated via change set changeset-123',
+            });
+
+            expect(mockSend).toHaveBeenCalledTimes(2);
+        });
+
+        it('should throw error for unsupported resource type', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            await expect(
+                importer.importResource({
+                    stackIdentifier,
+                    logicalId: 'MyFunction',
+                    resourceType: 'AWS::Lambda::Function',
+                    physicalId: 'my-function',
+                    properties: {},
+                })
+            ).rejects.toThrow('Resource type AWS::Lambda::Function does not support import');
+        });
+
+        it('should handle import failure', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const error = new Error('Resource already exists in stack');
+            error.name = 'AlreadyExistsException';
+            mockSend.mockRejectedValue(error);
+
+            await expect(
+                importer.importResource({
+                    stackIdentifier,
+                    logicalId: 'ExistingVPC',
+                    resourceType: 'AWS::EC2::VPC',
+                    physicalId: 'vpc-123',
+                    properties: { CidrBlock: '10.0.0.0/16' },
+                })
+            ).rejects.toThrow('Resource already exists in stack');
+        });
+    });
+
+    describe('importMultipleResources', () => {
+        it('should import multiple resources in single operation', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const resources = [
+                {
+                    logicalId: 'ImportedVPC',
+                    resourceType: 'AWS::EC2::VPC',
+                    physicalId: 'vpc-123',
+                    properties: { CidrBlock: '10.0.0.0/16' },
+                },
+                {
+                    logicalId: 'ImportedSubnet',
+                    resourceType: 'AWS::EC2::Subnet',
+                    physicalId: 'subnet-456',
+                    properties: { VpcId: 'vpc-123', CidrBlock: '10.0.1.0/24' },
+                },
+            ];
+
+            // Mock CreateChangeSet
+            mockSend.mockResolvedValueOnce({
+                Id: 'changeset-multi-123',
+                StackId: 'arn:aws:cloudformation:us-east-1:123456789012:stack/my-app-prod/guid',
+            });
+
+            // Mock ExecuteChangeSet
+            mockSend.mockResolvedValueOnce({});
+
+            const result = await importer.importMultipleResources({
+                stackIdentifier,
+                resources,
+            });
+
+            expect(result).toEqual({
+                operationId: 'changeset-multi-123',
+                status: 'IN_PROGRESS',
+                importedCount: 2,
+                failedCount: 0,
+                message: 'Import operation initiated for 2 resources',
+                details: [],
+            });
+        });
+
+        it('should filter out unsupported resource types', async () => {
+            const stackIdentifier = new StackIdentifier({
+                stackName: 'my-app-prod',
+                region: 'us-east-1',
+            });
+
+            const resources = [
+                {
+                    logicalId: 'ImportedVPC',
+                    resourceType: 'AWS::EC2::VPC',
+                    physicalId: 'vpc-123',
+                    properties: { CidrBlock: '10.0.0.0/16' },
+                },
+                {
+                    logicalId: 'UnsupportedFunction',
+                    resourceType: 'AWS::Lambda::Function',
+                    physicalId: 'my-function',
+                    properties: {},
+                },
+            ];
+
+            // Mock CreateChangeSet (only for VPC)
+            mockSend.mockResolvedValueOnce({
+                Id: 'changeset-filtered-123',
+                StackId: 'arn:aws:cloudformation:us-east-1:123456789012:stack/my-app-prod/guid',
+            });
+
+            // Mock ExecuteChangeSet
+            mockSend.mockResolvedValueOnce({});
+
+            const result = await importer.importMultipleResources({
+                stackIdentifier,
+                resources,
+            });
+
+            expect(result.importedCount).toBe(1);
+            expect(result.failedCount).toBe(1);
+        });
+    });
+
+    describe('getImportStatus', () => {
+        it('should get status of in-progress import', async () => {
+            mockSend.mockResolvedValue({
+                Status: 'CREATE_PENDING',
+                ExecutionStatus: 'AVAILABLE',
+                StatusReason: 'Change set created',
+            });
+
+            const status = await importer.getImportStatus('changeset-123');
+
+            expect(status).toEqual({
+                operationId: 'changeset-123',
+                status: 'IN_PROGRESS',
+                progress: 25,
+                message: 'Change set created',
+                completedTime: null,
+            });
+        });
+
+        it('should get status of completed import', async () => {
+            const completedTime = new Date('2024-01-15T10:30:00Z');
+
+            mockSend.mockResolvedValue({
+                Status: 'CREATE_COMPLETE',
+                ExecutionStatus: 'EXECUTE_COMPLETE',
+                StatusReason: 'Import completed successfully',
+                CreationTime: completedTime,
+            });
+
+            const status = await importer.getImportStatus('changeset-123');
+
+            expect(status.status).toBe('COMPLETE');
+            expect(status.progress).toBe(100);
+            expect(status.completedTime).toEqual(completedTime);
+        });
+
+        it('should get status of failed import', async () => {
+            mockSend.mockResolvedValue({
+                Status: 'FAILED',
+                ExecutionStatus: 'EXECUTE_FAILED',
+                StatusReason: 'Resource already exists',
+            });
+
+            const status = await importer.getImportStatus('changeset-123');
+
+            expect(status.status).toBe('FAILED');
+            expect(status.message).toContain('already exists');
+        });
+    });
+
+    describe('generateTemplateSnippet', () => {
+        it('should generate VPC template snippet', async () => {
+            const snippet = await importer.generateTemplateSnippet({
+                logicalId: 'ImportedVPC',
+                resourceType: 'AWS::EC2::VPC',
+                properties: {
+                    CidrBlock: '10.0.0.0/16',
+                    EnableDnsSupport: true,
+                    EnableDnsHostnames: true,
+                },
+            });
+
+            expect(snippet).toEqual({
+                ImportedVPC: {
+                    Type: 'AWS::EC2::VPC',
+                    Properties: {
+                        CidrBlock: '10.0.0.0/16',
+                        EnableDnsSupport: true,
+                        EnableDnsHostnames: true,
+                    },
+                },
+            });
+        });
+
+        it('should generate RDS DBCluster template snippet', async () => {
+            const snippet = await importer.generateTemplateSnippet({
+                logicalId: 'ImportedCluster',
+                resourceType: 'AWS::RDS::DBCluster',
+                properties: {
+                    Engine: 'aurora-postgresql',
+                    EngineVersion: '13.7',
+                    MasterUsername: 'admin',
+                },
+            });
+
+            expect(snippet).toEqual({
+                ImportedCluster: {
+                    Type: 'AWS::RDS::DBCluster',
+                    Properties: {
+                        Engine: 'aurora-postgresql',
+                        EngineVersion: '13.7',
+                        MasterUsername: 'admin',
+                    },
+                },
+            });
+        });
+
+        it('should throw error for unsupported resource type', async () => {
+            await expect(
+                importer.generateTemplateSnippet({
+                    logicalId: 'MyFunction',
+                    resourceType: 'AWS::Lambda::Function',
+                    properties: {},
+                })
+            ).rejects.toThrow('Resource type AWS::Lambda::Function does not support import');
+        });
+    });
+
+    describe('constructor', () => {
+        it('should create instance with default region', () => {
+            const imp = new AWSResourceImporter();
+            expect(imp).toBeInstanceOf(AWSResourceImporter);
+        });
+
+        it('should create instance with custom region', () => {
+            const imp = new AWSResourceImporter({ region: 'eu-west-1' });
+            expect(imp).toBeInstanceOf(AWSResourceImporter);
+        });
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.474.082077e.0",
+  "version": "2.0.0--canary.474.4793186.0",
   "dependencies": {
     "@aws-sdk/client-ec2": "^3.835.0",
     "@aws-sdk/client-kms": "^3.835.0",
@@ -11,8 +11,8 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/schemas": "2.0.0--canary.474.082077e.0",
-    "@friggframework/test": "2.0.0--canary.474.082077e.0",
+    "@friggframework/schemas": "2.0.0--canary.474.4793186.0",
+    "@friggframework/test": "2.0.0--canary.474.4793186.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -34,8 +34,8 @@
     "serverless-http": "^2.7.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.474.082077e.0",
-    "@friggframework/prettier-config": "2.0.0--canary.474.082077e.0",
+    "@friggframework/eslint-config": "2.0.0--canary.474.4793186.0",
+    "@friggframework/prettier-config": "2.0.0--canary.474.4793186.0",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "jest": "^30.1.3",
@@ -70,5 +70,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "082077ef7bba084fdeaaee60a08f9039542bff40"
+  "gitHead": "47931865212a71b5e52aaf06bc9c1e49dbb3171e"
 }