@eventvisor/core 0.14.0 → 0.16.0

package/src/generate-code/typescript/generateInterface.ts

@@ -0,0 +1,89 @@
+import { JSONSchema } from "@eventvisor/types";
+
+export function generateInterface(schema: JSONSchema, interfaceName: string): string {
+  function generateType(schema: JSONSchema, indent: number = 0): string {
+    const indentStr = "  ".repeat(indent);
+
+    // Handle const
+    if (schema.const !== undefined) {
+      return JSON.stringify(schema.const);
+    }
+
+    // Handle enum
+    if (schema.enum && schema.enum.length > 0) {
+      const enumValues = schema.enum.map((val) => JSON.stringify(val));
+      return enumValues.join(" | ");
+    }
+
+    // Handle array
+    if (schema.type === "array") {
+      if (schema.items) {
+        if (Array.isArray(schema.items)) {
+          // Tuple type
+          const tupleTypes = schema.items.map((item) => generateType(item, indent));
+          return `[${tupleTypes.join(", ")}]`;
+        } else {
+          // Array type
+          const itemType = generateType(schema.items, indent);
+          return `${itemType}[]`;
+        }
+      }
+      return "any[]";
+    }
+
+    // Handle object
+    if (schema.type === "object" || (schema.properties && !schema.type)) {
+      if (!schema.properties || Object.keys(schema.properties).length === 0) {
+        return "Record<string, any>";
+      }
+
+      const required = schema.required || [];
+      const properties = Object.entries(schema.properties).map(([key, propSchema]) => {
+        const isRequired = required.includes(key);
+        const optionalMarker = isRequired ? "" : "?";
+        const propType = generateType(propSchema, indent + 1);
+        return `${indentStr}  ${key}${optionalMarker}: ${propType};`;
+      });
+
+      return `{\n${properties.join("\n")}\n${indentStr}}`;
+    }
+
+    // Handle primitives
+    switch (schema.type) {
+      case "string":
+        return "string";
+      case "number":
+      case "integer":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "null":
+        return "null";
+      default:
+        return "any";
+    }
+  }
+
+  const typeDefinition = generateType(schema);
+
+  // Use 'type' for primitives, arrays, tuples, enums, const, and Record types
+  // Use 'interface' for object types with properties
+  // Object types have property declarations (contain ': ' or '?: ' followed by type)
+  // Const objects are JSON stringified and don't have property declarations
+  const trimmed = typeDefinition.trim();
+  const isArrayType = trimmed.endsWith("[]");
+  const isObjectType =
+    !isArrayType &&
+    trimmed.startsWith("{") &&
+    !trimmed.startsWith('{"') &&
+    (trimmed.includes(":\n") ||
+      trimmed.includes("?:\n") ||
+      trimmed.includes(": ") ||
+      trimmed.includes("?: "));
+  const declarationType = isObjectType ? "interface" : "type";
+  const separator = isObjectType ? " " : " = ";
+
+  const description = schema.description ? `/** ${schema.description} */\n` : "";
+
+  return `${description}export ${declarationType} ${interfaceName}${separator}${typeDefinition}`;
+}

package/src/generate-code/typescript/index.ts

@@ -0,0 +1,199 @@
+import fs from "fs";
+import path from "path";
+
+import { Dependencies } from "../../dependencies";
+import { generateInterface } from "./generateInterface";
+
+export function getInterfaceName(entityName: string, suffix: string = ""): string {
+  return (
+    entityName
+      .replace(/[^a-zA-Z0-9]+/g, " ") // Replace all special characters with spaces
+      .split(" ")
+      .filter((word) => word.length > 0) // Remove empty strings
+      .map((word) => {
+        // Check if word already has mixed case (camelCase/PascalCase pattern)
+        // This detects if there are both lowercase and uppercase letters in the word
+        const hasLowercase = /[a-z]/.test(word);
+        const hasUppercase = /[A-Z]/.test(word);
+        const hasMixedCase = hasLowercase && hasUppercase;
+
+        if (hasMixedCase) {
+          // Preserve existing casing structure, just ensure first letter is uppercase
+          return word.charAt(0).toUpperCase() + word.slice(1);
+        }
+        // Normal PascalCase transformation for words without mixed case
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+      })
+      .join("") + suffix
+  );
+}
+
+export async function generateTypeScriptCodeForProject(deps: Dependencies, outputPath: string) {
+  const { datasource } = deps;
+
+  /**
+   * Attributes
+   */
+  const generatedAttributes: {
+    entityName: string;
+    interfaceName: string;
+    code: string;
+  }[] = [];
+
+  const attributes = await datasource.listAttributes();
+  for (const attribute of attributes) {
+    const parsedAttribute = await datasource.readAttribute(attribute);
+    if (!parsedAttribute) {
+      continue;
+    }
+    const interfaceName = getInterfaceName(attribute, "Attribute");
+    const interfaceCode = generateInterface(parsedAttribute, interfaceName);
+
+    generatedAttributes.push({
+      entityName: attribute,
+      interfaceName,
+      code: interfaceCode,
+    });
+  }
+
+  const attributesCodePath = path.resolve(outputPath, "attributes.ts");
+  let attributesContent = generatedAttributes
+    .map(
+      ({ entityName, code }) => `/**
+ * ${entityName}
+ */
+${code}
+`,
+    )
+    .join("\n");
+
+  const allAttributesContent = `
+/**
+ * Attributes
+ */
+export interface Attributes {
+${generatedAttributes.map(({ entityName, interfaceName }) => `  ${entityName}: ${interfaceName};`).join("\n")}
+}
+`;
+
+  attributesContent += allAttributesContent;
+
+  fs.writeFileSync(attributesCodePath, attributesContent);
+
+  /**
+   * Events
+   */
+  const generatedEvents: {
+    entityName: string;
+    interfaceName: string;
+    code: string;
+  }[] = [];
+
+  const events = await datasource.listEvents();
+  for (const event of events) {
+    const parsedEvent = await datasource.readEvent(event);
+    if (!parsedEvent) {
+      continue;
+    }
+    const interfaceName = getInterfaceName(event, "Event");
+    const interfaceCode = generateInterface(parsedEvent, interfaceName);
+
+    generatedEvents.push({
+      entityName: event,
+      interfaceName,
+      code: interfaceCode,
+    });
+  }
+
+  const eventsCodePath = path.resolve(outputPath, "events.ts");
+  let eventsContent = generatedEvents
+    .map(
+      ({ entityName, code }) => `/**
+ * ${entityName}
+ */
+${code}
+`,
+    )
+    .join("\n");
+
+  const allEventsContent = `
+/**
+ * Events
+ */
+export interface Events {
+${generatedEvents.map(({ entityName, interfaceName }) => `  ${entityName}: ${interfaceName};`).join("\n")}
+}
+`;
+
+  eventsContent += allEventsContent;
+
+  fs.writeFileSync(eventsCodePath, eventsContent);
+
+  /**
+   * Index
+   */
+  let indexContent = `import type { Eventvisor } from "@eventvisor/sdk";
+import type { Value } from "@eventvisor/types";
+
+import type { Events } from "./events";
+import type { Attributes } from "./attributes";
+
+/**
+ * Instance
+ */
+let instance: Eventvisor | null = null;
+
+export function setInstance(instance: Eventvisor) {
+  instance = instance;
+}
+
+/**
+ * Event
+ */
+type TrackHandler = (eventName: string, payload: Value) => void;
+
+let trackHandler: TrackHandler | null = null;
+
+export function assignEventHandler(handler: TrackHandler | null) {
+  trackHandler = handler;
+}
+
+export function track<K extends keyof Events>(eventName: K, payload: Events[K]): void {
+  if (instance) {
+    instance.track(eventName, payload as unknown as Value);
+  }
+
+  if (trackHandler) {
+    trackHandler(eventName, payload as unknown as Value);
+  }
+}
+
+/**
+ * Attribute
+ */
+
+type SetAttributeHandler = (attributeName: string, value: Value) => void;
+
+let setAttributeHandler: SetAttributeHandler | null = null;
+
+export function assignAttributeHandler(handler: SetAttributeHandler | null) {
+  setAttributeHandler = handler;
+}
+
+export function setAttribute<K extends keyof Attributes>(
+  attributeName: K,
+  value: Attributes[K],
+): void {
+  if (instance) {
+    instance.setAttribute(attributeName, value as unknown as Value);
+  }
+
+  if (setAttributeHandler) {
+    setAttributeHandler(attributeName, value as unknown as Value);
+  }
+}
+`;
+
+  const indexCodePath = path.resolve(outputPath, "index.ts");
+  fs.writeFileSync(indexCodePath, indexContent);
+}