simplify resource state logical id during import/clone (#108)

Author: Zee2413

src/resourceState/ResourceStateImporter.ts

@@ -189,21 +189,18 @@ export class ResourceStateImporter {
     }
 
     private generateLogicalId(resourceType: string, identifier: string, existingLogicalIds?: Set<string>): string {
-        // get Bucket from AWS::S3::Bucket or if malformed just the resourceType sanitized
-        const resourceTypeParts = resourceType.split('::');
-        const resourceTypeThirdPartOrFull = resourceTypeParts.pop() ?? resourceType.replaceAll(/[^a-zA-Z]/g, '');
-        if (!existingLogicalIds?.has(resourceTypeThirdPartOrFull)) {
-            return resourceTypeThirdPartOrFull;
+        const parts = resourceType.split('::');
+        const baseName = parts.length >= 3 ? parts[1] + parts[2] : parts[parts.length - 1];
+
+        if (!existingLogicalIds?.has(baseName)) {
+            return baseName;
         }
-        const cleanIdentifier = identifier.replaceAll(/[^a-zA-Z]/g, '');
-        const typeAndId = resourceTypeThirdPartOrFull + cleanIdentifier.slice(0, 10);
-        if (!existingLogicalIds?.has(typeAndId)) {
-            return typeAndId;
+
+        let count = 1;
+        while (existingLogicalIds.has(`${baseName}${count}`)) {
+            count++;
         }
-        return crypto
-            .randomUUID()
-            .replaceAll(/[^a-zA-Z]/g, '')
-            .slice(0, 10);
+        return `${baseName}${count}`;
     }
 
     private getResourceSection(syntaxTree: SyntaxTree): ResourcesSection | undefined {

tst/unit/resourceState/ResourceStateImporter.test.ts

@@ -320,4 +320,98 @@ describe('ResourceStateImporter', () => {
             expect(result.warning).toBeUndefined();
         });
     });
+
+    describe('Logical ID uniqueness', () => {
+        it('should generate unique logical IDs with numeric suffixes', async () => {
+            const uri = 'test://test-unique-ids.template';
+            const initialContent = `{
+  "AWSTemplateFormatVersion": "2010-09-09",
+  "Resources": {
+    "IAMRole": {
+      "Type": "AWS::IAM::Role",
+      "Properties": {
+        "RoleName": "ExistingRole"
+      }
+    },
+    "IAMRole1": {
+      "Type": "AWS::IAM::Role",
+      "Properties": {
+        "RoleName": "ExistingRole1"
+      }
+    }
+  }
+}`;
+
+            createAndRegisterDocument(uri, initialContent, DocumentType.JSON);
+
+            const mockResource = createMockResourceState('AWS::IAM::Role');
+            const resourceSelections: ResourceSelection[] = [
+                {
+                    resourceType: 'AWS::IAM::Role',
+                    resourceIdentifiers: [mockResource.identifier],
+                },
+            ];
+
+            mockResourceStateManager.getResource.mockResolvedValue(mockResource);
+
+            const params: ResourceStateParams = {
+                resourceSelections,
+                textDocument: { uri } as any,
+                range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } },
+                context: { diagnostics: [], only: [], triggerKind: 1 },
+                purpose: ResourceStatePurpose.IMPORT,
+            };
+
+            const result = await importer.importResourceState(params);
+
+            expect(result.edit).toBeDefined();
+            expect(result.edit!.changes![uri]).toBeDefined();
+
+            const textEdit = result.edit!.changes![uri][0];
+            expect(textEdit.newText).toContain('"IAMRole2"');
+            expect(textEdit.newText).not.toContain('"IAMRole"');
+            expect(textEdit.newText).not.toContain('"IAMRole1"');
+        });
+
+        it('should generate multiple unique logical IDs in same import', async () => {
+            const uri = 'test://test-multiple-unique-ids.template';
+            const initialContent = `{
+  "AWSTemplateFormatVersion": "2010-09-09",
+  "Resources": {}
+}`;
+
+            createAndRegisterDocument(uri, initialContent, DocumentType.JSON);
+
+            const mockResource1 = createMockResourceState('AWS::IAM::Role');
+            const mockResource2 = createMockResourceState('AWS::IAM::Role');
+            const mockResource3 = createMockResourceState('AWS::IAM::Role');
+
+            const resourceSelections: ResourceSelection[] = [
+                {
+                    resourceType: 'AWS::IAM::Role',
+                    resourceIdentifiers: [mockResource1.identifier, mockResource2.identifier, mockResource3.identifier],
+                },
+            ];
+
+            mockResourceStateManager.getResource.mockResolvedValue(mockResource1);
+
+            const params: ResourceStateParams = {
+                resourceSelections,
+                textDocument: { uri } as any,
+                range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } },
+                context: { diagnostics: [], only: [], triggerKind: 1 },
+                purpose: ResourceStatePurpose.IMPORT,
+            };
+
+            const result = await importer.importResourceState(params);
+
+            expect(result.edit).toBeDefined();
+            expect(result.edit!.changes![uri]).toBeDefined();
+
+            const textEdit = result.edit!.changes![uri][0];
+            expect(textEdit.newText).toContain('"IAMRole"');
+            expect(textEdit.newText).toContain('"IAMRole1"');
+            expect(textEdit.newText).toContain('"IAMRole2"');
+        });
+    });
 });

tst/unit/resourceState/StateImportExpectation.ts

@@ -58,22 +58,8 @@ Resources:
 ];
 
 function getResourceLogicalName(resourceType: string): string {
-    const typeMap: Record<string, string> = {
-        'AWS::S3::Bucket': 'Bucket',
-        'AWS::EC2::Instance': 'Instance',
-        'AWS::IAM::Role': 'Role',
-        'AWS::Lambda::Function': 'Function',
-        'AWS::EC2::VPC': 'VPC',
-        'AWS::EC2::Subnet': 'Subnet',
-        'AWS::EC2::SecurityGroup': 'SecurityGroup',
-        'AWS::EC2::LaunchTemplate': 'LaunchTemplate',
-        'AWS::AutoScaling::AutoScalingGroup': 'AutoScalingGroup',
-        'AWS::RDS::DBInstance': 'DBInstance',
-        'AWS::CloudWatch::Alarm': 'Alarm',
-        'AWS::SNS::Topic': 'Topic',
-        'AWS::SSM::Parameter': 'Parameter',
-    };
-    return typeMap[resourceType] || 'Resource';
+    const parts = resourceType.split('::');
+    return parts.length >= 3 ? parts[1] + parts[2] : parts[parts.length - 1];
 }
 
 function formatPropertiesForJson(properties: any, indent: number = 6): string {