strapi-plugin-navigation 2.0.11 → 2.1.0-beta.1

package/server/routes/admin.js

@@ -1,61 +1,72 @@
-module.exports = {
-  type: 'admin',
-  routes: [
-    {
-      method: 'GET',
-      path: '/',
-      handler: 'navigation.get',
-    },
-    {
-      method: 'POST',
-      path: '/',
-      handler: 'navigation.post',
-    },
-    {
-      method: 'GET',
-      path: '/config',
-      handler: 'navigation.config',
-    },
-    {
-      method: 'PUT',
-      path: '/config',
-      handler: 'navigation.updateConfig',
-    },
-    {
-      method: 'DELETE',
-      path: '/config',
-      handler: 'navigation.restoreConfig',
-    },
-    {
-      method: 'GET',
-      path: '/:id',
-      handler: 'navigation.getById',
-    },
-    {
-      method: 'PUT',
-      path: '/:id',
-      handler: 'navigation.put',
-    },
-    {
-      method: 'GET',
-      path: '/content-type-items/:model',
-      handler: 'navigation.getContentTypeItems',
-      policies: [
-        'admin::isAuthenticatedAdmin'
-      ]
-    },
-    {
-      method: 'GET',
-      path: '/settings/config',
-      handler: 'navigation.settingsConfig',
-    },
-    {
-      method: 'GET',
-      path: '/settings/restart',
-      handler: 'navigation.settingsRestart',
-      config: {
-        policies: [],
-      },
-    },
-  ]
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const routes = {
+    type: 'admin',
+    routes: [
+        {
+            method: 'GET',
+            path: '/',
+            handler: 'admin.get',
+        },
+        {
+            method: 'POST',
+            path: '/',
+            handler: 'admin.post',
+        },
+        {
+            method: 'GET',
+            path: '/config',
+            handler: 'admin.config',
+        },
+        {
+            method: 'PUT',
+            path: '/config',
+            handler: 'admin.updateConfig',
+        },
+        {
+            method: 'DELETE',
+            path: '/config',
+            handler: 'admin.restoreConfig',
+        },
+        {
+            method: 'GET',
+            path: '/:id',
+            handler: 'admin.getById',
+        },
+        {
+            method: 'PUT',
+            path: '/:id',
+            handler: 'admin.put',
+        },
+        {
+            method: 'GET',
+            path: '/content-type-items/:model',
+            handler: 'admin.getContentTypeItems',
+            config: {
+                policies: [
+                    'admin::isAuthenticatedAdmin'
+                ]
+            }
+        },
+        {
+            method: 'GET',
+            path: '/settings/config',
+            handler: 'admin.settingsConfig',
+        },
+        {
+            method: 'GET',
+            path: '/settings/restart',
+            handler: 'admin.settingsRestart',
+            config: {
+                policies: [],
+            },
+        },
+        {
+            method: 'PUT',
+            path: '/i18n/copy/:source/:target',
+            handler: 'admin.fillFromOtherLocale',
+        },
+    ]
+};
+exports.default = routes;
+//# sourceMappingURL=admin.js.map

package/server/routes/client.d.ts

@@ -0,0 +1,4 @@
+import { StrapiRoutes } from "../../types";
+declare const routes: StrapiRoutes;
+export default routes;
+//# sourceMappingURL=client.d.ts.map

package/server/routes/client.js

@@ -1,21 +1,25 @@
-module.exports = {
-  type: 'content-api',
-  routes: [
-		 {
-      method: "GET",
-      path: "/render/:idOrSlug",
-      handler: "navigation.render",
-      config: {
-        policies: []
-      }
-    },
-    {
-      method: "GET",
-      path: "/render/:idOrSlug/:childUIKey",
-      handler: "navigation.renderChild",
-      config: {
-        policies: []
-      }
-    }
-  ]
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const routes = {
+    type: 'content-api',
+    routes: [
+        {
+            method: "GET",
+            path: "/render/:idOrSlug",
+            handler: "client.render",
+            config: {
+                policies: []
+            }
+        },
+        {
+            method: "GET",
+            path: "/render/:idOrSlug/:childUIKey",
+            handler: "client.renderChild",
+            config: {
+                policies: []
+            }
+        }
+    ]
+};
+exports.default = routes;
+//# sourceMappingURL=client.js.map

package/server/routes/index.d.ts

@@ -0,0 +1,6 @@
+declare const routes: {
+    admin: import("../../types").StrapiRoutes;
+    'content-api': import("../../types").StrapiRoutes;
+};
+export default routes;
+//# sourceMappingURL=index.d.ts.map

package/server/routes/index.js

@@ -1,4 +1,13 @@
-module.exports = {
-	'admin': require('./admin'),
-	'content-api': require('./client'),
-};
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const admin_1 = __importDefault(require("./admin"));
+const client_1 = __importDefault(require("./client"));
+const routes = {
+    admin: admin_1.default,
+    'content-api': client_1.default,
+};
+exports.default = routes;
+//# sourceMappingURL=index.js.map

package/server/services/admin.d.ts

@@ -0,0 +1,5 @@
+import { StrapiContext } from "strapi-typed";
+import { IAdminService } from "../../types";
+declare const adminService: (context: StrapiContext) => IAdminService;
+export default adminService;
+//# sourceMappingURL=admin.d.ts.map

package/server/services/admin.js

@@ -0,0 +1,183 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const slugify_1 = __importDefault(require("slugify"));
+const lodash_1 = require("lodash");
+const utils_1 = require("../utils");
+const i18n_1 = require("../i18n");
+const NavigationError_1 = require("../../utils/NavigationError");
+const adminService = ({ strapi }) => ({
+    async config(viaSettingsPage = false) {
+        const commonService = (0, utils_1.getPluginService)('common');
+        const { audienceModel } = (0, utils_1.extractMeta)(strapi.plugins);
+        const pluginStore = await commonService.getPluginStore();
+        const config = await pluginStore.get({ key: 'config' });
+        const additionalFields = config.additionalFields;
+        const contentTypesNameFields = config.contentTypesNameFields;
+        const contentTypesPopulate = config.contentTypesPopulate;
+        const allowedLevels = config.allowedLevels;
+        const isGQLPluginEnabled = !(0, lodash_1.isNil)(strapi.plugin('graphql'));
+        let extendedResult = {
+            allowedContentTypes: utils_1.ALLOWED_CONTENT_TYPES,
+            restrictedContentTypes: utils_1.RESTRICTED_CONTENT_TYPES,
+        };
+        const configContentTypes = await commonService.configContentTypes();
+        const result = {
+            contentTypes: await commonService.configContentTypes(viaSettingsPage),
+            contentTypesNameFields: {
+                default: utils_1.CONTENT_TYPES_NAME_FIELDS_DEFAULTS,
+                ...((0, lodash_1.isObject)(contentTypesNameFields) ? contentTypesNameFields : {}),
+            },
+            contentTypesPopulate: {
+                ...((0, lodash_1.isObject)(contentTypesPopulate) ? contentTypesPopulate : {}),
+            },
+            allowedLevels,
+            additionalFields,
+            gql: {
+                navigationItemRelated: configContentTypes.map(({ labelSingular }) => labelSingular.replace(/\s+/g, ''))
+            },
+            isGQLPluginEnabled: viaSettingsPage ? isGQLPluginEnabled : undefined,
+        };
+        const i18nConfig = await (0, i18n_1.addI18NConfigFields)({ strapi, viaSettingsPage, previousConfig: {} });
+        if (additionalFields.includes(utils_1.ADDITIONAL_FIELDS.AUDIENCE)) {
+            const audienceItems = await strapi
+                .query(audienceModel.uid)
+                .findMany({
+                limit: Number.MAX_SAFE_INTEGER,
+            });
+            extendedResult = {
+                ...extendedResult,
+                availableAudience: audienceItems,
+            };
+        }
+        return {
+            ...result,
+            ...extendedResult,
+            ...i18nConfig,
+        };
+    },
+    async get() {
+        const { masterModel } = (0, utils_1.extractMeta)(strapi.plugins);
+        const entities = await strapi
+            .query(masterModel.uid)
+            .findMany({
+            limit: Number.MAX_SAFE_INTEGER,
+            populate: utils_1.DEFAULT_POPULATE,
+        });
+        return entities;
+    },
+    async getById(id) {
+        const commonService = (0, utils_1.getPluginService)('common');
+        const { masterModel, itemModel } = (0, utils_1.extractMeta)(strapi.plugins);
+        const entity = await strapi
+            .query(masterModel.uid)
+            .findOne({ where: { id }, populate: utils_1.DEFAULT_POPULATE });
+        const entityItems = await strapi
+            .query(itemModel.uid)
+            .findMany({
+            where: {
+                master: id,
+            },
+            limit: Number.MAX_SAFE_INTEGER,
+            orderBy: [{ order: 'asc', }],
+            populate: ['related', 'parent', 'audience']
+        });
+        const entities = await commonService.getRelatedItems(entityItems);
+        return {
+            ...entity,
+            items: (0, utils_1.buildNestedStructure)(entities),
+        };
+    },
+    async post(payload, auditLog) {
+        const commonService = (0, utils_1.getPluginService)('common');
+        const adminService = (0, utils_1.getPluginService)('admin');
+        const { masterModel } = (0, utils_1.extractMeta)(strapi.plugins);
+        const { name, visible } = payload;
+        const data = {
+            name,
+            slug: (0, slugify_1.default)(name).toLowerCase(),
+            visible,
+        };
+        const existingEntity = await strapi
+            .query(masterModel.uid)
+            .create({ data });
+        const result = commonService
+            .createBranch(payload.items, existingEntity, null, {})
+            .then(() => adminService.getById(existingEntity.id))
+            .then((newEntity) => {
+            (0, utils_1.sendAuditLog)(auditLog, 'onChangeNavigation', { actionType: 'CREATE', oldEntity: existingEntity, newEntity });
+            return newEntity;
+        });
+        await commonService.emitEvent(masterModel.uid, 'entry.create', existingEntity);
+        return result;
+    },
+    async put(id, payload, auditLog) {
+        const adminService = (0, utils_1.getPluginService)('admin');
+        const commonService = (0, utils_1.getPluginService)('common');
+        const { masterModel } = (0, utils_1.extractMeta)(strapi.plugins);
+        const { name, visible } = payload;
+        const existingEntity = await adminService.getById(id);
+        const entityNameHasChanged = existingEntity.name !== name || existingEntity.visible !== visible;
+        if (entityNameHasChanged) {
+            await strapi.query(masterModel.uid).update({
+                where: { id },
+                data: {
+                    name: entityNameHasChanged ? name : existingEntity.name,
+                    slug: entityNameHasChanged ? (0, slugify_1.default)(name).toLowerCase() : existingEntity.slug,
+                    visible,
+                },
+            });
+        }
+        const result = commonService
+            .analyzeBranch(payload.items, existingEntity)
+            .then((auditLogsOperations) => Promise.all([
+            auditLog ? (0, utils_1.prepareAuditLog)((auditLogsOperations || []).flat(Number.MAX_SAFE_INTEGER)) : [],
+            adminService.getById(existingEntity.id)
+        ]))
+            .then(([actionType, newEntity]) => {
+            (0, utils_1.sendAuditLog)(auditLog, 'onChangeNavigation', { actionType, oldEntity: existingEntity, newEntity });
+            return newEntity;
+        });
+        const navigationEntity = await strapi.query(masterModel.uid).findOne({ where: { id } });
+        await commonService.emitEvent(masterModel.uid, 'entry.update', navigationEntity);
+        return result;
+    },
+    async restart() {
+        setImmediate(() => strapi.reload());
+    },
+    async restoreConfig() {
+        const commonService = (0, utils_1.getPluginService)('common');
+        const pluginStore = await commonService.getPluginStore();
+        await pluginStore.delete({ key: 'config' });
+        await commonService.setDefaultConfig();
+    },
+    async updateConfig(newConfig) {
+        const commonService = (0, utils_1.getPluginService)('common');
+        const pluginStore = await commonService.getPluginStore();
+        await pluginStore.set({ key: 'config', value: newConfig });
+    },
+    async fillFromOtherLocale({ target, source, auditLog }) {
+        const { enabled } = await (0, i18n_1.getI18nStatus)({ strapi });
+        if (!enabled) {
+            throw new NavigationError_1.NavigationError("Not yet implemented.");
+        }
+        const adminService = (0, utils_1.getPluginService)('admin');
+        const commonService = (0, utils_1.getPluginService)('common');
+        const targetEntity = await adminService.getById(target);
+        return await (0, i18n_1.i18nNavigationContentsCopy)({
+            source: await adminService.getById(source),
+            target: targetEntity,
+            service: commonService,
+            strapi,
+        })
+            .then(() => adminService.getById(target))
+            .then((updated) => {
+            (0, utils_1.sendAuditLog)(auditLog, 'onChangeNavigation', { actionType: 'UPDATE', oldEntity: targetEntity, newEntity: updated });
+            return updated;
+        });
+    },
+});
+exports.default = adminService;
+//# sourceMappingURL=admin.js.map

package/server/services/client.d.ts

@@ -0,0 +1,5 @@
+import { StrapiContext } from "strapi-typed";
+import { IClientService } from "../../types";
+declare const clientService: (context: StrapiContext) => IClientService;
+export default clientService;
+//# sourceMappingURL=client.d.ts.map

package/server/services/client.js

@@ -0,0 +1,249 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const slugify_1 = __importDefault(require("slugify"));
+const uuid_1 = require("uuid");
+const types_1 = require("../../types");
+const utils_1 = require("../utils");
+const utils_2 = require("@strapi/utils");
+const i18n_1 = require("../i18n");
+const NavigationError_1 = require("../../utils/NavigationError");
+const clientService = ({ strapi }) => ({
+    async render({ idOrSlug, type = utils_1.RENDER_TYPES.FLAT, menuOnly = false, rootPath = null, wrapRelated = false, locale, }) {
+        const clientService = (0, utils_1.getPluginService)('client');
+        const findById = !isNaN((0, lodash_1.toNumber)(idOrSlug)) || (0, uuid_1.validate)(idOrSlug);
+        const criteria = findById ? { id: idOrSlug } : { slug: idOrSlug };
+        const itemCriteria = menuOnly ? { menuAttached: true } : {};
+        return await clientService.renderType({
+            type, criteria, itemCriteria, filter: null, rootPath, wrapRelated, locale,
+        });
+    },
+    async renderChildren({ idOrSlug, childUIKey, type = utils_1.RENDER_TYPES.FLAT, menuOnly = false, wrapRelated = false, locale, }) {
+        const clientService = (0, utils_1.getPluginService)('client');
+        const findById = !isNaN((0, lodash_1.toNumber)(idOrSlug)) || (0, uuid_1.validate)(idOrSlug);
+        const criteria = findById ? { id: idOrSlug } : { slug: idOrSlug };
+        const filter = type === utils_1.RENDER_TYPES.FLAT ? null : childUIKey;
+        const itemCriteria = {
+            ...(menuOnly && { menuAttached: true }),
+            ...(type === utils_1.RENDER_TYPES.FLAT ? { uiRouterKey: childUIKey } : {}),
+        };
+        return clientService.renderType({ type, criteria, itemCriteria, filter, rootPath: null, wrapRelated, locale });
+    },
+    renderRFR(items, parent = null, parentNavItem = null, contentTypes = []) {
+        const clientService = (0, utils_1.getPluginService)('client');
+        let pages = {};
+        let nav = {};
+        let navItems = [];
+        items.forEach(item => {
+            const { items: itemChilds, ...itemProps } = item;
+            const itemNav = clientService.renderRFRNav(itemProps);
+            const itemPage = clientService.renderRFRPage(itemProps, parent);
+            if (item.type === "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 === "INTERNAL");
+                if (!(0, lodash_1.isEmpty)(navLevel))
+                    nav = {
+                        ...nav,
+                        [parent]: navLevel.concat(parentNavItem ? parentNavItem : []),
+                    };
+            }
+            if (!(0, lodash_1.isEmpty)(itemChilds)) {
+                const { nav: nestedNavs } = clientService.renderRFR(itemChilds, itemPage.id, itemNav, contentTypes);
+                const { pages: nestedPages } = clientService.renderRFR((itemChilds).filter(child => child.type === "INTERNAL"), itemPage.id, itemNav, contentTypes);
+                pages = {
+                    ...pages,
+                    ...nestedPages,
+                };
+                nav = {
+                    ...nav,
+                    ...nestedNavs,
+                };
+            }
+        });
+        return {
+            pages,
+            nav,
+        };
+    },
+    renderRFRNav(item) {
+        const { uiRouterKey, title, path, type, audience } = item;
+        const itemCommon = {
+            label: title,
+            type: type,
+            audience,
+        };
+        if (type === "EXTERNAL") {
+            (0, types_1.assertNotEmpty)(path, new NavigationError_1.NavigationError("External navigation item's path is undefined", item));
+            return {
+                ...itemCommon,
+                url: path
+            };
+        }
+        if (type === "INTERNAL") {
+            return {
+                ...itemCommon,
+                page: uiRouterKey,
+            };
+        }
+        throw new NavigationError_1.NavigationError("Unknown item type", item);
+    },
+    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 === "INTERNAL" ? {
+                contentType,
+                id,
+            } : undefined,
+            path,
+            slug,
+            parent,
+            audience,
+            menuAttached,
+        };
+    },
+    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();
+            }
+            if (!!data && typeof data === 'object' && 'id' in data) {
+                return data.id === id;
+            }
+            return (data && data === id);
+        })
+            .filter(utils_1.filterOutUnpublished)
+            .map(item => itemParser({
+            ...item,
+        }, path, field))
+            .sort((x, y) => {
+            if (x.order !== undefined && y.order !== undefined)
+                return x.order - y.order;
+            else
+                return 0;
+        });
+    },
+    async renderType({ type = utils_1.RENDER_TYPES.FLAT, criteria = {}, itemCriteria = {}, filter = null, rootPath = null, wrapRelated = false, locale, }) {
+        const clientService = (0, utils_1.getPluginService)('client');
+        const adminService = (0, utils_1.getPluginService)('admin');
+        const commonService = (0, utils_1.getPluginService)('common');
+        const entityWhereClause = {
+            ...criteria,
+            visible: true,
+        };
+        const { masterModel, itemModel } = (0, utils_1.extractMeta)(strapi.plugins);
+        const entity = await (0, i18n_1.i18nAwareEntityReadHandler)({
+            entity: await strapi
+                .query(masterModel.uid)
+                .findOne({
+                where: entityWhereClause,
+            }),
+            entityUid: masterModel.uid,
+            strapi,
+            whereClause: entityWhereClause,
+            localeCode: locale,
+        });
+        if (entity && entity.id) {
+            const entities = await strapi.query(itemModel.uid).findMany({
+                where: {
+                    master: entity.id,
+                    ...itemCriteria,
+                },
+                limit: Number.MAX_SAFE_INTEGER,
+                orderBy: [{ order: 'asc', }],
+                populate: ['related', 'audience', 'parent'],
+            });
+            if (!entities) {
+                return [];
+            }
+            const items = await commonService.getRelatedItems(entities);
+            const { contentTypes, contentTypesNameFields } = await adminService.config(false);
+            const wrapContentType = (itemContentType) => wrapRelated && itemContentType ? {
+                id: itemContentType.id,
+                attributes: { ...itemContentType }
+            } : itemContentType;
+            switch (type) {
+                case utils_1.RENDER_TYPES.TREE:
+                case utils_1.RENDER_TYPES.RFR:
+                    const getTemplateName = await (0, utils_1.templateNameFactory)(items, strapi, contentTypes);
+                    const itemParser = (item, path = '', field) => {
+                        const isExternal = item.type === "EXTERNAL";
+                        const parentPath = isExternal ? undefined : `${path === '/' ? '' : path}/${(0, lodash_1.first)(item.path) === '/'
+                            ? item.path.substring(1)
+                            : item.path}`;
+                        const slug = (0, lodash_1.isString)(parentPath) ? (0, slugify_1.default)(((0, lodash_1.first)(parentPath) === '/' ? parentPath.substring(1) : parentPath).replace(/\//g, '-')) : undefined;
+                        const lastRelated = (0, lodash_1.isArray)(item.related) ? (0, lodash_1.last)(item.related) : item.related;
+                        const relatedContentType = wrapContentType(lastRelated);
+                        return {
+                            id: item.id,
+                            title: (0, utils_1.composeItemTitle)(item, contentTypesNameFields, contentTypes),
+                            menuAttached: item.menuAttached,
+                            order: item.order,
+                            path: isExternal ? item.externalPath : parentPath,
+                            type: item.type,
+                            uiRouterKey: item.uiRouterKey,
+                            slug: !slug && item.uiRouterKey ? (0, slugify_1.default)(item.uiRouterKey) : slug,
+                            external: isExternal,
+                            related: isExternal || !lastRelated ? undefined : {
+                                ...relatedContentType,
+                                __templateName: getTemplateName((lastRelated.relatedType || lastRelated.__contentType), lastRelated.id),
+                            },
+                            audience: !(0, lodash_1.isEmpty)(item.audience) ? item.audience.map(aItem => (aItem).key) : undefined,
+                            items: isExternal ? undefined : clientService.renderTree(items, item.id, field, parentPath, itemParser),
+                        };
+                    };
+                    const { items: itemsFilteredByPath, root: rootElement, } = (0, utils_1.filterByPath)(items, rootPath);
+                    const treeStructure = clientService.renderTree((0, lodash_1.isNil)(rootPath) ? items : itemsFilteredByPath, (0, lodash_1.get)(rootElement, 'parent.id'), 'parent', (0, lodash_1.get)(rootElement, 'parent.path'), itemParser);
+                    const filteredStructure = filter
+                        ? treeStructure.filter((item) => item.uiRouterKey === filter)
+                        : treeStructure;
+                    if (type === utils_1.RENDER_TYPES.RFR) {
+                        return clientService.renderRFR(filteredStructure, null, null, contentTypes);
+                    }
+                    return filteredStructure;
+                default:
+                    const publishedItems = items.filter(utils_1.filterOutUnpublished);
+                    const result = (0, lodash_1.isNil)(rootPath) ? items : (0, utils_1.filterByPath)(publishedItems, rootPath).items;
+                    return result.map((item) => ({
+                        ...item,
+                        audience: item.audience?.map(_ => (_).key),
+                        title: (0, utils_1.composeItemTitle)(item, contentTypesNameFields, contentTypes) || '',
+                        related: wrapContentType(item.related),
+                        items: null,
+                    }));
+            }
+        }
+        throw new utils_2.errors.NotFoundError();
+    },
+});
+exports.default = clientService;
+//# sourceMappingURL=client.js.map

package/server/services/common.d.ts

@@ -0,0 +1,5 @@
+import { StrapiContext } from "strapi-typed";
+import { ICommonService } from "../../types";
+declare const commonService: (context: StrapiContext) => ICommonService;
+export default commonService;
+//# sourceMappingURL=common.d.ts.map