strapi-plugin-navigation 2.0.13 → 2.1.0

package/server/utils/functions.d.ts

@@ -0,0 +1,139 @@
+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 | "";
+export declare const intercalate: <T, U extends T>(glue: T, arr: U[]) => (T | U)[];
+//# sourceMappingURL=functions.d.ts.map

package/server/utils/functions.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.intercalate = exports.isContentTypeEligible = exports.filterByPath = exports.buildNestedPaths = exports.buildNestedStructure = exports.extractMeta = exports.singularize = exports.checkDuplicatePath = exports.filterOutUnpublished = exports.extractItemRelationTitle = exports.composeItemTitle = exports.sendAuditLog = exports.prepareAuditLog = exports.getTemplateComponentFromTemplate = exports.templateNameFactory = exports.parseParams = exports.errorHandler = exports.getPluginService = void 0;
+const lodash_1 = require("lodash");
+const NavigationError_1 = require("../../utils/NavigationError");
+const constant_1 = require("./constant");
+const getPluginService = (name) => strapi.plugin("navigation").service(name);
+exports.getPluginService = getPluginService;
+const errorHandler = (ctx) => (error) => {
+    if (error instanceof NavigationError_1.NavigationError) {
+        return ctx.badRequest(error.message, error.additionalInfo);
+    }
+    throw error;
+};
+exports.errorHandler = errorHandler;
+const parseParams = (params) => Object.keys(params).reduce((prev, curr) => {
+    const value = params[curr];
+    const parsedValue = isNaN(Number(value)) ? value : parseInt(value, 10);
+    return {
+        ...prev,
+        [curr]: parsedValue,
+    };
+}, {});
+exports.parseParams = parseParams;
+const templateNameFactory = async (items = [], strapi, contentTypes = []) => {
+    const flatRelated = (0, lodash_1.flatten)(items.map(i => i.related)).filter(_ => !!_);
+    const relatedMap = (flatRelated).reduce((acc, curr) => {
+        if (curr === null)
+            return acc;
+        const index = curr.__contentType;
+        if (typeof index !== 'string')
+            return acc;
+        if (!acc[index]) {
+            acc[index] = [];
+        }
+        acc[index].push(curr.id);
+        return acc;
+    }, {});
+    const responses = await Promise.all(Object.entries(relatedMap)
+        .map(([contentType, ids]) => {
+        const contentTypeUid = (0, lodash_1.get)((0, lodash_1.find)(contentTypes, cnt => cnt.uid === contentType), 'uid');
+        return strapi.query(contentTypeUid)
+            .findMany({
+            where: { id: { $in: ids } },
+            limit: Number.MAX_SAFE_INTEGER,
+        })
+            .then(res => ({ [contentType]: res }));
+    }));
+    const relatedResponseMap = responses.reduce((acc, curr) => ({ ...acc, ...curr }), {});
+    const singleTypes = new Map(contentTypes
+        .filter(x => x.isSingle)
+        .map(({ contentTypeName, templateName }) => [contentTypeName, templateName || contentTypeName]));
+    return (contentType, id) => {
+        const template = (0, lodash_1.get)(relatedResponseMap[contentType].find(data => data.id === id), 'template');
+        if (template && template instanceof Array) {
+            const templateComponent = (0, exports.getTemplateComponentFromTemplate)(strapi, template);
+            return (0, lodash_1.get)(templateComponent, 'options.templateName', constant_1.TEMPLATE_DEFAULT);
+        }
+        if (singleTypes.get(contentType)) {
+            return singleTypes.get(contentType);
+        }
+        return constant_1.TEMPLATE_DEFAULT;
+    };
+};
+exports.templateNameFactory = templateNameFactory;
+const getTemplateComponentFromTemplate = (strapi, template = []) => {
+    const componentName = (0, lodash_1.get)((0, lodash_1.first)(template), '__component');
+    return !!componentName ? strapi.components[componentName] : null;
+};
+exports.getTemplateComponentFromTemplate = getTemplateComponentFromTemplate;
+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 sendAuditLog = (auditLogInstance, event, data) => {
+    if (auditLogInstance && auditLogInstance.emit) {
+        auditLogInstance.emit(event, data);
+    }
+};
+exports.sendAuditLog = sendAuditLog;
+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 filterOutUnpublished = (item) => {
+    const relatedItem = item.related && ((0, lodash_1.isArray)(item.related) ? (0, lodash_1.last)(item.related) : item.related);
+    const isHandledByPublishFlow = relatedItem ? 'published_at' in relatedItem : false;
+    if (isHandledByPublishFlow) {
+        const isRelatedDefinedAndPublished = relatedItem ?
+            isHandledByPublishFlow && (0, lodash_1.get)(relatedItem, 'published_at') :
+            false;
+        return item.type === "INTERNAL" ? isRelatedDefinedAndPublished : true;
+    }
+    return (item.type !== "INTERNAL") || relatedItem;
+};
+exports.filterOutUnpublished = filterOutUnpublished;
+const checkDuplicatePath = (parentItem, checkData) => {
+    return new Promise((resolve, reject) => {
+        if (parentItem && parentItem.items) {
+            for (let item of checkData) {
+                for (let _ of parentItem.items) {
+                    if (_.path === item.path && (_.id !== item.id) && (item.type === "INTERNAL")) {
+                        return reject(new NavigationError_1.NavigationError(`Duplicate path:${item.path} in parent: ${parentItem.title || 'root'} for ${item.title} and ${_.title} items`, {
+                            parentTitle: parentItem.title,
+                            parentId: parentItem.id,
+                            path: item.path,
+                            errorTitles: [item.title, _.title],
+                        }));
+                    }
+                }
+            }
+        }
+        return resolve();
+    });
+};
+exports.checkDuplicatePath = checkDuplicatePath;
+const singularize = (value = '') => {
+    return (0, lodash_1.last)(value) === 's' ? value.substr(0, value.length - 1) : value;
+};
+exports.singularize = singularize;
+const extractMeta = (plugins) => {
+    const { navigation: plugin } = plugins;
+    return {
+        masterModel: plugin.contentType('navigation'),
+        itemModel: plugin.contentType('navigation-item'),
+        relatedModel: plugin.contentType('navigations-items-related'),
+        audienceModel: plugin.contentType('audience'),
+        plugin,
+        pluginName: 'navigation',
+    };
+};
+exports.extractMeta = extractMeta;
+const buildNestedStructure = (entities, id = null, field = 'parent') => {
+    return entities
+        .filter(entity => {
+        let data = entity[field];
+        if (data == null && id === null) {
+            return true;
+        }
+        if (data && typeof id === 'string') {
+            data = data.toString();
+        }
+        if (!!data && typeof data === 'object' && 'id' in data) {
+            return (data).id === id;
+        }
+        return (data && data === id);
+    })
+        .map(entity => {
+        return ({
+            ...entity,
+            related: entity.related,
+            items: (0, exports.buildNestedStructure)(entities, entity.id, field),
+        });
+    });
+};
+exports.buildNestedStructure = buildNestedStructure;
+const buildNestedPaths = (items, id = null, parentPath = null) => {
+    return items
+        .filter(entity => {
+        let data = entity.parent;
+        if (data == null && id === null) {
+            return true;
+        }
+        if (data && typeof id === 'string') {
+            data = data.toString();
+        }
+        return (data && data === id) || ((0, lodash_1.isObject)(entity.parent) && ((entity.parent).id === id));
+    })
+        .reduce((acc, entity) => {
+        const path = `${parentPath || ''}/${entity.path}`;
+        return [
+            {
+                id: entity.id,
+                parent: parentPath ? {
+                    id: (0, lodash_1.get)(entity, 'parent.id'),
+                    path: parentPath,
+                } : undefined,
+                path,
+            },
+            ...(0, exports.buildNestedPaths)(items, entity.id, path),
+            ...acc,
+        ];
+    }, []);
+};
+exports.buildNestedPaths = buildNestedPaths;
+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 isContentTypeEligible = (uid = '') => {
+    const isOneOfAllowedType = constant_1.ALLOWED_CONTENT_TYPES.filter(_ => uid.includes(_)).length > 0;
+    const isNoneOfRestricted = constant_1.RESTRICTED_CONTENT_TYPES.filter(_ => uid.includes(_) || (uid === _)).length === 0;
+    return uid && isOneOfAllowedType && isNoneOfRestricted;
+};
+exports.isContentTypeEligible = isContentTypeEligible;
+const intercalate = (glue, arr) => arr.slice(1).reduce((acc, element) => acc.concat([glue, element]), arr.slice(0, 1));
+exports.intercalate = intercalate;
+//# sourceMappingURL=functions.js.map

package/server/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './functions';
+export * from './constant';
+//# sourceMappingURL=index.d.ts.map

package/server/utils/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./functions"), exports);
+__exportStar(require("./constant"), exports);
+//# sourceMappingURL=index.js.map

package/strapi-admin.d.ts

@@ -0,0 +1,3 @@
+import admin from './admin/src';
+export default admin;
+//# sourceMappingURL=strapi-admin.d.ts.map

package/strapi-admin.js

@@ -1 +1,8 @@
-module.exports = require('./admin/src').default;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = __importDefault(require("./admin/src"));
+exports.default = src_1.default;
+//# sourceMappingURL=strapi-admin.js.map

package/strapi-server.d.ts

@@ -0,0 +1,273 @@
+declare const _default: () => {
+    bootstrap: ({ strapi }: import("strapi-typed").StrapiContext) => Promise<void>;
+    config: import("./types").StrapiConfig<import("./types").NavigationPluginConfig>;
+    contentTypes: {
+        audience: {
+            schema: {
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    name: string;
+                };
+                options: {
+                    increments: boolean;
+                    comment: string;
+                };
+                attributes: {
+                    name: {
+                        type: string;
+                        required: boolean;
+                    };
+                    key: {
+                        type: string;
+                        targetField: string;
+                    };
+                };
+            };
+        };
+        navigation: {
+            lifecycle: {
+                renderType: {
+                    FLAT: string;
+                    TREE: string;
+                    RFR: string;
+                };
+            };
+            schema: {
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    name: string;
+                };
+                options: {
+                    increments: boolean;
+                    comment: string;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    name: {
+                        type: string;
+                        configurable: boolean;
+                        required: boolean;
+                    };
+                    slug: {
+                        type: string;
+                        target: string;
+                        configurable: boolean;
+                        required: boolean;
+                    };
+                    visible: {
+                        type: string;
+                        default: boolean;
+                        configurable: boolean;
+                    };
+                    items: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        configurable: boolean;
+                    };
+                    localizations: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                    };
+                    localeCode: {
+                        type: string;
+                    };
+                };
+            };
+        };
+        "navigation-item": {
+            lifecycle: {
+                type: {
+                    INTERNAL: string;
+                    EXTERNAL: string;
+                    WRAPPER: string;
+                };
+                additionalFields: {
+                    AUDIENCE: string;
+                };
+                lifecycles: {
+                    afterFind(results: any): void;
+                };
+            };
+            schema: {
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    name: string;
+                };
+                options: {
+                    increments: boolean;
+                    timestamps: boolean;
+                    comment: string;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                    i18n: {
+                        localized: boolean;
+                    };
+                };
+                attributes: {
+                    title: {
+                        type: string;
+                        configurable: boolean;
+                        required: boolean;
+                        pluginOptions: {
+                            i18n: {
+                                localized: boolean;
+                            };
+                        };
+                    };
+                    type: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                        configurable: boolean;
+                    };
+                    path: {
+                        type: string;
+                        targetField: string;
+                        configurable: boolean;
+                    };
+                    externalPath: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    uiRouterKey: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    menuAttached: {
+                        type: string;
+                        default: boolean;
+                        configurable: boolean;
+                    };
+                    order: {
+                        type: string;
+                        default: number;
+                        configurable: boolean;
+                    };
+                    collapsed: {
+                        type: string;
+                        default: boolean;
+                        configurable: boolean;
+                    };
+                    related: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        configurable: boolean;
+                    };
+                    parent: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        configurable: boolean;
+                        default: null;
+                    };
+                    master: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        configurable: boolean;
+                    };
+                    audience: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                    };
+                };
+            };
+        };
+        "navigations-items-related": {
+            lifecycle: {
+                lifecycles: {
+                    afterFind(results: any): void;
+                };
+            };
+            schema: {
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    name: string;
+                };
+                options: {
+                    increments: boolean;
+                    timestamps: boolean;
+                    populateCreatorFields: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                    i18n: {
+                        localized: boolean;
+                    };
+                };
+                attributes: {
+                    related_id: {
+                        type: string;
+                        required: boolean;
+                    };
+                    related_type: {
+                        type: string;
+                        required: boolean;
+                    };
+                    field: {
+                        type: string;
+                        required: boolean;
+                    };
+                    order: {
+                        type: string;
+                        required: boolean;
+                    };
+                    master: {
+                        type: string;
+                        required: boolean;
+                    };
+                };
+            };
+        };
+    };
+    controllers: import("./types").NavigationController;
+    destroy: () => void;
+    middlewares: {};
+    policies: {};
+    register: () => Promise<void>;
+    routes: {
+        admin: import("./types").StrapiRoutes;
+        'content-api': import("./types").StrapiRoutes;
+    };
+    services: {
+        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;
+//# sourceMappingURL=strapi-server.d.ts.map