strapi-plugin-navigation 2.0.0-beta.1 → 2.0.0-beta.5

package/server/services/navigation.js

@@ -8,11 +8,18 @@ const {
   last,
   upperFirst,
   map,
+  toNumber,
+  isString,
+  first,
+
 } = require('lodash');
+const { validate: isUuid } = require('uuid');
+const slugify = require('slugify');
 const { KIND_TYPES } = require('./utils/constant');
 const utilsFunctionsFactory = require('./utils/functions');
-const { additionalFields: configAdditionalFields } = require('../content-types/navigation-item').lifecycle;
-
+const { renderType } = require('../content-types/navigation/lifecycle');
+const { type: itemType, additionalFields: configAdditionalFields } = require('../content-types/navigation-item').lifecycle;
+const { NotFoundError } =  require('@strapi/utils').errors
 const excludedContentTypes = ['strapi::'];
 const contentTypesNameFieldsDefaults = ['title', 'subject', 'name'];
 
@@ -37,7 +44,7 @@ module.exports = ({ strapi }) => {
       const { masterModel, itemModel } = utilsFunctions.extractMeta(strapi.plugins);
       const entity = await strapi
         .query(masterModel.uid)
-        .findOne({ where: { id }});
+        .findOne({ where: { id } });
 
       const entityItems = await strapi
         .query(itemModel.uid)
@@ -193,9 +200,11 @@ module.exports = ({ strapi }) => {
               .map(async ([model, related]) => {
                 const relationData = await strapi
                   .query(model)
-                  .findMany({where: {
-                    id: { $in: map(related, 'related_id') }
-                  }});
+                  .findMany({
+                    where: {
+                      id: { $in: map(related, 'related_id') }
+                    }
+                  });
                 return relationData
                   .flatMap(_ =>
                     Object.assign(
@@ -286,6 +295,263 @@ module.exports = ({ strapi }) => {
         });
     },
 
+    async renderChildren(
+      idOrSlug,
+      childUIKey,
+      type = renderType.FLAT,
+      menuOnly = false,
+    ) {
+      const { service } = utilsFunctions.extractMeta(strapi.plugins);
+      const findById = !isNaN(toNumber(idOrSlug)) || isUuid(idOrSlug);
+      const criteria = findById ? { id: idOrSlug } : { slug: idOrSlug };
+      const filter = type === renderType.FLAT ? null : childUIKey;
+
+      const itemCriteria = {
+        ...(menuOnly && { menuAttached: true }),
+        ...(type === renderType.FLAT ? { uiRouterKey: childUIKey } : {}),
+      };
+
+      return service.renderType(type, criteria, itemCriteria, filter);
+    },
+
+    async render(idOrSlug, type = renderType.FLAT, menuOnly = false) {
+      const { service } = utilsFunctions.extractMeta(strapi.plugins);
+
+      const findById = !isNaN(toNumber(idOrSlug)) || isUuid(idOrSlug);
+      const criteria = findById ? { id: idOrSlug } : { slug: idOrSlug };
+      const itemCriteria = menuOnly ? { menuAttached: true } : {};
+
+      return service.renderType(type, criteria, itemCriteria);
+    },
+
+    async renderType(type = renderType.FLAT, criteria = {}, itemCriteria = {}, filter = null) {
+      const { pluginName, service, masterModel, itemModel } = utilsFunctions.extractMeta(
+        strapi.plugins,
+      );
+
+      const entity = await strapi
+        .query(masterModel.uid)
+        .findOne({
+          where: {
+            ...criteria,
+            visible: true,
+          }
+        });
+      if (entity && entity.id) {
+        const entities = await strapi.query(itemModel.uid).findMany({
+          where: {
+            master: entity.id,
+            ...itemCriteria,
+          },
+          paggination: {
+            limit: -1,
+          },
+          sort: ['order:asc'],
+          populate: ['related', 'audience', 'parent'],
+        });
+
+        if (!entities) {
+          return [];
+        }
+        const items = await this.getRelatedItems(entities);
+        const { contentTypes, contentTypesNameFields } = await service.config();
+
+        switch (type?.toLowerCase()) {
+          case renderType.TREE:
+          case renderType.RFR:
+            const getTemplateName = await utilsFunctions.templateNameFactory(items, strapi, contentTypes);
+            const itemParser = (item, path = '', field) => {
+              const isExternal = item.type === itemType.EXTERNAL;
+              const parentPath = isExternal ? undefined : `${path === '/' ? '' : path}/${item.path === '/'
+                ? ''
+                : item.path}`;
+              const slug = isString(parentPath) ? slugify(
+                (first(parentPath) === '/' ? parentPath.substring(1) : parentPath).replace(/\//g, '-')) : undefined;
+              const lastRelated = item.related ? last(item.related) : undefined;
+              return {
+                id: item.id,
+                title: utilsFunctions.composeItemTitle(item, contentTypesNameFields, contentTypes),
+                menuAttached: item.menuAttached,
+                path: isExternal ? item.externalPath : parentPath,
+                type: item.type,
+                uiRouterKey: item.uiRouterKey,
+                slug: !slug && item.uiRouterKey ? slugify(item.uiRouterKey) : slug,
+                external: isExternal,
+                related: isExternal || !lastRelated ? undefined : {
+                  ...lastRelated,
+                  __templateName: getTemplateName(lastRelated.relatedType || lastRelated.__contentType, lastRelated.id),
+                },
+                audience: !isEmpty(item.audience) ? item.audience.map(aItem => aItem.key) : undefined,
+                items: isExternal ? undefined : service.renderTree({
+                  items,
+                  id: item.id,
+                  field,
+                  path: parentPath,
+                  itemParser,
+                }),
+              };
+            };
+            const treeStructure = service.renderTree({
+              items,
+              field: 'parent',
+              itemParser,
+            });
+
+            const filteredStructure = filter
+              ? treeStructure.filter((item) => item.uiRouterKey === filter)
+              : treeStructure;
+
+            if (type === renderType.RFR) {
+              return service.renderRFR({
+                items: filteredStructure,
+                contentTypes,
+              });
+            }
+            return filteredStructure;
+          default:
+            return items
+              .filter(utilsFunctions.filterOutUnpublished)
+              .map((item) => ({
+                ...item,
+                audience: item.audience?.map(_ => _.key),
+                title: utilsFunctions.composeItemTitle(item, contentTypesNameFields, contentTypes),
+                related: item.related?.map(({ localizations, ...item }) => item),
+                items: null,
+              }));
+        }
+      }
+      throw new NotFoundError();
+    },
+
+    renderTree({
+      items = [],
+      id = null,
+      field = 'parent',
+      path = '',
+      itemParser = (i) => i,
+    }) {
+      return items
+        .filter(
+          (item) => {
+            if (item[field] === null && id === null) {
+              return true;
+            }
+            let data = item[field];
+            if (data && typeof id === 'string') {
+              data = data.toString();
+            }
+            return (data && data === id) || (isObject(item[field]) && (item[field].id === id));
+          },
+        )
+        .filter(utilsFunctions.filterOutUnpublished)
+        .map(item => itemParser({
+          ...item,
+        }, path, field));
+    },
+
+    renderRFR({ items, parent = null, parentNavItem = null, contentTypes = [] }) {
+      const { service } = utilsFunctions.extractMeta(strapi.plugins);
+      let pages = {};
+      let nav = {};
+      let navItems = [];
+
+      items.forEach(item => {
+        const { items: itemChilds, ...itemProps } = item;
+        const itemNav = service.renderRFRNav(itemProps);
+        const itemPage = service.renderRFRPage({
+          item: itemProps,
+          parent,
+        });
+
+        if (item.type === itemType.INTERNAL) {
+          pages = {
+            ...pages,
+            [itemPage.id]: {
+              ...itemPage,
+            },
+          };
+        }
+
+        if (item.menuAttached) {
+          navItems.push(itemNav);
+        }
+
+        if (!parent) {
+          nav = {
+            ...nav,
+            root: navItems,
+          };
+        } else {
+          const navLevel = navItems
+            .filter(navItem => navItem.type === itemType.INTERNAL.toLowerCase());
+          if (!isEmpty(navLevel))
+            nav = {
+              ...nav,
+              [parent]: [].concat(parentNavItem ? parentNavItem : [], navLevel),
+            };
+        }
+
+        if (!isEmpty(itemChilds)) {
+          const { nav: nestedNavs } = service.renderRFR({
+            items: itemChilds,
+            parent: itemPage.id,
+            parentNavItem: itemNav,
+            contentTypes,
+          });
+          const { pages: nestedPages } = service.renderRFR({
+            items: itemChilds.filter(child => child.type === itemType.INTERNAL),
+            parent: itemPage.id,
+            parentNavItem: itemNav,
+            contentTypes,
+          });
+          pages = {
+            ...pages,
+            ...nestedPages,
+          };
+          nav = {
+            ...nav,
+            ...nestedNavs,
+          };
+        }
+      });
+
+      return {
+        pages,
+        nav,
+      };
+    },
+
+    renderRFRNav(item) {
+      const { uiRouterKey, title, path, type, audience } = item;
+      return {
+        label: title,
+        type: type.toLowerCase(),
+        page: type === itemType.INTERNAL ? uiRouterKey : undefined,
+        url: type === itemType.EXTERNAL ? path : undefined,
+        audience,
+      };
+    },
+
+    renderRFRPage({ item, parent }) {
+      const { uiRouterKey, title, path, slug, related, type, audience, menuAttached } = item;
+      const { __contentType, id, __templateName } = related || {};
+      const contentType = __contentType || '';
+      return {
+        id: uiRouterKey,
+        title,
+        templateName: __templateName,
+        related: type === itemType.INTERNAL ? {
+          contentType,
+          id,
+        } : undefined,
+        path,
+        slug,
+        parent,
+        audience,
+        menuAttached,
+      };
+    },
+
     createBranch(items = [], masterEntity = null, parentItem = null, operations = {}) {
       const { itemModel, service } = utilsFunctions.extractMeta(strapi.plugins);
       return Promise.all(

package/server/services/utils/functions.js

@@ -2,9 +2,13 @@ const {
   last,
   isObject,
   isEmpty,
+  flatten,
+  find,
+  isString,
+  get,
 } = require('lodash');
 
-const { type: itemType } = require('../../content-types/navigation-item');
+const { type: itemType } = require('../../content-types/navigation-item/lifecycle');
 const { NavigationError } = require('../../../utils/NavigationError');
 const { TEMPLATE_DEFAULT } = require('./constant');
 
@@ -13,7 +17,7 @@ module.exports = ({ strapi }) => {
     singularize(value = '') {
       return last(value) === 's' ? value.substr(0, value.length - 1) : value;
     },
-    
+
     extractMeta(plugins) {
       const { navigation: plugin } = plugins;
       const { navigation: service } = plugin.services;
@@ -99,5 +103,83 @@ module.exports = ({ strapi }) => {
         return resolve();
       });
     },
+
+    async templateNameFactory(items, strapi, contentTypes = []) {
+      const flatRelated = flatten(items.map(i => i.related)).filter(_ => !!_);
+      const relatedMap = flatRelated.reduce((acc, curr) => {
+        if (!acc[curr.__contentType]) {
+          acc[curr.__contentType] = [];
+        }
+        acc[curr.__contentType].push(curr.id);
+        return acc;
+      }, {});
+      const responses = await Promise.all(
+        Object.entries(relatedMap)
+          .map(
+            ([contentType, ids]) => {
+              const contentTypeUid = get(find(contentTypes, cnt => cnt.uid === contentType), 'uid');
+              return strapi.query(contentTypeUid)
+                .findMany({ id_in: ids, _limit: -1 })
+                .then(res => ({ [contentType]: res }))
+            }),
+      );
+      const relatedResponseMap = responses.reduce((acc, curr) => ({ ...acc, ...curr }), {});
+      const singleTypes = new Map(
+        contentTypes
+          .filter(x => x.isSingle)
+          .map(({ contentTypeName, templateName }) => [contentTypeName, templateName || contentTypeName])
+      );
+
+      return (contentType, id) => {
+        const template = get(relatedResponseMap[contentType].find(data => data.id === id), 'template');
+
+        if (template) {
+          const templateComponent = this.getTemplateComponentFromTemplate(template);
+          return get(templateComponent, 'options.templateName', TEMPLATE_DEFAULT);
+        }
+
+        if (singleTypes.get(contentType)) {
+          return singleTypes.get(contentType);
+        }
+
+        return TEMPLATE_DEFAULT;
+      };
+    },
+
+    getTemplateComponentFromTemplate(template = []) {
+      const componentName = get(first(template), '__component');
+      return componentName ? strapi.components[componentName] : null;
+    },
+
+    composeItemTitle(item = {}, fields = {}, contentTypes = []) {
+      const { title, related } = item;
+      if (title) {
+        return isString(title) && !isEmpty(title) ? title : undefined;
+      } else if (related) {
+        const relationTitle = this.extractItemRelationTitle(isArray(related) ? last(related) : related, fields, { contentTypes });
+        return isString(relationTitle) && !isEmpty(relationTitle) ? relationTitle : undefined;
+      }
+      return undefined;
+    },
+
+    extractItemRelationTitle(relatedItem = {}, fields = {}, contentTypes = []) {
+      const { __contentType } = relatedItem;
+      const contentType = find(contentTypes, _ => _.contentTypeName === __contentType);
+      const { default: defaultFields = [] } = fields;
+      return get(fields, `${contentType ? contentType.collectionName : ''}`, defaultFields).map((_) => relatedItem[_]).filter((_) => _)[0] || '';
+    },
+
+    filterOutUnpublished(item) {
+      const relatedItem = item.related && last(item.related);
+      const isHandledByPublshFlow = relatedItem ? 'published_at' in relatedItem : false;
+
+      if (isHandledByPublshFlow) {
+        const isRelatedDefinedAndPublished = relatedItem ?
+          isHandledByPublshFlow && get(relatedItem, 'published_at') :
+          false;
+        return item.type === itemType.INTERNAL ? isRelatedDefinedAndPublished : true;
+      }
+      return (item.type === itemType.EXTERNAL) || relatedItem;
+    },
   };
 }

package/strapi-server.js

@@ -4,6 +4,7 @@ const routes = require('./server/routes');
 const controllers = require('./server/controllers');
 const contentTypes = require('./server/content-types');
 const config = require('./server/config');
+const register = require('./server/register');
 
 
 module.exports = () => {
@@ -13,6 +14,7 @@ module.exports = () => {
     routes,
     controllers,
     services,
-    contentTypes
+    contentTypes,
+    register,
   };
 };