strapi-plugin-navigation 2.0.0 → 2.0.4

package/admin/src/utils/index.js

@@ -0,0 +1,20 @@
+import { useIntl } from 'react-intl';
+import { isString } from 'lodash';
+
+import pluginId from '../pluginId';
+
+const getMessage = (input, defaultMessage = '', inPluginScope = true) => {
+    const { formatMessage } = useIntl();
+    let formattedId = ''
+    if (isString(input)) {
+        formattedId = input;
+    } else {
+        formattedId = input?.id;
+    }
+    return formatMessage({
+        id: `${inPluginScope ? pluginId : 'app.components'}.${formattedId}`,
+        defaultMessage,
+    }, input?.props || undefined)
+};
+
+export { getMessage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strapi-plugin-navigation",
-  "version": "2.0.0",
+  "version": "2.0.4",
   "description": "Strapi - Navigation plugin",
   "strapi": {
     "name": "navigation",
@@ -13,11 +13,11 @@
     "url": "https://github.com/VirtusLab/strapi-plugin-navigation"
   },
   "scripts": {
-    "publish": "npm publish --tag latest",
+    "publish:latest": "npm publish --tag latest",
     "test:unit": "jest --verbose --coverage"
   },
   "dependencies": {
-    "@strapi/utils": "^4.0.7",
+    "@strapi/utils": "^4.1.0",
     "uuid": "^8.3.0",
     "bad-words": "^3.0.3",
     "lodash": "^4.17.11",
@@ -44,8 +44,8 @@
     "@strapi/strapi": "4.x"
   },
   "author": {
-    "name": "VirtusLab // Mateusz Ziarko",
-    "email": "mziarko@virtuslab.com",
+    "name": "VirtusLab",
+    "email": "strapi@virtuslab.com",
     "url": "https://virtuslab.com"
   },
   "maintainers": [

package/server/bootstrap.js

@@ -23,7 +23,9 @@ module.exports = async ({ strapi }) => {
       pluginName: "navigation",
     },
   ];
+  await strapi.admin.services.permission.actionProvider.registerMany(actions);
 
+  // Initialize first navigation
   const navigations = await strapi
     .query("plugin::navigation.navigation")
     .findMany();
@@ -38,5 +40,32 @@ module.exports = async ({ strapi }) => {
         }
       });
   }
-  await strapi.admin.services.permission.actionProvider.registerMany(actions);
+  
+  // Initialize configuration
+  const pluginStore = strapi.store({
+    environment: '',
+    type: 'plugin',
+    name: 'navigation',
+  });
+
+  const config = await pluginStore.get({ key: 'config' });
+  const pluginDefaultConfig = await strapi.plugin('navigation').config
+  const defaultConfigValue = {
+    additionalFields: pluginDefaultConfig('additionalFields'),
+    contentTypes: pluginDefaultConfig('contentTypes'),
+    contentTypesNameFields: pluginDefaultConfig('contentTypesNameFields'),
+    allowedLevels: pluginDefaultConfig('allowedLevels'),
+    gql: pluginDefaultConfig('gql'),
+  }
+  
+  if (!config) {
+    pluginStore.set({
+      key: 'config', value: defaultConfigValue
+    });
+  }
+
+  if (strapi.plugin('graphql')) {
+    const graphqlConfiguration = require('./graphql')
+    await graphqlConfiguration({ strapi, config: config || defaultConfigValue });
+  }
 };

package/server/controllers/navigation.js

@@ -19,10 +19,34 @@ const errorHandler = (ctx) => (error) => {
   throw error;
 };
 
-module.exports = {
+module.exports = ({strapi}) => ({
   async config() {
     return getService().config();
   },
+
+  async updateConfig(ctx) {
+    await getService().updateConfig(ctx.request.body)
+    return ctx.send({ status: 200 });
+  },
+
+  async restoreConfig(ctx) {
+    await getService().restoreConfig()
+    return ctx.send({ status: 200 })
+  },
+
+  async settingsConfig() {
+    return getService().config(true);
+  },
+
+  async settingsRestart(ctx) {
+    try {
+      await getService().restart();
+      return ctx.send({ status: 200 });
+    } catch (e) {
+      errorHandler(ctx, e);
+    }
+  },
+
   async get() {
     return getService().get();
   },
@@ -50,13 +74,14 @@ module.exports = {
   },
   async render(ctx) {
     const { params, query = {} } = ctx;
-    const { type, menu: menuOnly } = query;
+    const { type, menu: menuOnly, path: rootPath } = query;
     const { idOrSlug } = parseParams(params);
-    return getService().render(
+    return getService().render({
       idOrSlug,
       type,
       menuOnly,
-    );
+      rootPath
+    });
   },
   async renderChild(ctx) {
     const { params, query = {} } = ctx;
@@ -69,4 +94,4 @@ module.exports = {
       menuOnly
     );
   },
-};
+});

package/server/graphql/index.js

@@ -2,16 +2,15 @@ const getTypes = require('./types');
 const getQueries = require('./queries');
 const getResolversConfig = require('./resolvers-config');
 
-module.exports = () => {
+module.exports = async ({ strapi, config }) => {
 	const extensionService = strapi.plugin('graphql').service('extension');
-
 	extensionService.shadowCRUD('plugin::navigation.audience').disable();
 	extensionService.shadowCRUD('plugin::navigation.navigation').disable();
 	extensionService.shadowCRUD('plugin::navigation.navigation-item').disable();
 	extensionService.shadowCRUD('plugin::navigation.navigations-items-related').disable();
 
-	extensionService.use(({ nexus }) => {
-		const types = getTypes({ strapi, nexus });
+	extensionService.use(({strapi, nexus}) => {
+		const types = getTypes({ strapi, nexus, config });
 		const queries = getQueries({ strapi, nexus });
 		const resolversConfig = getResolversConfig({ strapi });
 

package/server/graphql/queries/render-navigation.js

@@ -5,11 +5,12 @@ module.exports = ({ strapi, nexus }) => {
 		args: {
 			navigationIdOrSlug: nonNull(stringArg()),
 			type: 'NavigationRenderType',
-			menuOnly: booleanArg()
+			menuOnly: booleanArg(),
+			path: stringArg(),
 		},
 		resolve(obj, args) {
-			const { navigationIdOrSlug, type, menuOnly } = args;
-			return strapi.plugin('navigation').service('navigation').render(navigationIdOrSlug, type, menuOnly);
+			const { navigationIdOrSlug: idOrSlug, type, menuOnly, path: rootPath } = args;
+			return strapi.plugin('navigation').service('navigation').render({idOrSlug, type, menuOnly, rootPath});
 		},
 	};
 }

package/server/graphql/types/content-types-name-fields.js

@@ -1,8 +1,10 @@
 module.exports = ({ nexus }) => nexus.objectType({
   name: "ContentTypesNameFields",
-  definition(t) {
+  async definition(t) {
 		t.nonNull.list.nonNull.string("default")
-		const contentTypesNameFields = strapi.plugin('navigation').config('contentTypesNameFields')
+		const pluginStore = strapi.store({ type: 'plugin', name: 'navigation' });
+		const config = await pluginStore.get({ key: 'config' });
+		const contentTypesNameFields = config.contentTypesNameFields;
 		Object.keys(contentTypesNameFields || {}).forEach(key => t.nonNull.list.string(key))
   }
 })

package/server/graphql/types/navigation-related.js

@@ -1,5 +1,5 @@
-module.exports = ({ strapi, nexus }) => {
-	const related = strapi.plugin('navigation').config('gql')?.navigationItemRelated;
+module.exports = ({ strapi, nexus, config }) => {
+	const related = config.gql?.navigationItemRelated;
 	const name = "NavigationRelated";
 
 	if (related?.length) {

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

@@ -26,7 +26,7 @@ describe('Navigation services', () => {
   describe('Render navigation', () => {
     it('Can render branch in flat format', async () => {
       const service = strapi.plugin('navigation').service('navigation');
-      const result = await service.render(1);
+      const result = await service.render({ idOrSlug: 1 });
 
       expect(result).toBeDefined()
       expect(result.length).toBe(2)
@@ -34,7 +34,10 @@ describe('Navigation services', () => {
 
     it('Can render branch in tree format', async () => {
       const service = strapi.plugin('navigation').service('navigation');
-      const result = await service.render(1, "TREE");
+      const result = await service.render({
+        idOrSlug: 1,
+        type: "TREE"
+      });
 
       expect(result).toBeDefined()
       expect(result.length).toBeGreaterThan(0)
@@ -42,7 +45,10 @@ describe('Navigation services', () => {
 
     it('Can render branch in rfr format', async () => {
       const service = strapi.plugin('navigation').service('navigation');
-      const result = await service.render(1, "RFR");
+      const result = await service.render({
+        idOrSlug: 1,
+        type: "RFR"
+      });
 
       expect(result).toBeDefined()
       expect(result.length).toBeGreaterThan(0)
@@ -50,11 +56,27 @@ describe('Navigation services', () => {
 
     it('Can render only menu attached elements', async () => {
       const service = strapi.plugin('navigation').service('navigation');
-      const result = await service.render(1, "FLAT", true);
+      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', () => {

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,12 +65,19 @@ module.exports = ({ strapi }) => {
       };
     },
 
+    async restart() {
+      setImmediate(() => strapi.reload());
+    },
+
     // Get plugin config
-    async config() {
-      const { pluginName, audienceModel, service } = 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 = {
@@ -81,6 +88,7 @@ module.exports = ({ strapi }) => {
         },
         allowedLevels,
         additionalFields,
+        isGQLPluginEnabled: viaSettingsPage ? isGQLPluginEnabled : undefined,
       };
 
       if (additionalFields.includes(configAdditionalFields.AUDIENCE)) {
@@ -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,8 @@ const {
   find,
   isString,
   get,
+  isNil,
+  isArray
 } = require('lodash');
 
 const { type: itemType } = require('../../content-types/navigation-item/lifecycle');
@@ -52,6 +54,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,
   };
 };