used matchPathWithLogicalId and used schema instead of hardcoding

Author: tylerymarkowitz

src/artifacts/resourceAttributes/CreationPolicyPropertyDocs.ts

@@ -140,3 +140,30 @@ export function supportsAutoScalingCreationPolicy(resourceType: string): boolean
 export function supportsStartFleet(resourceType: string): boolean {
     return START_FLEET_SUPPORTED_RESOURCE_TYPES.includes(resourceType);
 }
+
+export interface CreationPolicyPropertySchema {
+    type: 'object' | 'simple';
+    supportedResourceTypes?: ReadonlyArray<string>;
+    properties?: Record<string, CreationPolicyPropertySchema>;
+}
+
+export const CREATION_POLICY_SCHEMA: Record<string, CreationPolicyPropertySchema> = {
+    [CreationPolicyProperty.ResourceSignal]: {
+        type: 'object',
+        properties: {
+            [ResourceSignalProperty.Count]: { type: 'simple' },
+            [ResourceSignalProperty.Timeout]: { type: 'simple' },
+        },
+    },
+    [CreationPolicyProperty.AutoScalingCreationPolicy]: {
+        type: 'object',
+        supportedResourceTypes: AUTO_SCALING_CREATION_POLICY_SUPPORTED_RESOURCE_TYPES,
+        properties: {
+            [AutoScalingCreationPolicyProperty.MinSuccessfulInstancesPercent]: { type: 'simple' },
+        },
+    },
+    [CreationPolicyProperty.StartFleet]: {
+        type: 'simple',
+        supportedResourceTypes: START_FLEET_SUPPORTED_RESOURCE_TYPES,
+    },
+};

src/autocomplete/ResourcePropertyCompletionProvider.ts

@@ -1,8 +1,8 @@
 import { CompletionItem, CompletionItemKind, CompletionParams } from 'vscode-languageserver';
 import {
     supportsCreationPolicy,
-    supportsAutoScalingCreationPolicy,
-    supportsStartFleet,
+    CREATION_POLICY_SCHEMA,
+    CreationPolicyPropertySchema,
 } from '../artifacts/resourceAttributes/CreationPolicyPropertyDocs';
 import { Context } from '../context/Context';
 import { ResourceAttribute, TopLevelSection, ResourceAttributesSet } from '../context/ContextType';
@@ -366,76 +366,88 @@ export class ResourcePropertyCompletionProvider implements CompletionProvider {
             return [];
         }
 
-        const completions: CompletionItem[] = [];
+        return this.getSchemaBasedCompletions(
+            CREATION_POLICY_SCHEMA,
+            propertyPath,
+            resourceType,
+            context,
+            existingProperties,
+        );
+    }
 
+    private getSchemaBasedCompletions(
+        schema: Record<string, CreationPolicyPropertySchema>,
+        propertyPath: ReadonlyArray<string>,
+        resourceType: string,
+        context: Context,
+        existingProperties: Set<string>,
+    ): CompletionItem[] {
+        const completions: CompletionItem[] = [];
         const filteredPath = propertyPath.filter((segment) => segment !== '');
         const depth = filteredPath.length;
 
-        // Root CreationPolicy level
-        if (depth === 1 && context.isKey()) {
-            if (!existingProperties.has('ResourceSignal')) {
-                completions.push(
-                    createCompletionItem('ResourceSignal', CompletionItemKind.Property, {
-                        data: { type: 'object' },
-                        context: context,
-                    }),
-                );
-            }
+        if (!context.isKey()) {
+            return completions;
+        }
 
-            if (
-                supportsAutoScalingCreationPolicy(resourceType) &&
-                !existingProperties.has('AutoScalingCreationPolicy')
-            ) {
-                completions.push(
-                    createCompletionItem('AutoScalingCreationPolicy', CompletionItemKind.Property, {
-                        data: { type: 'object' },
-                        context: context,
-                    }),
-                );
-            }
+        // Root level
+        if (depth === 1) {
+            for (const [propertyName, propertySchema] of Object.entries(schema)) {
+                if (existingProperties.has(propertyName)) {
+                    continue;
+                }
+
+                if (
+                    propertySchema.supportedResourceTypes &&
+                    !propertySchema.supportedResourceTypes.includes(resourceType)
+                ) {
+                    continue;
+                }
 
-            if (supportsStartFleet(resourceType) && !existingProperties.has('StartFleet')) {
                 completions.push(
-                    createCompletionItem('StartFleet', CompletionItemKind.Property, {
-                        data: { type: 'simple' },
+                    createCompletionItem(propertyName, CompletionItemKind.Property, {
+                        data: { type: propertySchema.type },
                         context: context,
                     }),
                 );
             }
         }
-        // Nested properties
-        else if (depth >= 2 && context.isKey()) {
-            const parentProperty = filteredPath[1];
+        // Nested levels
+        else if (depth >= 2) {
+            const parentPropertyName = filteredPath[1];
+            const parentSchema = schema[parentPropertyName];
+
+            if (parentSchema?.properties) {
+                if (
+                    parentSchema.supportedResourceTypes &&
+                    !parentSchema.supportedResourceTypes.includes(resourceType)
+                ) {
+                    return completions;
+                }
 
-            if (parentProperty === 'ResourceSignal') {
-                if (!existingProperties.has('Count')) {
-                    completions.push(
-                        createCompletionItem('Count', CompletionItemKind.Property, {
-                            data: { type: 'simple' },
-                            context: context,
-                        }),
-                    );
+                let currentSchema = parentSchema.properties;
+                for (let i = 2; i < depth - 1; i++) {
+                    const segmentName = filteredPath[i];
+                    const segmentSchema = currentSchema[segmentName];
+                    if (segmentSchema?.properties) {
+                        currentSchema = segmentSchema.properties;
+                    } else {
+                        return completions;
+                    }
                 }
 
-                if (!existingProperties.has('Timeout')) {
+                for (const [propertyName, propertySchema] of Object.entries(currentSchema)) {
+                    if (existingProperties.has(propertyName)) {
+                        continue;
+                    }
+
                     completions.push(
-                        createCompletionItem('Timeout', CompletionItemKind.Property, {
-                            data: { type: 'simple' },
+                        createCompletionItem(propertyName, CompletionItemKind.Property, {
+                            data: { type: propertySchema.type },
                             context: context,
                         }),
                     );
                 }
-            } else if (
-                parentProperty === 'AutoScalingCreationPolicy' &&
-                supportsAutoScalingCreationPolicy(resourceType) &&
-                !existingProperties.has('MinSuccessfulInstancesPercent')
-            ) {
-                completions.push(
-                    createCompletionItem('MinSuccessfulInstancesPercent', CompletionItemKind.Property, {
-                        data: { type: 'simple' },
-                        context: context,
-                    }),
-                );
             }
         }
 

src/autocomplete/ResourceSectionCompletionProvider.ts

@@ -1,6 +1,6 @@
 import { CompletionItem, CompletionParams, CompletionTriggerKind } from 'vscode-languageserver';
 import { Context } from '../context/Context';
-import { ResourceAttributesSet } from '../context/ContextType';
+import { ResourceAttributesSet, TopLevelSection } from '../context/ContextType';
 import { Resource } from '../context/semantic/Entity';
 import { ServerComponents } from '../server/ServerComponents';
 import { LoggerFactory } from '../telemetry/LoggerFactory';
@@ -59,8 +59,7 @@ export class ResourceSectionCompletionProvider implements CompletionProvider {
 
             if (
                 params.context?.triggerKind === CompletionTriggerKind.Invoked &&
-                context.propertyPath.length === 3 &&
-                context.entitySection === 'Properties'
+                context.matchPathWithLogicalId(TopLevelSection.Resources, 'Properties')
             ) {
                 const resource = context.entity as Resource;
                 if (resource.Type) {