Use array of strings for methods in data model

Author: malte-hansen

public/resources/preset-landscapes/distributed-petclinic.json

@@ -9,7 +9,7 @@ import { strict as assert } from 'assert';
 import { NameGenerator } from './naming';
 import { FakeSpan, FakeTrace } from './tracing';
 
-import { AppGenerationParameters, FakeApp, FakeClass, FakeMethod, FakePackage } from './shared/types';
+import { AppGenerationParameters, FakeApp, FakeClass, FakePackage } from './shared/types';
 
 // TraceGenerationParameters uses CommunicationStyle enum, so we keep a local version
 export interface TraceGenerationParameters {
@@ -115,7 +115,7 @@ function generateFakeApp(params: AppGenerationParameters, nameGenerator: NameGen
 
   const classes: Array<FakeClass> = [];
   const packages: Array<FakePackage> = [];
-  const methods: Array<FakeMethod> = [];
+  const methods: Array<string> = [];
 
   const classCount: number = faker.number.int({
     min: params.minClassCount,
@@ -146,11 +146,9 @@ function generateFakeApp(params: AppGenerationParameters, nameGenerator: NameGen
         max: params.maxMethodCount,
       });
       const newMethods = Array.from(Array(numMethods), () => {
-        const newMethod = {
-          identifier: nameGenerator.getRandomMethodName(),
-        };
-        methods.push(newMethod);
-        return newMethod;
+        const methodName = nameGenerator.getRandomMethodName();
+        methods.push(methodName);
+        return methodName;
       });
       const newClass = {
         identifier: nameGenerator.getRandomClassName(),
@@ -241,11 +239,9 @@ function generateFakeApp(params: AppGenerationParameters, nameGenerator: NameGen
       max: params.maxMethodCount,
     });
     const newMethods = Array.from(Array(numMethods), () => {
-      const newMethod = {
-        identifier: nameGenerator.getRandomMethodName(),
-      };
-      methods.push(newMethod);
-      return newMethod;
+      const methodName = nameGenerator.getRandomMethodName();
+      methods.push(methodName);
+      return methodName;
     });
     const newClass = {
       identifier: nameGenerator.getRandomClassName(),
@@ -515,10 +511,10 @@ export function generateFakeTrace(apps: Array<FakeApp>, params: TraceGenerationP
   }
   spanAttrs[ATTR_SERVICE_NAME] = startingApp.name;
   spanAttrs[SEMATTRS_CODE_NAMESPACE] = entryPointFqn;
-  spanAttrs[ATTR_CODE_FUNCTION_NAME] = entryMethod.identifier;
+  spanAttrs[ATTR_CODE_FUNCTION_NAME] = entryMethod;
 
   const entrySpan: FakeSpan = {
-    name: `${entryPointFqn}.${entryMethod.identifier}`,
+    name: `${entryPointFqn}.${entryMethod}`,
     relativeStartTime: 0,
     relativeEndTime: params.duration,
     attributes: { ...spanAttrs },
@@ -540,7 +536,7 @@ export function generateFakeTrace(apps: Array<FakeApp>, params: TraceGenerationP
   // Collect all methods for visitAllMethods feature
   interface MethodReference {
     class: FakeClass;
-    method: FakeMethod;
+    method: string;
   }
   const allMethods: Array<MethodReference> = [];
   classes.forEach((cls) => {
@@ -566,7 +562,7 @@ export function generateFakeTrace(apps: Array<FakeApp>, params: TraceGenerationP
     // Select next class for method call
 
     let nextClass: FakeClass;
-    let nextMethod: FakeMethod;
+    let nextMethod: string;
 
     // If visitAllMethods is enabled and there are unvisited methods, prioritize them
     if (params.visitAllMethods && visitedMethods.size < allMethods.length) {
@@ -636,9 +632,9 @@ export function generateFakeTrace(apps: Array<FakeApp>, params: TraceGenerationP
     const classFqn = getClassFqn(nextClass);
     spanAttrs[ATTR_SERVICE_NAME] = nextClass.parentAppName;
     spanAttrs[SEMATTRS_CODE_NAMESPACE] = classFqn;
-    spanAttrs[ATTR_CODE_FUNCTION_NAME] = nextMethod.identifier;
+    spanAttrs[ATTR_CODE_FUNCTION_NAME] = nextMethod;
     const nextSpan: FakeSpan = {
-      name: `${classFqn}.${nextMethod.identifier}`,
+      name: `${classFqn}.${nextMethod}`,
       relativeStartTime: timePassed,
       relativeEndTime: -1,
       attributes: { ...spanAttrs },

public/resources/preset-landscapes/petclinic-demo.json

@@ -16,8 +16,8 @@ export function createServer(): Express {
 
   // Middleware
   app.use(cors());
-  app.use(express.json());
-  app.use(express.urlencoded({ extended: true }));
+  app.use(express.json({ limit: '50mb' }));
+  app.use(express.urlencoded({ extended: true, limit: '50mb' }));
 
   // Health check
   app.get('/health', (req, res) => {

public/resources/preset-landscapes/petclinic.json

@@ -2,6 +2,7 @@ import { generateFakeApps } from '../generation';
 import { LandscapeStore } from '../landscape';
 import { AppGenerationParameters } from '../shared/types';
 import { isValidInteger } from '../utils';
+import { convertStructureLandscapeToRegular, isStructureLandscape } from '../utils/landscape-structure-converter';
 import {
   CleanedLandscape,
   cleanLandscapeForSerialization,
@@ -39,9 +40,19 @@ export class LandscapeService {
   /**
    * Update the landscape
    */
-  updateLandscape(landscapeData: any[]): CleanedLandscape[] {
+  updateLandscape(landscapeData: any): CleanedLandscape[] {
+    // Check if this is a structure landscape format
+    if (isStructureLandscape(landscapeData)) {
+      // Convert structure format to regular format
+      const convertedLandscape = convertStructureLandscapeToRegular(landscapeData);
+      const landscape = reconstructParentReferences(convertedLandscape);
+      this.landscapeStore.setLandscape(landscape);
+      return cleanLandscapeForSerialization(landscape);
+    }
+
+    // Regular landscape format (array of CleanedLandscape)
     if (!Array.isArray(landscapeData)) {
-      throw new Error('Landscape must be an array');
+      throw new Error('Landscape must be an array or structure landscape format');
     }
     const landscape = reconstructParentReferences(landscapeData);
     this.landscapeStore.setLandscape(landscape);

public/resources/preset-landscapes/plant-uml.json

@@ -8,7 +8,7 @@ export interface FakeMethod {
 
 export interface FakeClass {
   identifier: string;
-  methods: Array<FakeMethod>;
+  methods: Array<string>;
   parent?: FakePackage;
   parentAppName: string;
   linkedClass?: FakeClass;
@@ -27,7 +27,7 @@ export interface FakeApp {
   entryPoint: FakeClass;
   classes: Array<FakeClass>;
   packages: Array<FakePackage>;
-  methods: Array<FakeMethod>;
+  methods: Array<string>;
 }
 
 /**
@@ -113,7 +113,7 @@ export interface CleanedLandscape {
   entryPointFqn: string;
   classes: CleanedClass[];
   packages: CleanedPackage[];
-  methods: FakeMethod[];
+  methods: string[];
 }
 
 export interface CleanedPackage {
@@ -124,6 +124,6 @@ export interface CleanedPackage {
 
 export interface CleanedClass {
   identifier: string;
-  methods: FakeMethod[];
+  methods: string[];
   parentAppName: string;
 }

src/backend/generation.ts

@@ -0,0 +1,160 @@
+import { CleanedClass, CleanedLandscape, CleanedPackage } from '../shared/types';
+
+interface StructureMethod {
+  name: string;
+  methodHash?: string;
+}
+
+interface StructureClass {
+  name: string;
+  methods: StructureMethod[];
+}
+
+interface StructurePackage {
+  name: string;
+  subPackages: StructurePackage[];
+  classes: StructureClass[];
+}
+
+interface StructureApplication {
+  name: string;
+  language: string;
+  instanceId: string;
+  packages: StructurePackage[];
+}
+
+interface StructureNode {
+  ipAddress: string;
+  hostName: string;
+  applications: StructureApplication[];
+}
+
+export interface StructureLandscape {
+  landscapeToken: string;
+  nodes: StructureNode[];
+}
+
+/**
+ * Check if the given data is a structure landscape JSON format
+ */
+export function isStructureLandscape(data: any): data is StructureLandscape {
+  return (
+    typeof data === 'object' &&
+    data !== null &&
+    typeof data.landscapeToken === 'string' &&
+    Array.isArray(data.nodes) &&
+    data.nodes.length > 0 &&
+    data.nodes.every(
+      (node: any) =>
+        typeof node === 'object' &&
+        node !== null &&
+        typeof node.ipAddress === 'string' &&
+        typeof node.hostName === 'string' &&
+        Array.isArray(node.applications)
+    )
+  );
+}
+
+/**
+ * Convert structure landscape format to landscape format for trace generator
+ */
+export function convertStructureLandscapeToRegular(structureData: StructureLandscape): CleanedLandscape[] {
+  const landscapes: CleanedLandscape[] = [];
+
+  // Process each node
+  for (const node of structureData.nodes) {
+    // Process each application in the node
+    for (const app of node.applications) {
+      const allClasses: CleanedClass[] = [];
+      const allPackages: CleanedPackage[] = [];
+      const allMethodsSet = new Set<string>();
+
+      // Convert structure packages to regular packages recursively
+      function convertPackage(structPkg: StructurePackage): CleanedPackage {
+        const regularPkg: CleanedPackage = {
+          name: structPkg.name,
+          classes: [],
+          subpackages: [],
+        };
+
+        // Convert classes
+        for (const structClass of structPkg.classes) {
+          const methods: string[] = [];
+          for (const structMethod of structClass.methods) {
+            const methodName = structMethod.name;
+            methods.push(methodName);
+            // Deduplicate methods by name
+            if (!allMethodsSet.has(methodName)) {
+              allMethodsSet.add(methodName);
+            }
+          }
+
+          const regularClass: CleanedClass = {
+            identifier: structClass.name,
+            methods,
+            parentAppName: app.name,
+          };
+
+          regularPkg.classes.push(regularClass);
+          allClasses.push(regularClass);
+        }
+
+        // Convert subpackages recursively
+        for (const structSubPkg of structPkg.subPackages) {
+          const regularSubPkg = convertPackage(structSubPkg);
+          regularPkg.subpackages.push(regularSubPkg);
+        }
+
+        allPackages.push(regularPkg);
+        return regularPkg;
+      }
+
+      // Convert all root packages
+      const rootPackages: CleanedPackage[] = app.packages.map((structPkg) => convertPackage(structPkg));
+
+      // Build FQN for entry point - find first class with methods, or first class
+      let entryPointFqn = '';
+      if (allClasses.length > 0) {
+        const entryPointClass = allClasses.find((cls) => cls.methods.length > 0) || allClasses[0];
+
+        // Build FQN by traversing package tree
+        function buildFqnForClass(cls: CleanedClass): string {
+          // Find the package containing this class
+          function findPackageForClass(pkg: CleanedPackage, path: string[]): string | null {
+            if (pkg.classes.includes(cls)) {
+              path.push(pkg.name);
+              path.push(cls.identifier);
+              return path.join('.');
+            }
+            for (const subPkg of pkg.subpackages) {
+              const found = findPackageForClass(subPkg, [...path, pkg.name]);
+              if (found) return found;
+            }
+            return null;
+          }
+
+          for (const rootPkg of rootPackages) {
+            const fqn = findPackageForClass(rootPkg, []);
+            if (fqn) return fqn;
+          }
+
+          // Fallback: just return class name
+          return cls.identifier;
+        }
+
+        entryPointFqn = buildFqnForClass(entryPointClass);
+      }
+
+      landscapes.push({
+        name: app.name,
+        rootPackages,
+        entryPointFqn,
+        classes: allClasses,
+        packages: allPackages,
+        methods: Array.from(allMethodsSet),
+      });
+    }
+  }
+
+  return landscapes;
+}