@eventra_dev/eventra-cli 0.1.6 → 0.1.8

package/dist/engine/scanner.js

@@ -7,94 +7,179 @@ exports.scanSource = scanSource;
 const typescript_1 = __importDefault(require("typescript"));
 const resolver_1 = require("./resolver");
 const callResolver_1 = require("./callResolver");
+const exportResolver_1 = require("./exportResolver");
 const functionAnalyzer_1 = require("./functionAnalyzer");
+const boundary_1 = require("./boundary");
+const TRACKING_NAMES = new Set(["track", "event", "capture", "send"]);
 function getCallName(expr) {
     if (typescript_1.default.isIdentifier(expr))
         return expr.text;
-    if (typescript_1.default.isPropertyAccessExpression(expr)) {
+    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 };
+function getJsxAttrName(name) {
+    if (typescript_1.default.isIdentifier(name))
+        return name.text;
+    if (typescript_1.default.isJsxNamespacedName(name))
+        return name.name.text;
+    return null;
+}
+function isValidEvent(v) {
+    return (v &&
+        v.length > 1 &&
+        v.length < 100 &&
+        !v.includes(" ") &&
+        /^[a-zA-Z0-9._:-]+$/.test(v));
+}
+function isPropUsedInTracking(fn, prop) {
+    let found = false;
+    function visit(node) {
+        if (typescript_1.default.isCallExpression(node)) {
+            const name = getCallName(node.expression);
+            if (!TRACKING_NAMES.has(name))
+                return;
+            for (const arg of node.arguments) {
+                if ((typescript_1.default.isIdentifier(arg) && arg.text === prop) ||
+                    (typescript_1.default.isPropertyAccessExpression(arg) && arg.name.text === prop)) {
+                    found = true;
+                }
+            }
         }
+        typescript_1.default.forEachChild(node, visit);
     }
-    return best?.node;
+    visit(fn);
+    return found;
 }
-function scanSource(source, checker, visited = new Set(), depth = 0) {
-    if (depth > 5)
-        return new Set();
+function scanSource(source, checker, config, visited = new Set(), depth = 0) {
     const events = new Set();
-    if (visited.has(source.fileName))
-        return events;
+    const detectedFunctionWrappers = new Set();
+    const detectedComponentWrappers = new Map();
+    if (depth > 5 || visited.has(source.fileName)) {
+        return { events, detectedFunctionWrappers, detectedComponentWrappers };
+    }
     visited.add(source.fileName);
     function visit(node) {
+        // CALL EXPRESSIONS
         if (typescript_1.default.isCallExpression(node)) {
             const name = getCallName(node.expression);
-            if (/(track|event|capture|send)/i.test(name)) {
-                const fn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
-                const paramMap = new Map();
-                if (fn && typescript_1.default.isFunctionLike(fn)) {
-                    fn.parameters.forEach((param, index) => {
-                        const arg = node.arguments[index];
-                        if (!arg)
-                            return;
-                        if (typescript_1.default.isIdentifier(param.name)) {
-                            paramMap.set(param.name.text, arg);
-                        }
+            const isKnownWrapper = config.functionWrappers.some(w => w.name === name);
+            const fn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
+            const isAutoWrapper = fn && (0, functionAnalyzer_1.findTrackParamIndex)(fn) !== null;
+            const isTracking = isKnownWrapper ||
+                TRACKING_NAMES.has(name) ||
+                (isAutoWrapper && fn && !(0, boundary_1.isExternalFile)(fn.getSourceFile().fileName));
+            if (!isTracking)
+                return;
+            if (!isKnownWrapper && isAutoWrapper && !TRACKING_NAMES.has(name)) {
+                detectedFunctionWrappers.add(name);
+            }
+            const paramMap = new Map();
+            if (fn && typescript_1.default.isFunctionLike(fn)) {
+                fn.parameters.forEach((param, i) => {
+                    const arg = node.arguments[i];
+                    if (!arg)
+                        return;
+                    if (typescript_1.default.isIdentifier(param.name)) {
+                        paramMap.set(param.name.text, arg);
+                    }
+                });
+            }
+            let handled = false;
+            if (fn) {
+                const idx = (0, functionAnalyzer_1.findTrackParamIndex)(fn);
+                if (idx !== null && node.arguments[idx]) {
+                    const res = (0, resolver_1.resolveNodeValue)(node.arguments[idx], checker, paramMap);
+                    res?.values.forEach(v => {
+                        if (isValidEvent(v))
+                            events.add(v);
                     });
+                    handled = true;
                 }
-                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;
-                        }
+            }
+            if (!handled) {
+                for (const arg of node.arguments) {
+                    const res = (0, resolver_1.resolveNodeValue)(arg, checker, paramMap);
+                    res?.values.forEach(v => {
+                        if (isValidEvent(v))
+                            events.add(v);
+                    });
+                }
+            }
+            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
+        if (typescript_1.default.isJsxSelfClosingElement(node) ||
+            typescript_1.default.isJsxOpeningElement(node)) {
+            const tagNode = typescript_1.default.isPropertyAccessExpression(node.tagName)
+                ? node.tagName.name
+                : node.tagName;
+            let symbol = checker.getSymbolAtLocation(tagNode);
+            if (symbol) {
+                symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
+            }
+            if (symbol && (symbol.flags & typescript_1.default.SymbolFlags.Alias)) {
+                symbol = checker.getAliasedSymbol(symbol);
+            }
+            if (!symbol)
+                return;
+            const tagName = typescript_1.default.isPropertyAccessExpression(node.tagName)
+                ? node.tagName.name.getText()
+                : node.tagName.getText();
+            for (const decl of symbol.getDeclarations() ?? []) {
+                let fn = null;
+                if (typescript_1.default.isFunctionDeclaration(decl))
+                    fn = decl;
+                if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
+                    const init = decl.initializer;
+                    if (typescript_1.default.isArrowFunction(init) || typescript_1.default.isFunctionExpression(init)) {
+                        fn = init;
                     }
                 }
-                // fallback (heuristic)
-                const target = pickBestArg(node.arguments, checker, paramMap);
-                if (target) {
-                    const res = (0, resolver_1.resolveNodeValue)(target, checker, paramMap);
+                if (!fn)
+                    continue;
+                const param = fn.parameters[0];
+                if (!param || !typescript_1.default.isObjectBindingPattern(param.name))
+                    continue;
+                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 (!typescript_1.default.isJsxAttribute(p))
+                            return false;
+                        return getJsxAttrName(p.name) === prop;
+                    });
+                    if (!attr || !attr.initializer)
+                        continue;
+                    const expr = typescript_1.default.isJsxExpression(attr.initializer)
+                        ? attr.initializer.expression
+                        : attr.initializer;
+                    if (!expr)
+                        continue;
+                    const res = (0, resolver_1.resolveNodeValue)(expr, checker);
                     res?.values.forEach(v => {
-                        if (v &&
-                            v.length > 1 &&
-                            v.length < 100 &&
-                            !v.includes(" ") &&
-                            /^[a-zA-Z0-9._:-]+$/.test(v)) {
+                        if (isValidEvent(v))
                             events.add(v);
-                        }
                     });
+                    detectedComponentWrappers.set(tagName, prop);
                 }
             }
         }
         typescript_1.default.forEachChild(node, visit);
     }
     visit(source);
-    return events;
+    return {
+        events,
+        detectedFunctionWrappers,
+        detectedComponentWrappers,
+    };
 }

package/package.json

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

package/src/commands/check.ts

@@ -28,7 +28,7 @@ export async function check({ fix = false }: { fix?: boolean }) {
 
       const { content, virtualFile } = processFile(file, raw);
 
-      engine.scanFile(virtualFile, content);
+      engine.scanFile(virtualFile, content, config);
 
     } catch (err) {
       console.log(chalk.yellow(`Skipped: ${file}`));

package/src/commands/sync.ts

@@ -23,13 +23,24 @@ export async function sync() {
 
   const engine = new EventraEngine(process.cwd());
 
+  const detectedFn = new Set<string>();
+  const detectedCmp = new Map<string, string>();
+
   for (const file of files) {
     try {
       const raw = await fs.readFile(file, "utf-8");
 
       const { content, virtualFile } = processFile(file, raw);
 
-      engine.scanFile(virtualFile, content);
+      const res = engine.scanFile(virtualFile, content, config);
+
+      for (const w of res.detectedFunctionWrappers) {
+        detectedFn.add(w);
+      }
+
+      for (const [k, v] of res.detectedComponentWrappers) {
+        detectedCmp.set(k, v);
+      }
 
     } catch (err) {
       console.log(chalk.yellow(`Skipped: ${file}`));
@@ -40,10 +51,59 @@ export async function sync() {
     }
   }
 
+  // EVENTS
   const events = engine.getAllEvents().sort();
 
-  config.events = events;
+  const mergedEvents = new Set(config.events ?? []);
+  events.forEach(e => mergedEvents.add(e));
+
+  config.events = [...mergedEvents].sort();
+
+  // FUNCTION WRAPPERS
+  config.functionWrappers = mergeUnique(
+    config.functionWrappers ?? [],
+    [...detectedFn].map(name => ({ name })),
+    w => w.name
+  );
+
+  // COMPONENT WRAPPERS
+  config.wrappers = mergeUnique(
+    config.wrappers ?? [],
+    [...detectedCmp.entries()].map(([name, prop]) => ({
+      name,
+      prop,
+    })),
+    w => `${w.name}:${w.prop}`
+  );
+
   await saveConfig(config);
 
   console.log(chalk.green(`Found ${events.length} events`));
+
+  if (detectedFn.size) {
+    console.log(chalk.blue("\nDetected function wrappers:"));
+    detectedFn.forEach(w => console.log(chalk.gray(`• ${w}`)));
+  }
+
+  if (detectedCmp.size) {
+    console.log(chalk.blue("\nDetected component wrappers:"));
+    detectedCmp.forEach((prop, name) =>
+      console.log(chalk.gray(`• ${name} (${prop})`))
+    );
+  }
+}
+
+// HELPERS
+function mergeUnique<T>(
+  a: T[],
+  b: T[],
+  key: (v: T) => string
+): T[] {
+  const map = new Map<string, T>();
+
+  [...b, ...a].forEach(item => {
+    map.set(key(item), item);
+  });
+
+  return [...map.values()];
 }

package/src/commands/watch.ts

@@ -25,7 +25,7 @@ export async function watch() {
 
       const { content, virtualFile } = processFile(file, raw);
 
-      engine.scanFile(virtualFile, content);
+      engine.scanFile(virtualFile, content, config);
 
     } catch {
       console.log(chalk.gray(`skip: ${file}`));
@@ -56,7 +56,7 @@ export async function watch() {
 
         const { content, virtualFile } = processFile(file, raw);
 
-        engine.updateFile(virtualFile, content);
+        engine.updateFile(virtualFile, content, config);
 
       } catch {
         console.log(chalk.gray(`skip: ${file}`));

package/src/engine/boundary.ts

@@ -0,0 +1,12 @@
+import path from "path";
+
+export function isExternalFile(file: string) {
+  const normalized = path.resolve(file);
+
+  return (
+    normalized.includes(`${path.sep}node_modules${path.sep}`) ||
+    normalized.includes(`${path.sep}dist${path.sep}`) ||
+    normalized.includes(`${path.sep}build${path.sep}`) ||
+    normalized.endsWith(".d.ts")
+  );
+}

package/src/engine/callResolver.ts

@@ -1,25 +1,95 @@
 import ts from "typescript";
 
+function isFunctionLike(
+  node: ts.Node
+): node is ts.FunctionLikeDeclaration {
+  return (
+    ts.isFunctionDeclaration(node) ||
+    ts.isMethodDeclaration(node) ||
+    ts.isConstructorDeclaration(node) ||
+    ts.isFunctionExpression(node) ||
+    ts.isArrowFunction(node)
+  );
+}
+
+function resolveFromSymbol(
+  symbol: ts.Symbol,
+  checker: ts.TypeChecker,
+  visited = new Set<ts.Symbol>(),
+  depth = 0
+): ts.FunctionLikeDeclaration | null {
+  if (visited.has(symbol)) return null;
+  if (depth > 5) return null;
+
+  visited.add(symbol);
+
+  // unwrap alias
+  if (symbol.flags & ts.SymbolFlags.Alias) {
+    const aliased = checker.getAliasedSymbol(symbol);
+    return resolveFromSymbol(aliased, checker, visited, depth + 1);
+  }
+
+  const decls = symbol.getDeclarations() ?? [];
+
+  for (const decl of decls) {
+    if (isFunctionLike(decl)) {
+      return decl;
+    }
+
+    // MethodSignature
+    if (ts.isMethodSignature(decl)) {
+      const parent = decl.parent;
+
+      if (ts.isInterfaceDeclaration(parent) || ts.isTypeLiteralNode(parent)) {
+        const name = decl.name.getText();
+
+        const type = checker.getTypeAtLocation(parent);
+        const props = type.getProperties();
+
+        for (const prop of props) {
+          if (prop.name !== name) continue;
+
+          const resolved = resolveFromSymbol(prop, checker, visited, depth + 1);
+          if (resolved) return resolved;
+        }
+      }
+    }
+
+    // SAFE fallback
+    const s = checker.getSymbolAtLocation(decl);
+    if (s && s !== symbol) {
+      const resolved = resolveFromSymbol(s, checker, visited, depth + 1);
+      if (resolved) return resolved;
+    }
+  }
+
+  return null;
+}
+
 export function resolveFunctionFromCall(
   expr: ts.Expression,
   checker: ts.TypeChecker
 ): ts.FunctionLikeDeclaration | null {
-
   const type = checker.getTypeAtLocation(expr);
   const signatures = type.getCallSignatures();
 
   for (const sig of signatures) {
     const decl = sig.getDeclaration();
+    if (!decl) continue;
 
-    if (
-      decl &&
-      (ts.isFunctionDeclaration(decl) ||
-        ts.isMethodDeclaration(decl) ||
-        ts.isFunctionExpression(decl) ||
-        ts.isArrowFunction(decl))
-    ) {
+    if (isFunctionLike(decl)) {
       return decl;
     }
+
+    // interface method
+    if (ts.isMethodSignature(decl)) {
+      const symbol = checker.getSymbolAtLocation(decl.name);
+
+      if (symbol) {
+        const resolved = resolveFromSymbol(symbol, checker);
+        if (resolved) return resolved;
+      }
+    }
   }
 
   return null;

package/src/engine/engine.ts

@@ -1,13 +1,15 @@
 import { TSService } from "./languageService";
-import { scanSource } from "./scanner";
+import { ScanResult, scanSource } from "./scanner";
 import { DependencyGraph } from "./graph";
 import { hash } from "./hash";
+import { EventraConfig } from "../types";
+import { isExternalFile } from "./boundary";
 
 export class EventraEngine {
   private ts: TSService;
   private graph: DependencyGraph;
 
-  private fileEvents = new Map<string, Set<string>>();
+  private fileResults = new Map<string, ScanResult>();
   private fileHash = new Map<string, string>();
 
   constructor(root: string) {
@@ -17,65 +19,136 @@ export class EventraEngine {
     this.graph = new DependencyGraph(baseUrl, paths);
   }
 
-  scanFile(file: string, content: string) {
+  // SCAN FILE
+  scanFile(
+    file: string,
+    content: string,
+    config: EventraConfig
+  ): ScanResult {
     const h = hash(content);
 
-    // cache
+    // skip unchanged
     if (this.fileHash.get(file) === h) {
-      return this.fileEvents.get(file) ?? new Set();
+      return (
+        this.fileResults.get(file) ?? {
+          events: new Set(),
+          detectedFunctionWrappers: new Set(),
+          detectedComponentWrappers: new Map(),
+        }
+      );
     }
 
     this.fileHash.set(file, h);
-
     this.ts.updateFile(file, content);
 
     const source = this.ts.getSourceFile(file);
     const checker = this.ts.getChecker();
 
-    if (!source || !checker) return new Set();
+    if (!source || !checker) {
+      return {
+        events: new Set(),
+        detectedFunctionWrappers: new Set(),
+        detectedComponentWrappers: new Map(),
+      };
+    }
 
-    // обновляем graph
+    // update dependency graph
     this.graph.update(file, source);
 
-    const events = scanSource(source, checker);
+    const res = scanSource(source, checker, config);
 
-    this.fileEvents.set(file, events);
+    this.fileResults.set(file, res);
 
-    return events;
+    return res;
   }
 
-  updateFile(file: string, content: string) {
-    const events = this.scanFile(file, content);
+  // UPDATE FILE (incremental)
+  updateFile(
+    file: string,
+    content: string,
+    config: EventraConfig
+  ) {
+    const res = this.scanFile(file, content, config);
 
-    const dependents = this.graph.getDependents(file);
+    const dependents = this.graph.getAllDependentsDeep(file);
 
     for (const dep of dependents) {
+      // skip external files
+      if (isExternalFile(dep)) continue;
+
       const source = this.ts.getSourceFile(dep);
       const checker = this.ts.getChecker();
 
       if (!source || !checker) continue;
 
-      const ev = scanSource(source, checker);
+      const depContent = this.ts.getFileContent(dep);
+      if (!depContent) continue;
+
+      const h = hash(depContent);
+
+      // skip unchanged dependents
+      if (this.fileHash.get(dep) === h) continue;
+
+      this.fileHash.set(dep, h);
 
-      this.fileEvents.set(dep, ev);
+      this.graph.update(dep, source);
+
+      const r = scanSource(source, checker, config);
+      this.fileResults.set(dep, r);
     }
 
-    return events;
+    return res;
   }
 
+  // GET ALL EVENTS
   getAllEvents() {
     const all = new Set<string>();
 
-    for (const set of this.fileEvents.values()) {
-      set.forEach(e => all.add(e));
+    for (const r of this.fileResults.values()) {
+      r.events.forEach(e => all.add(e));
     }
 
     return [...all];
   }
 
-  removeFile(file: string) {
-    this.fileEvents.delete(file);
+  // REMOVE FILE
+  removeFile(file: string, config?: EventraConfig) {
+    this.ts.removeFile(file);
+    this.fileResults.delete(file);
     this.fileHash.delete(file);
     this.graph.remove(file);
+    const dependents = this.graph.getAllDependentsDeep(file);
+
+    for (const dep of dependents) {
+      if (isExternalFile(dep)) continue;
+
+      const source = this.ts.getSourceFile(dep);
+      const checker = this.ts.getChecker();
+
+      if (!source || !checker) continue;
+
+      const content = this.ts.getFileContent(dep);
+      if (!content) continue;
+
+      const h = hash(content);
+
+      // skip unchanged
+      if (this.fileHash.get(dep) === h) continue;
+
+      this.fileHash.set(dep, h);
+
+      const r = scanSource(
+        source,
+        checker,
+        config ?? {
+          events: [],
+          wrappers: [],
+          functionWrappers: [],
+          sync: { include: [], exclude: [] },
+        }
+      );
+
+      this.fileResults.set(dep, r);
+    }
   }
 }