@eventra_dev/eventra-cli 0.0.19 → 0.1.1

package/src/commands/sync.ts

@@ -1,217 +1,46 @@
-import chalk from "chalk";
 import fg from "fast-glob";
-import {Project} from "ts-morph";
 import fs from "fs/promises";
-import inquirer from "inquirer";
-
-import {loadConfig, saveConfig} from "../utils/config";
-
-import {detectWrappers} from "../utils/detect-wrappers";
-import {detectAliases} from "../utils/detect-aliases";
-
-import {detectParser} from "../utils/parsers/router";
-import {parseVue} from "../utils/parsers/vue";
-import {parseSvelte} from "../utils/parsers/svelte";
-import {parseAstro} from "../utils/parsers/astro";
-
-import {scanTrack} from "../utils/scanners/track";
-import {scanFunctionWrappers} from "../utils/scanners/function-wrappers";
-import {scanComponentWrappers} from "../utils/scanners/component-wrappers";
+import chalk from "chalk";
 
-import {ExtractedEvent} from "../types";
+import { loadConfig, saveConfig } from "../utils/config";
+import { EventraEngine } from "../engine/engine";
+import { processFile } from "../utils/processFile";
 
 export async function sync() {
   const config = await loadConfig();
+  if (!config) return;
 
-  if (!config) {
-    console.log(chalk.red("Run 'eventra init'"));
-    return;
-  }
-
-  console.log(chalk.blue("Scanning project..."));
-
-  const project = new Project();
-
-  const events = new Set<string>();
-  const aliases = config.aliases ?? {};
-  const asked = new Set<string>();
+  console.log(chalk.blue("Scanning..."));
 
   const files = await fg(config.sync.include, {
-    ignore: config.sync.exclude
+    ignore: config.sync.exclude,
   });
 
-  for (const file of files) {
-    try {
-      const parser = detectParser(file);
-
-      let content = await fs.readFile(file, "utf-8");
-
-      if (parser === "vue") content = parseVue(content);
-      if (parser === "svelte") content = parseSvelte(content);
-      if (parser === "astro") content = parseAstro(content);
-
-      const virtualFile =
-        parser === "ts" ? file : file + ".tsx";
-
-      const source = project.createSourceFile(
-        virtualFile,
-        content,
-        {overwrite: true}
-      );
-
-
-      // AUTO ALIASES
-      const detectedAliases = detectAliases(source);
-
-      for (const key in detectedAliases) {
-        if (!(key in aliases)) {
-          aliases[key] = detectedAliases[key];
-
-          console.log(
-            chalk.green(
-              `Detected alias: ${key} → ${detectedAliases[key]}`
-            )
-          );
-        }
-      }
-
-
-      // AUTO WRAPPERS
-      const detected = detectWrappers(source);
-
-      // function wrappers
-      for (const fn of detected.functions) {
-        if (
-          !config.functionWrappers?.some(
-            (w) => w.name === fn.name
-          )
-        ) {
-          config.functionWrappers.push(fn);
-
-          console.log(
-            chalk.green(
-              `Detected function wrapper: ${fn.name}`
-            )
-          );
-        }
-      }
-
-      // component wrappers
-      for (const comp of detected.components) {
-        if (
-          !config.wrappers?.some(
-            (w) => w.name === comp.name
-          )
-        ) {
-          config.wrappers.push(comp);
-
-          console.log(
-            chalk.green(
-              `Detected component wrapper: ${comp.name} (prop: ${comp.prop})`
-            )
-          );
-        }
-      }
-
-      // SCAN EVENTS
-      const found: ExtractedEvent[] = [
-        ...scanTrack(source, config, aliases),
-        ...scanFunctionWrappers(
-          source,
-          config.functionWrappers ?? [],
-          aliases
-        ),
-        ...scanComponentWrappers(
-          source,
-          config.wrappers ?? [],
-          aliases
-        )
-      ];
-
-      for (const event of found) {
-        const {value, dynamic} = event;
-
-        if (!value) continue;
-
-        // skip explicit ignore
-        if (value in aliases && aliases[value] === "__skip__") {
-          continue;
-        }
-
-        // resolve alias
-        if (value in aliases) {
-          events.add(aliases[value]);
-          continue;
-        }
-
-        // static
-        if (!dynamic) {
-          events.add(value);
-          continue;
-        }
-
-        // already handled
-        if (asked.has(value)) continue;
-
-        // ASK ONLY IF NEEDED
-        console.log(
-          chalk.yellow("\nDynamic event detected:")
-        );
-        console.log(chalk.gray(value));
-
-        const {name} = await inquirer.prompt([
-          {
-            type: "input",
-            name: "name",
-            message:
-              "Enter event name (or type 'skip'):"
-          }
-        ]);
-
-        const normalized = name?.trim();
-        asked.add(value);
-
-        if (!normalized || normalized === "skip") {
-          continue;
-        }
+  if (!files.length) {
+    console.log(chalk.yellow("No files found"));
+    return;
+  }
 
-        // save alias
-        aliases[value] = normalized;
+  const engine = new EventraEngine(process.cwd());
 
-        console.log(
-          chalk.green(
-            `Saved alias: ${value} → ${normalized}`
-          )
-        );
+  for (const file of files) {
+    try {
+      const raw = await fs.readFile(file, "utf-8");
 
-        events.add(normalized);
-      }
+      const { content, virtualFile } = processFile(file, raw);
 
-      // free memory
-      project.removeSourceFile(source);
+      engine.scanFile(virtualFile, content);
 
-    } catch {
-      console.log(
-        chalk.gray(`Skipped file: ${file}`)
-      );
+    } catch (e) {
+      console.log(chalk.red(`ERROR: ${file}`));
+      console.error(e);
     }
   }
-  // SAVE CONFIG
-  config.aliases = Object.fromEntries(
-    Object.entries(aliases).sort()
-  );
-
-  // MERGE
-  const merged = new Set([
-    ...config.events,
-    ...events
-  ]);
 
-  config.events = [...merged].sort();
+  const events = engine.getAllEvents().sort();
 
+  config.events = events;
   await saveConfig(config);
 
-  console.log(
-    chalk.green(`\nFound ${config.events.length} events`)
-  );
+  console.log(chalk.green(`Found ${events.length} events`));
 }

package/src/commands/watch.ts

@@ -1,113 +1,166 @@
 import chokidar from "chokidar";
 import chalk from "chalk";
-import { Project } from "ts-morph";
 import fs from "fs/promises";
+import fg from "fast-glob";
 
 import { loadConfig, saveConfig } from "../utils/config";
+import { EventraEngine } from "../engine/engine";
 
 import { detectParser } from "../utils/parsers/router";
 import { parseVue } from "../utils/parsers/vue";
 import { parseSvelte } from "../utils/parsers/svelte";
 import { parseAstro } from "../utils/parsers/astro";
 
-import { scanTrack } from "../utils/scanners/track";
-import { scanFunctionWrappers } from "../utils/scanners/function-wrappers";
-import { scanComponentWrappers } from "../utils/scanners/component-wrappers";
+// PREPROCESS (CONTENT)
+function preprocess(file: string, content: string) {
+  const parser = detectParser(file);
 
+  if (parser === "vue") return parseVue(content);
+  if (parser === "svelte") return parseSvelte(content);
+  if (parser === "astro") return parseAstro(content);
+
+  return content;
+}
+
+// VIRTUAL FILE (PATH)
+function toVirtualFile(file: string) {
+  return file.endsWith(".vue")
+    ? file + ".tsx"
+    : file;
+}
+
+// WATCH
 export async function watch() {
   const config = await loadConfig();
-
-  if (!config) {
-    console.log(chalk.red("Run init first"));
-    return;
-  }
+  if (!config) return;
 
   console.log(chalk.blue("Watching...\n"));
 
-  const project = new Project();
+  const files = await fg(config.sync.include, {
+    ignore: config.sync.exclude,
+  });
 
-  const aliases = config.aliases ?? {};
+  if (!files.length) {
+    console.log(chalk.yellow("No files found"));
+    return;
+  }
 
-  // уже известные события
-  const seen = new Set(config.events);
+  const engine = new EventraEngine(process.cwd());
+
+  // INITIAL SCAN
+  for (const file of files) {
+    try {
+      const raw = await fs.readFile(file, "utf-8");
 
-  const queue = new Set<string>();
-  let timer: NodeJS.Timeout;
+      const content = preprocess(file, raw);
+      const virtualFile = toVirtualFile(file);
 
-  const processQueue = async () => {
-    const files = [...queue];
-    queue.clear();
+      engine.scanFile(virtualFile, content);
 
-    for (const file of files) {
-      await handle(file);
+    } catch {
+      console.log(chalk.gray(`skip: ${file}`));
     }
+  }
 
-    config.events = [...new Set(config.events)].sort();
+  config.events = engine.getAllEvents().sort();
+  await saveConfig(config);
 
-    await saveConfig(config);
-  };
+  console.log(
+    chalk.gray(`Initial: ${config.events.length} events\n`)
+  );
 
-  const handle = async (file: string) => {
-    try {
-      let content = await fs.readFile(file, "utf-8");
-
-      const parser = detectParser(file);
+  // STATE
+  let locked = false;
+  let queued = new Set<string>();
 
-      if (parser === "vue") content = parseVue(content);
-      if (parser === "svelte") content = parseSvelte(content);
-      if (parser === "astro") content = parseAstro(content);
+  const run = async () => {
+    if (locked) return;
+    locked = true;
 
-      const source = project.createSourceFile(file, content, {
-        overwrite: true
-      });
+    const batch = [...queued];
+    queued.clear();
 
-      const found = [
-        ...scanTrack(source, config, aliases),
-        ...scanFunctionWrappers(source, config.functionWrappers ?? [], aliases),
-        ...scanComponentWrappers(source, config.wrappers ?? [], aliases)
-      ];
+    for (const file of batch) {
+      try {
+        const raw = await fs.readFile(file, "utf-8");
 
-      for (const e of found) {
-        if (!e.value) continue;
+        const content = preprocess(file, raw);
+        const virtualFile = toVirtualFile(file);
 
-        if (aliases[e.value] === "__skip__") continue;
+        engine.updateFile(virtualFile, content);
 
-        if (e.value in aliases) continue;
+      } catch {
+        console.log(chalk.gray(`skip: ${file}`));
+      }
+    }
 
-        if (seen.has(e.value)) continue;
+    const next = engine.getAllEvents();
 
-        seen.add(e.value);
+    const added = next.filter(e => !config.events.includes(e));
+    const removed = config.events.filter(e => !next.includes(e));
 
-        if (!e.dynamic) {
-          config.events.push(e.value);
-          console.log(chalk.green(`+ ${e.value}`));
-        } else {
-          console.log(chalk.yellow(`Dynamic: ${e.value}`));
-        }
-      }
+    if (added.length || removed.length) {
+      added.forEach(e => console.log(chalk.green(`+ ${e}`)));
+      removed.forEach(e => console.log(chalk.red(`- ${e}`)));
 
-      project.removeSourceFile(source);
+      config.events = next.sort();
+      await saveConfig(config);
 
-    } catch {
-      console.log(chalk.gray(`skip: ${file}`));
+      console.log(
+        chalk.gray(`Total: ${config.events.length} events\n`)
+      );
     }
+
+    locked = false;
   };
 
+  const schedule = (file: string) => {
+    queued.add(file);
+    setTimeout(run, 50);
+  };
+
+  // WATCHER
   const watcher = chokidar.watch(config.sync.include, {
-    ignored: [
-      ...config.sync.exclude,
-      "**/*.log",
-      "**/*.tmp",
-      "**/*.swp"
-    ],
-    ignoreInitial: true
+    ignored: config.sync.exclude,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 50,
+      pollInterval: 10,
+    },
   });
 
-  watcher.on("change", (file) => {
-    queue.add(file);
+  watcher
+    .on("add", (file) => {
+      console.log(chalk.gray(`add: ${file}`));
+      schedule(file);
+    })
+    .on("change", (file) => {
+      console.log(chalk.gray(`change: ${file}`));
+      schedule(file);
+    })
+    .on("unlink", async (file) => {
+      console.log(chalk.gray(`remove: ${file}`));
+
+      const virtualFile = toVirtualFile(file);
+
+      engine.removeFile?.(virtualFile);
 
-    clearTimeout(timer);
+      const next = engine.getAllEvents();
+
+      const removed = config.events.filter(e => !next.includes(e));
+
+      if (removed.length) {
+        removed.forEach(e => console.log(chalk.red(`- ${e}`)));
+
+        config.events = next.sort();
+        await saveConfig(config);
+      }
+    });
 
-    timer = setTimeout(processQueue, 200);
+  // EXIT
+  process.on("SIGINT", async () => {
+    console.log(chalk.yellow("\nStopping watcher..."));
+    await watcher.close();
+    process.exit(0);
   });
 }

package/src/engine/callResolver.ts

@@ -0,0 +1,37 @@
+import { Node } from "ts-morph";
+
+export function resolveFunctionFromCall(expr: Node) {
+  let symbol = expr.getSymbol();
+
+  if (!symbol && Node.isPropertyAccessExpression(expr)) {
+    symbol = expr.getNameNode().getSymbol();
+  }
+
+  if (!symbol) return null;
+
+  const decls = symbol.getDeclarations() ?? [];
+
+  for (const d of decls) {
+    if (Node.isFunctionDeclaration(d)) return d;
+
+    if (Node.isVariableDeclaration(d)) {
+      const init = d.getInitializer();
+
+      if (
+        init &&
+        (Node.isArrowFunction(init) ||
+          Node.isFunctionExpression(init))
+      ) {
+        return init;
+      }
+    }
+
+    if (Node.isMethodDeclaration(d)) return d;
+
+    if (Node.isFunctionExpression(d) || Node.isArrowFunction(d)) {
+      return d;
+    }
+  }
+
+  return null;
+}

package/src/engine/engine.ts

@@ -0,0 +1,39 @@
+import { ProjectGraph } from "./project";
+import { scanSource } from "./scanner";
+
+export class EventraEngine {
+  private project: ProjectGraph;
+  private fileEvents = new Map<string, Set<string>>();
+
+  constructor(entry: string) {
+    this.project = new ProjectGraph(entry);
+  }
+
+  scanFile(file: string, content: string) {
+    const source = this.project.getSource(file, content);
+    const checker = this.project.getChecker();
+
+    const events = scanSource(source, checker);
+
+    this.fileEvents.set(file, events);
+    return events;
+  }
+
+  updateFile(file: string, content: string) {
+    return this.scanFile(file, content);
+  }
+
+  getAllEvents() {
+    const all = new Set<string>();
+
+    for (const set of this.fileEvents.values()) {
+      set.forEach(e => all.add(e));
+    }
+
+    return [...all];
+  }
+
+  removeFile(file: string) {
+    this.fileEvents.delete(file);
+  }
+}

package/src/engine/extract.ts

@@ -0,0 +1,74 @@
+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

@@ -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;
+}