Merge branch 'hw-ff' into crash

Author: satyakigh

README.md

@@ -49,8 +49,7 @@ The server implements the Language Server Protocol (LSP) to enable code editors
 - **Artifact Export** - Export and upload template artifacts to S3 for deployment
 
 ### Code Lens Actions
-- **Validate Deployment** - Validate template deployment from the editor
-- **Deploy Template** - Deploy templates with a single click
+- **Validate and Deploy** - Validate and deploy templates with a single click
 - **Open Stack Template** - Open managed stack templates for resources
 
 ### Advanced Capabilities

src/artifactexporter/ArtifactExporter.ts

@@ -1,35 +1,13 @@
-import { readFileSync } from 'fs';
 import { resolve, dirname, isAbsolute } from 'path';
-import { fileURLToPath, pathToFileURL } from 'url';
-import { load } from 'js-yaml';
-import { TopLevelSection, IntrinsicFunction } from '../context/ContextType';
-import { Document, DocumentType } from '../document/Document';
-import { detectDocumentType } from '../document/DocumentUtils';
+import { fileURLToPath } from 'url';
+import { TopLevelSection } from '../context/ContextType';
+import { normalizeIntrinsicFunctionAndCondition } from '../context/semantic/Intrinsics';
+import { DocumentType } from '../document/Document';
+import { parseDocumentContent } from '../document/DocumentUtils';
 import { S3Service } from '../services/S3Service';
 import { Artifact } from '../stacks/actions/StackActionRequestType';
 import { isS3Url, RESOURCE_EXPORTER_MAP } from './ResourceExporters';
 
-const INTRINSIC_FUNCTION_MAP = new Map<string, string>([
-    ['!Ref', IntrinsicFunction.Ref],
-    ['!GetAtt', IntrinsicFunction.GetAtt],
-    ['!Join', IntrinsicFunction.Join],
-    ['!Sub', IntrinsicFunction.Sub],
-    ['!Base64', IntrinsicFunction.Base64],
-    ['!GetAZs', IntrinsicFunction.GetAZs],
-    ['!ImportValue', IntrinsicFunction.ImportValue],
-    ['!Select', IntrinsicFunction.Select],
-    ['!Split', IntrinsicFunction.Split],
-    ['!FindInMap', IntrinsicFunction.FindInMap],
-    ['!Equals', IntrinsicFunction.Equals],
-    ['!If', IntrinsicFunction.If],
-    ['!Not', IntrinsicFunction.Not],
-    ['!And', IntrinsicFunction.And],
-    ['!Or', IntrinsicFunction.Or],
-    ['!Cidr', IntrinsicFunction.Cidr],
-    ['!Transform', IntrinsicFunction.Transform],
-    ['!Condition', 'Condition'],
-]);
-
 export type ArtifactWithProperty = {
     resourceType: string;
     resourcePropertyDict: Record<string, unknown>;
@@ -39,30 +17,14 @@ export type ArtifactWithProperty = {
 
 export class ArtifactExporter {
     private readonly templateDict: unknown;
-    private readonly templateUri: string;
-    private readonly templateType: DocumentType;
 
     constructor(
         private readonly s3Service: S3Service,
-        private readonly document?: Document,
-        private readonly templateAbsPath?: string,
+        private readonly templateType: DocumentType,
+        private readonly templateUri: string,
+        templateContent: string,
     ) {
-        if (this.document) {
-            this.templateDict = this.document.getParsedDocumentContent();
-            this.templateUri = this.document.uri;
-            this.templateType = this.document.documentType;
-        } else if (this.templateAbsPath) {
-            const content = readFileSync(this.templateAbsPath, 'utf8');
-            this.templateUri = pathToFileURL(this.templateAbsPath).href;
-            this.templateType = detectDocumentType(this.templateUri, content).type;
-            if (this.templateType === DocumentType.YAML) {
-                this.templateDict = load(content);
-            } else {
-                this.templateDict = JSON.parse(content);
-            }
-        } else {
-            throw new Error('Either document or absolutePath must be provided');
-        }
+        this.templateDict = parseDocumentContent(templateUri, templateContent);
     }
 
     private getResourceMapWithArtifact(): Record<string, ArtifactWithProperty[]> {
@@ -148,7 +110,7 @@ export class ArtifactExporter {
         const objDict = obj as Record<string, unknown>;
 
         for (const [key, value] of Object.entries(objDict)) {
-            const newKey = INTRINSIC_FUNCTION_MAP.get(key) ?? key;
+            const newKey = normalizeIntrinsicFunctionAndCondition(key);
             result[newKey] = this.convertIntrinsicFunctionKeys(value);
         }
 

src/artifactexporter/ResourceExporters.ts

@@ -1,23 +1,15 @@
-import {
-    existsSync,
-    mkdtempSync,
-    copyFileSync,
-    rmSync,
-    createWriteStream,
-    statSync,
-    openSync,
-    readSync,
-    closeSync,
-} from 'fs';
+import { existsSync, mkdtempSync, copyFileSync, rmSync, createWriteStream, statSync, readFileSync } from 'fs';
 import { tmpdir } from 'os';
 import path, { join, basename } from 'path';
+import { pathToFileURL } from 'url';
 import archiver from 'archiver';
 import { dump } from 'js-yaml';
+import { detectDocumentType } from '../document/DocumentUtils';
 import { S3Service } from '../services/S3Service';
 import { ArtifactExporter } from './ArtifactExporter';
 
 export function isS3Url(url: string): boolean {
-    return typeof url === 'string' && /^s3:\/\/[^/]+\/.+/.test(url);
+    return /^s3:\/\/[^/]+\/.+/.test(url);
 }
 
 export function isLocalFile(filePath: string): boolean {
@@ -31,26 +23,9 @@ function isLocalFolder(path: string): boolean {
 function isArchiveFile(filePath: string) {
     // Quick extension check
     const ext = path.extname(filePath).toLowerCase();
-    const archiveExts = ['.zip', '.rar', '.7z', '.tar', '.gz', '.tgz'];
-
-    if (!archiveExts.includes(ext)) return false;
-
-    // Verify with magic numbers
-    try {
-        const fd = openSync(filePath, 'r');
-        const buffer = Buffer.alloc(8);
-        readSync(fd, buffer, 0, 8, 0);
-        closeSync(fd);
-
-        return (
-            (buffer[0] === 0x50 && buffer[1] === 0x4b) || // ZIP
-            buffer.toString('ascii', 0, 4) === 'Rar!' || // RAR
-            (buffer[0] === 0x37 && buffer[1] === 0x7a) || // 7Z
-            (buffer[0] === 0x1f && buffer[1] === 0x8b) // GZIP
-        );
-    } catch {
-        return false;
-    }
+    const archiveExts = ['.zip', '.rar', '.7z', '.tar', '.gz', '.tgz', '.zst', '.war'];
+
+    return archiveExts.includes(ext);
 }
 
 function copyToTempDir(filePath: string): string {
@@ -228,25 +203,25 @@ export abstract class ResourceWithS3UrlDict extends Resource {
     }
 }
 
-export class ServerlessFunctionResource extends Resource {
+class ServerlessFunctionResource extends Resource {
     public override resourceType = 'AWS::Serverless::Function';
     public override propertyName = 'CodeUri';
     protected override forceZip = true;
 }
 
-export class ServerlessApiResource extends Resource {
+class ServerlessApiResource extends Resource {
     public override resourceType = 'AWS::Serverless::Api';
     public override propertyName = 'DefinitionUri';
     protected override packageNullProperty = false;
 }
 
-export class GraphQLSchemaResource extends Resource {
+class GraphQLSchemaResource extends Resource {
     public override resourceType = 'AWS::AppSync::GraphQLSchema';
     public override propertyName = 'DefinitionS3Location';
     protected override packageNullProperty = false;
 }
 
-export class LambdaFunctionResource extends ResourceWithS3UrlDict {
+class LambdaFunctionResource extends ResourceWithS3UrlDict {
     public override resourceType = 'AWS::Lambda::Function';
     public override propertyName = 'Code';
     protected override bucketNameProperty = 'S3Bucket';
@@ -255,7 +230,7 @@ export class LambdaFunctionResource extends ResourceWithS3UrlDict {
     protected override forceZip = true;
 }
 
-export class ApiGatewayRestApiResource extends ResourceWithS3UrlDict {
+class ApiGatewayRestApiResource extends ResourceWithS3UrlDict {
     public override resourceType = 'AWS::ApiGateway::RestApi';
     public override propertyName = 'BodyS3Location';
     protected override packageNullProperty = false;
@@ -264,7 +239,7 @@ export class ApiGatewayRestApiResource extends ResourceWithS3UrlDict {
     protected override versionProperty = 'Version';
 }
 
-export class CloudFormationStackResource extends Resource {
+class CloudFormationStackResource extends Resource {
     public override resourceType = 'AWS::CloudFormation::Stack';
     public override propertyName = 'TemplateURL';
 
@@ -278,7 +253,11 @@ export class CloudFormationStackResource extends Resource {
             throw new Error(`Invalid template path: ${templateAbsPath}`);
         }
 
-        const template = new ArtifactExporter(this.s3Service, undefined, templateAbsPath);
+        const templateUri = pathToFileURL(templateAbsPath).href;
+        const content = readFileSync(templateAbsPath, 'utf8');
+        const templateType = detectDocumentType(templateUri, content).type;
+
+        const template = new ArtifactExporter(this.s3Service, templateType, templateUri, content);
         const exportedTemplateDict = await template.export(bucketName, s3KeyPrefix);
         const exportedTemplateStr = dump(exportedTemplateDict);
 

src/autocomplete/CompletionFormatter.ts

@@ -297,6 +297,7 @@ export class CompletionFormatter {
         if (
             item?.kind === CompletionItemKind.EnumMember ||
             item?.kind === CompletionItemKind.Reference ||
+            item?.kind === CompletionItemKind.Constant ||
             item?.kind === CompletionItemKind.Event
         ) {
             return label;

src/autocomplete/CompletionRouter.ts

@@ -311,6 +311,7 @@ export function createCompletionProviders(
             core.syntaxTreeManager,
             external.schemaRetriever,
             core.documentManager,
+            external.featureFlags.get('Constants'),
         ),
     );
     completionProviderMap.set('ParameterTypeValue', new ParameterTypeValueCompletionProvider());

src/autocomplete/IntrinsicFunctionArgumentCompletionProvider.ts

@@ -3,11 +3,12 @@ import { pseudoParameterDocsMap } from '../artifacts/PseudoParameterDocs';
 import { Context } from '../context/Context';
 import { IntrinsicFunction, PseudoParameter, PseudoParametersSet, TopLevelSection } from '../context/ContextType';
 import { getEntityMap } from '../context/SectionContextBuilder';
-import { Mapping, Parameter, Resource } from '../context/semantic/Entity';
+import { Constant, Mapping, Parameter, Resource } from '../context/semantic/Entity';
 import { EntityType } from '../context/semantic/SemanticTypes';
 import { SyntaxTree } from '../context/syntaxtree/SyntaxTree';
 import { SyntaxTreeManager } from '../context/syntaxtree/SyntaxTreeManager';
 import { DocumentManager } from '../document/DocumentManager';
+import { FeatureFlag } from '../featureFlag/FeatureFlagI';
 import { SchemaRetriever } from '../schema/SchemaRetriever';
 import { LoggerFactory } from '../telemetry/LoggerFactory';
 import { Measure } from '../telemetry/TelemetryDecorator';
@@ -54,6 +55,7 @@ export class IntrinsicFunctionArgumentCompletionProvider implements CompletionPr
         private readonly syntaxTreeManager: SyntaxTreeManager,
         private readonly schemaRetriever: SchemaRetriever,
         private readonly documentManager: DocumentManager,
+        private readonly constantsFeatureFlag: FeatureFlag,
     ) {}
 
     @Measure({ name: 'getCompletions' })
@@ -104,14 +106,19 @@ export class IntrinsicFunctionArgumentCompletionProvider implements CompletionPr
             syntaxTree,
         );
 
-        if (!parametersAndResourcesCompletions || parametersAndResourcesCompletions.length === 0) {
+        const constantsCompletions = this.getConstantsCompletions(syntaxTree);
+
+        const allCompletions = [
+            ...this.pseudoParameterCompletionItems,
+            ...(parametersAndResourcesCompletions ?? []),
+            ...constantsCompletions,
+        ];
+
+        if (allCompletions.length === this.pseudoParameterCompletionItems.length) {
             return this.applyFuzzySearch(this.pseudoParameterCompletionItems, context.text);
         }
 
-        return this.applyFuzzySearch(
-            [...this.pseudoParameterCompletionItems, ...parametersAndResourcesCompletions],
-            context.text,
-        );
+        return this.applyFuzzySearch(allCompletions, context.text);
     }
 
     private handleSubArguments(
@@ -125,6 +132,7 @@ export class IntrinsicFunctionArgumentCompletionProvider implements CompletionPr
             syntaxTree,
         );
         const getAttCompletions = this.getGetAttCompletions(syntaxTree, context.logicalId);
+        const constantsCompletions = this.getConstantsCompletions(syntaxTree, true);
 
         const baseItems = [...this.pseudoParameterCompletionItems];
         if (parametersAndResourcesCompletions && parametersAndResourcesCompletions.length > 0) {
@@ -133,6 +141,9 @@ export class IntrinsicFunctionArgumentCompletionProvider implements CompletionPr
         if (getAttCompletions.length > 0) {
             baseItems.push(...getAttCompletions);
         }
+        if (constantsCompletions.length > 0) {
+            baseItems.push(...constantsCompletions);
+        }
 
         // Handle ${} parameter substitution context detection
         const subText = this.getTextForSub(params.textDocument.uri, params.position, context);
@@ -246,6 +257,49 @@ export class IntrinsicFunctionArgumentCompletionProvider implements CompletionPr
         return completionItems;
     }
 
+    private getConstantsAsCompletionItems(
+        constantsMap: ReadonlyMap<string, Context>,
+        stringOnly: boolean = false,
+    ): CompletionItem[] {
+        const completionItems: CompletionItem[] = [];
+        for (const [constantName, context] of constantsMap) {
+            const constant = context.entity as Constant;
+
+            if (stringOnly && typeof constant.value !== 'string') {
+                continue;
+            }
+
+            const valuePreview =
+                typeof constant.value === 'string'
+                    ? constant.value
+                    : typeof constant.value === 'object'
+                      ? '[Object]'
+                      : String(constant.value);
+
+            completionItems.push(
+                createCompletionItem(constantName, CompletionItemKind.Constant, {
+                    detail: `Constant`,
+                    documentation: `Value: ${valuePreview}`,
+                }),
+            );
+        }
+
+        return completionItems;
+    }
+
+    private getConstantsCompletions(syntaxTree: SyntaxTree, stringOnly: boolean = false): CompletionItem[] {
+        if (!this.constantsFeatureFlag.isEnabled()) {
+            return [];
+        }
+
+        const constantsMap = getEntityMap(syntaxTree, TopLevelSection.Constants);
+        if (!constantsMap || constantsMap.size === 0) {
+            return [];
+        }
+
+        return this.getConstantsAsCompletionItems(constantsMap, stringOnly);
+    }
+
     private shouldIncludeResourceCompletions(context: Context): boolean {
         // Only provide resource completions in Resources and Outputs sections
         return context.section === TopLevelSection.Resources || context.section === TopLevelSection.Outputs;

src/codeLens/StackActionsCodeLens.ts

@@ -5,12 +5,10 @@ import { SyntaxTreeManager } from '../context/syntaxtree/SyntaxTreeManager';
 import { Document } from '../document/Document';
 
 const STACK_ACTION_TITLES = {
-    VALIDATE_DEPLOYMENT: 'Validate Deployment',
-    DEPLOY: 'Deploy Template',
+    DEPLOY: 'Validate and Deploy',
 } as const;
 
 const STACK_ACTION_COMMANDS = {
-    VALIDATE_DEPLOYMENT: 'aws.cloudformation.api.validateDeployment',
     DEPLOY: 'aws.cloudformation.api.deployTemplate',
 } as const;
 
@@ -49,14 +47,6 @@ export function getStackActionsCodeLenses(
     const range = Range.create(Position.create(codeLensLine, 0), Position.create(codeLensLine, 0));
 
     return [
-        {
-            range,
-            command: {
-                title: STACK_ACTION_TITLES.VALIDATE_DEPLOYMENT,
-                command: STACK_ACTION_COMMANDS.VALIDATE_DEPLOYMENT,
-                arguments: [uri],
-            },
-        },
         {
             range,
             command: {

src/context/semantic/Intrinsics.ts

@@ -11,3 +11,7 @@ export function normalizeIntrinsicFunction(text: string): string {
     }
     return text;
 }
+
+export function normalizeIntrinsicFunctionAndCondition(text: string): string {
+    return text === '!Condition' ? 'Condition' : normalizeIntrinsicFunction(text);
+}