Allow fqn names when adding packages

Author: malte-hansen

src/backend/generation.ts

@@ -29,10 +29,11 @@ function isClass(codeUnit: FakeClass | FakePackage): codeUnit is FakeClass {
 
 export function getClassFqn(fakeClass: FakeClass): string {
   let fqn: string = fakeClass.identifier;
-  let obj: FakeClass | FakePackage = fakeClass;
-  while (obj.parent !== undefined) {
-    fqn = obj.parent.name + '.' + fqn;
-    obj = obj.parent;
+  let obj: FakeClass | FakePackage | undefined = fakeClass;
+  while (obj && obj.parent !== undefined) {
+    const parent: FakePackage = obj.parent;
+    fqn = parent.name + '.' + fqn;
+    obj = parent;
   }
   return fqn;
 }
@@ -262,7 +263,7 @@ function generateFakeApp(params: AppGenerationParameters, nameGenerator: NameGen
 
   const fakeApp: FakeApp = {
     name: appName,
-    rootPackage: rootPackage1,
+    rootPackages: [rootPackage1],
     entryPoint: entryPoint,
     classes: classes,
     packages: packages,

src/backend/shared/types.ts

@@ -23,7 +23,7 @@ export interface FakePackage {
 
 export interface FakeApp {
   name: string;
-  rootPackage: FakePackage;
+  rootPackages: Array<FakePackage>;
   entryPoint: FakeClass;
   classes: Array<FakeClass>;
   packages: Array<FakePackage>;

src/backend/utils.ts

@@ -184,7 +184,20 @@ export function appTreeToString(app: FakeApp): string {
     return result.slice(0, -1); // Remove newline
   }
 
-  return packageTreeToString(app.rootPackage);
+  // Handle multiple root packages
+  if (app.rootPackages.length === 0) {
+    return '';
+  }
+  
+  let result = '';
+  app.rootPackages.forEach((rootPkg, idx) => {
+    if (idx > 0) {
+      result += '\n';
+    }
+    result += packageTreeToString(rootPkg);
+  });
+  
+  return result;
 }
 
 /**

src/backend/utils/landscape.utils.ts

@@ -12,7 +12,7 @@ export function cleanLandscapeForSerialization(landscape: Array<FakeApp>): Clean
     const entryPointFqn = getClassFqn(app.entryPoint);
     return {
       name: app.name,
-      rootPackages: [cleanPackage(app.rootPackage)],
+      rootPackages: app.rootPackages.map(cleanPackage),
       entryPointFqn,
       classes: app.classes.map(cleanClass),
       packages: app.packages.map(cleanPackage),
@@ -37,59 +37,16 @@ function cleanClass(cls: FakeClass): CleanedClass {
   };
 }
 
-/**
- * Find class by FQN in an app
- */
-function findClassByFqn(app: FakeApp, fqn: string): FakeClass | null {
-  function searchInPackage(pkg: FakePackage): FakeClass | null {
-    for (const cls of pkg.classes) {
-      const clsFqn = getClassFqn(cls);
-      if (clsFqn === fqn) {
-        return cls;
-      }
-    }
-    for (const subPkg of pkg.subpackages) {
-      const found = searchInPackage(subPkg);
-      if (found) return found;
-    }
-    return null;
-  }
-
-  return searchInPackage(app.rootPackage);
-}
-
 /**
  * Reconstruct parent references after deserialization
  */
 export function reconstructParentReferences(landscapeData: Array<any>): Array<FakeApp> {
   return landscapeData.map((appData: any) => {
     const rootPackages: FakePackage[] = appData.rootPackages || [];
 
-    // For FakeApp, we still use a single rootPackage
-    // If there are multiple root packages, create a synthetic root that contains them all
-    // If there's only one, use it directly
-    // If there are none, create an empty synthetic root
-    let primaryRootPackage: FakePackage;
-    if (rootPackages.length === 0) {
-      primaryRootPackage = {
-        name: appData.name,
-        subpackages: [],
-        classes: [],
-      };
-    } else if (rootPackages.length === 1) {
-      primaryRootPackage = rootPackages[0];
-    } else {
-      // Multiple root packages: create a synthetic root containing them all
-      primaryRootPackage = {
-        name: appData.name,
-        subpackages: rootPackages,
-        classes: [],
-      };
-    }
-
     const app: FakeApp = {
       name: appData.name,
-      rootPackage: primaryRootPackage,
+      rootPackages: rootPackages,
       entryPoint: null as any, // Will be set below
       classes: [],
       packages: [],
@@ -134,6 +91,29 @@ export function reconstructParentReferences(landscapeData: Array<any>): Array<Fa
 
     // Reconstruct entryPoint reference from FQN
     if (appData.entryPointFqn) {
+      function findClassByFqn(app: FakeApp, fqn: string): FakeClass | null {
+        function searchInPackage(pkg: FakePackage): FakeClass | null {
+          for (const cls of pkg.classes) {
+            const clsFqn = getClassFqn(cls);
+            if (clsFqn === fqn) {
+              return cls;
+            }
+          }
+          for (const subPkg of pkg.subpackages) {
+            const found = searchInPackage(subPkg);
+            if (found) return found;
+          }
+          return null;
+        }
+
+        // Search through all root packages
+        for (const rootPkg of app.rootPackages) {
+          const found = searchInPackage(rootPkg);
+          if (found) return found;
+        }
+        return null;
+      }
+
       const entryPoint = findClassByFqn(app, appData.entryPointFqn);
       if (entryPoint) {
         app.entryPoint = entryPoint;

src/frontend/components/LandscapeEditor.tsx

@@ -140,6 +140,50 @@ export function LandscapeEditor({ landscape, onLandscapeUpdated, onError }: Land
     return null;
   };
 
+  /**
+   * Helper function to create or find a package hierarchy from a dot-separated package name.
+   * Returns the deepest package and all newly created packages.
+   */
+  const createPackageHierarchy = (
+    parentPackages: CleanedPackage[],
+    packageNameParts: string[]
+  ): { deepestPackage: CleanedPackage; allCreatedPackages: CleanedPackage[] } => {
+    const allCreatedPackages: CleanedPackage[] = [];
+    let currentPackages = parentPackages;
+    let deepestPackage: CleanedPackage | null = null;
+
+    for (let i = 0; i < packageNameParts.length; i++) {
+      const partName = packageNameParts[i];
+      let foundPackage = currentPackages.find((pkg) => pkg.name === partName);
+
+      if (!foundPackage) {
+        // Create new package
+        foundPackage = {
+          name: partName,
+          classes: [],
+          subpackages: [],
+        };
+        allCreatedPackages.push(foundPackage);
+        // Add to current packages array (either parentPackages for root, or deepestPackage.subpackages for nested)
+        if (deepestPackage) {
+          deepestPackage.subpackages.push(foundPackage);
+        } else {
+          // This is the first level - add to parentPackages array
+          parentPackages.push(foundPackage);
+        }
+      }
+
+      deepestPackage = foundPackage;
+      currentPackages = foundPackage.subpackages;
+    }
+
+    if (!deepestPackage) {
+      throw new Error('Failed to create package hierarchy');
+    }
+
+    return { deepestPackage, allCreatedPackages };
+  };
+
   const updateLocalLandscape = (updated: CleanedLandscape[]) => {
     isInternalUpdateRef.current = true;
     setLocalLandscape(updated);
@@ -247,15 +291,18 @@ export function LandscapeEditor({ landscape, onLandscapeUpdated, onError }: Land
     if (packageName && packageName.trim() !== '') {
       const updated = [...localLandscape];
       const app = updated[appIdx];
-      const newPkg: CleanedPackage = {
-        name: packageName.trim(),
-        classes: [],
-        subpackages: [],
-      };
+      const packageNameParts = packageName.trim().split('.');
+
+      // Create a copy of rootPackages to avoid mutating the original
+      const rootPackagesCopy = [...app.rootPackages];
+
+      // Create or find the package hierarchy
+      const { allCreatedPackages } = createPackageHierarchy(rootPackagesCopy, packageNameParts);
+
       updated[appIdx] = {
         ...app,
-        rootPackages: [...app.rootPackages, newPkg],
-        packages: [...app.packages, newPkg],
+        rootPackages: rootPackagesCopy,
+        packages: [...app.packages, ...allCreatedPackages],
       };
       updateLocalLandscape(updated);
     }
@@ -264,6 +311,30 @@ export function LandscapeEditor({ landscape, onLandscapeUpdated, onError }: Land
   const addPackage = (appIdx: number) => {
     const packageName = prompt('Enter package name:', 'newpackage');
     if (packageName && packageName.trim() !== '') {
+      const trimmedName = packageName.trim();
+
+      // If the package name contains dots, treat it as a hierarchy and add as root package
+      if (trimmedName.includes('.')) {
+        const updated = [...localLandscape];
+        const app = updated[appIdx];
+        const packageNameParts = trimmedName.split('.');
+
+        // Create a copy of rootPackages to avoid mutating the original
+        const rootPackagesCopy = [...app.rootPackages];
+
+        // Create or find the package hierarchy
+        const { allCreatedPackages } = createPackageHierarchy(rootPackagesCopy, packageNameParts);
+
+        updated[appIdx] = {
+          ...app,
+          rootPackages: rootPackagesCopy,
+          packages: [...app.packages, ...allCreatedPackages],
+        };
+        updateLocalLandscape(updated);
+        return;
+      }
+
+      // For non-hierarchical names, use the existing behavior
       const updated = [...localLandscape];
       const app = updated[appIdx];
       // Find the first root package to add subpackage to
@@ -280,7 +351,7 @@ export function LandscapeEditor({ landscape, onLandscapeUpdated, onError }: Land
         }
       }
       const newPkg: CleanedPackage = {
-        name: packageName.trim(),
+        name: trimmedName,
         classes: [],
         subpackages: [],
       };
@@ -304,21 +375,44 @@ export function LandscapeEditor({ landscape, onLandscapeUpdated, onError }: Land
     if (packageName && packageName.trim() !== '') {
       const updated = [...localLandscape];
       const app = updated[appIdx];
-      const newPkg: CleanedPackage = {
-        name: packageName.trim(),
-        classes: [],
-        subpackages: [],
+      const packageNameParts = packageName.trim().split('.');
+
+      // Find the parent package in the updated landscape
+      const findPkgInUpdated = (p: CleanedPackage): CleanedPackage | null => {
+        if (p.name === parentPackageName) return p;
+        for (const subPkg of p.subpackages) {
+          const found = findPkgInUpdated(subPkg);
+          if (found) return found;
+        }
+        return null;
       };
+
+      let parentPkg: CleanedPackage | null = null;
+      for (const rootPkg of app.rootPackages) {
+        parentPkg = findPkgInUpdated(rootPkg);
+        if (parentPkg) break;
+      }
+
+      if (!parentPkg) {
+        onError(`Parent package "${parentPackageName}" not found`);
+        return;
+      }
+
+      // Create or find the package hierarchy under the parent
+      const { allCreatedPackages } = createPackageHierarchy(parentPkg.subpackages, packageNameParts);
+
+      // Update the parent package in the tree to ensure React detects the change
       const updatePkg = (p: CleanedPackage): CleanedPackage => {
         if (p.name === parentPackageName) {
-          return { ...p, subpackages: [...p.subpackages, newPkg] };
+          return { ...p, subpackages: [...parentPkg!.subpackages] };
         }
         return { ...p, subpackages: p.subpackages.map(updatePkg) };
       };
+
       updated[appIdx] = {
         ...app,
         rootPackages: app.rootPackages.map(updatePkg),
-        packages: [...app.packages, newPkg],
+        packages: [...app.packages, ...allCreatedPackages],
       };
       updateLocalLandscape(updated);
     }