@eventra_dev/eventra-cli 0.1.1 → 0.1.2

package/dist/engine/callResolver.js

@@ -1,31 +1,34 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveFunctionFromCall = resolveFunctionFromCall;
-const ts_morph_1 = require("ts-morph");
-function resolveFunctionFromCall(expr) {
-    let symbol = expr.getSymbol();
-    if (!symbol && ts_morph_1.Node.isPropertyAccessExpression(expr)) {
-        symbol = expr.getNameNode().getSymbol();
+const typescript_1 = __importDefault(require("typescript"));
+function resolveFunctionFromCall(expr, checker) {
+    let symbol = checker.getSymbolAtLocation(expr);
+    if (!symbol && typescript_1.default.isPropertyAccessExpression(expr)) {
+        symbol = checker.getSymbolAtLocation(expr.name);
     }
     if (!symbol)
         return null;
-    const decls = symbol.getDeclarations() ?? [];
-    for (const d of decls) {
-        if (ts_morph_1.Node.isFunctionDeclaration(d))
-            return d;
-        if (ts_morph_1.Node.isVariableDeclaration(d)) {
-            const init = d.getInitializer();
-            if (init &&
-                (ts_morph_1.Node.isArrowFunction(init) ||
-                    ts_morph_1.Node.isFunctionExpression(init))) {
+    if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
+        symbol = checker.getAliasedSymbol(symbol);
+    }
+    for (const decl of symbol.getDeclarations() ?? []) {
+        if (typescript_1.default.isFunctionDeclaration(decl) ||
+            typescript_1.default.isMethodDeclaration(decl) ||
+            typescript_1.default.isFunctionExpression(decl) ||
+            typescript_1.default.isArrowFunction(decl)) {
+            return decl;
+        }
+        if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
+            const init = decl.initializer;
+            if (typescript_1.default.isArrowFunction(init) ||
+                typescript_1.default.isFunctionExpression(init)) {
                 return init;
             }
         }
-        if (ts_morph_1.Node.isMethodDeclaration(d))
-            return d;
-        if (ts_morph_1.Node.isFunctionExpression(d) || ts_morph_1.Node.isArrowFunction(d)) {
-            return d;
-        }
     }
     return null;
 }

package/dist/engine/engine.js

@@ -1,17 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventraEngine = void 0;
-const project_1 = require("./project");
+const languageService_1 = require("./languageService");
 const scanner_1 = require("./scanner");
+const graph_1 = require("./graph");
+const hash_1 = require("./hash");
 class EventraEngine {
-    project;
+    ts;
+    graph = new graph_1.DependencyGraph();
     fileEvents = new Map();
-    constructor(entry) {
-        this.project = new project_1.ProjectGraph(entry);
+    fileHash = new Map();
+    constructor(root) {
+        this.ts = new languageService_1.TSService(root);
     }
     scanFile(file, content) {
-        const source = this.project.getSource(file, content);
-        const checker = this.project.getChecker();
+        const h = (0, hash_1.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 = (0, scanner_1.scanSource)(source, checker);
         this.fileEvents.set(file, events);
         return events;
@@ -28,6 +41,7 @@ class EventraEngine {
     }
     removeFile(file) {
         this.fileEvents.delete(file);
+        this.fileHash.delete(file);
     }
 }
 exports.EventraEngine = EventraEngine;

package/dist/engine/graph.js

@@ -1,18 +1,21 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DependencyGraph = void 0;
+const typescript_1 = __importDefault(require("typescript"));
 class DependencyGraph {
     reverse = new Map();
     update(file, source) {
-        const imports = source
-            .getImportDeclarations()
-            .map(i => i.getModuleSpecifierSourceFile()?.getFilePath())
-            .filter(Boolean);
-        for (const dep of imports) {
-            if (!this.reverse.has(dep)) {
-                this.reverse.set(dep, new Set());
+        for (const stmt of source.statements) {
+            if (!typescript_1.default.isImportDeclaration(stmt))
+                continue;
+            const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+            if (!this.reverse.has(module)) {
+                this.reverse.set(module, new Set());
             }
-            this.reverse.get(dep).add(file);
+            this.reverse.get(module).add(file);
         }
     }
     getDependents(file) {

package/dist/engine/hash.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hash = hash;
+const crypto_1 = __importDefault(require("crypto"));
+function hash(content) {
+    return crypto_1.default.createHash("md5").update(content).digest("hex");
+}

package/dist/engine/languageService.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSService = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const fs_1 = __importDefault(require("fs"));
+class TSService {
+    root;
+    files = new Map();
+    service;
+    constructor(root) {
+        this.root = root;
+        const host = {
+            getScriptFileNames: () => [...this.files.keys()],
+            getScriptVersion: (file) => this.files.get(file)?.version.toString() ?? "0",
+            getScriptSnapshot: (file) => {
+                const f = this.files.get(file);
+                if (f) {
+                    return typescript_1.default.ScriptSnapshot.fromString(f.content);
+                }
+                if (fs_1.default.existsSync(file)) {
+                    return typescript_1.default.ScriptSnapshot.fromString(fs_1.default.readFileSync(file, "utf-8"));
+                }
+                return undefined;
+            },
+            getCurrentDirectory: () => this.root,
+            getCompilationSettings: () => ({
+                allowJs: true,
+                jsx: typescript_1.default.JsxEmit.Preserve,
+                moduleResolution: typescript_1.default.ModuleResolutionKind.Node16,
+                target: typescript_1.default.ScriptTarget.ESNext,
+                esModuleInterop: true,
+                allowSyntheticDefaultImports: true,
+            }),
+            getDefaultLibFileName: (opts) => typescript_1.default.getDefaultLibFilePath(opts),
+            readFile: (fileName, encoding) => {
+                try {
+                    return fs_1.default.readFileSync(fileName, encoding);
+                }
+                catch (err) {
+                    return undefined;
+                }
+            },
+            fileExists: fs_1.default.existsSync,
+        };
+        this.service = typescript_1.default.createLanguageService(host);
+    }
+    updateFile(file, content) {
+        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) {
+        return this.getProgram()?.getSourceFile(file);
+    }
+}
+exports.TSService = TSService;

package/dist/engine/resolver.js

@@ -1,36 +1,67 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveNodeValue = resolveNodeValue;
-const ts_morph_1 = require("ts-morph");
+const typescript_1 = __importDefault(require("typescript"));
 function resolveNodeValue(node, checker) {
-    if (!ts_morph_1.Node.isIdentifier(node))
-        return null;
-    const symbol = checker.getSymbolAtLocation(node.compilerNode);
-    if (!symbol)
-        return null;
-    const decls = symbol.getDeclarations() ?? [];
-    for (const d of decls) {
-        if (ts_morph_1.ts.isVariableDeclaration(d) && d.initializer) {
-            const init = d.initializer;
-            if (ts_morph_1.ts.isStringLiteral(init)) {
-                return { values: [init.text], dynamic: false };
-            }
-            if (ts_morph_1.ts.isNoSubstitutionTemplateLiteral(init)) {
-                return { values: [init.text], dynamic: false };
+    if (typescript_1.default.isStringLiteral(node)) {
+        return { values: [node.text], dynamic: false };
+    }
+    if (typescript_1.default.isTemplateExpression(node)) {
+        let result = node.head.text;
+        for (const span of node.templateSpans) {
+            result += "*";
+            result += span.literal.text;
+        }
+        return { values: [result], dynamic: true };
+    }
+    if (typescript_1.default.isConditionalExpression(node)) {
+        const a = resolveNodeValue(node.whenTrue, checker);
+        const b = resolveNodeValue(node.whenFalse, checker);
+        return {
+            values: [...new Set([...(a?.values ?? []), ...(b?.values ?? [])])],
+            dynamic: true,
+        };
+    }
+    if (typescript_1.default.isIdentifier(node)) {
+        let symbol = checker.getSymbolAtLocation(node);
+        if (!symbol)
+            return null;
+        if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
+            symbol = checker.getAliasedSymbol(symbol);
+        }
+        for (const decl of symbol.getDeclarations() ?? []) {
+            if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
+                return resolveNodeValue(decl.initializer, checker);
             }
-            if (ts_morph_1.ts.isTemplateExpression(init)) {
-                let result = init.head.text;
-                for (const span of init.templateSpans) {
-                    result += "*";
-                    result += span.literal.text;
+            if (typescript_1.default.isEnumMember(decl) && decl.initializer) {
+                if (typescript_1.default.isStringLiteral(decl.initializer)) {
+                    return {
+                        values: [decl.initializer.text],
+                        dynamic: false,
+                    };
                 }
-                return { values: [result], dynamic: true };
             }
         }
-        if (ts_morph_1.ts.isParameter(d) && d.initializer) {
-            const init = d.initializer;
-            if (ts_morph_1.ts.isStringLiteral(init)) {
-                return { values: [init.text], dynamic: false };
+    }
+    if (typescript_1.default.isPropertyAccessExpression(node)) {
+        const symbol = checker.getSymbolAtLocation(node);
+        if (symbol) {
+            let s = symbol;
+            if (s.flags & typescript_1.default.SymbolFlags.Alias) {
+                s = checker.getAliasedSymbol(s);
+            }
+            for (const decl of s.getDeclarations() ?? []) {
+                if (typescript_1.default.isEnumMember(decl) && decl.initializer) {
+                    if (typescript_1.default.isStringLiteral(decl.initializer)) {
+                        return {
+                            values: [decl.initializer.text],
+                            dynamic: false,
+                        };
+                    }
+                }
             }
         }
     }

package/dist/engine/scanner.js

@@ -1,78 +1,50 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanSource = scanSource;
-const ts_morph_1 = require("ts-morph");
-const extract_1 = require("./extract");
+const typescript_1 = __importDefault(require("typescript"));
+const resolver_1 = require("./resolver");
 const callResolver_1 = require("./callResolver");
-const flow_1 = require("./flow");
-function getCallName(expr) {
-    if (ts_morph_1.Node.isIdentifier(expr))
-        return expr.getText();
-    if (ts_morph_1.Node.isPropertyAccessExpression(expr))
-        return expr.getName();
-    return expr.getText();
-}
-function isTrackLike(name) {
-    return /(track|trackFeature)/i.test(name);
-}
-function pickArg(args) {
-    return (args.find(ts_morph_1.Node.isStringLiteral) ??
-        args.find(ts_morph_1.Node.isTemplateExpression) ??
-        args.find(ts_morph_1.Node.isObjectLiteralExpression) ??
-        args[0]);
-}
-function scanSource(source, checker) {
+function scanSource(source, checker, visited = new Set()) {
     const events = new Set();
-    // CALLS
-    for (const call of source.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)) {
-        const expr = call.getExpression();
-        const name = getCallName(expr);
-        if (!isTrackLike(name))
-            continue;
-        const args = call.getArguments();
-        if (!args.length)
-            continue;
-        let target = pickArg(args);
-        const fn = (0, callResolver_1.resolveFunctionFromCall)(expr);
-        if (fn) {
-            const index = (0, flow_1.getForwardedParamIndex)(fn);
-            if (index !== null && args[index]) {
-                target = args[index];
+    if (visited.has(source.fileName))
+        return events;
+    visited.add(source.fileName);
+    function visit(node) {
+        if (typescript_1.default.isCallExpression(node)) {
+            const name = getCallName(node.expression);
+            if (/(track|event|capture|send)/i.test(name)) {
+                let target = node.arguments[0];
+                const fn = (0, callResolver_1.resolveFunctionFromCall)(node.expression, checker);
+                // 🔥 cross-file
+                if (fn) {
+                    const sf = fn.getSourceFile();
+                    if (!visited.has(sf.fileName)) {
+                        scanSource(sf, checker, visited).forEach(e => events.add(e));
+                    }
+                }
+                if (target) {
+                    const res = (0, resolver_1.resolveNodeValue)(target, checker);
+                    res?.values.forEach(v => {
+                        if (v && v.length > 1 && !v.includes(" ")) {
+                            events.add(v);
+                        }
+                    });
+                }
             }
         }
-        (0, extract_1.extractEventsFromArgs)([target], checker).forEach(({ value }) => {
-            if (isValid(value))
-                events.add(value);
-        });
-    }
-    // JSX
-    const jsx = [
-        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.JsxOpeningElement),
-        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.JsxSelfClosingElement),
-    ];
-    for (const el of jsx) {
-        for (const attr of el.getAttributes()) {
-            if (!ts_morph_1.Node.isJsxAttribute(attr))
-                continue;
-            const name = attr.getNameNode().getText();
-            if (!/(event|name|action)/i.test(name))
-                continue;
-            const init = attr.getInitializer();
-            if (!init)
-                continue;
-            const expr = ts_morph_1.Node.isJsxExpression(init)
-                ? init.getExpression()
-                : init;
-            if (!expr)
-                continue;
-            (0, extract_1.extractEventsFromArgs)([expr], checker).forEach(({ value }) => {
-                if (isValid(value))
-                    events.add(value);
-            });
-        }
+        typescript_1.default.forEachChild(node, visit);
     }
+    visit(source);
     return events;
 }
-function isValid(v) {
-    return !!v && v.length > 1 && !v.includes(" ");
+function getCallName(expr) {
+    if (typescript_1.default.isIdentifier(expr))
+        return expr.text;
+    if (typescript_1.default.isPropertyAccessExpression(expr)) {
+        return expr.name.text;
+    }
+    return "";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Eventra CLI",
   "type": "commonjs",
   "bin": {

package/src/engine/callResolver.ts

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

@@ -1,21 +1,41 @@
-import { ProjectGraph } from "./project";
+import { TSService } from "./languageService";
 import { scanSource } from "./scanner";
+import { DependencyGraph } from "./graph";
+import { hash } from "./hash";
 
 export class EventraEngine {
-  private project: ProjectGraph;
+  private ts: TSService;
+  private graph = new DependencyGraph();
+
   private fileEvents = new Map<string, Set<string>>();
+  private fileHash = new Map<string, string>();
 
-  constructor(entry: string) {
-    this.project = new ProjectGraph(entry);
+  constructor(root: string) {
+    this.ts = new TSService(root);
   }
 
   scanFile(file: string, content: string) {
-    const source = this.project.getSource(file, content);
-    const checker = this.project.getChecker();
+    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;
   }
 
@@ -35,5 +55,6 @@ export class EventraEngine {
 
   removeFile(file: string) {
     this.fileEvents.delete(file);
+    this.fileHash.delete(file);
   }
 }

package/src/engine/graph.ts

@@ -1,19 +1,19 @@
-import { SourceFile } from "ts-morph";
+import ts from "typescript";
 
 export class DependencyGraph {
   private reverse = new Map<string, Set<string>>();
 
-  update(file: string, source: SourceFile) {
-    const imports = source
-      .getImportDeclarations()
-      .map(i => i.getModuleSpecifierSourceFile()?.getFilePath())
-      .filter(Boolean) as string[];
+  update(file: string, source: ts.SourceFile) {
+    for (const stmt of source.statements) {
+      if (!ts.isImportDeclaration(stmt)) continue;
 
-    for (const dep of imports) {
-      if (!this.reverse.has(dep)) {
-        this.reverse.set(dep, new Set());
+      const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+
+      if (!this.reverse.has(module)) {
+        this.reverse.set(module, new Set());
       }
-      this.reverse.get(dep)!.add(file);
+
+      this.reverse.get(module)!.add(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);
+  }
+}