Merged in task/dspace-cris-2023_02_x/DSC-2887 (pull request DSpace#4642)

Task/dspace cris 2023 02 x/DSC-2887

Approved-by: Andrea Barbasso

Author: Francesco Mauto

src/app/app.metareducers.spec.ts

@@ -0,0 +1,64 @@
+import { universalMetaReducer } from './app.metareducers';
+import { StoreActionTypes } from './store.actions';
+
+describe('universalMetaReducer', () => {
+  const mockReducer = (state: any, action: any) => state;
+
+  it('should pass state through for unknown action', () => {
+    const state = { core: { route: { queryParams: { a: '1' }, params: {} } } };
+    const result = universalMetaReducer(mockReducer)(state, { type: 'UNKNOWN' });
+    expect(result).toEqual(state);
+  });
+
+  describe('REHYDRATE', () => {
+    it('should merge payload into state', () => {
+      const state = { otherProp: 'keep-me' };
+      const payload = { core: { route: { queryParams: { f: ['x'] }, params: {} } } };
+      const result = universalMetaReducer(mockReducer)(state, {
+        type: StoreActionTypes.REHYDRATE,
+        payload,
+      });
+      expect(result.otherProp).toBe('keep-me');
+      expect(result.core.route).toEqual({ queryParams: {}, params: {} });
+    });
+
+    it('should reset core.route to empty after rehydration', () => {
+      const state = { core: { route: { queryParams: { f: ['x'] }, params: { id: '123' } } } };
+      const payload = { core: { route: { queryParams: { stale: ['val'] }, params: { stale: 'val' } } } };
+      const result = universalMetaReducer(mockReducer)(state, {
+        type: StoreActionTypes.REHYDRATE,
+        payload,
+      });
+      expect(result.core.route).toEqual({ queryParams: {}, params: {} });
+    });
+
+    it('should not crash when state.core is undefined', () => {
+      const state = {};
+      const payload = { core: { route: { queryParams: { a: '1' }, params: {} } } };
+      const result = universalMetaReducer(mockReducer)(state, {
+        type: StoreActionTypes.REHYDRATE,
+        payload,
+      });
+      expect(result.core.route).toEqual({ queryParams: {}, params: {} });
+    });
+
+    it('should preserve other core properties when resetting route', () => {
+      const state = { core: { route: {} } };
+      const payload = { core: { route: { queryParams: { x: '1' }, params: {} }, otherProp: 'keep-me' } };
+      const result = universalMetaReducer(mockReducer)(state, {
+        type: StoreActionTypes.REHYDRATE,
+        payload,
+      });
+      expect(result.core.otherProp).toBe('keep-me');
+      expect(result.core.route).toEqual({ queryParams: {}, params: {} });
+    });
+
+    it('should handle REPLAY action (no-op)', () => {
+      const state = { core: { route: { queryParams: { a: '1' }, params: {} } } };
+      const result = universalMetaReducer(mockReducer)(state, {
+        type: StoreActionTypes.REPLAY,
+      });
+      expect(result).toEqual(state);
+    });
+  });
+});

src/app/app.metareducers.ts

@@ -19,6 +19,11 @@ export function universalMetaReducer(reducer) {
     switch (action.type) {
       case StoreActionTypes.REHYDRATE:
         state = Object.assign({}, state, action.payload);
+        if (state.core) {
+          state.core = Object.assign({}, state.core, {
+            route: { queryParams: {}, params: {} },
+          });
+        }
         break;
       case StoreActionTypes.REPLAY:
       default:

src/app/core/services/route.reducer.spec.ts

@@ -0,0 +1,134 @@
+import { Params } from '@angular/router';
+
+import {
+  AddParameterAction,
+  AddQueryParameterAction,
+  ResetRouteStateAction,
+  SetParameterAction,
+  SetParametersAction,
+  SetQueryParameterAction,
+  SetQueryParametersAction,
+} from './route.actions';
+import {
+  routeReducer,
+  RouteState,
+} from './route.reducer';
+
+describe('routeReducer', () => {
+  const initialState: RouteState = {
+    queryParams: {},
+    params: {},
+  };
+
+  it('should return initial state for unknown action', () => {
+    const state = routeReducer(undefined, { type: 'UNKNOWN' } as any);
+    expect(state).toEqual(initialState);
+  });
+
+  describe('RESET', () => {
+    it('should reset state to initialState', () => {
+      const state: RouteState = {
+        queryParams: { f: { author: ['Smith'] } },
+        params: { id: '123', configuration: 'default' },
+      };
+      const result = routeReducer(state, new ResetRouteStateAction());
+      expect(result).toEqual(initialState);
+    });
+  });
+
+  describe('SET_PARAMETERS', () => {
+    it('should replace all params with action payload', () => {
+      const state: RouteState = { ...initialState };
+      const payload: Params = { id: '123', configuration: 'default' };
+      const result = routeReducer(state, new SetParametersAction(payload));
+      expect(result.params).toEqual(payload);
+      expect(result.queryParams).toEqual(state.queryParams);
+    });
+
+    it('should clear params when payload is empty', () => {
+      const state: RouteState = {
+        queryParams: {},
+        params: { id: '123' },
+      };
+      const result = routeReducer(state, new SetParametersAction({}));
+      expect(result.params).toEqual({});
+      expect(result.queryParams).toEqual(state.queryParams);
+    });
+  });
+
+  describe('SET_QUERY_PARAMETERS', () => {
+    it('should replace all queryParams with action payload', () => {
+      const state: RouteState = { ...initialState };
+      const payload: Params = { 'f.author': ['Smith'], 'spc.page': '1' };
+      const result = routeReducer(state, new SetQueryParametersAction(payload));
+      expect(result.queryParams).toEqual(payload);
+      expect(result.params).toEqual(state.params);
+    });
+
+    it('should clear queryParams when payload is empty', () => {
+      const state: RouteState = {
+        queryParams: { 'f.author': ['Smith'] },
+        params: {},
+      };
+      const result = routeReducer(state, new SetQueryParametersAction({}));
+      expect(result.queryParams).toEqual({});
+      expect(result.params).toEqual(state.params);
+    });
+  });
+
+  describe('SET_PARAMETER', () => {
+    it('should set a single param key-value pair', () => {
+      const state: RouteState = {
+        queryParams: {},
+        params: { id: '123' },
+      };
+      const result = routeReducer(state, new SetParameterAction('configuration', 'default'));
+      expect(result.params).toEqual({ id: '123', configuration: 'default' });
+    });
+  });
+
+  describe('SET_QUERY_PARAMETER', () => {
+    it('should set a single query param key-value pair', () => {
+      const state: RouteState = {
+        queryParams: { 'f.author': ['Smith'] },
+        params: {},
+      };
+      const result = routeReducer(state, new SetQueryParameterAction('tab', 'publications'));
+      expect(result.queryParams).toEqual({ 'f.author': ['Smith'], tab: 'publications' });
+    });
+  });
+
+  describe('ADD_PARAMETER', () => {
+    it('should append value to existing param key', () => {
+      const state: RouteState = {
+        queryParams: {},
+        params: { tag: ['a'] },
+      };
+      const result = routeReducer(state, new AddParameterAction('tag', 'b'));
+      expect(result.params.tag).toEqual(['a', 'b']);
+    });
+
+    it('should create new param key with value array when key does not exist', () => {
+      const state: RouteState = { ...initialState };
+      const result = routeReducer(state, new AddParameterAction('tag', 'new'));
+      expect(result.params.tag).toEqual(['new']);
+    });
+  });
+
+  describe('ADD_QUERY_PARAMETER', () => {
+    it('should append value to existing query param key', () => {
+      const state: RouteState = {
+        queryParams: { 'f.author': ['Smith'] },
+        params: {},
+      };
+      const result = routeReducer(state, new AddQueryParameterAction('f.author', 'Jones'));
+      expect(result.queryParams['f.author']).toEqual(['Smith', 'Jones']);
+    });
+
+    it('should create new query param key with value array when key does not exist', () => {
+      const state: RouteState = { ...initialState };
+      const result = routeReducer(state, new AddQueryParameterAction('tag', 'new'));
+      expect(result.queryParams.tag).toEqual(['new']);
+    });
+  });
+});

src/app/core/services/route.reducer.ts

@@ -5,9 +5,7 @@ import {
   RouteActions,
   RouteActionTypes,
   SetParameterAction,
-  SetParametersAction,
-  SetQueryParameterAction,
-  SetQueryParametersAction
+  SetQueryParameterAction
 } from './route.actions';
 import { isNotEmpty } from '../../shared/empty.util';
 
@@ -38,10 +36,14 @@ export function routeReducer(state = initialState, action: RouteActions): RouteS
       return initialState;
     }
     case RouteActionTypes.SET_PARAMETERS: {
-      return setParameters(state, action as SetParametersAction, 'params');
+      return Object.assign({}, state, {
+        params: isNotEmpty(action.payload) ? action.payload : {},
+      });
     }
     case RouteActionTypes.SET_QUERY_PARAMETERS: {
-      return setParameters(state, action as SetQueryParametersAction, 'queryParams');
+      return Object.assign({}, state, {
+        queryParams: isNotEmpty(action.payload) ? action.payload : {},
+      });
     }
     case RouteActionTypes.ADD_PARAMETER: {
       return addParameter(state, action as AddParameterAction, 'params');
@@ -67,7 +69,7 @@ export function routeReducer(state = initialState, action: RouteActions): RouteS
  * @param action The add action to perform on the current state
  * @param paramType The type of parameter to add: route or query parameter
  */
-function addParameter(state: RouteState, action: AddParameterAction | AddQueryParameterAction, paramType: string): RouteState {
+function addParameter(state: RouteState, action: AddParameterAction | AddQueryParameterAction, paramType: 'params' | 'queryParams'): RouteState {
   const subState = state[paramType];
   const existingValues = subState[action.payload.key] || [];
   const newValues = [...existingValues, action.payload.value];
@@ -81,18 +83,7 @@ function addParameter(state: RouteState, action: AddParameterAction | AddQueryPa
  * @param action The set action to perform on the current state
  * @param paramType The type of parameter to set: route or query parameter
  */
-function setParameters(state: RouteState, action: SetParametersAction | SetQueryParametersAction, paramType: string): RouteState {
-  const param = isNotEmpty(action.payload) ? { [paramType]: { [action.payload.key]: action.payload.value } } : {};
-  return Object.assign({}, state, param);
-}
-
-/**
- * Set a route or query parameter in the store
- * @param state The current state
- * @param action The set action to perform on the current state
- * @param paramType The type of parameter to set: route or query parameter
- */
-function setParameter(state: RouteState, action: SetParameterAction | SetQueryParameterAction, paramType: string): RouteState {
+function setParameter(state: RouteState, action: SetParameterAction | SetQueryParameterAction, paramType: 'params' | 'queryParams'): RouteState {
   const subState = state[paramType];
   const newSubstate = Object.assign({}, subState, { [action.payload.key]: action.payload.value });
   return Object.assign({}, state, { [paramType]: newSubstate });