strapi-plugin-navigation 2.4.0 → 2.5.0

package/server/cache/serviceEnhancers.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCacheConfigFields = void 0;
+const utils_1 = require("./utils");
+const addCacheConfigFields = async ({ previousConfig, strapi, }) => {
+    const { enabled, hasCachePlugin } = await (0, utils_1.getCacheStatus)({
+        strapi,
+    });
+    return {
+        ...previousConfig,
+        isCacheEnabled: enabled,
+        isCachePluginEnabled: hasCachePlugin,
+    };
+};
+exports.addCacheConfigFields = addCacheConfigFields;
+//# sourceMappingURL=serviceEnhancers.js.map

package/server/cache/setupStrategy.d.ts

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

package/server/cache/setupStrategy.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupCacheStrategy = void 0;
+const router_1 = __importDefault(require("@koa/router"));
+const client_1 = __importDefault(require("../routes/client"));
+const utils_1 = require("./utils");
+const setupCacheStrategy = async ({ strapi, }) => {
+    const { enabled, hasCachePlugin } = await (0, utils_1.getCacheStatus)({ strapi });
+    if (hasCachePlugin && enabled) {
+        const cachePlugin = strapi.plugin("rest-cache");
+        const createCacheMiddleware = cachePlugin?.middleware("recv");
+        if (!createCacheMiddleware) {
+            console.warn("Cache middleware not present in cache plugin. Stopping");
+            console.warn("Notify strapi-navigation-plugin-team");
+            return;
+        }
+        const pluginOption = strapi.config.get("plugin.rest-cache");
+        const router = new router_1.default();
+        const buildPathFrom = (route) => `/api/${route.info.pluginName}${route.path}`;
+        const buildFrom = (route) => ({
+            maxAge: pluginOption.strategy?.maxAge ?? 6 * 60 * 1000,
+            path: buildPathFrom(route),
+            method: "GET",
+            paramNames: ["idOrSlug", "childUIKey"],
+            keys: { useHeaders: [], useQueryParams: true },
+            hitpass: false,
+        });
+        client_1.default.routes.forEach((route) => {
+            router.get(buildPathFrom(route), createCacheMiddleware({ cacheRouteConfig: buildFrom(route) }, { strapi }));
+        });
+        strapi.server.router.use(router.routes());
+    }
+};
+exports.setupCacheStrategy = setupCacheStrategy;
+//# sourceMappingURL=setupStrategy.js.map

package/server/cache/types.d.ts

@@ -0,0 +1,11 @@
+import { IStrapi } from "strapi-typed";
+export type AddCacheConfigFieldsInput<T> = {
+    previousConfig: T;
+    strapi: IStrapi;
+    viaSettingsPage?: boolean;
+};
+export type CacheConfigFields = {
+    isCacheEnabled: boolean;
+    isCachePluginEnabled: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

package/server/cache/types.js

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

package/server/cache/utils.d.ts

@@ -0,0 +1,11 @@
+import { IStrapi } from "strapi-typed";
+type GetCacheStatusInput = {
+    strapi: IStrapi;
+};
+type CacheStatus = {
+    hasCachePlugin: boolean;
+    enabled: boolean;
+};
+export declare const getCacheStatus: ({ strapi, }: GetCacheStatusInput) => Promise<CacheStatus>;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/server/cache/utils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCacheStatus = void 0;
+const getCacheStatus = async ({ strapi, }) => {
+    const cachePlugin = strapi.plugin("rest-cache");
+    const hasCachePlugin = !!cachePlugin;
+    const pluginStore = strapi.store({
+        type: "plugin",
+        name: "navigation",
+    });
+    const config = await pluginStore.get({
+        key: "config",
+    });
+    return hasCachePlugin
+        ? { hasCachePlugin, enabled: config.isCacheEnabled }
+        : { hasCachePlugin, enabled: false };
+};
+exports.getCacheStatus = getCacheStatus;
+//# sourceMappingURL=utils.js.map

package/server/config/index.js

@@ -29,6 +29,7 @@ const config = {
         pathDefaultFields: {},
         pruneObsoleteI18nNavigations: false,
         cascadeMenuAttached: true,
+        isCacheEnabled: false,
     },
 };
 exports.default = config;

package/server/config/setupStrategy.js

@@ -25,6 +25,7 @@ const configSetupStrategy = async ({ strapi }) => {
         pruneObsoleteI18nNavigations: false,
         pathDefaultFields: getWithFallback("pathDefaultFields"),
         cascadeMenuAttached: getWithFallback("cascadeMenuAttached"),
+        isCacheEnabled: getWithFallback("isCacheEnabled"),
     };
     handleDeletedContentTypes(config, { strapi });
     (0, utils_1.validateAdditionalFields)(config.additionalFields);

package/server/controllers/admin.js

@@ -6,6 +6,7 @@ const utils_2 = require("../utils");
 const utils_3 = require("../utils");
 const InvalidParamNavigationError_1 = require("../../utils/InvalidParamNavigationError");
 const NavigationError_1 = require("../../utils/NavigationError");
+const utils_4 = require("../cache/utils");
 const adminControllers = {
     getAdminService() {
         return (0, utils_2.getPluginService)("admin");
@@ -137,6 +138,23 @@ const adminControllers = {
             throw error;
         }
     },
+    async purgeNavigationsCache() {
+        const mappedStrapi = strapi;
+        const { enabled } = await (0, utils_4.getCacheStatus)({ strapi: mappedStrapi });
+        if (!enabled) {
+            return { success: false };
+        }
+        return await this.getAdminService().purgeNavigationsCache();
+    },
+    async purgeNavigationCache(ctx) {
+        const { params: { id }, query: { clearLocalisations = 'false' } } = ctx;
+        const mappedStrapi = strapi;
+        const { enabled } = await (0, utils_4.getCacheStatus)({ strapi: mappedStrapi });
+        if (!enabled) {
+            return { success: false };
+        }
+        return await this.getAdminService().purgeNavigationCache(id, JSON.parse(clearLocalisations));
+    }
 };
 const assertCopyParams = (source, target) => {
     (0, types_1.assertIsNumber)(source, new InvalidParamNavigationError_1.InvalidParamNavigationError("Source's id is not a number"));

package/server/i18n/navigationSetupStrategy.js

@@ -104,7 +104,7 @@ const i18nNavigationSetupStrategy = async ({ strapi, }) => {
     return getCurrentNavigations(strapi);
 };
 exports.i18nNavigationSetupStrategy = i18nNavigationSetupStrategy;
-const getCurrentNavigations = (strapi, ids) => strapi.plugin("navigation").service("admin").get(ids);
+const getCurrentNavigations = (strapi, ids) => strapi.plugin("navigation").service("admin").get(ids, true);
 const createNavigation = ({ strapi, payload, populate, }) => strapi.query("plugin::navigation.navigation").create({
     data: {
         ...payload,

package/server/routes/admin.js

@@ -72,6 +72,26 @@ const routes = {
                     }]
             }
         },
+        {
+            method: 'DELETE',
+            path: '/cache/purge/:id',
+            handler: 'admin.purgeNavigationCache',
+            config: {
+                policies: [
+                    'admin::isAuthenticatedAdmin'
+                ]
+            }
+        },
+        {
+            method: 'DELETE',
+            path: '/cache/purge',
+            handler: 'admin.purgeNavigationsCache',
+            config: {
+                policies: [
+                    'admin::isAuthenticatedAdmin'
+                ]
+            }
+        },
         {
             method: 'GET',
             path: '/slug',

package/server/services/admin.js

@@ -5,6 +5,7 @@ const lodash_1 = require("lodash");
 const utils_2 = require("../utils");
 const i18n_1 = require("../i18n");
 const NavigationError_1 = require("../../utils/NavigationError");
+const serviceEnhancers_1 = require("../cache/serviceEnhancers");
 const adminService = ({ strapi, }) => ({
     async config(viaSettingsPage = false) {
         const commonService = (0, utils_2.getPluginService)("common");
@@ -50,6 +51,7 @@ const adminService = ({ strapi, }) => ({
             viaSettingsPage,
             previousConfig: {},
         });
+        const cacheConfig = await (0, serviceEnhancers_1.addCacheConfigFields)({ strapi, previousConfig: {} });
         if (additionalFields.includes("audience")) {
             const audienceItems = await strapi
                 .query(audienceModel.uid)
@@ -65,9 +67,10 @@ const adminService = ({ strapi, }) => ({
             ...result,
             ...extendedResult,
             ...i18nConfig,
+            ...cacheConfig,
         };
     },
-    async get(ids) {
+    async get(ids, ignoreLocale = false) {
         const { masterModel } = (0, utils_2.getPluginModels)();
         const { enabled: i18nEnabled, locales } = await (0, i18n_1.getI18nStatus)({ strapi });
         const whereClause = {};
@@ -79,7 +82,7 @@ const adminService = ({ strapi, }) => ({
             populate: utils_2.DEFAULT_POPULATE,
             where: whereClause,
         });
-        if (i18nEnabled) {
+        if (i18nEnabled && !ignoreLocale) {
             entities = entities.reduce((acc, entity) => {
                 if (entity.localeCode && locales?.includes(entity.localeCode)) {
                     acc.push({
@@ -126,11 +129,12 @@ const adminService = ({ strapi, }) => ({
             name,
             slug: await commonService.getSlug(name),
             visible,
+            localeCode: i18nEnabled && defaultLocale ? defaultLocale : null
         };
         const existingEntity = await strapi
             .query(masterModel.uid)
             .create({ data });
-        const result = commonService
+        const result = await commonService
             .createBranch(payload.items, existingEntity, null, {})
             .then(() => adminService.getById(existingEntity.id))
             .then((newEntity) => {
@@ -207,19 +211,21 @@ const adminService = ({ strapi, }) => ({
     },
     async delete(id, auditLog) {
         const { masterModel, itemModel } = (0, utils_2.getPluginModels)();
-        const adminService = (0, utils_2.getPluginService)("admin");
-        const entity = await adminService.getById(id);
+        const entity = await this.getById(id);
         const { enabled: i18nEnabled } = await (0, i18n_1.getI18nStatus)({ strapi });
         const cleanNavigationItems = async (masterIds) => {
+            if (masterIds.length < 1) {
+                return;
+            }
             const navigationItems = await strapi.query(itemModel.uid).findMany({
                 where: {
-                    $or: masterIds.map((id) => ({ master: id }))
+                    $or: masterIds.map((id) => ({ master: id })),
                 },
                 limit: Number.MAX_SAFE_INTEGER,
             });
             await strapi.query(itemModel.uid).deleteMany({
                 where: {
-                    $or: navigationItems.map(({ id }) => ({ id }))
+                    id: navigationItems.map(({ id }) => (id)),
                 },
             });
         };
@@ -248,7 +254,7 @@ const adminService = ({ strapi, }) => ({
         setImmediate(() => strapi.reload());
     },
     async restoreConfig() {
-        const commonService = (0, utils_2.getPluginService)("common");
+        const commonService = (0, utils_2.getPluginService)("common", strapi);
         const pluginStore = await commonService.getPluginStore();
         await pluginStore.delete({ key: "config" });
         await commonService.setDefaultConfig();
@@ -306,6 +312,34 @@ const adminService = ({ strapi, }) => ({
             strapi,
         });
     },
+    async purgeNavigationCache(id, clearLocalisations) {
+        const entity = await this.getById(id);
+        const regexps = [];
+        const mapToRegExp = (id) => new RegExp(`/api/navigation/render/${id}`);
+        if (!entity) {
+            throw new utils_1.errors.NotFoundError("Navigation is not defined");
+        }
+        if (clearLocalisations) {
+            const { enabled: isI18nEnabled } = await (0, i18n_1.getI18nStatus)({ strapi });
+            if (isI18nEnabled) {
+                entity.localizations?.forEach((navigation) => {
+                    regexps.push(mapToRegExp(navigation.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;
 //# sourceMappingURL=admin.js.map

package/server/utils/functions.d.ts

@@ -9,7 +9,7 @@ type TypeMap = {
     admin: IAdminService;
     common: ICommonService;
 };
-export declare function getPluginService<T extends NavigationServiceName>(name: T): T extends infer R extends NavigationServiceName ? TypeMap[R] : never;
+export declare function getPluginService<T extends NavigationServiceName>(name: T, strapiInstance?: IStrapi): T extends infer R extends NavigationServiceName ? TypeMap[R] : never;
 export declare const errorHandler: (ctx: ToBeFixed) => (error: NavigationError | string) => any;
 export declare const getCustomFields: (additionalFields: NavigationItemAdditionalField[]) => NavigationItemCustomField[];
 export declare const parseParams: <TParams extends StringMap<string> = StringMap<string>, TResult extends StringMap<Primitive> = StringMap<Primitive>>(params: TParams) => TResult;

package/server/utils/functions.js

@@ -6,8 +6,8 @@ const types_1 = require("../../types");
 const NavigationError_1 = require("../../utils/NavigationError");
 const constant_1 = require("./constant");
 const UID_REGEX = /^(?<type>[a-z0-9-]+)\:{2}(?<api>[a-z0-9-]+)\.{1}(?<contentType>[a-z0-9-]+)$/i;
-function getPluginService(name) {
-    return strapi.plugin("navigation").service(name);
+function getPluginService(name, strapiInstance = strapi) {
+    return strapiInstance.plugin("navigation").service(name);
 }
 exports.getPluginService = getPluginService;
 const errorHandler = (ctx) => (error) => {