@mattisvensson/strapi-plugin-webatlas 0.9.5 → 0.10.0

package/dist/server/index.js

@@ -1,10 +1,4 @@
 "use strict";
-function getPath(parentPath, slug) {
-  if (!slug) return null;
-  if (!parentPath) return slug;
-  const newPath = parentPath.endsWith("/") ? parentPath : `${parentPath}/`;
-  return `${newPath}${slug}`;
-}
 function transformToUrl(input) {
   const specialCharMap = {
     "ü": "ue",
@@ -16,6 +10,7 @@ function transformToUrl(input) {
   input = input.replace(/\/+/g, "/");
   input = input.startsWith("/") ? input.slice(1) : input;
   input = input.endsWith("/") ? input.slice(0, -1) : input;
+  input = input.replace(/\//g, "-");
   for (const char in specialCharMap) {
     const regex = new RegExp(char, "g");
     input = input.replace(regex, specialCharMap[char]);
@@ -26,7 +21,7 @@ function transformToUrl(input) {
   input = input.replace(/-+/g, "-");
   return input;
 }
-const version = "0.9.5";
+const version = "0.9.6";
 const keywords = [];
 const type = "commonjs";
 const exports$1 = {
@@ -151,15 +146,10 @@ async function checkPathExists(path, targetRoutePath) {
   const entities = await strapi.documents(waRoute).findMany({
     filters: {
       $or: [
-        {
-          path
-        },
-        {
-          slug: path
-        },
-        {
-          uidPath: path
-        }
+        { path },
+        { slug: path },
+        { uidPath: path },
+        { canonicalPath: path }
       ]
     }
   });
@@ -186,27 +176,12 @@ async function duplicateCheck(initialPath, targetRouteDocumentId) {
     }
     return uniquePath;
   } catch (e) {
-    console.log(e);
+    strapi.log.error(e);
   }
 }
 async function createNavItem(data) {
   try {
     if (!data.route || !data.navigation) return null;
-    const parent = data.parent ? await strapi.documents(waNavItem).findOne({
-      documentId: data.parent,
-      populate: ["route"]
-    }) : null;
-    const route2 = data.route ? await strapi.documents(waRoute).findOne({
-      documentId: data.route
-    }) : null;
-    let path = route2.slug;
-    if (route2.type === "internal" && !route2.isOverride && parent?.route.type === "internal") path = getPath(parent?.route?.path, route2.slug);
-    await strapi.documents(waRoute).update({
-      documentId: data.route,
-      data: {
-        path
-      }
-    });
     const entity = await strapi.documents(waNavItem).create({
       data: {
         navigation: data.navigation,
@@ -217,7 +192,7 @@ async function createNavItem(data) {
     });
     return entity;
   } catch (e) {
-    console.log(e);
+    strapi.log.error(e);
   }
 }
 async function updateNavItem(documentId, data) {
@@ -230,7 +205,7 @@ async function updateNavItem(documentId, data) {
       data: updateData
     });
   } catch (e) {
-    console.log(e);
+    strapi.log.error(e);
   }
 }
 async function deleteNavItem(documentId) {
@@ -240,7 +215,7 @@ async function deleteNavItem(documentId) {
     });
     return true;
   } catch (e) {
-    console.log(e);
+    strapi.log.error(e);
   }
 }
 function getAdminService() {
@@ -282,7 +257,31 @@ async function createExternalRoute(data) {
       }
     });
   } catch (e) {
-    console.log(e);
+    strapi.log.error(e);
+  }
+}
+async function updateRoute(documentId, data) {
+  try {
+    const entity = await strapi.documents(waRoute).update({
+      documentId,
+      data: {
+        ...data
+      }
+    });
+    return entity;
+  } catch (e) {
+    strapi.log.error(e);
+  }
+}
+async function deleteRoute(documentId) {
+  try {
+    await strapi.documents(waRoute).delete({
+      documentId
+    });
+    return true;
+  } catch (e) {
+    strapi.log.error(e);
+    return false;
   }
 }
 function buildStructuredNavigation(navigation2, variant = "nested") {
@@ -336,7 +335,7 @@ function buildStructuredNavigation(navigation2, variant = "nested") {
       return { ...navigation2, items: flattenedItems };
     }
   } catch (error) {
-    console.error(error);
+    strapi.log.error(error);
     throw error;
   }
 }
@@ -377,8 +376,6 @@ function extractRouteAndItems(items) {
     delete route2.createdAt;
     delete route2.updatedAt;
     delete route2.isOverride;
-    delete route2.internal;
-    delete route2.wrapper;
     return {
       __component: route2.type === "wrapper" ? `${PLUGIN_ID}.wrapper` : `${PLUGIN_ID}.route`,
       type: route2.type,
@@ -4399,10 +4396,406 @@ function cleanRootKeys(obj) {
 function removeWaFields(obj) {
   delete obj["webatlas_path"];
   delete obj["webatlas_override"];
+  delete obj["webatlas_parent"];
   return obj;
 }
+async function buildCanonicalPath(slug, parentDocumentId) {
+  try {
+    const parentRoute = await strapi.documents(waRoute).findOne({
+      documentId: parentDocumentId
+    });
+    const parentCanonicalPath = parentRoute?.canonicalPath || "";
+    const canonicalPath = `${parentCanonicalPath ? parentCanonicalPath + "/" : ""}${slug}`;
+    return canonicalPath;
+  } catch (err) {
+    strapi.log.error("Error building canonical path:", err);
+    return slug;
+  }
+}
+async function cascadeCanonicalPathUpdates(parentRouteId, newParentCanonicalPath) {
+  const children = await strapi.db.query(waRoute).findMany({
+    where: {
+      parent: {
+        documentId: parentRouteId
+      }
+    }
+  });
+  for (const child of children) {
+    const newCanonicalPath = `${newParentCanonicalPath}/${child.slug}`;
+    const updateData = {
+      canonicalPath: newCanonicalPath,
+      // Only update path if not manually overridden
+      ...child.isOverride ? {} : { path: newCanonicalPath }
+    };
+    await strapi.documents(waRoute).update({
+      documentId: child.documentId,
+      data: updateData
+    });
+    await cascadeCanonicalPathUpdates(child.documentId, newCanonicalPath);
+  }
+}
+async function getRouteDescendants(routeId) {
+  const descendants = [];
+  const stack = [routeId];
+  while (stack.length > 0) {
+    const currentId = stack.pop();
+    if (!currentId) continue;
+    const children = await strapi.documents(waRoute).findMany({
+      filters: {
+        parent: {
+          documentId: currentId
+        }
+      }
+    });
+    for (const child of children) {
+      descendants.push(child.documentId);
+      stack.push(child.documentId);
+    }
+  }
+  return descendants;
+}
+async function getNonInternalRouteIds() {
+  const routes2 = await strapi.documents(waRoute).findMany({
+    filters: {
+      type: {
+        $ne: "internal"
+      }
+    }
+  });
+  const routeIds = routes2.map((route2) => route2.documentId);
+  return routeIds;
+}
+async function validateRouteDependencies({
+  routeId,
+  newParentId
+}) {
+  if (!newParentId) return true;
+  const normalizedRouteId = routeId ?? void 0;
+  const parentRoute = await strapi.documents(waRoute).findOne({
+    documentId: newParentId
+  });
+  if (!parentRoute) {
+    throw new Error(`Parent route not found: ${newParentId}`);
+  }
+  if (parentRoute?.type === "external") {
+    throw new Error("External routes cannot have children");
+  }
+  if (!normalizedRouteId) return true;
+  const descendants = await getRouteDescendants(normalizedRouteId);
+  const nonInternalRouteIds = await getNonInternalRouteIds();
+  if (normalizedRouteId === newParentId || descendants.includes(newParentId) || nonInternalRouteIds.includes(newParentId)) {
+    throw new Error(`Circular dependency detected: Cannot set route ${newParentId} as parent of ${normalizedRouteId}`);
+  }
+  return true;
+}
+async function buildNavigationPath({
+  slug,
+  routeDocumentId,
+  calculatedParent
+}) {
+  let parentDocumentId = calculatedParent;
+  let parent = null;
+  if (parentDocumentId) {
+    do {
+      const navItem = await strapi.documents(waNavItem).findOne({
+        documentId: parentDocumentId,
+        populate: ["route", "parent"]
+      });
+      parent = navItem;
+      parentDocumentId = navItem?.parent?.documentId || null;
+      if (parent?.route?.type === "internal") break;
+    } while (parentDocumentId);
+  }
+  if (parent?.route?.type !== "internal")
+    parent = null;
+  if (slug.startsWith("/")) slug = slug.substring(1);
+  const newPath = parent?.route ? `${parent.route.path}/${slug}` : `${slug}`;
+  const validatedPath = await duplicateCheck(newPath, routeDocumentId);
+  return validatedPath;
+}
+async function handleItemDeletion(navigationItems) {
+  const errors = [];
+  let items = [...navigationItems];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (item.clientModifications?.type === "delete") {
+      try {
+        if (item.documentId) {
+          await deleteNavItem(item.documentId);
+        }
+        if (item.route.type !== "internal") {
+          await deleteRoute(item.route.documentId);
+        }
+        const newItems = reduceDepthOfOrphanedItems(items, item.documentId);
+        if (!newItems) {
+          throw new Error("Failed to reduce depth of orphaned items");
+        }
+        items = newItems;
+        i--;
+      } catch (err) {
+        const errorMsg = `Error deleting navigation item: ${err instanceof Error ? err.message : String(err)}`;
+        errors.push(errorMsg);
+        strapi.log.error(errorMsg, err);
+      }
+      continue;
+    }
+    if (!item.route && item.documentId) {
+      try {
+        strapi.log.warn("Navigation item without route found. Deleting it.", item);
+        await deleteNavItem(item.documentId);
+        items.splice(i, 1);
+        i--;
+      } catch (err) {
+        const errorMsg = `Error deleting navigation item without route: ${err instanceof Error ? err.message : String(err)}`;
+        errors.push(errorMsg);
+        strapi.log.error(errorMsg, err);
+      }
+      continue;
+    }
+  }
+  return {
+    success: errors.length === 0,
+    items,
+    errors
+  };
+}
+async function handleItemUpdate({
+  item,
+  calculatedParent,
+  calculatedOrder,
+  navigationId,
+  newNavItemsMap
+}) {
+  const errors = [];
+  const isCreate = item.clientModifications?.type === "create";
+  const isUpdate = item.clientModifications?.type === "update";
+  const isInternal = item.route.type === "internal";
+  if (isCreate && !item.clientModifications.route) {
+    try {
+      const newRoute = await createExternalRoute({
+        title: item.route.title,
+        slug: item.route.slug,
+        path: item.route.path,
+        type: item.route.type
+      });
+      const newNavItem = await createNavItem({
+        route: newRoute.documentId,
+        navigation: navigationId,
+        parent: calculatedParent,
+        order: calculatedOrder
+      });
+      if (newNavItem) newNavItemsMap.set(item.documentId, newNavItem);
+    } catch (err) {
+      errors.push(err instanceof Error ? err.message : String(err));
+      strapi.log.error(`Error creating navigation item '${item.route.title}': `, err);
+    }
+    return { success: errors.length === 0, errors };
+  }
+  if (isCreate && item.clientModifications.route) {
+    try {
+      const route2 = await strapi.documents(waRoute).findOne({
+        documentId: item.clientModifications.route
+      });
+      if (!route2) throw new Error(`Related route not found for new navigation item '${item.route.title}'`);
+      const path = await buildNavigationPath({
+        slug: item.route.slug,
+        routeDocumentId: route2.documentId,
+        calculatedParent
+      });
+      await updateRoute(route2.documentId, {
+        title: item.route.title,
+        slug: item.route.slug,
+        path,
+        isOverride: path !== route2.canonicalPath
+      });
+      const newNavItem = await createNavItem({
+        route: item.clientModifications.route,
+        navigation: item.clientModifications.navigation,
+        parent: calculatedParent,
+        order: calculatedOrder
+      });
+      if (newNavItem) newNavItemsMap.set(item.documentId, newNavItem);
+    } catch (err) {
+      errors.push(err instanceof Error ? err.message : String(err));
+      strapi.log.error(`Error creating navigation item with existing route '${item.route.title}': `, err);
+    }
+    return { success: errors.length === 0, errors };
+  }
+  const needsRouteUpdate = isUpdate || isInternal;
+  if (needsRouteUpdate || isInternal) {
+    try {
+      const route2 = await strapi.documents(waRoute).findOne({
+        documentId: item.route.documentId
+      });
+      if (!route2) throw new Error(`Related route not found for navigation item '${item.route.title}'`);
+      const slug = item.clientModifications?.slug || item.route.slug;
+      const path = isInternal ? await buildNavigationPath({ slug, routeDocumentId: route2.documentId, calculatedParent }) : slug;
+      if (needsRouteUpdate) {
+        await updateRoute(route2.documentId, {
+          title: item.clientModifications?.title || item.route.title,
+          slug,
+          path,
+          isOverride: path !== route2.canonicalPath
+        });
+      }
+      if (isInternal) {
+        await strapi.entityService.update(item.route.relatedContentType, item.route.relatedDocumentId, {
+          data: {
+            webatlas_path: path,
+            webatlas_override: path !== route2.canonicalPath
+          }
+        });
+      }
+    } catch (err) {
+      errors.push(err instanceof Error ? err.message : String(err));
+      strapi.log.error(`Error processing route for navigation item '${item.route.title}': `, err);
+    }
+  }
+  await updateNavItem(item.documentId, {
+    parent: calculatedParent,
+    order: calculatedOrder
+  });
+  return {
+    success: errors.length === 0,
+    errors
+  };
+}
+function calculateParentAndOrder({
+  navigationItems,
+  item,
+  index: index2,
+  parentIds,
+  groupIndices,
+  newNavItemsMap
+}) {
+  if (item.depth === 0) {
+    if (groupIndices[0] !== void 0) {
+      groupIndices[0] = groupIndices[0] + 1;
+    } else {
+      groupIndices[0] = 0;
+    }
+    parentIds.length = 0;
+  } else {
+    const previousItem = navigationItems[index2 - 1];
+    if (previousItem && typeof previousItem.depth === "number") {
+      if (item.depth === previousItem.depth + 1) {
+        parentIds.push(previousItem.documentId.startsWith("temp-") ? newNavItemsMap.get(previousItem.documentId)?.documentId || previousItem.documentId : previousItem.documentId);
+        groupIndices[item.depth] = 0;
+      } else if (item.depth <= previousItem.depth) {
+        const diff = previousItem.depth - item.depth;
+        for (let i = 0; i < diff; i++) {
+          parentIds.pop();
+          groupIndices.pop();
+        }
+        groupIndices[item.depth] = (groupIndices[item.depth] || 0) + 1;
+      } else {
+        groupIndices[item.depth] = (groupIndices[item.depth] || 0) + 1;
+      }
+    }
+  }
+  const calculatedParent = parentIds.at(-1) || null;
+  const calculatedOrder = groupIndices[item.depth] || 0;
+  return {
+    calculatedParent,
+    calculatedOrder
+  };
+}
+const migration_001_canonical_path = {
+  version: "001",
+  description: "Migrate title field to canonicalPath using transformToUrl",
+  async up(strapi2) {
+    strapi2.log.info("[webatlas] Starting canonical path migration...");
+    try {
+      const routes2 = await strapi2.db?.query(waRoute).findMany({
+        where: {
+          title: {
+            $notNull: true,
+            $ne: ""
+          },
+          $or: [
+            { canonicalPath: { $null: true } },
+            { canonicalPath: "" }
+          ]
+        },
+        populate: ["parent"]
+      });
+      if (!routes2 || routes2.length === 0) {
+        strapi2.log.info("[webatlas] No routes found that need canonical path migration");
+        return;
+      }
+      strapi2.log.info(`[webatlas] Found ${routes2.length} routes to migrate`);
+      let migratedCount = 0;
+      let errorCount = 0;
+      const chunkSize = 50;
+      for (let i = 0; i < routes2.length; i += chunkSize) {
+        const chunk = routes2.slice(i, i + chunkSize);
+        await Promise.all(chunk.map(async (route2) => {
+          try {
+            const transformedTitle = transformToUrl(route2.title);
+            const parentId = route2.parent?.id || null;
+            const canonicalPath = await buildCanonicalPath(transformedTitle, parentId);
+            await strapi2.db?.query(waRoute).update({
+              where: { id: route2.id },
+              data: { canonicalPath }
+            });
+            migratedCount++;
+            if (migratedCount % 25 === 0) {
+              strapi2.log.info(`[webatlas] Migrated ${migratedCount}/${routes2.length} routes`);
+            }
+          } catch (error) {
+            strapi2.log.error(`[webatlas] Failed to migrate route ${route2.id}:`, error);
+            errorCount++;
+          }
+        }));
+      }
+      strapi2.log.info(`[webatlas] Canonical path migration completed. Migrated: ${migratedCount}, Errors: ${errorCount}`);
+      if (errorCount > 0) {
+        strapi2.log.warn(`[webatlas] ${errorCount} routes failed to migrate. Check logs for details.`);
+      }
+    } catch (error) {
+      strapi2.log.error("[webatlas] Canonical path migration failed:", error);
+      throw error;
+    }
+  }
+};
+const migrations = [
+  migration_001_canonical_path
+];
+const runMigrations = async (strapi2) => {
+  const pluginStore = strapi2.store({ type: "plugin", name: PLUGIN_ID });
+  let config2 = await pluginStore.get({ key: "config" });
+  if (!config2) {
+    config2 = { migrationVersion: "0" };
+  }
+  const currentVersion = config2.migrationVersion || "0";
+  const pendingMigrations = migrations.filter((migration) => migration.version > currentVersion);
+  if (pendingMigrations.length === 0) {
+    strapi2.log.info("[webatlas] All migrations up to date");
+    return;
+  }
+  strapi2.log.info(`[webatlas] Running ${pendingMigrations.length} migration(s)...`);
+  for (const migration of pendingMigrations) {
+    try {
+      strapi2.log.info(`[webatlas] Running migration ${migration.version}: ${migration.description}`);
+      await migration.up(strapi2);
+      await pluginStore.set({
+        key: "config",
+        value: {
+          ...config2,
+          migrationVersion: migration.version
+        }
+      });
+      strapi2.log.info(`[webatlas] Migration ${migration.version} completed successfully`);
+    } catch (error) {
+      strapi2.log.error(`[webatlas] Migration ${migration.version} failed:`, error);
+      throw error;
+    }
+  }
+  strapi2.log.info("[webatlas] All migrations completed successfully");
+};
 const bootstrap = async ({ strapi: strapi2 }) => {
   try {
+    await runMigrations(strapi2);
     const actions = [
       {
         section: "plugins",
@@ -4454,22 +4847,20 @@ const bootstrap = async ({ strapi: strapi2 }) => {
   });
   let newConfig = {
     ...config2,
-    selectedContentTypes: [...config2?.selectedContentTypes || []],
+    selectedContentTypes: [],
     navigation: {
       maxDepth: config2?.navigation?.maxDepth || 1,
       ...config2?.navigation
-    }
+    },
+    migrationVersion: config2?.migrationVersion || "0"
   };
   enabledContentTypes.forEach((type2) => {
-    const exists = config2?.selectedContentTypes?.find((ct) => ct.uid === type2.uid);
-    if (!exists) {
-      newConfig.selectedContentTypes.push({
-        uid: type2.uid,
-        label: type2.info.displayName,
-        default: null,
-        pattern: null
-      });
-    }
+    const existingConfig = config2?.selectedContentTypes?.find((ct) => ct.uid === type2.uid);
+    newConfig.selectedContentTypes.push({
+      uid: type2.uid,
+      label: type2.info.displayName,
+      default: existingConfig?.default || null
+    });
   });
   if (JSON.stringify(newConfig) !== JSON.stringify(config2)) {
     await pluginStore.set({ key: "config", value: newConfig });
@@ -4491,7 +4882,7 @@ const bootstrap = async ({ strapi: strapi2 }) => {
         if (!navItem || !navItem.route) return;
         event.state = navItem.route.id && navItem.route.type === "external" ? { id: navItem.route.id } : null;
       } catch (err) {
-        console.log(err);
+        strapi2.log.error(err);
       }
     },
     async afterDelete(event) {
@@ -4504,15 +4895,13 @@ const bootstrap = async ({ strapi: strapi2 }) => {
           }
         });
       } catch (err) {
-        console.log(err);
+        strapi2.log.error(err);
       }
     }
   });
   strapi2.db?.lifecycles.subscribe({
     models: enabledContentTypes.map((type2) => type2.uid),
     async beforeCreate(event) {
-      const validContentTypes = config2.selectedContentTypes.filter((type2) => strapi2.contentTypes[type2.uid]);
-      await pluginStore.set({ key: "config", value: { selectedContentTypes: validContentTypes } });
       if (!event.params.data.webatlas_path) return;
       event.params.data.webatlas_path = transformToUrl(event.params.data.webatlas_path);
     },
@@ -4520,7 +4909,8 @@ const bootstrap = async ({ strapi: strapi2 }) => {
       const ctSettings = config2.selectedContentTypes.find((type2) => type2.uid === event.model.uid);
       const {
         webatlas_path,
-        webatlas_override
+        webatlas_override,
+        webatlas_parent
       } = event.params.data;
       if (!webatlas_path) return;
       const relatedRoute = await strapi2.db?.query(waRoute).findOne({
@@ -4529,8 +4919,20 @@ const bootstrap = async ({ strapi: strapi2 }) => {
         }
       });
       if (relatedRoute) return;
-      const title = ctSettings?.default ? event.params.data[ctSettings.default] : "";
+      let parent = null;
+      if (webatlas_parent) {
+        try {
+          const isValid = await validateRouteDependencies({
+            newParentId: webatlas_parent
+          });
+          if (isValid) parent = webatlas_parent;
+        } catch (err) {
+          strapi2.log.error(`Route dependency validation failed: ${err.message}`);
+        }
+      }
       const path = await duplicateCheck(transformToUrl(webatlas_path));
+      const canonicalPath = await buildCanonicalPath(path, parent);
+      const title = event.params.data[ctSettings?.default]?.trim() || path;
       await strapi2.documents(waRoute).create({
         data: {
           relatedContentType: event.model.uid,
@@ -4540,7 +4942,9 @@ const bootstrap = async ({ strapi: strapi2 }) => {
           path,
           uidPath: `${event.model.singularName}/${event.result.id}`,
           isOverride: webatlas_override || false,
-          title
+          title,
+          parent,
+          canonicalPath
         }
       });
     },
@@ -4549,46 +4953,74 @@ const bootstrap = async ({ strapi: strapi2 }) => {
       const {
         webatlas_path,
         webatlas_override,
+        webatlas_parent,
         documentId
       } = event.params.data;
       if (!webatlas_path) return;
-      const relatedRoute = await strapi2.db?.query(waRoute).findOne({
-        where: {
+      const relatedRoute = await strapi2.documents(waRoute).findFirst({
+        filters: {
           relatedDocumentId: documentId
         }
       });
-      const title = ctSettings?.default ? event.params.data[ctSettings.default] : "";
-      const path = await duplicateCheck(transformToUrl(webatlas_path), relatedRoute ? relatedRoute.documentId : null);
+      let parent = null;
+      if (webatlas_parent) {
+        try {
+          const isValid = await validateRouteDependencies({
+            routeId: relatedRoute ? relatedRoute.documentId : null,
+            newParentId: webatlas_parent
+          });
+          if (isValid) {
+            parent = await strapi2.documents(waRoute).findOne({
+              documentId: webatlas_parent
+            });
+          }
+        } catch (err) {
+          strapi2.log.error(`Route dependency validation failed: ${err.message}`);
+        }
+      }
+      const transformedPath = transformToUrl(webatlas_path);
+      const rawPath = parent ? `${parent.path}/${transformedPath}` : transformedPath;
+      const path = await duplicateCheck(rawPath, relatedRoute ? relatedRoute.documentId : null);
+      const canonicalPath = await buildCanonicalPath(transformedPath, parent?.documentId);
+      const title = event.params.data[ctSettings?.default]?.trim() || path;
       const routeData = {
         title,
         path,
-        slug: path,
-        isOverride: webatlas_override || false
+        slug: transformedPath,
+        isOverride: webatlas_override || false,
+        parent: parent?.documentId || null
       };
+      let routeDocumentId = relatedRoute?.documentId;
       if (!relatedRoute) {
-        await strapi2.documents(waRoute).create({
+        const createdRoute = await strapi2.documents(waRoute).create({
           data: {
             relatedContentType: event.model.uid,
             relatedId: event.result.id,
             relatedDocumentId: event.result.documentId,
             uidPath: `${event.model.singularName}/${event.result.id}`,
+            canonicalPath,
             ...routeData
           }
         });
+        routeDocumentId = createdRoute?.documentId;
       } else {
         await strapi2.documents(waRoute).update({
           documentId: relatedRoute.documentId,
           data: {
-            ...routeData
+            ...routeData,
+            canonicalPath
           }
         });
       }
+      if (routeDocumentId) {
+        await cascadeCanonicalPathUpdates(routeDocumentId, canonicalPath);
+      }
     },
     async afterDelete(event) {
       try {
         await findAndDeleteNavItem(event.result.id, event.model.uid);
       } catch (err) {
-        console.log(err);
+        strapi2.log.error(err);
       }
     },
     async afterDeleteMany(event) {
@@ -4622,7 +5054,7 @@ async function findAndDeleteNavItem(relatedId, relatedContentType) {
     await strapi.documents(waRoute).delete({ documentId: route2.documentId });
     if (navItem?.documentId) await strapi.documents(waNavItem).delete({ documentId: navItem.documentId });
   } catch (err) {
-    console.log(err);
+    strapi.log.error(err);
   }
 }
 const destroy = ({ strapi: strapi2 }) => {
@@ -5159,6 +5591,11 @@ const register = ({ strapi: strapi2 }) => {
       type: "boolean",
       private: true
     });
+    set$1(attributes, "webatlas_parent", {
+      ...fieldSettings,
+      type: "string",
+      private: true
+    });
   });
 };
 const config = {
@@ -5217,6 +5654,10 @@ const schema$2 = {
       type: "string",
       configurable: false
     },
+    canonicalPath: {
+      type: "string",
+      configurable: false
+    },
     slug: {
       type: "string",
       configurable: false
@@ -5248,6 +5689,20 @@ const schema$2 = {
       default: "internal",
       configurable: false,
       required: true
+    },
+    parent: {
+      type: "relation",
+      relation: "manyToOne",
+      target: "plugin::webatlas.route",
+      inversedBy: "children",
+      configurable: false
+    },
+    children: {
+      type: "relation",
+      relation: "oneToMany",
+      target: "plugin::webatlas.route",
+      mappedBy: "parent",
+      configurable: false
     }
   }
 };
@@ -5376,19 +5831,18 @@ const admin$2 = () => ({
       return ctx.throw(500, e);
     }
   },
-  async getRoutes(ctx) {
+  async getRoute(ctx) {
     try {
-      return await getAdminService().getRoutes();
+      const { documentId } = ctx.params;
+      if (!documentId) return ctx.throw(400, "Route documentId is required");
+      return await getAdminService().getRoute(documentId);
     } catch (e) {
       return ctx.throw(500, e);
     }
   },
-  async updateRoute(ctx) {
+  async getAllRoutes(ctx) {
     try {
-      const { documentId } = ctx.query;
-      if (!documentId) return ctx.throw(400, "Route documentId is required");
-      const { data } = ctx.request.body;
-      return await getAdminService().updateRoute(documentId, data);
+      return await getAdminService().getAllRoutes();
     } catch (e) {
       return ctx.throw(500, e);
     }
@@ -5402,6 +5856,14 @@ const admin$2 = () => ({
       return ctx.throw(500, e);
     }
   },
+  async getProhibitedRouteIds(ctx) {
+    try {
+      const { documentId } = ctx.params;
+      return await getAdminService().getProhibitedRouteIds(documentId);
+    } catch (e) {
+      return ctx.throw(500, e);
+    }
+  },
   async getNavigation(ctx) {
     try {
       const { documentId, variant } = ctx.query;
@@ -5556,7 +6018,7 @@ const admin$1 = {
     {
       method: "GET",
       path: "/route",
-      handler: "admin.getRoutes",
+      handler: "admin.getAllRoutes",
       config: {
         policies: [
           "admin::isAuthenticatedAdmin",
@@ -5573,9 +6035,9 @@ const admin$1 = {
       }
     },
     {
-      method: "PUT",
-      path: "/route",
-      handler: "admin.updateRoute",
+      method: "GET",
+      path: "/route/related",
+      handler: "admin.getRelatedRoute",
       config: {
         policies: [
           "admin::isAuthenticatedAdmin",
@@ -5583,6 +6045,7 @@ const admin$1 = {
             name: `plugin::${PLUGIN_ID}.has-permissions`,
             config: {
               actions: [
+                `plugin::${PLUGIN_ID}.cm.aside`,
                 `plugin::${PLUGIN_ID}.page.navigation`
               ]
             }
@@ -5592,8 +6055,26 @@ const admin$1 = {
     },
     {
       method: "GET",
-      path: "/route/related",
-      handler: "admin.getRelatedRoute",
+      path: "/route/prohibitedIds/:documentId?",
+      handler: "admin.getProhibitedRouteIds",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: `plugin::${PLUGIN_ID}.has-permissions`,
+            config: {
+              actions: [
+                `plugin::${PLUGIN_ID}.cm.aside`
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      method: "GET",
+      path: "/route/:documentId",
+      handler: "admin.getRoute",
       config: {
         policies: [
           "admin::isAuthenticatedAdmin",
@@ -5601,7 +6082,6 @@ const admin$1 = {
             name: `plugin::${PLUGIN_ID}.has-permissions`,
             config: {
               actions: [
-                `plugin::${PLUGIN_ID}.cm.aside`,
                 `plugin::${PLUGIN_ID}.page.navigation`
               ]
             }
@@ -5757,7 +6237,7 @@ const admin = ({ strapi: strapi2 }) => ({
       newConfigMerged = { ...config2, ...newConfig };
       await pluginStore.set({ key: "config", value: newConfigMerged });
     } catch (err) {
-      console.log(err);
+      strapi2.log.error(err);
       return "Error. Couldn't update config";
     }
     return newConfigMerged;
@@ -5778,35 +6258,21 @@ const admin = ({ strapi: strapi2 }) => ({
     };
     return config2;
   },
-  async getRoutes() {
+  async getRoute(documentId) {
     try {
-      const entities = await strapi2.documents(waRoute).findMany();
-      return entities;
+      return await strapi2.documents(waRoute).findOne({
+        documentId
+      });
     } catch (e) {
-      console.log(e);
+      strapi2.log.error(e);
     }
   },
-  // TODO: Types
-  async updateRoute(documentId, data) {
+  async getAllRoutes() {
     try {
-      let checkedPath = data.path;
-      if (data.internal) {
-        const parent = data.parent ? await strapi2.documents(waNavItem).findOne({
-          documentId: data.parent
-        }) : null;
-        const path = data.isOverride ? data.slug : getPath(parent?.path, data.slug);
-        checkedPath = await duplicateCheck(path, documentId);
-      }
-      const entity = await strapi2.documents(waRoute).update({
-        documentId,
-        data: {
-          ...data,
-          path: checkedPath
-        }
-      });
-      return entity;
+      const entities = await strapi2.documents(waRoute).findMany();
+      return entities;
     } catch (e) {
-      console.log(e);
+      strapi2.log.error(e);
     }
   },
   async getRelatedRoute(documentId) {
@@ -5814,10 +6280,28 @@ const admin = ({ strapi: strapi2 }) => ({
       return await strapi2.db?.query(waRoute).findOne({
         where: {
           relatedDocumentId: documentId
-        }
+        },
+        populate: ["parent"]
       });
     } catch (e) {
-      console.log(e);
+      strapi2.log.error(e);
+    }
+  },
+  async getProhibitedRouteIds(documentId) {
+    try {
+      let route2 = null;
+      if (documentId) {
+        route2 = await strapi2.documents(waRoute).findOne({
+          documentId
+        });
+      }
+      const descendants = route2?.documentId ? await getRouteDescendants(route2.documentId) : [];
+      const nonInternalRouteIds = await getNonInternalRouteIds();
+      const prohibitedRouteIds = [...descendants, ...nonInternalRouteIds];
+      route2?.documentId && prohibitedRouteIds.push(route2.documentId);
+      return prohibitedRouteIds;
+    } catch (e) {
+      strapi2.log.error(e);
     }
   },
   async getNavigation(documentId, variant) {
@@ -5853,7 +6337,7 @@ const admin = ({ strapi: strapi2 }) => ({
       }
       return navigation2;
     } catch (e) {
-      console.log(e);
+      strapi2.log.error(e);
     }
   },
   async createNavigation(name2, visible) {
@@ -5866,7 +6350,7 @@ const admin = ({ strapi: strapi2 }) => ({
         }
       });
     } catch (e) {
-      console.log(e);
+      strapi2.log.error(e);
     }
   },
   async updateNavigation(documentId, data) {
@@ -5880,7 +6364,7 @@ const admin = ({ strapi: strapi2 }) => ({
       });
       return entity;
     } catch (e) {
-      console.log(e);
+      strapi2.log.error(e);
     }
   },
   async deleteNavigation(documentId) {
@@ -5899,115 +6383,46 @@ const admin = ({ strapi: strapi2 }) => ({
         documentId
       });
     } catch (e) {
-      console.log(e);
+      strapi2.log.error(e);
     }
   },
   async updateNavigationItemStructure(navigationId, navigationItems) {
     if (!navigationId || !navigationItems) return;
     let error = false;
-    const newNavItemsMap = /* @__PURE__ */ new Map();
-    for (const [index2, item] of navigationItems.entries()) {
-      if (item.deleted) {
-        try {
-          item.documentId && await deleteNavItem(item.documentId);
-          const newItems = reduceDepthOfOrphanedItems(navigationItems, item.documentId);
-          if (!newItems) throw new Error("Failed to reduce depth of orphaned items");
-          navigationItems = newItems;
-        } catch (error2) {
-          error2 = true;
-          console.error("Error deleting navigation item ", error2);
-        }
-        continue;
-      }
-      if (!item.route && item.documentId) {
-        try {
-          console.warn("Navigation item without route found. Deleting it. ", item);
-          await deleteNavItem(item.documentId);
-        } catch (error2) {
-          console.error("Error deleting navigation item without route ", error2);
-        }
-        continue;
-      }
-      if (item.update && !item.isNew) {
-        try {
-          await this.updateRoute(item.route.documentId, {
-            title: item.update.title || item.route.title,
-            slug: item.update.slug || item.route.slug,
-            path: item.update.path || item.route.path,
-            isOverride: item.update.isOverride !== void 0 ? item.update.isOverride : item.route.isOverride
-          });
-        } catch (error2) {
-          error2 = true;
-          console.error("Error updating route ", error2);
-        }
-      }
+    let newNavItemsMap = /* @__PURE__ */ new Map();
+    const deletionResult = await handleItemDeletion(navigationItems);
+    if (!deletionResult.success) {
+      strapi2.log.error("Deletion errors:", deletionResult.errors);
     }
+    navigationItems = deletionResult.items;
     let parentIds = [];
     let groupIndices = [];
     for (const [index2, item] of navigationItems.entries()) {
       if (typeof item.depth !== "number") {
         continue;
       }
-      if (item.depth === 0) {
-        if (groupIndices[0] !== void 0) {
-          groupIndices[0] = groupIndices[0] + 1;
-        } else {
-          groupIndices[0] = 0;
-        }
-        parentIds = [];
-      } else {
-        const previousItem = navigationItems[index2 - 1];
-        if (previousItem && typeof previousItem.depth === "number") {
-          if (item.depth === previousItem.depth + 1) {
-            parentIds.push(previousItem.documentId.startsWith("temp-") ? newNavItemsMap.get(previousItem.documentId)?.documentId || previousItem.documentId : previousItem.documentId);
-            groupIndices[item.depth] = 0;
-          } else if (item.depth <= previousItem.depth) {
-            const diff = previousItem.depth - item.depth;
-            for (let i = 0; i < diff; i++) {
-              parentIds.pop();
-              groupIndices.pop();
-            }
-            groupIndices[item.depth] = (groupIndices[item.depth] || 0) + 1;
-          } else {
-            groupIndices[item.depth] = (groupIndices[item.depth] || 0) + 1;
-          }
-        }
-      }
-      const calculatedParent = parentIds.at(-1) || null;
-      const calculatedOrder = groupIndices[item.depth] || 0;
       try {
-        if (item.isNew) {
-          if (item.isNew.route) {
-            await createNavItem({
-              route: item.isNew.route,
-              parent: calculatedParent,
-              navigation: item.isNew.navigation,
-              order: calculatedOrder
-            });
-          } else {
-            const newRoute = await createExternalRoute({
-              title: item.route.title,
-              slug: item.route.slug,
-              path: item.route.path,
-              type: item.route.type
-            });
-            const newNavItem = await createNavItem({
-              route: newRoute.documentId,
-              navigation: navigationId,
-              parent: calculatedParent,
-              order: calculatedOrder
-            });
-            if (newNavItem) newNavItemsMap.set(item.documentId, newNavItem);
-          }
-        } else {
-          await updateNavItem(item.documentId, {
-            order: calculatedOrder,
-            parent: calculatedParent
-          });
+        const { calculatedParent, calculatedOrder } = calculateParentAndOrder({
+          navigationItems,
+          item,
+          index: index2,
+          parentIds,
+          groupIndices,
+          newNavItemsMap
+        });
+        const result = await handleItemUpdate({
+          item,
+          calculatedParent,
+          calculatedOrder,
+          navigationId,
+          newNavItemsMap
+        });
+        if (!result.success) {
+          strapi2.log.error("Error updating item: ", item);
         }
       } catch (errorMsg) {
         error = true;
-        console.error("Error updating navigation item ", errorMsg);
+        strapi2.log.error("Error updating navigation item ", errorMsg);
       }
     }
     return !error;
@@ -6016,7 +6431,7 @@ const admin = ({ strapi: strapi2 }) => ({
     try {
       return await duplicateCheck(initialPath, targetRouteDocumentId);
     } catch (e) {
-      console.log(e);
+      strapi2.log.error(e);
     }
   }
 });
@@ -6027,6 +6442,7 @@ const client = ({ strapi: strapi2 }) => ({
         filters: {
           $or: [
             { path: slug },
+            { canonicalPath: slug },
             { uidPath: slug }
           ]
         }
@@ -6053,9 +6469,21 @@ const client = ({ strapi: strapi2 }) => ({
       if (!entity) return null;
       let cleanEntity = cleanRootKeys(entity);
       cleanEntity = removeWaFields(cleanEntity);
-      return { contentType: contentType.info.singularName, ...cleanEntity };
+      const webatlasFields = {
+        path: route2.path,
+        canonicalPath: route2.canonicalPath,
+        slug: route2.slug,
+        uidPath: route2.uidPath
+      };
+      return {
+        contentType: contentType.info.singularName,
+        webatlas: {
+          ...webatlasFields
+        },
+        ...cleanEntity
+      };
     } catch (e) {
-      console.log(e);
+      strapi2.log.error(e);
       return e;
     }
   },
@@ -6093,7 +6521,7 @@ const client = ({ strapi: strapi2 }) => ({
           try {
             navigation2 = await method.lookup();
           } catch (error) {
-            console.log(`Navigation lookup by ${method.name} failed:`, error);
+            strapi2.log.error(`Navigation lookup by ${method.name} failed:`, error);
           }
         }
       }
@@ -6103,7 +6531,7 @@ const client = ({ strapi: strapi2 }) => ({
       const entityNavigation = extractRouteAndItems(structured.items);
       return { ...structured, items: entityNavigation };
     } catch (e) {
-      console.log(e);
+      strapi2.log.error(e);
       return e;
     }
   }
@@ -6125,4 +6553,3 @@ const index = {
   middlewares
 };
 module.exports = index;
-//# sourceMappingURL=index.js.map