@eventra_dev/eventra-cli 0.2.4 → 0.3.1

package/src/engine/languageService.ts

@@ -1,197 +0,0 @@
-import ts from "typescript";
-import fs from "fs";
-import path from "path";
-
-export class TSService {
-  private files = new Map<string, { version: number; content: string }>();
-  private fileNames = new Set<string>();
-  private service: ts.LanguageService;
-
-  private compilerOptions: ts.CompilerOptions;
-  private baseUrl: string;
-  private paths: Record<string, string[]>;
-
-  constructor(private root: string) {
-    const configPath = ts.findConfigFile(
-      root,
-      ts.sys.fileExists,
-      "tsconfig.json"
-    );
-
-    let compilerOptions: ts.CompilerOptions = {
-      allowJs: true,
-      allowNonTsExtensions: true,
-      jsx: ts.JsxEmit.Preserve,
-      jsxImportSource: "react",
-      moduleResolution: ts.ModuleResolutionKind.Node16,
-      target: ts.ScriptTarget.ESNext,
-      esModuleInterop: true,
-      allowSyntheticDefaultImports: true,
-      skipLibCheck: true,
-    };
-
-    let baseUrl = root;
-    let paths: Record<string, string[]> = {};
-
-    if (configPath) {
-      const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-
-      const parsed = ts.parseJsonConfigFileContent(
-        configFile.config,
-        ts.sys,
-        root
-      );
-
-      compilerOptions = {
-        ...compilerOptions,
-        ...parsed.options,
-      };
-
-      paths = parsed.options.paths || {};
-      baseUrl = parsed.options.baseUrl
-        ? path.resolve(root, parsed.options.baseUrl)
-        : root;
-    }
-
-    this.compilerOptions = compilerOptions;
-    this.baseUrl = baseUrl;
-    this.paths = paths;
-
-    const allFiles = ts.sys.readDirectory(
-      root,
-      [".ts", ".tsx", ".js", ".jsx"],
-      undefined,
-      undefined
-    );
-
-    for (const f of allFiles) {
-      this.fileNames.add(this.normalize(f));
-    }
-
-    const host: ts.LanguageServiceHost = {
-      getScriptFileNames: () => {
-        return Array.from(this.fileNames);
-      },
-
-      getScriptVersion: (file) => {
-        file = this.normalize(file);
-        return this.files.get(file)?.version.toString() ?? "0";
-      },
-      getScriptKind: (fileName) => {
-        fileName = this.normalize(fileName);
-
-        if (fileName.endsWith(".tsx")) {
-          return ts.ScriptKind.TSX;
-        }
-
-        if (fileName.endsWith(".ts")) {
-          return ts.ScriptKind.TS;
-        }
-
-        if (fileName.endsWith(".jsx")) {
-          return ts.ScriptKind.JSX;
-        }
-
-        if (fileName.endsWith(".js")) {
-          return ts.ScriptKind.JS;
-        }
-
-        return ts.ScriptKind.Unknown;
-      },
-      getScriptSnapshot: (file) => {
-        file = this.normalize(file);
-        const f = this.files.get(file);
-        if (f) {
-          return ts.ScriptSnapshot.fromString(f.content);
-        }
-
-        try {
-          if (fs.existsSync(file)) {
-            const content = fs.readFileSync(file, "utf-8");
-
-            this.files.set(file, {
-              content,
-              version: 1,
-            });
-
-            this.fileNames.add(file);
-
-            return ts.ScriptSnapshot.fromString(content);
-          }
-        } catch {
-        }
-
-        return ts.ScriptSnapshot.fromString("");
-      },
-
-      getCurrentDirectory: () => this.root,
-      getCompilationSettings: () => this.compilerOptions,
-      getDefaultLibFileName: (opts) =>
-        ts.getDefaultLibFilePath(opts),
-
-      fileExists: (file) => {
-        file = this.normalize(file);
-        return this.files.has(file) || ts.sys.fileExists(file);
-      },
-
-      readFile: (file) => {
-        file = this.normalize(file);
-        return this.files.get(file)?.content ?? ts.sys.readFile(file);
-      },
-
-      readDirectory: ts.sys.readDirectory,
-    };
-
-    this.service = ts.createLanguageService(host);
-  }
-
-  private normalize(file: string) {
-    return path.resolve(file).replace(/\\/g, "/");
-  }
-
-  // PUBLIC API
-  updateFile(file: string, content: string) {
-    file = this.normalize(file);
-
-    const prev = this.files.get(file);
-
-    this.files.set(file, {
-      content,
-      version: prev ? prev.version + 1 : 1,
-    });
-
-    this.fileNames.add(file);
-  }
-
-  removeFile(file: string) {
-    file = this.normalize(file);
-
-    this.files.delete(file);
-    this.fileNames.delete(file);
-  }
-
-  getProgram() {
-    return this.service.getProgram();
-  }
-
-  getChecker() {
-    return this.getProgram()?.getTypeChecker();
-  }
-
-  getSourceFile(file: string) {
-    file = this.normalize(file);
-    return this.getProgram()?.getSourceFile(file);
-  }
-
-  getFileContent(file: string) {
-    file = this.normalize(file);
-    return this.files.get(file)?.content;
-  }
-
-  getModuleResolutionConfig() {
-    return {
-      baseUrl: this.baseUrl,
-      paths: this.paths,
-    };
-  }
-}

package/src/engine/resolver.ts

@@ -1,177 +0,0 @@
-import ts from "typescript";
-import { resolveExportedSymbol } from "./exportResolver";
-import { resolveFunctionFromCall } from "./callResolver";
-
-export type ResolveResult = {
-  values: string[];
-  dynamic: boolean;
-};
-
-export function resolveNodeValue(
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  paramMap?: Map<string, ts.Expression>,
-  seen = new Set<ts.Node>()
-): ResolveResult {
-  if (seen.has(node)) return { values: [], dynamic: true };
-  seen.add(node);
-
-  // param passthrough
-  if (ts.isIdentifier(node) && paramMap?.has(node.text)) {
-    return resolveNodeValue(paramMap.get(node.text)!, checker, paramMap, seen);
-  }
-
-  // string
-  if (ts.isStringLiteral(node)) {
-    return { values: [node.text], dynamic: false };
-  }
-
-  // template
-  if (ts.isTemplateExpression(node)) {
-    let results = node.head.text ? [node.head.text] : [""];
-    for (const span of node.templateSpans) {
-      const r = resolveNodeValue(span.expression, checker, paramMap, seen);
-      results = results.flatMap(s =>
-        r.values.length ? r.values.map(v => s + v) : [s + "*"]
-      );
-      results = results.map(s => s + span.literal.text);
-    }
-    return { values: results, dynamic: true };
-  }
-
-  // ternary
-  if (ts.isConditionalExpression(node)) {
-    const a = resolveNodeValue(node.whenTrue, checker, paramMap, seen);
-    const b = resolveNodeValue(node.whenFalse, checker, paramMap, seen);
-    return {
-      values: [...new Set([...a.values, ...b.values])],
-      dynamic: true,
-    };
-  }
-
-  // object (event/name priority)
-  if (ts.isObjectLiteralExpression(node)) {
-    for (const p of node.properties) {
-      if (ts.isPropertyAssignment(p)) {
-        const key = p.name.getText();
-        if (key === "event" || key === "name") {
-          return resolveNodeValue(p.initializer, checker, paramMap, seen);
-        }
-      }
-    }
-    const vals: string[] = [];
-    for (const p of node.properties) {
-      if (!ts.isPropertyAssignment(p)) continue;
-      const r = resolveNodeValue(p.initializer, checker, paramMap, seen);
-      vals.push(...r.values);
-    }
-    return { values: [...new Set(vals)], dynamic: true };
-  }
-
-  // array
-  if (ts.isArrayLiteralExpression(node)) {
-    const vals: string[] = [];
-    for (const el of node.elements) {
-      const r = resolveNodeValue(el, checker, paramMap, seen);
-      vals.push(...r.values);
-    }
-    return { values: [...new Set(vals)], dynamic: true };
-  }
-
-  // concat
-  if (ts.isBinaryExpression(node) &&
-    node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
-    const l = resolveNodeValue(node.left, checker, paramMap, seen);
-    const r = resolveNodeValue(node.right, checker, paramMap, seen);
-    return {
-      values: l.values.flatMap(a =>
-        r.values.length ? r.values.map(b => a + b) : [a + "*"]
-      ),
-      dynamic: true,
-    };
-  }
-
-  // identifier (const / enum)
-  if (ts.isIdentifier(node)) {
-    let s = checker.getSymbolAtLocation(node);
-    if (!s) return { values: [], dynamic: true };
-
-    s = resolveExportedSymbol(s, checker) ?? s;
-
-    for (const d of s.getDeclarations() ?? []) {
-      if (ts.isVariableDeclaration(d) && d.initializer) {
-        return resolveNodeValue(d.initializer, checker, paramMap, seen);
-      }
-      if (ts.isEnumMember(d) && d.initializer && ts.isStringLiteral(d.initializer)) {
-        return { values: [d.initializer.text], dynamic: false };
-      }
-    }
-    return { values: [], dynamic: true };
-  }
-
-  // PROPERTY ACCESS (OBJECT + ENUM)
-  if (ts.isPropertyAccessExpression(node)) {
-    const obj = node.expression;
-    const prop = node.name.text;
-
-    // object literal lookup
-    if (ts.isIdentifier(obj)) {
-      const sym = checker.getSymbolAtLocation(obj);
-      if (sym) {
-        const s = resolveExportedSymbol(sym, checker) ?? sym;
-        for (const d of s.getDeclarations() ?? []) {
-          if (
-            ts.isVariableDeclaration(d) &&
-            d.initializer &&
-            ts.isObjectLiteralExpression(d.initializer)
-          ) {
-            for (const p of d.initializer.properties) {
-              if (
-                ts.isPropertyAssignment(p) &&
-                p.name.getText() === prop
-              ) {
-                return resolveNodeValue(p.initializer, checker, paramMap, seen);
-              }
-            }
-          }
-        }
-      }
-    }
-
-    // enum fallback
-    const sym = checker.getSymbolAtLocation(node);
-    if (sym) {
-      let s = resolveExportedSymbol(sym, checker) ?? sym;
-      if (s.flags & ts.SymbolFlags.Alias) s = checker.getAliasedSymbol(s);
-      for (const d of s.getDeclarations() ?? []) {
-        if (ts.isEnumMember(d) && d.initializer && ts.isStringLiteral(d.initializer)) {
-          return { values: [d.initializer.text], dynamic: false };
-        }
-      }
-    }
-
-    return { values: [], dynamic: true };
-  }
-
-  // CALL (unwrap + dive into wrapper body)
-  if (ts.isCallExpression(node)) {
-    const vals: string[] = [];
-
-    // args
-    for (const a of node.arguments) {
-      const r = resolveNodeValue(a, checker, paramMap, seen);
-      vals.push(...r.values);
-    }
-
-    // dive into called function (wrapper support)
-    const fn = resolveFunctionFromCall(node.expression, checker);
-    if (fn?.body) {
-      const r = resolveNodeValue(fn.body, checker, paramMap, seen);
-      vals.push(...r.values);
-    }
-
-    return { values: [...new Set(vals)], dynamic: true };
-  }
-
-  return { values: [], dynamic: true };
-}

package/src/engine/scanner.ts

@@ -1,298 +0,0 @@
-import ts from "typescript";
-import { resolveNodeValue } from "./resolver";
-import { resolveFunctionFromCall } from "./callResolver";
-import { resolveExportedSymbol } from "./exportResolver";
-import { EventraConfig, ScanResult } from "../types";
-
-// HELPERS
-function isValidEvent(v: string) {
-  return (
-    v &&
-    v.length > 1 &&
-    v.length < 120 &&
-    !v.includes(" ") &&
-    /^[a-zA-Z0-9._:-]+$/.test(v)
-  );
-}
-
-function getCallName(expr: ts.Expression): string {
-  if (ts.isIdentifier(expr)) return expr.text;
-  if (ts.isPropertyAccessExpression(expr)) return expr.name.text;
-  return "";
-}
-
-function getJsxTagName(tag: ts.JsxTagNameExpression): string {
-  if (ts.isIdentifier(tag)) return tag.text;
-  if (ts.isPropertyAccessExpression(tag)) return tag.name.text;
-  return tag.getText();
-}
-
-function getJsxAttrName(name: ts.JsxAttributeName): string {
-  if (ts.isIdentifier(name)) return name.text;
-  if (ts.isJsxNamespacedName(name)) return name.name.text;
-  return "";
-}
-
-// MAIN
-export function scanSource(
-  source: ts.SourceFile,
-  checker: ts.TypeChecker,
-  config: EventraConfig,
-  visited = new Set<string>(),
-  inheritedParamMap?: Map<string, ts.Expression>,
-  wrapperCache = new Map<string, string | null>()
-): ScanResult {
-  const events = new Set<string>();
-  const detectedFunctionWrappers = new Set<string>();
-  const detectedComponentWrappers = new Map<string, string>();
-
-  if (visited.has(source.fileName)) {
-    return { events, detectedFunctionWrappers, detectedComponentWrappers };
-  }
-
-  visited.add(source.fileName);
-
-  // TRACK DETECTION
-  function isTrackCall(expr: ts.Expression) {
-    const name = getCallName(expr);
-
-    // direct track()
-    if (name === "track") {
-      return true;
-    }
-
-    // configured wrappers
-    if (
-      config.functionWrappers?.some(
-        w => w.name === name
-      )
-    ) {
-      return true;
-    }
-
-    // *.track()
-    return ts.isPropertyAccessExpression(expr) &&
-      expr.name.text === "track";
-
-
-  }
-
-  function extractTrackCall(
-    node: ts.CallExpression,
-    paramMap: Map<string, ts.Expression>
-  ) {
-    if (!isTrackCall(node.expression)) return;
-
-    const arg = node.arguments[0];
-    if (!arg) return;
-
-    const res = resolveNodeValue(arg, checker, paramMap);
-
-    for (const v of res.values) {
-      if (isValidEvent(v)) {
-        events.add(v);
-      }
-    }
-  }
-
-  // WRAPPER DETECTION
-  function isWrapperFunction(fn: ts.FunctionLikeDeclaration) {
-    let found = false;
-
-    function walk(n: ts.Node) {
-      if (found) return;
-
-      if (ts.isCallExpression(n) && isTrackCall(n.expression)) {
-        found = true;
-        return;
-      }
-
-      ts.forEachChild(n, walk);
-    }
-
-    if (fn.body) walk(fn.body);
-    return found;
-  }
-
-  // COMPONENT WRAPPER
-  function detectComponentWrapper(tag: ts.JsxTagNameExpression): string | null {
-    const tagName = getJsxTagName(tag);
-
-    if (wrapperCache.has(tagName)) {
-      return wrapperCache.get(tagName)!;
-    }
-
-    let symbol = checker.getSymbolAtLocation(tag);
-
-    if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
-      symbol = checker.getAliasedSymbol(symbol);
-    }
-
-    if (!symbol) {
-      wrapperCache.set(tagName, null);
-      return null;
-    }
-
-    symbol = resolveExportedSymbol(symbol, checker) ?? symbol;
-
-    for (const decl of symbol.getDeclarations() ?? []) {
-      let fn: ts.FunctionLikeDeclaration | null = null;
-
-      if (ts.isFunctionDeclaration(decl)) fn = decl;
-
-      if (
-        ts.isVariableDeclaration(decl) &&
-        decl.initializer &&
-        (ts.isArrowFunction(decl.initializer) ||
-          ts.isFunctionExpression(decl.initializer))
-      ) {
-        fn = decl.initializer;
-      }
-
-      if (!fn || !fn.body) continue;
-
-      let prop: string | null = null;
-
-      function walk(n: ts.Node) {
-        if (prop) return;
-
-        if (ts.isCallExpression(n) && isTrackCall(n.expression)) {
-          const arg = n.arguments[0];
-
-          if (ts.isPropertyAccessExpression(arg)) {
-            prop = arg.name.text;
-            return;
-          }
-        }
-
-        ts.forEachChild(n, walk);
-      }
-
-      walk(fn.body);
-
-      wrapperCache.set(tagName, prop);
-
-      if (prop) {
-        detectedComponentWrappers.set(tagName, prop);
-        return prop;
-      }
-    }
-
-    wrapperCache.set(tagName, null);
-    return null;
-  }
-
-  // VISITOR
-  function visit(node: ts.Node) {
-    // JSX
-    if (ts.isJsxSelfClosingElement(node) || ts.isJsxOpeningElement(node)) {
-      const tagName = getJsxTagName(node.tagName);
-
-      if (tagName[0] === tagName[0].toLowerCase()) {
-        ts.forEachChild(node, visit);
-        return;
-      }
-
-      let wrapper = config.wrappers.find(w => w.name === tagName);
-
-      if (!wrapper) {
-        const prop = detectComponentWrapper(node.tagName);
-        if (prop) wrapper = { name: tagName, prop };
-      }
-
-      if (wrapper) {
-        for (const attr of node.attributes.properties) {
-          if (!ts.isJsxAttribute(attr)) continue;
-
-          const name = getJsxAttrName(attr.name);
-          if (name !== wrapper.prop) continue;
-
-          if (!attr.initializer) continue;
-
-          if (ts.isStringLiteral(attr.initializer)) {
-            if (isValidEvent(attr.initializer.text)) {
-              events.add(attr.initializer.text);
-            }
-          }
-
-          if (ts.isJsxExpression(attr.initializer)) {
-            const expr = attr.initializer.expression;
-            if (!expr) continue;
-
-            const res = resolveNodeValue(expr, checker);
-            res.values.forEach(v => {
-              if (isValidEvent(v)) events.add(v);
-            });
-          }
-        }
-      }
-
-      ts.forEachChild(node, visit);
-      return;
-    }
-
-    // CALL
-    if (ts.isCallExpression(node)) {
-      const resolvedFn = resolveFunctionFromCall(node.expression, checker);
-
-      const paramMap = new Map(inheritedParamMap ?? []);
-
-      if (resolvedFn) {
-        resolvedFn.parameters.forEach((p, i) => {
-          const arg = node.arguments[i];
-          if (!arg) return;
-
-          if (ts.isIdentifier(p.name)) {
-            paramMap.set(p.name.text, arg);
-          }
-        });
-      }
-
-      extractTrackCall(node, paramMap);
-
-      if (resolvedFn && isWrapperFunction(resolvedFn)) {
-        const name = getCallName(node.expression);
-
-        if (name && name !== "track") {
-          detectedFunctionWrappers.add(name);
-        }
-
-        if (resolvedFn.body) {
-          visit(resolvedFn.body);
-        }
-      }
-
-      if (resolvedFn && resolvedFn.body) {
-        const sf = resolvedFn.getSourceFile();
-
-        if (!visited.has(sf.fileName)) {
-          const res = scanSource(
-            sf,
-            checker,
-            config,
-            visited,
-            paramMap,
-            wrapperCache
-          );
-
-          res.events.forEach(e => events.add(e));
-        }
-      }
-
-      node.arguments.forEach(visit);
-      visit(node.expression);
-
-      return;
-    }
-
-    ts.forEachChild(node, visit);
-  }
-
-  visit(source);
-
-  return {
-    events,
-    detectedFunctionWrappers,
-    detectedComponentWrappers,
-  };
-}

package/src/index.ts

@@ -1,49 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from "commander";
-
-const program = new Command();
-
-program
-  .name("eventra")
-  .description("Eventra CLI")
-  .version("0.0.1");
-
-program
-  .command("init")
-  .action(async () => {
-    const { init } = await import("./commands/init");
-    await init();
-  });
-
-program
-  .command("sync")
-  .action(async () => {
-    const { sync } = await import("./commands/sync");
-    await sync();
-  });
-
-program
-  .command("check")
-  .option("--fix", "auto fix issues")
-  .action(async (opts) => {
-    const { check } = await import("./commands/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")
-  .action(async () => {
-    const { send } = await import("./commands/send");
-    await send();
-  });
-
-program.parse();