@eventra_dev/eventra-cli 0.0.17 → 0.0.18

package/README.md

@@ -64,6 +64,7 @@ npx eventra init
 ```bash
 eventra init
 eventra sync
+eventra check
 eventra send
 ```
 
@@ -121,6 +122,94 @@ analytics.trackFeature("user_signup")
 
 ---
 
+## eventra check
+
+Validate events in your codebase without modifying `eventra.json`.
+
+This command is designed for CI/CD pipelines and ensures:
+
+-   No new events are introduced unintentionally
+-   All dynamic events are resolved via aliases
+-   Event naming stays consistent
+
+``` bash
+eventra check
+```
+
+------------------------------------------------------------------------
+
+### What it checks
+
+#### 1. New events
+
+If your code contains events not listed in `eventra.json`:
+
+``` ts
+trackFeature("new_event")
+```
+
+CLI output:
+
+    New events detected:
+    + new_event
+    ❌ Event check failed
+
+------------------------------------------------------------------------
+
+#### 2. Unresolved dynamic events
+
+If your code contains dynamic values without alias:
+
+``` ts
+trackFeature(eventName)
+```
+
+CLI output:
+
+    Unresolved dynamic events:
+    - eventName
+    ❌ Event check failed
+
+------------------------------------------------------------------------
+
+### CI usage
+
+``` bash
+pnpm eventra check
+```
+
+#### GitHub Actions example
+
+``` yaml
+- run: pnpm eventra check
+```
+
+------------------------------------------------------------------------
+
+### Skipping dynamic events
+
+You can explicitly ignore dynamic variables using aliases:
+
+``` json
+{
+  "aliases": {
+    "eventName": "__skip__"
+  }
+}
+```
+
+------------------------------------------------------------------------
+
+### When to use
+
+Use `eventra check` to:
+
+-   enforce event consistency\
+-   prevent accidental event creation\
+-   validate analytics in pull requests
+
+---
+
 ## eventra send
 
 Send events to Eventra backend.

package/dist/commands/check.js

@@ -0,0 +1,116 @@
+"use strict";
+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 fast_glob_1 = __importDefault(require("fast-glob"));
+const ts_morph_1 = require("ts-morph");
+const promises_1 = __importDefault(require("fs/promises"));
+const config_1 = require("../utils/config");
+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");
+const track_1 = require("../utils/scanners/track");
+const function_wrappers_1 = require("../utils/scanners/function-wrappers");
+const component_wrappers_1 = require("../utils/scanners/component-wrappers");
+async function check() {
+    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 project = new ts_morph_1.Project();
+    const knownEvents = new Set(config.events ?? []);
+    const aliases = config.aliases ?? {};
+    const foundEvents = new Set();
+    const newEvents = new Set();
+    const unresolvedDynamic = new Set();
+    const files = await (0, fast_glob_1.default)(config.sync.include, {
+        ignore: config.sync.exclude
+    });
+    for (const file of files) {
+        try {
+            // skip huge files
+            const stat = await promises_1.default.stat(file);
+            if (stat.size > 2 * 1024 * 1024) {
+                console.log(chalk_1.default.gray(`Skipped large file: ${file}`));
+                continue;
+            }
+            const parser = (0, router_1.detectParser)(file);
+            let content = await promises_1.default.readFile(file, "utf-8");
+            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 = parser === "ts" ? file : file + ".tsx";
+            const source = project.createSourceFile(virtualFile, content, { overwrite: true });
+            const found = [
+                ...(0, track_1.scanTrack)(source, config),
+                ...(0, function_wrappers_1.scanFunctionWrappers)(source, config.functionWrappers ?? []),
+                ...(0, component_wrappers_1.scanComponentWrappers)(source, config.wrappers ?? [])
+            ];
+            for (const event of found) {
+                const { value, dynamic } = event;
+                if (!value)
+                    continue;
+                // alias skip
+                if (aliases[value] === "__skip__") {
+                    continue;
+                }
+                // alias resolve
+                if (aliases[value]) {
+                    foundEvents.add(aliases[value]);
+                    continue;
+                }
+                // dynamic without alias
+                if (dynamic) {
+                    unresolvedDynamic.add(value);
+                    continue;
+                }
+                // static
+                foundEvents.add(value);
+            }
+            // clear memory
+            project.removeSourceFile(source);
+        }
+        catch {
+            console.log(chalk_1.default.gray(`Skipped file (error): ${file}`));
+        }
+    }
+    // find new events
+    for (const event of foundEvents) {
+        if (!knownEvents.has(event)) {
+            newEvents.add(event);
+        }
+    }
+    let hasError = false;
+    // dynamic
+    if (unresolvedDynamic.size > 0) {
+        hasError = true;
+        console.log(chalk_1.default.red("\nUnresolved dynamic events:"));
+        [...unresolvedDynamic]
+            .sort()
+            .forEach((e) => console.log(chalk_1.default.red(`- ${e}`)));
+    }
+    // new events
+    if (newEvents.size > 0) {
+        hasError = true;
+        console.log(chalk_1.default.red("\nNew events detected:"));
+        [...newEvents]
+            .sort()
+            .forEach((e) => console.log(chalk_1.default.red(`+ ${e}`)));
+    }
+    if (hasError) {
+        console.log("");
+        console.log(chalk_1.default.red("Event check failed"));
+        console.log(chalk_1.default.red(`dynamic: ${unresolvedDynamic.size}, new: ${newEvents.size}`));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.green("\nAll events are valid"));
+}

package/dist/index.js

@@ -54,6 +54,13 @@ program
     const { sync } = await Promise.resolve().then(() => __importStar(require("./commands/sync")));
     await sync();
 });
+program
+    .command("check")
+    .description("Validate events (CI mode)")
+    .action(async () => {
+    const { check } = await Promise.resolve().then(() => __importStar(require("./commands/check")));
+    await check();
+});
 program
     .command("send")
     .description("Send events")

package/package.json

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

package/src/commands/check.ts

@@ -0,0 +1,172 @@
+import chalk from "chalk";
+import fg from "fast-glob";
+import { Project } from "ts-morph";
+import fs from "fs/promises";
+
+import { loadConfig } from "../utils/config";
+
+import { detectParser } from "../utils/parsers/router";
+import { parseVue } from "../utils/parsers/vue";
+import { parseSvelte } from "../utils/parsers/svelte";
+import { parseAstro } from "../utils/parsers/astro";
+
+import { scanTrack } from "../utils/scanners/track";
+import { scanFunctionWrappers } from "../utils/scanners/function-wrappers";
+import { scanComponentWrappers } from "../utils/scanners/component-wrappers";
+
+import { ExtractedEvent } from "../types";
+
+export async function check() {
+  const config = await loadConfig();
+
+  if (!config) {
+    console.log(chalk.red("eventra.json not found"));
+    process.exit(1);
+  }
+
+  console.log(chalk.blue("Checking events..."));
+
+  const project = new Project();
+
+  const knownEvents = new Set(config.events ?? []);
+  const aliases = config.aliases ?? {};
+
+  const foundEvents = new Set<string>();
+  const newEvents = new Set<string>();
+  const unresolvedDynamic = new Set<string>();
+
+  const files = await fg(config.sync.include, {
+    ignore: config.sync.exclude
+  });
+
+  for (const file of files) {
+    try {
+      // skip huge files
+      const stat = await fs.stat(file);
+      if (stat.size > 2 * 1024 * 1024) {
+        console.log(chalk.gray(`Skipped large file: ${file}`));
+        continue;
+      }
+
+      const parser = detectParser(file);
+
+      let content = await fs.readFile(file, "utf-8");
+
+      if (parser === "vue") content = parseVue(content);
+      if (parser === "svelte") content = parseSvelte(content);
+      if (parser === "astro") content = parseAstro(content);
+
+      const virtualFile =
+        parser === "ts" ? file : file + ".tsx";
+
+      const source = project.createSourceFile(
+        virtualFile,
+        content,
+        { overwrite: true }
+      );
+
+      const found: ExtractedEvent[] = [
+        ...scanTrack(source, config),
+        ...scanFunctionWrappers(
+          source,
+          config.functionWrappers ?? []
+        ),
+        ...scanComponentWrappers(
+          source,
+          config.wrappers ?? []
+        )
+      ];
+
+      for (const event of found) {
+        const { value, dynamic } = event;
+
+        if (!value) continue;
+
+        // alias skip
+        if (aliases[value] === "__skip__") {
+          continue;
+        }
+
+        // alias resolve
+        if (aliases[value]) {
+          foundEvents.add(aliases[value]);
+          continue;
+        }
+
+        // dynamic without alias
+        if (dynamic) {
+          unresolvedDynamic.add(value);
+          continue;
+        }
+
+        // static
+        foundEvents.add(value);
+      }
+
+      // clear memory
+      project.removeSourceFile(source);
+
+    } catch {
+      console.log(
+        chalk.gray(`Skipped file (error): ${file}`)
+      );
+    }
+  }
+
+  // find new events
+  for (const event of foundEvents) {
+    if (!knownEvents.has(event)) {
+      newEvents.add(event);
+    }
+  }
+
+  let hasError = false;
+
+  // dynamic
+  if (unresolvedDynamic.size > 0) {
+    hasError = true;
+
+    console.log(
+      chalk.red("\nUnresolved dynamic events:")
+    );
+
+    [...unresolvedDynamic]
+      .sort()
+      .forEach((e) =>
+        console.log(chalk.red(`- ${e}`))
+      );
+  }
+
+  // new events
+  if (newEvents.size > 0) {
+    hasError = true;
+
+    console.log(
+      chalk.red("\nNew events detected:")
+    );
+
+    [...newEvents]
+      .sort()
+      .forEach((e) =>
+        console.log(chalk.red(`+ ${e}`))
+      );
+  }
+
+  if (hasError) {
+    console.log("");
+
+    console.log(chalk.red("Event check failed"));
+
+    console.log(
+      chalk.red(
+        `dynamic: ${unresolvedDynamic.size}, new: ${newEvents.size}`
+      )
+    );
+
+    process.exit(1);
+  }
+
+  console.log(
+    chalk.green("\nAll events are valid")
+  );
+}

package/src/index.ts

@@ -25,6 +25,14 @@ program
     await sync();
   });
 
+program
+  .command("check")
+  .description("Validate events (CI mode)")
+  .action(async () => {
+    const { check } = await import("./commands/check");
+    await check();
+  });
+
 program
   .command("send")
   .description("Send events")