@eventra_dev/eventra-cli 0.0.4 → 0.0.6

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

@@ -0,0 +1,108 @@
+import {
+  SourceFile,
+  SyntaxKind,
+} from "ts-morph";
+
+import { ComponentWrapper } from "../../types";
+
+export function scanComponentWrappers(
+  source: SourceFile,
+  wrappers: ComponentWrapper[]
+) {
+  const events = new Set<string>();
+
+  const elements = [
+    ...source.getDescendantsOfKind(
+      SyntaxKind.JsxOpeningElement
+    ),
+    ...source.getDescendantsOfKind(
+      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(
+            SyntaxKind.JsxAttribute
+          );
+
+        if (!attrNode) continue;
+
+        const key =
+          attrNode
+            .getNameNode()
+            .getText()
+            .toLowerCase();
+
+        if (
+          key !==
+          wrapper.prop.toLowerCase()
+        )
+          continue;
+
+        const init =
+          attrNode.getInitializer();
+
+        if (!init) continue;
+
+        if (
+          init.getKind() ===
+          SyntaxKind.StringLiteral
+        ) {
+          const value =
+            init.asKindOrThrow(
+              SyntaxKind.StringLiteral
+            );
+
+          events.add(
+            value.getLiteralText()
+          );
+        }
+
+        if (
+          init.getKind() ===
+          SyntaxKind.JsxExpression
+        ) {
+          const expr =
+            init
+              .asKindOrThrow(
+                SyntaxKind.JsxExpression
+              )
+              .getExpression();
+
+          if (
+            expr?.getKind() ===
+            SyntaxKind.StringLiteral
+          ) {
+            const value =
+              expr.asKindOrThrow(
+                SyntaxKind.StringLiteral
+              );
+
+            events.add(
+              value.getLiteralText()
+            );
+          }
+        }
+      }
+    }
+  }
+
+  return events;
+}

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

@@ -0,0 +1,98 @@
+import {
+  SourceFile,
+  SyntaxKind,
+  Node,
+  CallExpression,
+  PropertyAccessExpression,
+} from "ts-morph";
+
+import { extractEvent } from "../extract";
+import { FunctionWrapper } from "../../types";
+
+export function scanFunctionWrappers(
+  source: SourceFile,
+  wrappers: FunctionWrapper[]
+) {
+  const events = new Set<string>();
+
+  const calls =
+    source.getDescendantsOfKind(
+      SyntaxKind.CallExpression
+    );
+
+  for (const call of calls) {
+    const name =
+      getFunctionName(call);
+
+    if (!name) continue;
+
+    for (const wrapper of wrappers) {
+      if (wrapper.name !== name)
+        continue;
+
+      const event =
+        extractEvent(
+          call,
+          wrapper.path ?? "0"
+        );
+
+      if (event)
+        events.add(event);
+    }
+  }
+
+  return events;
+}
+
+function getFunctionName(
+  call: CallExpression
+): string | null {
+  const expression =
+    call.getExpression();
+
+  // trackFeature()
+  if (
+    Node.isIdentifier(
+      expression
+    )
+  ) {
+    return expression.getText();
+  }
+
+  // analytics.trackFeature()
+  if (
+    Node.isPropertyAccessExpression(
+      expression
+    )
+  ) {
+    return getDeepName(
+      expression
+    );
+  }
+
+  return null;
+}
+
+function getDeepName(
+  node: PropertyAccessExpression
+): string {
+  let current:
+    | Node
+    | undefined = node;
+
+  let name = "";
+
+  while (
+    Node.isPropertyAccessExpression(
+      current
+    )
+    ) {
+    name =
+      current.getName();
+
+    current =
+      current.getExpression();
+  }
+
+  return name;
+}

package/src/utils/scanners/track.ts

@@ -0,0 +1,84 @@
+import {
+  SourceFile,
+  SyntaxKind
+} from "ts-morph";
+
+export function scanTrack(
+  source: SourceFile
+) {
+  const events =
+    new Set<string>();
+
+  const calls =
+    source.getDescendantsOfKind(
+      SyntaxKind.CallExpression
+    );
+
+  for (const call of calls) {
+    const expr =
+      call.getExpression();
+
+    let isTrack = false;
+
+    // track()
+    if (
+      expr.getKind() ===
+      SyntaxKind.Identifier
+    ) {
+      isTrack =
+        expr.getText() === "track";
+    }
+
+    // analytics.track()
+    if (
+      expr.getKind() ===
+      SyntaxKind.PropertyAccessExpression
+    ) {
+      const prop =
+        expr.asKindOrThrow(
+          SyntaxKind.PropertyAccessExpression
+        );
+
+      isTrack =
+        prop.getName() === "track";
+    }
+
+    if (!isTrack) continue;
+
+    const arg =
+      call.getArguments()[0];
+
+    if (!arg) continue;
+
+    if (
+      arg.getKind() ===
+      SyntaxKind.StringLiteral
+    ) {
+      const value =
+        arg.asKindOrThrow(
+          SyntaxKind.StringLiteral
+        );
+
+      events.add(
+        value.getLiteralText()
+      );
+    }
+
+    // template literal
+    if (
+      arg.getKind() ===
+      SyntaxKind.NoSubstitutionTemplateLiteral
+    ) {
+      const value =
+        arg.asKindOrThrow(
+          SyntaxKind.NoSubstitutionTemplateLiteral
+        );
+
+      events.add(
+        value.getLiteralText()
+      );
+    }
+  }
+
+  return events;
+}

package/tests/fixtures/backend/express/app.ts

@@ -0,0 +1,78 @@
+/* eslint-disable */
+
+declare function track(event: string): void;
+
+const express = (...args: any[]) => ({
+  get: (...args: any[]) => {},
+  post: (...args: any[]) => {},
+  put: (...args: any[]) => {},
+  delete: (...args: any[]) => {},
+  use: (...args: any[]) => {},
+  listen: (...args: any[]) => {}
+});
+
+const app = express();
+
+// ===== direct =====
+track("express_event");
+
+// ===== middleware =====
+app.use(() => {
+  track("middleware_event");
+});
+
+// ===== get =====
+app.get("/", () => {
+  track("get_event");
+});
+
+// ===== post =====
+app.post("/users", () => {
+  track("post_event");
+});
+
+// ===== put =====
+app.put("/users", () => {
+  track("put_event");
+});
+
+// ===== delete =====
+app.delete("/users", () => {
+  track("delete_event");
+});
+
+// ===== nested =====
+app.get("/nested", () => {
+  if (true) {
+    track("nested_event");
+  }
+});
+
+// ===== async =====
+app.get("/async", async () => {
+  track("async_event");
+});
+
+// ===== arrow =====
+const handler = () => {
+  track("arrow_event");
+};
+
+app.get("/arrow", handler);
+
+// ===== function =====
+function service() {
+  track("function_event");
+}
+
+// ===== class =====
+class Service {
+  run() {
+    track("class_event");
+  }
+}
+
+// ===== listen =====
+app.listen(3000, () => {
+  track("listen_event");
+});

package/tests/fixtures/backend/nest/service.ts

@@ -0,0 +1,70 @@
+/* eslint-disable */
+
+declare function track(event: string): void;
+
+function Injectable(): any {
+  return () => {};
+}
+
+function Controller(): any {
+  return () => {};
+}
+
+function Get(): any {
+  return () => {};
+}
+
+function Post(): any {
+  return () => {};
+}
+
+// ===== service =====
+@Injectable()
+export class TestService {
+  run() {
+    track("nest_event");
+  }
+
+  async asyncRun() {
+    track("async_event");
+  }
+
+  arrow = () => {
+    track("arrow_event");
+  };
+}
+
+// ===== controller =====
+@Controller()
+export class TestController {
+  @Get()
+  get() {
+    track("get_event");
+  }
+
+  @Post()
+  post() {
+    track("post_event");
+  }
+
+  nested() {
+    if (true) {
+      track("nested_event");
+    }
+  }
+}
+
+// ===== function =====
+function service() {
+  track("function_event");
+}
+
+// ===== class =====
+class AnotherService {
+  run() {
+    track("class_event");
+  }
+}
+
+// ===== direct =====
+track("direct_event");

package/tests/fixtures/backend/node/index.ts

@@ -0,0 +1,63 @@
+/* eslint-disable */
+
+declare function track(event: string): void;
+
+const eventName = "variable_event";
+
+// ===== direct =====
+track("node_event");
+
+// ===== multiline =====
+track(
+  "multiline_event"
+);
+
+// ===== template string =====
+track(`template_event`);
+
+// ===== conditional =====
+if (true) {
+  track("conditional_event");
+}
+
+// ===== ternary =====
+true
+  ? track("ternary_a")
+  : track("ternary_b");
+
+// ===== variable =====
+track(eventName);
+
+// ===== function =====
+function run() {
+  track("function_event");
+}
+
+// ===== arrow =====
+const handler = () => {
+  track("arrow_event");
+};
+
+// ===== class =====
+class Service {
+  run() {
+    track("class_event");
+  }
+}
+
+// ===== nested =====
+function outer() {
+  function inner() {
+    track("nested_event");
+  }
+}
+
+// ===== async =====
+async function asyncRun() {
+  track("async_event");
+}
+
+// ===== promise =====
+Promise.resolve().then(() => {
+  track("promise_event");
+});

package/tests/fixtures/frontend/next/page.tsx

@@ -0,0 +1,101 @@
+/* eslint-disable */
+
+declare function track(event: string): void;
+declare function trackFeature(event: string): void;
+
+declare const analytics: any;
+declare const Button: any;
+declare const TrackedButton: any;
+declare const MyButton: any;
+
+const eventName = "variable_event";
+
+export default function Page() {
+  // ===== direct =====
+  track("next_event");
+
+  // ===== multiline =====
+  track(
+    "multiline_event"
+  );
+
+  // ===== template string =====
+  track(`template_event`);
+
+  // ===== wrapper function =====
+  trackFeature("wrapper_function");
+
+  // ===== object =====
+  analytics.track("object_track");
+
+  // ===== nested object =====
+  analytics.events.track("nested_track");
+
+  // ===== variable =====
+  track(eventName);
+
+  // ===== conditional =====
+  if (true) {
+    track("conditional_event");
+  }
+
+  // ===== ternary =====
+  true
+    ? track("ternary_a")
+    : track("ternary_b");
+
+  // ===== arrow function =====
+  const run = () => {
+    track("arrow_event");
+  };
+
+  // ===== function =====
+  function test() {
+    track("function_event");
+  }
+
+  // ===== class =====
+  class Service {
+    run() {
+      track("class_event");
+    }
+  }
+
+  return (
+    <>
+      {/* basic */}
+      <Button event="next_button" />
+
+      {/* expression */}
+      <Button event={"expression_event"} />
+
+      {/* wrapper component */}
+      <TrackedButton event="tracked_button" />
+
+      {/* another wrapper */}
+      <MyButton event="my_button" />
+
+      {/* nested */}
+      <div>
+        <Button event="nested_button" />
+      </div>
+
+      {/* conditional */}
+      {true && (
+        <Button event="conditional_button" />
+      )}
+
+      {/* ternary */}
+      {true
+        ? <Button event="ternary_a_button" />
+        : <Button event="ternary_b_button" />
+      }
+
+      {/* array */}
+      {[
+        <Button key="1" event="array_1" />,
+        <Button key="2" event="array_2" />
+      ]}
+    </>
+  );
+}

package/tests/fixtures/frontend/react/App.tsx

@@ -0,0 +1,104 @@
+/* eslint-disable */
+
+declare function track(event: string): void;
+declare function trackFeature(event: string): void;
+
+declare const analytics: any;
+declare const Button: any;
+declare const TrackedButton: any;
+declare const MyButton: any;
+
+const eventName = "variable_event";
+
+// ===== direct =====
+track("direct_event");
+
+// ===== multiline =====
+track(
+  "multiline_event"
+);
+
+// ===== template string =====
+track(`template_event`);
+
+// ===== conditional =====
+if (true) {
+  track("conditional_event");
+}
+
+// ===== ternary =====
+true
+  ? track("ternary_a")
+  : track("ternary_b");
+
+// ===== wrapper function =====
+trackFeature("wrapper_function");
+
+// ===== object function =====
+analytics.track("object_track");
+
+// ===== nested object =====
+analytics.events.track("nested_track");
+
+// ===== variable (optional support) =====
+track(eventName);
+
+// ===== function =====
+function test() {
+  track("function_event");
+}
+
+// ===== arrow function =====
+const run = () => {
+  track("arrow_event");
+};
+
+// ===== class =====
+class TestService {
+  run() {
+    track("class_event");
+  }
+}
+
+// ===== component return =====
+export default function Page() {
+  track("page_event");
+
+  return (
+    <>
+      {/* basic */}
+      <Button event="button_event" />
+
+      {/* wrapper component */}
+      <TrackedButton event="tracked_button" />
+
+      {/* another wrapper */}
+      <MyButton event="my_button" />
+
+      {/* expression */}
+      <Button event={"expression_event"} />
+
+      {/* nested */}
+      <div>
+        <Button event="nested_button" />
+      </div>
+
+      {/* conditional */}
+      {true && (
+        <Button event="conditional_button" />
+      )}
+
+      {/* ternary */}
+      {true
+        ? <Button event="ternary_a_button" />
+        : <Button event="ternary_b_button" />
+      }
+
+      {/* array */}
+      {[
+        <Button key="1" event="array_1" />,
+        <Button key="2" event="array_2" />
+      ]}
+    </>
+  );
+}