@eventra_dev/eventra-cli 0.0.18 → 0.1.1

package/src/engine/flow.ts

@@ -0,0 +1,54 @@
+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/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/index.ts

@@ -11,7 +11,6 @@ program
 
 program
   .command("init")
-  .description("Initialize Eventra")
   .action(async () => {
     const { init } = await import("./commands/init");
     await init();
@@ -19,7 +18,6 @@ program
 
 program
   .command("sync")
-  .description("Sync events")
   .action(async () => {
     const { sync } = await import("./commands/sync");
     await sync();
@@ -27,15 +25,22 @@ program
 
 program
   .command("check")
-  .description("Validate events (CI mode)")
-  .action(async () => {
+  .option("--fix", "auto fix issues")
+  .action(async (opts) => {
     const { check } = await import("./commands/check");
-    await check();
+    await check({ fix: opts.fix });
+  });
+
+program
+  .command("watch")
+  .description("Watch files and detect events in real-time")
+  .action(async () => {
+    const { watch } = await import("./commands/watch");
+    await watch();
   });
 
 program
   .command("send")
-  .description("Send events")
   .action(async () => {
     const { send } = await import("./commands/send");
     await send();

package/src/types.ts

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

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
+// =========================