strapi-plugin-navigation 2.0.0-rc.1 → 2.0.3

package/server/routes/admin.js

@@ -16,6 +16,16 @@ module.exports = {
       path: '/config',
       handler: 'navigation.config',
     },
+    {
+      method: 'PUT',
+      path: '/config',
+      handler: 'navigation.updateConfig',
+    },
+    {
+      method: 'DELETE',
+      path: '/config',
+      handler: 'navigation.restoreConfig',
+    },
     {
       method: 'GET',
       path: '/:id',
@@ -33,6 +43,19 @@ module.exports = {
       policies: [
         'admin::isAuthenticatedAdmin'
       ]
-    }
+    },
+    {
+      method: 'GET',
+      path: '/settings/config',
+      handler: 'navigation.settingsConfig',
+    },
+    {
+      method: 'GET',
+      path: '/settings/restart',
+      handler: 'navigation.settingsRestart',
+      config: {
+        policies: [],
+      },
+    },
   ]
 }

package/server/services/__tests__/functions.test.js

@@ -0,0 +1,48 @@
+const { setupStrapi } = require('../../../__mocks__/strapi');
+const utilsFunctionsFactory = require('../utils/functions');
+
+describe('Utilities functions', () => {
+	beforeAll(async () => {
+		setupStrapi();
+	});
+
+	describe('Path rendering functions', () => {
+		it('Can build nested path structure', async () => {
+			const utilsFunctions = utilsFunctionsFactory({ strapi });
+			const { itemModel } = utilsFunctions.extractMeta(strapi.plugins);
+			const rootPath = '/home/side';
+			const entities = await strapi
+				.query(itemModel.uid)
+				.findMany({
+					where: {
+						master: 1
+					}
+				});
+			const nested = utilsFunctions.buildNestedPaths({ items: entities });
+
+			expect(nested.length).toBe(2);
+			expect(nested[1].path).toBe(rootPath);
+		});
+
+		it('Can filter items by path', async () => {
+			const utilsFunctions = utilsFunctionsFactory({ strapi });
+			const { itemModel } = utilsFunctions.extractMeta(strapi.plugins);
+			const rootPath = '/home/side';
+			const entities = await strapi
+				.query(itemModel.uid)
+				.findMany({
+					where: {
+						master: 1
+					}
+				});
+			const {
+				root,
+				items
+			} = utilsFunctions.filterByPath(entities, rootPath);
+
+			expect(root).toBeDefined();
+			expect(root.path).toBe(rootPath);
+			expect(items.length).toBe(1)
+		});
+	});
+});

package/server/services/__tests__/navigation.test.js

@@ -1,84 +1,91 @@
-const { setupStrapi } = require('../../__mocks__/helpers/strapi');
+const { setupStrapi } = require('../../../__mocks__/strapi');
 
-beforeAll(setupStrapi);
+describe('Navigation services', () => {
+  beforeAll(async () => {
+    setupStrapi();
+  });
+
+  describe('Correct config', () => {
+    it('Declares Strapi instance', () => {
+      expect(strapi).toBeDefined()
+      expect(strapi.plugin('navigation').service('navigation')).toBeDefined()
+    });
 
-describe('Navigation service', () => {
-  it('Strapi is defined', () => {
-    expect(strapi).toBeDefined();
-    expect(strapi.contentTypes).toBeDefined();
-    expect(Object.keys(strapi.contentTypes).length).toBe(6);
+    it('Defines proper content types', () => {
+      expect(strapi.contentTypes).toBeDefined()
+      expect(strapi.plugin('navigation').contentTypes).toBeDefined()
+    });
+
+    it('Can read and return plugins config', () => {
+      expect(strapi.plugin('navigation').config('contentTypes')).toBeDefined()
+      expect(strapi.plugin('navigation').config('allowedLevels')).toBeDefined()
+      expect(strapi.plugin('navigation').config()).not.toBeDefined()
+    });
   });
-  it('Config Content Types', () => {
-    const { configContentTypes } = require('../navigation');
-    const results = [
-      {
-        uid: 'application::pages.pages',
-        collectionName: 'pages',
-        isSingle: false,
-        contentTypeName: 'Pages',
-        endpoint: 'pages',
-        label: 'Pages',
-        labelSingular: 'Page',
-        name: 'page',
-        visible: true,
-      }, {
-        uid: 'application::blog-post.blog-post',
-        collectionName: 'blog_posts',
-        isSingle: false,
-        contentTypeName: 'BlogPost',
-        endpoint: 'blog-posts',
-        label: 'Blog posts',
-        labelSingular: 'Blog post',
-        name: 'blog-post',
-        visible: true,
-      }, {
-        uid: 'application::my-homepages.my-homepage',
-        collectionName: 'my-homepages',
-        isSingle: true,
-        contentTypeName: 'MyHomepage',
-        endpoint: 'my-homepage',
-        label: 'My Homepage',
-        labelSingular: 'My Homepage',
-        name: 'my-homepage',
-        visible: true,
-      }, {
-        uid: 'application::page-homes.home-page',
-        collectionName: 'page_homes',
-        isSingle: true,
-        contentTypeName: 'HomePage',
-        endpoint: 'custom-api',
-        label: 'Page Home',
-        labelSingular: 'Page Home',
-        name: 'home-page',
-        visible: true,
-      }, {
-        uid: 'plugins::another-plugin.pages',
-        collectionName: 'pages',
-        isSingle: false,
-        contentTypeName: 'Plugin-pages',
-        endpoint: 'plugin-pages',
-        label: 'Pages',
-        labelSingular: 'Page',
-        name: 'plugin-page',
-        visible: true,
-        plugin: 'another-plugin',
-      }, {
-        uid: 'plugins::another-plugin.blog-post',
-        collectionName: 'blog_posts',
-        isSingle: false,
-        contentTypeName: 'BlogPost',
-        endpoint: 'plugin-blog-posts',
-        label: 'Blog posts',
-        labelSingular: 'Blog post',
-        name: 'plugin-blog-post',
-        visible: true,
-        plugin: 'another-plugin',
-      }];
-    return configContentTypes().then(types => {
-      types.map(type => {
-        const result = results.find(({ uid }) => uid === type.uid);
-        expect(type).toMatchObject(result);
+
+  describe('Render navigation', () => {
+    it('Can render branch in flat format', async () => {
+      const service = strapi.plugin('navigation').service('navigation');
+      const result = await service.render({ idOrSlug: 1 });
+
+      expect(result).toBeDefined()
+      expect(result.length).toBe(2)
+    });
+
+    it('Can render branch in tree format', async () => {
+      const service = strapi.plugin('navigation').service('navigation');
+      const result = await service.render({
+        idOrSlug: 1,
+        type: "TREE"
+      });
+
+      expect(result).toBeDefined()
+      expect(result.length).toBeGreaterThan(0)
+    });
+
+    it('Can render branch in rfr format', async () => {
+      const service = strapi.plugin('navigation').service('navigation');
+      const result = await service.render({
+        idOrSlug: 1,
+        type: "RFR"
       });
+
+      expect(result).toBeDefined()
+      expect(result.length).toBeGreaterThan(0)
+    });
+
+    it('Can render only menu attached elements', async () => {
+      const service = strapi.plugin('navigation').service('navigation');
+      const result = await service.render({
+        idOrSlug: 1,
+        type: "FLAT",
+        menuOnly: true.valueOf,
+      });
+
+      expect(result).toBeDefined()
+      expect(result.length).toBe(1)
+    });
+
+    it('Can render branch by path', async () => {
+      const service = strapi.plugin('navigation').service('navigation');
+      const result = await service.render({
+        idOrSlug: 1,
+        type: "FLAT",
+        rootPath: '/home/side'
+      });
+
+      expect(result).toBeDefined();
+      expect(result.length).toBe(1);
+    });
+  });
+
+  describe('Render child', () => {
+    it('Can render child', async () => {
+      const service = strapi.plugin('navigation').service('navigation');
+      const result = await service.renderChildren(1, "home");
+
+      expect(result).toBeDefined();
+      expect(result.length).toBe(1);
     });
   });
 });

package/server/services/navigation.js

@@ -19,7 +19,7 @@ const { KIND_TYPES } = require('./utils/constant');
 const utilsFunctionsFactory = require('./utils/functions');
 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 { NotFoundError } = require('@strapi/utils').errors
 const excludedContentTypes = ['strapi::'];
 const contentTypesNameFieldsDefaults = ['title', 'subject', 'name'];
 
@@ -56,7 +56,7 @@ module.exports = ({ strapi }) => {
             limit: -1,
           },
           sort: ['order:asc'],
-          populate: ['related', 'parent']
+          populate: ['related', 'parent', 'audience']
         });
       const entities = await this.getRelatedItems(entityItems);
       return {
@@ -65,27 +65,35 @@ module.exports = ({ strapi }) => {
       };
     },
 
+    async restart() {
+      setImmediate(() => strapi.reload());
+    },
+
     // Get plugin config
-    async config() {
-      const { pluginName, audienceModel } = utilsFunctions.extractMeta(strapi.plugins);
-      const additionalFields = strapi.plugin(pluginName).config('additionalFields')
-      const contentTypesNameFields = strapi.plugin(pluginName).config('contentTypesNameFields');
-      const allowedLevels = strapi.plugin(pluginName).config('allowedLevels');
+    async config(viaSettingsPage = false) {
+      const { audienceModel, service } = utilsFunctions.extractMeta(strapi.plugins);
+      const pluginStore = await strapi.store({ type: 'plugin', name: 'navigation' });
+      const config = await pluginStore.get({ key: 'config' });
+      const additionalFields = config.additionalFields;
+      const contentTypesNameFields = config.contentTypesNameFields;
+      const allowedLevels = config.allowedLevels;
+      const isGQLPluginEnabled = !isNil(strapi.plugin('graphql'));
 
       let extendedResult = {};
       const result = {
-        contentTypes: await strapi.plugin(pluginName).service('navigation').configContentTypes(),
+        contentTypes: await service.configContentTypes(),
         contentTypesNameFields: {
           default: contentTypesNameFieldsDefaults,
           ...(isObject(contentTypesNameFields) ? contentTypesNameFields : {}),
         },
         allowedLevels,
         additionalFields,
+        isGQLPluginEnabled: viaSettingsPage ? isGQLPluginEnabled : undefined,
       };
 
       if (additionalFields.includes(configAdditionalFields.AUDIENCE)) {
         const audienceItems = await strapi
-          .query(`plugin::${pluginName}.${audienceModel.modelName}`)
+          .query(audienceModel.uid)
           .findMany({
             paggination: {
               limit: -1,
@@ -102,10 +110,33 @@ module.exports = ({ strapi }) => {
       };
     },
 
+    async updateConfig(newConfig) {
+      const pluginStore = await strapi.store({ type: 'plugin', name: 'navigation' });
+      await pluginStore.set({ key: 'config', value: newConfig });
+    },
+
+    async restoreConfig() {
+      const pluginStore = await strapi.store({ type: 'plugin', name: 'navigation' });
+      const defaultConfig = await strapi.plugin('navigation').config
+
+      await pluginStore.delete({ key: 'config' })
+      await pluginStore.set({
+        key: 'config', value: {
+          additionalFields: defaultConfig('additionalFields'),
+          contentTypes: defaultConfig('contentTypes'),
+          contentTypesNameFields: defaultConfig('contentTypesNameFields'),
+          allowedLevels: defaultConfig('allowedLevels'),
+          gql: defaultConfig('gql'),
+        }
+      });
+    },
+
     async configContentTypes() {
+      const pluginStore = strapi.store({ type: 'plugin', name: 'navigation' });
+      const config = await pluginStore.get({ key: 'config' });
       const eligibleContentTypes =
         await Promise.all(
-          strapi.plugin('navigation').config('contentTypes')
+          config.contentTypes
             .filter(contentType => !!strapi.contentTypes[contentType])
             .map(
               async (key) => {
@@ -311,20 +342,20 @@ module.exports = ({ strapi }) => {
         ...(type === renderType.FLAT ? { uiRouterKey: childUIKey } : {}),
       };
 
-      return service.renderType(type, criteria, itemCriteria, filter);
+      return service.renderType({ type, criteria, itemCriteria, filter });
     },
 
-    async render(idOrSlug, type = renderType.FLAT, menuOnly = false) {
+    async render({ idOrSlug, type = renderType.FLAT, menuOnly = false, rootPath = null }) {
       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);
+      return service.renderType({ type, criteria, itemCriteria, rootPath });
     },
 
-    async renderType(type = renderType.FLAT, criteria = {}, itemCriteria = {}, filter = null) {
+    async renderType({ type = renderType.FLAT, criteria = {}, itemCriteria = {}, filter = null, rootPath = null }) {
       const { pluginName, service, masterModel, itemModel } = utilsFunctions.extractMeta(
         strapi.plugins,
       );
@@ -362,8 +393,8 @@ module.exports = ({ strapi }) => {
             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 === '/'
-                ? ''
+              const parentPath = isExternal ? undefined : `${path === '/' ? '' : path}/${first(item.path) === '/'
+                ? item.path.substring(1)
                 : item.path}`;
               const slug = isString(parentPath) ? slugify(
                 (first(parentPath) === '/' ? parentPath.substring(1) : parentPath).replace(/\//g, '-')) : undefined;
@@ -391,9 +422,17 @@ module.exports = ({ strapi }) => {
                 }),
               };
             };
+
+            const {
+              items: itemsFilteredByPath,
+              root: rootElement,
+            } = utilsFunctions.filterByPath(items, rootPath);
+
             const treeStructure = service.renderTree({
-              items,
+              items: isNil(rootPath) ? items : itemsFilteredByPath,
               field: 'parent',
+              id: get(rootElement, 'parent.id'),
+              path: get(rootElement, 'parent.path'),
               itemParser,
             });
 
@@ -409,7 +448,7 @@ module.exports = ({ strapi }) => {
             }
             return filteredStructure;
           default:
-            return items
+            const publishedItems = items
               .filter(utilsFunctions.filterOutUnpublished)
               .map((item) => ({
                 ...item,
@@ -418,6 +457,7 @@ module.exports = ({ strapi }) => {
                 related: item.related?.map(({ localizations, ...item }) => item),
                 items: null,
               }));
+            return isNil(rootPath) ? items : utilsFunctions.filterByPath(publishedItems, rootPath).items;
         }
       }
       throw new NotFoundError();

package/server/services/utils/functions.js

@@ -6,6 +6,7 @@ const {
   find,
   isString,
   get,
+  isNil,
 } = require('lodash');
 
 const { type: itemType } = require('../../content-types/navigation-item/lifecycle');
@@ -20,19 +21,12 @@ module.exports = ({ strapi }) => {
 
     extractMeta(plugins) {
       const { navigation: plugin } = plugins;
-      const { navigation: service } = plugin.services;
-      const {
-        navigation: masterModel,
-        'navigation-item': itemModel,
-        audience: audienceModel,
-        'navigations-items-related': relatedModel,
-      } = plugin.contentTypes;
       return {
-        masterModel,
-        itemModel,
-        relatedModel,
-        audienceModel,
-        service,
+        masterModel: plugin.contentType('navigation'),
+        itemModel: plugin.contentType('navigation-item'),
+        relatedModel: plugin.contentType('navigations-items-related'),
+        audienceModel: plugin.contentType('audience'),
+        service: plugin.service('navigation'),
         plugin,
         pluginName: 'navigation',
       };
@@ -59,6 +53,45 @@ module.exports = ({ strapi }) => {
         });
     },
 
+    buildNestedPaths({items, id = null, field = 'parent', parentPath = null}){
+      return items
+        .filter(entity => {
+          if (entity[field] == null && id === null) {
+            return true;
+          }
+          let data = entity[field];
+          if (data && typeof id === 'string') {
+            data = data.toString();
+          }
+          return (data && data === id) || (isObject(entity[field]) && (entity[field].id === id));
+        })
+        .reduce((acc, entity) => {
+          const path = `${parentPath || ''}/${entity.path}`
+          return [
+            {
+              id: entity.id,
+              parent: parentPath && {
+                id: get(entity, 'parent.id'),
+                path: parentPath,
+              },
+              path
+            },
+            ...this.buildNestedPaths({items, id: entity.id, field, parentPath: path}),
+            ...acc,
+          ];
+        }, [])
+    },
+
+    filterByPath(items, path) {
+      const itemsWithPaths = this.buildNestedPaths({ items }).filter(({path: itemPath}) => itemPath.includes(path));
+      const root = itemsWithPaths.find(({ path: itemPath }) => itemPath === path);
+
+      return {
+        root,
+        items: isNil(root) ? [] : items.filter(({ id }) => (itemsWithPaths.find(v => v.id === id))),
+      }
+    },
+
     prepareAuditLog(actions) {
       return [
         ...new Set(

package/strapi-server.js

@@ -4,7 +4,6 @@ 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 = () => {
@@ -15,6 +14,5 @@ module.exports = () => {
     controllers,
     services,
     contentTypes,
-    register,
   };
 };