@eventra_dev/eventra-cli 0.1.1 → 0.1.3

package/src/engine/engine.ts

@@ -1,26 +1,57 @@
-import { ProjectGraph } from "./project";
+import { TSService } from "./languageService";
 import { scanSource } from "./scanner";
+import { DependencyGraph } from "./graph";
+import { hash } from "./hash";
 
 export class EventraEngine {
-  private project: ProjectGraph;
+  private ts: TSService;
+  private graph = new DependencyGraph();
+
   private fileEvents = new Map<string, Set<string>>();
+  private fileHash = new Map<string, string>();
 
-  constructor(entry: string) {
-    this.project = new ProjectGraph(entry);
+  constructor(root: string) {
+    this.ts = new TSService(root);
   }
 
   scanFile(file: string, content: string) {
-    const source = this.project.getSource(file, content);
-    const checker = this.project.getChecker();
+    const h = hash(content);
+
+    if (this.fileHash.get(file) === h) {
+      return this.fileEvents.get(file) ?? new Set();
+    }
+
+    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();
+
+    this.graph.update(file, source);
     const events = scanSource(source, checker);
 
     this.fileEvents.set(file, events);
+
     return events;
   }
 
   updateFile(file: string, content: string) {
-    return this.scanFile(file, content);
+    const events = this.scanFile(file, content);
+    const dependents = this.graph.getDependents(file);
+
+    for (const dep of dependents) {
+      const source = this.ts.getSourceFile(dep);
+      const checker = this.ts.getChecker();
+
+      if (!source || !checker) continue;
+
+      const ev = scanSource(source, checker);
+      this.fileEvents.set(dep, ev);
+    }
+
+    return events;
   }
 
   getAllEvents() {
@@ -35,5 +66,7 @@ export class EventraEngine {
 
   removeFile(file: string) {
     this.fileEvents.delete(file);
+    this.fileHash.delete(file);
+    this.graph.remove(file);
   }
 }

package/src/engine/graph.ts

@@ -1,23 +1,70 @@
-import { SourceFile } from "ts-morph";
+import ts from "typescript";
+import path from "path";
+import fs from "fs";
 
 export class DependencyGraph {
   private reverse = new Map<string, Set<string>>();
 
-  update(file: string, source: SourceFile) {
-    const imports = source
-      .getImportDeclarations()
-      .map(i => i.getModuleSpecifierSourceFile()?.getFilePath())
-      .filter(Boolean) as string[];
+  private normalize(file: string) {
+    return path.resolve(file);
+  }
+
+  private resolveImport(from: string, module: string): string | null {
+    if (!module.startsWith(".")) return null;
+
+    const base = path.resolve(path.dirname(from), module);
 
-    for (const dep of imports) {
-      if (!this.reverse.has(dep)) {
-        this.reverse.set(dep, new Set());
+    const tryFiles = [
+      base,
+      base + ".ts",
+      base + ".tsx",
+      base + ".js",
+      base + ".jsx",
+      path.join(base, "index.ts"),
+      path.join(base, "index.tsx"),
+      path.join(base, "index.js"),
+    ];
+
+    for (const f of tryFiles) {
+      if (fs.existsSync(f)) {
+        return this.normalize(f);
       }
-      this.reverse.get(dep)!.add(file);
+    }
+
+    return this.normalize(base);
+  }
+
+  update(file: string, source: ts.SourceFile) {
+    const normalizedFile = this.normalize(file);
+
+    for (const stmt of source.statements) {
+      if (!ts.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());
+      }
+
+      this.reverse.get(resolved)!.add(normalizedFile);
     }
   }
 
   getDependents(file: string) {
-    return [...(this.reverse.get(file) ?? [])];
+    return [...(this.reverse.get(this.normalize(file)) ?? [])];
+  }
+
+  remove(file: string) {
+    const normalized = this.normalize(file);
+
+    for (const set of this.reverse.values()) {
+      set.delete(normalized);
+    }
   }
 }

package/src/engine/hash.ts

@@ -0,0 +1,5 @@
+import crypto from "crypto";
+
+export function hash(content: string) {
+  return crypto.createHash("md5").update(content).digest("hex");
+}

package/src/engine/languageService.ts

@@ -0,0 +1,103 @@
+import ts from "typescript";
+import fs from "fs";
+
+export class TSService {
+  private files = new Map<string, { version: number; content: string }>();
+  private service: ts.LanguageService;
+
+  constructor(private root: string) {
+    const configPath = ts.findConfigFile(
+      root,
+      ts.sys.fileExists,
+      "tsconfig.json"
+    );
+
+    let compilerOptions: ts.CompilerOptions = {
+      allowJs: true,
+      jsx: ts.JsxEmit.Preserve,
+      moduleResolution: ts.ModuleResolutionKind.Node16,
+      target: ts.ScriptTarget.ESNext,
+      esModuleInterop: true,
+      allowSyntheticDefaultImports: true,
+    };
+
+    if (configPath) {
+      const configFile = ts.readConfigFile(
+        configPath,
+        ts.sys.readFile
+      );
+
+      const parsed = ts.parseJsonConfigFileContent(
+        configFile.config,
+        ts.sys,
+        root
+      );
+
+      compilerOptions = {
+        ...compilerOptions,
+        ...parsed.options,
+      };
+    }
+
+    const host: ts.LanguageServiceHost = {
+      getScriptFileNames: () => [
+        ...this.files.keys(),
+        ...ts.sys.readDirectory(
+          this.root,
+          [".ts", ".tsx"],
+          ["node_modules", "dist", ".git"]
+        )
+      ],
+      getScriptVersion: (file) =>
+        this.files.get(file)?.version.toString() ?? "0",
+
+      getScriptSnapshot: (file) => {
+        const f = this.files.get(file);
+
+        if (f) {
+          return ts.ScriptSnapshot.fromString(f.content);
+        }
+
+        if (fs.existsSync(file)) {
+          return ts.ScriptSnapshot.fromString(
+            fs.readFileSync(file, "utf-8")
+          );
+        }
+
+        return undefined;
+      },
+
+      getCurrentDirectory: () => this.root,
+      getCompilationSettings: () => compilerOptions,
+      getDefaultLibFileName: (opts) =>
+        ts.getDefaultLibFilePath(opts),
+
+      readFile: ts.sys.readFile,
+      fileExists: ts.sys.fileExists,
+      readDirectory: ts.sys.readDirectory,
+    };
+
+    this.service = ts.createLanguageService(host);
+  }
+
+  updateFile(file: string, content: string) {
+    const prev = this.files.get(file);
+
+    this.files.set(file, {
+      content,
+      version: prev ? prev.version + 1 : 1,
+    });
+  }
+
+  getProgram() {
+    return this.service.getProgram();
+  }
+
+  getChecker() {
+    return this.getProgram()?.getTypeChecker();
+  }
+
+  getSourceFile(file: string) {
+    return this.getProgram()?.getSourceFile(file);
+  }
+}

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,125 @@ export type ResolveResult = {
 };
 
 export function resolveNodeValue(
-  node: Node,
-  checker: ts.TypeChecker
+  node: ts.Node,
+  checker: ts.TypeChecker,
+  paramMap?: Map<string, ts.Expression>,
+  seen = new Set<ts.Node>()
 ): ResolveResult | null {
-  if (!Node.isIdentifier(node)) return null;
 
-  const symbol = checker.getSymbolAtLocation(node.compilerNode);
-  if (!symbol) return null;
+  if (seen.has(node)) return null;
+  seen.add(node);
 
-  const decls = symbol.getDeclarations() ?? [];
+  // param mapping
+  if (ts.isIdentifier(node) && paramMap?.has(node.text)) {
+    return resolveNodeValue(
+      paramMap.get(node.text)!,
+      checker,
+      paramMap
+    );
+  }
+
+  if (ts.isStringLiteral(node)) {
+    return { values: [node.text], dynamic: false };
+  }
+
+  if (ts.isTemplateExpression(node)) {
+    let result = node.head.text;
+
+    for (const span of node.templateSpans) {
+      result += "*";
+      result += span.literal.text;
+    }
+
+    return { values: [result], dynamic: true };
+  }
+
+  if (ts.isConditionalExpression(node)) {
+    const a = resolveNodeValue(node.whenTrue, checker, paramMap, seen);
+    const b = resolveNodeValue(node.whenFalse, checker, paramMap, seen);
+
+    return {
+      values: [...new Set([...(a?.values ?? []), ...(b?.values ?? [])])],
+      dynamic: true,
+    };
+  }
 
-  for (const d of decls) {
-    if (ts.isVariableDeclaration(d) && d.initializer) {
-      const init = d.initializer;
+  if (ts.isIdentifier(node)) {
+    let symbol = checker.getSymbolAtLocation(node);
+    if (!symbol) return null;
 
-      if (ts.isStringLiteral(init)) {
-        return { values: [init.text], dynamic: false };
+    if (symbol.flags & ts.SymbolFlags.Alias) {
+      symbol = checker.getAliasedSymbol(symbol);
+    }
+
+    for (const decl of symbol.getDeclarations() ?? []) {
+      if (ts.isVariableDeclaration(decl) && decl.initializer) {
+        return resolveNodeValue(decl.initializer, checker, paramMap, seen);
       }
 
-      if (ts.isNoSubstitutionTemplateLiteral(init)) {
-        return { values: [init.text], dynamic: false };
+      if (ts.isEnumMember(decl) && decl.initializer) {
+        if (ts.isStringLiteral(decl.initializer)) {
+          return {
+            values: [decl.initializer.text],
+            dynamic: false,
+          };
+        }
       }
+    }
+  }
 
-      if (ts.isTemplateExpression(init)) {
-        let result = init.head.text;
+  if (ts.isPropertyAccessExpression(node)) {
+    const symbol = checker.getSymbolAtLocation(node);
 
-        for (const span of init.templateSpans) {
-          result += "*";
-          result += span.literal.text;
+    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,
+            };
+          }
         }
+      }
+    }
+  }
+
+  if (ts.isObjectLiteralExpression(node)) {
+    const values: string[] = [];
+
+    for (const prop of node.properties) {
+      if (!ts.isPropertyAssignment(prop)) continue;
 
-        return { values: [result], dynamic: true };
+      const name = prop.name.getText();
+
+      if (name === "event") {
+        const res = resolveNodeValue(prop.initializer, checker, paramMap, seen);
+        if (res) values.push(...res.values);
       }
     }
 
-    if (ts.isParameter(d) && d.initializer) {
-      const init = d.initializer;
+    return { values, dynamic: true };
+  }
+
+  if (ts.isBinaryExpression(node)) {
+    if (node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+      const left = resolveNodeValue(node.left, checker, paramMap, seen);
+      const right = resolveNodeValue(node.right, checker, paramMap, seen);
 
-      if (ts.isStringLiteral(init)) {
-        return { values: [init.text], dynamic: false };
+      if (left && right) {
+        return {
+          values: left.values.flatMap(l =>
+            right.values.map(r => l + r)
+          ),
+          dynamic: true,
+        };
       }
     }
   }

package/src/engine/scanner.ts

@@ -1,90 +1,83 @@
-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>(),
+  depth = 0
+): Set<string> {
+  if (depth > 5) return new Set();
   const events = new Set<string>();
 
-  // CALLS
-  for (const call of source.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-    const expr = call.getExpression();
-    const name = getCallName(expr);
-
-    if (!isTrackLike(name)) continue;
-
-    const args = call.getArguments();
-    if (!args.length) continue;
-
-    let target = pickArg(args);
-
-    const fn = resolveFunctionFromCall(expr);
-
-    if (fn) {
-      const index = getForwardedParamIndex(fn);
-      if (index !== null && args[index]) {
-        target = args[index];
+  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 (/(track|event|capture|send)/i.test(name)) {
+
+        const fn = resolveFunctionFromCall(node.expression, checker);
+
+        // param mapping
+        let paramMap = new Map<string, ts.Expression>();
+
+        if (fn && ts.isFunctionLike(fn)) {
+          fn.parameters.forEach((param, index) => {
+            const arg = node.arguments[index];
+            if (!arg) return;
+
+            if (ts.isIdentifier(param.name)) {
+              paramMap.set(param.name.text, arg);
+            }
+          });
+        }
+
+        // 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));
+          }
+        }
+
+        for (const arg of node.arguments) {
+          const res = resolveNodeValue(arg, 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);
+            }
+          });
+        }
       }
     }
 
-    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;
-
-      const name = attr.getNameNode().getText();
-      if (!/(event|name|action)/i.test(name)) continue;
+  visit(source);
 
-      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/src/utils/config.ts

@@ -12,8 +12,7 @@ export function normalizeConfig(
     events: config.events ?? [],
     endpoint: config.endpoint ?? "",
     wrappers: config.wrappers ?? [],
-    functionWrappers:
-      config.functionWrappers ?? [],
+    functionWrappers: config.functionWrappers ?? [],
     aliases: config.aliases ?? {},
     sync: config.sync ?? {
       include: [
@@ -30,43 +29,26 @@ export function normalizeConfig(
 }
 
 export async function loadConfig(): Promise<EventraConfig | null> {
-  const configPath = path.join(
-    process.cwd(),
-    CONFIG_NAME
-  );
+  const configPath = path.join(process.cwd(), CONFIG_NAME);
 
-  if (
-    !(await fs.pathExists(
-      configPath
-    ))
-  ) {
+  if (!(await fs.pathExists(configPath))) {
     return null;
   }
 
-  const config =
-    await fs.readJSON(
-      configPath
-    );
-
-  return normalizeConfig(config);
+  try {
+    const config = await fs.readJSON(configPath);
+    return normalizeConfig(config);
+  } catch {
+    return null;
+  }
 }
 
-export async function saveConfig(
-  config: EventraConfig
-) {
-  const configPath = path.join(
-    process.cwd(),
-    CONFIG_NAME
-  );
+export async function saveConfig(config: EventraConfig) {
+  const configPath = path.join(process.cwd(), CONFIG_NAME);
 
-  const normalized =
-    normalizeConfig(config);
+  const normalized = normalizeConfig(config);
 
-  await fs.writeJSON(
-    configPath,
-    normalized,
-    {
-      spaces: 2
-    }
-  );
+  await fs.writeJSON(configPath, normalized, {
+    spaces: 2
+  });
 }

package/src/utils/parsers/astro.ts

@@ -1,5 +1,12 @@
-export function parseAstro(
-  content: string
-) {
-  return content;
+export function parseAstro(content: string) {
+  const frontmatter = content.match(/---([\s\S]*?)---/);
+
+  const scripts = [
+    ...content.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/g)
+  ];
+
+  return [
+    frontmatter?.[1] ?? "",
+    ...scripts.map(s => s[1])
+  ].join("\n");
 }

package/src/utils/parsers/router.ts

@@ -1,14 +1,9 @@
-export function detectParser(
-  file: string
-) {
-  if (file.endsWith(".vue"))
-    return "vue";
+export function detectParser(file: string) {
+  file = file.toLowerCase();
 
-  if (file.endsWith(".svelte"))
-    return "svelte";
-
-  if (file.endsWith(".astro"))
-    return "astro";
+  if (file.endsWith(".vue")) return "vue";
+  if (file.endsWith(".svelte")) return "svelte";
+  if (file.endsWith(".astro")) return "astro";
 
   return "ts";
 }