@eventra_dev/eventra-cli 0.2.4 → 0.3.1

package/dist/analysis/scanner/sinkDetector.js

@@ -0,0 +1,91 @@
+"use strict";
+// src/analysis/scanner/sinkDetector.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectTrackSink = detectTrackSink;
+const typescript_1 = __importDefault(require("typescript"));
+function isElementTrackProperty(expr) {
+    return (typescript_1.default.isElementAccessExpression(expr)
+        && expr.argumentExpression
+        && typescript_1.default.isStringLiteral(expr.argumentExpression)
+        && expr.argumentExpression.text
+            === "track");
+}
+function isTrackIdentifier(expr) {
+    return (typescript_1.default.isIdentifier(expr)
+        && expr.text === "track");
+}
+function isTrackProperty(expr) {
+    return (typescript_1.default.isPropertyAccessExpression(expr)
+        && expr.name.text
+            === "track");
+}
+function isOptionalTrackProperty(expr) {
+    return (typescript_1.default.isPropertyAccessChain(expr)
+        && expr.name.text
+            === "track");
+}
+function extractTrackedArguments(call) {
+    const result = [];
+    if (call.arguments.length
+        === 0) {
+        return result;
+    }
+    //
+    // ONLY FIRST ARGUMENT
+    // IS EVENT SINK
+    //
+    // track(name, payload)
+    //       ^^^^
+    //
+    const first = call.arguments[0];
+    //
+    // track({
+    //   event: "signup"
+    // })
+    //
+    if (typescript_1.default.isObjectLiteralExpression(first)) {
+        for (const property of first.properties) {
+            if (!typescript_1.default.isPropertyAssignment(property)) {
+                continue;
+            }
+            const name = property.name
+                .getText();
+            if (name !== "event"
+                && name !== "name"
+                && name !== "type") {
+                continue;
+            }
+            result.push({
+                index: 0,
+                propertyPath: [
+                    name,
+                ],
+            });
+        }
+        return result;
+    }
+    //
+    // track(name)
+    //
+    result.push({
+        index: 0,
+        propertyPath: [],
+    });
+    return result;
+}
+function detectTrackSink(call) {
+    const expression = call.expression;
+    if (!isTrackIdentifier(expression)
+        && !isTrackProperty(expression)
+        && !isOptionalTrackProperty(expression)
+        && !isElementTrackProperty(expression)) {
+        return null;
+    }
+    return {
+        call,
+        trackedArguments: extractTrackedArguments(call),
+    };
+}

package/dist/analysis/shared/evaluationContext.js

@@ -0,0 +1,9 @@
+"use strict";
+// src/analysis/shared/evaluationContext.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEvaluationContext = createEvaluationContext;
+function createEvaluationContext() {
+    return {
+        parameterBindings: new Map(),
+    };
+}

package/dist/analysis/shared/propagation.js

@@ -0,0 +1,3 @@
+"use strict";
+// src/analysis/shared/propagation.ts
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/analysis/shared/returnPropagation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/analysis/shared/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/analysis/shared/utils.js

@@ -0,0 +1,62 @@
+"use strict";
+// src/analysis/shared/utils.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCallName = getCallName;
+exports.getFunctionName = getFunctionName;
+const typescript_1 = __importDefault(require("typescript"));
+function getCallName(expression) {
+    //
+    // track()
+    //
+    if (typescript_1.default.isIdentifier(expression)) {
+        return expression.text;
+    }
+    //
+    // analytics.track()
+    //
+    if (typescript_1.default.isPropertyAccessExpression(expression)) {
+        return expression.name.text;
+    }
+    //
+    // analytics?.track()
+    //
+    if (typescript_1.default.isPropertyAccessChain(expression)) {
+        return expression.name.text;
+    }
+    return "";
+}
+function getFunctionName(node) {
+    //
+    // function foo()
+    //
+    if (typescript_1.default.isFunctionDeclaration(node)
+        && node.name) {
+        return node.name.text;
+    }
+    //
+    // class method()
+    //
+    if (typescript_1.default.isMethodDeclaration(node)
+        && typescript_1.default.isIdentifier(node.name)) {
+        return node.name.text;
+    }
+    //
+    // const foo = () => {}
+    //
+    const parent = node.parent;
+    if (typescript_1.default.isVariableDeclaration(parent)
+        && typescript_1.default.isIdentifier(parent.name)) {
+        return parent.name.text;
+    }
+    //
+    // class field = () => {}
+    //
+    if (typescript_1.default.isPropertyDeclaration(parent)
+        && typescript_1.default.isIdentifier(parent.name)) {
+        return parent.name.text;
+    }
+    return "anonymous";
+}

package/dist/analysis/symbols/symbolUtils.js

@@ -0,0 +1,68 @@
+"use strict";
+// src/analysis/symbols/symbolUtils.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFunctionSymbol = getFunctionSymbol;
+const typescript_1 = __importDefault(require("typescript"));
+function getFunctionSymbol(node, checker) {
+    //
+    // function foo() {}
+    //
+    if (typescript_1.default.isFunctionDeclaration(node)
+        && node.name) {
+        return checker.getSymbolAtLocation(node.name);
+    }
+    //
+    // class method() {}
+    //
+    if (typescript_1.default.isMethodDeclaration(node)
+        && typescript_1.default.isIdentifier(node.name)) {
+        return checker.getSymbolAtLocation(node.name);
+    }
+    //
+    // object literal method
+    //
+    // const obj = {
+    //   foo() {}
+    // }
+    //
+    if (typescript_1.default.isMethodDeclaration(node)
+        && typescript_1.default.isComputedPropertyName(node.name)) {
+        return checker.getSymbolAtLocation(node.name.expression);
+    }
+    //
+    // const foo = () => {}
+    //
+    const parent = node.parent;
+    if (typescript_1.default.isVariableDeclaration(parent)
+        && typescript_1.default.isIdentifier(parent.name)) {
+        return checker.getSymbolAtLocation(parent.name);
+    }
+    //
+    // class field = () => {}
+    //
+    if (typescript_1.default.isPropertyDeclaration(parent)
+        && typescript_1.default.isIdentifier(parent.name)) {
+        return checker.getSymbolAtLocation(parent.name);
+    }
+    //
+    // object property
+    //
+    // const x = {
+    //   foo: () => {}
+    // }
+    //
+    if (typescript_1.default.isPropertyAssignment(parent)
+        && typescript_1.default.isIdentifier(parent.name)) {
+        return checker.getSymbolAtLocation(parent.name);
+    }
+    //
+    // export default function() {}
+    //
+    if (typescript_1.default.isExportAssignment(parent)) {
+        return checker.getSymbolAtLocation(node);
+    }
+    return undefined;
+}

package/dist/analysis/symbols/wrapperRegistry.js

@@ -0,0 +1,55 @@
+"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");
+function isSymbol(value) {
+    return "flags" in value;
+}
+class WrapperRegistry {
+    wrappers = new WeakMap();
+    normalize(symbol, checker, exportCache) {
+        return ((0, exportResolver_1.resolveExportedSymbol)(symbol, checker, exportCache)
+            ?? symbol);
+    }
+    set(semantic, checker, exportCache) {
+        this.wrappers.set(this.normalize(semantic.symbol, checker, exportCache), semantic);
+    }
+    get(target, checker, exportCache) {
+        if (isSymbol(target)) {
+            return this.wrappers.get(this.normalize(target, checker, exportCache));
+        }
+        let symbol;
+        if (typescript_1.default.isFunctionDeclaration(target)
+            && target.name) {
+            symbol =
+                checker.getSymbolAtLocation(target.name);
+        }
+        else if (typescript_1.default.isMethodDeclaration(target)
+            && typescript_1.default.isIdentifier(target.name)) {
+            symbol =
+                checker.getSymbolAtLocation(target.name);
+        }
+        else if (target.parent
+            && typescript_1.default.isVariableDeclaration(target.parent)
+            && typescript_1.default.isIdentifier(target.parent.name)) {
+            symbol =
+                checker.getSymbolAtLocation(target.parent.name);
+        }
+        if (!symbol) {
+            return undefined;
+        }
+        return this.wrappers.get(this.normalize(symbol, checker, exportCache));
+    }
+    has(symbol, checker, exportCache) {
+        return this.wrappers.has(this.normalize(symbol, checker, exportCache));
+    }
+    clear() {
+        this.wrappers =
+            new WeakMap();
+    }
+}
+exports.WrapperRegistry = WrapperRegistry;

package/dist/cli/check.js

@@ -0,0 +1,73 @@
+"use strict";
+// src/commands/check.ts
+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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check = check;
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../config/config");
+const projectScanner_1 = require("../core/projectScanner");
+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..."));
+    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));
+    if (fix) {
+        config.events =
+            [...found].sort();
+        const { saveConfig } = await Promise.resolve().then(() => __importStar(require("../config/config")));
+        await saveConfig(config);
+        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}`)));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.green("All good"));
+}

package/dist/{commands → cli}/init.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = init;
 const chalk_1 = __importDefault(require("chalk"));
 const inquirer_1 = __importDefault(require("inquirer"));
-const config_1 = require("../utils/config");
+const config_1 = require("../config/config");
 async function init() {
     console.log(chalk_1.default.blue("Initializing Eventra..."));
     // API KEY ENDPOINT

package/dist/{commands → cli}/send.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.send = send;
 const chalk_1 = __importDefault(require("chalk"));
 const inquirer_1 = __importDefault(require("inquirer"));
-const config_1 = require("../utils/config");
+const config_1 = require("../config/config");
 const package_json_1 = __importDefault(require("../../package.json"));
 const CLI_VERSION = package_json_1.default.version;
 async function send() {

package/dist/cli/sync.js

@@ -0,0 +1,56 @@
+"use strict";
+// src/commands/sync.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sync = sync;
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../config/config");
+const projectScanner_1 = require("../core/projectScanner");
+async function sync() {
+    const config = await (0, config_1.loadConfig)();
+    if (!config) {
+        return;
+    }
+    console.log(chalk_1.default.blue("Scanning..."));
+    const { engine, results, } = await (0, projectScanner_1.scanProject)(config);
+    const detectedFn = new Set();
+    const detectedCmp = new Map();
+    for (const result of results.values()) {
+        result
+            .detectedFunctionWrappers
+            .forEach(w => detectedFn.add(w));
+        result
+            .detectedComponentWrappers
+            .forEach((v, k) => detectedCmp.set(k, v));
+    }
+    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 (0, config_1.saveConfig)(config);
+    console.log(chalk_1.default.green(`Found ${events.length} events`));
+}
+function mergeUnique(a, b, key) {
+    const map = new Map();
+    [...b, ...a]
+        .forEach(item => map.set(key(item), item));
+    return [
+        ...map.values()
+    ];
+}

package/dist/{commands → cli}/watch.js

@@ -9,20 +9,22 @@ const chalk_1 = __importDefault(require("chalk"));
 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("../utils/config");
-const engine_1 = require("../engine/engine");
-const processFile_1 = require("../utils/processFile");
-const getVirtualFile_1 = require("../utils/getVirtualFile");
+const config_1 = require("../config/config");
+const EventraEngine_1 = require("../core/EventraEngine");
+const processFile_1 = require("../filesystem/processFile");
+const getVirtualFile_1 = require("../filesystem/getVirtualFile");
 async function watch() {
     const config = await (0, config_1.loadConfig)();
-    if (!config)
+    if (!config) {
         return;
+    }
     console.log(chalk_1.default.blue("Watching...\n"));
-    const engine = new engine_1.EventraEngine(process.cwd());
+    const engine = new EventraEngine_1.EventraEngine(process.cwd());
     const fileDeps = new Map();
     const cache = new Map();
     const watchedDeps = new Set();
-    const normalize = (f) => path_1.default.resolve(f).replace(/\\/g, "/");
+    const normalize = (f) => path_1.default.resolve(f)
+        .replace(/\\/g, "/");
     // INITIAL LOAD
     const files = await (0, fast_glob_1.default)(config.sync.include, {
         ignore: config.sync.exclude,
@@ -32,19 +34,26 @@ async function watch() {
         try {
             const abs = normalize(file);
             const raw = await promises_1.default.readFile(abs, "utf-8");
-            const parsed = (0, processFile_1.processFile)(abs, raw);
+            const parsed = await (0, processFile_1.processFile)(abs, raw);
             cache.set(abs, parsed);
-            engine.preloadFile((0, getVirtualFile_1.getVirtualFile)(abs), parsed.content);
-            engine.updateFile((0, getVirtualFile_1.getVirtualFile)(abs), parsed.content, config);
-            fileDeps.set(abs, new Set(parsed.deps.map(d => normalize(d))));
+            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(d => normalize(d))));
         }
         catch { }
     }
-    config.events = engine.getAllEvents().sort();
+    config.events =
+        engine.getAllEvents()
+            .sort();
     await (0, config_1.saveConfig)(config);
     console.log(chalk_1.default.gray(`Initial: ${config.events.length}\n`));
     // WATCHER
-    const watcher = chokidar_1.default.watch([...files.map(normalize), ...watchedDeps], { ignoreInitial: true });
+    const watcher = chokidar_1.default.watch([
+        ...files.map(normalize),
+        ...watchedDeps,
+    ], {
+        ignoreInitial: true
+    });
     const queue = new Map();
     let timer = null;
     const run = async () => {
@@ -53,13 +62,14 @@ async function watch() {
         for (const file of batch) {
             try {
                 const raw = await promises_1.default.readFile(file, "utf-8");
-                const parsed = (0, processFile_1.processFile)(file, raw);
+                const parsed = await (0, processFile_1.processFile)(file, raw);
                 cache.set(file, parsed);
-                engine.updateFile((0, getVirtualFile_1.getVirtualFile)(file), parsed.content, config);
-                //dependency diff
+                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.deps.map(d => normalize(d)));
+                const prevDeps = fileDeps.get(abs)
+                    ?? new Set();
+                const nextDeps = new Set(parsed.dependencies.map(d => normalize(d)));
                 // add new deps
                 for (const dep of nextDeps) {
                     if (!prevDeps.has(dep)) {
@@ -80,26 +90,32 @@ async function watch() {
                 console.log(chalk_1.default.gray(`skip: ${file}`));
             }
         }
-        const next = engine.getAllEvents().sort();
-        config.events = next;
+        const next = engine.getAllEvents()
+            .sort();
+        config.events =
+            next;
         await (0, config_1.saveConfig)(config);
         console.log(chalk_1.default.green(`Updated: ${next.length}`));
     };
     const schedule = (file) => {
         const abs = normalize(file);
         queue.set(abs, true);
-        if (timer)
+        if (timer) {
             clearTimeout(timer);
-        timer = setTimeout(run, 200);
+        }
+        timer =
+            setTimeout(run, 200);
     };
     watcher
         .on("change", schedule)
         .on("add", schedule)
         .on("unlink", async (file) => {
         const abs = normalize(file);
-        engine.removeFile((0, getVirtualFile_1.getVirtualFile)(abs), config);
-        const next = engine.getAllEvents().sort();
-        config.events = next;
+        await engine.removeFile((0, getVirtualFile_1.getVirtualFile)(abs), config);
+        const next = engine.getAllEvents()
+            .sort();
+        config.events =
+            next;
         await (0, config_1.saveConfig)(config);
         console.log(chalk_1.default.red(`Removed → ${next.length}`));
     });