Handle private resources lacking list handler and PrivateTypeException (#241)

Author: Zee2413

src/resourceState/ResourceStateManager.ts

@@ -1,4 +1,8 @@
-import { GetResourceCommandOutput, ResourceNotFoundException } from '@aws-sdk/client-cloudcontrol';
+import {
+    GetResourceCommandOutput,
+    PrivateTypeException,
+    ResourceNotFoundException,
+} from '@aws-sdk/client-cloudcontrol';
 import { DateTime } from 'luxon';
 import { SchemaRetriever } from '../schema/SchemaRetriever';
 import { CfnExternal } from '../server/CfnExternal';
@@ -10,6 +14,7 @@ import { LoggerFactory } from '../telemetry/LoggerFactory';
 import { ScopedTelemetry } from '../telemetry/ScopedTelemetry';
 import { Telemetry, Measure } from '../telemetry/TelemetryDecorator';
 import { Closeable } from '../utils/Closeable';
+import { handleLspError } from '../utils/Errors';
 import { NO_LIST_SUPPORT, REQUIRES_RESOURCE_MODEL } from './ListResourcesExclusionTypes';
 import { ListResourcesResult, RefreshResourcesResult } from './ResourceStateTypes';
 
@@ -141,7 +146,7 @@ export class ResourceStateManager implements SettingsConfigurable, Closeable {
             return { found: true, resourceList: cached };
         }
 
-        // Create new cache entry if doesn't exist
+        // Create new cache entry if it doesn't exist
         if (!cached) {
             const newList: ResourceList = {
                 typeName,
@@ -158,9 +163,11 @@ export class ResourceStateManager implements SettingsConfigurable, Closeable {
     }
 
     public getResourceTypes(): string[] {
-        const schemas = this.schemaRetriever.getDefault().schemas;
-        const allTypes = new Set(schemas.keys());
-        return [...allTypes].filter((type) => !NO_LIST_SUPPORT.has(type) && !REQUIRES_RESOURCE_MODEL.has(type));
+        const schemas = [...this.schemaRetriever.getDefault().schemas.values()];
+        const listableTypes = schemas
+            .filter((schema) => schema.handlers?.list !== undefined)
+            .map((schema) => schema.typeName);
+        return [...listableTypes].filter((type) => !NO_LIST_SUPPORT.has(type) && !REQUIRES_RESOURCE_MODEL.has(type));
     }
 
     private storeResourceState(typeName: ResourceType, id: ResourceId, state: ResourceState) {
@@ -214,7 +221,7 @@ export class ResourceStateManager implements SettingsConfigurable, Closeable {
             };
         } catch (error) {
             log.error(error, `CCAPI ListResource failed for type ${typeName}`);
-            return;
+            this.handleListExceptions(error, typeName);
         }
     }
 
@@ -277,6 +284,16 @@ export class ResourceStateManager implements SettingsConfigurable, Closeable {
         }
     }
 
+    private handleListExceptions(error: unknown, typeName: string) {
+        if (error instanceof PrivateTypeException) {
+            log.error(error, `Failed to list private resource`);
+            handleLspError(
+                error,
+                `Failed to list identifiers for ${typeName}. Cloud Control API hasn't received a valid response from the resource handler, due to a configuration error. This includes issues such as the resource handler returning an invalid response, or timing out.`,
+            );
+        }
+    }
+
     configure(settingsManager: ISettingsSubscriber) {
         if (this.settingsSubscription) {
             this.settingsSubscription.unsubscribe();

tst/unit/resourceState/ResourceStateManager.test.ts

@@ -1,11 +1,17 @@
-import { GetResourceCommandOutput, ResourceNotFoundException } from '@aws-sdk/client-cloudcontrol';
+import {
+    GetResourceCommandOutput,
+    PrivateTypeException,
+    ResourceNotFoundException,
+} from '@aws-sdk/client-cloudcontrol';
 import { DateTime } from 'luxon';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ResponseError } from 'vscode-languageserver';
 import { ResourceStateManager } from '../../../src/resourceState/ResourceStateManager';
 import { CombinedSchemas } from '../../../src/schema/CombinedSchemas';
 import { CcapiService } from '../../../src/services/CcapiService';
 import { S3Service } from '../../../src/services/S3Service';
 import { createMockSchemaRetriever } from '../../utils/MockServerComponents';
+import { combinedSchemas } from '../../utils/SchemaUtils';
 
 describe('ResourceStateManager', () => {
     const mockCcapiService = {
@@ -175,6 +181,19 @@ describe('ResourceStateManager', () => {
 
             expect(result).toBeUndefined();
         });
+
+        it('should handle private resource exceptions', async () => {
+            const error = new PrivateTypeException({
+                message: 'Private type error',
+                $metadata: {},
+            });
+            vi.mocked(mockCcapiService.listResources).mockRejectedValue(error);
+
+            await expect(manager.listResources('MyOrg::Custom::Resource')).rejects.toThrow(ResponseError);
+            await expect(manager.listResources('MyOrg::Custom::Resource')).rejects.toThrow(
+                "Failed to list identifiers for MyOrg::Custom::Resource. Cloud Control API hasn't received a valid response from the resource handler, due to a configuration error. This includes issues such as the resource handler returning an invalid response, or timing out.",
+            );
+        });
     });
 
     describe('searchResourceByIdentifier()', () => {
@@ -427,9 +446,9 @@ describe('ResourceStateManager', () => {
         it('should filter out resource types without list support', () => {
             const mockSchemas: CombinedSchemas = {
                 schemas: new Map([
-                    ['AWS::S3::Bucket', {}],
-                    ['AWS::IAM::Role', {}],
-                    ['AWS::IAM::RolePolicy', {}],
+                    ['AWS::S3::Bucket', { typeName: 'AWS::S3::Bucket', handlers: { list: {} } }],
+                    ['AWS::IAM::Role', { typeName: 'AWS::IAM::Role', handlers: { list: {} } }],
+                    ['AWS::IAM::RolePolicy', { typeName: 'AWS::IAM::RolePolicy', handlers: { list: {} } }],
                 ]),
             } as CombinedSchemas;
             const managerWithSchemas = new ResourceStateManager(
@@ -448,9 +467,9 @@ describe('ResourceStateManager', () => {
         it('should filter out resource types requiring resource model properties', () => {
             const mockSchemas: CombinedSchemas = {
                 schemas: new Map([
-                    ['AWS::S3::Bucket', {}],
-                    ['AWS::EKS::Cluster', {}],
-                    ['AWS::EKS::AddOn', {}],
+                    ['AWS::S3::Bucket', { typeName: 'AWS::S3::Bucket', handlers: { list: {} } }],
+                    ['AWS::EKS::Cluster', { typeName: 'AWS::EKS::Cluster', handlers: { list: {} } }],
+                    ['AWS::EKS::AddOn', { typeName: 'AWS::EKS::AddOn', handlers: { list: {} } }],
                 ]),
             } as CombinedSchemas;
             const managerWithSchemas = new ResourceStateManager(
@@ -465,5 +484,40 @@ describe('ResourceStateManager', () => {
             expect(result).toContain('AWS::EKS::Cluster');
             expect(result).not.toContain('AWS::EKS::AddOn');
         });
+
+        it('should return all supported public types', () => {
+            const testSchemas = combinedSchemas();
+            const resourceManagerWithRealSchemas = new ResourceStateManager(
+                mockCcapiService,
+                createMockSchemaRetriever(testSchemas),
+                mockS3Service,
+            );
+
+            const result = resourceManagerWithRealSchemas.getResourceTypes();
+
+            expect(result).toContain('AWS::S3::Bucket');
+            expect(result).toContain('AWS::IAM::Role');
+            expect(result).toContain('AWS::Lambda::Function');
+            expect(result.every((type) => type.startsWith('AWS::'))).toBe(true);
+        });
+
+        it('should not return private resource types with no list handler permissions', () => {
+            const mockSchemas: CombinedSchemas = {
+                schemas: new Map([
+                    ['AWS::S3::Bucket', { typeName: 'AWS::S3::Bucket', handlers: { list: {} } }],
+                    ['MyOrg::Custom::Resource', { typeName: 'MyOrg::Custom::Resource' }],
+                ]),
+            } as CombinedSchemas;
+            const managerWithSchemas = new ResourceStateManager(
+                mockCcapiService,
+                createMockSchemaRetriever(mockSchemas),
+                mockS3Service,
+            );
+
+            const result = managerWithSchemas.getResourceTypes();
+
+            expect(result).toContain('AWS::S3::Bucket');
+            expect(result).not.toContain('MyOrg::Custom::Resource');
+        });
     });
 });