strapi-plugin-navigation 2.0.13 → 2.1.0

package/server/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const bootstrap_1 = __importDefault(require("./bootstrap"));
+const config_1 = __importDefault(require("./config"));
+const content_types_1 = __importDefault(require("./content-types"));
+const controllers_1 = __importDefault(require("./controllers"));
+const destroy_1 = __importDefault(require("./destroy"));
+const register_1 = __importDefault(require("./register"));
+const routes_1 = __importDefault(require("./routes"));
+const services_1 = __importDefault(require("./services"));
+exports.default = {
+    bootstrap: bootstrap_1.default,
+    config: config_1.default,
+    contentTypes: content_types_1.default,
+    controllers: controllers_1.default,
+    destroy: destroy_1.default,
+    middlewares: {},
+    policies: {},
+    register: register_1.default,
+    routes: routes_1.default,
+    services: services_1.default,
+};
+//# sourceMappingURL=index.js.map

package/server/navigation/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./setupStrategy";
+//# sourceMappingURL=index.d.ts.map

package/server/navigation/index.js

@@ -0,0 +1,18 @@
+"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("./setupStrategy"), exports);
+//# sourceMappingURL=index.js.map

package/server/navigation/setupStrategy.d.ts

@@ -0,0 +1,3 @@
+import { INavigationSetupStrategy } from "../../types";
+export declare const navigationSetupStrategy: INavigationSetupStrategy;
+//# sourceMappingURL=setupStrategy.d.ts.map

package/server/navigation/setupStrategy.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.navigationSetupStrategy = void 0;
+const i18n_1 = require("../i18n");
+const utils_1 = require("../utils");
+const navigationSetupStrategy = async (context) => {
+    const i18nPlugin = context.strapi.plugin("i18n");
+    const defaultLocale = i18nPlugin ? await i18nPlugin.service("locales").getDefaultLocale() : null;
+    if (defaultLocale) {
+        return await (0, i18n_1.i18nNavigationSetupStrategy)(context);
+    }
+    else {
+        return await regularNavigationSetupStrategy(context);
+    }
+};
+exports.navigationSetupStrategy = navigationSetupStrategy;
+const regularNavigationSetupStrategy = async ({ strapi, }) => {
+    const navigations = await getCurrentNavigations();
+    if (!navigations.length) {
+        return [
+            await createNavigation({
+                strapi,
+                payload: {
+                    ...utils_1.DEFAULT_NAVIGATION_ITEM,
+                },
+                populate: utils_1.DEFAULT_POPULATE
+            }),
+        ];
+    }
+    return navigations;
+};
+const createNavigation = ({ strapi, payload, populate }) => strapi.query("plugin::navigation.navigation").create({
+    data: {
+        ...payload,
+    },
+    populate,
+});
+const getCurrentNavigations = () => (0, utils_1.getPluginService)('admin').get();
+//# sourceMappingURL=setupStrategy.js.map

package/server/register/index.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => Promise<void>;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/server/register/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = async () => { };
+//# sourceMappingURL=index.js.map

package/server/routes/admin.d.ts

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

package/server/routes/admin.js

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

package/server/routes/client.d.ts

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

package/server/routes/client.js

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

package/server/routes/index.d.ts

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

package/server/routes/index.js

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

package/server/services/admin.d.ts

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

package/server/services/admin.js

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

package/server/services/client.d.ts

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