@eventra_dev/eventra-cli 0.0.19 → 0.1.1

package/src/engine/graph.ts

@@ -0,0 +1,23 @@
+import { SourceFile } from "ts-morph";
+
+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[];
+
+    for (const dep of imports) {
+      if (!this.reverse.has(dep)) {
+        this.reverse.set(dep, new Set());
+      }
+      this.reverse.get(dep)!.add(file);
+    }
+  }
+
+  getDependents(file: string) {
+    return [...(this.reverse.get(file) ?? [])];
+  }
+}

package/src/engine/project.ts

@@ -0,0 +1,75 @@
+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;
+  }
+}

package/src/engine/resolver.ts

@@ -0,0 +1,53 @@
+import { Node, ts } from "ts-morph";
+
+export type ResolveResult = {
+  values: string[];
+  dynamic: boolean;
+};
+
+export function resolveNodeValue(
+  node: Node,
+  checker: ts.TypeChecker
+): ResolveResult | null {
+  if (!Node.isIdentifier(node)) return null;
+
+  const symbol = checker.getSymbolAtLocation(node.compilerNode);
+  if (!symbol) return null;
+
+  const decls = symbol.getDeclarations() ?? [];
+
+  for (const d of decls) {
+    if (ts.isVariableDeclaration(d) && d.initializer) {
+      const init = d.initializer;
+
+      if (ts.isStringLiteral(init)) {
+        return { values: [init.text], dynamic: false };
+      }
+
+      if (ts.isNoSubstitutionTemplateLiteral(init)) {
+        return { values: [init.text], dynamic: false };
+      }
+
+      if (ts.isTemplateExpression(init)) {
+        let result = init.head.text;
+
+        for (const span of init.templateSpans) {
+          result += "*";
+          result += span.literal.text;
+        }
+
+        return { values: [result], dynamic: true };
+      }
+    }
+
+    if (ts.isParameter(d) && d.initializer) {
+      const init = d.initializer;
+
+      if (ts.isStringLiteral(init)) {
+        return { values: [init.text], dynamic: false };
+      }
+    }
+  }
+
+  return null;
+}

package/src/engine/scanner.ts

@@ -0,0 +1,90 @@
+import { SourceFile, SyntaxKind, Node, ts } from "ts-morph";
+import { extractEventsFromArgs } from "./extract";
+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
+) {
+  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];
+      }
+    }
+
+    extractEventsFromArgs([target], checker).forEach(({ value }) => {
+      if (isValid(value)) events.add(value);
+    });
+  }
+
+  // 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;
+
+      const init = attr.getInitializer();
+      if (!init) continue;
+
+      const expr = Node.isJsxExpression(init)
+        ? init.getExpression()
+        : init;
+
+      if (!expr) continue;
+
+      extractEventsFromArgs([expr], checker).forEach(({ value }) => {
+        if (isValid(value)) events.add(value);
+      });
+    }
+  }
+
+  return events;
+}
+
+function isValid(v: string) {
+  return !!v && v.length > 1 && !v.includes(" ");
+}

package/src/engine/symbol.ts

@@ -0,0 +1,42 @@
+import { Node, ts } from "ts-morph";
+
+export type ResolveResult = {
+  values: string[];
+  dynamic: boolean;
+};
+
+export function resolveNodeValue(
+  node: Node,
+  checker: ts.TypeChecker
+): ResolveResult | null {
+
+  if (Node.isIdentifier(node)) {
+    const symbol = checker.getSymbolAtLocation(node.compilerNode);
+    if (!symbol) return null;
+
+    const decls = symbol.getDeclarations() ?? [];
+
+    for (const d of decls) {
+
+      if (ts.isVariableDeclaration(d) && d.initializer) {
+        if (Node.isStringLiteral(d.initializer as any)) {
+          return {
+            values: [(d.initializer as any).text],
+            dynamic: false
+          };
+        }
+      }
+
+      if (ts.isParameter(d) && d.initializer) {
+        if (Node.isStringLiteral(d.initializer as any)) {
+          return {
+            values: [(d.initializer as any).text],
+            dynamic: false
+          };
+        }
+      }
+    }
+  }
+
+  return null;
+}

package/src/types.ts

@@ -1,3 +1,5 @@
+export type ScanMode = "strict" | "hybrid" | "discovery";
+
 export type ComponentWrapper = {
   name: string;
   prop: string;
@@ -6,14 +8,13 @@ export type ComponentWrapper = {
 export type FunctionWrapper = {
   name: string;
   event?: string;
-  file?: string;
-  line?: number;
 };
 
 export type EventraConfig = {
   apiKey?: string;
   endpoint?: string;
   events: string[];
+  mode?: ScanMode;
   wrappers: ComponentWrapper[];
   functionWrappers: FunctionWrapper[];
   aliases?: Record<string, string>;
@@ -22,10 +23,3 @@ export type EventraConfig = {
     exclude: string[];
   };
 };
-
-export type ExtractedEvent = {
-  value: string;
-  dynamic: boolean;
-  file?: string;
-  line?: number;
-};

package/src/utils/parsers/vue.ts

@@ -1,25 +1,24 @@
-export function parseVue(
-  content: string
-) {
-  const template =
-    content.match(
-      /<template[\s\S]*?>([\s\S]*?)<\/template>/
-    );
+export function parseVue(content: string) {
+  const scriptMatch = content.match(/<script[\s\S]*?>([\s\S]*?)<\/script>/);
+  const templateMatch = content.match(/<template>([\s\S]*?)<\/template>/);
 
-  const script =
-    content.match(
-      /<script[\s\S]*?>([\s\S]*?)<\/script>/
-    );
+  const script = scriptMatch?.[1] ?? "";
+  let template = templateMatch?.[1] ?? "";
 
-  return `
-${script?.[1] ?? ""}
+  template = template.replace(/<!--[\s\S]*?-->/g, "");
 
-function __vue_template__() {
-  return (
-    <>
-      ${template?.[1] ?? ""}
-    </>
-  );
-}
+  template = template
+    .replace(/v-if="[^"]+"/g, "")
+    .replace(/v-for="[^"]+"/g, "")
+    .replace(/@click=/g, "onClick=");
+
+  const jsx = `
+const __VUE_JSX__ = (
+  <>
+    ${template}
+  </>
+);
 `;
+
+  return script + "\n" + jsx;
 }

package/src/utils/processFile.ts

@@ -0,0 +1,18 @@
+import { detectParser } from "./parsers/router";
+import { parseVue } from "./parsers/vue";
+import { parseSvelte } from "./parsers/svelte";
+import { parseAstro } from "./parsers/astro";
+
+export function processFile(file: string, content: string) {
+  const parser = detectParser(file);
+
+  if (parser === "vue") content = parseVue(content);
+  if (parser === "svelte") content = parseSvelte(content);
+  if (parser === "astro") content = parseAstro(content);
+
+  const virtualFile = file.endsWith(".vue")
+    ? file + ".tsx"
+    : file;
+
+  return { content, virtualFile };
+}

package/tests/fixtures/backend/express/app.ts

@@ -13,66 +13,221 @@ const express = (...args: any[]) => ({
 
 const app = express();
 
-// ===== direct =====
+// =========================
+// BASIC
+// =========================
+
 track("express_event");
 
-// ===== middleware =====
+// =========================
+// VARIABLES
+// =========================
+
+const eventName = "variable_event";
+track(eventName);
+
+let anotherEvent;
+anotherEvent = "assigned_event";
+track(anotherEvent);
+
+// =========================
+// TEMPLATE
+// =========================
+
+track(`template_event`);
+
+const id = "123";
+track(`template_${id}`); // dynamic
+
+// =========================
+// MIDDLEWARE
+// =========================
+
 app.use(() => {
   track("middleware_event");
 });
 
-// ===== get =====
+// =========================
+// ROUTES
+// =========================
+
 app.get("/", () => {
   track("get_event");
 });
 
-// ===== post =====
 app.post("/users", () => {
   track("post_event");
 });
 
-// ===== put =====
 app.put("/users", () => {
   track("put_event");
 });
 
-// ===== delete =====
 app.delete("/users", () => {
   track("delete_event");
 });
 
-// ===== nested =====
+// =========================
+// NESTED
+// =========================
+
 app.get("/nested", () => {
   if (true) {
     track("nested_event");
   }
 });
 
-// ===== async =====
+// =========================
+// ASYNC
+// =========================
+
 app.get("/async", async () => {
   track("async_event");
 });
 
-// ===== arrow =====
+// =========================
+// ARROW HANDLER
+// =========================
+
 const handler = () => {
   track("arrow_event");
 };
 
 app.get("/arrow", handler);
 
-// ===== function =====
+// =========================
+// FUNCTION DECLARATION
+// =========================
+
 function service() {
   track("function_event");
 }
 
-// ===== class =====
+// =========================
+// CLASS
+// =========================
+
 class Service {
   run() {
     track("class_event");
   }
 }
 
-// ===== listen =====
+// =========================
+// LISTEN
+// =========================
+
 app.listen(3000, () => {
   track("listen_event");
 });
+
+// =========================
+// OBJECT WRAPPER
+// =========================
+
+const analytics = {
+  track
+};
+
+analytics.track("object_event");
+
+// nested object
+const analyticsDeep = {
+  events: {
+    track
+  }
+};
+
+analyticsDeep.events.track("nested_object_event");
+
+// =========================
+// CONDITIONALS
+// =========================
+
+if (true) {
+  track("if_event");
+} else {
+  track("else_event");
+}
+
+// ternary
+true
+  ? track("ternary_true")
+  : track("ternary_false");
+
+// =========================
+// ARRAYS
+// =========================
+
+[
+  () => track("array_1"),
+  () => track("array_2")
+];
+
+// =========================
+// LOOP
+// =========================
+
+for (let i = 0; i < 1; i++) {
+  track("loop_event");
+}
+
+// =========================
+// TRY / CATCH
+// =========================
+
+try {
+  track("try_event");
+} catch {
+  track("catch_event");
+}
+
+// =========================
+// RETURN
+// =========================
+
+function returnTest() {
+  return track("return_event");
+}
+
+// =========================
+// PARAM DEFAULT
+// =========================
+
+function withDefault(e = "default_event") {
+  track(e);
+}
+
+// =========================
+// INLINE OBJECT
+// =========================
+
+track({
+  name: "object_payload_event"
+} as any);
+
+// =========================
+// OPTIONAL CHAINING
+// =========================
+
+analytics?.track?.("optional_chain_event");
+
+// =========================
+// EDGE CASES
+// =========================
+
+// not first argument (should be ignored usually)
+// @ts-ignore
+track("real_event", "extra");
+
+// no args
+// @ts-ignore
+track();
+
+// dynamic identifier (should be dynamic)
+const dynamicEvent = Math.random() > 0.5 ? "a" : "b";
+track(dynamicEvent);
+
+// =========================
+// END
+// =========================

package/tests/fixtures/wrappers/component/test.tsx

@@ -43,7 +43,7 @@ export default function WrapperTest() {
       ]}
 
       {/* wrapper components */}
-      <TrackedButton event="tracked_button" />
+      <TrackedButton event={eventName} />
       <MyButton event="my_button" />
 
       {/* multiline */}

package/tests/run.ts

@@ -18,7 +18,7 @@ const fixtures = [
   "wrappers/function"
 ];
 
-function runCLI(args: string[], cwd: string) {
+function runCLI(args: string[], cwd: string): string {
   const result = spawnSync(
     process.execPath,
     [CLI, ...args],
@@ -35,23 +35,12 @@ function runCLI(args: string[], cwd: string) {
 function ensureTestConfig(dir: string) {
   const configPath = path.join(dir, "eventra.json");
 
-  if (fs.existsSync(configPath)) return;
-
   const config = {
     apiKey: "",
     events: [],
-    wrappers: [
-      {
-        name: "Button",
-        prop: "event"
-      }
-    ],
-    functionWrappers: [
-      {
-        name: "trackFeature",
-        path: "0"
-      }
-    ],
+    wrappers: [],
+    functionWrappers: [],
+    aliases: {},
     sync: {
       include: [
         "**/*.{ts,tsx,js,jsx,vue,svelte,astro}"
@@ -90,8 +79,6 @@ function runFixture(name: string) {
 
   ensureTestConfig(dir);
 
-  runCLI(["init"], dir);
-
   const output = runCLI(["sync"], dir);
 
   const match =