Add error message to resource importer result

src/autocomplete/ResourceStateCompletionProvider.ts

@@ -53,12 +53,15 @@ export class ResourceStateCompletionProvider implements CompletionProvider {
         }
 
         log.info(`Retrieving resource details from AWS account with id: ${identifier} and type: ${resource.Type}`);
-        const resourceState = await this.resourceStateManager.getResource(resource.Type, identifier);
-        const properties = resourceState?.properties;
-        if (!properties) {
+        let properties: string;
+        try {
+            const resourceState = await this.resourceStateManager.getResource(resource.Type, identifier);
+            properties = resourceState.properties;
+        } catch {
             log.info(`No resource found for id: ${identifier} and type: ${resource.Type}`);
             return [];
         }
+
         const propertiesObj = JSON.parse(properties) as Record<string, string>;
         this.applyTransformers(propertiesObj, schema);
         this.removeExistingProperties(propertiesObj, resource);

src/resourceState/ResourceStateImporter.ts

@@ -160,6 +160,7 @@ export class ResourceStateImporter {
             completionItem: undefined,
             failedImports: {},
             successfulImports: {},
+            failureReasons: {},
         };
 
         const generatedLogicalIds = new Set<string>();
@@ -176,36 +177,31 @@ export class ResourceStateImporter {
             for (const resourceIdentifier of resourceSelection.resourceIdentifiers) {
                 try {
                     const resourceState = await this.resourceStateManager.getResource(resourceType, resourceIdentifier);
-                    if (resourceState) {
-                        this.getOrCreate(importResult.successfulImports, resourceType, []).push(resourceIdentifier);
-                        const logicalId = this.generateUniqueLogicalId(
-                            resourceType,
-                            resourceIdentifier,
-                            syntaxTree,
-                            generatedLogicalIds,
-                            parentResourceType,
-                        );
-                        generatedLogicalIds.add(logicalId);
-                        fetchedResourceStates.push({
-                            [logicalId]: {
-                                Type: resourceType,
-                                DeletionPolicy:
-                                    purpose === ResourceStatePurpose.IMPORT ? DeletionPolicyOnImport : undefined,
-                                Properties: this.applyTransformations(
-                                    resourceState.properties,
-                                    schema,
-                                    purpose,
-                                    logicalId,
-                                ),
-                                Metadata: await this.createMetadata(resourceIdentifier, purpose),
-                            },
-                        });
-                    } else {
-                        this.getOrCreate(importResult.failedImports, resourceType, []).push(resourceIdentifier);
-                    }
+                    this.getOrCreate(importResult.successfulImports, resourceType, []).push(resourceIdentifier);
+                    const logicalId = this.generateUniqueLogicalId(
+                        resourceType,
+                        resourceIdentifier,
+                        syntaxTree,
+                        generatedLogicalIds,
+                        parentResourceType,
+                    );
+                    generatedLogicalIds.add(logicalId);
+                    fetchedResourceStates.push({
+                        [logicalId]: {
+                            Type: resourceType,
+                            DeletionPolicy:
+                                purpose === ResourceStatePurpose.IMPORT ? DeletionPolicyOnImport : undefined,
+                            Properties: this.applyTransformations(resourceState.properties, schema, purpose, logicalId),
+                            Metadata: await this.createMetadata(resourceIdentifier, purpose),
+                        },
+                    });
                 } catch (error) {
                     log.error(error, `Error importing resource state for ${resourceType} id: ${resourceIdentifier}`);
                     this.getOrCreate(importResult.failedImports, resourceType, []).push(resourceIdentifier);
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    importResult.failureReasons ??= {};
+                    importResult.failureReasons[resourceType] ??= {};
+                    importResult.failureReasons[resourceType][resourceIdentifier] = errorMessage;
                 }
             }
         }

src/resourceState/ResourceStateManager.ts

@@ -59,13 +59,14 @@ export class ResourceStateManager implements SettingsConfigurable, Closeable {
         this.initializeCounters();
     }
 
-    @Measure({ name: 'getResource', captureErrorType: true })
-    public async getResource(typeName: ResourceType, identifier: ResourceId): Promise<ResourceState | undefined> {
+    @Measure({ name: 'getResource' })
+    public async getResource(typeName: ResourceType, identifier: ResourceId): Promise<ResourceState> {
         const cachedResources = this.getResourceState(typeName, identifier);
         if (cachedResources) {
             this.telemetry.count('state.hit', 1);
             return cachedResources;
         }
+
         this.telemetry.count('state.miss', 1);
 
         let output: GetResourceCommandOutput | undefined = undefined;
@@ -75,20 +76,20 @@ export class ResourceStateManager implements SettingsConfigurable, Closeable {
         } catch (error) {
             if (error instanceof ResourceNotFoundException) {
                 log.info(`No resource found for type ${typeName} and identifier "${identifier}"`);
-                return;
+            } else {
+                log.error(error, `CCAPI GetResource failed for type ${typeName} and identifier "${identifier}"`);
             }
+
             if (isClientError(error)) {
                 log.info(`Client error for type ${typeName} and identifier "${identifier}"`);
-                return;
             }
             throw error;
         }
 
         if (!output?.TypeName || !output?.ResourceDescription?.Identifier || !output?.ResourceDescription?.Properties) {
-            log.error(
+            throw new Error(
                 `GetResource output is missing required fields for type ${typeName} with identifier "${identifier}"`,
             );
-            return;
         }
 
         const value: ResourceState = {
@@ -136,8 +137,9 @@ export class ResourceStateManager implements SettingsConfigurable, Closeable {
         typeName: string,
         identifier: string,
     ): Promise<{ found: boolean; resourceList?: ResourceList }> {
-        const resource = await this.getResource(typeName, identifier);
-        if (!resource) {
+        try {
+            await this.getResource(typeName, identifier);
+        } catch {
             return { found: false };
         }
 

src/resourceState/ResourceStateTypes.ts

@@ -38,6 +38,7 @@ export interface ResourceStateResult {
     completionItem?: CompletionItem;
     successfulImports: Record<ResourceType, ResourceIdentifier[]>;
     failedImports: Record<ResourceType, ResourceIdentifier[]>;
+    failureReasons?: Record<ResourceType, Record<ResourceIdentifier, string>>;
     warning?: string;
 }
 

tst/unit/autocomplete/ResourceStateCompletionProvider.test.ts

@@ -115,7 +115,7 @@ describe('ResourceStateCompletionProvider', () => {
         });
 
         mockComponents.schemaRetriever.getDefault.returns(s3Schemas);
-        mockComponents.resourceStateManager.getResource.resolves(undefined);
+        mockComponents.resourceStateManager.getResource.resolves();
 
         const result = await provider.getCompletions(context, mockYamlParams);
 
@@ -132,12 +132,7 @@ describe('ResourceStateCompletionProvider', () => {
         });
 
         mockComponents.schemaRetriever.getDefault.returns(s3Schemas);
-        mockComponents.resourceStateManager.getResource.resolves({
-            typeName: 'AWS::S3::Bucket',
-            identifier: 'test',
-            properties: '',
-            createdTimestamp: new Date() as any,
-        });
+        mockComponents.resourceStateManager.getResource.rejects(new Error('Invalid resource state'));
 
         const result = await provider.getCompletions(context, mockYamlParams);
 

tst/unit/resourceState/ResourceStateImporter.test.ts

@@ -203,6 +203,9 @@ describe('ResourceStateImporter', () => {
 
             createAndRegisterDocument(uri, scenario.initialContent, scenario.documentType);
 
+            // Mock getResource to throw an error
+            mockResourceStateManager.getResource.mockRejectedValue(new Error('Resource not found'));
+
             const params: ResourceStateParams = {
                 resourceSelections: [{ resourceType: 'AWS::S3::Bucket', resourceIdentifiers: ['test-bucket'] }],
                 textDocument: { uri } as any,
@@ -383,7 +386,10 @@ describe('ResourceStateImporter', () => {
                 },
             ];
 
-            mockResourceStateManager.getResource.mockResolvedValue(mockResource1);
+            mockResourceStateManager.getResource
+                .mockResolvedValueOnce(mockResource1)
+                .mockResolvedValueOnce(mockResource2)
+                .mockResolvedValueOnce(mockResource3);
 
             const params: ResourceStateParams = {
                 resourceSelections,

tst/unit/resourceState/ResourceStateManager.test.ts

@@ -73,35 +73,34 @@ describe('ResourceStateManager', () => {
             });
         });
 
-        it('should handle ResourceNotFoundException', async () => {
+        it('should throw ResourceNotFoundError for ResourceNotFoundException', async () => {
             const error = new ResourceNotFoundException({
                 message: 'Resource not found',
                 $metadata: { httpStatusCode: 404 },
             });
             vi.mocked(mockCcapiService.getResource).mockRejectedValue(error);
 
-            const result = await manager.getResource('AWS::S3::Bucket', 'nonexistent');
-
-            expect(result).toBeUndefined();
+            await expect(manager.getResource('AWS::S3::Bucket', 'nonexistent')).rejects.toThrow('Resource not found');
         });
 
-        it('should throw on server errors', async () => {
+        it('should rethrow other errors', async () => {
             const error = new Error('Service error');
             vi.mocked(mockCcapiService.getResource).mockRejectedValue(error);
 
             await expect(manager.getResource('AWS::S3::Bucket', 'my-bucket')).rejects.toThrow('Service error');
         });
 
-        it('should return undefined for client errors', async () => {
-            const error = { name: 'AccessDeniedException', $metadata: { httpStatusCode: 403 }, message: 'Denied' };
+        it('should rethrow AccessDeniedException', async () => {
+            const error = new Error(
+                'User: arn:aws:sts::123456789012:assumed-role/Limited/user is not authorized to perform: cloudformation:GetResource on resource: arn:aws:cloudformation:us-east-1:123456789012:resource/*',
+            );
+            error.name = 'AccessDeniedException';
             vi.mocked(mockCcapiService.getResource).mockRejectedValue(error);
 
-            const result = await manager.getResource('AWS::S3::Bucket', 'my-bucket');
-
-            expect(result).toBeUndefined();
+            await expect(manager.getResource('AWS::S3::Bucket', 'my-bucket')).rejects.toThrow(error.message);
         });
 
-        it('should handle missing required fields in output', async () => {
+        it('should throw InvalidResourceOutputError for missing required fields', async () => {
             const mockOutput: GetResourceCommandOutput = {
                 TypeName: 'AWS::S3::Bucket',
                 ResourceDescription: {
@@ -112,9 +111,9 @@ describe('ResourceStateManager', () => {
             };
             vi.mocked(mockCcapiService.getResource).mockResolvedValue(mockOutput);
 
-            const result = await manager.getResource('AWS::S3::Bucket', 'my-bucket');
-
-            expect(result).toBeUndefined();
+            await expect(manager.getResource('AWS::S3::Bucket', 'my-bucket')).rejects.toThrow(
+                'GetResource output is missing required fields',
+            );
         });
     });