@plone/volto 17.0.0-alpha.8 → 17.0.0

package/src/middleware/api.js

@@ -67,7 +67,15 @@ export function addExpandersToPath(path, type, isAnonymous) {
 
   const querystringFromConfig = apiExpanders
     .filter((expand) => matchPath(url, expand.match) && expand[type])
-    .reduce((acc, expand) => ({ ...acc, ...expand?.['querystring'] }), {});
+    .reduce((acc, expand) => {
+      let querystring = expand?.['querystring'];
+      // The querystring accepts being a function to be able to take other
+      // config parameters
+      if (typeof querystring === 'function') {
+        querystring = querystring(config);
+      }
+      return { ...acc, ...querystring };
+    }, {});
 
   const queryMerge = { ...query, ...querystringFromConfig };
 
@@ -117,52 +125,76 @@ function sendOnSocket(request) {
  * @param {Object} api Api object.
  * @returns {Promise} Action promise.
  */
-const apiMiddlewareFactory = (api) => ({ dispatch, getState }) => (next) => (
-  action,
-) => {
-  const { settings } = config;
+const apiMiddlewareFactory =
+  (api) =>
+  ({ dispatch, getState }) =>
+  (next) =>
+  (action) => {
+    const { settings } = config;
 
-  const isAnonymous = !getState().userSession.token;
+    const token = getState().userSession.token;
+    let isAnonymous = true;
+    if (token) {
+      const tokenExpiration = jwtDecode(token).exp;
+      const currentTime = new Date().getTime() / 1000;
+      isAnonymous = !token || currentTime > tokenExpiration;
+    }
 
-  if (typeof action === 'function') {
-    return action(dispatch, getState);
-  }
+    if (typeof action === 'function') {
+      return action(dispatch, getState);
+    }
 
-  const { request, type, mode = 'parallel', ...rest } = action;
-  const { subrequest } = action; // We want subrequest remains in `...rest` above
+    const { request, type, mode = 'parallel', ...rest } = action;
+    const { subrequest } = action; // We want subrequest remains in `...rest` above
 
-  let actionPromise;
+    let actionPromise;
 
-  if (!request) {
-    return next(action);
-  }
+    if (!request) {
+      return next(action);
+    }
 
-  next({ ...rest, type: `${type}_PENDING` });
+    next({ ...rest, type: `${type}_PENDING` });
 
-  if (socket) {
-    actionPromise = Array.isArray(request)
-      ? Promise.all(
-          request.map((item) =>
-            sendOnSocket({
-              ...item,
-              path: addExpandersToPath(item.path, type, isAnonymous),
-              id: type,
-            }),
-          ),
-        )
-      : sendOnSocket({
-          ...request,
-          path: addExpandersToPath(request.path, type, isAnonymous),
-          id: type,
-        });
-  } else {
-    actionPromise = Array.isArray(request)
-      ? mode === 'serial'
-        ? request.reduce((prevPromise, item) => {
-            return prevPromise.then((acc) => {
-              return api[item.op](
-                addExpandersToPath(item.path, type, isAnonymous),
-                {
+    if (socket) {
+      actionPromise = Array.isArray(request)
+        ? Promise.all(
+            request.map((item) =>
+              sendOnSocket({
+                ...item,
+                path: addExpandersToPath(item.path, type, isAnonymous),
+                id: type,
+              }),
+            ),
+          )
+        : sendOnSocket({
+            ...request,
+            path: addExpandersToPath(request.path, type, isAnonymous),
+            id: type,
+          });
+    } else {
+      actionPromise = Array.isArray(request)
+        ? mode === 'serial'
+          ? request.reduce((prevPromise, item) => {
+              return prevPromise.then((acc) => {
+                return api[item.op](
+                  addExpandersToPath(item.path, type, isAnonymous),
+                  {
+                    data: item.data,
+                    type: item.type,
+                    headers: item.headers,
+                    params: request.params,
+                    checkUrl: settings.actions_raising_api_errors.includes(
+                      action.type,
+                    ),
+                  },
+                ).then((reqres) => {
+                  return [...acc, reqres];
+                });
+              });
+            }, Promise.resolve([]))
+          : Promise.all(
+              request.map((item) =>
+                api[item.op](addExpandersToPath(item.path, type, isAnonymous), {
                   data: item.data,
                   type: item.type,
                   headers: item.headers,
@@ -170,164 +202,162 @@ const apiMiddlewareFactory = (api) => ({ dispatch, getState }) => (next) => (
                   checkUrl: settings.actions_raising_api_errors.includes(
                     action.type,
                   ),
-                },
-              ).then((reqres) => {
-                return [...acc, reqres];
-              });
-            });
-          }, Promise.resolve([]))
-        : Promise.all(
-            request.map((item) =>
-              api[item.op](addExpandersToPath(item.path, type, isAnonymous), {
-                data: item.data,
-                type: item.type,
-                headers: item.headers,
-                params: request.params,
-                checkUrl: settings.actions_raising_api_errors.includes(
-                  action.type,
-                ),
-              }),
-            ),
-          )
-      : api[request.op](addExpandersToPath(request.path, type, isAnonymous), {
-          data: request.data,
-          type: request.type,
-          headers: request.headers,
-          params: request.params,
-          checkUrl: settings.actions_raising_api_errors.includes(action.type),
-        });
-    actionPromise.then(
-      (result) => {
-        const { settings } = config;
-        if (getState().apierror.connectionRefused) {
-          next({
-            ...rest,
-            type: RESET_APIERROR,
+                }),
+              ),
+            )
+        : api[request.op](addExpandersToPath(request.path, type, isAnonymous), {
+            data: request.data,
+            type: request.type,
+            headers: request.headers,
+            params: request.params,
+            checkUrl: settings.actions_raising_api_errors.includes(action.type),
           });
-        }
-        if (type === GET_CONTENT) {
-          const lang = result?.language?.token;
-          if (
-            lang &&
-            getState().intl.locale !== toReactIntlLang(lang) &&
-            !subrequest &&
-            config.settings.supportedLanguages.includes(lang)
-          ) {
-            const langFileName = toGettextLang(lang);
-            import('~/../locales/' + langFileName + '.json').then((locale) => {
-              dispatch(changeLanguage(lang, locale.default));
+      actionPromise.then(
+        (result) => {
+          const { settings } = config;
+          if (getState().apierror.connectionRefused) {
+            next({
+              ...rest,
+              type: RESET_APIERROR,
             });
           }
-        }
-        if (type === LOGIN && settings.websockets) {
-          const cookies = new Cookies();
-          cookies.set(
-            'auth_token',
-            result.token,
-            getCookieOptions({
-              expires: new Date(jwtDecode(result.token).exp * 1000),
-            }),
-          );
-          api.get('/@wstoken').then((res) => {
-            socket = new WebSocket(
-              `${settings.apiPath.replace('http', 'ws')}/@ws?ws_token=${
-                res.token
-              }`,
+          if (type === GET_CONTENT) {
+            const lang = result?.language?.token;
+            if (
+              lang &&
+              getState().intl.locale !== toReactIntlLang(lang) &&
+              !subrequest &&
+              config.settings.supportedLanguages.includes(lang)
+            ) {
+              const langFileName = toGettextLang(lang);
+              import('~/../locales/' + langFileName + '.json').then(
+                (locale) => {
+                  dispatch(changeLanguage(lang, locale.default));
+                },
+              );
+            }
+          }
+          if (type === LOGIN && settings.websockets) {
+            const cookies = new Cookies();
+            cookies.set(
+              'auth_token',
+              result.token,
+              getCookieOptions({
+                expires: new Date(jwtDecode(result.token).exp * 1000),
+              }),
             );
-            socket.onmessage = (message) => {
-              const packet = JSON.parse(message.data);
-              if (packet.error) {
-                dispatch({
-                  type: `${packet.id}_FAIL`,
-                  error: packet.error,
-                });
-              } else {
-                dispatch({
-                  type: `${packet.id}_SUCCESS`,
-                  result: JSON.parse(packet.data),
-                });
-              }
-            };
-          });
-        }
-        return next({ ...rest, result, type: `${type}_SUCCESS` });
-      },
-      (error) => {
-        // Only SRR can set ECONNREFUSED
-        if (error.code === 'ECONNREFUSED') {
-          next({
-            ...rest,
-            error,
-            statusCode: error.code,
-            connectionRefused: true,
-            type: SET_APIERROR,
-          });
-        }
-
-        // Response error is marked crossDomain if CORS error happen
-        else if (error.crossDomain) {
-          next({
-            ...rest,
-            error,
-            statusCode: 'CORSERROR',
-            connectionRefused: false,
-            type: SET_APIERROR,
-          });
-        }
-
-        // Check for actions who can raise api errors
-        if (settings.actions_raising_api_errors.includes(action.type)) {
-          // Gateway timeout
-          if (error?.response?.statusCode === 504) {
-            next({
-              ...rest,
-              error,
-              statusCode: error.code,
-              connectionRefused: true,
-              type: SET_APIERROR,
+            api.get('/@wstoken').then((res) => {
+              socket = new WebSocket(
+                `${settings.apiPath.replace('http', 'ws')}/@ws?ws_token=${
+                  res.token
+                }`,
+              );
+              socket.onmessage = (message) => {
+                const packet = JSON.parse(message.data);
+                if (packet.error) {
+                  dispatch({
+                    type: `${packet.id}_FAIL`,
+                    error: packet.error,
+                  });
+                } else {
+                  dispatch({
+                    type: `${packet.id}_SUCCESS`,
+                    result: JSON.parse(packet.data),
+                  });
+                }
+              };
             });
           }
-
-          // Redirect
-          else if (error?.code === 301) {
+          try {
+            return next({ ...rest, result, type: `${type}_SUCCESS` });
+          } catch (error) {
+            // There was an exception while processing reducers or downstream middleware.
             next({
               ...rest,
-              error,
-              statusCode: error.code,
-              connectionRefused: false,
-              type: SET_APIERROR,
+              error: { status: 500, error },
+              type: `${type}_FAIL`,
             });
+            // Rethrow the original exception on the client side only,
+            // so it doesn't fall through to express on the server.
+            if (__CLIENT__) throw error;
           }
-
-          // Redirect
-          else if (error?.code === 408) {
+        },
+        (error) => {
+          // Only SSR can set ECONNREFUSED
+          if (error.code === 'ECONNREFUSED') {
             next({
               ...rest,
               error,
               statusCode: error.code,
-              connectionRefused: false,
+              connectionRefused: true,
               type: SET_APIERROR,
             });
           }
 
-          // Unauthorized
-          else if (error?.response?.statusCode === 401) {
+          // Response error is marked crossDomain if CORS error happen
+          else if (error.crossDomain) {
             next({
               ...rest,
               error,
-              statusCode: error.response,
-              message: error.response.body.message,
+              statusCode: 'CORSERROR',
               connectionRefused: false,
               type: SET_APIERROR,
             });
           }
-        }
-        return next({ ...rest, error, type: `${type}_FAIL` });
-      },
-    );
-  }
 
-  return actionPromise;
-};
+          // Check for actions who can raise api errors
+          if (settings.actions_raising_api_errors.includes(action.type)) {
+            // Gateway timeout
+            if (error?.response?.statusCode === 504) {
+              next({
+                ...rest,
+                error,
+                statusCode: error.code,
+                connectionRefused: true,
+                type: SET_APIERROR,
+              });
+            }
+
+            // Redirect
+            else if (error?.code === 301) {
+              next({
+                ...rest,
+                error,
+                statusCode: error.code,
+                connectionRefused: false,
+                type: SET_APIERROR,
+              });
+            }
+
+            // Redirect
+            else if (error?.code === 408) {
+              next({
+                ...rest,
+                error,
+                statusCode: error.code,
+                connectionRefused: false,
+                type: SET_APIERROR,
+              });
+            }
+
+            // Unauthorized
+            else if (error?.response?.statusCode === 401) {
+              next({
+                ...rest,
+                error,
+                statusCode: error.response,
+                message: error.response.body.message,
+                connectionRefused: false,
+                type: SET_APIERROR,
+              });
+            }
+          }
+          return next({ ...rest, error, type: `${type}_FAIL` });
+        },
+      );
+    }
+
+    return actionPromise;
+  };
 
 export default apiMiddlewareFactory;

package/src/middleware/blacklistRoutes.js

@@ -1,31 +1,34 @@
 import config from '@plone/volto/registry';
 import { matchPath } from 'react-router';
 
-const blacklistRoutes = ({ dispatch, getState }) => (next) => (action) => {
-  if (typeof action === 'function') {
-    return next(action);
-  }
+const blacklistRoutes =
+  ({ dispatch, getState }) =>
+  (next) =>
+  (action) => {
+    if (typeof action === 'function') {
+      return next(action);
+    }
 
-  switch (action.type) {
-    case '@@router/LOCATION_CHANGE':
-      const { pathname } = action.payload.location;
-      const { externalRoutes = [] } = config.settings;
+    switch (action.type) {
+      case '@@router/LOCATION_CHANGE':
+        const { pathname } = action.payload.location;
+        const { externalRoutes = [] } = config.settings;
 
-      const route = externalRoutes.find((route) =>
-        matchPath(pathname, route.match),
-      );
+        const route = externalRoutes.find((route) =>
+          matchPath(pathname, route.match),
+        );
 
-      if (!route) {
+        if (!route) {
+          return next(action);
+        } else {
+          window.location.replace(
+            route.url ? route.url(action.payload) : pathname,
+          );
+        }
+        break;
+      default:
         return next(action);
-      } else {
-        window.location.replace(
-          route.url ? route.url(action.payload) : pathname,
-        );
-      }
-      break;
-    default:
-      return next(action);
-  }
-};
+    }
+  };
 
 export default blacklistRoutes;

package/src/middleware/index.js

@@ -4,8 +4,8 @@
  * @example import { api } from 'middleware';
  */
 
-export api from '@plone/volto/middleware/api';
-export blacklistRoutes from './blacklistRoutes';
+export { default as api } from '@plone/volto/middleware/api';
+export { default as blacklistRoutes } from './blacklistRoutes';
 export {
   protectLoadStart,
   protectLoadEnd,

package/src/middleware/storeProtectLoadUtils.js

@@ -21,42 +21,43 @@ const RESET_CONTENT = 'RESET_CONTENT';
 // such a reset when navigating between two content routes.
 // ---
 
-export const protectLoadStart = ({ dispatch, getState }) => (next) => (
-  action,
-) => {
-  if (typeof action === 'function') {
-    return next(action);
-  }
-  switch (action.type) {
-    case LOCATION_CHANGE:
-      const { location } = action.payload;
-      const { pathname: path } = location;
-      const currentPath = getState().router.location.pathname;
-      const result = next(action);
-      if (isCmsUi(path)) {
-        // Next path: isCmsUI, Non Content. There is no
-        // loading here, so skip counting altogether.
-        // Will update the delayed location constantly.
-        dispatch({
-          type: PROTECT_SKIPPED,
-          location,
-        });
-      } else {
-        dispatch({
-          type: PROTECT_START,
-          location,
-          // Only reset before the fetch, if we depart from
-          // a not isCmsUi, Content pass. However, reset will
-          // not occur if moving between two content paths,
-          // only the postponed location will be booked.
-          resetBeforeFetch: isCmsUi(currentPath),
-        });
-      }
-      return result;
-    default:
+export const protectLoadStart =
+  ({ dispatch, getState }) =>
+  (next) =>
+  (action) => {
+    if (typeof action === 'function') {
       return next(action);
-  }
-};
+    }
+    switch (action.type) {
+      case LOCATION_CHANGE:
+        const { location } = action.payload;
+        const { pathname: path } = location;
+        const currentPath = getState().router.location.pathname;
+        const result = next(action);
+        if (isCmsUi(path)) {
+          // Next path: isCmsUI, Non Content. There is no
+          // loading here, so skip counting altogether.
+          // Will update the delayed location constantly.
+          dispatch({
+            type: PROTECT_SKIPPED,
+            location,
+          });
+        } else {
+          dispatch({
+            type: PROTECT_START,
+            location,
+            // Only reset before the fetch, if we depart from
+            // a not isCmsUi, Content pass. However, reset will
+            // not occur if moving between two content paths,
+            // only the postponed location will be booked.
+            resetBeforeFetch: isCmsUi(currentPath),
+          });
+        }
+        return result;
+      default:
+        return next(action);
+    }
+  };
 
 // Note that there is a bit of heuristics here. We assume that every action
 // like this is beginning/ending an action. If this logic fails then the counting
@@ -70,34 +71,32 @@ const mapActions = {
   [GET_CONTENT_PENDING]: RESET_CONTENT,
 };
 
-export const protectLoadEnd = ({ dispatch, getState }) => (next) => (
-  action,
-) => {
-  if (typeof action === 'function') {
-    return next(action);
-  }
-  const {
-    isCounting,
-    resetBeforeFetch,
-    requestCount,
-  } = getState().loadProtector;
-  if (resetBeforeFetch) {
-    const type = mapActions[action.type];
-    if (type) {
-      dispatch({ type });
+export const protectLoadEnd =
+  ({ dispatch, getState }) =>
+  (next) =>
+  (action) => {
+    if (typeof action === 'function') {
+      return next(action);
     }
-  }
-  if (isCounting && requestCount === 1 && isResponseAction(action)) {
-    setTimeout(
-      () =>
-        dispatch({
-          type: PROTECT_END,
-        }),
-      0,
-    );
-  }
-  return next(action);
-};
+    const { isCounting, resetBeforeFetch, requestCount } =
+      getState().loadProtector;
+    if (resetBeforeFetch) {
+      const type = mapActions[action.type];
+      if (type) {
+        dispatch({ type });
+      }
+    }
+    if (isCounting && requestCount === 1 && isResponseAction(action)) {
+      setTimeout(
+        () =>
+          dispatch({
+            type: PROTECT_END,
+          }),
+        0,
+      );
+    }
+    return next(action);
+  };
 
 export function loadProtector(state = {}, action = {}) {
   switch (action.type) {