@eventra_dev/eventra-cli 0.1.1 → 0.1.2

package/src/engine/resolver.ts

@@ -1,4 +1,4 @@
-import { Node, ts } from "ts-morph";
+import ts from "typescript";
 
 export type ResolveResult = {
   values: string[];
@@ -6,45 +6,78 @@ export type ResolveResult = {
 };
 
 export function resolveNodeValue(
-  node: Node,
+  node: ts.Node,
   checker: ts.TypeChecker
 ): ResolveResult | null {
-  if (!Node.isIdentifier(node)) return null;
 
-  const symbol = checker.getSymbolAtLocation(node.compilerNode);
-  if (!symbol) return null;
+  if (ts.isStringLiteral(node)) {
+    return { values: [node.text], dynamic: false };
+  }
 
-  const decls = symbol.getDeclarations() ?? [];
+  if (ts.isTemplateExpression(node)) {
+    let result = node.head.text;
 
-  for (const d of decls) {
-    if (ts.isVariableDeclaration(d) && d.initializer) {
-      const init = d.initializer;
+    for (const span of node.templateSpans) {
+      result += "*";
+      result += span.literal.text;
+    }
 
-      if (ts.isStringLiteral(init)) {
-        return { values: [init.text], dynamic: false };
-      }
+    return { values: [result], dynamic: true };
+  }
 
-      if (ts.isNoSubstitutionTemplateLiteral(init)) {
-        return { values: [init.text], dynamic: false };
-      }
+  if (ts.isConditionalExpression(node)) {
+    const a = resolveNodeValue(node.whenTrue, checker);
+    const b = resolveNodeValue(node.whenFalse, checker);
 
-      if (ts.isTemplateExpression(init)) {
-        let result = init.head.text;
+    return {
+      values: [...new Set([...(a?.values ?? []), ...(b?.values ?? [])])],
+      dynamic: true,
+    };
+  }
 
-        for (const span of init.templateSpans) {
-          result += "*";
-          result += span.literal.text;
-        }
+  if (ts.isIdentifier(node)) {
+    let symbol = checker.getSymbolAtLocation(node);
+    if (!symbol) return null;
+
+    if (symbol.flags & ts.SymbolFlags.Alias) {
+      symbol = checker.getAliasedSymbol(symbol);
+    }
 
-        return { values: [result], dynamic: true };
+    for (const decl of symbol.getDeclarations() ?? []) {
+      if (ts.isVariableDeclaration(decl) && decl.initializer) {
+        return resolveNodeValue(decl.initializer, checker);
+      }
+
+      if (ts.isEnumMember(decl) && decl.initializer) {
+        if (ts.isStringLiteral(decl.initializer)) {
+          return {
+            values: [decl.initializer.text],
+            dynamic: false,
+          };
+        }
       }
     }
+  }
 
-    if (ts.isParameter(d) && d.initializer) {
-      const init = d.initializer;
+  if (ts.isPropertyAccessExpression(node)) {
+    const symbol = checker.getSymbolAtLocation(node);
 
-      if (ts.isStringLiteral(init)) {
-        return { values: [init.text], dynamic: false };
+    if (symbol) {
+      let s = symbol;
+
+      if (s.flags & ts.SymbolFlags.Alias) {
+        s = checker.getAliasedSymbol(s);
+      }
+
+      for (const decl of s.getDeclarations() ?? []) {
+        if (ts.isEnumMember(decl) && decl.initializer) {
+          if (ts.isStringLiteral(decl.initializer)) {
+            return {
+              values: [decl.initializer.text],
+              dynamic: false,
+            };
+          }
+        }
       }
     }
   }

package/src/engine/scanner.ts

@@ -1,90 +1,61 @@
-import { SourceFile, SyntaxKind, Node, ts } from "ts-morph";
-import { extractEventsFromArgs } from "./extract";
+import ts from "typescript";
+import { resolveNodeValue } from "./resolver";
 import { resolveFunctionFromCall } from "./callResolver";
-import { getForwardedParamIndex } from "./flow";
-
-function getCallName(expr: Node): string {
-  if (Node.isIdentifier(expr)) return expr.getText();
-  if (Node.isPropertyAccessExpression(expr)) return expr.getName();
-  return expr.getText();
-}
-
-function isTrackLike(name: string) {
-  return /(track|trackFeature)/i.test(name);
-}
-
-function pickArg(args: Node[]) {
-  return (
-    args.find(Node.isStringLiteral) ??
-    args.find(Node.isTemplateExpression) ??
-    args.find(Node.isObjectLiteralExpression) ??
-    args[0]
-  );
-}
 
 export function scanSource(
-  source: SourceFile,
-  checker: ts.TypeChecker
+  source: ts.SourceFile,
+  checker: ts.TypeChecker,
+  visited = new Set<string>()
 ) {
   const events = new Set<string>();
 
-  // CALLS
-  for (const call of source.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-    const expr = call.getExpression();
-    const name = getCallName(expr);
+  if (visited.has(source.fileName)) return events;
+  visited.add(source.fileName);
+
+  function visit(node: ts.Node) {
+    if (ts.isCallExpression(node)) {
+      const name = getCallName(node.expression);
 
-    if (!isTrackLike(name)) continue;
+      if (/(track|event|capture|send)/i.test(name)) {
+        let target = node.arguments[0];
 
-    const args = call.getArguments();
-    if (!args.length) continue;
+        const fn = resolveFunctionFromCall(node.expression, checker);
 
-    let target = pickArg(args);
+        // 🔥 cross-file
+        if (fn) {
+          const sf = fn.getSourceFile();
 
-    const fn = resolveFunctionFromCall(expr);
+          if (!visited.has(sf.fileName)) {
+            scanSource(sf, checker, visited).forEach(e => events.add(e));
+          }
+        }
 
-    if (fn) {
-      const index = getForwardedParamIndex(fn);
-      if (index !== null && args[index]) {
-        target = args[index];
+        if (target) {
+          const res = resolveNodeValue(target, checker);
+
+          res?.values.forEach(v => {
+            if (v && v.length > 1 && !v.includes(" ")) {
+              events.add(v);
+            }
+          });
+        }
       }
     }
 
-    extractEventsFromArgs([target], checker).forEach(({ value }) => {
-      if (isValid(value)) events.add(value);
-    });
+    ts.forEachChild(node, visit);
   }
 
-  // JSX
-  const jsx = [
-    ...source.getDescendantsOfKind(SyntaxKind.JsxOpeningElement),
-    ...source.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement),
-  ];
-
-  for (const el of jsx) {
-    for (const attr of el.getAttributes()) {
-      if (!Node.isJsxAttribute(attr)) continue;
+  visit(source);
 
-      const name = attr.getNameNode().getText();
-      if (!/(event|name|action)/i.test(name)) continue;
-
-      const init = attr.getInitializer();
-      if (!init) continue;
-
-      const expr = Node.isJsxExpression(init)
-        ? init.getExpression()
-        : init;
+  return events;
+}
 
-      if (!expr) continue;
+function getCallName(expr: ts.Expression): string {
+  if (ts.isIdentifier(expr)) return expr.text;
 
-      extractEventsFromArgs([expr], checker).forEach(({ value }) => {
-        if (isValid(value)) events.add(value);
-      });
-    }
+  if (ts.isPropertyAccessExpression(expr)) {
+    return expr.name.text;
   }
 
-  return events;
-}
-
-function isValid(v: string) {
-  return !!v && v.length > 1 && !v.includes(" ");
+  return "";
 }

package/src/types.ts

@@ -23,3 +23,8 @@ export type EventraConfig = {
     exclude: string[];
   };
 };
+
+export type ResolveResult = {
+  values: string[];
+  dynamic: boolean;
+};

package/dist/engine/extract.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractEventsFromArgs = extractEventsFromArgs;
-const ts_morph_1 = require("ts-morph");
-const resolver_1 = require("./resolver");
-function extractEventsFromArgs(args, checker) {
-    return args.flatMap(arg => extract(arg, checker));
-}
-function extract(node, checker) {
-    if (ts_morph_1.Node.isStringLiteral(node)) {
-        return [{ value: node.getLiteralText(), dynamic: false }];
-    }
-    if (ts_morph_1.Node.isNoSubstitutionTemplateLiteral(node)) {
-        return [{ value: node.getLiteralText(), dynamic: false }];
-    }
-    if (ts_morph_1.Node.isTemplateExpression(node)) {
-        let result = node.getHead().getLiteralText();
-        for (const span of node.getTemplateSpans()) {
-            result += "*";
-            result += span.getLiteral().getLiteralText();
-        }
-        return [{ value: result, dynamic: true }];
-    }
-    if (ts_morph_1.Node.isObjectLiteralExpression(node)) {
-        return extractObject(node, checker);
-    }
-    const resolved = (0, resolver_1.resolveNodeValue)(node, checker);
-    if (resolved) {
-        return resolved.values.map(v => ({
-            value: v,
-            dynamic: resolved.dynamic,
-        }));
-    }
-    return [];
-}
-function extractObject(obj, checker) {
-    const res = [];
-    for (const prop of obj.getProperties()) {
-        if (!ts_morph_1.Node.isPropertyAssignment(prop))
-            continue;
-        const name = prop.getName();
-        const init = prop.getInitializer();
-        if (!init)
-            continue;
-        if (["event", "name", "action", "type"].includes(name)) {
-            res.push(...extract(init, checker));
-        }
-        if (ts_morph_1.Node.isObjectLiteralExpression(init)) {
-            res.push(...extractObject(init, checker));
-        }
-    }
-    return res;
-}

package/dist/engine/flow.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getForwardedParamIndex = getForwardedParamIndex;
-const ts_morph_1 = require("ts-morph");
-function getBodyNodes(fn) {
-    const body = fn.getBody();
-    if (!body)
-        return [];
-    if (ts_morph_1.Node.isBlock(body))
-        return body.getStatements();
-    return [body];
-}
-function getForwardedParamIndex(fn) {
-    if (!ts_morph_1.Node.isFunctionDeclaration(fn) &&
-        !ts_morph_1.Node.isArrowFunction(fn) &&
-        !ts_morph_1.Node.isFunctionExpression(fn))
-        return null;
-    const f = fn;
-    const params = f.getParameters();
-    for (const node of getBodyNodes(f)) {
-        const calls = node.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
-        for (const call of calls) {
-            const name = call.getExpression().getText();
-            if (!/(track|event|log|analytics|capture|send)/i.test(name))
-                continue;
-            const args = call.getArguments();
-            for (let i = 0; i < args.length; i++) {
-                const arg = args[i];
-                if (ts_morph_1.Node.isIdentifier(arg)) {
-                    const idx = params.findIndex(p => p.getName() === arg.getText());
-                    if (idx !== -1)
-                        return idx;
-                }
-            }
-        }
-    }
-    return null;
-}

package/dist/engine/project.js

@@ -1,74 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProjectGraph = void 0;
-const ts_morph_1 = require("ts-morph");
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-function normalize(file) {
-    return path_1.default.resolve(file);
-}
-function findTsConfig(start) {
-    let dir = path_1.default.dirname(start);
-    while (true) {
-        const file = path_1.default.join(dir, "tsconfig.json");
-        if (fs_1.default.existsSync(file))
-            return file;
-        const parent = path_1.default.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return null;
-}
-function getScriptKind(file) {
-    if (file.endsWith(".tsx"))
-        return ts_morph_1.ts.ScriptKind.TSX;
-    if (file.endsWith(".jsx"))
-        return ts_morph_1.ts.ScriptKind.JSX;
-    if (file.endsWith(".js"))
-        return ts_morph_1.ts.ScriptKind.JS;
-    if (file.endsWith(".vue"))
-        return ts_morph_1.ts.ScriptKind.TSX;
-    return ts_morph_1.ts.ScriptKind.TS;
-}
-class ProjectGraph {
-    project;
-    constructor(entry) {
-        const tsconfig = findTsConfig(entry);
-        this.project = tsconfig
-            ? new ts_morph_1.Project({
-                tsConfigFilePath: tsconfig,
-                skipAddingFilesFromTsConfig: false,
-            })
-            : new ts_morph_1.Project({
-                useInMemoryFileSystem: true,
-                compilerOptions: {
-                    allowJs: true,
-                    jsx: ts_morph_1.ts.JsxEmit.Preserve,
-                    moduleResolution: ts_morph_1.ts.ModuleResolutionKind.NodeJs,
-                    target: ts_morph_1.ts.ScriptTarget.ESNext,
-                },
-            });
-    }
-    getSource(file, content) {
-        const filePath = normalize(file);
-        let source = this.project.getSourceFile(filePath);
-        if (!source) {
-            source = this.project.createSourceFile(filePath, content, {
-                overwrite: true,
-                scriptKind: getScriptKind(filePath),
-            });
-        }
-        else {
-            source.replaceWithText(content);
-        }
-        return source;
-    }
-    getChecker() {
-        return this.project.getTypeChecker().compilerObject;
-    }
-}
-exports.ProjectGraph = ProjectGraph;

package/dist/engine/symbol.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveNodeValue = resolveNodeValue;
-const ts_morph_1 = require("ts-morph");
-function resolveNodeValue(node, checker) {
-    if (ts_morph_1.Node.isIdentifier(node)) {
-        const symbol = checker.getSymbolAtLocation(node.compilerNode);
-        if (!symbol)
-            return null;
-        const decls = symbol.getDeclarations() ?? [];
-        for (const d of decls) {
-            if (ts_morph_1.ts.isVariableDeclaration(d) && d.initializer) {
-                if (ts_morph_1.Node.isStringLiteral(d.initializer)) {
-                    return {
-                        values: [d.initializer.text],
-                        dynamic: false
-                    };
-                }
-            }
-            if (ts_morph_1.ts.isParameter(d) && d.initializer) {
-                if (ts_morph_1.Node.isStringLiteral(d.initializer)) {
-                    return {
-                        values: [d.initializer.text],
-                        dynamic: false
-                    };
-                }
-            }
-        }
-    }
-    return null;
-}

package/src/engine/extract.ts

@@ -1,74 +0,0 @@
-import { Node, ObjectLiteralExpression, ts } from "ts-morph";
-import { resolveNodeValue } from "./resolver";
-
-export type Extracted = {
-  value: string;
-  dynamic: boolean;
-};
-
-export function extractEventsFromArgs(
-  args: Node[],
-  checker: ts.TypeChecker
-): Extracted[] {
-  return args.flatMap(arg => extract(arg, checker));
-}
-
-function extract(node: Node, checker: ts.TypeChecker): Extracted[] {
-  if (Node.isStringLiteral(node)) {
-    return [{ value: node.getLiteralText(), dynamic: false }];
-  }
-
-  if (Node.isNoSubstitutionTemplateLiteral(node)) {
-    return [{ value: node.getLiteralText(), dynamic: false }];
-  }
-
-  if (Node.isTemplateExpression(node)) {
-    let result = node.getHead().getLiteralText();
-
-    for (const span of node.getTemplateSpans()) {
-      result += "*";
-      result += span.getLiteral().getLiteralText();
-    }
-
-    return [{ value: result, dynamic: true }];
-  }
-
-  if (Node.isObjectLiteralExpression(node)) {
-    return extractObject(node, checker);
-  }
-
-  const resolved = resolveNodeValue(node, checker);
-  if (resolved) {
-    return resolved.values.map(v => ({
-      value: v,
-      dynamic: resolved.dynamic,
-    }));
-  }
-
-  return [];
-}
-
-function extractObject(
-  obj: ObjectLiteralExpression,
-  checker: ts.TypeChecker
-): Extracted[] {
-  const res: Extracted[] = [];
-
-  for (const prop of obj.getProperties()) {
-    if (!Node.isPropertyAssignment(prop)) continue;
-
-    const name = prop.getName();
-    const init = prop.getInitializer();
-    if (!init) continue;
-
-    if (["event", "name", "action", "type"].includes(name)) {
-      res.push(...extract(init, checker));
-    }
-
-    if (Node.isObjectLiteralExpression(init)) {
-      res.push(...extractObject(init, checker));
-    }
-  }
-
-  return res;
-}

package/src/engine/flow.ts

@@ -1,54 +0,0 @@
-import {
-  Node,
-  SyntaxKind,
-  FunctionDeclaration,
-  ArrowFunction,
-  FunctionExpression
-} from "ts-morph";
-
-type Fn =
-  | FunctionDeclaration
-  | ArrowFunction
-  | FunctionExpression;
-
-function getBodyNodes(fn: Fn) {
-  const body = fn.getBody();
-  if (!body) return [];
-
-  if (Node.isBlock(body)) return body.getStatements();
-  return [body];
-}
-
-export function getForwardedParamIndex(fn: Node): number | null {
-  if (
-    !Node.isFunctionDeclaration(fn) &&
-    !Node.isArrowFunction(fn) &&
-    !Node.isFunctionExpression(fn)
-  ) return null;
-
-  const f = fn as Fn;
-  const params = f.getParameters();
-
-  for (const node of getBodyNodes(f)) {
-    const calls = node.getDescendantsOfKind(SyntaxKind.CallExpression);
-
-    for (const call of calls) {
-      const name = call.getExpression().getText();
-
-      if (!/(track|event|log|analytics|capture|send)/i.test(name)) continue;
-
-      const args = call.getArguments();
-
-      for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-
-        if (Node.isIdentifier(arg)) {
-          const idx = params.findIndex(p => p.getName() === arg.getText());
-          if (idx !== -1) return idx;
-        }
-      }
-    }
-  }
-
-  return null;
-}

package/src/engine/project.ts

@@ -1,75 +0,0 @@
-import { Project, SourceFile, ts } from "ts-morph";
-import path from "path";
-import fs from "fs";
-
-function normalize(file: string) {
-  return path.resolve(file);
-}
-
-function findTsConfig(start: string): string | null {
-  let dir = path.dirname(start);
-
-  while (true) {
-    const file = path.join(dir, "tsconfig.json");
-    if (fs.existsSync(file)) return file;
-
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-
-    dir = parent;
-  }
-
-  return null;
-}
-
-function getScriptKind(file: string): ts.ScriptKind {
-  if (file.endsWith(".tsx")) return ts.ScriptKind.TSX;
-  if (file.endsWith(".jsx")) return ts.ScriptKind.JSX;
-  if (file.endsWith(".js")) return ts.ScriptKind.JS;
-  if (file.endsWith(".vue")) return ts.ScriptKind.TSX;
-  return ts.ScriptKind.TS;
-}
-
-export class ProjectGraph {
-  private project: Project;
-
-  constructor(entry: string) {
-    const tsconfig = findTsConfig(entry);
-
-    this.project = tsconfig
-      ? new Project({
-        tsConfigFilePath: tsconfig,
-        skipAddingFilesFromTsConfig: false,
-      })
-      : new Project({
-        useInMemoryFileSystem: true,
-        compilerOptions: {
-          allowJs: true,
-          jsx: ts.JsxEmit.Preserve,
-          moduleResolution: ts.ModuleResolutionKind.NodeJs,
-          target: ts.ScriptTarget.ESNext,
-        },
-      });
-  }
-
-  getSource(file: string, content: string): SourceFile {
-    const filePath = normalize(file);
-
-    let source = this.project.getSourceFile(filePath);
-
-    if (!source) {
-      source = this.project.createSourceFile(filePath, content, {
-        overwrite: true,
-        scriptKind: getScriptKind(filePath),
-      });
-    } else {
-      source.replaceWithText(content);
-    }
-
-    return source;
-  }
-
-  getChecker() {
-    return this.project.getTypeChecker().compilerObject;
-  }
-}