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

package/server/services/common.js

@@ -0,0 +1,313 @@
+"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 pluralize_1 = __importDefault(require("pluralize"));
+const utils_1 = require("@strapi/utils");
+const config_1 = require("../config");
+const i18n_1 = require("../i18n");
+const utils_2 = require("../utils");
+const commonService = ({ strapi }) => ({
+    analyzeBranch(items = [], masterEntity = null, parentItem = null, prevOperations = {}) {
+        const commonService = (0, utils_2.getPluginService)('common');
+        const { toCreate, toRemove, toUpdate } = items
+            .reduce((acc, _) => {
+            const branchName = commonService.getBranchName(_);
+            if (branchName) {
+                return { ...acc, [branchName]: [...acc[branchName], _] };
+            }
+            return acc;
+        }, { toRemove: [], toCreate: [], toUpdate: [] });
+        const operations = {
+            create: prevOperations.create || !!toCreate.length,
+            update: prevOperations.update || !!toUpdate.length,
+            remove: prevOperations.remove || !!toRemove.length,
+        };
+        return (0, utils_2.checkDuplicatePath)(parentItem || masterEntity, toCreate.concat(toUpdate))
+            .then(() => Promise.all([
+            commonService.createBranch(toCreate, masterEntity, parentItem, operations),
+            commonService.removeBranch(toRemove, operations),
+            commonService.updateBranch(toUpdate, masterEntity, parentItem, operations),
+        ]));
+    },
+    async configContentTypes(viaSettingsPage = false) {
+        const commonService = (0, utils_2.getPluginService)('common');
+        const pluginStore = await commonService.getPluginStore();
+        const config = await pluginStore.get({ key: 'config' });
+        const eligibleContentTypes = await Promise.all(config.contentTypes
+            .filter(contentType => !!strapi.contentTypes[contentType] && (0, utils_2.isContentTypeEligible)(contentType))
+            .map(async (key) => {
+            const item = strapi.contentTypes[key];
+            const { kind, options, uid } = item;
+            const { draftAndPublish } = options;
+            const isSingleType = kind === utils_2.KIND_TYPES.SINGLE;
+            const isSingleTypeWithPublishFlow = isSingleType && draftAndPublish;
+            const returnType = (available) => ({
+                key,
+                available,
+            });
+            if (isSingleType) {
+                if (isSingleTypeWithPublishFlow) {
+                    const itemsCountOrBypass = isSingleTypeWithPublishFlow ?
+                        await strapi.query(uid).count({
+                            where: {
+                                published_at: { $notNull: true },
+                            },
+                        }) :
+                        true;
+                    return returnType(itemsCountOrBypass !== 0);
+                }
+                const isAvailable = await strapi.query(uid).count({});
+                return isAvailable === 1 ?
+                    returnType(true) :
+                    (viaSettingsPage ? returnType(false) : undefined);
+            }
+            return returnType(true);
+        }));
+        return eligibleContentTypes
+            .filter(key => key)
+            .map((value) => {
+            if (value === undefined)
+                return;
+            const { key, available } = value;
+            const item = strapi.contentTypes[key];
+            const relatedField = (item.associations || []).find((_) => _.model === 'navigationitem');
+            const { uid, options, info, collectionName, modelName, apiName, plugin, kind, pluginOptions } = item;
+            const { visible = true } = pluginOptions['content-manager'] || {};
+            const { name, description } = info;
+            const { hidden, templateName, draftAndPublish } = options;
+            const findRouteConfig = (0, lodash_1.find)((0, lodash_1.get)(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));
+            return {
+                uid,
+                name: relationName,
+                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,
+                plugin,
+                available: available && !hidden,
+                visible,
+                templateName,
+            };
+        })
+            .filter((item) => viaSettingsPage || (item && item.available));
+    },
+    async createBranch(items, masterEntity, parentItem, operations) {
+        const commonService = (0, utils_2.getPluginService)('common');
+        const { itemModel } = (0, utils_2.extractMeta)(strapi.plugins);
+        return await Promise.all(items.map(async (item) => {
+            operations.create = true;
+            const { parent, master, related, ...params } = item;
+            const relatedItems = await this.getIdsRelated(related, master);
+            const data = {
+                ...params,
+                related: relatedItems,
+                master: masterEntity,
+                parent: parentItem ? { ...parentItem, _id: parentItem.id } : null,
+            };
+            const navigationItem = await strapi
+                .query(itemModel.uid)
+                .create({ data, populate: ['related'] });
+            return !(0, lodash_1.isEmpty)(item.items)
+                ? commonService.createBranch(item.items, masterEntity, navigationItem, operations)
+                : operations;
+        }));
+    },
+    getBranchName(item) {
+        const hasId = !(0, lodash_1.isNil)(item.id);
+        const toRemove = item.removed;
+        if (hasId && !toRemove) {
+            return 'toUpdate';
+        }
+        if (hasId && toRemove) {
+            return 'toRemove';
+        }
+        if (!hasId && !toRemove) {
+            return 'toCreate';
+        }
+    },
+    async getContentTypeItems(uid, query) {
+        const commonService = (0, utils_2.getPluginService)('common');
+        const pluginStore = await commonService.getPluginStore();
+        const config = await pluginStore.get({ key: 'config' });
+        const where = await (0, i18n_1.addI18nWhereClause)({
+            strapi,
+            previousWhere: {},
+            query,
+            modelUid: uid,
+        });
+        try {
+            const contentTypeItems = await strapi.query(uid).findMany({
+                populate: config.contentTypesPopulate[uid] || [],
+                where,
+            });
+            return contentTypeItems;
+        }
+        catch (err) {
+            return [];
+        }
+    },
+    async getIdsRelated(relatedItems, master) {
+        if (relatedItems) {
+            return (await Promise.all(relatedItems.map(async (relatedItem) => {
+                try {
+                    const model = strapi.query("plugin::navigation.navigations-items-related");
+                    const entity = await model.findOne({
+                        where: {
+                            related_id: relatedItem.refId,
+                            related_type: relatedItem.ref,
+                            field: relatedItem.field,
+                            master,
+                        },
+                    });
+                    if (!entity) {
+                        const newEntity = {
+                            master,
+                            order: 1,
+                            field: relatedItem.field,
+                            related_id: relatedItem.refId,
+                            related_type: relatedItem.ref,
+                        };
+                        return model.create({ data: newEntity }).then(({ id }) => id);
+                    }
+                    return entity.id;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }))).reduce((acc, id) => (id ? acc.concat([id]) : acc), []);
+        }
+    },
+    async getPluginStore() {
+        return await strapi.store({ type: 'plugin', name: 'navigation' });
+    },
+    async getRelatedItems(entityItems) {
+        const commonService = (0, utils_2.getPluginService)('common');
+        const pluginStore = await commonService.getPluginStore();
+        const config = await pluginStore.get({ key: 'config' });
+        const relatedTypes = new Set(entityItems.flatMap((item) => (0, lodash_1.get)(item.related, 'related_type', '')));
+        const groupedItems = Array.from(relatedTypes).filter((relatedType) => relatedType).reduce((acc, relatedType) => Object.assign(acc, {
+            [relatedType]: [
+                ...(acc[relatedType] || []),
+                ...entityItems
+                    .filter((item => (0, lodash_1.get)(item.related, 'related_type') === relatedType))
+                    .flatMap((item) => Object.assign(item.related, { navigationItemId: item.id })),
+            ],
+        }), {});
+        const data = new Map((await Promise.all(Object.entries(groupedItems)
+            .map(async ([model, related]) => {
+            const relationData = await strapi
+                .query(model)
+                .findMany({
+                where: {
+                    id: { $in: (0, lodash_1.map)(related, 'related_id') },
+                },
+                populate: config.contentTypesPopulate[model] || []
+            });
+            return relationData
+                .flatMap(_ => Object.assign(_, {
+                __contentType: model,
+                navigationItemId: related.find(({ related_id }) => related_id === _.id.toString())?.navigationItemId,
+            }));
+        })))
+            .flat(1)
+            .map(_ => [_.navigationItemId, _]));
+        return entityItems
+            .map(({ related, ...item }) => {
+            const relatedData = data.get(item.id);
+            if (relatedData) {
+                return Object.assign(item, { related: relatedData });
+            }
+            return { ...item, related: null };
+        });
+    },
+    removeBranch(items = [], operations = {}) {
+        const commonService = (0, utils_2.getPluginService)('common');
+        const { itemModel } = (0, utils_2.extractMeta)(strapi.plugins);
+        return Promise.all(items
+            .filter(item => item.id)
+            .map(async (item) => {
+            operations.remove = true;
+            const { id, related, master } = item;
+            await Promise.all([
+                strapi
+                    .query(itemModel.uid)
+                    .delete({ where: { id } }),
+                this.removeRelated(related, master),
+            ]);
+            return !(0, lodash_1.isEmpty)(item.items)
+                ? commonService.removeBranch(item.items, operations)
+                : operations;
+        }));
+    },
+    removeRelated(relatedItems, master) {
+        return Promise.all((relatedItems || []).map(relatedItem => {
+            const model = strapi.query('plugin::navigation.navigations-items-related');
+            const entityToRemove = {
+                master,
+                field: relatedItem.field,
+                related_id: relatedItem.refId,
+                related_type: relatedItem.ref,
+            };
+            return model.delete({ where: entityToRemove });
+        }));
+    },
+    setDefaultConfig() {
+        return (0, config_1.configSetupStrategy)({ strapi });
+    },
+    async updateBranch(toUpdate, masterEntity, parentItem, operations) {
+        const commonService = (0, utils_2.getPluginService)('common');
+        const { itemModel } = (0, utils_2.extractMeta)(strapi.plugins);
+        const databaseModel = strapi.query(itemModel.uid);
+        return Promise.all(toUpdate.map(async (item) => {
+            operations.update = true;
+            const { id, updated, parent, master, related, items, ...params } = item;
+            let currentItem;
+            if (updated) {
+                const relatedItems = await this.getIdsRelated(related, master);
+                currentItem = await databaseModel
+                    .update({
+                    where: { id },
+                    data: {
+                        ...params,
+                        related: relatedItems,
+                        master: masterEntity,
+                        parent: parentItem ? { ...parentItem, _id: parentItem.id } : null,
+                    },
+                });
+            }
+            else {
+                currentItem = item;
+            }
+            return !(0, lodash_1.isEmpty)(items)
+                ? commonService.analyzeBranch(items, masterEntity, currentItem, operations)
+                : operations;
+        }));
+    },
+    async emitEvent(uid, event, entity) {
+        const model = strapi.getModel(uid);
+        const sanitizedEntity = await utils_1.sanitize.sanitizers.defaultSanitizeOutput(model, entity);
+        strapi.webhookRunner.eventHub.emit(event, {
+            model: model.modelName,
+            entry: sanitizedEntity,
+        });
+    }
+});
+exports.default = commonService;
+//# sourceMappingURL=common.js.map

package/server/services/index.d.ts

@@ -0,0 +1,7 @@
+declare const navigationService: {
+    common: (context: import("strapi-typed").StrapiContext) => import("../../types").ICommonService;
+    admin: (context: import("strapi-typed").StrapiContext) => import("../../types").IAdminService;
+    client: (context: import("strapi-typed").StrapiContext) => import("../../types").IClientService;
+};
+export default navigationService;
+//# sourceMappingURL=index.d.ts.map

package/server/services/index.js

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

package/server/utils/constant.d.ts

@@ -0,0 +1,27 @@
+export declare const TEMPLATE_DEFAULT: "Generic";
+export declare const MODEL_TYPES: {
+    readonly CONTENT_TYPE: "contentType";
+};
+export declare const KIND_TYPES: {
+    readonly SINGLE: "singleType";
+    readonly COLLECTION: "collectionType";
+};
+export declare const ALLOWED_CONTENT_TYPES: readonly ["api::", "plugin::"];
+export declare const RESTRICTED_CONTENT_TYPES: readonly ["plugin::users-permissions", "plugin::i18n.locale", "plugin::navigation"];
+export declare const EXCLUDED_CONTENT_TYPES: string[];
+export declare const CONTENT_TYPES_NAME_FIELDS_DEFAULTS: string[];
+export declare const ADDITIONAL_FIELDS: {
+    AUDIENCE: string;
+};
+export declare const DEFAULT_POPULATE: "localizations"[];
+export declare const DEFAULT_NAVIGATION_ITEM: {
+    readonly name: "Main navigation";
+    readonly slug: "main-navigation";
+    readonly visible: true;
+};
+export declare const RENDER_TYPES: Readonly<{
+    FLAT: "FLAT";
+    TREE: "TREE";
+    RFR: "RFR";
+}>;
+//# sourceMappingURL=constant.d.ts.map

package/server/utils/constant.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RENDER_TYPES = exports.DEFAULT_NAVIGATION_ITEM = exports.DEFAULT_POPULATE = exports.ADDITIONAL_FIELDS = exports.CONTENT_TYPES_NAME_FIELDS_DEFAULTS = exports.EXCLUDED_CONTENT_TYPES = exports.RESTRICTED_CONTENT_TYPES = exports.ALLOWED_CONTENT_TYPES = exports.KIND_TYPES = exports.MODEL_TYPES = exports.TEMPLATE_DEFAULT = void 0;
+const i18n_1 = require("../i18n");
+exports.TEMPLATE_DEFAULT = 'Generic';
+exports.MODEL_TYPES = { CONTENT_TYPE: 'contentType' };
+exports.KIND_TYPES = { SINGLE: 'singleType', COLLECTION: 'collectionType' };
+exports.ALLOWED_CONTENT_TYPES = ['api::', 'plugin::'];
+exports.RESTRICTED_CONTENT_TYPES = ['plugin::users-permissions', 'plugin::i18n.locale', 'plugin::navigation'];
+exports.EXCLUDED_CONTENT_TYPES = ['strapi::'];
+exports.CONTENT_TYPES_NAME_FIELDS_DEFAULTS = ['title', 'subject', 'name'];
+exports.ADDITIONAL_FIELDS = { AUDIENCE: 'audience' };
+exports.DEFAULT_POPULATE = [...i18n_1.I18N_DEFAULT_POPULATE];
+exports.DEFAULT_NAVIGATION_ITEM = {
+    name: "Main navigation",
+    slug: "main-navigation",
+    visible: true,
+};
+exports.RENDER_TYPES = {
+    FLAT: 'FLAT',
+    TREE: 'TREE',
+    RFR: 'RFR'
+};
+//# sourceMappingURL=constant.js.map

package/server/utils/functions.d.ts

@@ -0,0 +1,138 @@
+import { Id, IStrapi, Primitive, StrapiContentType, StrapiPlugin, StringMap } from "strapi-typed";
+import { AuditLogContext, AuditLogParams, ContentTypeEntity, NavigationActions, NavigationItem, NavigationItemEntity, NavigationService, NavigationServiceName, NestedPath, NestedStructure, PluginConfigNameFields, ToBeFixed } from "../../types";
+import { NavigationError } from '../../utils/NavigationError';
+export declare const getPluginService: <T extends NavigationService>(name: NavigationServiceName) => T;
+export declare const errorHandler: (ctx: ToBeFixed) => (error: NavigationError | string) => any;
+export declare const parseParams: <TParams extends StringMap<string> = StringMap<string>, TResult extends StringMap<Primitive> = StringMap<Primitive>>(params: TParams) => TResult;
+export declare const templateNameFactory: (items: import("strapi-typed").TypeResult<{
+    path: string | null;
+    title: string;
+    type: import("../../types").NavigationItemType;
+    collapsed: boolean;
+    menuAttached: boolean;
+    order: number;
+    uiRouterKey: string;
+} & {
+    createdAt: string;
+    updatedAt: string;
+} & {
+    id: number;
+    parent: import("strapi-typed").TypeResult<{
+        path: string | null;
+        title: string;
+        type: import("../../types").NavigationItemType;
+        collapsed: boolean;
+        menuAttached: boolean;
+        order: number;
+        uiRouterKey: string;
+    } & {
+        createdAt: string;
+        updatedAt: string;
+    } & {
+        id: number;
+        parent: import("strapi-typed").TypeResult<{
+            path: string | null;
+            title: string;
+            type: import("../../types").NavigationItemType;
+            collapsed: boolean;
+            menuAttached: boolean;
+            order: number;
+            uiRouterKey: string;
+        } & {
+            createdAt: string;
+            updatedAt: string;
+        } & any> | null;
+        master: import("../../types").Navigation;
+        audience: import("../../types").Audience[];
+        externalPath: string | null;
+        related: import("../../types").NavigationItemRelated | null;
+    }> | null;
+    master: import("../../types").Navigation;
+    audience: import("../../types").Audience[];
+    externalPath: string | null;
+    related: ContentTypeEntity | ContentTypeEntity[] | null;
+}>[] | undefined, strapi: IStrapi, contentTypes?: StrapiContentType<ToBeFixed>[]) => Promise<(contentType: ToBeFixed, id: Id) => any>;
+export declare const getTemplateComponentFromTemplate: (strapi: IStrapi, template?: ToBeFixed[]) => any;
+export declare const prepareAuditLog: (actions: NavigationActions[]) => string;
+export declare const sendAuditLog: (auditLogInstance: AuditLogContext, event: string, data: AuditLogParams) => void;
+export declare const composeItemTitle: (item: NavigationItemEntity<ContentTypeEntity[] | ContentTypeEntity>, fields?: PluginConfigNameFields, contentTypes?: StrapiContentType<ToBeFixed>[]) => string | undefined;
+export declare const extractItemRelationTitle: (relatedItem: ContentTypeEntity, fields?: PluginConfigNameFields, contentTypes?: StrapiContentType<ToBeFixed>[]) => unknown;
+export declare const filterOutUnpublished: (item: NavigationItemEntity<ContentTypeEntity | ContentTypeEntity[]>) => unknown;
+export declare const checkDuplicatePath: (parentItem: ToBeFixed | null, checkData: NavigationItem[]) => Promise<void>;
+export declare const singularize: (value?: string) => string;
+export declare const extractMeta: (plugins: {
+    [uid: string]: StrapiPlugin;
+}) => {
+    masterModel: any;
+    itemModel: any;
+    relatedModel: any;
+    audienceModel: any;
+    plugin: StrapiPlugin;
+    pluginName: string;
+};
+export declare const buildNestedStructure: (entities: NavigationItemEntity<ContentTypeEntity>[], id?: Id | null, field?: keyof NavigationItemEntity) => NestedStructure<NavigationItemEntity<ContentTypeEntity>>[];
+export declare const buildNestedPaths: <T extends Pick<import("strapi-typed").TypeResult<{
+    path: string | null;
+    title: string;
+    type: import("../../types").NavigationItemType;
+    collapsed: boolean;
+    menuAttached: boolean;
+    order: number;
+    uiRouterKey: string;
+} & {
+    createdAt: string;
+    updatedAt: string;
+} & {
+    id: number;
+    parent: import("strapi-typed").TypeResult<{
+        path: string | null;
+        title: string;
+        type: import("../../types").NavigationItemType;
+        collapsed: boolean;
+        menuAttached: boolean;
+        order: number;
+        uiRouterKey: string;
+    } & {
+        createdAt: string;
+        updatedAt: string;
+    } & any> | null;
+    master: import("../../types").Navigation;
+    audience: import("../../types").Audience[];
+    externalPath: string | null;
+    related: import("../../types").NavigationItemRelated | null;
+}>, "id" | "path" | "parent">>(items: T[], id?: Id | null, parentPath?: string | null) => NestedPath[];
+export declare const filterByPath: <T extends Pick<import("strapi-typed").TypeResult<{
+    path: string | null;
+    title: string;
+    type: import("../../types").NavigationItemType;
+    collapsed: boolean;
+    menuAttached: boolean;
+    order: number;
+    uiRouterKey: string;
+} & {
+    createdAt: string;
+    updatedAt: string;
+} & {
+    id: number;
+    parent: import("strapi-typed").TypeResult<{
+        path: string | null;
+        title: string;
+        type: import("../../types").NavigationItemType;
+        collapsed: boolean;
+        menuAttached: boolean;
+        order: number;
+        uiRouterKey: string;
+    } & {
+        createdAt: string;
+        updatedAt: string;
+    } & any> | null;
+    master: import("../../types").Navigation;
+    audience: import("../../types").Audience[];
+    externalPath: string | null;
+    related: import("../../types").NavigationItemRelated | null;
+}>, "id" | "path" | "parent">>(items: T[], path: string | null) => {
+    root?: NestedPath | undefined;
+    items: T[];
+};
+export declare const isContentTypeEligible: (uid?: string) => boolean | "";
+//# sourceMappingURL=functions.d.ts.map