@eventra_dev/eventra-cli 0.1.5 → 0.1.7

package/src/engine/graph.ts

@@ -5,6 +5,7 @@ import fs from "fs";
 export class DependencyGraph {
   private reverse = new Map<string, Set<string>>();
   private exports = new Map<string, Set<string>>();
+  private fileCache = new Map<string, string | null>();
 
   constructor(
     private baseUrl: string,
@@ -15,42 +16,43 @@ export class DependencyGraph {
     return path.resolve(file);
   }
 
-  // TS-like resolver
   private resolveModule(module: string, from: string): string | null {
-    // relative
     if (module.startsWith(".")) {
       const abs = path.resolve(path.dirname(from), module);
       return this.resolveFile(abs);
     }
 
-    // paths mapping
     for (const key in this.paths) {
-      const pattern = key.replace("*", "(.*)");
+      const pattern = key.replace(/\*/g, "(.*)");
       const regex = new RegExp("^" + pattern + "$");
       const match = module.match(regex);
 
       if (!match) continue;
 
-      const wildcard = match[1] || "";
+      const wildcard = match.slice(1);
 
       for (const target of this.paths[key]) {
-        const replaced = target.replace("*", wildcard);
-        const abs = path.resolve(this.baseUrl, replaced);
+        let replaced = target;
+
+        wildcard.forEach(w => {
+          replaced = replaced.replace("*", w);
+        });
 
+        const abs = path.resolve(this.baseUrl, replaced);
         const resolved = this.resolveFile(abs);
         if (resolved) return resolved;
       }
     }
 
-    // baseUrl fallback
     const abs = path.resolve(this.baseUrl, module);
-    const resolved = this.resolveFile(abs);
-    if (resolved) return resolved;
-
-    return null;
+    return this.resolveFile(abs);
   }
 
   private resolveFile(base: string): string | null {
+    if (this.fileCache.has(base)) {
+      return this.fileCache.get(base)!;
+    }
+
     const tryFiles = [
       base,
       base + ".ts",
@@ -64,10 +66,13 @@ export class DependencyGraph {
 
     for (const f of tryFiles) {
       if (fs.existsSync(f)) {
-        return this.normalize(f);
+        const normalized = this.normalize(f);
+        this.fileCache.set(base, normalized);
+        return normalized;
       }
     }
 
+    this.fileCache.set(base, null);
     return null;
   }
 
@@ -77,11 +82,10 @@ export class DependencyGraph {
     this.exports.set(normalizedFile, new Set());
 
     for (const stmt of source.statements) {
-      // IMPORT
       if (ts.isImportDeclaration(stmt)) {
         const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
-
         const resolved = this.resolveModule(module, normalizedFile);
+
         if (!resolved) continue;
 
         if (!this.reverse.has(resolved)) {
@@ -91,18 +95,13 @@ export class DependencyGraph {
         this.reverse.get(resolved)!.add(normalizedFile);
       }
 
-      // EXPORT *
       if (ts.isExportDeclaration(stmt) && stmt.moduleSpecifier) {
         const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
-
         const resolved = this.resolveModule(module, normalizedFile);
-        if (!resolved) continue;
 
-        if (!this.exports.has(normalizedFile)) {
-          this.exports.set(normalizedFile, new Set());
-        }
+        if (!resolved) continue;
 
-        this.exports.get(normalizedFile)!.add(resolved);
+        this.exports.get(normalizedFile)?.add(resolved);
 
         if (!this.reverse.has(resolved)) {
           this.reverse.set(resolved, new Set());
@@ -113,17 +112,43 @@ export class DependencyGraph {
     }
   }
 
-  getDependents(file: string) {
-    return [...(this.reverse.get(this.normalize(file)) ?? [])];
+  getAllDependentsDeep(file: string): string[] {
+    const start = this.normalize(file);
+    const visited = new Set<string>();
+    const result = new Set<string>();
+
+    const walk = (f: string) => {
+      if (visited.has(f)) return;
+      visited.add(f);
+
+      const deps = this.reverse.get(f);
+      deps?.forEach(d => {
+        result.add(d);
+        walk(d);
+      });
+
+      const ex = this.exports.get(f);
+      ex?.forEach(e => walk(e));
+    };
+
+    walk(start);
+
+    return [...result];
   }
 
   remove(file: string) {
     const normalized = this.normalize(file);
 
+    this.reverse.delete(normalized);
     this.exports.delete(normalized);
+    this.fileCache.delete(normalized);
 
     for (const set of this.reverse.values()) {
       set.delete(normalized);
     }
+
+    for (const set of this.exports.values()) {
+      set.delete(normalized);
+    }
   }
 }

package/src/engine/languageService.ts

@@ -52,7 +52,11 @@ export class TSService {
     this.compilerOptions = compilerOptions;
 
     const host: ts.LanguageServiceHost = {
-      getScriptFileNames: () => [...this.fileNames],
+      getScriptFileNames: () => {
+        return [...new Set(this.fileNames)].sort((a, b) =>
+          a.localeCompare(b)
+        );
+      },
 
       getScriptVersion: (file) =>
         this.files.get(file)?.version.toString() ?? "0",

package/src/engine/resolver.ts

@@ -1,4 +1,5 @@
 import ts from "typescript";
+import {resolveExportedSymbol} from "./exportResolver";
 
 export type ResolveResult = {
   values: string[];
@@ -52,6 +53,18 @@ export function resolveNodeValue(
   if (ts.isIdentifier(node)) {
     let symbol = checker.getSymbolAtLocation(node);
     if (!symbol) return null;
+    for (const decl of symbol.getDeclarations() ?? []) {
+      if (ts.isVariableDeclaration(decl) && decl.initializer) {
+        return resolveNodeValue(
+          decl.initializer,
+          checker,
+          paramMap,
+          seen
+        );
+      }
+    }
+
+    symbol = resolveExportedSymbol(symbol, checker) ?? symbol;
 
     if (symbol.flags & ts.SymbolFlags.Alias) {
       symbol = checker.getAliasedSymbol(symbol);

package/src/engine/scanner.ts

@@ -1,120 +1,267 @@
 import ts from "typescript";
 import { resolveNodeValue } from "./resolver";
 import { resolveFunctionFromCall } from "./callResolver";
+import { resolveExportedSymbol } from "./exportResolver";
 import { findTrackParamIndex } from "./functionAnalyzer";
+import { EventraConfig } from "../types";
+
+const TRACKING_NAMES = new Set(["track", "event", "capture", "send"]);
 
 function getCallName(expr: ts.Expression): string {
   if (ts.isIdentifier(expr)) return expr.text;
-
-  if (ts.isPropertyAccessExpression(expr)) {
-    return expr.name.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;
+function getJsxAttrName(name: ts.JsxAttributeName): string | null {
+  if (ts.isIdentifier(name)) return name.text;
+  if (ts.isJsxNamespacedName(name)) return name.name.text;
+  return null;
+}
 
-  for (const arg of args) {
-    const res = resolveNodeValue(arg, checker, paramMap);
+function isValidEvent(v: string) {
+  return (
+    v &&
+    v.length > 1 &&
+    v.length < 100 &&
+    !v.includes(" ") &&
+    /^[a-zA-Z0-9._:-]+$/.test(v)
+  );
+}
 
-    if (!res?.values?.length) continue;
+function isPropUsedInTracking(
+  fn: ts.FunctionLikeDeclaration,
+  prop: string
+) {
+  let found = false;
 
-    let score = 0;
+  function visit(node: ts.Node) {
+    if (ts.isCallExpression(node)) {
+      const name = getCallName(node.expression);
 
-    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 (!TRACKING_NAMES.has(name)) return;
 
-    if (!best || score > best.score) {
-      best = { score, node: arg };
+      for (const arg of node.arguments) {
+        if (
+          (ts.isIdentifier(arg) && arg.text === prop) ||
+          (ts.isPropertyAccessExpression(arg) &&
+            arg.name.text === prop)
+        ) {
+          found = true;
+        }
+      }
     }
+
+    ts.forEachChild(node, visit);
   }
 
-  return best?.node;
+  visit(fn);
+  return found;
 }
 
+export type ScanResult = {
+  events: Set<string>;
+  detectedFunctionWrappers: Set<string>;
+  detectedComponentWrappers: Map<string, string>;
+};
+
 export function scanSource(
   source: ts.SourceFile,
   checker: ts.TypeChecker,
+  config: EventraConfig,
   visited = new Set<string>(),
   depth = 0
-): Set<string> {
-  if (depth > 5) return new Set();
-
+): ScanResult {
   const events = new Set<string>();
+  const detectedFunctionWrappers = new Set<string>();
+  const detectedComponentWrappers = new Map<string, string>();
+
+  if (depth > 5 || visited.has(source.fileName)) {
+    return { events, detectedFunctionWrappers, detectedComponentWrappers };
+  }
 
-  if (visited.has(source.fileName)) return events;
   visited.add(source.fileName);
 
   function visit(node: ts.Node) {
+    // CALL EXPRESSIONS
     if (ts.isCallExpression(node)) {
       const name = getCallName(node.expression);
 
-      if (/(track|event|capture|send)/i.test(name)) {
-        const fn = resolveFunctionFromCall(node.expression, checker);
+      const isKnownWrapper = config.functionWrappers.some(
+        w => w.name === name
+      );
+
+      const fn = resolveFunctionFromCall(node.expression, checker);
+
+      const isAutoWrapper =
+        fn && findTrackParamIndex(fn) !== null;
+
+      const isTracking =
+        isKnownWrapper ||
+        TRACKING_NAMES.has(name) ||
+        isAutoWrapper;
+
+      if (!isTracking) return;
+
+      // AUTO DETECT WRAPPER
+      if (
+        !isKnownWrapper &&
+        fn &&
+        !TRACKING_NAMES.has(name)
+      ) {
+        detectedFunctionWrappers.add(name);
+      }
+
+      const paramMap = new Map<string, ts.Expression>();
+
+      if (fn && ts.isFunctionLike(fn)) {
+        fn.parameters.forEach((param, i) => {
+          const arg = node.arguments[i];
+          if (!arg) return;
+
+          if (ts.isIdentifier(param.name)) {
+            paramMap.set(param.name.text, arg);
+          }
+        });
+      }
+
+      let handled = false;
+
+      if (fn) {
+        const idx = findTrackParamIndex(fn);
+
+        if (idx !== null && node.arguments[idx]) {
+          const res = resolveNodeValue(
+            node.arguments[idx],
+            checker,
+            paramMap
+          );
+
+          res?.values.forEach(v => {
+            if (isValidEvent(v)) events.add(v);
+          });
 
-        const paramMap = new Map<string, ts.Expression>();
+          handled = true;
+        }
+      }
 
-        if (fn && ts.isFunctionLike(fn)) {
-          fn.parameters.forEach((param, index) => {
-            const arg = node.arguments[index];
-            if (!arg) return;
+      // fallback
+      if (!handled) {
+        for (const arg of node.arguments) {
+          const res = resolveNodeValue(arg, checker, paramMap);
 
-            if (ts.isIdentifier(param.name)) {
-              paramMap.set(param.name.text, arg);
-            }
+          res?.values.forEach(v => {
+            if (isValidEvent(v)) events.add(v);
           });
         }
+      }
+
+      // cross-file traversal
+      if (fn) {
+        const sf = fn.getSourceFile();
+
+        if (!visited.has(sf.fileName)) {
+          const res = scanSource(
+            sf,
+            checker,
+            config,
+            visited,
+            depth + 1
+          );
+
+          res.events.forEach(e => events.add(e));
+        }
+      }
+    }
+
+    // JSX COMPONENTS
+    if (
+      ts.isJsxSelfClosingElement(node) ||
+      ts.isJsxOpeningElement(node)
+    ) {
+      const tagNode =
+        ts.isPropertyAccessExpression(node.tagName)
+          ? node.tagName.name
+          : node.tagName;
+
+      let symbol = checker.getSymbolAtLocation(tagNode);
+
+      if (symbol) {
+        const resolved = resolveExportedSymbol(symbol, checker);
+        if (resolved) symbol = resolved;
+      }
+
+      if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
+        const aliased = checker.getAliasedSymbol(symbol);
+        if (aliased) symbol = aliased;
+      }
 
-        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;
-            }
+      if (!symbol) return;
+
+      const tagName =
+        ts.isPropertyAccessExpression(node.tagName)
+          ? node.tagName.name.getText()
+          : node.tagName.getText();
+
+      const declarations = symbol.getDeclarations();
+      if (!declarations) return;
+
+      for (const decl of declarations) {
+        let fn: ts.FunctionLikeDeclaration | null = null;
+
+        if (ts.isFunctionDeclaration(decl)) {
+          fn = decl;
+        }
+
+        if (ts.isVariableDeclaration(decl) && decl.initializer) {
+          const init = decl.initializer;
+
+          if (
+            ts.isArrowFunction(init) ||
+            ts.isFunctionExpression(init)
+          ) {
+            fn = init;
           }
         }
 
-        // fallback (heuristic)
-        const target = pickBestArg(node.arguments, checker, paramMap);
+        if (!fn) continue;
+
+        const param = fn.parameters[0];
+        if (!param) continue;
+
+        if (!ts.isObjectBindingPattern(param.name)) continue;
 
-        if (target) {
-          const res = resolveNodeValue(target, checker, paramMap);
+        for (const el of param.name.elements) {
+          const prop = el.name.getText();
+
+          const isEvent =
+            isPropUsedInTracking(fn, prop) ||
+            config.wrappers.some(
+              w => w.name === tagName && w.prop === prop
+            );
+
+          if (!isEvent) continue;
+
+          const attr = node.attributes.properties.find(p => {
+            if (!ts.isJsxAttribute(p)) return false;
+            return getJsxAttrName(p.name) === prop;
+          }) as ts.JsxAttribute | undefined;
+
+          if (!attr || !attr.initializer) continue;
+
+          const expr = ts.isJsxExpression(attr.initializer)
+            ? attr.initializer.expression
+            : attr.initializer;
+
+          if (!expr) continue;
+
+          const res = resolveNodeValue(expr, checker);
 
           res?.values.forEach(v => {
-            if (
-              v &&
-              v.length > 1 &&
-              v.length < 100 &&
-              !v.includes(" ") &&
-              /^[a-zA-Z0-9._:-]+$/.test(v)
-            ) {
-              events.add(v);
-            }
+            if (isValidEvent(v)) events.add(v);
           });
+
+          detectedComponentWrappers.set(tagName, prop);
         }
       }
     }
@@ -124,5 +271,9 @@ export function scanSource(
 
   visit(source);
 
-  return events;
+  return {
+    events,
+    detectedFunctionWrappers,
+    detectedComponentWrappers,
+  };
 }