strapi-plugin-navigation 2.5.3 → 3.0.0-beta.0

package/server/services/client/client.js

@@ -0,0 +1,397 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@strapi/utils");
+const lodash_1 = require("lodash");
+const app_errors_1 = require("../../app-errors");
+const repositories_1 = require("../../repositories");
+const utils_2 = require("../../utils");
+const utils_3 = require("./utils");
+const clientService = (context) => ({
+    async readAll({ locale, orderBy = 'createdAt', orderDirection = 'DESC' }) {
+        const repository = (0, repositories_1.getNavigationRepository)(context);
+        const navigations = repository.find({
+            where: locale
+                ? {
+                    localeCode: locale,
+                }
+                : {},
+            orderBy: { [orderBy]: orderDirection },
+        });
+        return navigations;
+    },
+    renderRFRNavigationItem({ item }) {
+        const { uiRouterKey, title, path, type, audience } = item;
+        const itemCommon = {
+            label: title,
+            type: type,
+            audience: audience?.map(({ key }) => key),
+        };
+        if (type === 'EXTERNAL') {
+            (0, utils_2.assertNotEmpty)(path, new app_errors_1.NavigationError("External navigation item's path is undefined", item));
+            return {
+                ...itemCommon,
+                url: path,
+            };
+        }
+        if (type === 'INTERNAL') {
+            return {
+                ...itemCommon,
+                page: uiRouterKey,
+            };
+        }
+        if (type === 'WRAPPER') {
+            return {
+                ...itemCommon,
+            };
+        }
+        throw new app_errors_1.NavigationError('Unknown item type', item);
+    },
+    renderRFRPage({ item, parent, enabledCustomFieldsNames }) {
+        const { uiRouterKey, title, path, related, type, audience, menuAttached } = item;
+        return {
+            id: uiRouterKey,
+            title,
+            related: type === 'INTERNAL' && related?.id && related?.uid
+                ? {
+                    contentType: related.uid,
+                    id: related.id,
+                }
+                : undefined,
+            path,
+            parent,
+            audience,
+            menuAttached,
+            ...enabledCustomFieldsNames.reduce((acc, field) => ({ ...acc, [field]: (0, lodash_1.get)(item, field) }), {}),
+        };
+    },
+    renderRFR({ items, parent, parentNavItem, contentTypes = [], enabledCustomFieldsNames, }) {
+        const navItems = [];
+        let nav = {};
+        let pages = {};
+        items.forEach((item) => {
+            const { items: itemChildren, ...restOfItem } = item;
+            const itemNav = this.renderRFRNavigationItem({
+                item: restOfItem,
+            });
+            const itemPage = this.renderRFRPage({
+                item: restOfItem,
+                parent,
+                enabledCustomFieldsNames,
+            });
+            if (item.type !== 'EXTERNAL') {
+                pages = {
+                    ...pages,
+                    [itemPage.id]: {
+                        ...itemPage,
+                    },
+                };
+            }
+            if (item.menuAttached) {
+                navItems.push(itemNav);
+            }
+            if (!parent) {
+                nav = {
+                    ...nav,
+                    root: navItems,
+                };
+            }
+            else {
+                const navigationLevel = navItems.filter((navItem) => navItem.type !== 'EXTERNAL');
+                if (!(0, lodash_1.isEmpty)(navigationLevel))
+                    nav = {
+                        ...nav,
+                        [parent]: navigationLevel.concat(parentNavItem ? parentNavItem : []),
+                    };
+            }
+            if (!(0, lodash_1.isEmpty)(itemChildren)) {
+                const { nav: nestedNavs } = this.renderRFR({
+                    items: itemChildren ?? [],
+                    parent: itemPage.id,
+                    parentNavItem: itemNav,
+                    contentTypes,
+                    enabledCustomFieldsNames,
+                });
+                const { pages: nestedPages } = this.renderRFR({
+                    items: itemChildren?.filter((child) => child.type !== 'EXTERNAL') || [],
+                    parent: itemPage.id,
+                    parentNavItem: itemNav,
+                    contentTypes,
+                    enabledCustomFieldsNames,
+                });
+                pages = {
+                    ...pages,
+                    ...nestedPages,
+                };
+                nav = {
+                    ...nav,
+                    ...nestedNavs,
+                };
+            }
+        });
+        return {
+            pages,
+            nav,
+        };
+    },
+    renderTree({ items = [], id, path = '', itemParser = (i) => Promise.resolve(i), }) {
+        return Promise.all(items.reduce((acc, item) => {
+            if (item.parent?.id === id && (0, utils_3.filterOutUnpublished)(item)) {
+                acc.push(itemParser((0, lodash_1.cloneDeep)(item), path));
+            }
+            return acc;
+        }, [])).then((result) => result.sort((x, y) => {
+            if (x.order !== undefined && y.order !== undefined) {
+                return x.order - y.order;
+            }
+            return 0;
+        }));
+    },
+    getCustomFields(additionalFields) {
+        return additionalFields.reduce((acc, field) => {
+            if (field !== 'audience') {
+                acc.push(field);
+            }
+            return acc;
+        }, []);
+    },
+    async templateNameFactory(items = [], contentTypes = []) {
+        const flatRelated = (0, lodash_1.flatten)(items.map((i) => i.related)).filter(Boolean);
+        const relatedMap = flatRelated.reduce((acc, curr) => {
+            const [contentType, id] = [curr?.uid, curr?.id];
+            if ((0, lodash_1.isNil)(curr) || !contentType || !id)
+                return acc;
+            if ((0, lodash_1.isNil)(acc[contentType]))
+                acc[contentType] = [];
+            return { ...acc, [contentType]: [...acc[contentType], id] };
+        }, {});
+        const relatedResponseMap = await Promise.all(Object.entries(relatedMap).map(async ([contentType, ids]) => {
+            (0, utils_2.assertNotEmpty)((0, lodash_1.find)(contentTypes, ({ uid }) => uid === contentType));
+            const repository = (0, repositories_1.getGenericRepository)(context, contentType);
+            const relatedItems = await repository.findManyById(ids, ['template']);
+            return { [contentType]: relatedItems };
+        })).then((res) => {
+            return res.reduce((acc, curr) => ({ ...acc, ...curr }), {});
+        });
+        const singleTypes = new Map(contentTypes
+            .filter((x) => x.isSingle)
+            .map(({ contentTypeName, templateName }) => [
+            contentTypeName,
+            templateName || contentTypeName,
+        ]));
+        const getTemplateComponentFromTemplate = (template = []) => {
+            const componentName = (0, lodash_1.get)((0, lodash_1.first)(template), '__component');
+            return !!componentName ? context.strapi.components[componentName] : null;
+        };
+        return (contentType, id) => {
+            const template = (0, lodash_1.get)(relatedResponseMap[contentType].find((data) => data.id === id), 'template');
+            if (template && template instanceof Array) {
+                const templateComponent = getTemplateComponentFromTemplate(template);
+                return (0, lodash_1.get)(templateComponent, 'options.templateName', utils_2.TEMPLATE_DEFAULT);
+            }
+            if (singleTypes.get(contentType)) {
+                return singleTypes.get(contentType);
+            }
+            return utils_2.TEMPLATE_DEFAULT;
+        };
+    },
+    async renderType({ criteria = {}, filter, itemCriteria = {}, locale, populate, rootPath, type = 'FLAT', wrapRelated, }) {
+        const adminService = (0, utils_2.getPluginService)(context, 'admin');
+        const commonService = (0, utils_2.getPluginService)(context, 'common');
+        const entityWhereClause = {
+            ...criteria,
+            visible: true,
+        };
+        const navigationRepository = (0, repositories_1.getNavigationRepository)(context);
+        const navigationItemRepository = (0, repositories_1.getNavigationItemRepository)(context);
+        let navigation = await navigationRepository.findOne({
+            where: entityWhereClause,
+            populate: true,
+        });
+        if (locale && locale !== navigation.localeCode) {
+            navigation = await navigationRepository.findOne({
+                where: {
+                    documentId: navigation.documentId,
+                    localeCode: locale,
+                },
+                populate: true,
+            });
+        }
+        if (navigation && navigation.id) {
+            const navigationItems = await navigationItemRepository.find({
+                where: {
+                    master: navigation.id,
+                    ...itemCriteria,
+                },
+                limit: Number.MAX_SAFE_INTEGER,
+                order: [{ order: 'asc' }],
+                populate: ['related', 'audience', 'parent'],
+            });
+            const mappedItems = await commonService.mapToNavigationItemDTO({
+                navigationItems,
+                populate,
+                master: navigation,
+            });
+            const { contentTypes, contentTypesNameFields, additionalFields } = await adminService.config({
+                viaSettingsPage: false,
+            });
+            const enabledCustomFieldsNames = this.getCustomFields(additionalFields).reduce((acc, curr) => (curr.enabled ? [...acc, curr.name] : acc), []);
+            const wrapContentType = (itemContentType) => wrapRelated && itemContentType
+                ? {
+                    id: itemContentType.id,
+                    attributes: { ...itemContentType },
+                }
+                : itemContentType;
+            const mediaFields = ['name', 'url', 'mime', 'width', 'height', 'previewUrl'];
+            const customFieldsDefinitions = additionalFields.filter((_) => typeof _ !== 'string');
+            switch (type) {
+                case 'TREE':
+                case 'RFR':
+                    const getTemplateName = await this.templateNameFactory(mappedItems, contentTypes);
+                    const itemParser = async (item, path = '') => {
+                        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 = typeof parentPath === 'string'
+                            ? await commonService.getSlug({
+                                query: ((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);
+                        const customFields = enabledCustomFieldsNames.reduce((acc, field) => {
+                            const mapper = customFieldsDefinitions.find(({ name }) => name === field)?.type === 'media'
+                                ? (_) => (0, lodash_1.pick)(JSON.parse(_), mediaFields)
+                                : (_) => _;
+                            const content = (0, lodash_1.get)(item, `additionalFields.${field}`);
+                            return { ...acc, [field]: content ? mapper(content) : content };
+                        }, {});
+                        return {
+                            id: item.id,
+                            title: (0, utils_3.composeItemTitle)(item, contentTypesNameFields, contentTypes) ?? 'Title missing',
+                            menuAttached: item.menuAttached,
+                            order: item.order,
+                            path: (isExternal ? item.externalPath : parentPath) ?? 'Path is missing',
+                            type: item.type,
+                            uiRouterKey: item.uiRouterKey,
+                            slug: !slug && item.uiRouterKey
+                                ? await commonService.getSlug({ query: item.uiRouterKey })
+                                : slug,
+                            related: isExternal || !lastRelated
+                                ? undefined
+                                : {
+                                    ...relatedContentType,
+                                    __templateName: getTemplateName(lastRelated.relatedType || lastRelated.uid, lastRelated.id),
+                                },
+                            audience: !(0, lodash_1.isEmpty)(item.audience) ? item.audience : undefined,
+                            items: isExternal
+                                ? []
+                                : await this.renderTree({
+                                    itemParser,
+                                    path: parentPath,
+                                    id: item.id,
+                                    items: mappedItems,
+                                }),
+                            collapsed: item.collapsed,
+                            ...customFields,
+                        };
+                    };
+                    const { items: itemsFilteredByPath, root: rootElement } = (0, utils_3.filterByPath)(mappedItems, rootPath);
+                    const treeStructure = (await this.renderTree({
+                        itemParser,
+                        items: (0, lodash_1.isNil)(rootPath) ? mappedItems : itemsFilteredByPath,
+                        path: rootElement?.parent?.path,
+                        id: rootElement?.parent?.id,
+                    }));
+                    const filteredStructure = filter
+                        ? treeStructure.filter((item) => item.uiRouterKey === filter)
+                        : treeStructure;
+                    if (type === 'RFR') {
+                        return this.renderRFR({
+                            items: filteredStructure,
+                            contentTypes: contentTypes.map((_) => _.contentTypeName),
+                            enabledCustomFieldsNames,
+                        });
+                    }
+                    return filteredStructure;
+                default:
+                    const publishedItems = mappedItems.filter(utils_3.filterOutUnpublished);
+                    const result = (0, lodash_1.isNil)(rootPath)
+                        ? mappedItems
+                        : (0, utils_3.filterByPath)(publishedItems, rootPath).items;
+                    const defaultCache = new Map();
+                    const getNestedOrders = (id, cache = defaultCache) => {
+                        const cached = cache.get(id);
+                        if (!(0, lodash_1.isNil)(cached))
+                            return cached;
+                        const item = result.find((item) => item.id === id);
+                        if ((0, lodash_1.isNil)(item))
+                            return [0];
+                        const { order, parent } = item;
+                        const nestedOrders = parent ? getNestedOrders(parent.id, cache).concat(order) : [order];
+                        cache.set(id, nestedOrders);
+                        return nestedOrders;
+                    };
+                    return result
+                        .map(({ additionalFields, ...item }) => {
+                        const customFields = enabledCustomFieldsNames.reduce((acc, field) => {
+                            const mapper = customFieldsDefinitions.find(({ name }) => name === field)?.type === 'media'
+                                ? (_) => (0, lodash_1.pick)(JSON.parse(_.toString()), mediaFields)
+                                : (_) => _;
+                            const content = (0, lodash_1.get)(additionalFields, field);
+                            return {
+                                ...acc,
+                                [field]: content
+                                    ? mapper(typeof content === 'boolean' ? content : content.toString())
+                                    : content,
+                            };
+                        }, {});
+                        return {
+                            ...item,
+                            audience: item.audience?.map((_) => _.key),
+                            title: (0, utils_3.composeItemTitle)({ ...item, additionalFields }, contentTypesNameFields, contentTypes) || '',
+                            related: wrapContentType(item.related),
+                            items: null,
+                            ...customFields,
+                        };
+                    })
+                        .sort((a, b) => (0, utils_3.compareArraysOfNumbers)(getNestedOrders(a.id), getNestedOrders(b.id)));
+            }
+        }
+        throw new utils_1.errors.NotFoundError();
+    },
+    renderChildren({ childUIKey, idOrSlug, locale, menuOnly, type = 'FLAT', wrapRelated, }) {
+        const findById = typeof idOrSlug === 'number';
+        const criteria = findById ? { id: idOrSlug } : { slug: idOrSlug };
+        const filter = type === 'FLAT' ? undefined : childUIKey;
+        const itemCriteria = {
+            ...(menuOnly && { menuAttached: true }),
+            ...(type === 'FLAT' ? { uiRouterKey: childUIKey } : {}),
+        };
+        return this.renderType({
+            type,
+            criteria,
+            itemCriteria,
+            filter,
+            wrapRelated,
+            locale,
+        });
+    },
+    render({ idOrSlug, locale, menuOnly, populate, rootPath, type = 'FLAT', wrapRelated, }) {
+        const findById = typeof idOrSlug === 'number';
+        const criteria = findById ? { id: idOrSlug } : { slug: idOrSlug };
+        const itemCriteria = menuOnly ? { menuAttached: true } : {};
+        return this.renderType({
+            type,
+            criteria,
+            itemCriteria,
+            rootPath,
+            wrapRelated,
+            locale,
+            populate,
+        });
+    },
+});
+exports.default = clientService;

package/server/services/client/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = __importDefault(require("./client"));
+exports.default = client_1.default;

package/{admin/src/pages/View/components/NavigationManager → server/services/client}/types.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map

package/server/services/client/utils.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterOutUnpublished = exports.compareArraysOfNumbers = exports.buildNestedPaths = exports.filterByPath = exports.extractItemRelationTitle = exports.composeItemTitle = void 0;
+const lodash_1 = require("lodash");
+const composeItemTitle = (item, fields = {}, contentTypes = []) => {
+    const { title, related } = item;
+    const lastRelated = (0, lodash_1.isArray)(related) ? (0, lodash_1.last)(related) : related;
+    if (title) {
+        return (0, lodash_1.isString)(title) && !(0, lodash_1.isEmpty)(title) ? title : undefined;
+    }
+    else if (lastRelated) {
+        const relationTitle = (0, exports.extractItemRelationTitle)(lastRelated, fields, contentTypes);
+        return (0, lodash_1.isString)(relationTitle) && !(0, lodash_1.isEmpty)(relationTitle) ? relationTitle : undefined;
+    }
+    return undefined;
+};
+exports.composeItemTitle = composeItemTitle;
+const extractItemRelationTitle = (relatedItem, fields = {}, contentTypes = []) => {
+    const { __contentType } = relatedItem;
+    const contentType = (0, lodash_1.find)(contentTypes, (_) => _.contentTypeName === __contentType);
+    const { default: defaultFields = [] } = fields;
+    return ((0, lodash_1.get)(fields, `${contentType ? contentType.collectionName : ''}`, defaultFields)
+        .map((_) => relatedItem[_])
+        .filter((_) => _)[0] || '');
+};
+exports.extractItemRelationTitle = extractItemRelationTitle;
+const filterByPath = (items, path) => {
+    const itemsWithPaths = path
+        ? (0, exports.buildNestedPaths)(items).filter(({ path: itemPath }) => itemPath.includes(path))
+        : [];
+    const root = itemsWithPaths.find(({ path: itemPath }) => itemPath === path);
+    return {
+        root,
+        items: (0, lodash_1.isNil)(root) ? [] : items.filter(({ id }) => itemsWithPaths.find((v) => v.id === id)),
+    };
+};
+exports.filterByPath = filterByPath;
+const buildNestedPaths = (items, id, parentPath = null) => {
+    return items
+        .filter((entity) => {
+        let data = entity.parent;
+        if (!data == null && !id) {
+            return true;
+        }
+        return entity.parent?.id === id;
+    })
+        .reduce((acc, entity) => {
+        const path = `${parentPath || ''}/${entity.path}`.replace('//', '/');
+        return [
+            {
+                id: entity.id,
+                parent: parentPath && entity.parent?.id
+                    ? {
+                        id: entity.parent?.id,
+                        path: parentPath,
+                    }
+                    : undefined,
+                path,
+            },
+            ...(0, exports.buildNestedPaths)(items, entity.id, path),
+            ...acc,
+        ];
+    }, []);
+};
+exports.buildNestedPaths = buildNestedPaths;
+const compareArraysOfNumbers = (arrA, arrB) => {
+    const diff = (0, lodash_1.zipWith)(arrA, arrB, (a, b) => {
+        if ((0, lodash_1.isNil)(a))
+            return -1;
+        if ((0, lodash_1.isNil)(b))
+            return 1;
+        return a - b;
+    });
+    return (0, lodash_1.find)(diff, (a) => a !== 0) || 0;
+};
+exports.compareArraysOfNumbers = compareArraysOfNumbers;
+const filterOutUnpublished = (item) => {
+    const relatedItem = item.related && ((0, lodash_1.isArray)(item.related) ? (0, lodash_1.last)(item.related) : item.related);
+    const isHandledByPublishFlow = relatedItem ? 'publishedAt' in relatedItem : false;
+    if (isHandledByPublishFlow) {
+        const isRelatedDefinedAndPublished = relatedItem
+            ? isHandledByPublishFlow && !!(0, lodash_1.get)(relatedItem, 'publishedAt')
+            : false;
+        return item.type === 'INTERNAL' ? isRelatedDefinedAndPublished : true;
+    }
+    return item.type !== 'INTERNAL' || relatedItem;
+};
+exports.filterOutUnpublished = filterOutUnpublished;