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

package/server/services/admin/admin.js

@@ -0,0 +1,483 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@strapi/utils");
+const lodash_1 = require("lodash");
+const pluralize_1 = __importDefault(require("pluralize"));
+const app_errors_1 = require("../../app-errors");
+const repositories_1 = require("../../repositories");
+const schemas_1 = require("../../schemas");
+const utils_2 = require("../../utils");
+const utils_3 = require("./utils");
+const adminService = (context) => ({
+    async config({ viaSettingsPage = false }) {
+        const commonService = (0, utils_2.getPluginService)(context, 'common');
+        const cacheStatus = await (0, utils_3.getCacheStatus)(context);
+        const pluginStore = await commonService.getPluginStore();
+        const config = await pluginStore
+            .get({
+            key: 'config',
+        })
+            .then(schemas_1.configSchema.parse);
+        const { additionalFields, cascadeMenuAttached, contentTypesPopulate, contentTypesNameFields, pathDefaultFields, allowedLevels, preferCustomContentTypes, } = config;
+        const isGQLPluginEnabled = !!strapi.plugin('graphql');
+        let extendedResult = {
+            allowedContentTypes: utils_2.ALLOWED_CONTENT_TYPES,
+            restrictedContentTypes: utils_2.RESTRICTED_CONTENT_TYPES,
+            availableAudience: [],
+        };
+        const configContentTypes = await this.configContentTypes({});
+        const result = {
+            contentTypes: await this.configContentTypes({ viaSettingsPage }),
+            contentTypesNameFields: {
+                default: utils_2.CONTENT_TYPES_NAME_FIELDS_DEFAULTS,
+                ...((0, lodash_1.isObject)(contentTypesNameFields) ? contentTypesNameFields : {}),
+            },
+            contentTypesPopulate: (0, lodash_1.isObject)(contentTypesPopulate) ? contentTypesPopulate : {},
+            pathDefaultFields: (0, lodash_1.isObject)(pathDefaultFields) ? pathDefaultFields : {},
+            allowedLevels,
+            additionalFields: viaSettingsPage
+                ? additionalFields
+                : additionalFields.filter((field) => typeof field === 'string' || !!field.enabled),
+            gql: {
+                navigationItemRelated: configContentTypes.map(({ labelSingular }) => labelSingular.replace(/\s+/g, '')),
+            },
+            isGQLPluginEnabled: viaSettingsPage ? isGQLPluginEnabled : undefined,
+            cascadeMenuAttached,
+            preferCustomContentTypes,
+        };
+        if (additionalFields.includes('audience')) {
+            const audienceItems = await (0, repositories_1.getAudienceRepository)(context).find({}, Number.MAX_SAFE_INTEGER);
+            extendedResult = {
+                ...extendedResult,
+                availableAudience: audienceItems,
+            };
+        }
+        return {
+            ...result,
+            ...extendedResult,
+            isCacheEnabled: cacheStatus.enabled,
+            isCachePluginEnabled: cacheStatus.hasCachePlugin,
+        };
+    },
+    async configContentTypes({ viaSettingsPage = false, }) {
+        const commonService = (0, utils_2.getPluginService)(context, 'common');
+        const pluginStore = await commonService.getPluginStore();
+        const config = await pluginStore.get({ key: 'config' }).then(schemas_1.configSchema.parse);
+        const eligibleContentTypes = await Promise.all(config.contentTypes
+            .filter((contentType) => !!context.strapi.contentTypes[contentType] && (0, utils_2.isContentTypeEligible)(contentType))
+            .map(async (key) => {
+            const item = schemas_1.contentTypeFullSchema.parse(strapi.contentTypes[key]);
+            const { kind, options, uid } = item;
+            const draftAndPublish = options?.draftAndPublish;
+            const isSingleType = kind === utils_2.KIND_TYPES.SINGLE;
+            const isSingleTypeWithPublishFlow = isSingleType && draftAndPublish;
+            const returnType = (available) => ({
+                key,
+                available,
+            });
+            if (isSingleType) {
+                const repository = (0, repositories_1.getGenericRepository)(context, uid);
+                if (isSingleTypeWithPublishFlow) {
+                    const itemsCountOrBypass = isSingleTypeWithPublishFlow
+                        ? await repository.count({
+                            publishedAt: {
+                                $notNull: true,
+                            },
+                        })
+                        : true;
+                    return returnType(itemsCountOrBypass !== 0);
+                }
+                const isAvailable = await repository.count({});
+                return isAvailable !== 0
+                    ? returnType(true)
+                    : viaSettingsPage
+                        ? returnType(false)
+                        : undefined;
+            }
+            return returnType(true);
+        }));
+        return eligibleContentTypes.reduce((acc, current) => {
+            if (!current?.key) {
+                return acc;
+            }
+            const { key, available } = current;
+            const item = schemas_1.contentTypeFullSchema.parse(context.strapi.contentTypes[key]);
+            const relatedField = (item.associations || []).find(({ model }) => model === 'navigationitem');
+            const { uid, options, info, collectionName, modelName, apiName, plugin, kind, pluginOptions = {}, } = item;
+            const isAvailable = available && !options?.hidden;
+            if (!isAvailable) {
+                return acc;
+            }
+            const { visible = true } = pluginOptions['content-manager'] || {};
+            const { name = '', description = '' } = info;
+            const findRouteConfig = (0, lodash_1.find)((0, lodash_1.get)(context.strapi.api, `[${modelName}].config.routes`, []), (route) => route.handler.includes('.find'));
+            const findRoutePath = findRouteConfig && findRouteConfig.path.split('/')[1];
+            const apiPath = findRoutePath && findRoutePath !== apiName ? findRoutePath : apiName || modelName;
+            const isSingle = kind === utils_2.KIND_TYPES.SINGLE;
+            const endpoint = isSingle ? apiPath : (0, pluralize_1.default)(apiPath);
+            const relationName = (0, utils_2.singularize)(modelName);
+            const relationNameParts = typeof uid === 'string' ? (0, lodash_1.last)(uid.split('.')).split('-') : [];
+            const contentTypeName = relationNameParts.length > 1
+                ? relationNameParts.reduce((prev, curr) => `${prev}${(0, lodash_1.upperFirst)(curr)}`, '')
+                : (0, lodash_1.upperFirst)(modelName);
+            const labelSingular = name ||
+                (0, lodash_1.upperFirst)(relationNameParts.length > 1 ? relationNameParts.join(' ') : relationName);
+            acc.push({
+                uid,
+                name: relationName,
+                draftAndPublish: options?.draftAndPublish,
+                isSingle,
+                description,
+                collectionName,
+                contentTypeName,
+                label: isSingle ? labelSingular : (0, pluralize_1.default)(name || labelSingular),
+                relatedField: relatedField ? relatedField.alias : undefined,
+                labelSingular: (0, utils_2.singularize)(labelSingular),
+                endpoint: endpoint,
+                plugin,
+                available: isAvailable,
+                visible,
+                templateName: options?.templateName,
+            });
+            return acc;
+        }, []);
+    },
+    async get({ ids, localeCode }) {
+        let where = {};
+        if (ids && ids.length) {
+            where.id = { $in: ids };
+        }
+        if (localeCode) {
+            where.localeCode = localeCode;
+        }
+        const dbResults = await (0, repositories_1.getNavigationRepository)(context).find({
+            where,
+            limit: Number.MAX_SAFE_INTEGER,
+            populate: ['items', 'items.parent', 'items.audience'],
+        });
+        const buildItemsStructure = ({ allItems, item, parent, }) => {
+            const children = allItems.filter((child) => child.parent?.id === item.id);
+            return {
+                ...item,
+                parent,
+                items: children
+                    .map((child) => buildItemsStructure({
+                    parent: item,
+                    item: child,
+                    allItems,
+                }))
+                    .sort((a, b) => a.order - b.order),
+            };
+        };
+        return dbResults.map((navigation) => ({
+            ...navigation,
+            items: navigation.items
+                ?.filter((item) => !item.parent)
+                .map((item) => buildItemsStructure({
+                allItems: navigation.items ?? [],
+                item,
+            })),
+        }));
+    },
+    async getById({ id }) {
+        const commonService = (0, utils_2.getPluginService)(context, 'common');
+        const navigation = await (0, repositories_1.getNavigationRepository)(context).findOne({
+            where: { id },
+        });
+        const dbNavigationItems = await (0, repositories_1.getNavigationItemRepository)(context).find({
+            where: { master: navigation.id },
+            limit: Number.MAX_SAFE_INTEGER,
+            order: [{ order: 'asc' }],
+            populate: ['parent', 'audience'],
+        });
+        return {
+            ...navigation,
+            items: commonService
+                .buildNestedStructure({
+                navigationItems: dbNavigationItems,
+            })
+                .filter(({ parent }) => !parent),
+        };
+    },
+    async post({ auditLog, payload }) {
+        const { masterModel } = (0, utils_2.getPluginModels)(context);
+        const commonService = (0, utils_2.getPluginService)(context, 'common');
+        const { defaultLocale, restLocale } = await commonService.readLocale();
+        const repository = (0, repositories_1.getNavigationRepository)(context);
+        const navigationSummary = [];
+        const { name, visible } = payload;
+        const slug = await commonService.getSlug({ query: name });
+        const mainNavigation = await repository.save({
+            name,
+            visible,
+            localeCode: defaultLocale,
+            slug,
+        });
+        navigationSummary.push(await this.getById({ id: mainNavigation.id }));
+        for (const localeCode of restLocale) {
+            const newLocaleNavigation = await repository.save({
+                name,
+                visible,
+                localeCode,
+                slug: `${slug}-${localeCode}`,
+                documentId: mainNavigation.documentId,
+            });
+            navigationSummary.push(await this.getById({ id: newLocaleNavigation.id }));
+        }
+        navigationSummary.map((navigation) => {
+            (0, utils_3.sendAuditLog)(auditLog, 'onChangeNavigation', {
+                actionType: 'CREATE',
+                oldEntity: navigation,
+                newEntity: navigation,
+            });
+        });
+        await commonService.emitEvent({
+            entity: mainNavigation,
+            event: 'entry.create',
+            uid: masterModel.uid,
+        });
+        return {
+            ...mainNavigation,
+            items: [],
+        };
+    },
+    async put({ auditLog, payload }) {
+        const { masterModel } = (0, utils_2.getPluginModels)(context);
+        const commonService = (0, utils_2.getPluginService)(context, 'common');
+        const { defaultLocale } = await commonService.readLocale();
+        const repository = (0, repositories_1.getNavigationRepository)(context);
+        const { name, visible, items } = payload;
+        const currentNavigation = await repository.findOne({
+            where: { id: payload.id },
+            populate: true,
+        });
+        const currentNavigationAsDTO = await this.getById({ id: payload.id });
+        const detailsHaveChanged = currentNavigation.name !== name || currentNavigation.visible !== visible;
+        if (detailsHaveChanged) {
+            const allNavigations = await repository.find({
+                where: { documentId: currentNavigation.documentId },
+            });
+            for (const navigation of allNavigations) {
+                const newSlug = name
+                    ? await commonService.getSlug({
+                        query: `${name}${navigation.localeCode !== defaultLocale ? ` ${navigation.localeCode}` : ''}`,
+                    })
+                    : currentNavigation.slug;
+                await repository.save({
+                    id: navigation.id,
+                    slug: newSlug,
+                    name,
+                    visible,
+                });
+            }
+        }
+        const updatedNavigationAsDTO = await commonService
+            .analyzeBranch({
+            navigationItems: items ?? [],
+            masterEntity: currentNavigation,
+            prevAction: {},
+        })
+            .then(utils_3.prepareAuditLog)
+            .then(async (actionType) => {
+            const newEntity = await this.getById({ id: currentNavigation.id });
+            (0, utils_3.sendAuditLog)(auditLog, 'onChangeNavigation', {
+                actionType,
+                oldEntity: currentNavigationAsDTO,
+                newEntity,
+            });
+            return newEntity;
+        });
+        await commonService.emitEvent({
+            entity: await repository.findOne({ where: { id: payload.id }, populate: true }),
+            event: 'entry.update',
+            uid: masterModel.uid,
+        });
+        return updatedNavigationAsDTO;
+    },
+    async delete({ auditLog, id }) {
+        const navigationRepository = (0, repositories_1.getNavigationRepository)(context);
+        const navigationItemRepository = (0, repositories_1.getNavigationItemRepository)(context);
+        const navigationAsDTO = await this.getById({ id });
+        // TODO: remove when cascade deletion is present
+        // NOTE: Delete many with relation `where` crashes ORM
+        const cleanNavigationItems = async (masterIds) => {
+            if (masterIds.length < 1) {
+                return;
+            }
+            await navigationItemRepository.removeForIds(await navigationItemRepository.findForMasterIds(masterIds).then((_) => _.reduce((acc, { id }) => {
+                if (id) {
+                    acc.push(id);
+                }
+                return acc;
+            }, [])));
+        };
+        const navigation = await navigationRepository.findOne({ where: { id }, populate: true });
+        const allNavigations = await navigationRepository.find({
+            where: { documentId: navigation.documentId },
+            populate: true,
+        });
+        await cleanNavigationItems(allNavigations.map(({ id }) => id));
+        await navigationRepository.remove({ documentId: navigation.documentId });
+        (0, utils_3.sendAuditLog)(auditLog, 'onNavigationDeletion', {
+            entity: navigationAsDTO,
+            actionType: 'DELETE',
+        });
+    },
+    async restart() {
+        setImmediate(() => context.strapi.reload());
+    },
+    async restoreConfig() {
+        const commonService = (0, utils_2.getPluginService)(context, 'common');
+        const pluginStore = await commonService.getPluginStore();
+        await pluginStore.delete({ key: 'config' });
+        await commonService.setDefaultConfig();
+    },
+    async updateConfig({ config: newConfig }) {
+        const commonService = (0, utils_2.getPluginService)(context, 'common');
+        const pluginStore = await commonService.getPluginStore();
+        const config = await pluginStore
+            .get({
+            key: 'config',
+        })
+            .then(schemas_1.configSchema.parse);
+        (0, utils_2.validateAdditionalFields)(newConfig.additionalFields);
+        await pluginStore.set({ key: 'config', value: newConfig });
+        const removedFields = (0, lodash_1.differenceBy)(config.additionalFields, newConfig.additionalFields, 'name').reduce((acc, field) => {
+            if (typeof field === 'string') {
+                return acc;
+            }
+            acc.push(field);
+            return acc;
+        }, []);
+        if (!(0, lodash_1.isEmpty)(removedFields)) {
+            await commonService.pruneCustomFields({ removedFields });
+        }
+    },
+    async fillFromOtherLocale({ auditLog, source, target, }) {
+        const targetEntity = await this.getById({ id: target });
+        return await this.i18nNavigationContentsCopy({
+            source: await this.getById({ id: source }),
+            target: targetEntity,
+        })
+            .then(() => this.getById({ id: target }))
+            .then((newEntity) => {
+            (0, utils_3.sendAuditLog)(auditLog, 'onChangeNavigation', {
+                actionType: 'UPDATE',
+                oldEntity: targetEntity,
+                newEntity,
+            });
+            return newEntity;
+        });
+    },
+    async i18nNavigationContentsCopy({ source, target, }) {
+        const commonService = (0, utils_2.getPluginService)(context, 'common');
+        const sourceItems = source.items ?? [];
+        const navigationRepository = (0, repositories_1.getNavigationRepository)(context);
+        if (target.items?.length) {
+            throw new app_errors_1.FillNavigationError('Current navigation is non-empty');
+        }
+        if (!target.localeCode) {
+            throw new app_errors_1.FillNavigationError('Current navigation does not have specified locale');
+        }
+        if (!sourceItems.length) {
+            throw new app_errors_1.FillNavigationError('Source navigation is empty');
+        }
+        const entities = new Map();
+        const itemProcessor = (0, utils_3.processItems)({
+            master: target,
+            localeCode: target.localeCode,
+            strapi,
+            entities,
+        });
+        await commonService.createBranch({
+            action: { create: true },
+            masterEntity: await navigationRepository.findOne({
+                where: { id: target.id },
+                populate: true,
+            }),
+            navigationItems: await Promise.all(sourceItems.map(itemProcessor)),
+            parentItem: undefined,
+        });
+    },
+    async readNavigationItemFromLocale({ path, source, target, }) {
+        const sourceNavigation = await this.getById({ id: source });
+        const targetNavigation = await this.getById({ id: target });
+        if (!sourceNavigation) {
+            throw new utils_1.errors.NotFoundError('Unable to find source navigation for specified query');
+        }
+        if (!targetNavigation) {
+            throw new utils_1.errors.NotFoundError('Unable to find target navigation for specified query');
+        }
+        const requiredFields = [
+            'path',
+            'related',
+            'type',
+            'uiRouterKey',
+            'title',
+            'externalPath',
+        ];
+        const structurePath = path.split('.').map((p) => parseInt(p, 10));
+        if (!structurePath.some(Number.isNaN) || !structurePath.length) {
+            new app_errors_1.InvalidParamNavigationError('Path is invalid');
+        }
+        let result = (0, lodash_1.get)(sourceNavigation.items, (0, utils_3.intercalate)('items', structurePath.map(lodash_1.toString)));
+        if (!result) {
+            throw new utils_1.errors.NotFoundError('Unable to find navigation item');
+        }
+        return schemas_1.readNavigationItemFromLocaleSchema.parse((0, lodash_1.pick)(result, requiredFields));
+    },
+    async getContentTypeItems({ query, uid }) {
+        const commonService = (0, utils_2.getPluginService)(context, 'common');
+        const pluginStore = await commonService.getPluginStore();
+        const config = await pluginStore.get({ key: 'config' }).then(schemas_1.configSchema.parse);
+        const where = {
+            publishedAt: {
+                $notNull: true,
+            },
+        };
+        if (query.localeCode) {
+            where.locale = query.localeCode;
+        }
+        const repository = (0, repositories_1.getGenericRepository)(context, uid);
+        try {
+            const contentTypeItems = await repository.findMany(where, config.contentTypesPopulate[uid] || []);
+            return contentTypeItems;
+        }
+        catch (err) {
+            return [];
+        }
+    },
+    async purgeNavigationCache(id, clearLocalisations) {
+        const navigationRepository = (0, repositories_1.getNavigationRepository)(context);
+        const entity = await navigationRepository.findOne({ where: { id } });
+        if (!entity) {
+            throw new utils_1.errors.NotFoundError('Navigation is not defined');
+        }
+        const mapToRegExp = (id) => new RegExp(`/api/navigation/render/${id}`);
+        let regexps = [mapToRegExp(entity.id)];
+        if (clearLocalisations) {
+            const navigations = await navigationRepository.find({
+                where: {
+                    documentId: entity.documentId,
+                },
+            });
+            regexps = navigations.map(({ id }) => mapToRegExp(id));
+        }
+        const restCachePlugin = strapi.plugin('rest-cache');
+        const cacheStore = restCachePlugin.service('cacheStore');
+        regexps.push(mapToRegExp(id));
+        await cacheStore.clearByRegexp(regexps);
+        return { success: true };
+    },
+    async purgeNavigationsCache() {
+        const restCachePlugin = strapi.plugin('rest-cache');
+        const cacheStore = restCachePlugin.service('cacheStore');
+        const regex = new RegExp('/api/navigation/render(.*)');
+        await cacheStore.clearByRegexp([regex]);
+        return { success: true };
+    },
+});
+exports.default = adminService;

package/server/{content-types/navigations-items-related → services/admin}/index.js

@@ -3,8 +3,5 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const schema_1 = __importDefault(require("./schema"));
-exports.default = {
-    schema: schema_1.default
-};
-//# sourceMappingURL=index.js.map
+const admin_1 = __importDefault(require("./admin"));
+exports.default = admin_1.default;

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

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

package/server/services/admin/utils.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCacheStatus = exports.intercalate = exports.processItems = exports.prepareAuditLog = exports.sendAuditLog = void 0;
+const repositories_1 = require("../../repositories");
+const schemas_1 = require("../../schemas");
+const utils_1 = require("../../utils");
+const sendAuditLog = (auditLogInstance, event, data) => {
+    if (auditLogInstance && auditLogInstance.emit) {
+        auditLogInstance.emit(event, data);
+    }
+};
+exports.sendAuditLog = sendAuditLog;
+const prepareAuditLog = (actions) => {
+    return [
+        ...new Set(actions
+            .filter((_) => !!_)
+            .flatMap(({ remove, create, update }) => {
+            return [create ? 'CREATE' : '', update ? 'UPDATE' : '', remove ? 'REMOVE' : ''].filter((_) => !!_);
+        })),
+    ].join('_');
+};
+exports.prepareAuditLog = prepareAuditLog;
+const processItems = (context) => async (item) => {
+    const { related } = item;
+    let nextRelated = related;
+    if (related && !context.entities.has(related)) {
+        const [uid, id] = related.split(utils_1.RELATED_ITEM_SEPARATOR);
+        const entity = await (0, repositories_1.getGenericRepository)(context, uid).findById(parseInt(id, 10), true);
+        if (!context.entities.has(related)) {
+            context.entities.set(related, {
+                ...entity,
+                uid,
+            });
+        }
+    }
+    if (related && context.entities.has(related)) {
+        const entity = context.entities.get(related);
+        const localeVersion = await strapi.documents(entity.uid).findOne({
+            documentId: entity.documentId,
+            locale: context.localeCode,
+            status: 'published',
+        });
+        if (localeVersion) {
+            nextRelated = [entity.uid, localeVersion.id].join(utils_1.RELATED_ITEM_SEPARATOR);
+        }
+    }
+    return {
+        title: item.title,
+        path: item.path,
+        audience: item.audience,
+        type: item.type,
+        uiRouterKey: item.uiRouterKey,
+        order: item.order,
+        collapsed: item.collapsed,
+        menuAttached: item.menuAttached,
+        removed: false,
+        updated: true,
+        externalPath: item.externalPath,
+        items: item.items
+            ? await Promise.all(item.items.map((0, exports.processItems)(context)))
+            : [],
+        master: context.master,
+        parent: undefined,
+        related: nextRelated,
+    };
+};
+exports.processItems = processItems;
+const intercalate = (glue, arr) => arr.slice(1).reduce((acc, element) => acc.concat([glue, element]), arr.slice(0, 1));
+exports.intercalate = intercalate;
+const getCacheStatus = async ({ strapi, }) => {
+    const cachePlugin = strapi.plugin('rest-cache');
+    const hasCachePlugin = !!cachePlugin;
+    const pluginStore = strapi.store({
+        type: 'plugin',
+        name: 'navigation',
+    });
+    const config = schemas_1.configSchema.parse(await pluginStore.get({
+        key: 'config',
+    }));
+    return hasCachePlugin
+        ? { hasCachePlugin, enabled: !!config.isCacheEnabled }
+        : { hasCachePlugin, enabled: false };
+};
+exports.getCacheStatus = getCacheStatus;