@eventra_dev/eventra-cli 0.0.4 → 0.0.5

package/dist/utils/scanners/component-wrappers.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanComponentWrappers = scanComponentWrappers;
+const ts_morph_1 = require("ts-morph");
+function scanComponentWrappers(source, wrappers) {
+    const events = new Set();
+    const elements = [
+        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.JsxOpeningElement),
+        ...source.getDescendantsOfKind(ts_morph_1.SyntaxKind.JsxSelfClosingElement)
+    ];
+    for (const el of elements) {
+        const name = el
+            .getTagNameNode()
+            .getText()
+            .toLowerCase();
+        for (const wrapper of wrappers) {
+            if (name !==
+                wrapper.name.toLowerCase())
+                continue;
+            const attrs = el.getAttributes();
+            for (const attr of attrs) {
+                const attrNode = attr.asKind(ts_morph_1.SyntaxKind.JsxAttribute);
+                if (!attrNode)
+                    continue;
+                const key = attrNode
+                    .getNameNode()
+                    .getText()
+                    .toLowerCase();
+                if (key !==
+                    wrapper.prop.toLowerCase())
+                    continue;
+                const init = attrNode.getInitializer();
+                if (!init)
+                    continue;
+                // event="signup"
+                if (init.getKind() ===
+                    ts_morph_1.SyntaxKind.StringLiteral) {
+                    const value = init.asKindOrThrow(ts_morph_1.SyntaxKind.StringLiteral);
+                    events.add(value.getLiteralText());
+                }
+                // event={"signup"}
+                if (init.getKind() ===
+                    ts_morph_1.SyntaxKind.JsxExpression) {
+                    const expr = init
+                        .asKindOrThrow(ts_morph_1.SyntaxKind.JsxExpression)
+                        .getExpression();
+                    if (expr?.getKind() ===
+                        ts_morph_1.SyntaxKind.StringLiteral) {
+                        const value = expr.asKindOrThrow(ts_morph_1.SyntaxKind.StringLiteral);
+                        events.add(value.getLiteralText());
+                    }
+                }
+            }
+        }
+    }
+    return events;
+}

package/dist/utils/scanners/function-wrappers.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanFunctionWrappers = scanFunctionWrappers;
+const ts_morph_1 = require("ts-morph");
+const extract_1 = require("../extract");
+function scanFunctionWrappers(source, wrappers) {
+    const events = new Set();
+    const calls = source.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
+    for (const call of calls) {
+        const expression = call.getExpression();
+        let name = null;
+        // trackFeature()
+        if (expression.getKind() ===
+            ts_morph_1.SyntaxKind.Identifier) {
+            name =
+                expression.getText();
+        }
+        // analytics.trackFeature()
+        if (expression.getKind() ===
+            ts_morph_1.SyntaxKind.PropertyAccessExpression) {
+            const prop = expression.asKindOrThrow(ts_morph_1.SyntaxKind.PropertyAccessExpression);
+            name = prop.getName();
+        }
+        if (!name)
+            continue;
+        for (const wrapper of wrappers) {
+            if (name !== wrapper.name)
+                continue;
+            const event = (0, extract_1.extractEvent)(call, wrapper.path);
+            if (event)
+                events.add(event);
+        }
+    }
+    return events;
+}

package/dist/utils/scanners/track.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanTrack = scanTrack;
+const ts_morph_1 = require("ts-morph");
+function scanTrack(source) {
+    const events = new Set();
+    const calls = source.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
+    for (const call of calls) {
+        const expr = call.getExpression();
+        let isTrack = false;
+        // track()
+        if (expr.getKind() ===
+            ts_morph_1.SyntaxKind.Identifier) {
+            isTrack =
+                expr.getText() === "track";
+        }
+        // analytics.track()
+        if (expr.getKind() ===
+            ts_morph_1.SyntaxKind.PropertyAccessExpression) {
+            const prop = expr.asKindOrThrow(ts_morph_1.SyntaxKind.PropertyAccessExpression);
+            isTrack =
+                prop.getName() === "track";
+        }
+        if (!isTrack)
+            continue;
+        const arg = call.getArguments()[0];
+        if (!arg)
+            continue;
+        if (arg.getKind() ===
+            ts_morph_1.SyntaxKind.StringLiteral) {
+            const value = arg.asKindOrThrow(ts_morph_1.SyntaxKind.StringLiteral);
+            events.add(value.getLiteralText());
+        }
+        // template literal
+        if (arg.getKind() ===
+            ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral) {
+            const value = arg.asKindOrThrow(ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral);
+            events.add(value.getLiteralText());
+        }
+    }
+    return events;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Eventra CLI",
   "type": "commonjs",
   "bin": {
@@ -9,12 +9,12 @@
   "access": "public",
   "repository": {
     "type": "git",
-    "url": "https://github.com/and-1991/eventa-cli"
+    "url": "https://github.com/and-1991/eventra-cli"
   },
   "homepage": "https://eventra.dev",
   "license": "MIT",
   "scripts": {
-    "build": "tsc && chmod +x dist/index.js",
+    "build": "tsc",
     "dev": "tsx src/index.ts"
   },
   "dependencies": {

package/src/commands/init.ts

@@ -39,6 +39,7 @@ export async function init() {
     apiKey: answers.apiKey || "",
     events: [],
     wrappers: [],
+    functionWrappers: [],
     sync: {
       include: ["**/*.{ts,tsx,js,jsx}"],
       exclude: [

package/src/commands/send.ts

@@ -5,12 +5,15 @@ import {
   saveConfig
 } from "../utils/config";
 
-const EVENTRA_ENDPOINT = process.env.EVENTRA_ENDPOINT ?? "";
+import pkg from "../../package.json";
 
-const CLI_VERSION = "0.0.1";
+const EVENTRA_ENDPOINT =
+  process.env.EVENTRA_ENDPOINT ?? "";
+
+const CLI_VERSION = pkg.version;
 
 export async function send() {
-  let config = await loadConfig();
+  const config = await loadConfig();
 
   if (!config) {
     console.log(
@@ -23,6 +26,7 @@ export async function send() {
 
   let apiKey = config.apiKey;
 
+  // ask api key
   if (!apiKey) {
     const answers =
       await inquirer.prompt([
@@ -41,13 +45,12 @@ export async function send() {
     await saveConfig(config);
 
     console.log(
-      chalk.green(
-        "API key saved"
-      )
+      chalk.green("API key saved")
     );
   }
 
-  if (!config.events.length) {
+  // no events
+  if (!config.events?.length) {
     console.log(
       chalk.yellow(
         "No events found. Run 'eventra sync'"
@@ -56,12 +59,32 @@ export async function send() {
     return;
   }
 
+  if (!apiKey) {
+    console.log(
+      chalk.red("API key required")
+    );
+    return;
+  }
+
+  if (!EVENTRA_ENDPOINT) {
+    console.log(
+      chalk.red(
+        "EVENTRA_ENDPOINT not configured"
+      )
+    );
+    return;
+  }
+
+  console.log("");
   console.log(
-    chalk.blue("Sending events...")
+    chalk.blue(
+      `Sending ${config.events.length} events...`
+    )
   );
 
   try {
-    const res = await fetch(EVENTRA_ENDPOINT,
+    const res = await fetch(
+      EVENTRA_ENDPOINT,
       {
         method: "POST",
         headers: {
@@ -81,17 +104,27 @@ export async function send() {
       }
     );
 
-    if (res.status >= 400) {
+    if (!res.ok) {
       console.log(
         chalk.red(
-          `Failed (${res.status})`
+          `Request failed (${res.status})`
         )
       );
 
+      try {
+        const text =
+          await res.text();
+
+        console.log(
+          chalk.gray(text)
+        );
+      } catch {}
+
       return;
     }
 
-    const data = await res.json();
+    const data =
+      await res.json();
 
     console.log(
       chalk.green(
@@ -99,11 +132,10 @@ export async function send() {
       )
     );
 
+    // created
     if (data.created?.length) {
       console.log(
-        chalk.green(
-          "\nNew events:"
-        )
+        chalk.green("\nNew events:")
       );
 
       data.created.forEach(
@@ -116,9 +148,61 @@ export async function send() {
       );
     }
 
-  } catch {
+    // existing
+    if (data.existing?.length) {
+      console.log(
+        chalk.gray(
+          "\nExisting events:"
+        )
+      );
+
+      data.existing.forEach(
+        (e: string) =>
+          console.log(
+            chalk.gray(
+              `• ${e}`
+            )
+          )
+      );
+    }
+
+    // processing notice
+    if (data.created?.length) {
+      console.log("");
+      console.log(
+        chalk.yellow(
+          "Events queued for processing (~2 min)"
+        )
+      );
+
+      console.log(
+        chalk.gray(
+          "They will appear in dashboard shortly"
+        )
+      );
+    }
+
+    console.log("");
+
     console.log(
-      chalk.red("Network error")
+      chalk.gray(
+        `Sent ${config.events.length} events`
+      )
     );
+
+  } catch (err) {
+    console.log(
+      chalk.red(
+        "Network error"
+      )
+    );
+
+    if (err instanceof Error) {
+      console.log(
+        chalk.gray(
+          err.message
+        )
+      );
+    }
   }
 }