JS-154: Bridge sends AST to plugin as multipart/form-data

its/plugin/tests/src/test/java/com/sonar/javascript/it/plugin/SonarJsIntegrationTest.java

@@ -97,8 +97,9 @@ private void assertAnalyzeJs(Bridge bridge) throws IOException, InterruptedExcep
     r.fileContent =
       "function foo() { \n" + "  var a; \n" + "  var c; // NOSONAR\n" + "  var b = 42; \n" + "} \n";
     r.filePath = temp.resolve("file.js").toAbsolutePath().toString();
-    String response = bridge.request(gson.toJson(r), "analyze-js");
-    JsonObject jsonObject = gson.fromJson(response, JsonObject.class);
+    HttpResponse<String> response = bridge.request(gson.toJson(r), "analyze-js");
+    var parsedResponse = parseFormData(response);
+    JsonObject jsonObject = gson.fromJson(parsedResponse.json(), JsonObject.class);
     JsonArray issues = jsonObject.getAsJsonArray("issues");
     assertThat(issues).hasSize(3);
     assertThat(issues)
@@ -108,6 +109,34 @@ private void assertAnalyzeJs(Bridge bridge) throws IOException, InterruptedExcep
     JsonObject metrics = jsonObject.getAsJsonObject("metrics");
     assertThat(metrics.entrySet()).hasSize(1);
     assertThat(metrics.get("nosonarLines").getAsJsonArray()).containsExactly(new JsonPrimitive(3));
+    assertThat(parsedResponse.ast()).contains("plop");
+  }
+
+  private static BridgeResponse parseFormData(HttpResponse<String> response) {
+    String boundary = "--" + response.headers().firstValue("Content-Type")
+      .orElseThrow(() -> new IllegalStateException("No Content-Type header"))
+      .split("boundary=")[1];
+    String[] parts = response.body().split(boundary);
+    String json = null;
+    String ast = null;
+    for (String part : parts) {
+      // Split the part into headers and body
+      String[] splitPart = part.split("\r\n\r\n", 2);
+      if (splitPart.length < 2) {
+        // Skip if there's no body
+        continue;
+      }
+
+      String headers = splitPart[0];
+      String partBody = splitPart[1];
+
+      if (headers.contains("json")) {
+        json = partBody;
+      } else if (headers.contains("ast")) {
+        ast = partBody;
+      }
+    }
+    return new BridgeResponse(json, ast);
   }
 
   private void assertStatus(Bridge bridge) {
@@ -186,15 +215,14 @@ void start(Path dest) throws IOException {
       process = pb.start();
     }
 
-    String request(String json, String endpoint) throws IOException, InterruptedException {
+    HttpResponse<String> request(String json, String endpoint) throws IOException, InterruptedException {
       var request = HttpRequest
         .newBuilder(url(endpoint))
         .header("Content-Type", "application/json")
         .POST(HttpRequest.BodyPublishers.ofString(json))
         .build();
 
-      var response = client.send(request, HttpResponse.BodyHandlers.ofString());
-      return response.body();
+      return client.send(request, HttpResponse.BodyHandlers.ofString());
     }
 
     String status() throws IOException, InterruptedException {
@@ -249,4 +277,6 @@ static class Rule {
     List<Object> configurations = Collections.emptyList();
     String fileTypeTarget = "MAIN";
   }
+
+  record BridgeResponse(String json, String ast) {}
 }

package.json

@@ -91,6 +91,7 @@
     "eslint-plugin-react-hooks": "4.6.0",
     "eslint-plugin-sonarjs": "^1.0.3",
     "express": "4.19.2",
+    "form-data": "4.0.0",
     "functional-red-black-tree": "1.0.1",
     "htmlparser2": "9.1.0",
     "jsx-ast-utils": "3.3.5",
@@ -136,6 +137,7 @@
     "eslint-plugin-react-hooks",
     "eslint-plugin-sonarjs",
     "express",
+    "form-data",
     "functional-red-black-tree",
     "htmlparser2",
     "jsx-ast-utils",

packages/bridge/src/errors/middleware.ts

@@ -92,4 +92,5 @@ export const EMPTY_JSTS_ANALYSIS_OUTPUT: JsTsAnalysisOutput = {
     cognitiveComplexity: 0,
   },
   cpdTokens: [],
+  ast: '',
 };

packages/bridge/src/worker.js

@@ -20,6 +20,7 @@
 
 require('module-alias/register');
 
+const formData = require('form-data');
 const { parentPort, workerData } = require('worker_threads');
 const {
   analyzeJSTS,
@@ -47,8 +48,20 @@ exports.delegate = function (worker, type) {
     worker.once('message', message => {
       switch (message.type) {
         case 'success':
-          response.send(message.result);
+          if (message.format === 'multipart') {
+            const fd = new formData();
+            fd.append('ast', message.result.ast);
+            delete message.result.ast;
+            fd.append('json', JSON.stringify(message.result));
+            // this adds the boundary string that will be used to separate the parts
+            response.set('Content-Type', fd.getHeaders()['content-type']);
+            response.set('Content-Length', fd.getLengthSync());
+            fd.pipe(response);
+          } else {
+            response.send(message.result);
+          }
           break;
+
         case 'failure':
           next(message.error);
           break;
@@ -92,7 +105,11 @@ if (parentPort) {
           await readFileLazily(data);
 
           const output = analyzeJSTS(data, 'js');
-          parentThread.postMessage({ type: 'success', result: JSON.stringify(output) });
+          parentThread.postMessage({
+            type: 'success',
+            result: output,
+            format: 'multipart',
+          });
           break;
         }
 
@@ -107,7 +124,11 @@ if (parentPort) {
           await readFileLazily(data);
 
           const output = analyzeJSTS(data, 'ts');
-          parentThread.postMessage({ type: 'success', result: JSON.stringify(output) });
+          parentThread.postMessage({
+            type: 'success',
+            result: output,
+            format: 'multipart',
+          });
           break;
         }
 

packages/bridge/tests/router.test.ts

@@ -114,10 +114,10 @@ describe('router', () => {
     const filePath = path.join(fixtures, 'file.js');
     const fileType = 'MAIN';
     const data = { filePath, fileType, tsConfigs: [] };
-    const response = (await request(server, '/analyze-js', 'POST', data)) as string;
+    const response = (await request(server, '/analyze-js', 'POST', data, 'formdata')) as FormData;
     const {
       issues: [issue],
-    } = JSON.parse(response);
+    } = JSON.parse(response.get('json') as string);
     expect(issue).toEqual(
       expect.objectContaining({
         ruleId: 'prefer-regex-literals',
@@ -128,6 +128,8 @@ describe('router', () => {
         message: `Use a regular expression literal instead of the 'RegExp' constructor.`,
       }),
     );
+    const ast = response.get('ast');
+    expect(ast).toEqual('plop');
   });
 
   it('should route /analyze-ts requests', async () => {
@@ -138,10 +140,10 @@ describe('router', () => {
     const fileType = 'MAIN';
     const tsConfig = path.join(fixtures, 'tsconfig.json');
     const data = { filePath, fileType, tsConfigs: [tsConfig] };
-    const response = (await request(server, '/analyze-ts', 'POST', data)) as string;
+    const response = (await request(server, '/analyze-ts', 'POST', data, 'formdata')) as FormData;
     const {
       issues: [issue],
-    } = JSON.parse(response);
+    } = JSON.parse(response.get('json') as string);
     expect(issue).toEqual(
       expect.objectContaining({
         ruleId: 'no-duplicate-in-composite',
@@ -152,6 +154,8 @@ describe('router', () => {
         message: `Remove this duplicated type or replace with another one.`,
       }),
     );
+    const ast = response.get('ast');
+    expect(ast).toEqual('plop');
   });
 
   it('should route /analyze-with-program requests', async () => {
@@ -165,10 +169,16 @@ describe('router', () => {
       (await request(server, '/create-program', 'POST', { tsConfig })) as string,
     );
     const data = { filePath, fileType, programId };
-    const response = (await request(server, '/analyze-with-program', 'POST', data)) as string;
+    const response = (await request(
+      server,
+      '/analyze-with-program',
+      'POST',
+      data,
+      'formdata',
+    )) as FormData;
     const {
       issues: [issue],
-    } = JSON.parse(response);
+    } = JSON.parse(response.get('json') as string);
     expect(issue).toEqual(
       expect.objectContaining({
         ruleId: 'no-duplicate-in-composite',

packages/bridge/tests/server.test.ts

@@ -21,7 +21,7 @@ import { start } from '../src/server';
 import path from 'path';
 import { setContext } from '@sonar/shared';
 import { AddressInfo } from 'net';
-import { request } from './tools';
+import { BridgeResponseType, request } from './tools';
 import http from 'http';
 
 describe('server', () => {
@@ -75,10 +75,10 @@ describe('server', () => {
     });
 
     expect(await requestInitLinter(server, fileType, ruleId)).toBe('OK!');
-
+    const response = await requestAnalyzeJs(server, fileType, 'formdata');
     const {
       issues: [issue],
-    } = JSON.parse(await requestAnalyzeJs(server, fileType));
+    } = JSON.parse(response.get('json'));
     expect(issue).toEqual(
       expect.objectContaining({
         ruleId,
@@ -99,11 +99,11 @@ describe('server', () => {
     const fileType = 'MAIN';
 
     await requestInitLinter(server, fileType, ruleId);
-    const response = await requestAnalyzeJs(server, fileType);
+    const response = await requestAnalyzeJs(server, fileType, 'formdata');
 
     const {
       issues: [issue],
-    } = JSON.parse(response);
+    } = JSON.parse(response.get('json'));
     expect(issue).toEqual(
       expect.objectContaining({
         ruleId,
@@ -162,11 +162,15 @@ describe('server', () => {
   });
 });
 
-async function requestAnalyzeJs(server: http.Server, fileType: string): Promise<any> {
+async function requestAnalyzeJs(
+  server: http.Server,
+  fileType: string,
+  format: BridgeResponseType = 'text',
+): Promise<any> {
   const filePath = path.join(__dirname, 'fixtures', 'routing.js');
   const analysisInput = { filePath, fileType };
 
-  return await request(server, '/analyze-js', 'POST', analysisInput);
+  return await request(server, '/analyze-js', 'POST', analysisInput, format);
 }
 
 function requestInitLinter(server: http.Server, fileType: string, ruleId: string) {