strapi-cache 1.6.2 → 1.8.1

package/dist/_chunks/index-D_ssKKxu.js

@@ -0,0 +1,395 @@
+"use strict";
+const react = require("react");
+const jsxRuntime = require("react/jsx-runtime");
+const admin = require("@strapi/strapi/admin");
+const reactIntl = require("react-intl");
+const icons = require("@strapi/icons");
+const designSystem = require("@strapi/design-system");
+const __variableDynamicImportRuntimeHelper = (glob, path, segs) => {
+  const v = glob[path];
+  if (v) {
+    return typeof v === "function" ? v() : Promise.resolve(v);
+  }
+  return new Promise((_, reject) => {
+    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(
+      reject.bind(
+        null,
+        new Error(
+          "Unknown variable dynamic import: " + path + (path.split("/").length !== segs ? ". Note that variables only represent file names one level deep." : "")
+        )
+      )
+    );
+  });
+};
+const PLUGIN_ID = "strapi-cache";
+const Initializer = ({ setPlugin }) => {
+  const ref = react.useRef(setPlugin);
+  react.useEffect(() => {
+    ref.current(PLUGIN_ID);
+  }, []);
+  return null;
+};
+const useCacheConfig = (enabled = true) => {
+  const [config, setConfig] = react.useState();
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const { get } = admin.useFetchClient();
+  react.useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+    const fetchConfig = async () => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const { data } = await get("/strapi-cache/config");
+        setConfig(data);
+      } catch (error2) {
+        setError(error2);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    fetchConfig();
+  }, [enabled, get]);
+  return {
+    config,
+    isLoading,
+    error,
+    refetch: () => {
+      const fetchConfig = async () => {
+        setIsLoading(true);
+        setError(null);
+        try {
+          const { data } = await get("/strapi-cache/config");
+          setConfig(data);
+        } catch (error2) {
+          setError(error2);
+        } finally {
+          setIsLoading(false);
+        }
+      };
+      fetchConfig();
+    }
+  };
+};
+const pluginPermissions = {
+  purge: [{ action: "plugin::strapi-cache.purge-cache", subject: null }]
+};
+const useCachePermissions = () => {
+  const { allowedActions } = admin.useRBAC(pluginPermissions);
+  return {
+    canPurgeCache: allowedActions.canPurgeCache,
+    allowedActions
+  };
+};
+const useCacheOperations = () => {
+  const { post } = admin.useFetchClient();
+  const isCacheableRoute = (keyToUse, contentTypeName, config) => {
+    if (!keyToUse || !config) {
+      return false;
+    }
+    const { cacheableRoutes } = config;
+    return cacheableRoutes.length === 0 || cacheableRoutes.some((route) => {
+      return route.includes(keyToUse) || contentTypeName && route.includes(contentTypeName);
+    });
+  };
+  const clearCache = async (keyToUse) => {
+    if (!keyToUse) {
+      return {
+        success: false,
+        message: "No content type found"
+      };
+    }
+    try {
+      await post(
+        `/strapi-cache/purge-cache/key`,
+        { key: keyToUse },
+        {
+          headers: {
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      return {
+        success: true,
+        message: `Cache purged successfully for key: "${keyToUse}"`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Error purging cache for key: "${keyToUse}"`,
+        error
+      };
+    }
+  };
+  const clearAllCache = async () => {
+    try {
+      await post(
+        `/strapi-cache/purge-cache`,
+        {},
+        {
+          headers: {
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      return {
+        success: true,
+        message: "All cache purged successfully"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: "Error purging all cache",
+        error
+      };
+    }
+  };
+  return {
+    isCacheableRoute,
+    clearCache,
+    clearAllCache
+  };
+};
+const useCacheNotifications = (config) => {
+  const formatMessage = reactIntl.useIntl().formatMessage;
+  const { toggleNotification } = admin.useNotification();
+  const showConfigFetchError = (error) => {
+    const isPermissionError = error?.response?.status === 403 || error?.response?.status === 401;
+    if (!isPermissionError && !config?.disableAdminPopups) {
+      toggleNotification({
+        type: "warning",
+        message: formatMessage({
+          id: "strapi-cache.cache.routes.fetch-error",
+          defaultMessage: "Unable to fetch cache config. Cache purge may not work correctly."
+        })
+      });
+    }
+  };
+  const showPurgeSuccess = (key) => {
+    if (!config?.disableAdminPopups) {
+      toggleNotification({
+        type: "success",
+        message: formatMessage(
+          {
+            id: "strapi-cache.cache.purge.success",
+            defaultMessage: "Cache purged successfully"
+          },
+          {
+            key: `"${key}"`
+          }
+        )
+      });
+    }
+  };
+  const showPurgeError = (key) => {
+    if (!config?.disableAdminPopups) {
+      toggleNotification({
+        type: "danger",
+        message: formatMessage(
+          {
+            id: "strapi-cache.cache.purge.error",
+            defaultMessage: "Error purging cache"
+          },
+          {
+            key: `"${key}"`
+          }
+        )
+      });
+    }
+  };
+  const showNoContentTypeWarning = () => {
+    if (!config?.disableAdminPopups) {
+      toggleNotification({
+        type: "warning",
+        message: formatMessage({
+          id: "strapi-cache.cache.purge.no-content-type",
+          defaultMessage: "No content type found"
+        })
+      });
+    }
+  };
+  return {
+    showConfigFetchError,
+    showPurgeSuccess,
+    showPurgeError,
+    showNoContentTypeWarning
+  };
+};
+function PurgeModal({
+  buttonText,
+  keyToUse,
+  buttonWidth,
+  contentTypeName,
+  isSettingsPage,
+  isPurgeAll
+}) {
+  const { canPurgeCache } = useCachePermissions();
+  const { config, error: configError } = useCacheConfig(canPurgeCache);
+  const { isCacheableRoute, clearCache, clearAllCache } = useCacheOperations();
+  const { showConfigFetchError, showPurgeSuccess, showPurgeError, showNoContentTypeWarning } = useCacheNotifications(config);
+  const formatMessage = reactIntl.useIntl().formatMessage;
+  react.useEffect(() => {
+    if (configError) {
+      showConfigFetchError(configError);
+    }
+  }, [configError, showConfigFetchError]);
+  const handleClearCache = async () => {
+    if (isPurgeAll) {
+      const result2 = await clearAllCache();
+      if (result2.success) {
+        showPurgeSuccess("all keys");
+      } else {
+        showPurgeError("all keys");
+      }
+      return;
+    }
+    if (!keyToUse) {
+      showNoContentTypeWarning();
+      return;
+    }
+    const result = await clearCache(keyToUse);
+    if (result.success) {
+      showPurgeSuccess(keyToUse);
+    } else {
+      showPurgeError(keyToUse);
+    }
+  };
+  if (!canPurgeCache || !isPurgeAll && !isSettingsPage && !isCacheableRoute(keyToUse, contentTypeName, config)) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Modal.Root, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Trigger, { children: /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.Button,
+      {
+        width: buttonWidth,
+        disabled: !isPurgeAll && !keyToUse,
+        startIcon: /* @__PURE__ */ jsxRuntime.jsx(icons.Archive, {}),
+        variant: "danger",
+        children: buttonText
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Modal.Content, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Header, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Title, { children: buttonText }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Body, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "omega", children: isPurgeAll ? formatMessage({
+        id: "strapi-cache.cache.purge.confirmation-all",
+        defaultMessage: "This purges all items in the cache. Are you sure you want to purge the cache?"
+      }) : formatMessage(
+        {
+          id: "strapi-cache.cache.purge.confirmation",
+          defaultMessage: "Are you sure you want to purge the cache?"
+        },
+        { key: `"${keyToUse}"` }
+      ) }) }),
+      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Modal.Footer, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Close, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "tertiary", children: formatMessage({
+          id: "strapi-cache.cache.cancel",
+          defaultMessage: "No, cancel"
+        }) }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Close, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { onClick: handleClearCache, children: formatMessage({
+          id: "strapi-cache.cache.confirm",
+          defaultMessage: "Yes, confirm"
+        }) }) })
+      ] })
+    ] })
+  ] });
+}
+function PurgeCacheButton() {
+  const { contentType } = admin.unstable_useContentManagerContext();
+  const { formatMessage } = reactIntl.useIntl();
+  const { config } = useCacheConfig();
+  const keyToUse = contentType?.info.pluralName;
+  if (config?.disableAdminButtons) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    PurgeModal,
+    {
+      buttonText: formatMessage({
+        id: "strapi-cache.cache.purge",
+        defaultMessage: "Purge Cache"
+      }),
+      keyToUse
+    }
+  );
+}
+function PurgeEntityButton() {
+  const { formatMessage } = reactIntl.useIntl();
+  const { id, isSingleType, contentType } = admin.unstable_useContentManagerContext();
+  const { config } = useCacheConfig();
+  const apiPath = isSingleType ? contentType?.info.singularName : id;
+  if (!apiPath) {
+    return null;
+  }
+  if (config?.disableAdminButtons) {
+    return null;
+  }
+  const keyToUse = encodeURIComponent(apiPath);
+  const contentTypeName = isSingleType ? contentType?.info.singularName : contentType?.info.pluralName;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    PurgeModal,
+    {
+      buttonWidth: "100%",
+      buttonText: formatMessage({
+        id: "strapi-cache.cache.purge.entity",
+        defaultMessage: "Purge Entity Cache"
+      }),
+      keyToUse,
+      contentTypeName
+    }
+  );
+}
+const index = {
+  register(app) {
+    app.registerPlugin({
+      id: PLUGIN_ID,
+      initializer: Initializer,
+      isReady: false,
+      name: PLUGIN_ID
+    });
+    app.getPlugin("content-manager").injectComponent("listView", "actions", {
+      name: PurgeCacheButton,
+      Component: PurgeCacheButton
+    });
+    app.getPlugin("content-manager").injectComponent("editView", "right-links", {
+      name: PurgeEntityButton,
+      Component: PurgeEntityButton
+    });
+    app.createSettingSection(
+      {
+        id: PLUGIN_ID,
+        intlLabel: {
+          id: "strapi-cache.settings.link",
+          defaultMessage: "Strapi Cache"
+        }
+      },
+      [
+        {
+          intlLabel: {
+            id: "strapi-cache.settings.link",
+            defaultMessage: "Strapi Cache"
+          },
+          id: "settings",
+          to: `${PLUGIN_ID}/settings`,
+          Component: () => Promise.resolve().then(() => require("./index-B_MAAg0W.js")),
+          permissions: []
+        }
+      ]
+    );
+  },
+  async registerTrads({ locales }) {
+    return Promise.all(
+      locales.map(async (locale) => {
+        try {
+          const { default: data } = await __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/de.json": () => Promise.resolve().then(() => require("./de-l6MDDAXu.js")), "./translations/en.json": () => Promise.resolve().then(() => require("./en-D9w03LyX.js")) }), `./translations/${locale}.json`, 3);
+          return { data, locale };
+        } catch {
+          return { data: {}, locale };
+        }
+      })
+    );
+  }
+};
+exports.PurgeModal = PurgeModal;
+exports.index = index;

package/dist/admin/index.js

@@ -0,0 +1,3 @@
+"use strict";
+const index = require("../_chunks/index-D_ssKKxu.js");
+module.exports = index.index;

package/dist/admin/index.mjs

@@ -0,0 +1,4 @@
+import { i } from "../_chunks/index-BwuX8jJl.mjs";
+export {
+  i as default
+};

package/dist/admin/src/components/PurgeCacheButton/index.d.ts

@@ -1,2 +1,2 @@
-declare function PurgeCacheButton(): import("react/jsx-runtime").JSX.Element;
+declare function PurgeCacheButton(): import("react/jsx-runtime").JSX.Element | null;
 export default PurgeCacheButton;

package/dist/admin/src/components/PurgeModal/index.d.ts

@@ -4,6 +4,7 @@ export type PurgeProps = {
     keyToUse?: string;
     contentTypeName?: string;
     isSettingsPage?: boolean;
+    isPurgeAll?: boolean;
 };
-declare function PurgeModal({ buttonText, keyToUse, buttonWidth, contentTypeName, isSettingsPage, }: PurgeProps): import("react/jsx-runtime").JSX.Element | null;
+declare function PurgeModal({ buttonText, keyToUse, buttonWidth, contentTypeName, isSettingsPage, isPurgeAll, }: PurgeProps): import("react/jsx-runtime").JSX.Element | null;
 export default PurgeModal;

package/dist/admin/src/hooks/useCacheConfig.d.ts

@@ -1,6 +1,7 @@
 export type CacheConfig = {
     cacheableRoutes: string[];
     disableAdminPopups: boolean;
+    disableAdminButtons: boolean;
 };
 export declare const useCacheConfig: (enabled?: boolean) => {
     config: CacheConfig | undefined;

package/dist/admin/src/hooks/useCacheOperations.d.ts

@@ -7,4 +7,5 @@ export type CacheOperationResult = {
 export declare const useCacheOperations: () => {
     isCacheableRoute: (keyToUse?: string, contentTypeName?: string, config?: CacheConfig) => boolean;
     clearCache: (keyToUse?: string) => Promise<CacheOperationResult>;
+    clearAllCache: () => Promise<CacheOperationResult>;
 };