@eventra_dev/eventra-cli 0.0.19 → 0.1.2

package/src/engine/resolver.ts

@@ -0,0 +1,86 @@
+import ts from "typescript";
+
+export type ResolveResult = {
+  values: string[];
+  dynamic: boolean;
+};
+
+export function resolveNodeValue(
+  node: ts.Node,
+  checker: ts.TypeChecker
+): ResolveResult | null {
+
+  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);
+    const b = resolveNodeValue(node.whenFalse, checker);
+
+    return {
+      values: [...new Set([...(a?.values ?? []), ...(b?.values ?? [])])],
+      dynamic: true,
+    };
+  }
+
+  if (ts.isIdentifier(node)) {
+    let symbol = checker.getSymbolAtLocation(node);
+    if (!symbol) return null;
+
+    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);
+      }
+
+      if (ts.isEnumMember(decl) && decl.initializer) {
+        if (ts.isStringLiteral(decl.initializer)) {
+          return {
+            values: [decl.initializer.text],
+            dynamic: false,
+          };
+        }
+      }
+    }
+  }
+
+  if (ts.isPropertyAccessExpression(node)) {
+    const symbol = checker.getSymbolAtLocation(node);
+
+    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,
+            };
+          }
+        }
+      }
+    }
+  }
+
+  return null;
+}

package/src/engine/scanner.ts

@@ -0,0 +1,61 @@
+import ts from "typescript";
+import { resolveNodeValue } from "./resolver";
+import { resolveFunctionFromCall } from "./callResolver";
+
+export function scanSource(
+  source: ts.SourceFile,
+  checker: ts.TypeChecker,
+  visited = new Set<string>()
+) {
+  const events = new Set<string>();
+
+  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)) {
+        let target = node.arguments[0];
+
+        const fn = resolveFunctionFromCall(node.expression, checker);
+
+        // 🔥 cross-file
+        if (fn) {
+          const sf = fn.getSourceFile();
+
+          if (!visited.has(sf.fileName)) {
+            scanSource(sf, checker, visited).forEach(e => events.add(e));
+          }
+        }
+
+        if (target) {
+          const res = resolveNodeValue(target, checker);
+
+          res?.values.forEach(v => {
+            if (v && v.length > 1 && !v.includes(" ")) {
+              events.add(v);
+            }
+          });
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(source);
+
+  return events;
+}
+
+function getCallName(expr: ts.Expression): string {
+  if (ts.isIdentifier(expr)) return expr.text;
+
+  if (ts.isPropertyAccessExpression(expr)) {
+    return expr.name.text;
+  }
+
+  return "";
+}

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>;
@@ -23,9 +24,7 @@ export type EventraConfig = {
   };
 };
 
-export type ExtractedEvent = {
-  value: string;
+export type ResolveResult = {
+  values: 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 =

package/dist/utils/detect-aliases.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectAliases = detectAliases;
-const ts_morph_1 = require("ts-morph");
-function detectAliases(source) {
-    const aliases = {};
-    const vars = source.getDescendantsOfKind(ts_morph_1.SyntaxKind.VariableDeclaration);
-    for (const v of vars) {
-        const name = v.getName();
-        const init = v.getInitializer();
-        if (!init)
-            continue;
-        // const A = "event"
-        if (ts_morph_1.Node.isStringLiteral(init)) {
-            aliases[name] = init.getLiteralText();
-            continue;
-        }
-        // const A = `event`
-        if (init.getKind() === ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral) {
-            aliases[name] = init.getText().replace(/`/g, "");
-            continue;
-        }
-        // const EVENTS = { CLICK: "click" }
-        if (ts_morph_1.Node.isObjectLiteralExpression(init)) {
-            for (const p of init.getProperties()) {
-                if (!ts_morph_1.Node.isPropertyAssignment(p))
-                    continue;
-                const key = p.getName();
-                const val = p.getInitializer();
-                if (!val)
-                    continue;
-                if (ts_morph_1.Node.isStringLiteral(val)) {
-                    aliases[`${name}.${key}`] = val.getLiteralText();
-                }
-            }
-        }
-    }
-    return aliases;
-}

package/dist/utils/detect-wrappers.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectWrappers = detectWrappers;
-const ts_morph_1 = require("ts-morph");
-function detectWrappers(source) {
-    return {
-        functions: detectFunctionWrappers(source),
-        components: detectComponentWrappers(source)
-    };
-}
-// FUNCTIONS
-function detectFunctionWrappers(source) {
-    const result = new Map();
-    const functions = [
-        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.FunctionDeclaration),
-        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.ArrowFunction),
-        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.FunctionExpression)
-    ];
-    for (const fn of functions) {
-        const body = fn.getBody();
-        if (!body)
-            continue;
-        const calls = body.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
-        for (const call of calls) {
-            if (!isTrackCall(call))
-                continue;
-            const name = getFunctionName(fn);
-            if (!name)
-                continue;
-            const arg = call.getArguments()[0];
-            let eventField;
-            if (arg && ts_morph_1.Node.isObjectLiteralExpression(arg)) {
-                const prop = arg.getProperties()[0];
-                if (prop && ts_morph_1.Node.isPropertyAssignment(prop)) {
-                    eventField = prop.getName();
-                }
-            }
-            result.set(name, { name, event: eventField });
-        }
-    }
-    return [...result.values()];
-}
-function isTrackCall(call) {
-    const expr = call.getExpression();
-    if (ts_morph_1.Node.isIdentifier(expr)) {
-        return expr.getText() === "track";
-    }
-    if (ts_morph_1.Node.isPropertyAccessExpression(expr)) {
-        return expr.getName() === "track";
-    }
-    return false;
-}
-function getFunctionName(fn) {
-    if (ts_morph_1.Node.isFunctionDeclaration(fn)) {
-        return fn.getName() ?? null;
-    }
-    const varDecl = fn.getFirstAncestorByKind(ts_morph_1.SyntaxKind.VariableDeclaration);
-    return varDecl?.getName() ?? null;
-}
-// COMPONENTS
-function detectComponentWrappers(source) {
-    const result = new Map();
-    const elements = [
-        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.JsxOpeningElement),
-        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.JsxSelfClosingElement)
-    ];
-    for (const el of elements) {
-        const name = el.getTagNameNode().getText();
-        for (const attr of el.getAttributes()) {
-            const a = attr.asKind(ts_morph_1.SyntaxKind.JsxAttribute);
-            if (!a)
-                continue;
-            const prop = a.getNameNode().getText();
-            const val = a.getInitializer();
-            if (!val)
-                continue;
-            if (ts_morph_1.Node.isStringLiteral(val) ||
-                ts_morph_1.Node.isJsxExpression(val)) {
-                result.set(name, { name, prop });
-            }
-        }
-    }
-    return [...result.values()];
-}