@eventra_dev/eventra-cli 0.0.18 → 0.0.19

package/src/commands/sync.ts

@@ -1,157 +1,217 @@
 import chalk from "chalk";
 import fg from "fast-glob";
-import { Project } from "ts-morph";
+import {Project} from "ts-morph";
 import fs from "fs/promises";
 import inquirer from "inquirer";
 
-import {
-  loadConfig,
-  saveConfig
-} from "../utils/config";
+import {loadConfig, saveConfig} from "../utils/config";
 
-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 {detectWrappers} from "../utils/detect-wrappers";
+import {detectAliases} from "../utils/detect-aliases";
 
-import { scanTrack } from "../utils/scanners/track";
-import { scanFunctionWrappers } from "../utils/scanners/function-wrappers";
-import { scanComponentWrappers } from "../utils/scanners/component-wrappers";
+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 { ExtractedEvent } from "../types";
+import {scanTrack} from "../utils/scanners/track";
+import {scanFunctionWrappers} from "../utils/scanners/function-wrappers";
+import {scanComponentWrappers} from "../utils/scanners/component-wrappers";
+
+import {ExtractedEvent} from "../types";
 
 export async function sync() {
   const config = await loadConfig();
 
   if (!config) {
-    console.log(
-      chalk.red("Run 'eventra init'")
-    );
+    console.log(chalk.red("Run 'eventra init'"));
     return;
   }
 
-  console.log(
-    chalk.blue("Scanning project...")
-  );
+  console.log(chalk.blue("Scanning project..."));
 
   const project = new Project();
-  const events = new Set<string>();
 
+  const events = new Set<string>();
   const aliases = config.aliases ?? {};
   const asked = new Set<string>();
 
-  const files = await fg(
-    config.sync.include,
-    {
-      ignore: config.sync.exclude
-    }
-  );
+  const files = await fg(config.sync.include, {
+    ignore: config.sync.exclude
+  });
 
   for (const file of files) {
-    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 }
-    );
-
-    const found: ExtractedEvent[] = [
-      ...scanTrack(source, config),
-      ...scanFunctionWrappers(
-        source,
-        config.functionWrappers ?? []
-      ),
-      ...scanComponentWrappers(
-        source,
-        config.wrappers ?? []
-      )
-    ];
-
-    for (const event of found) {
-      const { value, dynamic } = event;
-
-      if (!value) continue;
-
-      // alias
-      if (aliases[value]) {
-        console.log(
-          chalk.gray(`alias: ${value} → ${aliases[value]}`)
-        );
-        events.add(aliases[value]);
-        continue;
+    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]}`
+            )
+          );
+        }
       }
 
-      // static
-      if (!dynamic) {
-        events.add(value);
-        continue;
+
+      // 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}`
+            )
+          );
+        }
       }
 
-      // already asked
-      if (asked.has(value)) {
-        continue;
+      // 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})`
+            )
+          );
+        }
       }
 
-      // ask user
-      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'):"
+      // 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;
         }
-      ]);
 
-      const normalized = name?.trim();
+        // already handled
+        if (asked.has(value)) continue;
 
-      asked.add(value);
+        // 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;
+        }
+
+        // save alias
+        aliases[value] = normalized;
+
+        console.log(
+          chalk.green(
+            `Saved alias: ${value} → ${normalized}`
+          )
+        );
 
-      if (!normalized || normalized === "skip") {
-        continue;
+        events.add(normalized);
       }
 
-      // save alias
-      aliases[value] = normalized;
+      // free memory
+      project.removeSourceFile(source);
 
-      events.add(normalized);
+    } catch {
+      console.log(
+        chalk.gray(`Skipped file: ${file}`)
+      );
     }
   }
+  // SAVE CONFIG
+  config.aliases = Object.fromEntries(
+    Object.entries(aliases).sort()
+  );
 
-  config.aliases = aliases;
+  // MERGE
+  const merged = new Set([
+    ...config.events,
+    ...events
+  ]);
 
-  const list = [...events].sort();
-  config.events = list;
+  config.events = [...merged].sort();
 
   await saveConfig(config);
 
   console.log(
-    chalk.green(
-      `Found ${list.length} events`
-    )
+    chalk.green(`\nFound ${config.events.length} events`)
   );
 }

package/src/commands/watch.ts

@@ -0,0 +1,113 @@
+import chokidar from "chokidar";
+import chalk from "chalk";
+import { Project } from "ts-morph";
+import fs from "fs/promises";
+
+import { loadConfig, saveConfig } from "../utils/config";
+
+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";
+
+export async function watch() {
+  const config = await loadConfig();
+
+  if (!config) {
+    console.log(chalk.red("Run init first"));
+    return;
+  }
+
+  console.log(chalk.blue("Watching...\n"));
+
+  const project = new Project();
+
+  const aliases = config.aliases ?? {};
+
+  // уже известные события
+  const seen = new Set(config.events);
+
+  const queue = new Set<string>();
+  let timer: NodeJS.Timeout;
+
+  const processQueue = async () => {
+    const files = [...queue];
+    queue.clear();
+
+    for (const file of files) {
+      await handle(file);
+    }
+
+    config.events = [...new Set(config.events)].sort();
+
+    await saveConfig(config);
+  };
+
+  const handle = async (file: string) => {
+    try {
+      let content = await fs.readFile(file, "utf-8");
+
+      const parser = detectParser(file);
+
+      if (parser === "vue") content = parseVue(content);
+      if (parser === "svelte") content = parseSvelte(content);
+      if (parser === "astro") content = parseAstro(content);
+
+      const source = project.createSourceFile(file, content, {
+        overwrite: true
+      });
+
+      const found = [
+        ...scanTrack(source, config, aliases),
+        ...scanFunctionWrappers(source, config.functionWrappers ?? [], aliases),
+        ...scanComponentWrappers(source, config.wrappers ?? [], aliases)
+      ];
+
+      for (const e of found) {
+        if (!e.value) continue;
+
+        if (aliases[e.value] === "__skip__") continue;
+
+        if (e.value in aliases) continue;
+
+        if (seen.has(e.value)) continue;
+
+        seen.add(e.value);
+
+        if (!e.dynamic) {
+          config.events.push(e.value);
+          console.log(chalk.green(`+ ${e.value}`));
+        } else {
+          console.log(chalk.yellow(`Dynamic: ${e.value}`));
+        }
+      }
+
+      project.removeSourceFile(source);
+
+    } catch {
+      console.log(chalk.gray(`skip: ${file}`));
+    }
+  };
+
+  const watcher = chokidar.watch(config.sync.include, {
+    ignored: [
+      ...config.sync.exclude,
+      "**/*.log",
+      "**/*.tmp",
+      "**/*.swp"
+    ],
+    ignoreInitial: true
+  });
+
+  watcher.on("change", (file) => {
+    queue.add(file);
+
+    clearTimeout(timer);
+
+    timer = setTimeout(processQueue, 200);
+  });
+}

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

@@ -6,6 +6,8 @@ export type ComponentWrapper = {
 export type FunctionWrapper = {
   name: string;
   event?: string;
+  file?: string;
+  line?: number;
 };
 
 export type EventraConfig = {
@@ -24,4 +26,6 @@ export type EventraConfig = {
 export type ExtractedEvent = {
   value: string;
   dynamic: boolean;
+  file?: string;
+  line?: number;
 };

package/src/utils/detect-aliases.ts

@@ -0,0 +1,46 @@
+import {
+  SourceFile,
+  SyntaxKind,
+  Node
+} from "ts-morph";
+
+export function detectAliases(source: SourceFile) {
+  const aliases: Record<string, string> = {};
+
+  const vars = source.getDescendantsOfKind(SyntaxKind.VariableDeclaration);
+
+  for (const v of vars) {
+    const name = v.getName();
+    const init = v.getInitializer();
+    if (!init) continue;
+
+    // const A = "event"
+    if (Node.isStringLiteral(init)) {
+      aliases[name] = init.getLiteralText();
+      continue;
+    }
+
+    // const A = `event`
+    if (init.getKind() === SyntaxKind.NoSubstitutionTemplateLiteral) {
+      aliases[name] = init.getText().replace(/`/g, "");
+      continue;
+    }
+
+    // const EVENTS = { CLICK: "click" }
+    if (Node.isObjectLiteralExpression(init)) {
+      for (const p of init.getProperties()) {
+        if (!Node.isPropertyAssignment(p)) continue;
+
+        const key = p.getName();
+        const val = p.getInitializer();
+        if (!val) continue;
+
+        if (Node.isStringLiteral(val)) {
+          aliases[`${name}.${key}`] = val.getLiteralText();
+        }
+      }
+    }
+  }
+
+  return aliases;
+}

package/src/utils/detect-wrappers.ts

@@ -0,0 +1,119 @@
+import {
+  SourceFile,
+  SyntaxKind,
+  Node,
+  CallExpression
+} from "ts-morph";
+
+export type FunctionWrapper = {
+  name: string;
+  event?: string;
+};
+
+export type ComponentWrapper = {
+  name: string;
+  prop: string;
+};
+
+export function detectWrappers(source: SourceFile) {
+  return {
+    functions: detectFunctionWrappers(source),
+    components: detectComponentWrappers(source)
+  };
+}
+
+// FUNCTIONS
+function detectFunctionWrappers(source: SourceFile): FunctionWrapper[] {
+  const result = new Map<string, FunctionWrapper>();
+
+  const functions = [
+    ...source.getDescendantsOfKind(SyntaxKind.FunctionDeclaration),
+    ...source.getDescendantsOfKind(SyntaxKind.ArrowFunction),
+    ...source.getDescendantsOfKind(SyntaxKind.FunctionExpression)
+  ];
+
+  for (const fn of functions) {
+    const body = fn.getBody();
+    if (!body) continue;
+
+    const calls = body.getDescendantsOfKind(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: string | undefined;
+
+      if (arg && Node.isObjectLiteralExpression(arg)) {
+        const prop = arg.getProperties()[0];
+        if (prop && Node.isPropertyAssignment(prop)) {
+          eventField = prop.getName();
+        }
+      }
+
+      result.set(name, { name, event: eventField });
+    }
+  }
+
+  return [...result.values()];
+}
+
+function isTrackCall(call: CallExpression) {
+  const expr = call.getExpression();
+
+  if (Node.isIdentifier(expr)) {
+    return expr.getText() === "track";
+  }
+
+  if (Node.isPropertyAccessExpression(expr)) {
+    return expr.getName() === "track";
+  }
+
+  return false;
+}
+
+function getFunctionName(fn: Node): string | null {
+  if (Node.isFunctionDeclaration(fn)) {
+    return fn.getName() ?? null;
+  }
+
+  const varDecl = fn.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
+  return varDecl?.getName() ?? null;
+}
+
+// COMPONENTS
+function detectComponentWrappers(source: SourceFile): ComponentWrapper[] {
+  const result = new Map<string, ComponentWrapper>();
+
+  const elements = [
+    ...source.getDescendantsOfKind(SyntaxKind.JsxOpeningElement),
+    ...source.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement)
+  ];
+
+  for (const el of elements) {
+    const name = el.getTagNameNode().getText();
+
+    for (const attr of el.getAttributes()) {
+      const a = attr.asKind(SyntaxKind.JsxAttribute);
+      if (!a) continue;
+
+      const prop = a.getNameNode().getText();
+      const val = a.getInitializer();
+
+      if (!val) continue;
+
+      if (
+        Node.isStringLiteral(val) ||
+        Node.isJsxExpression(val)
+      ) {
+        result.set(name, { name, prop });
+      }
+    }
+  }
+
+  return [...result.values()];
+}