@eventra_dev/eventra-cli 0.0.19 → 0.1.2

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,43 @@
+import ts from "typescript";
+
+export function resolveFunctionFromCall(
+  expr: ts.Expression,
+  checker: ts.TypeChecker
+): ts.FunctionLikeDeclaration | null {
+
+  let symbol = checker.getSymbolAtLocation(expr);
+
+  if (!symbol && ts.isPropertyAccessExpression(expr)) {
+    symbol = checker.getSymbolAtLocation(expr.name);
+  }
+
+  if (!symbol) return null;
+
+  if (symbol.flags & ts.SymbolFlags.Alias) {
+    symbol = checker.getAliasedSymbol(symbol);
+  }
+
+  for (const decl of symbol.getDeclarations() ?? []) {
+    if (
+      ts.isFunctionDeclaration(decl) ||
+      ts.isMethodDeclaration(decl) ||
+      ts.isFunctionExpression(decl) ||
+      ts.isArrowFunction(decl)
+    ) {
+      return decl;
+    }
+
+    if (ts.isVariableDeclaration(decl) && decl.initializer) {
+      const init = decl.initializer;
+
+      if (
+        ts.isArrowFunction(init) ||
+        ts.isFunctionExpression(init)
+      ) {
+        return init;
+      }
+    }
+  }
+
+  return null;
+}

package/src/engine/engine.ts

@@ -0,0 +1,60 @@
+import { TSService } from "./languageService";
+import { scanSource } from "./scanner";
+import { DependencyGraph } from "./graph";
+import { hash } from "./hash";
+
+export class EventraEngine {
+  private ts: TSService;
+  private graph = new DependencyGraph();
+
+  private fileEvents = new Map<string, Set<string>>();
+  private fileHash = new Map<string, string>();
+
+  constructor(root: string) {
+    this.ts = new TSService(root);
+  }
+
+  scanFile(file: string, content: string) {
+    const h = hash(content);
+
+    if (this.fileHash.get(file) === h) {
+      return this.fileEvents.get(file) ?? new Set();
+    }
+
+    this.fileHash.set(file, h);
+
+    this.ts.updateFile(file, content);
+
+    const source = this.ts.getSourceFile(file);
+    const checker = this.ts.getChecker();
+
+    if (!source || !checker) return new Set();
+
+    this.graph.update(file, source);
+
+    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);
+    this.fileHash.delete(file);
+  }
+}

package/src/engine/graph.ts

@@ -0,0 +1,23 @@
+import ts from "typescript";
+
+export class DependencyGraph {
+  private reverse = new Map<string, Set<string>>();
+
+  update(file: string, source: ts.SourceFile) {
+    for (const stmt of source.statements) {
+      if (!ts.isImportDeclaration(stmt)) continue;
+
+      const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+
+      if (!this.reverse.has(module)) {
+        this.reverse.set(module, new Set());
+      }
+
+      this.reverse.get(module)!.add(file);
+    }
+  }
+
+  getDependents(file: string) {
+    return [...(this.reverse.get(file) ?? [])];
+  }
+}

package/src/engine/hash.ts

@@ -0,0 +1,5 @@
+import crypto from "crypto";
+
+export function hash(content: string) {
+  return crypto.createHash("md5").update(content).digest("hex");
+}

package/src/engine/languageService.ts

@@ -0,0 +1,73 @@
+import ts from "typescript";
+import fs from "fs";
+
+export class TSService {
+  private files = new Map<string, { version: number; content: string }>();
+  private service: ts.LanguageService;
+
+  constructor(private root: string) {
+    const host: ts.LanguageServiceHost = {
+      getScriptFileNames: () => [...this.files.keys()],
+      getScriptVersion: (file) =>
+        this.files.get(file)?.version.toString() ?? "0",
+      getScriptSnapshot: (file) => {
+        const f = this.files.get(file);
+
+        if (f) {
+          return ts.ScriptSnapshot.fromString(f.content);
+        }
+
+        if (fs.existsSync(file)) {
+          return ts.ScriptSnapshot.fromString(
+            fs.readFileSync(file, "utf-8" as BufferEncoding)
+          );
+        }
+
+        return undefined;
+      },
+      getCurrentDirectory: () => this.root,
+      getCompilationSettings: () => ({
+        allowJs: true,
+        jsx: ts.JsxEmit.Preserve,
+        moduleResolution: ts.ModuleResolutionKind.Node16,
+        target: ts.ScriptTarget.ESNext,
+        esModuleInterop: true,
+        allowSyntheticDefaultImports: true,
+      }),
+      getDefaultLibFileName: (opts) => ts.getDefaultLibFilePath(opts),
+
+      readFile: (fileName: string, encoding?: string) => {
+        try {
+          return fs.readFileSync(fileName, encoding as BufferEncoding);
+        } catch (err) {
+          return undefined;
+        }
+      },
+
+      fileExists: fs.existsSync,
+    };
+
+    this.service = ts.createLanguageService(host);
+  }
+
+  updateFile(file: string, content: string) {
+    const prev = this.files.get(file);
+
+    this.files.set(file, {
+      content,
+      version: prev ? prev.version + 1 : 1,
+    });
+  }
+
+  getProgram() {
+    return this.service.getProgram();
+  }
+
+  getChecker() {
+    return this.getProgram()?.getTypeChecker();
+  }
+
+  getSourceFile(file: string) {
+    return this.getProgram()?.getSourceFile(file);
+  }
+}