Merge branch 'main' into findInMap-bug-fix

Author: gemammercado

src/artifacts/IntrinsicFunctionsDocs.ts

@@ -1,6 +1,6 @@
 import { IntrinsicFunction } from '../context/ContextType';
 
-export const intrinsicFunctionsDocsMap = getIntrinsicFunctionsDocsMap();
+export const intrinsicFunctionsDocsMap: ReadonlyMap<IntrinsicFunction, string> = getIntrinsicFunctionsDocsMap();
 
 function getIntrinsicFunctionsDocsMap(): Map<IntrinsicFunction, string> {
     const intrinsicFunctionsDocsMap = new Map<IntrinsicFunction, string>();

src/artifacts/OutputSectionFieldDocs.ts

@@ -1,4 +1,4 @@
-export const outputSectionFieldDocsMap = getOutputSectionFieldDocsMap();
+export const outputSectionFieldDocsMap: ReadonlyMap<string, string> = getOutputSectionFieldDocsMap();
 
 function getOutputSectionFieldDocsMap(): Map<string, string> {
     const outputSectionFieldDocsMap = new Map<string, string>();

src/artifacts/ParameterAttributeDocs.ts

@@ -1,4 +1,4 @@
-export const parameterAttributeDocsMap = getParameterAttributeDocsMap();
+export const parameterAttributeDocsMap: ReadonlyMap<string, string> = getParameterAttributeDocsMap();
 
 function getParameterAttributeDocsMap(): Map<string, string> {
     const parameterAttributeDocsMap = new Map<string, string>();

src/artifacts/PseudoParameterDocs.ts

@@ -1,6 +1,6 @@
 import { PseudoParameter } from '../context/ContextType';
 
-export const pseudoParameterDocsMap = getPseudoParameterDocsMap();
+export const pseudoParameterDocsMap: ReadonlyMap<PseudoParameter, string> = getPseudoParameterDocsMap();
 
 function getPseudoParameterDocsMap(): Map<PseudoParameter, string> {
     const pseudoParameterDocsMap = new Map<PseudoParameter, string>();

src/artifacts/ResourceAttributeDocs.ts

@@ -1,6 +1,6 @@
 import { ResourceAttribute } from '../context/ContextType';
 
-export const resourceAttributeDocsMap = getResourceAttributeDocsMap();
+export const resourceAttributeDocsMap: ReadonlyMap<ResourceAttribute, string> = getResourceAttributeDocsMap();
 
 function getResourceAttributeDocsMap(): Map<ResourceAttribute, string> {
     const resourceAttributeDocsMap = new Map<ResourceAttribute, string>();

src/artifacts/TemplateSectionDocs.ts

@@ -1,6 +1,6 @@
 import { TopLevelSection } from '../context/ContextType';
 
-export const templateSectionDocsMap = getTemplateSectionDocsMap();
+export const templateSectionDocsMap: ReadonlyMap<TopLevelSection, string> = getTemplateSectionDocsMap();
 
 function getTemplateSectionDocsMap(): Map<TopLevelSection, string> {
     const templateSectionDocsMap = new Map<TopLevelSection, string>();

src/autocomplete/IntrinsicFunctionArgumentCompletionProvider.ts

@@ -247,7 +247,9 @@ export class IntrinsicFunctionArgumentCompletionProvider implements CompletionPr
         return undefined;
     }
 
-    private getPseudoParametersAsCompletionItems(pseudoParameterMap: Map<PseudoParameter, string>): CompletionItem[] {
+    private getPseudoParametersAsCompletionItems(
+        pseudoParameterMap: ReadonlyMap<PseudoParameter, string>,
+    ): CompletionItem[] {
         const completionItems: CompletionItem[] = [];
         for (const [paramName, doc] of pseudoParameterMap) {
             completionItems.push(

src/codeLens/ManagedResourceCodeLens.ts

@@ -0,0 +1,71 @@
+import { CodeLens, Position, Range } from 'vscode-languageserver';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { TopLevelSection } from '../context/ContextType';
+import { getEntityMap } from '../context/SectionContextBuilder';
+import { Resource } from '../context/semantic/Entity';
+import { SyntaxTreeManager } from '../context/syntaxtree/SyntaxTreeManager';
+import { ServerComponents } from '../server/ServerComponents';
+
+const MANAGED_RESOURCE_CONSTANTS = {
+    COMMAND_TITLE: 'Open Stack Template',
+    COMMAND_NAME: 'aws.cloudformation.api.openStackTemplate',
+    STACK_NAME_REGEX: /^\s*"?StackName"?\s*:/,
+} as const;
+
+export class ManagedResourceCodeLens {
+    constructor(private readonly syntaxTreeManager: SyntaxTreeManager) {}
+
+    getCodeLenses(uri: string, document: TextDocument): CodeLens[] {
+        const lenses: CodeLens[] = [];
+
+        const syntaxTree = this.syntaxTreeManager.getSyntaxTree(uri);
+        if (!syntaxTree) {
+            return lenses;
+        }
+
+        const resourcesMap = getEntityMap(syntaxTree, TopLevelSection.Resources);
+        if (!resourcesMap) {
+            return lenses;
+        }
+
+        const text = document.getText();
+        const lines = text.split('\n');
+
+        for (const [, resourceContext] of resourcesMap) {
+            const resource = resourceContext.entity as Resource;
+            const metadata = resource.Metadata;
+
+            if (
+                metadata?.ManagedByStack === true &&
+                typeof metadata.StackName === 'string' &&
+                typeof metadata.PrimaryIdentifier === 'string'
+            ) {
+                const stackName = metadata.StackName;
+                const primaryIdentifier = metadata.PrimaryIdentifier;
+
+                const startRow = resourceContext.startPosition.row;
+                const endRow = resourceContext.endPosition.row;
+
+                for (let i = startRow; i <= endRow && i < lines.length; i++) {
+                    if (MANAGED_RESOURCE_CONSTANTS.STACK_NAME_REGEX.test(lines[i])) {
+                        lenses.push({
+                            range: Range.create(Position.create(i, 0), Position.create(i, 0)),
+                            command: {
+                                title: MANAGED_RESOURCE_CONSTANTS.COMMAND_TITLE,
+                                command: MANAGED_RESOURCE_CONSTANTS.COMMAND_NAME,
+                                arguments: [stackName, primaryIdentifier],
+                            },
+                        });
+                        break;
+                    }
+                }
+            }
+        }
+
+        return lenses;
+    }
+
+    static create(components: ServerComponents): ManagedResourceCodeLens {
+        return new ManagedResourceCodeLens(components.syntaxTreeManager);
+    }
+}

src/codeLens/StackActionsCodeLens.ts

@@ -0,0 +1,34 @@
+import { CodeLens, Position, Range } from 'vscode-languageserver';
+
+const STACK_ACTION_TITLES = {
+    DRY_RUN: 'Dry Run Deployment',
+    DEPLOY: 'Deploy',
+} as const;
+
+const STACK_ACTION_COMMANDS = {
+    VALIDATE: 'aws.cloudformation.api.validateTemplate',
+    DEPLOY: 'aws.cloudformation.api.deployTemplate',
+} as const;
+
+export function getStackActionsCodeLenses(uri: string): CodeLens[] {
+    const range = Range.create(Position.create(0, 0), Position.create(0, 0));
+
+    return [
+        {
+            range,
+            command: {
+                title: STACK_ACTION_TITLES.DRY_RUN,
+                command: STACK_ACTION_COMMANDS.VALIDATE,
+                arguments: [uri],
+            },
+        },
+        {
+            range,
+            command: {
+                title: STACK_ACTION_TITLES.DEPLOY,
+                command: STACK_ACTION_COMMANDS.DEPLOY,
+                arguments: [uri],
+            },
+        },
+    ];
+}

src/handlers/CodeLensHandler.ts

@@ -0,0 +1,31 @@
+import { CodeLens, CodeLensParams } from 'vscode-languageserver';
+import { ServerRequestHandler } from 'vscode-languageserver/lib/common/server';
+import { getStackActionsCodeLenses } from '../codeLens/StackActionsCodeLens';
+import { ServerComponents } from '../server/ServerComponents';
+import { LoggerFactory } from '../telemetry/LoggerFactory';
+
+const log = LoggerFactory.getLogger('CodeLensHandler');
+
+export function codeLensHandler(
+    components: ServerComponents,
+): ServerRequestHandler<CodeLensParams, CodeLens[], never, void> {
+    return (params, _token, _workDoneProgress, _resultProgress) => {
+        log.debug({
+            Handler: 'CodeLens',
+            Document: params.textDocument.uri,
+        });
+
+        const document = components.documents.documents.get(params.textDocument.uri);
+        if (!document) {
+            return [];
+        }
+
+        const stackActions = getStackActionsCodeLenses(params.textDocument.uri);
+        const managedResourceActions = components.managedResourceCodeLens.getCodeLenses(
+            params.textDocument.uri,
+            document,
+        );
+
+        return [...stackActions, ...managedResourceActions];
+    };
+}