@mattisvensson/strapi-plugin-webatlas 0.10.1 → 0.11.0

package/dist/server/index.mjs

@@ -1,15 +1,22 @@
-function transformToUrl(input) {
+function transformToUrl(input, replaceSlash = true) {
   const specialCharMap = {
     "ü": "ue",
     "ä": "ae",
-    "ö": "oe"
+    "ö": "oe",
+    "ß": "ss"
   };
   if (!input || typeof input !== "string") return "";
   input = input.toLowerCase();
   input = input.replace(/\/+/g, "/");
   input = input.startsWith("/") ? input.slice(1) : input;
   input = input.endsWith("/") ? input.slice(0, -1) : input;
-  input = input.replace(/\//g, "-");
+  if (replaceSlash) {
+    input = input.replace(/\//g, "-");
+  } else {
+    input = input.replace(/\/+/g, "/");
+    input = input.startsWith("/") ? input.slice(1) : input;
+    input = input.endsWith("/") ? input.slice(0, -1) : input;
+  }
   for (const char in specialCharMap) {
     const regex = new RegExp(char, "g");
     input = input.replace(regex, specialCharMap[char]);
@@ -28,36 +35,28 @@ const PLUGIN_ID = pluginPkg.strapi.name.replace(/^(@[^-,.][\w,-]+\/|strapi-)plug
 const waNavigation = `plugin::${PLUGIN_ID}.navigation`;
 const waNavItem = `plugin::${PLUGIN_ID}.navitem`;
 const waRoute = `plugin::${PLUGIN_ID}.route`;
-async function checkPathExists(path, targetRoutePath) {
-  const entities = await strapi.documents(waRoute).findMany({
-    filters: {
-      $or: [
-        { path },
-        { slug: path },
-        { uidPath: path },
-        { canonicalPath: path }
-      ]
-    }
-  });
-  if (targetRoutePath && entities && entities[0]?.path === targetRoutePath)
-    return false;
-  return entities?.length > 0;
+async function checkPathExists(path, excludeDocumentId) {
+  const filters = {
+    $or: [
+      { path },
+      { uidPath: path },
+      { canonicalPath: path }
+    ]
+  };
+  if (excludeDocumentId) {
+    filters.documentId = { $ne: excludeDocumentId };
+  }
+  const entity = await strapi.documents(waRoute).findFirst({ filters });
+  return !!entity;
 }
 async function duplicateCheck(initialPath, targetRouteDocumentId) {
   try {
     let uniquePath = initialPath;
-    let targetRoutePath = null;
     let counter = 1;
-    if (targetRouteDocumentId) {
-      const route2 = await strapi.documents(waRoute).findOne({
-        documentId: targetRouteDocumentId
-      });
-      if (route2) targetRoutePath = route2.path;
-    }
-    let exists = await checkPathExists(uniquePath, targetRoutePath);
+    let exists = await checkPathExists(uniquePath, targetRouteDocumentId);
     while (exists) {
       uniquePath = `${initialPath}-${counter}`;
-      exists = await checkPathExists(uniquePath);
+      exists = await checkPathExists(uniquePath, targetRouteDocumentId);
       counter++;
     }
     return uniquePath;
@@ -249,12 +248,14 @@ function extractRouteAndItems(items) {
   return items.map((item) => {
     const route2 = { ...item.route };
     if (!route2) return null;
-    if (item.depth) {
-      route2.depth = item.depth;
+    let depth = null;
+    if (item.depth !== void 0) {
+      depth = item.depth;
     }
+    let children = null;
     if (item.items?.length > 0) {
       const items2 = extractRouteAndItems(item.items);
-      if (items2.length > 0) route2.items = items2;
+      if (items2.length > 0) children = items2;
     }
     delete route2.relatedContentType;
     delete route2.relatedDocumentId;
@@ -265,7 +266,9 @@ function extractRouteAndItems(items) {
     return {
       __component: route2.type === "wrapper" ? `${PLUGIN_ID}.wrapper` : `${PLUGIN_ID}.route`,
       type: route2.type,
-      ...route2
+      ...route2,
+      depth: depth !== null ? depth : void 0,
+      items: children !== null ? children : void 0
     };
   });
 }
@@ -4316,6 +4319,7 @@ function removeWaFields(obj) {
   delete obj["webatlas_path"];
   delete obj["webatlas_override"];
   delete obj["webatlas_parent"];
+  delete obj["webatlas"];
   return obj;
 }
 async function buildCanonicalPath(slug, parentDocumentId) {
@@ -4331,26 +4335,55 @@ async function buildCanonicalPath(slug, parentDocumentId) {
     return slug;
   }
 }
-async function cascadeCanonicalPathUpdates(parentRouteId, newParentCanonicalPath) {
-  const children = await strapi.db.query(waRoute).findMany({
-    where: {
-      parent: {
-        documentId: parentRouteId
+async function cascadePathUpdates({
+  validatedParentPath,
+  parentRouteDocumentId,
+  canonicalPath,
+  isOverride
+}) {
+  try {
+    const children = await strapi.db.query(waRoute).findMany({
+      where: {
+        parent: {
+          documentId: parentRouteDocumentId
+        }
       }
-    }
-  });
-  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);
+    for (const child of children) {
+      const newCanonicalPath = `${canonicalPath}/${child.slug}`;
+      const newPath = isOverride ? `${validatedParentPath}/${child.slug}` : newCanonicalPath;
+      const validatedCanonicalPath = await duplicateCheck(newCanonicalPath, child.documentId);
+      const validatedPath = isOverride ? await duplicateCheck(newPath, child.documentId) : validatedCanonicalPath;
+      await strapi.db.query(waRoute).updateMany({
+        where: { documentId: child.documentId },
+        data: {
+          canonicalPath: validatedCanonicalPath,
+          path: validatedPath
+        }
+      });
+      const existingEntry = await strapi.db.query(child.relatedContentType).findOne({
+        where: { documentId: child.relatedDocumentId }
+      });
+      if (existingEntry) {
+        await strapi.db.query(child.relatedContentType).updateMany({
+          where: { documentId: child.relatedDocumentId },
+          data: {
+            webatlas: {
+              ...existingEntry.webatlas,
+              path: validatedPath
+            }
+          }
+        });
+      }
+      await cascadePathUpdates({
+        validatedParentPath: validatedPath,
+        parentRouteDocumentId: child.documentId,
+        canonicalPath: validatedCanonicalPath,
+        isOverride
+      });
+    }
+  } catch (err) {
+    strapi.log.error(err);
   }
 }
 async function getRouteDescendants(routeId) {
@@ -4677,8 +4710,66 @@ const migration_001_canonical_path = {
     }
   }
 };
+const migration_002_webatlas_json_field = {
+  version: "002",
+  description: "Migrate webatlas_path, webatlas_parent and webatlas_override text fields into the webatlas JSON field",
+  async up(strapi2) {
+    const knex = strapi2.db.connection;
+    const enabledContentTypes = Object.values(strapi2.contentTypes).filter(
+      (ct) => ct.pluginOptions?.webatlas?.enabled === true
+    );
+    for (const contentType of enabledContentTypes) {
+      const tableName = strapi2.db.metadata.get(contentType.uid)?.tableName ?? contentType.collectionName;
+      strapi2.log.info(`[webatlas] Processing table: ${tableName} (${contentType.uid})`);
+      const [hasPathCol, hasOverrideCol, hasParentCol, hasWebatlasCol] = await Promise.all([
+        knex.schema.hasColumn(tableName, "webatlas_path"),
+        knex.schema.hasColumn(tableName, "webatlas_override"),
+        knex.schema.hasColumn(tableName, "webatlas_parent"),
+        knex.schema.hasColumn(tableName, "webatlas")
+      ]);
+      const hasAnyOldCol = hasPathCol || hasOverrideCol || hasParentCol;
+      if (!hasAnyOldCol) {
+        strapi2.log.info(`[webatlas] No old fields found in ${tableName}, skipping data migration`);
+      } else if (!hasWebatlasCol) {
+        strapi2.log.warn(`[webatlas] New "webatlas" column not found in ${tableName} — schema may not have synced yet. Skipping data migration, old columns will still be dropped.`);
+      } else {
+        const selectCols = ["id"];
+        if (hasPathCol) selectCols.push("webatlas_path");
+        if (hasOverrideCol) selectCols.push("webatlas_override");
+        if (hasParentCol) selectCols.push("webatlas_parent");
+        const rows = await knex(tableName).select(selectCols);
+        let migratedCount = 0;
+        for (const row of rows) {
+          const path = row.webatlas_path || "";
+          const isOverride = Boolean(row.webatlas_override);
+          const parentDocumentId = row.webatlas_parent || null;
+          if (!path && !isOverride && !parentDocumentId) continue;
+          const slug = path ? path.split("/").pop() || "" : "";
+          await knex(tableName).where({ id: row.id }).update({
+            webatlas: JSON.stringify({ path, slug, isOverride, parentDocumentId })
+          });
+          migratedCount++;
+        }
+        strapi2.log.info(`[webatlas] Migrated ${migratedCount} / ${rows.length} rows in ${tableName}`);
+      }
+      const colsToDrop = [
+        hasPathCol && "webatlas_path",
+        hasOverrideCol && "webatlas_override",
+        hasParentCol && "webatlas_parent"
+      ].filter(Boolean);
+      if (colsToDrop.length > 0) {
+        await knex.schema.table(tableName, (table) => {
+          colsToDrop.forEach((col) => table.dropColumn(col));
+        });
+        strapi2.log.info(`[webatlas] Dropped columns [${colsToDrop.join(", ")}] from ${tableName}`);
+      }
+    }
+    strapi2.log.info("[webatlas] webatlas JSON field migration completed");
+  }
+};
 const migrations = [
-  migration_001_canonical_path
+  migration_001_canonical_path,
+  migration_002_webatlas_json_field
 ];
 const runMigrations = async (strapi2) => {
   const pluginStore = strapi2.store({ type: "plugin", name: PLUGIN_ID });
@@ -4712,54 +4803,47 @@ const runMigrations = async (strapi2) => {
   }
   strapi2.log.info("[webatlas] All migrations completed successfully");
 };
-const bootstrap = async ({ strapi: strapi2 }) => {
-  try {
-    await runMigrations(strapi2);
-    const actions = [
-      {
-        section: "plugins",
-        displayName: "Navigation page",
-        uid: "page.navigation",
-        subCategory: "Pages",
-        pluginName: PLUGIN_ID
-      },
-      {
-        section: "plugins",
-        displayName: "Routes page",
-        uid: "page.routes",
-        subCategory: "Pages",
-        pluginName: PLUGIN_ID
-      },
-      {
-        section: "plugins",
-        displayName: "General page",
-        uid: "settings.general",
-        subCategory: "Settings",
-        pluginName: PLUGIN_ID
-      },
-      {
-        section: "plugins",
-        displayName: "Navigation page",
-        uid: "settings.navigation",
-        subCategory: "Settings",
-        pluginName: PLUGIN_ID
-      },
-      {
-        section: "plugins",
-        displayName: "Aside panel",
-        uid: "cm.aside",
-        subCategory: "Content Manager",
-        pluginName: PLUGIN_ID
-      }
-    ];
-    strapi2.admin.services.permission.actionProvider.registerMany(actions);
-  } catch (error) {
-    strapi2.log.error(`Bootstrap failed. ${String(error)}`);
-  }
-  const contentTypes2 = strapi2.contentTypes;
-  const enabledContentTypes = Object.values(contentTypes2).filter(
-    (type) => type.pluginOptions?.webatlas?.enabled === true
-  );
+function registerPermissions(strapi2) {
+  const actions = [
+    {
+      section: "plugins",
+      displayName: "Navigation page",
+      uid: "page.navigation",
+      subCategory: "Pages",
+      pluginName: PLUGIN_ID
+    },
+    {
+      section: "plugins",
+      displayName: "Routes page",
+      uid: "page.routes",
+      subCategory: "Pages",
+      pluginName: PLUGIN_ID
+    },
+    {
+      section: "plugins",
+      displayName: "General page",
+      uid: "settings.general",
+      subCategory: "Settings",
+      pluginName: PLUGIN_ID
+    },
+    {
+      section: "plugins",
+      displayName: "Navigation page",
+      uid: "settings.navigation",
+      subCategory: "Settings",
+      pluginName: PLUGIN_ID
+    },
+    {
+      section: "plugins",
+      displayName: "Aside panel",
+      uid: "cm.aside",
+      subCategory: "Content Manager",
+      pluginName: PLUGIN_ID
+    }
+  ];
+  strapi2.admin.services.permission.actionProvider.registerMany(actions);
+}
+async function syncConfig(strapi2, enabledContentTypes) {
   const pluginStore = strapi2.store({ type: "plugin", name: PLUGIN_ID });
   const config2 = await pluginStore.get({
     key: "config"
@@ -4784,140 +4868,117 @@ const bootstrap = async ({ strapi: strapi2 }) => {
   if (JSON.stringify(newConfig) !== JSON.stringify(config2)) {
     await pluginStore.set({ key: "config", value: newConfig });
   }
-  if (!enabledContentTypes.length) return;
-  strapi2.db?.lifecycles.subscribe({
-    models: [waNavItem],
-    // TODO: is beforeDelete needed?
-    async beforeDelete(event) {
-      const id = event.params.where["id"];
-      if (!id) return;
-      try {
-        const navItem = await strapi2.db?.query(waNavItem).findOne({
-          where: {
-            id
-          },
-          populate: ["route"]
-        });
-        if (!navItem || !navItem.route) return;
-        event.state = navItem.route.id && navItem.route.type === "external" ? { id: navItem.route.id } : null;
-      } catch (err) {
-        strapi2.log.error(err);
-      }
-    },
-    async afterDelete(event) {
-      const { id } = event.state;
-      if (!id) return;
-      try {
-        await strapi2.db?.query(waRoute).delete({
-          where: {
-            id
-          }
-        });
-      } catch (err) {
-        strapi2.log.error(err);
-      }
+  return newConfig;
+}
+function documentMiddleware(strapi2, enabledContentTypes, config2) {
+  const actions = ["create", "update", "delete"];
+  strapi2.documents.use(async (context, next) => {
+    if (!enabledContentTypes.map((type) => type.uid).includes(context.uid) || !actions.includes(context.action)) {
+      return next();
     }
-  });
-  strapi2.db?.lifecycles.subscribe({
-    models: enabledContentTypes.map((type) => type.uid),
-    async beforeCreate(event) {
-      if (!event.params.data.webatlas_path) return;
-      event.params.data.webatlas_path = transformToUrl(event.params.data.webatlas_path);
-    },
-    async afterCreate(event) {
-      const ctSettings = config2.selectedContentTypes.find((type) => type.uid === event.model.uid);
-      const {
-        webatlas_path,
-        webatlas_override,
-        webatlas_parent
-      } = event.params.data;
-      if (!webatlas_path) return;
-      const relatedRoute = await strapi2.db?.query(waRoute).findOne({
-        where: {
-          relatedDocumentId: event.result.documentId
-        }
+    const ctSettings = config2.selectedContentTypes.find((ct) => ct.uid === context.uid);
+    if (context.action === "create") {
+      const data = context.params.data;
+      const { webatlas } = data;
+      const { slug, parentDocumentId, isOverride } = webatlas || {};
+      const transformedSlug = slug ? transformToUrl(slug) : null;
+      if (transformedSlug) {
+        data.webatlas.slug = transformedSlug;
+      }
+      const result2 = await next();
+      if (!transformedSlug) return result2;
+      const existing = await strapi2.db?.query(waRoute).findOne({
+        where: { relatedDocumentId: result2.documentId }
       });
-      if (relatedRoute) return;
+      if (existing) return result2;
       let parent = null;
-      if (webatlas_parent) {
-        try {
-          const isValid = await validateRouteDependencies({
-            newParentId: webatlas_parent
+      let isValid = false;
+      if (parentDocumentId) {
+        isValid = await validateRouteDependencies({ newParentId: parentDocumentId });
+        if (isValid) {
+          parent = await strapi2.documents(waRoute).findOne({
+            documentId: parentDocumentId
           });
-          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;
+      let rawPath = transformedSlug;
+      if (!isOverride) rawPath = parent ? `${parent.path}/${transformedSlug}` : transformedSlug;
+      const validatedPath = await duplicateCheck(rawPath);
+      if (!validatedPath) throw new Error(`Failed to generate a unique path for slug: ${transformedSlug}`);
+      const singularName = context.contentType.info.singularName;
+      const title = context.params.data[ctSettings?.default]?.trim() || transformedSlug;
+      const canonicalPath = await buildCanonicalPath(transformToUrl(title), isValid ? parent.documentId : null);
       await strapi2.documents(waRoute).create({
         data: {
-          relatedContentType: event.model.uid,
-          relatedId: event.result.id,
-          relatedDocumentId: event.result.documentId,
-          slug: path,
-          path,
-          uidPath: `${event.model.singularName}/${event.result.id}`,
-          isOverride: webatlas_override || false,
+          relatedContentType: context.uid,
+          relatedId: result2.id,
+          relatedDocumentId: result2.documentId,
+          slug: transformedSlug,
+          path: validatedPath,
+          uidPath: `${singularName}/${result2.id}`,
+          isOverride: isOverride || false,
           title,
-          parent,
+          parent: isValid ? parent?.documentId : null,
           canonicalPath
         }
       });
-    },
-    async afterUpdate(event) {
-      const ctSettings = config2.selectedContentTypes.find((type) => type.uid === event.model.uid);
-      const {
-        webatlas_path,
-        webatlas_override,
-        webatlas_parent,
-        documentId
-      } = event.params.data;
-      if (!webatlas_path) return;
+      await strapi2.db?.query(context.uid).updateMany({
+        where: { documentId: result2.documentId },
+        data: { webatlas: { ...webatlas, slug: transformedSlug, path: validatedPath, parentDocumentId: isValid ? parent?.documentId : null } }
+      });
+      return result2;
+    }
+    if (context.action === "update") {
+      const data = context.params.data;
+      const { documentId } = context.params;
+      const { webatlas } = data;
+      const { slug, parentDocumentId, isOverride } = webatlas || {};
+      if (!slug) return;
       const relatedRoute = await strapi2.documents(waRoute).findFirst({
         filters: {
           relatedDocumentId: documentId
         }
       });
       let parent = null;
-      if (webatlas_parent) {
-        try {
-          const isValid = await validateRouteDependencies({
-            routeId: relatedRoute ? relatedRoute.documentId : null,
-            newParentId: webatlas_parent
+      let isValid = false;
+      if (parentDocumentId) {
+        isValid = await validateRouteDependencies({
+          routeId: relatedRoute ? relatedRoute.documentId : null,
+          newParentId: parentDocumentId
+        });
+        if (isValid) {
+          parent = await strapi2.documents(waRoute).findOne({
+            documentId: parentDocumentId
           });
-          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 transformedSlug = transformToUrl(slug);
+      let rawPath = transformedSlug;
+      if (!isOverride) rawPath = parent ? `${parent.path}/${transformedSlug}` : transformedSlug;
+      const validatedPath = await duplicateCheck(rawPath, relatedRoute?.documentId ?? null);
+      data.webatlas.path = validatedPath;
+      data.webatlas.slug = transformedSlug;
+      if (relatedRoute) data.relatedRoute = relatedRoute;
+      if (!isValid && parentDocumentId) data.webatlas.parent = null;
+      const result2 = await next();
+      const title = context.params.data[ctSettings?.default]?.trim() || slug;
+      const canonicalPath = isOverride ? relatedRoute.path : await buildCanonicalPath(transformToUrl(title), parent?.documentId);
       const routeData = {
         title,
-        path,
-        slug: transformedPath,
-        isOverride: webatlas_override || false,
-        parent: parent?.documentId || null
+        path: validatedPath,
+        slug,
+        isOverride: isOverride || false,
+        parent: parent?.documentId || null,
+        canonicalPath
       };
       let routeDocumentId = relatedRoute?.documentId;
       if (!relatedRoute) {
         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,
+            relatedContentType: context.uid,
+            relatedId: result2.id,
+            relatedDocumentId: result2.documentId,
+            uidPath: `${context.contentType.info.singularName}/${result2.id}`,
             ...routeData
           }
         });
@@ -4925,57 +4986,121 @@ const bootstrap = async ({ strapi: strapi2 }) => {
       } else {
         await strapi2.documents(waRoute).update({
           documentId: relatedRoute.documentId,
-          data: {
-            ...routeData,
-            canonicalPath
-          }
+          data: routeData
         });
       }
       if (routeDocumentId) {
-        await cascadeCanonicalPathUpdates(routeDocumentId, canonicalPath);
+        await cascadePathUpdates({
+          validatedParentPath: validatedPath,
+          parentRouteDocumentId: routeDocumentId,
+          canonicalPath,
+          isOverride
+        });
       }
-    },
-    async afterDelete(event) {
+    }
+    if (context.action === "delete") {
+      const result2 = await next();
       try {
-        await findAndDeleteNavItem(event.result.id, event.model.uid);
+        const relatedDocumentId = context.params.documentId;
+        const deletedRoute = await strapi2.db.query(waRoute).delete({
+          where: { relatedDocumentId },
+          populate: ["navitem"]
+        });
+        if (!deletedRoute?.documentId) return result2;
+        const navItemDocumentIds = Array.from(deletedRoute.navitem?.map((item) => item.documentId));
+        for (const navItemDocumentId of navItemDocumentIds) {
+          await strapi2.documents(waNavItem).delete({ documentId: navItemDocumentId });
+        }
       } catch (err) {
         strapi2.log.error(err);
       }
-    },
-    async afterDeleteMany(event) {
-      const deletedArr = event.params.where["$and"];
-      deletedArr.map((item) => {
-        const ids = item.id["$in"];
-        ids.map(async (id) => {
-          await findAndDeleteNavItem(id, event.model.uid);
-        });
-      });
+      return result2;
     }
+    const result = await next();
+    return result;
   });
-};
-async function findAndDeleteNavItem(relatedId, relatedContentType) {
-  if (!relatedId || !relatedContentType) return;
-  try {
-    const route2 = await strapi.db?.query(waRoute).findOne({
-      where: {
-        relatedId,
-        relatedContentType
+}
+function webatlasMiddleware(strapi2) {
+  strapi2.documents.use(async (context, next) => {
+    if (context.uid !== waNavItem) return next();
+    if (context.action === "delete") {
+      let externalRouteDocumentId = null;
+      try {
+        const navItem = await strapi2.db?.query(waNavItem).findOne({
+          where: { documentId: context.params.documentId },
+          populate: ["route"]
+        });
+        if (navItem?.route?.type === "external") {
+          externalRouteDocumentId = navItem.route.documentId;
+        }
+      } catch (err) {
+        strapi2.log.error(err);
       }
-    });
-    if (!route2?.documentId) return;
-    const navItem = await strapi.db?.query(waNavItem).findOne({
-      where: {
-        route: {
-          documentId: route2.documentId
+      const result = await next();
+      if (externalRouteDocumentId) {
+        try {
+          await strapi2.documents(waRoute).delete({ documentId: externalRouteDocumentId });
+        } catch (err) {
+          strapi2.log.error(err);
         }
       }
-    });
-    await strapi.documents(waRoute).delete({ documentId: route2.documentId });
-    if (navItem?.documentId) await strapi.documents(waNavItem).delete({ documentId: navItem.documentId });
-  } catch (err) {
-    strapi.log.error(err);
-  }
+      return result;
+    }
+    return next();
+  });
+}
+function contentTypeMiddleware(strapi2) {
+  strapi2.documents.use(async (context, next) => {
+    const pluginOptions = context.contentType?.pluginOptions;
+    if (!pluginOptions?.webatlas?.enabled) {
+      return next();
+    }
+    if (!["findOne", "findMany"].includes(context.action)) {
+      return next();
+    }
+    const result = await next();
+    if (context.action === "findOne") {
+      if (!result || typeof result !== "object" || Array.isArray(result)) return result;
+      const entry = result;
+      const webatlasObj = entry.webatlas || {};
+      const newWebatlasObj = {
+        path: webatlasObj.path || "",
+        slug: webatlasObj.slug || ""
+      };
+      return { ...entry, webatlas: newWebatlasObj };
+    }
+    if (context.action === "findMany") {
+      if (!Array.isArray(result)) return result;
+      return result.map(
+        (entry) => {
+          const webatlasObj = entry.webatlas || {};
+          const newWebatlasObj = {
+            path: webatlasObj.path || "",
+            slug: webatlasObj.slug || ""
+          };
+          return { ...entry, webatlas: newWebatlasObj };
+        }
+      );
+    }
+    return result;
+  });
 }
+const bootstrap = async ({ strapi: strapi2 }) => {
+  try {
+    await runMigrations(strapi2);
+    registerPermissions(strapi2);
+    const enabledContentTypes = Object.values(strapi2.contentTypes).filter(
+      (type) => type.pluginOptions?.webatlas?.enabled === true
+    );
+    const config2 = await syncConfig(strapi2, enabledContentTypes);
+    if (!enabledContentTypes.length) return;
+    documentMiddleware(strapi2, enabledContentTypes, config2);
+    webatlasMiddleware(strapi2);
+    contentTypeMiddleware(strapi2);
+  } catch (error) {
+    strapi2.log.error(`Bootstrap failed. ${String(error)}`);
+  }
+};
 const destroy = ({ strapi: strapi2 }) => {
 };
 var _freeGlobal;
@@ -5891,21 +6016,11 @@ const register = ({ strapi: strapi2 }) => {
       visible: true,
       default: null
     };
-    set(attributes, "webatlas_path", {
+    set(attributes, "webatlas", {
       ...fieldSettings,
-      type: "string",
+      type: "json",
       private: false
     });
-    set(attributes, "webatlas_override", {
-      ...fieldSettings,
-      type: "boolean",
-      private: true
-    });
-    set(attributes, "webatlas_parent", {
-      ...fieldSettings,
-      type: "string",
-      private: true
-    });
   });
 };
 const config = {
@@ -6244,9 +6359,9 @@ const client$2 = ({ strapi: strapi2 }) => ({
   },
   async getNavigation(ctx) {
     try {
-      const { id, name, documentId, variant } = ctx.query;
-      if (!id && !name && !documentId) return ctx.throw(400, "Navigation id, name or documentId is required");
-      const navigation2 = await getClientService().getNavigation(id, name, documentId, variant);
+      const { id, name, slug, documentId, variant } = ctx.query;
+      if (!id && !name && !slug && !documentId) return ctx.throw(400, "Navigation id, name, slug or documentId is required");
+      const navigation2 = await getClientService().getNavigation(id, name, slug, documentId, variant);
       if (!navigation2) return ctx.throw(404, "Navigation not found");
       return ctx.send(navigation2);
     } catch (e) {
@@ -6797,23 +6912,32 @@ const client = ({ strapi: strapi2 }) => ({
       return e;
     }
   },
-  async getNavigation(id, name, documentId, variant = "nested") {
+  async getNavigation(id, name, slug, documentId, variant = "nested") {
     try {
       let navigation2 = null;
+      const populateObject = ["items", "items.parent", "items.route"];
       const lookupMethods = [
         {
           condition: documentId,
           lookup: () => strapi2.documents(waNavigation).findOne({
             documentId,
-            populate: ["items", "items.parent", "items.route"]
+            populate: populateObject
           }),
           name: "documentId"
         },
+        {
+          condition: slug,
+          lookup: () => strapi2.db?.query(waNavigation).findOne({
+            where: { slug },
+            populate: populateObject
+          }),
+          name: "slug"
+        },
         {
           condition: name,
           lookup: () => strapi2.db?.query(waNavigation).findOne({
             where: { name },
-            populate: ["items", "items.parent", "items.route"]
+            populate: populateObject
           }),
           name: "name"
         },
@@ -6821,7 +6945,7 @@ const client = ({ strapi: strapi2 }) => ({
           condition: id,
           lookup: () => strapi2.db?.query(waNavigation).findOne({
             where: { id },
-            populate: ["items", "items.parent", "items.route"]
+            populate: populateObject
           }),
           name: "id"
         }
@@ -6865,3 +6989,4 @@ const index = {
 export {
   index as default
 };
+//# sourceMappingURL=index.mjs.map