JS-728 Revert Write ast files to disk (#5432)

Author: vdiez

packages/bridge/src/delegate.ts

@@ -15,13 +15,13 @@
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
 import express from 'express';
-import { Worker } from 'node:worker_threads';
 import { handleRequest } from './handle-request.js';
-import { RequestResult, RequestType, WsIncrementalResult } from './request.js';
-import { WorkerData } from '../../shared/src/helpers/worker.js';
 import { info, debug, error } from '../../shared/src/helpers/logging.js';
+import type { Worker } from 'node:worker_threads';
+import type { RequestResult, RequestType, WsIncrementalResult } from './request.js';
+import type { WorkerData } from '../../shared/src/helpers/worker.js';
 import type { RawData, WebSocket } from 'ws';
-import { WorkerMessageListeners } from './router.js';
+import type { WorkerMessageListeners } from './router.js';
 
 /**
  * Returns a delegate function to handle an HTTP request

packages/bridge/src/handle-request.ts

@@ -28,8 +28,13 @@ import {
 } from '../../jsts/src/program/program.js';
 import { Linter } from '../../jsts/src/linter/linter.js';
 import { clearTypeScriptESLintParserCaches } from '../../jsts/src/parsers/eslint.js';
-import { BridgeRequest, RequestResult, serializeError, WsIncrementalResult } from './request.js';
-import { WorkerData } from '../../shared/src/helpers/worker.js';
+import {
+  type BridgeRequest,
+  type RequestResult,
+  serializeError,
+  type WsIncrementalResult,
+} from './request.js';
+import type { WorkerData } from '../../shared/src/helpers/worker.js';
 
 export async function handleRequest(
   request: BridgeRequest,

packages/bridge/src/request.ts

@@ -14,19 +14,19 @@
  * You should have received a copy of the Sonar Source-Available License
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
-import { AnalysisOutput } from '../../shared/src/types/analysis.js';
-import {
-  type FileResult,
+import type { AnalysisOutput } from '../../shared/src/types/analysis.js';
+import type {
+  FileResult,
   ProjectAnalysisInput,
   ProjectAnalysisMeta,
 } from '../../jsts/src/analysis/projectAnalysis/projectAnalysis.js';
-import { TsConfigJson } from 'type-fest';
-import { RuleConfig } from '../../jsts/src/linter/config/rule-config.js';
+import type { TsConfigJson } from 'type-fest';
+import type { RuleConfig } from '../../jsts/src/linter/config/rule-config.js';
 import { APIError, ErrorCode } from '../../shared/src/errors/error.js';
-import { NamedDependency } from '../../jsts/src/rules/index.js';
-import { CssAnalysisInput } from '../../css/src/analysis/analysis.js';
-import { JsTsAnalysisInput } from '../../jsts/src/analysis/analysis.js';
-import { EmbeddedAnalysisInput } from '../../jsts/src/embedded/analysis/analysis.js';
+import type { NamedDependency } from '../../jsts/src/rules/index.js';
+import type { CssAnalysisInput } from '../../css/src/analysis/analysis.js';
+import type { JsTsAnalysisInput } from '../../jsts/src/analysis/analysis.js';
+import type { EmbeddedAnalysisInput } from '../../jsts/src/embedded/analysis/analysis.js';
 
 export type RequestResult =
   | {

packages/bridge/tests/router.test.ts

@@ -26,11 +26,10 @@ import { rule as S5362 } from '../../css/src/rules/S5362/index.js';
 import assert from 'node:assert';
 import { toUnixPath } from '../../shared/src/helpers/files.js';
 import { ProjectAnalysisInput } from '../../jsts/src/analysis/projectAnalysis/projectAnalysis.js';
-import { readProtobufFromFilePath } from '../../jsts/src/parsers/ast.js';
+import { deserializeProtobuf } from '../../jsts/src/parsers/ast.js';
 import { createAndSaveProgram } from '../../jsts/src/program/program.js';
 import { RuleConfig } from '../../jsts/src/linter/config/rule-config.js';
 import { createWorker } from '../../shared/src/helpers/worker.js';
-import { join } from 'node:path/posix';
 
 describe('router', () => {
   const fixtures = path.join(import.meta.dirname, 'fixtures', 'router');
@@ -109,32 +108,28 @@ describe('router', () => {
   });
 
   it('should route /analyze-jsts requests', async () => {
-    await requestInitLinter(
-      server,
-      [
-        {
-          key: 'S6325',
-          configurations: [],
-          fileTypeTargets: ['MAIN'],
-          language: 'js',
-          analysisModes: ['DEFAULT'],
-        },
-        {
-          key: 'S4621',
-          configurations: [],
-          fileTypeTargets: ['MAIN'],
-          language: 'ts',
-          analysisModes: ['DEFAULT'],
-        },
-      ],
-      join(fixtures, '.scannerwork'),
-    );
+    await requestInitLinter(server, [
+      {
+        key: 'S6325',
+        configurations: [],
+        fileTypeTargets: ['MAIN'],
+        language: 'js',
+        analysisModes: ['DEFAULT'],
+      },
+      {
+        key: 'S4621',
+        configurations: [],
+        fileTypeTargets: ['MAIN'],
+        language: 'ts',
+        analysisModes: ['DEFAULT'],
+      },
+    ]);
     let filePath = path.join(fixtures, 'file.js');
     let fileType = 'MAIN';
     let data: any = { filePath, fileType, tsConfigs: [] };
     let response = await request(server, '/analyze-jsts', 'POST', data);
     let {
-      astFilePath,
+      ast,
       issues: [issue],
     } = JSON.parse(response);
     expect(issue).toEqual(
@@ -147,7 +142,7 @@ describe('router', () => {
         message: `Use a regular expression literal instead of the 'RegExp' constructor.`,
       }),
     );
-    const protoMessage = await readProtobufFromFilePath(astFilePath);
+    const protoMessage = deserializeProtobuf(ast);
     expect(protoMessage.type).toEqual(0);
     expect(protoMessage.program.body).toHaveLength(1);
     expect(protoMessage.program.body[0].expressionStatement.expression.newExpression).toBeDefined();
@@ -362,7 +357,7 @@ describe('router', () => {
   });
 });
 
-function requestInitLinter(server: http.Server, rules: RuleConfig[], rulesWorkdir?: string) {
-  const config = { rules, rulesWorkdir };
+function requestInitLinter(server: http.Server, rules: RuleConfig[]) {
+  const config = { rules };
   return request(server, '/init-linter', 'POST', config);
 }

packages/jsts/src/analysis/analysis.ts

@@ -75,7 +75,7 @@ export interface JsTsAnalysisOutput extends AnalysisOutput {
 }
 
 export interface JsTsAnalysisOutputWithAst extends JsTsAnalysisOutput {
-  astFilePath: string; // path to a binary encoded AST
+  ast: string; // Base64 encoded Protobuf binary representation
 }
 /**
  * In SonarQube context, an analysis input includes both path and content of a file

packages/jsts/src/analysis/analyzer.ts

@@ -34,9 +34,6 @@ import { getCpdTokens } from '../linter/visitors/cpd.js';
 import { clearDependenciesCache, getAllDependencies } from '../rules/index.js';
 import { Telemetry } from '../../../bridge/src/request.js';
 import { fillFileContent } from '../../../shared/src/types/analysis.js';
-import { writeFile, mkdir } from 'node:fs/promises';
-import { join } from 'node:path/posix';
-import { randomBytes } from 'node:crypto';
 
 /**
  * Analyzes a JavaScript / TypeScript analysis input
@@ -87,11 +84,11 @@ export async function analyzeJSTS(
     };
 
     if (!input.skipAst) {
-      const astFilePath = await serializeAst(parseResult.sourceCode, filePath, Linter.rulesWorkdir);
-      if (astFilePath) {
+      const ast = serializeAst(parseResult.sourceCode, filePath);
+      if (ast) {
         return {
+          ast,
           ...result,
-          astFilePath,
         };
       }
     }
@@ -107,27 +104,13 @@ export async function analyzeJSTS(
   }
 }
 
-function generateRandomFilename(extension: string) {
-  // 16 bytes = 32 hex characters
-  const randomName = randomBytes(16).toString('hex');
-  return randomName + extension;
-}
-
-async function serializeAst(sourceCode: SourceCode, filePath: string, workdir: string | undefined) {
-  if (!workdir) {
-    return null;
-  }
+function serializeAst(sourceCode: SourceCode, filePath: string) {
   try {
-    const serializedAST = serializeInProtobuf(sourceCode.ast as TSESTree.Program, filePath);
-    const astDir = join(workdir, 'asts');
-    await mkdir(astDir, { recursive: true });
-    const astFilePath = join(astDir, generateRandomFilename('.ast'));
-    await writeFile(astFilePath, serializedAST);
-    return astFilePath;
+    return serializeInProtobuf(sourceCode.ast as TSESTree.Program, filePath);
   } catch (e) {
     info(`Failed to serialize AST for file "${filePath}"`);
+    return null;
   }
-  return null;
 }
 
 /**

packages/jsts/src/analysis/projectAnalysis/analyzeWithProgram.ts

@@ -23,7 +23,7 @@ import { tsConfigStore } from './file-stores/index.js';
 import ts from 'typescript';
 import { ProgressReport } from '../../../../shared/src/helpers/progress-report.js';
 import { handleFileResult } from './handleFileResult.js';
-import { WsIncrementalResult } from '../../../../bridge/src/request.js';
+import type { WsIncrementalResult } from '../../../../bridge/src/request.js';
 
 /**
  * Analyzes JavaScript / TypeScript files using TypeScript programs. Files not

packages/jsts/src/analysis/projectAnalysis/handleFileResult.ts

@@ -15,7 +15,7 @@
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
 import type { FileResult, ProjectAnalysisOutput } from './projectAnalysis.js';
-import { WsIncrementalResult } from '../../../../bridge/src/request.js';
+import type { WsIncrementalResult } from '../../../../bridge/src/request.js';
 
 export function handleFileResult(
   result: FileResult,

packages/jsts/src/linter/linter.ts

@@ -92,7 +92,7 @@ export class Linter {
   /** The global variables */
   public static readonly globals: Map<string, ESLintLinter.GlobalConf> = new Map();
   /** The rules working directory (used for ucfg, architecture, dbd...) */
-  public static rulesWorkdir?: string;
+  private static rulesWorkdir?: string;
   /** whether we are running in sonarlint context */
   private static sonarlint: boolean;
 

packages/jsts/src/parsers/ast.ts

@@ -15,20 +15,20 @@
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
 import protobuf from 'protobufjs';
+import base64 from '@protobufjs/base64';
 import type { TSESTree } from '@typescript-eslint/utils';
 
 import path from 'path';
 import { fileURLToPath } from 'node:url';
 import { debug } from '../../../shared/src/helpers/logging.js';
-import { readFile } from 'node:fs/promises';
 
 const PATH_TO_PROTOFILE = path.join(path.dirname(fileURLToPath(import.meta.url)), 'estree.proto');
 const PROTO_ROOT = protobuf.loadSync(PATH_TO_PROTOFILE);
 const NODE_TYPE = PROTO_ROOT.lookupType('Node');
 export const NODE_TYPE_ENUM = PROTO_ROOT.lookupEnum('NodeType');
 const unsupportedNodeTypes = new Map<string, number>();
 
-export function serializeInProtobuf(ast: TSESTree.Program, filePath: string) {
+export function serializeInProtobuf(ast: TSESTree.Program, filePath: string): string {
   unsupportedNodeTypes.clear();
   const protobufAST = parseInProtobuf(ast);
   if (unsupportedNodeTypes.size > 0) {
@@ -39,7 +39,8 @@ export function serializeInProtobuf(ast: TSESTree.Program, filePath: string) {
           .join(', '),
     );
   }
-  return NODE_TYPE.encode(NODE_TYPE.create(protobufAST)).finish();
+  const binaryArray = NODE_TYPE.encode(NODE_TYPE.create(protobufAST)).finish();
+  return base64.encode(binaryArray, 0, binaryArray.length);
 }
 
 /**
@@ -51,15 +52,14 @@ export function parseInProtobuf(ast: TSESTree.Program) {
   return protobufType.create(protobufShapedAST);
 }
 
-export function deserializeProtobuf(buffer: Uint8Array) {
-  return NODE_TYPE.decode(buffer);
-}
-
 /**
  * Only used for tests
  */
-export async function readProtobufFromFilePath(filePath: string): Promise<any> {
-  return deserializeProtobuf(await readFile(filePath));
+export function deserializeProtobuf(serialized: string): any {
+  const computedLength = base64.length(serialized);
+  const buffer = new Uint8Array(computedLength);
+  base64.decode(serialized, buffer, 0);
+  return NODE_TYPE.decode(buffer);
 }
 
 // Exported for testing purpose