Use parsed document to determine template type (#222)

Author: kddejong

src/document/CloudFormationDetection.ts

@@ -1,7 +1,7 @@
 import { TextDocument, Position, Range, DocumentUri } from 'vscode-languageserver-textdocument';
+import { TopLevelSection } from '../context/ContextType';
 import { DefaultSettings } from '../settings/Settings';
 import { LoggerFactory } from '../telemetry/LoggerFactory';
-import { detectCfnFileType } from './CloudFormationDetection';
 import { DocumentMetadata } from './DocumentProtocol';
 import { detectDocumentType, uriToPath } from './DocumentUtils';
 import { parseValidYaml } from './YamlParser';
@@ -10,9 +10,10 @@ export class Document {
     private readonly log = LoggerFactory.getLogger(Document);
     public readonly extension: string;
     public readonly documentType: DocumentType;
-    public readonly cfnFileType: CloudFormationFileType;
+    private _cfnFileType: CloudFormationFileType;
     public readonly fileName: string;
     private tabSize: number;
+    private cachedParsedContent: unknown;
 
     constructor(
         private readonly textDocument: TextDocument,
@@ -28,22 +29,87 @@ export class Document {
         this.extension = extension;
         this.documentType = type;
         this.fileName = uriToPath(uri).base;
+        this._cfnFileType = CloudFormationFileType.Unknown;
 
-        try {
-            this.cfnFileType = detectCfnFileType(this.textDocument.getText(), this.documentType);
-        } catch (error) {
-            this.cfnFileType = CloudFormationFileType.Unknown;
-            this.log.error(error, `Failed to detect CloudFormation file type ${this.textDocument.uri}`);
-        }
+        this.updateCfnFileType();
         this.tabSize = fallbackTabSize;
         this.processIndentation(detectIndentation, fallbackTabSize);
     }
 
-    public getParsedDocumentContent(): unknown {
+    public get cfnFileType(): CloudFormationFileType {
+        return this._cfnFileType;
+    }
+
+    public updateCfnFileType(): void {
+        const content = this.textDocument.getText();
+        if (!content.trim()) {
+            this._cfnFileType = CloudFormationFileType.Unknown;
+            this.cachedParsedContent = undefined;
+            return;
+        }
+
+        try {
+            this.cachedParsedContent = this.parseContent();
+            this._cfnFileType = this.detectCfnFileType();
+        } catch {
+            // If parsing fails, leave cfnFileType unchanged and clear cache
+            this.cachedParsedContent = undefined;
+            this.log.debug(
+                `Failed to parse document ${this.textDocument.uri}, keeping cfnFileType as ${this._cfnFileType}`,
+            );
+        }
+    }
+
+    private parseContent(): unknown {
+        const content = this.textDocument.getText();
         if (this.documentType === DocumentType.JSON) {
-            return JSON.parse(this.contents());
+            return JSON.parse(content);
+        }
+        return parseValidYaml(content);
+    }
+
+    private detectCfnFileType(): CloudFormationFileType {
+        // If languageId is cloudformation, treat as template
+        if (this.languageId === 'cloudformation') {
+            return CloudFormationFileType.Template;
+        }
+
+        if (!this.cachedParsedContent || typeof this.cachedParsedContent !== 'object') {
+            return CloudFormationFileType.Unknown;
+        }
+
+        const parsed = this.cachedParsedContent as Record<string, unknown>;
+
+        // Check for GitSync deployment file
+        const gitSyncKeys = ['template-file-path', 'templateFilePath', 'templatePath'];
+        if (gitSyncKeys.some((key) => Object.prototype.hasOwnProperty.call(parsed, key))) {
+            return CloudFormationFileType.GitSyncDeployment;
+        }
+
+        // Check for CloudFormation template
+        const templateKeys = [
+            TopLevelSection.AWSTemplateFormatVersion,
+            TopLevelSection.Resources,
+            TopLevelSection.Transform,
+        ];
+        if (templateKeys.some((key) => Object.prototype.hasOwnProperty.call(parsed, key))) {
+            return CloudFormationFileType.Template;
+        }
+
+        return CloudFormationFileType.Unknown;
+    }
+
+    public getParsedDocumentContent(): unknown {
+        if (this.cachedParsedContent !== undefined) {
+            return this.cachedParsedContent;
+        }
+
+        // Fallback to parsing if cache is empty
+        try {
+            return this.parseContent();
+        } catch {
+            return undefined;
         }
-        return parseValidYaml(this.contents());
     }
 
     public getLine(lineNumber: number): string | undefined {

src/document/Document.ts

@@ -1,7 +1,7 @@
 import { readFileSync, statSync } from 'fs';
+import { TextDocument } from 'vscode-languageserver-textdocument';
 import { detectDocumentType, uriToPath } from '../src/document/DocumentUtils';
-import { CloudFormationFileType, DocumentType } from '../src/document/Document';
-import { detectCfnFileType } from '../src/document/CloudFormationDetection';
+import { CloudFormationFileType, DocumentType, Document } from '../src/document/Document';
 
 export type TestPosition = {
     line: number;
@@ -173,13 +173,15 @@ export function discoverTemplateFiles(paths: string[]): TemplateFile[] {
         .map((path): TemplateFile => {
             const content = readFileSync(path, 'utf8');
             const { extension, type } = detectDocumentType(path, content);
+            const textDocument = TextDocument.create(path, type === DocumentType.JSON ? 'json' : 'yaml', 1, content);
+            const document = new Document(textDocument);
 
             return {
                 name: uriToPath(path).base,
                 path: path,
                 extension,
                 documentType: type,
-                cfnFileType: detectCfnFileType(content, type),
+                cfnFileType: document.cfnFileType,
                 content,
                 size: statSync(path).size,
             };