@mattisvensson/strapi-plugin-webatlas 0.11.4 → 0.11.6

package/dist/server/index.mjs

@@ -4662,6 +4662,205 @@ function calculateParentAndOrder({
     calculatedOrder
   };
 }
+async function enrichWebatlasData(data, contentTypeUid) {
+  if (!data || typeof data !== "object") return data;
+  const collectDocumentIds = (obj, uid) => {
+    if (!obj || typeof obj !== "object") return [];
+    const ids = [];
+    if (obj.documentId) ids.push(obj.documentId);
+    if (!uid) return ids;
+    const ct = strapi.contentTypes[uid];
+    if (!ct?.attributes) return ids;
+    for (const [key, attr] of Object.entries(ct.attributes)) {
+      const attribute = attr;
+      if (attribute.type === "relation" && obj[key]) {
+        const targetUid = attribute.target;
+        if (Array.isArray(obj[key])) {
+          ids.push(...obj[key].flatMap((item) => collectDocumentIds(item, targetUid)));
+        } else {
+          ids.push(...collectDocumentIds(obj[key], targetUid));
+        }
+      }
+      if (attribute.type === "component" && obj[key]) {
+        const componentUid = attribute.component;
+        if (Array.isArray(obj[key])) {
+          ids.push(...obj[key].flatMap((item) => collectDocumentIds(item, componentUid)));
+        } else {
+          ids.push(...collectDocumentIds(obj[key], componentUid));
+        }
+      }
+      if (attribute.type === "dynamiczone" && Array.isArray(obj[key])) {
+        ids.push(
+          ...obj[key].flatMap((item) => {
+            if (!item || !item.__component) return [];
+            return collectDocumentIds(item, item.__component);
+          })
+        );
+      }
+    }
+    return ids;
+  };
+  const documentIds = collectDocumentIds(data, contentTypeUid);
+  if (documentIds.length === 0) return data;
+  const uniqueDocumentIds = [...new Set(documentIds)];
+  const routes2 = await strapi.db?.query(waRoute).findMany({
+    where: {
+      relatedDocumentId: { $in: uniqueDocumentIds }
+    },
+    select: ["relatedDocumentId", "relatedContentType", "path", "canonicalPath", "slug", "uidPath"]
+  });
+  const routeMap = new Map(routes2?.map((route2) => [route2.relatedDocumentId, route2]) || []);
+  const enrichEntity2 = (entity, uid) => {
+    if (!entity || typeof entity !== "object") return entity;
+    const ct = uid ? strapi.contentTypes[uid] : null;
+    const isWebatlasEnabled = ct?.pluginOptions?.webatlas?.enabled === true;
+    if (isWebatlasEnabled && entity.documentId && routeMap.has(entity.documentId)) {
+      const route2 = routeMap.get(entity.documentId);
+      entity.webatlas = {
+        path: route2.path || "",
+        canonicalPath: route2.canonicalPath || "",
+        slug: route2.slug || "",
+        uidPath: route2.uidPath || ""
+      };
+    }
+    if (ct?.attributes) {
+      for (const [key, attr] of Object.entries(ct.attributes)) {
+        const attribute = attr;
+        if (attribute.type === "relation" && entity[key]) {
+          const targetUid = attribute.target;
+          if (Array.isArray(entity[key])) {
+            entity[key] = entity[key].map(
+              (item) => item ? enrichEntity2(item, targetUid) : item
+            );
+          } else {
+            entity[key] = enrichEntity2(entity[key], targetUid);
+          }
+        }
+        if (attribute.type === "component" && entity[key]) {
+          const componentUid = attribute.component;
+          if (Array.isArray(entity[key])) {
+            entity[key] = entity[key].map(
+              (item) => item ? enrichEntity2(item, componentUid) : item
+            );
+          } else {
+            entity[key] = enrichEntity2(entity[key], componentUid);
+          }
+        }
+        if (attribute.type === "dynamiczone" && Array.isArray(entity[key])) {
+          entity[key] = entity[key].map((item) => {
+            if (!item || !item.__component) return item;
+            return enrichEntity2(item, item.__component);
+          });
+        }
+      }
+    }
+    return entity;
+  };
+  return enrichEntity2(data, contentTypeUid);
+}
+function isExternalUrl(value) {
+  return !/^[a-z0-9]+$/.test(value);
+}
+function collectRoutePickerIds(obj, uid) {
+  if (!obj || typeof obj !== "object") return [];
+  const ids = [];
+  if (!uid) return ids;
+  const ct = strapi.contentTypes[uid] || strapi.components?.[uid];
+  if (!ct?.attributes) return ids;
+  for (const [key, attr] of Object.entries(ct.attributes)) {
+    const attribute = attr;
+    if (attribute.customField === "plugin::webatlas.route-picker" && obj[key]) {
+      const value = obj[key];
+      if (typeof value === "string" && !isExternalUrl(value)) {
+        ids.push(value);
+      }
+    }
+    if (attribute.type === "relation" && obj[key]) {
+      const targetUid = attribute.target;
+      if (Array.isArray(obj[key])) {
+        ids.push(...obj[key].flatMap((item) => collectRoutePickerIds(item, targetUid)));
+      } else {
+        ids.push(...collectRoutePickerIds(obj[key], targetUid));
+      }
+    }
+    if (attribute.type === "component" && obj[key]) {
+      const componentUid = attribute.component;
+      if (Array.isArray(obj[key])) {
+        ids.push(...obj[key].flatMap((item) => collectRoutePickerIds(item, componentUid)));
+      } else {
+        ids.push(...collectRoutePickerIds(obj[key], componentUid));
+      }
+    }
+    if (attribute.type === "dynamiczone" && Array.isArray(obj[key])) {
+      ids.push(
+        ...obj[key].flatMap((item) => {
+          if (!item || !item.__component) return [];
+          return collectRoutePickerIds(item, item.__component);
+        })
+      );
+    }
+  }
+  return ids;
+}
+function enrichEntity(entity, uid, routeMap) {
+  if (!entity || typeof entity !== "object") return entity;
+  const ct = strapi.contentTypes[uid] || strapi.components?.[uid];
+  if (!ct?.attributes) return entity;
+  for (const [key, attr] of Object.entries(ct.attributes)) {
+    const attribute = attr;
+    if (attribute.customField === "plugin::webatlas.route-picker" && entity[key]) {
+      const value = entity[key];
+      if (typeof value === "string" && !isExternalUrl(value)) {
+        const route2 = routeMap.get(value);
+        if (route2) {
+          entity[key] = route2.canonicalPath || route2.path || value;
+        }
+      }
+    }
+    if (attribute.type === "relation" && entity[key]) {
+      const targetUid = attribute.target;
+      if (Array.isArray(entity[key])) {
+        entity[key] = entity[key].map(
+          (item) => item ? enrichEntity(item, targetUid, routeMap) : item
+        );
+      } else {
+        entity[key] = enrichEntity(entity[key], targetUid, routeMap);
+      }
+    }
+    if (attribute.type === "component" && entity[key]) {
+      const componentUid = attribute.component;
+      if (Array.isArray(entity[key])) {
+        entity[key] = entity[key].map(
+          (item) => item ? enrichEntity(item, componentUid, routeMap) : item
+        );
+      } else {
+        entity[key] = enrichEntity(entity[key], componentUid, routeMap);
+      }
+    }
+    if (attribute.type === "dynamiczone" && Array.isArray(entity[key])) {
+      entity[key] = entity[key].map((item) => {
+        if (!item || !item.__component) return item;
+        return enrichEntity(item, item.__component, routeMap);
+      });
+    }
+  }
+  return entity;
+}
+async function enrichRoutePickerFields(data, contentTypeUid) {
+  if (!data || typeof data !== "object") return data;
+  const documentIds = collectRoutePickerIds(data, contentTypeUid);
+  if (documentIds.length === 0) return data;
+  const uniqueDocumentIds = [...new Set(documentIds)];
+  const routes2 = await strapi.db?.query(waRoute).findMany({
+    where: {
+      documentId: { $in: uniqueDocumentIds }
+    },
+    select: ["documentId", "path", "canonicalPath"]
+  });
+  const routeMap = new Map(routes2?.map((route2) => [route2.documentId, route2]) || []);
+  const enriched = enrichEntity(data, contentTypeUid, routeMap);
+  return enriched;
+}
 const migration_001_canonical_path = {
   version: "001",
   description: "Migrate title field to canonicalPath using transformToUrl",
@@ -4900,7 +5099,7 @@ function documentMiddleware(strapi2, enabledContentTypes, config2) {
       const data = context.params.data;
       const { webatlas } = data;
       const { slug, parentDocumentId, isOverride } = webatlas || {};
-      const transformedSlug = slug ? transformToUrl(slug) : null;
+      const transformedSlug = slug ? transformToUrl(slug, !isOverride) : null;
       const result2 = await next();
       if (!transformedSlug) return result2;
       const existing = await strapi2.db?.query(waRoute).findOne({
@@ -4973,7 +5172,7 @@ function documentMiddleware(strapi2, enabledContentTypes, config2) {
           });
         }
       }
-      const transformedSlug = transformToUrl(slug);
+      const transformedSlug = transformToUrl(slug, !isOverride);
       let rawPath = transformedSlug;
       if (!isOverride) rawPath = parent ? `${parent.path}/${transformedSlug}` : transformedSlug;
       const validatedPath = await duplicateCheck(rawPath, relatedRoute?.documentId ?? null);
@@ -5084,130 +5283,59 @@ const addWebatlasField = ({ strapi: strapi2 }) => {
       ([uid, ct]) => ct.info?.pluralName === apiEndpoint
     );
     if (!contentTypeEntry) return;
-    const [contentTypeUid, contentType] = contentTypeEntry;
-    const collectDocumentIds = (data, uid = contentTypeUid) => {
-      if (!data || typeof data !== "object") return [];
-      const ids = [];
-      if (data.documentId) {
-        ids.push(data.documentId);
-      }
-      const ct = strapi2.contentTypes[uid];
-      if (ct?.attributes) {
-        for (const [key, attr] of Object.entries(ct.attributes)) {
-          const attribute = attr;
-          if (attribute.type === "relation" && data[key]) {
-            const targetUid = attribute.target;
-            if (Array.isArray(data[key])) {
-              ids.push(...data[key].flatMap((item) => collectDocumentIds(item, targetUid)));
-            } else {
-              ids.push(...collectDocumentIds(data[key], targetUid));
-            }
-          }
-          if (attribute.type === "component" && data[key]) {
-            const componentUid = attribute.component;
-            if (Array.isArray(data[key])) {
-              ids.push(...data[key].flatMap((item) => collectDocumentIds(item, componentUid)));
-            } else {
-              ids.push(...collectDocumentIds(data[key], componentUid));
-            }
-          }
-          if (attribute.type === "dynamiczone" && Array.isArray(data[key])) {
-            ids.push(
-              ...data[key].flatMap((item) => {
-                const componentUid = item.__component;
-                return collectDocumentIds(item, componentUid);
-              })
-            );
-          }
-        }
-      }
-      return ids;
-    };
-    let documentIds = [];
+    const [contentTypeUid] = contentTypeEntry;
     if (ctx.body.data) {
       if (Array.isArray(ctx.body.data)) {
-        documentIds = ctx.body.data.flatMap((item) => collectDocumentIds(item, contentTypeUid));
+        ctx.body.data = await Promise.all(
+          ctx.body.data.map((item) => enrichWebatlasData(item, contentTypeUid))
+        );
       } else {
-        documentIds = collectDocumentIds(ctx.body.data, contentTypeUid);
+        ctx.body.data = await enrichWebatlasData(ctx.body.data, contentTypeUid);
       }
     } else if (Array.isArray(ctx.body)) {
-      documentIds = ctx.body.flatMap((item) => collectDocumentIds(item, contentTypeUid));
+      ctx.body = await Promise.all(ctx.body.map((item) => enrichWebatlasData(item, contentTypeUid)));
     } else if (typeof ctx.body === "object") {
-      documentIds = collectDocumentIds(ctx.body, contentTypeUid);
+      ctx.body = await enrichWebatlasData(ctx.body, contentTypeUid);
     }
-    if (documentIds.length === 0) return;
-    const uniqueDocumentIds = [...new Set(documentIds)];
-    const routes2 = await strapi2.db?.query(waRoute).findMany({
-      where: {
-        relatedDocumentId: { $in: uniqueDocumentIds }
-      },
-      select: [
-        "relatedDocumentId",
-        "relatedContentType",
-        "path",
-        "canonicalPath",
-        "slug",
-        "uidPath"
-      ]
-    });
-    const routeMap = new Map(routes2?.map((route2) => [route2.relatedDocumentId, route2]) || []);
-    const enrichWebatlasField = (data, uid = contentTypeUid) => {
-      if (!data || typeof data !== "object") return data;
-      const ct = strapi2.contentTypes[uid];
-      const isWebatlasEnabled = ct?.pluginOptions?.webatlas?.enabled === true;
-      if (isWebatlasEnabled && data.documentId && routeMap.has(data.documentId)) {
-        const route2 = routeMap.get(data.documentId);
-        data.webatlas = {
-          path: route2.path || "",
-          canonicalPath: route2.canonicalPath || "",
-          slug: route2.slug || "",
-          uidPath: route2.uidPath || ""
-        };
-      }
-      if (ct?.attributes) {
-        for (const [key, attr] of Object.entries(ct.attributes)) {
-          const attribute = attr;
-          if (attribute.type === "relation" && data[key]) {
-            const targetUid = attribute.target;
-            if (Array.isArray(data[key])) {
-              data[key] = data[key].map((item) => enrichWebatlasField(item, targetUid));
-            } else {
-              data[key] = enrichWebatlasField(data[key], targetUid);
-            }
-          }
-          if (attribute.type === "component" && data[key]) {
-            const componentUid = attribute.component;
-            if (Array.isArray(data[key])) {
-              data[key] = data[key].map((item) => enrichWebatlasField(item, componentUid));
-            } else {
-              data[key] = enrichWebatlasField(data[key], componentUid);
-            }
-          }
-          if (attribute.type === "dynamiczone" && Array.isArray(data[key])) {
-            data[key] = data[key].map((item) => {
-              const componentUid = item.__component;
-              return enrichWebatlasField(item, componentUid);
-            });
-          }
-        }
-      }
-      return data;
-    };
+  };
+};
+const enrichRoutePicker = ({ strapi: strapi2 }) => {
+  return async (ctx, next) => {
+    await next();
+    if (!ctx.request.url.startsWith("/api/")) {
+      return;
+    }
+    if (!ctx.body || ctx.status !== 200) {
+      return;
+    }
+    const urlMatch = ctx.request.url.match(/^\/api\/([^/?]+)/);
+    if (!urlMatch) return;
+    const apiEndpoint = urlMatch[1];
+    const contentTypeEntry = Object.entries(strapi2.contentTypes).find(
+      ([uid, ct]) => ct.info?.pluralName === apiEndpoint
+    );
+    if (!contentTypeEntry) return;
+    const [contentTypeUid] = contentTypeEntry;
     if (ctx.body.data) {
       if (Array.isArray(ctx.body.data)) {
-        ctx.body.data = ctx.body.data.map((item) => enrichWebatlasField(item, contentTypeUid));
+        ctx.body.data = await Promise.all(
+          ctx.body.data.map((item) => enrichRoutePickerFields(item, contentTypeUid))
+        );
       } else {
-        ctx.body.data = enrichWebatlasField(ctx.body.data, contentTypeUid);
+        ctx.body.data = await enrichRoutePickerFields(ctx.body.data, contentTypeUid);
       }
     } else if (Array.isArray(ctx.body)) {
-      ctx.body = ctx.body.map((item) => enrichWebatlasField(item, contentTypeUid));
+      ctx.body = await Promise.all(
+        ctx.body.map((item) => enrichRoutePickerFields(item, contentTypeUid))
+      );
     } else if (typeof ctx.body === "object") {
-      ctx.body = enrichWebatlasField(ctx.body, contentTypeUid);
+      ctx.body = await enrichRoutePickerFields(ctx.body, contentTypeUid);
     }
   };
 };
 const middlewares = {
-  addWebatlasField
+  addWebatlasField,
+  enrichRoutePicker
 };
 const bootstrap = async ({ strapi: strapi2 }) => {
   try {
@@ -5221,6 +5349,7 @@ const bootstrap = async ({ strapi: strapi2 }) => {
     documentMiddleware(strapi2, enabledContentTypes, config2);
     webatlasMiddleware(strapi2);
     strapi2.server.use(middlewares.addWebatlasField({ strapi: strapi2 }));
+    strapi2.server.use(middlewares.enrichRoutePicker({ strapi: strapi2 }));
   } catch (error) {
     strapi2.log.error(`Bootstrap failed. ${String(error)}`);
   }
@@ -5228,6 +5357,11 @@ const bootstrap = async ({ strapi: strapi2 }) => {
 const destroy = ({ strapi: strapi2 }) => {
 };
 const register = ({ strapi: strapi2 }) => {
+  strapi2.customFields.register({
+    name: "route-picker",
+    plugin: PLUGIN_ID,
+    type: "string"
+  });
 };
 const config = {
   default: {
@@ -6090,17 +6224,10 @@ const client = ({ strapi: strapi2 }) => ({
       if (!entity) return null;
       let cleanEntity = cleanRootKeys(entity);
       cleanEntity = removeWaFields(cleanEntity);
-      const webatlasFields = {
-        path: route2.path,
-        canonicalPath: route2.canonicalPath,
-        slug: route2.slug,
-        uidPath: route2.uidPath
-      };
+      cleanEntity = await enrichWebatlasData(cleanEntity, route2.relatedContentType);
+      cleanEntity = await enrichRoutePickerFields(cleanEntity, contentTypeKey);
       return {
         contentType: contentType.info.singularName,
-        webatlas: {
-          ...webatlasFields
-        },
         ...cleanEntity
       };
     } catch (e) {

package/dist/server/src/index.d.ts

@@ -300,6 +300,9 @@ declare const _default: {
         addWebatlasField: ({ strapi }: {
             strapi: import('@strapi/types/dist/core').Strapi;
         }) => (ctx: any, next: any) => Promise<void>;
+        enrichRoutePicker: ({ strapi }: {
+            strapi: import('@strapi/types/dist/core').Strapi;
+        }) => (ctx: any, next: any) => Promise<void>;
     };
 };
 export default _default;

package/package.json

@@ -2,7 +2,7 @@
 	"name": "@mattisvensson/strapi-plugin-webatlas",
 	"description": "A strapi plugin to manage URL routes and navigations.",
 	"license": "MIT",
-	"version": "0.11.4",
+	"version": "0.11.6",
 	"keywords": [
 		"strapi",
 		"plugin",