@eventra_dev/eventra-cli 0.3.4 → 0.3.5

package/dist/analysis/engine/recursiveWrapperAnalyzer.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeFileRecursive = analyzeFileRecursive;
+const typescript_1 = __importDefault(require("typescript"));
+const propagationAnalyzer_1 = require("../scanner/analyzer/propagationAnalyzer");
+const extractor_1 = require("../extractor/extractor");
+async function analyzeFileRecursive(sourceFile, config, wrapperRegistry, evaluationCache, resolvedCallCache, returnPropagationCache, resolvedExportCache) {
+    const checker = wrapperRegistry["checker"];
+    const sinks = [];
+    const wrappers = [];
+    const trackCalls = [];
+    // Support empty functionWrappers
+    const wrapperNames = new Set(config.functionWrappers?.map(w => w.name) ?? []);
+    function visit(node, parentFunction) {
+        // Detect calls to configured wrapper functions
+        if (typescript_1.default.isCallExpression(node)) {
+            const callName = getCallName(node.expression);
+            if (wrapperNames.has(callName)) {
+                // Track this wrapper call
+                sinks.push({ call: node, trackedArguments: [{ index: 0, propertyPath: [] }] });
+                trackCalls.push({
+                    node,
+                    sourceFile,
+                    trackedArguments: node.arguments.filter(typescript_1.default.isExpression)
+                });
+            }
+        }
+        // Detect and analyze function declarations / expressions / methods
+        if (typescript_1.default.isFunctionDeclaration(node) ||
+            typescript_1.default.isFunctionExpression(node) ||
+            typescript_1.default.isArrowFunction(node) ||
+            typescript_1.default.isMethodDeclaration(node)) {
+            const localSinks = sinks.filter(s => isNodeInside(s.call, node));
+            const wrapper = (0, propagationAnalyzer_1.analyzeWrapperPropagation)(node, checker, localSinks);
+            if (wrapper) {
+                wrappers.push(wrapper);
+                wrapperRegistry.set(wrapper);
+            }
+            // Recurse into function body
+            if (node.body) {
+                typescript_1.default.forEachChild(node.body, child => visit(child, node));
+            }
+            return;
+        }
+        // Recurse into child nodes
+        typescript_1.default.forEachChild(node, child => visit(child, parentFunction));
+    }
+    visit(sourceFile);
+    // Extract events from tracked calls and wrapper metadata
+    return (0, extractor_1.extractEvents)({
+        fileName: sourceFile.fileName,
+        sourceFile,
+        sinks,
+        trackCalls,
+        wrappers,
+    }, checker, config, evaluationCache, resolvedExportCache, resolvedCallCache, returnPropagationCache, wrapperRegistry);
+}
+function isNodeInside(child, fn) {
+    let current = child;
+    while (current) {
+        if (current === fn)
+            return true;
+        current = current.parent;
+    }
+    return false;
+}
+function getCallName(expr) {
+    if (typescript_1.default.isIdentifier(expr))
+        return expr.text;
+    if (typescript_1.default.isPropertyAccessExpression(expr) || typescript_1.default.isPropertyAccessChain(expr))
+        return expr.name.text;
+    return "";
+}

package/dist/core/EventraEngine.js

@@ -14,9 +14,8 @@ const resolvedCallCache_1 = require("../analysis/cache/resolvedCallCache");
 const resolvedExportCache_1 = require("../analysis/cache/resolvedExportCache");
 const returnPropagationCache_1 = require("../analysis/cache/returnPropagationCache");
 const symbolInvalidation_1 = require("../analysis/cache/symbolInvalidation");
-const scanner_1 = require("../analysis/scanner/scanner");
-const extractor_1 = require("../analysis/extractor/extractor");
 const wrapperRegistry_1 = require("../analysis/symbols/wrapperRegistry");
+const recursiveWrapperAnalyzer_1 = require("../analysis/engine/recursiveWrapperAnalyzer");
 const EMPTY_RESULT = () => ({
     events: new Set(),
     detectedFunctionWrappers: new Set(),
@@ -63,7 +62,7 @@ class EventraEngine {
             }
             // RE-ANALYZE
             for (const file of affected) {
-                this.analyzeFile(file, this.lastConfig);
+                await this.analyzeFile(file, this.lastConfig);
             }
         });
     }
@@ -109,19 +108,6 @@ class EventraEngine {
         }
         this.importGraph.updateFile(normalized, imports);
     }
-    analyzeFile(fileName, config) {
-        const normalized = this.normalize(fileName);
-        const source = this.compiler.getSourceFile(normalized);
-        if (!source) {
-            this.fileResults.delete(normalized);
-            return EMPTY_RESULT();
-        }
-        const checker = this.compiler.getChecker();
-        const index = (0, scanner_1.scanSource)(source, checker, this.wrapperRegistry);
-        const result = (0, extractor_1.extractEvents)(index, checker, config, this.evaluationCache, this.resolvedExportCache, this.resolvedCallCache, this.returnPropagationCache, this.wrapperRegistry);
-        this.fileResults.set(normalized, result);
-        return result;
-    }
     async preloadFile(fileName, content) {
         if (!this.isPreloading) {
             throw new Error("preload phase not active");
@@ -135,9 +121,9 @@ class EventraEngine {
         const normalized = this.normalize(fileName);
         await this.scheduler.enqueue(normalized, content);
     }
-    scanFile(fileName, config) {
+    async scanFile(fileName, config) {
         this.lastConfig = config;
-        return this.analyzeFile(fileName, config);
+        return await this.analyzeFile(fileName, config);
     }
     async removeFile(fileName, config) {
         const normalized = this.normalize(fileName);
@@ -152,9 +138,20 @@ class EventraEngine {
             if (file === normalized) {
                 continue;
             }
-            this.analyzeFile(file, nextConfig);
+            await this.analyzeFile(file, nextConfig);
         }
     }
+    async analyzeFile(fileName, config) {
+        const normalized = this.normalize(fileName);
+        const source = this.compiler.getSourceFile(normalized);
+        if (!source) {
+            this.fileResults.delete(normalized);
+            return EMPTY_RESULT();
+        }
+        const result = await (0, recursiveWrapperAnalyzer_1.analyzeFileRecursive)(source, config, this.wrapperRegistry, this.evaluationCache, this.resolvedCallCache, this.returnPropagationCache, this.resolvedExportCache);
+        this.fileResults.set(normalized, result);
+        return result;
+    }
     getAllEvents() {
         const events = new Set();
         for (const result of this.fileResults.values()) {

package/dist/core/projectScanner.js

@@ -60,7 +60,7 @@ async function scanProject(config) {
     const results = new Map();
     for (const file of toScan) {
         try {
-            const result = engine.scanFile((0, getVirtualFile_1.getVirtualFile)(file), config);
+            const result = await engine.scanFile((0, getVirtualFile_1.getVirtualFile)(file), config);
             results.set(file, result);
         }
         catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Static analytics event extraction CLI powered by the TypeScript compiler API",
   "license": "MIT",
   "type": "commonjs",