@eventra_dev/eventra-cli 0.3.6 → 0.3.10

package/dist/analysis/sdk/isEventraTrackCall.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEventraSdkTrackCall = isEventraSdkTrackCall;
+const typescript_1 = __importDefault(require("typescript"));
+const eventraSdk_1 = require("./eventraSdk");
+function isTrackCallee(expr) {
+    if (typescript_1.default.isPropertyAccessExpression(expr) || typescript_1.default.isPropertyAccessChain(expr)) {
+        return expr.name.text === "track";
+    }
+    if (typescript_1.default.isElementAccessExpression(expr) &&
+        expr.argumentExpression &&
+        typescript_1.default.isStringLiteral(expr.argumentExpression) &&
+        expr.argumentExpression.text === "track") {
+        return true;
+    }
+    return false;
+}
+function fileImportsEventraSdk(sourceFile) {
+    for (const stmt of sourceFile.statements) {
+        if (!typescript_1.default.isImportDeclaration(stmt) || !stmt.moduleSpecifier) {
+            continue;
+        }
+        if (!typescript_1.default.isStringLiteral(stmt.moduleSpecifier)) {
+            continue;
+        }
+        if ((0, eventraSdk_1.isEventraSdkModuleSpecifier)(stmt.moduleSpecifier.text)) {
+            return true;
+        }
+    }
+    return false;
+}
+function getImportDeclarationForSpecifier(decl) {
+    let current = decl;
+    while (current) {
+        if (typescript_1.default.isImportDeclaration(current)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+function isEventraImportDeclaration(decl) {
+    if (typescript_1.default.isImportSpecifier(decl) && decl.name.text === "Eventra") {
+        const importDecl = getImportDeclarationForSpecifier(decl);
+        if (importDecl?.moduleSpecifier && typescript_1.default.isStringLiteral(importDecl.moduleSpecifier)) {
+            return (0, eventraSdk_1.isEventraSdkModuleSpecifier)(importDecl.moduleSpecifier.text);
+        }
+    }
+    if (typescript_1.default.isImportClause(decl)) {
+        const parent = decl.parent;
+        if (parent && typescript_1.default.isImportDeclaration(parent) && parent.moduleSpecifier && typescript_1.default.isStringLiteral(parent.moduleSpecifier)) {
+            return (0, eventraSdk_1.isEventraSdkModuleSpecifier)(parent.moduleSpecifier.text);
+        }
+    }
+    return false;
+}
+function isEventraClassDeclaration(decl) {
+    if (!typescript_1.default.isClassDeclaration(decl) || decl.name?.text !== "Eventra") {
+        return false;
+    }
+    const file = decl.getSourceFile().fileName.replace(/\\/g, "/");
+    return file.includes("eventra-sdk") || file.includes("@eventra_dev");
+}
+function isEventraSymbol(symbol, checker, depth = 0) {
+    if (depth > 10) {
+        return false;
+    }
+    if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
+        return isEventraSymbol(checker.getAliasedSymbol(symbol), checker, depth + 1);
+    }
+    for (const decl of symbol.getDeclarations() ?? []) {
+        if (isEventraImportDeclaration(decl) || isEventraClassDeclaration(decl)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isEventraNewExpression(node, checker) {
+    const expr = node.expression;
+    if (!typescript_1.default.isIdentifier(expr)) {
+        return false;
+    }
+    const symbol = checker.getSymbolAtLocation(expr);
+    return symbol ? isEventraSymbol(symbol, checker) : false;
+}
+function typeLooksLikeEventra(type, checker, depth = 0) {
+    if (depth > 8) {
+        return false;
+    }
+    const symbol = type.getSymbol();
+    if (symbol && isEventraSymbol(symbol, checker)) {
+        return true;
+    }
+    const typeStr = checker.typeToString(type);
+    if (typeStr === "Eventra" || /^Eventra<.*>$/.test(typeStr)) {
+        return true;
+    }
+    if (type.isUnionOrIntersection()) {
+        return type.types.some((t) => typeLooksLikeEventra(t, checker, depth + 1));
+    }
+    return false;
+}
+function isEventraReceiverExpression(receiver, checker) {
+    if (typescript_1.default.isNewExpression(receiver)) {
+        return isEventraNewExpression(receiver, checker);
+    }
+    if (typescript_1.default.isCallExpression(receiver) && typescript_1.default.isNewExpression(receiver.expression)) {
+        return isEventraNewExpression(receiver.expression, checker);
+    }
+    const type = checker.getTypeAtLocation(receiver);
+    if (typeLooksLikeEventra(type, checker)) {
+        return true;
+    }
+    if (typescript_1.default.isIdentifier(receiver)) {
+        const symbol = checker.getSymbolAtLocation(receiver);
+        if (!symbol) {
+            return false;
+        }
+        for (const decl of symbol.getDeclarations() ?? []) {
+            if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
+                if (typescript_1.default.isNewExpression(decl.initializer) && isEventraNewExpression(decl.initializer, checker)) {
+                    return true;
+                }
+                if (typescript_1.default.isCallExpression(decl.initializer) &&
+                    typescript_1.default.isNewExpression(decl.initializer.expression) &&
+                    isEventraNewExpression(decl.initializer.expression, checker)) {
+                    return true;
+                }
+            }
+            if (typescript_1.default.isParameter(decl) && decl.type) {
+                const paramType = checker.getTypeFromTypeNode(decl.type);
+                if (typeLooksLikeEventra(paramType, checker)) {
+                    return true;
+                }
+            }
+            if (typescript_1.default.isPropertyDeclaration(decl) && decl.type) {
+                const propType = checker.getTypeFromTypeNode(decl.type);
+                if (typeLooksLikeEventra(propType, checker)) {
+                    return true;
+                }
+            }
+        }
+    }
+    if (typescript_1.default.isPropertyAccessExpression(receiver) || typescript_1.default.isPropertyAccessChain(receiver)) {
+        return isEventraReceiverExpression(receiver.expression, checker);
+    }
+    return false;
+}
+/** Only `instance.track(...)` where instance is Eventra from @eventra_dev/eventra-sdk. */
+function isEventraSdkTrackCall(call, checker) {
+    const expr = call.expression;
+    if (!isTrackCallee(expr)) {
+        return false;
+    }
+    const sourceFile = call.getSourceFile();
+    if (!fileImportsEventraSdk(sourceFile)) {
+        return false;
+    }
+    const receiver = typescript_1.default.isPropertyAccessExpression(expr) ||
+        typescript_1.default.isPropertyAccessChain(expr) ||
+        typescript_1.default.isElementAccessExpression(expr)
+        ? expr.expression
+        : undefined;
+    if (!receiver) {
+        return false;
+    }
+    return isEventraReceiverExpression(receiver, checker);
+}

package/dist/analysis/shared/eventValidation.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_EVENT_NAME_LENGTH = exports.normalizeEventName = exports.isValidEventName = void 0;
+var eventraSdk_1 = require("../sdk/eventraSdk");
+Object.defineProperty(exports, "isValidEventName", { enumerable: true, get: function () { return eventraSdk_1.isValidEventName; } });
+Object.defineProperty(exports, "normalizeEventName", { enumerable: true, get: function () { return eventraSdk_1.normalizeEventName; } });
+Object.defineProperty(exports, "MAX_EVENT_NAME_LENGTH", { enumerable: true, get: function () { return eventraSdk_1.MAX_EVENT_NAME_LENGTH; } });

package/dist/analysis/symbols/wrapperRegistry.js

@@ -1,13 +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.WrapperRegistry = void 0;
-const typescript_1 = __importDefault(require("typescript"));
 const exportResolver_1 = require("../resolver/exportResolver");
+const symbolUtils_1 = require("./symbolUtils");
 function isSymbol(value) {
-    return "flags" in value;
+    return typeof value.getDeclarations === "function";
 }
 class WrapperRegistry {
     checker;
@@ -17,6 +14,12 @@ class WrapperRegistry {
         this.checker = checker;
         this.exportCache = exportCache;
     }
+    setChecker(checker) {
+        this.checker = checker;
+    }
+    getChecker() {
+        return this.checker;
+    }
     normalize(symbol) {
         return ((0, exportResolver_1.resolveExportedSymbol)(symbol, this.checker, this.exportCache) ?? symbol);
     }
@@ -27,16 +30,7 @@ class WrapperRegistry {
         if (isSymbol(target)) {
             return this.wrappers.get(this.normalize(target));
         }
-        let symbol;
-        if (typescript_1.default.isFunctionDeclaration(target) && target.name) {
-            symbol = this.checker.getSymbolAtLocation(target.name);
-        }
-        else if (typescript_1.default.isMethodDeclaration(target) && typescript_1.default.isIdentifier(target.name)) {
-            symbol = this.checker.getSymbolAtLocation(target.name);
-        }
-        else if (target.parent && typescript_1.default.isVariableDeclaration(target.parent) && typescript_1.default.isIdentifier(target.parent.name)) {
-            symbol = this.checker.getSymbolAtLocation(target.parent.name);
-        }
+        const symbol = (0, symbolUtils_1.getFunctionSymbol)(target, this.checker);
         if (!symbol) {
             return undefined;
         }

package/dist/cli/check.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -40,31 +7,46 @@ exports.check = check;
 const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../config/config");
 const projectScanner_1 = require("../core/projectScanner");
+const scanResults_1 = require("../core/scanResults");
+function diffSets(found, known) {
+    return {
+        added: [...found].filter((e) => !known.has(e)),
+        removed: [...known].filter((e) => !found.has(e)),
+    };
+}
 async function check({ fix = false }) {
     const config = await (0, config_1.loadConfig)();
     if (!config) {
         console.log(chalk_1.default.red("eventra.json not found"));
         process.exit(1);
     }
-    console.log(chalk_1.default.blue("Checking events..."));
+    console.log(chalk_1.default.blue("Checking events and function wrappers..."));
     const { engine } = await (0, projectScanner_1.scanProject)(config);
-    const found = new Set(engine.getAllEvents());
-    const known = new Set(config.events ?? []);
-    const added = [...found].filter(e => !known.has(e));
-    const removed = [...known].filter(e => !found.has(e));
+    const foundEvents = new Set(engine.getAllEvents());
+    const knownEvents = new Set(config.events ?? []);
+    const eventDiff = diffSets(foundEvents, knownEvents);
+    const foundWrappers = new Set(engine.getAllFunctionWrappers());
+    const knownWrappers = new Set(config.functionWrappers?.map((w) => w.name) ?? []);
+    const wrapperDiff = diffSets(foundWrappers, knownWrappers);
     if (fix) {
-        const nextConfig = {
-            ...config,
-            events: [...found].sort(),
-        };
-        const { saveConfig } = await Promise.resolve().then(() => __importStar(require("../config/config")));
-        await saveConfig(nextConfig);
+        await (0, config_1.saveConfig)((0, scanResults_1.buildConfigFromScan)(config, engine));
         console.log(chalk_1.default.green("Synced"));
         return;
     }
-    if (added.length || removed.length) {
-        added.forEach(e => console.log(chalk_1.default.red(`+ ${e}`)));
-        removed.forEach(e => console.log(chalk_1.default.yellow(`- ${e}`)));
+    let hasDiff = false;
+    if (eventDiff.added.length || eventDiff.removed.length) {
+        hasDiff = true;
+        console.log(chalk_1.default.blue("\nEvents:"));
+        eventDiff.added.forEach((e) => console.log(chalk_1.default.red(`+ ${e}`)));
+        eventDiff.removed.forEach((e) => console.log(chalk_1.default.yellow(`- ${e}`)));
+    }
+    if (wrapperDiff.added.length || wrapperDiff.removed.length) {
+        hasDiff = true;
+        console.log(chalk_1.default.blue("\nFunction wrappers:"));
+        wrapperDiff.added.forEach((w) => console.log(chalk_1.default.red(`+ ${w}`)));
+        wrapperDiff.removed.forEach((w) => console.log(chalk_1.default.yellow(`- ${w}`)));
+    }
+    if (hasDiff) {
         process.exit(1);
     }
     console.log(chalk_1.default.green("All good"));

package/dist/cli/init.js

@@ -23,17 +23,16 @@ async function init() {
         },
     ]);
     console.log("");
-    console.log(chalk_1.default.gray("Eventra automatically detects:"));
-    console.log(chalk_1.default.gray("• track('event')"));
-    console.log(chalk_1.default.gray("• analytics.track('event')"));
-    console.log(chalk_1.default.gray("• semantic parameter propagation"));
-    console.log(chalk_1.default.gray("• cross-file wrappers"));
-    console.log(chalk_1.default.gray("• parameter propagation"));
+    console.log(chalk_1.default.gray("Eventra detects @eventra_dev/eventra-sdk usage:"));
+    console.log(chalk_1.default.gray('• tracker.track("event.name")'));
+    console.log(chalk_1.default.gray("• function wrappers → Eventra.track()"));
+    console.log(chalk_1.default.gray("• cross-file propagation chains"));
     console.log("");
     const config = {
         apiKey,
         endpoint,
         events: [],
+        functionWrappers: [],
         sync: {
             include: [
                 "**/*.{ts,tsx,js,jsx}",

package/dist/cli/sync.js

@@ -7,6 +7,7 @@ exports.sync = sync;
 const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../config/config");
 const projectScanner_1 = require("../core/projectScanner");
+const scanResults_1 = require("../core/scanResults");
 async function sync() {
     const config = await (0, config_1.loadConfig)();
     if (!config) {
@@ -15,7 +16,8 @@ async function sync() {
     }
     console.log(chalk_1.default.blue("Scanning..."));
     const { engine } = await (0, projectScanner_1.scanProject)(config);
-    const events = engine.getAllEvents().sort();
-    await (0, config_1.saveConfig)({ ...config, events });
-    console.log(chalk_1.default.green(`Found ${events.length} events`));
+    await (0, scanResults_1.persistScanResults)(config, engine);
+    const events = engine.getAllEvents();
+    const wrappers = engine.getAllFunctionWrappers();
+    console.log(chalk_1.default.green(`Found ${events.length} events, ${wrappers.length} function wrappers`));
 }

package/dist/cli/watch.js

@@ -10,7 +10,10 @@ const promises_1 = __importDefault(require("fs/promises"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const path_1 = __importDefault(require("path"));
 const config_1 = require("../config/config");
+const eventraSdk_1 = require("../analysis/sdk/eventraSdk");
 const EventraEngine_1 = require("../core/EventraEngine");
+const scanResults_1 = require("../core/scanResults");
+const SDK_TYPES_FILE = "__eventra_sdk_types__.d.ts";
 const processFile_1 = require("../filesystem/processFile");
 const getVirtualFile_1 = require("../filesystem/getVirtualFile");
 async function watch() {
@@ -24,38 +27,39 @@ async function watch() {
     const fileDeps = new Map();
     const cache = new Map();
     const watchedDeps = new Set();
+    const trackedFiles = new Set();
     const normalize = (file) => {
         return path_1.default.resolve(file).replace(/\\/g, "/");
     };
-    // INITIAL LOAD
     const files = await (0, fast_glob_1.default)(config.sync.include, {
         ignore: config.sync.exclude,
         absolute: true,
     });
     engine.beginPreload();
+    await engine.preloadFile(SDK_TYPES_FILE, eventraSdk_1.EVENTRA_SDK_SHIM);
     for (const file of files) {
         try {
             const abs = normalize(file);
             const raw = await promises_1.default.readFile(abs, "utf-8");
             const parsed = await (0, processFile_1.processFile)(abs, raw);
             cache.set(abs, parsed);
+            trackedFiles.add(abs);
             await engine.preloadFile((0, getVirtualFile_1.getVirtualFile)(abs), parsed.content);
-            await engine.updateFile((0, getVirtualFile_1.getVirtualFile)(abs), parsed.content, config);
-            fileDeps.set(abs, new Set(parsed.dependencies.map(dep => normalize(dep))));
+            fileDeps.set(abs, new Set(parsed.dependencies
+                .filter((dep) => dep.startsWith(".") || dep.startsWith("/"))
+                .map((dep) => normalize(path_1.default.resolve(path_1.default.dirname(abs), dep)))));
         }
         catch {
             // ignore invalid files
         }
     }
     engine.endPreload();
-    const initialEvents = engine.getAllEvents().sort();
-    await (0, config_1.saveConfig)({
-        ...config,
-        events: initialEvents,
-    });
-    console.log(chalk_1.default.gray(`Initial: ${initialEvents.length}\n`));
-    // WATCHER
-    const watcher = chokidar_1.default.watch([...files.map(normalize), ...watchedDeps], { ignoreInitial: true });
+    await engine.runFullAnalysis([SDK_TYPES_FILE, ...trackedFiles].map((f) => (0, getVirtualFile_1.getVirtualFile)(f)), config);
+    await (0, scanResults_1.persistScanResults)(config, engine);
+    const initialEvents = engine.getAllEvents();
+    const initialWrappers = engine.getAllFunctionWrappers();
+    console.log(chalk_1.default.gray(`Initial: ${initialEvents.length} events, ${initialWrappers.length} wrappers\n`));
+    const watcher = chokidar_1.default.watch([...trackedFiles, ...watchedDeps], { ignoreInitial: true });
     const queue = new Map();
     let timer = null;
     const run = async () => {
@@ -66,24 +70,22 @@ async function watch() {
                 const raw = await promises_1.default.readFile(file, "utf-8");
                 const parsed = await (0, processFile_1.processFile)(file, raw);
                 cache.set(file, parsed);
+                trackedFiles.add(file);
                 await engine.updateFile((0, getVirtualFile_1.getVirtualFile)(file), parsed.content, config);
-                // dependency diff
                 const abs = normalize(file);
                 const prevDeps = fileDeps.get(abs) ?? new Set();
-                const nextDeps = new Set(parsed.dependencies.map(dep => normalize(dep)));
-                // add deps
+                const nextDeps = new Set(parsed.dependencies
+                    .filter((dep) => dep.startsWith(".") || dep.startsWith("/"))
+                    .map((dep) => normalize(path_1.default.resolve(path_1.default.dirname(abs), dep))));
                 for (const dep of nextDeps) {
-                    if (prevDeps.has(dep)) {
+                    if (prevDeps.has(dep))
                         continue;
-                    }
                     watcher.add(dep);
                     watchedDeps.add(dep);
                 }
-                // remove deps
                 for (const dep of prevDeps) {
-                    if (nextDeps.has(dep)) {
+                    if (nextDeps.has(dep))
                         continue;
-                    }
                     watcher.unwatch(dep);
                     watchedDeps.delete(dep);
                 }
@@ -93,19 +95,14 @@ async function watch() {
                 console.log(chalk_1.default.gray(`skip: ${file}`));
             }
         }
-        const nextEvents = engine.getAllEvents().sort();
-        await (0, config_1.saveConfig)({
-            ...config,
-            events: nextEvents,
-        });
-        console.log(chalk_1.default.green(`Updated: ${nextEvents.length}`));
+        await (0, scanResults_1.persistScanResults)(config, engine);
+        console.log(chalk_1.default.green(`Updated: ${engine.getAllEvents().length} events, ${engine.getAllFunctionWrappers().length} wrappers`));
     };
     const schedule = (file) => {
         const abs = normalize(file);
         queue.set(abs, true);
-        if (timer) {
+        if (timer)
             clearTimeout(timer);
-        }
         timer = setTimeout(run, 200);
     };
     watcher
@@ -113,13 +110,10 @@ async function watch() {
         .on("add", schedule)
         .on("unlink", async (file) => {
         const abs = normalize(file);
+        trackedFiles.delete(abs);
         await engine.removeFile((0, getVirtualFile_1.getVirtualFile)(abs), config);
-        const nextEvents = engine.getAllEvents().sort();
-        await (0, config_1.saveConfig)({
-            ...config,
-            events: nextEvents,
-        });
-        console.log(chalk_1.default.red(`Removed → ${nextEvents.length}`));
+        await (0, scanResults_1.persistScanResults)(config, engine);
+        console.log(chalk_1.default.red(`Removed → ${engine.getAllEvents().length} events, ${engine.getAllFunctionWrappers().length} wrappers`));
     });
     process.on("SIGINT", async () => {
         await watcher.close();