@eventra_dev/eventra-cli 0.0.7 → 0.0.8

package/dist/commands/sync.js

@@ -8,6 +8,7 @@ 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 inquirer_1 = __importDefault(require("inquirer"));
 const config_1 = require("../utils/config");
 const router_1 = require("../utils/parsers/router");
 const vue_1 = require("../utils/parsers/vue");
@@ -25,16 +26,10 @@ async function sync() {
     console.log(chalk_1.default.blue("Scanning project..."));
     const project = new ts_morph_1.Project();
     const events = new Set();
+    const aliases = config.aliases ?? {};
     const files = await (0, fast_glob_1.default)(config.sync.include, {
         ignore: config.sync.exclude
     });
-    const functionWrappers = (config.functionWrappers ?? []).map((w) => ({
-        name: w.name,
-        path: w.event
-            ? `0.${w.event}`
-            : "0"
-    }));
-    const componentWrappers = config.wrappers ?? [];
     for (const file of files) {
         const parser = (0, router_1.detectParser)(file);
         let content = await promises_1.default.readFile(file, "utf-8");
@@ -48,10 +43,47 @@ async function sync() {
             ? file
             : file + ".tsx";
         const source = project.createSourceFile(virtualFile, content, { overwrite: true });
-        (0, track_1.scanTrack)(source).forEach((e) => events.add(e));
-        (0, function_wrappers_1.scanFunctionWrappers)(source, functionWrappers).forEach((e) => events.add(e));
-        (0, component_wrappers_1.scanComponentWrappers)(source, componentWrappers).forEach((e) => events.add(e));
+        const found = [
+            ...(0, track_1.scanTrack)(source),
+            ...(0, function_wrappers_1.scanFunctionWrappers)(source, config.functionWrappers ?? []),
+            ...(0, component_wrappers_1.scanComponentWrappers)(source, config.wrappers ?? [])
+        ];
+        for (const event of found) {
+            if (!event)
+                continue;
+            const value = typeof event === "string"
+                ? event
+                : event.value;
+            const dynamic = typeof event === "string"
+                ? false
+                : event.dynamic;
+            // alias exists
+            if (aliases[value]) {
+                events.add(aliases[value]);
+                continue;
+            }
+            // dynamic event
+            if (dynamic) {
+                console.log(chalk_1.default.yellow("\nDynamic event detected:"));
+                console.log(chalk_1.default.gray(value));
+                const { name } = await inquirer_1.default.prompt([
+                    {
+                        type: "input",
+                        name: "name",
+                        message: "Enter event name:",
+                        validate: (v) => v
+                            ? true
+                            : "Required"
+                    }
+                ]);
+                aliases[value] = name;
+                events.add(name);
+                continue;
+            }
+            events.add(value);
+        }
     }
+    config.aliases = aliases;
     const list = [...events].sort();
     config.events = list;
     await (0, config_1.saveConfig)(config);

package/dist/utils/extract.js

@@ -1,44 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractEvent = extractEvent;
+exports.extractExpression = extractExpression;
 const ts_morph_1 = require("ts-morph");
-function extractEvent(call, path) {
-    const parts = path.split(".");
-    let node = call.getArguments()[Number(parts[0])];
-    if (!node)
-        return null;
-    node = unwrap(node);
-    for (let i = 1; i < parts.length; i++) {
-        if (!ts_morph_1.Node.isObjectLiteralExpression(node)) {
-            return null;
-        }
-        const obj = node;
-        const prop = obj.getProperty(parts[i]);
-        if (!prop)
-            return null;
-        if (!ts_morph_1.Node.isPropertyAssignment(prop)) {
-            return null;
-        }
-        const initializer = prop.getInitializer();
-        if (!initializer)
-            return null;
-        node = unwrap(initializer);
-    }
-    if (ts_morph_1.Node.isStringLiteral(node)) {
-        return node.getLiteralText();
-    }
-    if (node.getKind() ===
+function extractExpression(expr) {
+    // "signup"
+    if (ts_morph_1.Node.isStringLiteral(expr)) {
+        return {
+            value: expr.getLiteralText(),
+            dynamic: false
+        };
+    }
+    // `signup`
+    if (expr.getKind() ===
         ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral) {
-        return node
-            .getText()
-            .replace(/`/g, "");
+        return {
+            value: expr
+                .getText()
+                .replace(/`/g, ""),
+            dynamic: false
+        };
     }
-    return null;
-}
-function unwrap(node) {
-    let current = node;
-    while (ts_morph_1.Node.isParenthesizedExpression(current)) {
-        current = current.getExpression();
+    // template `${event}`
+    if (ts_morph_1.Node.isTemplateExpression(expr)) {
+        return {
+            value: expr.getText(),
+            dynamic: true
+        };
+    }
+    // ROUTES.APP
+    if (ts_morph_1.Node.isPropertyAccessExpression(expr)) {
+        return {
+            value: expr.getText(),
+            dynamic: true
+        };
+    }
+    // EVENT
+    if (ts_morph_1.Node.isIdentifier(expr)) {
+        return {
+            value: expr.getText(),
+            dynamic: true
+        };
     }
-    return current;
+    // getEvent()
+    if (ts_morph_1.Node.isCallExpression(expr)) {
+        return {
+            value: expr
+                .getExpression()
+                .getText(),
+            dynamic: true
+        };
+    }
+    // condition ? "a" : "b"
+    if (ts_morph_1.Node.isConditionalExpression(expr)) {
+        return {
+            value: expr.getText(),
+            dynamic: true
+        };
+    }
+    // array[index]
+    if (ts_morph_1.Node.isElementAccessExpression(expr)) {
+        return {
+            value: expr.getText(),
+            dynamic: true
+        };
+    }
+    return null;
 }

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanComponentWrappers = scanComponentWrappers;
 const ts_morph_1 = require("ts-morph");
+const extract_1 = require("../extract");
 function scanComponentWrappers(source, wrappers) {
     const events = new Set();
     const elements = [
@@ -32,21 +33,21 @@ function scanComponentWrappers(source, wrappers) {
                 const init = attrNode.getInitializer();
                 if (!init)
                     continue;
-                if (init.getKind() ===
-                    ts_morph_1.SyntaxKind.StringLiteral) {
-                    const value = init.asKindOrThrow(ts_morph_1.SyntaxKind.StringLiteral);
-                    events.add(value.getLiteralText());
+                // event="signup"
+                if (ts_morph_1.Node.isStringLiteral(init)) {
+                    events.add({
+                        value: init.getLiteralText(),
+                        dynamic: false
+                    });
                 }
-                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());
-                    }
+                // event={...}
+                if (ts_morph_1.Node.isJsxExpression(init)) {
+                    const expr = init.getExpression();
+                    if (!expr)
+                        continue;
+                    const result = (0, extract_1.extractExpression)(expr);
+                    if (result)
+                        events.add(result);
                 }
             }
         }

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

@@ -13,20 +13,18 @@ function scanFunctionWrappers(source, wrappers) {
         for (const wrapper of wrappers) {
             if (wrapper.name !== name)
                 continue;
-            const event = extractEventFromArgs(call, wrapper.event);
-            if (event)
-                events.add(event);
+            const result = extractEventFromArgs(call, wrapper.event);
+            if (result)
+                events.add(result);
         }
     }
     return events;
 }
 function getFunctionName(call) {
     const expression = call.getExpression();
-    // trackFeature()
     if (ts_morph_1.Node.isIdentifier(expression)) {
         return expression.getText();
     }
-    // analytics.trackFeature()
     if (ts_morph_1.Node.isPropertyAccessExpression(expression)) {
         return getDeepName(expression);
     }
@@ -47,25 +45,27 @@ function extractEventFromArgs(call, event) {
     const args = call.getArguments();
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
-        // string case
+        // track("event")
         if (!event) {
-            if (ts_morph_1.Node.isStringLiteral(arg)) {
-                return arg.getLiteralText();
-            }
-            // template literal
-            if (arg.getKind() ===
-                ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral) {
-                return arg
-                    .getText()
-                    .replace(/`/g, "");
-            }
-        }
-        // object case
-        if (event) {
-            const result = (0, extract_1.extractEvent)(call, `${i}.${event}`);
+            const result = (0, extract_1.extractExpression)(arg);
             if (result)
                 return result;
         }
+        // track({ event: "..." })
+        if (event) {
+            const obj = arg.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+            if (!obj)
+                continue;
+            const prop = obj.getProperty(event);
+            if (!prop)
+                continue;
+            if (ts_morph_1.Node.isPropertyAssignment(prop)) {
+                const init = prop.getInitializer();
+                if (!init)
+                    continue;
+                return (0, extract_1.extractExpression)(init);
+            }
+        }
     }
     return null;
 }

package/package.json

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

package/src/commands/sync.ts

@@ -2,6 +2,7 @@ import chalk from "chalk";
 import fg from "fast-glob";
 import { Project } from "ts-morph";
 import fs from "fs/promises";
+import inquirer from "inquirer";
 
 import {
   loadConfig,
@@ -34,6 +35,9 @@ export async function sync() {
   const project = new Project();
   const events = new Set<string>();
 
+  const aliases =
+    config.aliases ?? {};
+
   const files = await fg(
     config.sync.include,
     {
@@ -41,18 +45,6 @@ export async function sync() {
     }
   );
 
-  const functionWrappers =
-    (config.functionWrappers ?? []).map(
-      (w) => ({
-        name: w.name,
-        path: w.event
-          ? `0.${w.event}`
-          : "0"
-      })
-    );
-  const componentWrappers =
-    config.wrappers ?? [];
-
   for (const file of files) {
     const parser =
       detectParser(file);
@@ -84,26 +76,78 @@ export async function sync() {
         { overwrite: true }
       );
 
-    scanTrack(source).forEach(
-      (e) => events.add(e)
-    );
-
-
-    scanFunctionWrappers(
-      source,
-      functionWrappers
-    ).forEach((e) =>
-      events.add(e)
-    );
-
-    scanComponentWrappers(
-      source,
-      componentWrappers
-    ).forEach((e) =>
-      events.add(e)
-    );
+    const found = [
+      ...scanTrack(source),
+      ...scanFunctionWrappers(
+        source,
+        config.functionWrappers ?? []
+      ),
+      ...scanComponentWrappers(
+        source,
+        config.wrappers ?? []
+      )
+    ];
+
+    for (const event of found) {
+      if (!event) continue;
+
+      const value =
+        typeof event === "string"
+          ? event
+          : event.value;
+
+      const dynamic =
+        typeof event === "string"
+          ? false
+          : event.dynamic;
+
+      // alias exists
+      if (aliases[value]) {
+        events.add(
+          aliases[value]
+        );
+        continue;
+      }
+
+      // dynamic event
+      if (dynamic) {
+        console.log(
+          chalk.yellow(
+            "\nDynamic event detected:"
+          )
+        );
+
+        console.log(
+          chalk.gray(value)
+        );
+
+        const { name } =
+          await inquirer.prompt([
+            {
+              type: "input",
+              name: "name",
+              message:
+                "Enter event name:",
+              validate: (v) =>
+                v
+                  ? true
+                  : "Required"
+            }
+          ]);
+
+        aliases[value] = name;
+
+        events.add(name);
+
+        continue;
+      }
+
+      events.add(value);
+    }
   }
 
+  config.aliases = aliases;
+
   const list =
     [...events].sort();
 

package/src/types.ts

@@ -13,8 +13,14 @@ export type EventraConfig = {
   events: string[];
   wrappers: ComponentWrapper[];
   functionWrappers: FunctionWrapper[];
+  aliases?: Record<string, string>;
   sync: {
     include: string[];
     exclude: string[];
   };
 };
+
+export type ExtractedEvent = {
+  value: string;
+  dynamic: boolean;
+};

package/src/utils/extract.ts

@@ -1,74 +1,97 @@
 import {
-  CallExpression,
   Node,
-  ObjectLiteralExpression,
-  SyntaxKind,
+  SyntaxKind
 } from "ts-morph";
 
-export function extractEvent(
-  call: CallExpression,
-  path: string
-): string | null {
-  const parts = path.split(".");
+import { ExtractedEvent } from "../types";
 
-  let node: Node | undefined =
-    call.getArguments()[Number(parts[0])];
+export function extractExpression(
+  expr: Node
+): ExtractedEvent | null {
 
-  if (!node) return null;
-
-  node = unwrap(node);
-
-  for (let i = 1; i < parts.length; i++) {
-    if (!Node.isObjectLiteralExpression(node)) {
-      return null;
-    }
-
-    const obj: ObjectLiteralExpression =
-      node;
-
-    const prop =
-      obj.getProperty(parts[i]);
-
-    if (!prop) return null;
-
-    if (!Node.isPropertyAssignment(prop)) {
-      return null;
-    }
-
-    const initializer =
-      prop.getInitializer();
+  // "signup"
+  if (Node.isStringLiteral(expr)) {
+    return {
+      value: expr.getLiteralText(),
+      dynamic: false
+    };
+  }
 
-    if (!initializer) return null;
+  // `signup`
+  if (
+    expr.getKind() ===
+    SyntaxKind.NoSubstitutionTemplateLiteral
+  ) {
+    return {
+      value: expr
+        .getText()
+        .replace(/`/g, ""),
+      dynamic: false
+    };
+  }
 
-    node = unwrap(initializer);
+  // template `${event}`
+  if (
+    Node.isTemplateExpression(expr)
+  ) {
+    return {
+      value: expr.getText(),
+      dynamic: true
+    };
   }
 
-  if (Node.isStringLiteral(node)) {
-    return node.getLiteralText();
+  // ROUTES.APP
+  if (
+    Node.isPropertyAccessExpression(expr)
+  ) {
+    return {
+      value: expr.getText(),
+      dynamic: true
+    };
   }
 
+  // EVENT
   if (
-    node.getKind() ===
-    SyntaxKind.NoSubstitutionTemplateLiteral
+    Node.isIdentifier(expr)
   ) {
-    return node
-      .getText()
-      .replace(/`/g, "");
+    return {
+      value: expr.getText(),
+      dynamic: true
+    };
   }
 
-  return null;
-}
+  // getEvent()
+  if (
+    Node.isCallExpression(expr)
+  ) {
+    return {
+      value:
+        expr
+          .getExpression()
+          .getText(),
+      dynamic: true
+    };
+  }
 
-function unwrap(node: Node): Node {
-  let current = node;
+  // condition ? "a" : "b"
+  if (
+    Node.isConditionalExpression(expr)
+  ) {
+    return {
+      value: expr.getText(),
+      dynamic: true
+    };
+  }
 
-  while (
-    Node.isParenthesizedExpression(
-      current
-    )
-    ) {
-    current = current.getExpression();
+  // array[index]
+  if (
+    Node.isElementAccessExpression(expr)
+  ) {
+    return {
+      value: expr.getText(),
+      dynamic: true
+    };
   }
 
-  return current;
+  return null;
 }

package/src/utils/scanners/component-wrappers.ts

@@ -1,15 +1,18 @@
 import {
   SourceFile,
   SyntaxKind,
+  Node
 } from "ts-morph";
 
-import { ComponentWrapper } from "../../types";
+import { ComponentWrapper, ExtractedEvent } from "../../types";
+import { extractExpression } from "../extract";
 
 export function scanComponentWrappers(
   source: SourceFile,
   wrappers: ComponentWrapper[]
 ) {
-  const events = new Set<string>();
+  const events =
+    new Set<ExtractedEvent>();
 
   const elements = [
     ...source.getDescendantsOfKind(
@@ -61,44 +64,31 @@ export function scanComponentWrappers(
 
         if (!init) continue;
 
+        // event="signup"
         if (
-          init.getKind() ===
-          SyntaxKind.StringLiteral
+          Node.isStringLiteral(init)
         ) {
-          const value =
-            init.asKindOrThrow(
-              SyntaxKind.StringLiteral
-            );
-
-          events.add(
-            value.getLiteralText()
-          );
+          events.add({
+            value:
+              init.getLiteralText(),
+            dynamic: false
+          });
         }
 
+        // event={...}
         if (
-          init.getKind() ===
-          SyntaxKind.JsxExpression
+          Node.isJsxExpression(init)
         ) {
           const expr =
-            init
-              .asKindOrThrow(
-                SyntaxKind.JsxExpression
-              )
-              .getExpression();
-
-          if (
-            expr?.getKind() ===
-            SyntaxKind.StringLiteral
-          ) {
-            const value =
-              expr.asKindOrThrow(
-                SyntaxKind.StringLiteral
-              );
-
-            events.add(
-              value.getLiteralText()
-            );
-          }
+            init.getExpression();
+
+          if (!expr) continue;
+
+          const result =
+            extractExpression(expr);
+
+          if (result)
+            events.add(result);
         }
       }
     }

package/src/utils/scanners/function-wrappers.ts

@@ -6,14 +6,15 @@ import {
   PropertyAccessExpression,
 } from "ts-morph";
 
-import { extractEvent } from "../extract";
-import { FunctionWrapper } from "../../types";
+import { extractExpression } from "../extract";
+import { FunctionWrapper, ExtractedEvent } from "../../types";
 
 export function scanFunctionWrappers(
   source: SourceFile,
   wrappers: FunctionWrapper[]
 ) {
-  const events = new Set<string>();
+  const events =
+    new Set<ExtractedEvent>();
 
   const calls =
     source.getDescendantsOfKind(
@@ -30,14 +31,14 @@ export function scanFunctionWrappers(
       if (wrapper.name !== name)
         continue;
 
-      const event =
+      const result =
         extractEventFromArgs(
           call,
           wrapper.event
         );
 
-      if (event)
-        events.add(event);
+      if (result)
+        events.add(result);
     }
   }
 
@@ -50,16 +51,12 @@ function getFunctionName(
   const expression =
     call.getExpression();
 
-  // trackFeature()
   if (
-    Node.isIdentifier(
-      expression
-    )
+    Node.isIdentifier(expression)
   ) {
     return expression.getText();
   }
 
-  // analytics.trackFeature()
   if (
     Node.isPropertyAccessExpression(
       expression
@@ -97,42 +94,52 @@ function getDeepName(
   return name;
 }
 
-
 function extractEventFromArgs(
   call: CallExpression,
   event?: string
-): string | null {
-  const args = call.getArguments();
+): ExtractedEvent | null {
+
+  const args =
+    call.getArguments();
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
 
-    // string case
+    // track("event")
     if (!event) {
-      if (Node.isStringLiteral(arg)) {
-        return arg.getLiteralText();
-      }
+      const result =
+        extractExpression(arg);
 
-      // template literal
-      if (
-        arg.getKind() ===
-        SyntaxKind.NoSubstitutionTemplateLiteral
-      ) {
-        return arg
-          .getText()
-          .replace(/`/g, "");
-      }
+      if (result)
+        return result;
     }
 
-    // object case
+    // track({ event: "..." })
     if (event) {
-      const result =
-        extractEvent(
-          call,
-          `${i}.${event}`
+      const obj =
+        arg.asKind(
+          SyntaxKind.ObjectLiteralExpression
         );
 
-      if (result) return result;
+      if (!obj) continue;
+
+      const prop =
+        obj.getProperty(event);
+
+      if (!prop) continue;
+
+      if (
+        Node.isPropertyAssignment(prop)
+      ) {
+        const init =
+          prop.getInitializer();
+
+        if (!init) continue;
+
+        return extractExpression(
+          init
+        );
+      }
     }
   }