@eventra_dev/eventra-cli 0.0.18 → 0.1.1

package/dist/commands/watch.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watch = watch;
+const chokidar_1 = __importDefault(require("chokidar"));
+const chalk_1 = __importDefault(require("chalk"));
+const promises_1 = __importDefault(require("fs/promises"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const config_1 = require("../utils/config");
+const engine_1 = require("../engine/engine");
+const router_1 = require("../utils/parsers/router");
+const vue_1 = require("../utils/parsers/vue");
+const svelte_1 = require("../utils/parsers/svelte");
+const astro_1 = require("../utils/parsers/astro");
+// PREPROCESS (CONTENT)
+function preprocess(file, content) {
+    const parser = (0, router_1.detectParser)(file);
+    if (parser === "vue")
+        return (0, vue_1.parseVue)(content);
+    if (parser === "svelte")
+        return (0, svelte_1.parseSvelte)(content);
+    if (parser === "astro")
+        return (0, astro_1.parseAstro)(content);
+    return content;
+}
+// VIRTUAL FILE (PATH)
+function toVirtualFile(file) {
+    return file.endsWith(".vue")
+        ? file + ".tsx"
+        : file;
+}
+// WATCH
+async function watch() {
+    const config = await (0, config_1.loadConfig)();
+    if (!config)
+        return;
+    console.log(chalk_1.default.blue("Watching...\n"));
+    const files = await (0, fast_glob_1.default)(config.sync.include, {
+        ignore: config.sync.exclude,
+    });
+    if (!files.length) {
+        console.log(chalk_1.default.yellow("No files found"));
+        return;
+    }
+    const engine = new engine_1.EventraEngine(process.cwd());
+    // INITIAL SCAN
+    for (const file of files) {
+        try {
+            const raw = await promises_1.default.readFile(file, "utf-8");
+            const content = preprocess(file, raw);
+            const virtualFile = toVirtualFile(file);
+            engine.scanFile(virtualFile, content);
+        }
+        catch {
+            console.log(chalk_1.default.gray(`skip: ${file}`));
+        }
+    }
+    config.events = engine.getAllEvents().sort();
+    await (0, config_1.saveConfig)(config);
+    console.log(chalk_1.default.gray(`Initial: ${config.events.length} events\n`));
+    // STATE
+    let locked = false;
+    let queued = new Set();
+    const run = async () => {
+        if (locked)
+            return;
+        locked = true;
+        const batch = [...queued];
+        queued.clear();
+        for (const file of batch) {
+            try {
+                const raw = await promises_1.default.readFile(file, "utf-8");
+                const content = preprocess(file, raw);
+                const virtualFile = toVirtualFile(file);
+                engine.updateFile(virtualFile, content);
+            }
+            catch {
+                console.log(chalk_1.default.gray(`skip: ${file}`));
+            }
+        }
+        const next = engine.getAllEvents();
+        const added = next.filter(e => !config.events.includes(e));
+        const removed = config.events.filter(e => !next.includes(e));
+        if (added.length || removed.length) {
+            added.forEach(e => console.log(chalk_1.default.green(`+ ${e}`)));
+            removed.forEach(e => console.log(chalk_1.default.red(`- ${e}`)));
+            config.events = next.sort();
+            await (0, config_1.saveConfig)(config);
+            console.log(chalk_1.default.gray(`Total: ${config.events.length} events\n`));
+        }
+        locked = false;
+    };
+    const schedule = (file) => {
+        queued.add(file);
+        setTimeout(run, 50);
+    };
+    // WATCHER
+    const watcher = chokidar_1.default.watch(config.sync.include, {
+        ignored: config.sync.exclude,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 50,
+            pollInterval: 10,
+        },
+    });
+    watcher
+        .on("add", (file) => {
+        console.log(chalk_1.default.gray(`add: ${file}`));
+        schedule(file);
+    })
+        .on("change", (file) => {
+        console.log(chalk_1.default.gray(`change: ${file}`));
+        schedule(file);
+    })
+        .on("unlink", async (file) => {
+        console.log(chalk_1.default.gray(`remove: ${file}`));
+        const virtualFile = toVirtualFile(file);
+        engine.removeFile?.(virtualFile);
+        const next = engine.getAllEvents();
+        const removed = config.events.filter(e => !next.includes(e));
+        if (removed.length) {
+            removed.forEach(e => console.log(chalk_1.default.red(`- ${e}`)));
+            config.events = next.sort();
+            await (0, config_1.saveConfig)(config);
+        }
+    });
+    // EXIT
+    process.on("SIGINT", async () => {
+        console.log(chalk_1.default.yellow("\nStopping watcher..."));
+        await watcher.close();
+        process.exit(0);
+    });
+}

package/dist/engine/callResolver.js

@@ -0,0 +1,31 @@
+"use strict";
+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();
+    }
+    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))) {
+                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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventraEngine = void 0;
+const project_1 = require("./project");
+const scanner_1 = require("./scanner");
+class EventraEngine {
+    project;
+    fileEvents = new Map();
+    constructor(entry) {
+        this.project = new project_1.ProjectGraph(entry);
+    }
+    scanFile(file, content) {
+        const source = this.project.getSource(file, content);
+        const checker = this.project.getChecker();
+        const events = (0, scanner_1.scanSource)(source, checker);
+        this.fileEvents.set(file, events);
+        return events;
+    }
+    updateFile(file, content) {
+        return this.scanFile(file, content);
+    }
+    getAllEvents() {
+        const all = new Set();
+        for (const set of this.fileEvents.values()) {
+            set.forEach(e => all.add(e));
+        }
+        return [...all];
+    }
+    removeFile(file) {
+        this.fileEvents.delete(file);
+    }
+}
+exports.EventraEngine = EventraEngine;

package/dist/engine/extract.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractEventsFromArgs = extractEventsFromArgs;
+const ts_morph_1 = require("ts-morph");
+const resolver_1 = require("./resolver");
+function extractEventsFromArgs(args, checker) {
+    return args.flatMap(arg => extract(arg, checker));
+}
+function extract(node, checker) {
+    if (ts_morph_1.Node.isStringLiteral(node)) {
+        return [{ value: node.getLiteralText(), dynamic: false }];
+    }
+    if (ts_morph_1.Node.isNoSubstitutionTemplateLiteral(node)) {
+        return [{ value: node.getLiteralText(), dynamic: false }];
+    }
+    if (ts_morph_1.Node.isTemplateExpression(node)) {
+        let result = node.getHead().getLiteralText();
+        for (const span of node.getTemplateSpans()) {
+            result += "*";
+            result += span.getLiteral().getLiteralText();
+        }
+        return [{ value: result, dynamic: true }];
+    }
+    if (ts_morph_1.Node.isObjectLiteralExpression(node)) {
+        return extractObject(node, checker);
+    }
+    const resolved = (0, resolver_1.resolveNodeValue)(node, checker);
+    if (resolved) {
+        return resolved.values.map(v => ({
+            value: v,
+            dynamic: resolved.dynamic,
+        }));
+    }
+    return [];
+}
+function extractObject(obj, checker) {
+    const res = [];
+    for (const prop of obj.getProperties()) {
+        if (!ts_morph_1.Node.isPropertyAssignment(prop))
+            continue;
+        const name = prop.getName();
+        const init = prop.getInitializer();
+        if (!init)
+            continue;
+        if (["event", "name", "action", "type"].includes(name)) {
+            res.push(...extract(init, checker));
+        }
+        if (ts_morph_1.Node.isObjectLiteralExpression(init)) {
+            res.push(...extractObject(init, checker));
+        }
+    }
+    return res;
+}

package/dist/engine/flow.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getForwardedParamIndex = getForwardedParamIndex;
+const ts_morph_1 = require("ts-morph");
+function getBodyNodes(fn) {
+    const body = fn.getBody();
+    if (!body)
+        return [];
+    if (ts_morph_1.Node.isBlock(body))
+        return body.getStatements();
+    return [body];
+}
+function getForwardedParamIndex(fn) {
+    if (!ts_morph_1.Node.isFunctionDeclaration(fn) &&
+        !ts_morph_1.Node.isArrowFunction(fn) &&
+        !ts_morph_1.Node.isFunctionExpression(fn))
+        return null;
+    const f = fn;
+    const params = f.getParameters();
+    for (const node of getBodyNodes(f)) {
+        const calls = node.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
+        for (const call of calls) {
+            const name = call.getExpression().getText();
+            if (!/(track|event|log|analytics|capture|send)/i.test(name))
+                continue;
+            const args = call.getArguments();
+            for (let i = 0; i < args.length; i++) {
+                const arg = args[i];
+                if (ts_morph_1.Node.isIdentifier(arg)) {
+                    const idx = params.findIndex(p => p.getName() === arg.getText());
+                    if (idx !== -1)
+                        return idx;
+                }
+            }
+        }
+    }
+    return null;
+}

package/dist/engine/graph.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyGraph = void 0;
+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());
+            }
+            this.reverse.get(dep).add(file);
+        }
+    }
+    getDependents(file) {
+        return [...(this.reverse.get(file) ?? [])];
+    }
+}
+exports.DependencyGraph = DependencyGraph;

package/dist/engine/project.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectGraph = void 0;
+const ts_morph_1 = require("ts-morph");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+function normalize(file) {
+    return path_1.default.resolve(file);
+}
+function findTsConfig(start) {
+    let dir = path_1.default.dirname(start);
+    while (true) {
+        const file = path_1.default.join(dir, "tsconfig.json");
+        if (fs_1.default.existsSync(file))
+            return file;
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+function getScriptKind(file) {
+    if (file.endsWith(".tsx"))
+        return ts_morph_1.ts.ScriptKind.TSX;
+    if (file.endsWith(".jsx"))
+        return ts_morph_1.ts.ScriptKind.JSX;
+    if (file.endsWith(".js"))
+        return ts_morph_1.ts.ScriptKind.JS;
+    if (file.endsWith(".vue"))
+        return ts_morph_1.ts.ScriptKind.TSX;
+    return ts_morph_1.ts.ScriptKind.TS;
+}
+class ProjectGraph {
+    project;
+    constructor(entry) {
+        const tsconfig = findTsConfig(entry);
+        this.project = tsconfig
+            ? new ts_morph_1.Project({
+                tsConfigFilePath: tsconfig,
+                skipAddingFilesFromTsConfig: false,
+            })
+            : new ts_morph_1.Project({
+                useInMemoryFileSystem: true,
+                compilerOptions: {
+                    allowJs: true,
+                    jsx: ts_morph_1.ts.JsxEmit.Preserve,
+                    moduleResolution: ts_morph_1.ts.ModuleResolutionKind.NodeJs,
+                    target: ts_morph_1.ts.ScriptTarget.ESNext,
+                },
+            });
+    }
+    getSource(file, content) {
+        const filePath = normalize(file);
+        let source = this.project.getSourceFile(filePath);
+        if (!source) {
+            source = this.project.createSourceFile(filePath, content, {
+                overwrite: true,
+                scriptKind: getScriptKind(filePath),
+            });
+        }
+        else {
+            source.replaceWithText(content);
+        }
+        return source;
+    }
+    getChecker() {
+        return this.project.getTypeChecker().compilerObject;
+    }
+}
+exports.ProjectGraph = ProjectGraph;

package/dist/engine/resolver.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNodeValue = resolveNodeValue;
+const ts_morph_1 = require("ts-morph");
+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 (ts_morph_1.ts.isTemplateExpression(init)) {
+                let result = init.head.text;
+                for (const span of init.templateSpans) {
+                    result += "*";
+                    result += span.literal.text;
+                }
+                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 };
+            }
+        }
+    }
+    return null;
+}

package/dist/engine/scanner.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanSource = scanSource;
+const ts_morph_1 = require("ts-morph");
+const extract_1 = require("./extract");
+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) {
+    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];
+            }
+        }
+        (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);
+            });
+        }
+    }
+    return events;
+}
+function isValid(v) {
+    return !!v && v.length > 1 && !v.includes(" ");
+}

package/dist/engine/symbol.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNodeValue = resolveNodeValue;
+const ts_morph_1 = require("ts-morph");
+function resolveNodeValue(node, checker) {
+    if (ts_morph_1.Node.isIdentifier(node)) {
+        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) {
+                if (ts_morph_1.Node.isStringLiteral(d.initializer)) {
+                    return {
+                        values: [d.initializer.text],
+                        dynamic: false
+                    };
+                }
+            }
+            if (ts_morph_1.ts.isParameter(d) && d.initializer) {
+                if (ts_morph_1.Node.isStringLiteral(d.initializer)) {
+                    return {
+                        values: [d.initializer.text],
+                        dynamic: false
+                    };
+                }
+            }
+        }
+    }
+    return null;
+}

package/dist/index.js

@@ -42,28 +42,32 @@ program
     .version("0.0.1");
 program
     .command("init")
-    .description("Initialize Eventra")
     .action(async () => {
     const { init } = await Promise.resolve().then(() => __importStar(require("./commands/init")));
     await init();
 });
 program
     .command("sync")
-    .description("Sync events")
     .action(async () => {
     const { sync } = await Promise.resolve().then(() => __importStar(require("./commands/sync")));
     await sync();
 });
 program
     .command("check")
-    .description("Validate events (CI mode)")
-    .action(async () => {
+    .option("--fix", "auto fix issues")
+    .action(async (opts) => {
     const { check } = await Promise.resolve().then(() => __importStar(require("./commands/check")));
-    await check();
+    await check({ fix: opts.fix });
+});
+program
+    .command("watch")
+    .description("Watch files and detect events in real-time")
+    .action(async () => {
+    const { watch } = await Promise.resolve().then(() => __importStar(require("./commands/watch")));
+    await watch();
 });
 program
     .command("send")
-    .description("Send events")
     .action(async () => {
     const { send } = await Promise.resolve().then(() => __importStar(require("./commands/send")));
     await send();

package/dist/utils/parsers/vue.js

@@ -2,17 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseVue = parseVue;
 function parseVue(content) {
-    const template = content.match(/<template[\s\S]*?>([\s\S]*?)<\/template>/);
-    const script = content.match(/<script[\s\S]*?>([\s\S]*?)<\/script>/);
-    return `
-${script?.[1] ?? ""}
-
-function __vue_template__() {
-  return (
-    <>
-      ${template?.[1] ?? ""}
-    </>
-  );
-}
+    const scriptMatch = content.match(/<script[\s\S]*?>([\s\S]*?)<\/script>/);
+    const templateMatch = content.match(/<template>([\s\S]*?)<\/template>/);
+    const script = scriptMatch?.[1] ?? "";
+    let template = templateMatch?.[1] ?? "";
+    template = template.replace(/<!--[\s\S]*?-->/g, "");
+    template = template
+        .replace(/v-if="[^"]+"/g, "")
+        .replace(/v-for="[^"]+"/g, "")
+        .replace(/@click=/g, "onClick=");
+    const jsx = `
+const __VUE_JSX__ = (
+  <>
+    ${template}
+  </>
+);
 `;
+    return script + "\n" + jsx;
 }

package/dist/utils/processFile.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFile = processFile;
+const router_1 = require("./parsers/router");
+const vue_1 = require("./parsers/vue");
+const svelte_1 = require("./parsers/svelte");
+const astro_1 = require("./parsers/astro");
+function processFile(file, content) {
+    const parser = (0, router_1.detectParser)(file);
+    if (parser === "vue")
+        content = (0, vue_1.parseVue)(content);
+    if (parser === "svelte")
+        content = (0, svelte_1.parseSvelte)(content);
+    if (parser === "astro")
+        content = (0, astro_1.parseAstro)(content);
+    const virtualFile = file.endsWith(".vue")
+        ? file + ".tsx"
+        : file;
+    return { content, virtualFile };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.0.18",
+  "version": "0.1.1",
   "description": "Eventra CLI",
   "type": "commonjs",
   "bin": {
@@ -20,6 +20,7 @@
   },
   "dependencies": {
     "chalk": "^4.1.2",
+    "chokidar": "^5.0.0",
     "commander": "^11.0.0",
     "fast-glob": "^3.3.3",
     "fs-extra": "^11.2.0",