@eventra_dev/eventra-cli 0.0.1

package/dist/index.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const program = new commander_1.Command();
+program
+    .name("eventra")
+    .description("Eventra CLI")
+    .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("send")
+    .description("Send events")
+    .action(async () => {
+    const { send } = await Promise.resolve().then(() => __importStar(require("./commands/send")));
+    await send();
+});
+program.parse();

package/dist/utils/config.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_NAME = void 0;
+exports.normalizeConfig = normalizeConfig;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+exports.CONFIG_NAME = "eventra.json";
+function normalizeConfig(config) {
+    return {
+        apiKey: config.apiKey ?? "",
+        events: config.events ?? [],
+        wrappers: config.wrappers ?? [],
+        sync: config.sync ?? {
+            include: ["**/*.{ts,tsx,js,jsx}"],
+            exclude: [
+                "node_modules",
+                "dist",
+                ".next",
+                ".git"
+            ]
+        }
+    };
+}
+async function loadConfig() {
+    const configPath = path_1.default.join(process.cwd(), exports.CONFIG_NAME);
+    if (!(await fs_extra_1.default.pathExists(configPath))) {
+        return null;
+    }
+    const config = await fs_extra_1.default.readJSON(configPath);
+    return normalizeConfig(config);
+}
+async function saveConfig(config) {
+    const configPath = path_1.default.join(process.cwd(), exports.CONFIG_NAME);
+    const normalized = normalizeConfig(config);
+    await fs_extra_1.default.writeJSON(configPath, normalized, {
+        spaces: 2
+    });
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@eventra_dev/eventra-cli",
+  "version": "0.0.1",
+  "description": "Eventra CLI",
+  "type": "commonjs",
+  "bin": {
+    "eventra": "./dist/index.js"
+  },
+  "access": "public",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.0.0",
+    "fast-glob": "^3.3.3",
+    "fs-extra": "^11.2.0",
+    "inquirer": "^8.2.7",
+    "ts-morph": "^27.0.2"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^20.0.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0"
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,60 @@
+import chalk from "chalk";
+import fs from "fs-extra";
+import path from "path";
+import inquirer from "inquirer";
+import {
+  CONFIG_NAME,
+  saveConfig
+} from "../utils/config";
+
+export async function init() {
+  console.log(
+    chalk.blue("Initializing Eventra...")
+  );
+
+  const configPath = path.join(
+    process.cwd(),
+    CONFIG_NAME
+  );
+
+  if (await fs.pathExists(configPath)) {
+    console.log(
+      chalk.yellow(
+        "eventra.json already exists"
+      )
+    );
+    return;
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "apiKey",
+      message:
+        "API Key (optional):"
+    }
+  ]);
+
+  const config = {
+    apiKey: answers.apiKey || "",
+    events: [],
+    wrappers: [],
+    sync: {
+      include: ["**/*.{ts,tsx,js,jsx}"],
+      exclude: [
+        "node_modules",
+        "dist",
+        ".next",
+        ".git"
+      ]
+    }
+  };
+
+  await saveConfig(config);
+
+  console.log(
+    chalk.green(
+      "eventra.json created"
+    )
+  );
+}

package/src/commands/send.ts

@@ -0,0 +1,124 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import {
+  loadConfig,
+  saveConfig
+} from "../utils/config";
+
+const EVENTRA_ENDPOINT = process.env.EVENTRA_ENDPOINT ?? "";
+
+const CLI_VERSION = "0.0.1";
+
+export async function send() {
+  let config = await loadConfig();
+
+  if (!config) {
+    console.log(
+      chalk.red(
+        "eventra.json not found. Run 'eventra init'"
+      )
+    );
+    return;
+  }
+
+  let apiKey = config.apiKey;
+
+  if (!apiKey) {
+    const answers =
+      await inquirer.prompt([
+        {
+          type: "input",
+          name: "apiKey",
+          message:
+            "Enter your API key:"
+        }
+      ]);
+
+    apiKey = answers.apiKey;
+
+    config.apiKey = apiKey;
+
+    await saveConfig(config);
+
+    console.log(
+      chalk.green(
+        "API key saved"
+      )
+    );
+  }
+
+  if (!config.events.length) {
+    console.log(
+      chalk.yellow(
+        "No events found. Run 'eventra sync'"
+      )
+    );
+    return;
+  }
+
+  console.log(
+    chalk.blue("Sending events...")
+  );
+
+  try {
+    const res = await fetch(EVENTRA_ENDPOINT,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type":
+            "application/json",
+          "x-api-key": apiKey
+        },
+        body: JSON.stringify({
+          events: config.events,
+          cli: {
+            name:
+              "@eventra_dev/eventra-cli",
+            version: CLI_VERSION,
+            runtime: "node"
+          }
+        })
+      }
+    );
+
+    if (res.status >= 400) {
+      console.log(
+        chalk.red(
+          `Failed (${res.status})`
+        )
+      );
+
+      return;
+    }
+
+    const data = await res.json();
+
+    console.log(
+      chalk.green(
+        "Events registered successfully"
+      )
+    );
+
+    if (data.created?.length) {
+      console.log(
+        chalk.green(
+          "\nNew events:"
+        )
+      );
+
+      data.created.forEach(
+        (e: string) =>
+          console.log(
+            chalk.green(
+              `+ ${e}`
+            )
+          )
+      );
+    }
+
+  } catch {
+    console.log(
+      chalk.red("Network error")
+    );
+  }
+}

package/src/commands/sync.ts

@@ -0,0 +1,397 @@
+import { Project, SyntaxKind } from "ts-morph";
+import fg from "fast-glob";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import {
+  loadConfig,
+  saveConfig
+} from "../utils/config";
+
+export async function sync() {
+  let config = await loadConfig();
+
+  if (!config) {
+    console.log(
+      chalk.red(
+        "Run 'eventra init' first"
+      )
+    );
+    return;
+  }
+
+  const events = new Set<string>();
+  const project = new Project();
+
+  console.log(
+    chalk.blue("Scanning project...")
+  );
+
+  const files = await fg(
+    config.sync.include,
+    {
+      ignore: config.sync.exclude
+    }
+  );
+
+  // track()
+  for (const file of files) {
+    const sourceFile =
+      project.addSourceFileAtPath(file);
+
+    const calls =
+      sourceFile.getDescendantsOfKind(
+        SyntaxKind.CallExpression
+      );
+
+    for (const call of calls) {
+      const expression =
+        call.getExpression();
+
+      if (
+        expression.getKind() ===
+        SyntaxKind.PropertyAccessExpression
+      ) {
+        const prop =
+          expression.asKind(
+            SyntaxKind.PropertyAccessExpression
+          );
+
+        if (!prop) continue;
+
+        if (prop.getName() !== "track")
+          continue;
+
+        const args =
+          call.getArguments();
+
+        const eventArg =
+          args[0];
+
+        if (!eventArg) continue;
+
+        let event: string | null = null;
+
+        // "event"
+        if (
+          eventArg.getKind() ===
+          SyntaxKind.StringLiteral
+        ) {
+          event =
+            eventArg
+              .asKindOrThrow(
+                SyntaxKind.StringLiteral
+              )
+              .getLiteralText();
+        }
+
+        // `event`
+        if (
+          eventArg.getKind() ===
+          SyntaxKind.NoSubstitutionTemplateLiteral
+        ) {
+          event =
+            eventArg
+              .asKindOrThrow(
+                SyntaxKind.NoSubstitutionTemplateLiteral
+              )
+              .getLiteralText();
+        }
+
+        if (event) {
+          events.add(event);
+        }
+      }
+    }
+  }
+
+  console.log(
+    chalk.green(
+      `Found ${events.size} track events`
+    )
+  );
+
+  // wrappers setup
+  if (!config.wrappers.length) {
+    const { useWrapper } =
+      await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "useWrapper",
+          message:
+            "Use wrapper components?",
+          default: true
+        }
+      ]);
+
+    if (useWrapper) {
+      const wrappers = [];
+
+      let addMore = true;
+
+      while (addMore) {
+        const answers =
+          await inquirer.prompt([
+            {
+              type: "input",
+              name: "name",
+              message:
+                "Wrapper component name:"
+            },
+            {
+              type: "input",
+              name: "prop",
+              message:
+                "Event prop name:"
+            }
+          ]);
+
+        wrappers.push({
+          name: answers.name,
+          prop: answers.prop
+        });
+
+        const more =
+          await inquirer.prompt([
+            {
+              type: "confirm",
+              name: "more",
+              message:
+                "Add another wrapper?",
+              default: false
+            }
+          ]);
+
+        addMore = more.more;
+      }
+
+      config.wrappers = wrappers;
+    }
+  }
+
+  // scan wrappers
+  if (config.wrappers.length) {
+    console.log(
+      chalk.blue(
+        "Scanning wrappers..."
+      )
+    );
+
+    for (const file of files) {
+      const sourceFile =
+        project.addSourceFileAtPath(file);
+
+      const elements = [
+        ...sourceFile.getDescendantsOfKind(
+          SyntaxKind.JsxOpeningElement
+        ),
+        ...sourceFile.getDescendantsOfKind(
+          SyntaxKind.JsxSelfClosingElement
+        )
+      ];
+
+      for (const element of elements) {
+        const tagName =
+          element
+            .getTagNameNode()
+            .getText()
+            .toLowerCase();
+
+        for (const wrapper of config.wrappers) {
+          if (
+            tagName !==
+            wrapper.name.toLowerCase()
+          )
+            continue;
+
+          const attrs =
+            element.getAttributes();
+
+          for (const attr of attrs) {
+            if (
+              attr.getKind() !==
+              SyntaxKind.JsxAttribute
+            )
+              continue;
+
+            const attrNode =
+              attr.asKind(
+                SyntaxKind.JsxAttribute
+              );
+
+            if (!attrNode) continue;
+
+            const attrName =
+              attrNode
+                .getNameNode()
+                .getText()
+                .toLowerCase();
+
+            if (
+              attrName !==
+              wrapper.prop.toLowerCase()
+            )
+              continue;
+
+            const initializer =
+              attrNode.getInitializer();
+
+            if (!initializer) continue;
+
+            let value: string | null = null;
+
+            // event="signup"
+            if (
+              initializer.getKind() ===
+              SyntaxKind.StringLiteral
+            ) {
+              value =
+                initializer
+                  .asKindOrThrow(
+                    SyntaxKind.StringLiteral
+                  )
+                  .getLiteralText();
+            }
+
+            // event={"signup"}
+            if (
+              initializer.getKind() ===
+              SyntaxKind.JsxExpression
+            ) {
+              const expr =
+                initializer
+                  .asKindOrThrow(
+                    SyntaxKind.JsxExpression
+                  )
+                  .getExpression();
+
+              if (
+                expr?.getKind() ===
+                SyntaxKind.StringLiteral
+              ) {
+                value =
+                  expr
+                    .asKindOrThrow(
+                      SyntaxKind.StringLiteral
+                    )
+                    .getLiteralText();
+              }
+            }
+
+            if (value) {
+              events.add(value);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // results
+  const list =
+    [...events].sort();
+
+  console.log("");
+
+  console.log(
+    chalk.green("Found events:")
+  );
+
+  list.forEach((e) =>
+    console.log(
+      chalk.gray(`- ${e}`)
+    )
+  );
+
+  console.log("");
+
+  // diff
+  const previous =
+    config.events ?? [];
+
+  const added = list.filter(
+    (e) => !previous.includes(e)
+  );
+
+  const removed =
+    previous.filter(
+      (e: string) =>
+        !list.includes(e)
+    );
+
+  if (added.length || removed.length) {
+    console.log(
+      chalk.blue("Changes:")
+    );
+
+    if (added.length) {
+      console.log(
+        chalk.green(
+          "New events:"
+        )
+      );
+
+      added.forEach((e) =>
+        console.log(
+          chalk.green(
+            `+ ${e}`
+          )
+        )
+      );
+    }
+
+    if (removed.length) {
+      console.log(
+        chalk.red(
+          "Removed events:"
+        )
+      );
+
+      removed.forEach((e: unknown) =>
+        console.log(
+          chalk.red(
+            `- ${e}`
+          )
+        )
+      );
+    }
+
+    console.log("");
+  } else {
+    console.log(
+      chalk.gray(
+        "No changes detected"
+      )
+    );
+  }
+
+  // confirm
+  const { confirm } =
+    await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message:
+          "Sync these events?",
+        default: true
+      }
+    ]);
+
+  if (!confirm) {
+    console.log(
+      chalk.yellow(
+        "Sync cancelled"
+      )
+    );
+    return;
+  }
+
+  config.events = list;
+
+  await saveConfig(config);
+
+  console.log(
+    chalk.green(
+      "eventra.json updated"
+    )
+  );
+}