Add environment file parsing handler (#187)

* Add environment file parsing handler

Author: chrisqm-dev

src/environments/EnvironmentParser.ts

@@ -0,0 +1,44 @@
+import { OnStackFailure } from '@aws-sdk/client-cloudformation';
+import { z } from 'zod';
+import { DocumentType } from '../document/Document';
+import { ParseEnvironmentFilesParams, DeploymentConfig } from './EnvironmentRequestType';
+
+const DocumentInfoSchema = z.object({
+    type: z.enum(DocumentType),
+    content: z.string(),
+    fileName: z.string(),
+});
+
+const ParseEnvironmentFilesParamsSchema = z.object({
+    documents: z.array(DocumentInfoSchema),
+});
+
+const DeploymentConfigSchema = z
+    .object({
+        'template-file-path': z.string().optional(),
+        parameters: z.record(z.string(), z.string()).optional(),
+        tags: z.record(z.string(), z.string()).optional(),
+        'on-stack-failure': z.enum(OnStackFailure).optional(),
+        'include-nested-stacks': z.boolean().optional(),
+        'import-existing-resources': z.boolean().optional(),
+    })
+    .refine((data) => Object.values(data).some((value) => value !== undefined), {
+        message: 'At least one property must be provided',
+    });
+
+export function parseEnvironmentFileParams(input: unknown): ParseEnvironmentFilesParams {
+    return ParseEnvironmentFilesParamsSchema.parse(input);
+}
+
+export function parseDeploymentConfig(input: unknown): DeploymentConfig {
+    const parsed = DeploymentConfigSchema.parse(input);
+
+    return {
+        templateFilePath: parsed['template-file-path'],
+        parameters: parsed['parameters'],
+        tags: parsed['tags'],
+        onStackFailure: parsed['on-stack-failure'],
+        includeNestedStacks: parsed['include-nested-stacks'],
+        importExistingResources: parsed['import-existing-resources'],
+    };
+}

src/environments/EnvironmentRequestType.ts

@@ -0,0 +1,37 @@
+import { OnStackFailure } from '@aws-sdk/client-cloudformation';
+import { RequestType } from 'vscode-languageserver';
+import { DocumentType } from '../document/Document';
+
+export type DocumentInfo = {
+    type: DocumentType;
+    content: string;
+    fileName: string;
+};
+
+export type DeploymentConfig = {
+    templateFilePath?: string;
+    parameters?: Record<string, string>;
+    tags?: Record<string, string>;
+    includeNestedStacks?: boolean;
+    importExistingResources?: boolean;
+    onStackFailure?: OnStackFailure;
+};
+
+export type ParsedEnvironmentFile = {
+    deploymentConfig: DeploymentConfig;
+    fileName: string;
+};
+
+export type ParseEnvironmentFilesParams = {
+    documents: DocumentInfo[];
+};
+
+export type ParseEnvironmentFilesResult = {
+    parsedFiles: ParsedEnvironmentFile[];
+};
+
+export const ParseEnvironmentFilesRequest = new RequestType<
+    ParseEnvironmentFilesParams,
+    ParseEnvironmentFilesResult,
+    void
+>('aws/cfn/environment/files/parse');

src/handlers/EnvironmentHandler.ts

@@ -0,0 +1,58 @@
+import { load } from 'js-yaml';
+import { RequestHandler } from 'vscode-languageserver';
+import { DocumentType } from '../document/Document';
+import { parseDeploymentConfig, parseEnvironmentFileParams } from '../environments/EnvironmentParser';
+import {
+    ParsedEnvironmentFile,
+    ParseEnvironmentFilesParams,
+    ParseEnvironmentFilesResult,
+} from '../environments/EnvironmentRequestType';
+import { TelemetryService } from '../telemetry/TelemetryService';
+import { handleLspError } from '../utils/Errors';
+import { parseWithPrettyError } from '../utils/ZodErrorWrapper';
+
+export function parseEnvironmentFilesHandler(): RequestHandler<
+    ParseEnvironmentFilesParams,
+    ParseEnvironmentFilesResult,
+    void
+> {
+    const telemetry = TelemetryService.instance.get('EnvironmentHandler');
+
+    return (rawParams): ParseEnvironmentFilesResult => {
+        return telemetry.measure('parseEnvironmentFiles', () => {
+            try {
+                const parsedFiles: ParsedEnvironmentFile[] = [];
+
+                const params = parseWithPrettyError(parseEnvironmentFileParams, rawParams);
+
+                for (const document of params.documents) {
+                    try {
+                        let parsedContent: unknown;
+                        if (document.type === DocumentType.JSON) {
+                            parsedContent = JSON.parse(document.content);
+                        } else if (document.type === DocumentType.YAML) {
+                            parsedContent = load(document.content);
+                        } else {
+                            continue;
+                        }
+
+                        const deploymentConfig = parseWithPrettyError(parseDeploymentConfig, parsedContent);
+
+                        parsedFiles.push({
+                            fileName: document.fileName,
+                            deploymentConfig: deploymentConfig,
+                        });
+                    } catch {
+                        telemetry.count('environmentFile.malformed', 1);
+                    }
+                }
+
+                return {
+                    parsedFiles: parsedFiles,
+                };
+            } catch (error) {
+                handleLspError(error, 'Failed to parse environment files');
+            }
+        });
+    };
+}

src/protocol/LspComponents.ts

@@ -2,6 +2,7 @@ import { LspAuthHandlers } from './LspAuthHandlers';
 import { LspCommunication } from './LspCommunication';
 import { LspDiagnostics } from './LspDiagnostics';
 import { LspDocuments } from './LspDocuments';
+import { LspEnvironmentHandlers } from './LspEnvironmentHandlers';
 import { LspHandlers } from './LspHandlers';
 import { LspRelatedResourcesHandlers } from './LspRelatedResourcesHandlers';
 import { LspResourceHandlers } from './LspResourceHandlers';
@@ -18,6 +19,7 @@ export class LspComponents {
         public readonly handlers: LspHandlers,
         public readonly authHandlers: LspAuthHandlers,
         public readonly stackHandlers: LspStackHandlers,
+        public readonly environmentHandlers: LspEnvironmentHandlers,
         public readonly resourceHandlers: LspResourceHandlers,
         public readonly relatedResourcesHandlers: LspRelatedResourcesHandlers,
         public readonly s3Handlers: LspS3Handlers,

src/protocol/LspConnection.ts

@@ -13,6 +13,7 @@ import { LspCommunication } from './LspCommunication';
 import { LspComponents } from './LspComponents';
 import { LspDiagnostics } from './LspDiagnostics';
 import { LspDocuments } from './LspDocuments';
+import { LspEnvironmentHandlers } from './LspEnvironmentHandlers';
 import { LspHandlers } from './LspHandlers';
 import { LspRelatedResourcesHandlers } from './LspRelatedResourcesHandlers';
 import { LspResourceHandlers } from './LspResourceHandlers';
@@ -35,6 +36,7 @@ export class LspConnection {
     private readonly handlers: LspHandlers;
     private readonly authHandlers: LspAuthHandlers;
     private readonly stackHandlers: LspStackHandlers;
+    private readonly environmentHandlers: LspEnvironmentHandlers;
     private readonly resourceHandlers: LspResourceHandlers;
     private readonly relatedResourcesHandlers: LspRelatedResourcesHandlers;
     private readonly s3Handlers: LspS3Handlers;
@@ -59,6 +61,7 @@ export class LspConnection {
         this.handlers = new LspHandlers(this.connection);
         this.authHandlers = new LspAuthHandlers(this.connection);
         this.stackHandlers = new LspStackHandlers(this.connection);
+        this.environmentHandlers = new LspEnvironmentHandlers(this.connection);
         this.resourceHandlers = new LspResourceHandlers(this.connection);
         this.relatedResourcesHandlers = new LspRelatedResourcesHandlers(this.connection);
         this.s3Handlers = new LspS3Handlers(this.connection);
@@ -93,6 +96,7 @@ export class LspConnection {
             this.handlers,
             this.authHandlers,
             this.stackHandlers,
+            this.environmentHandlers,
             this.resourceHandlers,
             this.relatedResourcesHandlers,
             this.s3Handlers,

src/protocol/LspEnvironmentHandlers.ts

@@ -0,0 +1,14 @@
+import { Connection, RequestHandler } from 'vscode-languageserver';
+import {
+    ParseEnvironmentFilesParams,
+    ParseEnvironmentFilesResult,
+    ParseEnvironmentFilesRequest,
+} from '../environments/EnvironmentRequestType';
+
+export class LspEnvironmentHandlers {
+    constructor(private readonly connection: Connection) {}
+
+    onParseEnvironmentFiles(handler: RequestHandler<ParseEnvironmentFilesParams, ParseEnvironmentFilesResult, void>) {
+        this.connection.onRequest(ParseEnvironmentFilesRequest.method, handler);
+    }
+}

src/server/CfnServer.ts

@@ -7,6 +7,7 @@ import { configurationHandler } from '../handlers/ConfigurationHandler';
 import { definitionHandler } from '../handlers/DefinitionHandler';
 import { didChangeHandler, didCloseHandler, didOpenHandler, didSaveHandler } from '../handlers/DocumentHandler';
 import { documentSymbolHandler } from '../handlers/DocumentSymbolHandler';
+import { parseEnvironmentFilesHandler } from '../handlers/EnvironmentHandler';
 import { executionHandler } from '../handlers/ExecutionHandler';
 import { hoverHandler } from '../handlers/HoverHandler';
 import { initializedHandler } from '../handlers/Initialize';
@@ -126,6 +127,8 @@ export class CfnServer {
         this.lsp.stackHandlers.onClearStackEvents(clearStackEventsHandler(this.components));
         this.lsp.stackHandlers.onGetStackOutputs(getStackOutputsHandler(this.components));
 
+        this.lsp.environmentHandlers.onParseEnvironmentFiles(parseEnvironmentFilesHandler());
+
         this.lsp.relatedResourcesHandlers.onGetAuthoredResourceTypes(getAuthoredResourceTypesHandler(this.components));
         this.lsp.relatedResourcesHandlers.onGetRelatedResourceTypes(getRelatedResourceTypesHandler(this.components));
         this.lsp.relatedResourcesHandlers.onInsertRelatedResources(insertRelatedResourcesHandler(this.components));

tools/telemetry-generator.ts

@@ -69,6 +69,7 @@ import { LspS3Handlers } from '../src/protocol/LspS3Handlers';
 import { ExtendedInitializeParams } from '../src/server/InitParams';
 import { FeatureFlagProvider } from '../src/featureFlag/FeatureFlagProvider';
 import { RelationshipSchemaService } from '../src/services/RelationshipSchemaService';
+import { LspEnvironmentHandlers } from '../src/protocol/LspEnvironmentHandlers';
 
 const argv = yargs(hideBin(process.argv))
     .option('templates', {
@@ -184,6 +185,7 @@ function main() {
         stubInterface<LspHandlers>(),
         createMockAuthHandlers(),
         stubInterface<LspStackHandlers>(),
+        stubInterface<LspEnvironmentHandlers>(),
         stubInterface<LspResourceHandlers>(),
         stubInterface<LspRelatedResourcesHandlers>(),
         stubInterface<LspS3Handlers>(),