@eventra_dev/eventra-cli 0.1.6 → 0.1.7

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,
+  };
 }