@eventra_dev/eventra-cli 0.1.3 → 0.1.4

package/dist/engine/functionAnalyzer.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findTrackParamIndex = findTrackParamIndex;
+const typescript_1 = __importDefault(require("typescript"));
+function findTrackParamIndex(fn) {
+    const paramIndex = new Map();
+    fn.parameters.forEach((p, i) => {
+        if (typescript_1.default.isIdentifier(p.name)) {
+            paramIndex.set(p.name.text, i);
+        }
+    });
+    let result = null;
+    function visit(node) {
+        if (typescript_1.default.isCallExpression(node)) {
+            const name = getCallName(node.expression);
+            if (/(track|event|capture|send)/i.test(name)) {
+                for (const arg of node.arguments) {
+                    if (typescript_1.default.isIdentifier(arg)) {
+                        const idx = paramIndex.get(arg.text);
+                        if (idx !== undefined) {
+                            result = idx;
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        typescript_1.default.forEachChild(node, visit);
+    }
+    if (fn.body) {
+        visit(fn.body);
+    }
+    return result;
+}
+function getCallName(expr) {
+    if (typescript_1.default.isIdentifier(expr))
+        return expr.text;
+    if (typescript_1.default.isPropertyAccessExpression(expr)) {
+        return expr.name.text;
+    }
+    return "";
+}

package/dist/engine/graph.js

@@ -9,6 +9,7 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 class DependencyGraph {
     reverse = new Map();
+    exports = new Map();
     normalize(file) {
         return path_1.default.resolve(file);
     }
@@ -35,26 +36,55 @@ class DependencyGraph {
     }
     update(file, source) {
         const normalizedFile = this.normalize(file);
+        this.exports.set(normalizedFile, new Set());
         for (const stmt of source.statements) {
-            if (!typescript_1.default.isImportDeclaration(stmt))
-                continue;
-            const module = stmt.moduleSpecifier
-                .getText()
-                .replace(/['"]/g, "");
-            const resolved = this.resolveImport(normalizedFile, module);
-            if (!resolved)
-                continue;
-            if (!this.reverse.has(resolved)) {
-                this.reverse.set(resolved, new Set());
+            // IMPORT
+            if (typescript_1.default.isImportDeclaration(stmt)) {
+                const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+                const resolved = this.resolveImport(normalizedFile, module);
+                if (!resolved)
+                    continue;
+                if (!this.reverse.has(resolved)) {
+                    this.reverse.set(resolved, new Set());
+                }
+                this.reverse.get(resolved).add(normalizedFile);
             }
-            this.reverse.get(resolved).add(normalizedFile);
+            // EXPORT
+            if (typescript_1.default.isExportDeclaration(stmt) && stmt.moduleSpecifier) {
+                const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+                const resolved = this.resolveImport(normalizedFile, module);
+                if (!resolved)
+                    continue;
+                if (!this.exports.has(normalizedFile)) {
+                    this.exports.set(normalizedFile, new Set());
+                }
+                this.exports.get(normalizedFile).add(resolved);
+                if (!this.reverse.has(resolved)) {
+                    this.reverse.set(resolved, new Set());
+                }
+                this.reverse.get(resolved).add(normalizedFile);
+            }
+        }
+    }
+    getAllRelated(file, visited = new Set()) {
+        const normalized = this.normalize(file);
+        if (visited.has(normalized))
+            return visited;
+        visited.add(normalized);
+        const deps = this.exports.get(normalized);
+        if (!deps)
+            return visited;
+        for (const dep of deps) {
+            this.getAllRelated(dep, visited);
         }
+        return visited;
     }
     getDependents(file) {
         return [...(this.reverse.get(this.normalize(file)) ?? [])];
     }
     remove(file) {
         const normalized = this.normalize(file);
+        this.exports.delete(normalized);
         for (const set of this.reverse.values()) {
             set.delete(normalized);
         }

package/dist/engine/languageService.js

@@ -9,6 +9,7 @@ const fs_1 = __importDefault(require("fs"));
 class TSService {
     root;
     files = new Map();
+    fileNames = new Set();
     service;
     constructor(root) {
         this.root = root;
@@ -30,10 +31,7 @@ class TSService {
             };
         }
         const host = {
-            getScriptFileNames: () => [
-                ...this.files.keys(),
-                ...typescript_1.default.sys.readDirectory(this.root, [".ts", ".tsx"], ["node_modules", "dist", ".git"])
-            ],
+            getScriptFileNames: () => [...this.fileNames],
             getScriptVersion: (file) => this.files.get(file)?.version.toString() ?? "0",
             getScriptSnapshot: (file) => {
                 const f = this.files.get(file);
@@ -60,6 +58,7 @@ class TSService {
             content,
             version: prev ? prev.version + 1 : 1,
         });
+        this.fileNames.add(file);
     }
     getProgram() {
         return this.service.getProgram();

package/dist/engine/scanner.js

@@ -7,6 +7,34 @@ exports.scanSource = scanSource;
 const typescript_1 = __importDefault(require("typescript"));
 const resolver_1 = require("./resolver");
 const callResolver_1 = require("./callResolver");
+const functionAnalyzer_1 = require("./functionAnalyzer");
+function getCallName(expr) {
+    if (typescript_1.default.isIdentifier(expr))
+        return expr.text;
+    if (typescript_1.default.isPropertyAccessExpression(expr)) {
+        return expr.name.text;
+    }
+    return "";
+}
+function pickBestArg(args, checker, paramMap) {
+    let best = null;
+    for (const arg of args) {
+        const res = (0, resolver_1.resolveNodeValue)(arg, checker, paramMap);
+        if (!res?.values?.length)
+            continue;
+        let score = 0;
+        if (!res.dynamic)
+            score += 3;
+        if (res.values.every(v => v.length < 50))
+            score += 2;
+        if (res.values.some(v => v.includes("*")))
+            score -= 2;
+        if (!best || score > best.score) {
+            best = { score, node: arg };
+        }
+    }
+    return best?.node;
+}
 function scanSource(source, checker, visited = new Set(), depth = 0) {
     if (depth > 5)
         return new Set();
@@ -19,8 +47,7 @@ function scanSource(source, checker, visited = new Set(), depth = 0) {
             const name = getCallName(node.expression);
             if (/(track|event|capture|send)/i.test(name)) {
                 const fn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
-                // param mapping
-                let paramMap = new Map();
+                const paramMap = new Map();
                 if (fn && typescript_1.default.isFunctionLike(fn)) {
                     fn.parameters.forEach((param, index) => {
                         const arg = node.arguments[index];
@@ -31,16 +58,29 @@ function scanSource(source, checker, visited = new Set(), depth = 0) {
                         }
                     });
                 }
-                // cross-file traversal
-                if (fn) {
-                    const sf = fn.getSourceFile();
-                    if (!visited.has(sf.fileName)) {
-                        scanSource(sf, checker, visited, depth + 1)
-                            .forEach(e => events.add(e));
+                if (fn && typescript_1.default.isFunctionLike(fn)) {
+                    const idx = (0, functionAnalyzer_1.findTrackParamIndex)(fn);
+                    if (idx !== null) {
+                        const realArg = node.arguments[idx];
+                        if (realArg) {
+                            const res = (0, resolver_1.resolveNodeValue)(realArg, checker, paramMap);
+                            res?.values.forEach(v => {
+                                if (v &&
+                                    v.length > 1 &&
+                                    v.length < 100 &&
+                                    !v.includes(" ") &&
+                                    /^[a-zA-Z0-9._:-]+$/.test(v)) {
+                                    events.add(v);
+                                }
+                            });
+                            return;
+                        }
                     }
                 }
-                for (const arg of node.arguments) {
-                    const res = (0, resolver_1.resolveNodeValue)(arg, checker, paramMap);
+                // fallback (heuristic)
+                const target = pickBestArg(node.arguments, checker, paramMap);
+                if (target) {
+                    const res = (0, resolver_1.resolveNodeValue)(target, checker, paramMap);
                     res?.values.forEach(v => {
                         if (v &&
                             v.length > 1 &&
@@ -58,11 +98,3 @@ function scanSource(source, checker, visited = new Set(), depth = 0) {
     visit(source);
     return events;
 }
-function getCallName(expr) {
-    if (typescript_1.default.isIdentifier(expr))
-        return expr.text;
-    if (typescript_1.default.isPropertyAccessExpression(expr)) {
-        return expr.name.text;
-    }
-    return "";
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Eventra CLI",
   "type": "commonjs",
   "bin": {

package/src/engine/functionAnalyzer.ts

@@ -0,0 +1,51 @@
+import ts from "typescript";
+
+export function findTrackParamIndex(
+  fn: ts.FunctionLikeDeclaration
+): number | null {
+  const paramIndex = new Map<string, number>();
+
+  fn.parameters.forEach((p, i) => {
+    if (ts.isIdentifier(p.name)) {
+      paramIndex.set(p.name.text, i);
+    }
+  });
+
+  let result: number | null = null;
+
+  function visit(node: ts.Node) {
+    if (ts.isCallExpression(node)) {
+      const name = getCallName(node.expression);
+
+      if (/(track|event|capture|send)/i.test(name)) {
+        for (const arg of node.arguments) {
+          if (ts.isIdentifier(arg)) {
+            const idx = paramIndex.get(arg.text);
+            if (idx !== undefined) {
+              result = idx;
+              return;
+            }
+          }
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  if (fn.body) {
+    visit(fn.body);
+  }
+
+  return result;
+}
+
+function getCallName(expr: ts.Expression): string {
+  if (ts.isIdentifier(expr)) return expr.text;
+
+  if (ts.isPropertyAccessExpression(expr)) {
+    return expr.name.text;
+  }
+
+  return "";
+}

package/src/engine/graph.ts

@@ -4,6 +4,7 @@ import fs from "fs";
 
 export class DependencyGraph {
   private reverse = new Map<string, Set<string>>();
+  private exports = new Map<string, Set<string>>();
 
   private normalize(file: string) {
     return path.resolve(file);
@@ -37,23 +38,60 @@ export class DependencyGraph {
   update(file: string, source: ts.SourceFile) {
     const normalizedFile = this.normalize(file);
 
+    this.exports.set(normalizedFile, new Set());
+
     for (const stmt of source.statements) {
-      if (!ts.isImportDeclaration(stmt)) continue;
+      // IMPORT
+      if (ts.isImportDeclaration(stmt)) {
+        const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+        const resolved = this.resolveImport(normalizedFile, module);
+
+        if (!resolved) continue;
+
+        if (!this.reverse.has(resolved)) {
+          this.reverse.set(resolved, new Set());
+        }
+
+        this.reverse.get(resolved)!.add(normalizedFile);
+      }
+
+      // EXPORT
+      if (ts.isExportDeclaration(stmt) && stmt.moduleSpecifier) {
+        const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+        const resolved = this.resolveImport(normalizedFile, module);
 
-      const module = stmt.moduleSpecifier
-        .getText()
-        .replace(/['"]/g, "");
+        if (!resolved) continue;
 
-      const resolved = this.resolveImport(normalizedFile, module);
+        if (!this.exports.has(normalizedFile)) {
+          this.exports.set(normalizedFile, new Set());
+        }
 
-      if (!resolved) continue;
+        this.exports.get(normalizedFile)!.add(resolved);
 
-      if (!this.reverse.has(resolved)) {
-        this.reverse.set(resolved, new Set());
+        if (!this.reverse.has(resolved)) {
+          this.reverse.set(resolved, new Set());
+        }
+
+        this.reverse.get(resolved)!.add(normalizedFile);
       }
+    }
+  }
+
+  getAllRelated(file: string, visited = new Set<string>()): Set<string> {
+    const normalized = this.normalize(file);
+
+    if (visited.has(normalized)) return visited;
+    visited.add(normalized);
 
-      this.reverse.get(resolved)!.add(normalizedFile);
+    const deps = this.exports.get(normalized);
+
+    if (!deps) return visited;
+
+    for (const dep of deps) {
+      this.getAllRelated(dep, visited);
     }
+
+    return visited;
   }
 
   getDependents(file: string) {
@@ -63,6 +101,8 @@ export class DependencyGraph {
   remove(file: string) {
     const normalized = this.normalize(file);
 
+    this.exports.delete(normalized);
+
     for (const set of this.reverse.values()) {
       set.delete(normalized);
     }

package/src/engine/languageService.ts

@@ -3,6 +3,7 @@ import fs from "fs";
 
 export class TSService {
   private files = new Map<string, { version: number; content: string }>();
+  private fileNames = new Set<string>();
   private service: ts.LanguageService;
 
   constructor(private root: string) {
@@ -40,14 +41,8 @@ export class TSService {
     }
 
     const host: ts.LanguageServiceHost = {
-      getScriptFileNames: () => [
-        ...this.files.keys(),
-        ...ts.sys.readDirectory(
-          this.root,
-          [".ts", ".tsx"],
-          ["node_modules", "dist", ".git"]
-        )
-      ],
+      getScriptFileNames: () => [...this.fileNames],
+
       getScriptVersion: (file) =>
         this.files.get(file)?.version.toString() ?? "0",
 
@@ -87,6 +82,8 @@ export class TSService {
       content,
       version: prev ? prev.version + 1 : 1,
     });
+
+    this.fileNames.add(file);
   }
 
   getProgram() {

package/src/engine/scanner.ts

@@ -1,6 +1,43 @@
 import ts from "typescript";
 import { resolveNodeValue } from "./resolver";
 import { resolveFunctionFromCall } from "./callResolver";
+import { findTrackParamIndex } from "./functionAnalyzer";
+
+function getCallName(expr: ts.Expression): string {
+  if (ts.isIdentifier(expr)) return expr.text;
+
+  if (ts.isPropertyAccessExpression(expr)) {
+    return expr.name.text;
+  }
+
+  return "";
+}
+
+function pickBestArg(
+  args: readonly ts.Expression[],
+  checker: ts.TypeChecker,
+  paramMap: Map<string, ts.Expression>
+) {
+  let best: { score: number; node: ts.Expression } | null = null;
+
+  for (const arg of args) {
+    const res = resolveNodeValue(arg, checker, paramMap);
+
+    if (!res?.values?.length) continue;
+
+    let score = 0;
+
+    if (!res.dynamic) score += 3;
+    if (res.values.every(v => v.length < 50)) score += 2;
+    if (res.values.some(v => v.includes("*"))) score -= 2;
+
+    if (!best || score > best.score) {
+      best = { score, node: arg };
+    }
+  }
+
+  return best?.node;
+}
 
 export function scanSource(
   source: ts.SourceFile,
@@ -9,6 +46,7 @@ export function scanSource(
   depth = 0
 ): Set<string> {
   if (depth > 5) return new Set();
+
   const events = new Set<string>();
 
   if (visited.has(source.fileName)) return events;
@@ -19,11 +57,9 @@ export function scanSource(
       const name = getCallName(node.expression);
 
       if (/(track|event|capture|send)/i.test(name)) {
-
         const fn = resolveFunctionFromCall(node.expression, checker);
 
-        // param mapping
-        let paramMap = new Map<string, ts.Expression>();
+        const paramMap = new Map<string, ts.Expression>();
 
         if (fn && ts.isFunctionLike(fn)) {
           fn.parameters.forEach((param, index) => {
@@ -36,18 +72,37 @@ export function scanSource(
           });
         }
 
-        // cross-file traversal
-        if (fn) {
-          const sf = fn.getSourceFile();
-
-          if (!visited.has(sf.fileName)) {
-            scanSource(sf, checker, visited, depth + 1)
-              .forEach(e => events.add(e));
+        if (fn && ts.isFunctionLike(fn)) {
+          const idx = findTrackParamIndex(fn);
+
+          if (idx !== null) {
+            const realArg = node.arguments[idx];
+
+            if (realArg) {
+              const res = resolveNodeValue(realArg, checker, paramMap);
+
+              res?.values.forEach(v => {
+                if (
+                  v &&
+                  v.length > 1 &&
+                  v.length < 100 &&
+                  !v.includes(" ") &&
+                  /^[a-zA-Z0-9._:-]+$/.test(v)
+                ) {
+                  events.add(v);
+                }
+              });
+
+              return;
+            }
           }
         }
 
-        for (const arg of node.arguments) {
-          const res = resolveNodeValue(arg, checker, paramMap);
+        // fallback (heuristic)
+        const target = pickBestArg(node.arguments, checker, paramMap);
+
+        if (target) {
+          const res = resolveNodeValue(target, checker, paramMap);
 
           res?.values.forEach(v => {
             if (
@@ -71,13 +126,3 @@ export function scanSource(
 
   return events;
 }
-
-function getCallName(expr: ts.Expression): string {
-  if (ts.isIdentifier(expr)) return expr.text;
-
-  if (ts.isPropertyAccessExpression(expr)) {
-    return expr.name.text;
-  }
-
-  return "";
-}