@eventra_dev/eventra-cli 0.2.4 → 0.3.2

package/src/commands/init.ts

@@ -1,174 +0,0 @@
-import chalk from "chalk";
-import inquirer from "inquirer";
-
-import { saveConfig } from "../utils/config";
-import {ComponentWrapper, FunctionWrapper} from "../types";
-
-export async function init() {
-  console.log(
-    chalk.blue("Initializing Eventra...")
-  );
-
-  // API KEY ENDPOINT
-  const { apiKey, endpoint } =
-    await inquirer.prompt([
-      {
-        type: "input",
-        name: "apiKey",
-        message:
-          "API Key (optional):"
-      },
-      {
-        type: "input",
-        name: "endpoint",
-        message: "Custom endpoint (optional):",
-        default: "https://api.eventra.dev/api/v1/cli/events"
-      }
-    ]);
-
-  console.log(
-    chalk.gray(
-      "\nEventra automatically detects:"
-    )
-  );
-
-  console.log(
-    chalk.gray("• track('event')")
-  );
-
-  console.log(
-    chalk.gray(
-      "• tracker.track('event')"
-    )
-  );
-
-  const wrappers: ComponentWrapper[] = [];
-  const functionWrappers: FunctionWrapper[] = [];
-
-
-  // COMPONENT WRAPPERS
-  console.log(
-    chalk.blue(
-      "\nComponent wrappers"
-    )
-  );
-
-  let addComponent = true;
-
-  while (addComponent) {
-    const { useWrapper } =
-      await inquirer.prompt([
-        {
-          type: "confirm",
-          name: "useWrapper",
-          message:
-            "Add component wrapper?",
-          default: false
-        }
-      ]);
-
-    if (!useWrapper) break;
-
-    const { name, prop } =
-      await inquirer.prompt([
-        {
-          type: "input",
-          name: "name",
-          message: "Component name:",
-          validate: (v) =>
-            v ? true : "Required"
-        },
-        {
-          type: "input",
-          name: "prop",
-          message:
-            "Event prop:",
-          default: "event"
-        }
-      ]);
-
-    wrappers.push({
-      name,
-      prop
-    });
-  }
-
-  // FUNCTION WRAPPERS
-  console.log(
-    chalk.blue(
-      "\nFunction wrappers"
-    )
-  );
-
-  let addFunction = true;
-
-  while (addFunction) {
-    const { useWrapper } =
-      await inquirer.prompt([
-        {
-          type: "confirm",
-          name: "useWrapper",
-          message:
-            "Add function wrapper?",
-          default: false
-        }
-      ]);
-
-    if (!useWrapper) break;
-
-    const { name, event } =
-      await inquirer.prompt([
-        {
-          type: "input",
-          name: "name",
-          message:
-            "Function name:"
-        },
-        {
-          type: "input",
-          name: "event",
-          message:
-            "Event field (leave empty if string argument):",
-          default: ""
-        }
-      ]);
-
-    functionWrappers.push({
-      name,
-      event: event || undefined
-    });
-  }
-
-  const config = {
-    apiKey,
-    endpoint,
-    events: [],
-    wrappers,
-    functionWrappers,
-    sync: {
-      include: [
-        "**/*.{ts,tsx,js,jsx,vue,svelte,astro}"
-      ],
-      exclude: [
-        "node_modules",
-        "dist",
-        ".next",
-        ".git"
-      ]
-    }
-  };
-
-  await saveConfig(config);
-
-  console.log(
-    chalk.green(
-      "\neventra.json created"
-    )
-  );
-
-  console.log(
-    chalk.gray(
-      "\nRun `eventra sync`"
-    )
-  );
-}

package/src/commands/send.ts

@@ -1,213 +0,0 @@
-import chalk from "chalk";
-import inquirer from "inquirer";
-import {
-  loadConfig,
-  saveConfig
-} from "../utils/config";
-
-import pkg from "../../package.json";
-
-const CLI_VERSION = pkg.version;
-
-export async function send() {
-  const config = await loadConfig();
-
-  const endpoint =
-    config?.endpoint ||
-    process.env.EVENTRA_ENDPOINT;
-
-  if (!config) {
-    console.log(
-      chalk.red(
-        "eventra.json not found. Run 'eventra init'"
-      )
-    );
-    return;
-  }
-
-  let apiKey = config.apiKey;
-
-  // ask api key
-  if (!apiKey) {
-    const answers =
-      await inquirer.prompt([
-        {
-          type: "input",
-          name: "apiKey",
-          message:
-            "Enter your API key:"
-        }
-      ]);
-
-    apiKey = answers.apiKey;
-
-    config.apiKey = apiKey;
-
-    await saveConfig(config);
-
-    console.log(
-      chalk.green("API key saved")
-    );
-  }
-
-  // no events
-  if (!config.events?.length) {
-    console.log(
-      chalk.yellow(
-        "No events found. Run 'eventra sync'"
-      )
-    );
-    return;
-  }
-
-  if (!apiKey) {
-    console.log(
-      chalk.red("API key required")
-    );
-    return;
-  }
-
-  if (!endpoint) {
-    console.log(
-      chalk.red("Endpoint not configured")
-    );
-    return;
-  }
-
-  console.log("");
-  console.log(
-    chalk.blue(
-      `Sending ${config.events.length} events...`
-    )
-  );
-
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 10000);
-
-  try {
-    const res = await fetch(
-      endpoint,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type":
-            "application/json",
-          "x-api-key": apiKey
-        },
-        body: JSON.stringify({
-          events: config.events,
-          cli: {
-            name:
-              "@eventra_dev/eventra-cli",
-            version: CLI_VERSION,
-            runtime: "node"
-          }
-        }),
-        signal: controller.signal
-      },
-    );
-
-    if (!res.ok) {
-      console.log(
-        chalk.red(
-          `Request failed (${res.status})`
-        )
-      );
-
-      try {
-        const text =
-          await res.text();
-
-        console.log(
-          chalk.gray(text)
-        );
-      } catch {}
-
-      return;
-    }
-
-    const data =
-      await res.json();
-
-    console.log(
-      chalk.green(
-        "Events registered successfully"
-      )
-    );
-
-    // created
-    if (data.created?.length) {
-      console.log(
-        chalk.green("\nNew events:")
-      );
-
-      data.created.forEach(
-        (e: string) =>
-          console.log(
-            chalk.green(
-              `+ ${e}`
-            )
-          )
-      );
-    }
-
-    // existing
-    if (data.existing?.length) {
-      console.log(
-        chalk.gray(
-          "\nExisting events:"
-        )
-      );
-
-      data.existing.forEach(
-        (e: string) =>
-          console.log(
-            chalk.gray(
-              `• ${e}`
-            )
-          )
-      );
-    }
-
-    // processing notice
-    if (data.created?.length) {
-      console.log("");
-      console.log(
-        chalk.yellow(
-          "Events queued for processing (~2 min)"
-        )
-      );
-
-      console.log(
-        chalk.gray(
-          "They will appear in dashboard shortly"
-        )
-      );
-    }
-
-    console.log("");
-
-    console.log(
-      chalk.gray(
-        `Sent ${config.events.length} events`
-      )
-    );
-
-  } catch (err) {
-    console.log(
-      chalk.red(
-        "Network error"
-      )
-    );
-
-    if (err instanceof Error) {
-      console.log(
-        chalk.gray(
-          err.message
-        )
-      );
-    }
-  } finally {
-    clearTimeout(timeout);
-  }
-}

package/src/commands/sync.ts

@@ -1,106 +0,0 @@
-import fg from "fast-glob";
-import fs from "fs/promises";
-import chalk from "chalk";
-import path from "path";
-
-import { loadConfig, saveConfig } from "../utils/config";
-import { EventraEngine } from "../engine/engine";
-import { processFile } from "../utils/processFile";
-import { getVirtualFile } from "../utils/getVirtualFile";
-
-export async function sync() {
-  const config = await loadConfig();
-  if (!config) return;
-
-  console.log(chalk.blue("Scanning..."));
-
-  const files = await fg(config.sync.include, {
-    ignore: config.sync.exclude,
-    absolute: true,
-  });
-
-  const engine = new EventraEngine(process.cwd());
-
-  const cache = new Map<string, { content: string; deps: string[] }>();
-  const toScan = new Set<string>();
-
-  // COLLECT
-  for (const file of files) {
-    try {
-      const raw = await fs.readFile(file, "utf-8");
-      if (raw.length > 2_000_000) continue;
-
-      const parsed = processFile(file, raw);
-
-      cache.set(file, parsed);
-      toScan.add(file);
-
-      parsed.deps.forEach(dep => toScan.add(path.resolve(dep)));
-
-    } catch {}
-  }
-
-  // PRELOAD
-  for (const file of toScan) {
-    try {
-      let parsed = cache.get(file);
-
-      if (!parsed) {
-        const raw = await fs.readFile(file, "utf-8");
-        parsed = processFile(file, raw);
-        cache.set(file, parsed);
-      }
-
-      engine.preloadFile(getVirtualFile(file), parsed.content);
-
-    } catch {}
-  }
-
-  // SCAN
-  const detectedFn = new Set<string>();
-  const detectedCmp = new Map<string, string>();
-
-  for (const file of toScan) {
-    try {
-      const parsed = cache.get(file);
-      if (!parsed) continue;
-
-      const res = engine.scanFile(
-        getVirtualFile(file),
-        parsed.content,
-        config
-      );
-
-      res.detectedFunctionWrappers.forEach(w => detectedFn.add(w));
-      res.detectedComponentWrappers.forEach((v, k) => detectedCmp.set(k, v));
-
-    } catch {}
-  }
-
-  // RESULT
-  const events = engine.getAllEvents().sort();
-
-  config.events = events;
-
-  config.functionWrappers = mergeUnique(
-    config.functionWrappers ?? [],
-    [...detectedFn].map(name => ({ name })),
-    w => w.name
-  );
-
-  config.wrappers = mergeUnique(
-    config.wrappers ?? [],
-    [...detectedCmp.entries()].map(([name, prop]) => ({ name, prop })),
-    w => `${w.name}:${w.prop}`
-  );
-
-  await saveConfig(config);
-
-  console.log(chalk.green(`Found ${events.length} events`));
-}
-
-function mergeUnique<T>(a: T[], b: T[], key: (v: T) => string): T[] {
-  const map = new Map<string, T>();
-  [...b, ...a].forEach(item => map.set(key(item), item));
-  return [...map.values()];
-}

package/src/commands/watch.ts

@@ -1,144 +0,0 @@
-import chokidar from "chokidar";
-import chalk from "chalk";
-import fs from "fs/promises";
-import fg from "fast-glob";
-import path from "path";
-
-import { loadConfig, saveConfig } from "../utils/config";
-import { EventraEngine } from "../engine/engine";
-import { processFile } from "../utils/processFile";
-import { getVirtualFile } from "../utils/getVirtualFile";
-
-export async function watch() {
-  const config = await loadConfig();
-  if (!config) return;
-
-  console.log(chalk.blue("Watching...\n"));
-
-  const engine = new EventraEngine(process.cwd());
-  const fileDeps = new Map<string, Set<string>>();
-  const cache = new Map<string, { content: string; deps: string[] }>();
-  const watchedDeps = new Set<string>();
-
-  const normalize = (f: string) =>
-    path.resolve(f).replace(/\\/g, "/");
-
-  // INITIAL LOAD
-  const files = await fg(config.sync.include, {
-    ignore: config.sync.exclude,
-    absolute: true,
-  });
-
-  for (const file of files) {
-    try {
-      const abs = normalize(file);
-      const raw = await fs.readFile(abs, "utf-8");
-
-      const parsed = processFile(abs, raw);
-
-      cache.set(abs, parsed);
-
-      engine.preloadFile(getVirtualFile(abs), parsed.content);
-      engine.updateFile(getVirtualFile(abs), parsed.content, config);
-
-      fileDeps.set(abs, new Set(parsed.deps.map(d => normalize(d))));
-
-    } catch {}
-  }
-
-  config.events = engine.getAllEvents().sort();
-  await saveConfig(config);
-
-  console.log(chalk.gray(`Initial: ${config.events.length}\n`));
-
-  // WATCHER
-  const watcher = chokidar.watch(
-    [...files.map(normalize), ...watchedDeps],
-    { ignoreInitial: true }
-  );
-
-  const queue = new Map<string, boolean>();
-  let timer: NodeJS.Timeout | null = null;
-
-  const run = async () => {
-    const batch = [...queue.keys()];
-    queue.clear();
-
-    for (const file of batch) {
-      try {
-        const raw = await fs.readFile(file, "utf-8");
-        const parsed = processFile(file, raw);
-
-        cache.set(file, parsed);
-
-        engine.updateFile(
-          getVirtualFile(file),
-          parsed.content,
-          config
-        );
-
-        //dependency diff
-        const abs = normalize(file);
-
-        const prevDeps = fileDeps.get(abs) ?? new Set();
-        const nextDeps = new Set(parsed.deps.map(d => normalize(d)));
-
-        // add new deps
-        for (const dep of nextDeps) {
-          if (!prevDeps.has(dep)) {
-            watcher.add(dep);
-            watchedDeps.add(dep);
-          }
-        }
-
-        // remove old deps
-        for (const dep of prevDeps) {
-          if (!nextDeps.has(dep)) {
-            watcher.unwatch(dep);
-            watchedDeps.delete(dep);
-          }
-        }
-
-        fileDeps.set(abs, nextDeps);
-
-      } catch {
-        console.log(chalk.gray(`skip: ${file}`));
-      }
-    }
-
-    const next = engine.getAllEvents().sort();
-    config.events = next;
-
-    await saveConfig(config);
-
-    console.log(chalk.green(`Updated: ${next.length}`));
-  };
-
-  const schedule = (file: string) => {
-    const abs = normalize(file);
-    queue.set(abs, true);
-
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(run, 200);
-  };
-
-  watcher
-    .on("change", schedule)
-    .on("add", schedule)
-    .on("unlink", async (file) => {
-      const abs = normalize(file);
-
-      engine.removeFile(getVirtualFile(abs), config);
-
-      const next = engine.getAllEvents().sort();
-      config.events = next;
-      await saveConfig(config);
-
-      console.log(chalk.red(`Removed → ${next.length}`));
-    });
-
-  process.on("SIGINT", async () => {
-    await watcher.close();
-    process.exit(0);
-  });
-}

package/src/engine/boundary.ts

@@ -1,12 +0,0 @@
-import path from "path";
-
-export function isExternalFile(file: string) {
-  const normalized = path.resolve(file);
-
-  return (
-    normalized.includes(`${path.sep}node_modules${path.sep}`) ||
-    normalized.includes(`${path.sep}dist${path.sep}`) ||
-    normalized.includes(`${path.sep}build${path.sep}`) ||
-    normalized.endsWith(".d.ts")
-  );
-}

package/src/engine/callResolver.ts

@@ -1,65 +0,0 @@
-import ts from "typescript";
-
-function isFn(node: ts.Node): node is ts.FunctionLikeDeclaration {
-  return (
-    ts.isFunctionDeclaration(node) ||
-    ts.isMethodDeclaration(node) ||
-    ts.isFunctionExpression(node) ||
-    ts.isArrowFunction(node)
-  );
-}
-
-function resolveFromSymbol(
-  symbol: ts.Symbol,
-  checker: ts.TypeChecker,
-  seen = new Set<ts.Symbol>()
-): ts.FunctionLikeDeclaration | null {
-  if (seen.has(symbol)) return null;
-  seen.add(symbol);
-
-  if (symbol.flags & ts.SymbolFlags.Alias) {
-    return resolveFromSymbol(checker.getAliasedSymbol(symbol), checker, seen);
-  }
-
-  for (const d of symbol.getDeclarations() ?? []) {
-    if (isFn(d)) return d;
-
-    if (ts.isVariableDeclaration(d) && d.initializer) {
-      if (isFn(d.initializer)) return d.initializer;
-
-      const s = checker.getSymbolAtLocation(d.initializer);
-      if (s) {
-        const r = resolveFromSymbol(s, checker, seen);
-        if (r) return r;
-      }
-    }
-  }
-
-  return null;
-}
-
-export function resolveFunctionFromCall(
-  expr: ts.Expression,
-  checker: ts.TypeChecker
-): ts.FunctionLikeDeclaration | null {
-  // foo.bar()
-  if (ts.isPropertyAccessExpression(expr)) {
-    const s = checker.getSymbolAtLocation(expr.name);
-    if (s) {
-      const r = resolveFromSymbol(s, checker);
-      if (r) return r;
-    }
-  }
-
-  // direct call
-  const type = checker.getTypeAtLocation(expr);
-  for (const sig of type.getCallSignatures()) {
-    const d = sig.getDeclaration();
-    if (d && isFn(d)) return d;
-  }
-
-  const s = checker.getSymbolAtLocation(expr);
-  if (s) return resolveFromSymbol(s, checker);
-
-  return null;
-}