@eventra_dev/eventra-cli 0.0.18 → 0.1.1

package/src/commands/check.ts

@@ -1,22 +1,12 @@
 import chalk from "chalk";
 import fg from "fast-glob";
-import { Project } from "ts-morph";
 import fs from "fs/promises";
 
-import { loadConfig } from "../utils/config";
+import { loadConfig, saveConfig } from "../utils/config";
+import { EventraEngine } from "../engine/engine";
+import { processFile } from "../utils/processFile";
 
-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 { ExtractedEvent } from "../types";
-
-export async function check() {
+export async function check({ fix = false }: { fix?: boolean }) {
   const config = await loadConfig();
 
   if (!config) {
@@ -26,147 +16,50 @@ export async function check() {
 
   console.log(chalk.blue("Checking events..."));
 
-  const project = new Project();
-
-  const knownEvents = new Set(config.events ?? []);
-  const aliases = config.aliases ?? {};
-
-  const foundEvents = new Set<string>();
-  const newEvents = new Set<string>();
-  const unresolvedDynamic = new Set<string>();
-
   const files = await fg(config.sync.include, {
-    ignore: config.sync.exclude
+    ignore: config.sync.exclude,
   });
 
+  const engine = new EventraEngine(process.cwd());
+
   for (const file of files) {
     try {
-      // skip huge files
-      const stat = await fs.stat(file);
-      if (stat.size > 2 * 1024 * 1024) {
-        console.log(chalk.gray(`Skipped large file: ${file}`));
-        continue;
-      }
-
-      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 skip
-        if (aliases[value] === "__skip__") {
-          continue;
-        }
-
-        // alias resolve
-        if (aliases[value]) {
-          foundEvents.add(aliases[value]);
-          continue;
-        }
-
-        // dynamic without alias
-        if (dynamic) {
-          unresolvedDynamic.add(value);
-          continue;
-        }
-
-        // static
-        foundEvents.add(value);
-      }
-
-      // clear memory
-      project.removeSourceFile(source);
+      const raw = await fs.readFile(file, "utf-8");
 
-    } catch {
-      console.log(
-        chalk.gray(`Skipped file (error): ${file}`)
-      );
-    }
-  }
+      const { content, virtualFile } = processFile(file, raw);
 
-  // find new events
-  for (const event of foundEvents) {
-    if (!knownEvents.has(event)) {
-      newEvents.add(event);
+      engine.scanFile(virtualFile, content);
+
+    } catch {
+      console.log(chalk.gray(`Skipped: ${file}`));
     }
   }
 
-  let hasError = false;
+  const found = new Set(engine.getAllEvents());
+  const known = new Set(config.events ?? []);
 
-  // dynamic
-  if (unresolvedDynamic.size > 0) {
-    hasError = true;
+  const newEvents = [...found].filter(e => !known.has(e));
 
-    console.log(
-      chalk.red("\nUnresolved dynamic events:")
-    );
+  if (fix) {
+    newEvents.forEach(e => {
+      config.events.push(e);
+      console.log(chalk.green(`+ ${e}`));
+    });
 
-    [...unresolvedDynamic]
-      .sort()
-      .forEach((e) =>
-        console.log(chalk.red(`- ${e}`))
-      );
-  }
-
-  // new events
-  if (newEvents.size > 0) {
-    hasError = true;
+    config.events = [...new Set(config.events)].sort();
 
-    console.log(
-      chalk.red("\nNew events detected:")
-    );
+    await saveConfig(config);
 
-    [...newEvents]
-      .sort()
-      .forEach((e) =>
-        console.log(chalk.red(`+ ${e}`))
-      );
+    console.log(chalk.green("\nFixed"));
+    return;
   }
 
-  if (hasError) {
-    console.log("");
-
-    console.log(chalk.red("Event check failed"));
-
-    console.log(
-      chalk.red(
-        `dynamic: ${unresolvedDynamic.size}, new: ${newEvents.size}`
-      )
-    );
+  if (newEvents.length) {
+    console.log(chalk.red("\nNew events:"));
+    newEvents.forEach(e => console.log(chalk.red(`+ ${e}`)));
 
     process.exit(1);
   }
 
-  console.log(
-    chalk.green("\nAll events are valid")
-  );
+  console.log(chalk.green("\nAll good"));
 }

package/src/commands/sync.ts

@@ -1,157 +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 { 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...")
-  );
+  console.log(chalk.blue("Scanning..."));
 
-  const project = new Project();
-  const events = new Set<string>();
+  const files = await fg(config.sync.include, {
+    ignore: config.sync.exclude,
+  });
 
-  const aliases = config.aliases ?? {};
-  const asked = new Set<string>();
+  if (!files.length) {
+    console.log(chalk.yellow("No files found"));
+    return;
+  }
 
-  const files = await fg(
-    config.sync.include,
-    {
-      ignore: config.sync.exclude
-    }
-  );
+  const engine = new EventraEngine(process.cwd());
 
   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);
+    try {
+      const raw = await fs.readFile(file, "utf-8");
 
-    if (parser === "astro")
-      content = parseAstro(content);
+      const { content, virtualFile } = processFile(file, raw);
 
-    const virtualFile =
-      parser === "ts"
-        ? file
-        : file + ".tsx";
+      engine.scanFile(virtualFile, content);
 
-    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;
-      }
-
-      // static
-      if (!dynamic) {
-        events.add(value);
-        continue;
-      }
-
-      // already asked
-      if (asked.has(value)) {
-        continue;
-      }
-
-      // 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'):"
-        }
-      ]);
-
-      const normalized = name?.trim();
-
-      asked.add(value);
-
-      if (!normalized || normalized === "skip") {
-        continue;
-      }
-
-      // save alias
-      aliases[value] = normalized;
-
-      events.add(normalized);
+    } catch (e) {
+      console.log(chalk.red(`ERROR: ${file}`));
+      console.error(e);
     }
   }
 
-  config.aliases = aliases;
-
-  const list = [...events].sort();
-  config.events = list;
+  const events = engine.getAllEvents().sort();
 
+  config.events = events;
   await saveConfig(config);
 
-  console.log(
-    chalk.green(
-      `Found ${list.length} events`
-    )
-  );
+  console.log(chalk.green(`Found ${events.length} events`));
 }

package/src/commands/watch.ts

@@ -0,0 +1,166 @@
+import chokidar from "chokidar";
+import chalk from "chalk";
+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";
+
+// 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) return;
+
+  console.log(chalk.blue("Watching...\n"));
+
+  const files = await fg(config.sync.include, {
+    ignore: config.sync.exclude,
+  });
+
+  if (!files.length) {
+    console.log(chalk.yellow("No files found"));
+    return;
+  }
+
+  const engine = new EventraEngine(process.cwd());
+
+  // INITIAL SCAN
+  for (const file of files) {
+    try {
+      const raw = await fs.readFile(file, "utf-8");
+
+      const content = preprocess(file, raw);
+      const virtualFile = toVirtualFile(file);
+
+      engine.scanFile(virtualFile, content);
+
+    } catch {
+      console.log(chalk.gray(`skip: ${file}`));
+    }
+  }
+
+  config.events = engine.getAllEvents().sort();
+  await saveConfig(config);
+
+  console.log(
+    chalk.gray(`Initial: ${config.events.length} events\n`)
+  );
+
+  // STATE
+  let locked = false;
+  let queued = new Set<string>();
+
+  const run = async () => {
+    if (locked) return;
+    locked = true;
+
+    const batch = [...queued];
+    queued.clear();
+
+    for (const file of batch) {
+      try {
+        const raw = await fs.readFile(file, "utf-8");
+
+        const content = preprocess(file, raw);
+        const virtualFile = toVirtualFile(file);
+
+        engine.updateFile(virtualFile, content);
+
+      } catch {
+        console.log(chalk.gray(`skip: ${file}`));
+      }
+    }
+
+    const next = engine.getAllEvents();
+
+    const added = next.filter(e => !config.events.includes(e));
+    const removed = config.events.filter(e => !next.includes(e));
+
+    if (added.length || removed.length) {
+      added.forEach(e => console.log(chalk.green(`+ ${e}`)));
+      removed.forEach(e => console.log(chalk.red(`- ${e}`)));
+
+      config.events = next.sort();
+      await saveConfig(config);
+
+      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,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 50,
+      pollInterval: 10,
+    },
+  });
+
+  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);
+
+      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);
+      }
+    });
+
+  // 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;
+}