Merge remote-tracking branch 'origin/main' into CST-6685

Author: nikunj59

server.ts

@@ -76,6 +76,10 @@ export function app() {
    */
   const server = express();
 
+  // Tell Express to trust X-FORWARDED-* headers from proxies
+  // See https://expressjs.com/en/guide/behind-proxies.html
+  server.set('trust proxy', environment.ui.useProxies);
+
   /*
    * If production mode is enabled in the environment file:
    * - Enable Angular's production mode

src/app/community-page/edit-community-page/community-roles/community-roles.component.html

@@ -1,5 +1,5 @@
 <ds-comcol-role
-  *ngFor="let comcolRole of getComcolRoles$() | async"
+  *ngFor="let comcolRole of comcolRoles$ | async"
   [dso]="community$ | async"
   [comcolRole]="comcolRole"
 >

src/app/community-page/edit-community-page/community-roles/community-roles.component.spec.ts

@@ -78,8 +78,9 @@ describe('CommunityRolesComponent', () => {
     fixture.detectChanges();
   });
 
-  it('should display a community admin role component', () => {
+  it('should display a community admin role component', (done) => {
     expect(de.query(By.css('ds-comcol-role .community-admin')))
       .toBeTruthy();
+    done();
   });
 });

src/app/community-page/edit-community-page/community-roles/community-roles.component.ts

@@ -19,28 +19,14 @@ export class CommunityRolesComponent implements OnInit {
   dsoRD$: Observable<RemoteData<Community>>;
 
   /**
-   * The community to manage, as an observable.
+   * The different roles for the community, as an observable.
    */
-  get community$(): Observable<Community> {
-    return this.dsoRD$.pipe(
-      getFirstSucceededRemoteData(),
-      getRemoteDataPayload(),
-    );
-  }
+  comcolRoles$: Observable<HALLink[]>;
 
   /**
-   * The different roles for the community.
+   * The community to manage, as an observable.
    */
-  getComcolRoles$(): Observable<HALLink[]> {
-    return this.community$.pipe(
-      map((community) => [
-        {
-          name: 'community-admin',
-          href: community._links.adminGroup.href,
-        },
-      ]),
-    );
-  }
+  community$: Observable<Community>;
 
   constructor(
     protected route: ActivatedRoute,
@@ -52,5 +38,22 @@ export class CommunityRolesComponent implements OnInit {
       first(),
       map((data) => data.dso),
     );
+
+    this.community$ = this.dsoRD$.pipe(
+      getFirstSucceededRemoteData(),
+      getRemoteDataPayload(),
+    );
+
+    /**
+     * The different roles for the community.
+     */
+    this.comcolRoles$ = this.community$.pipe(
+      map((community) => [
+        {
+          name: 'community-admin',
+          href: community._links.adminGroup.href,
+        },
+      ]),
+    );
   }
 }

src/app/core/cache/object-cache.actions.ts

@@ -13,7 +13,9 @@ export const ObjectCacheActionTypes = {
   REMOVE: type('dspace/core/cache/object/REMOVE'),
   RESET_TIMESTAMPS: type('dspace/core/cache/object/RESET_TIMESTAMPS'),
   ADD_PATCH: type('dspace/core/cache/object/ADD_PATCH'),
-  APPLY_PATCH: type('dspace/core/cache/object/APPLY_PATCH')
+  APPLY_PATCH: type('dspace/core/cache/object/APPLY_PATCH'),
+  ADD_DEPENDENTS: type('dspace/core/cache/object/ADD_DEPENDENTS'),
+  REMOVE_DEPENDENTS: type('dspace/core/cache/object/REMOVE_DEPENDENTS')
 };
 
 /**
@@ -126,13 +128,55 @@ export class ApplyPatchObjectCacheAction implements Action {
   }
 }
 
+/**
+ * An NgRx action to add dependent request UUIDs to a cached object
+ */
+export class AddDependentsObjectCacheAction implements Action {
+  type = ObjectCacheActionTypes.ADD_DEPENDENTS;
+  payload: {
+    href: string;
+    dependentRequestUUIDs: string[];
+  };
+
+  /**
+   * Create a new AddDependentsObjectCacheAction
+   *
+   * @param href                  the self link of a cached object
+   * @param dependentRequestUUIDs the UUID of the request that depends on this object
+   */
+  constructor(href: string, dependentRequestUUIDs: string[]) {
+    this.payload = {
+      href,
+      dependentRequestUUIDs,
+    };
+  }
+}
+
+/**
+ * An NgRx action to remove all dependent request UUIDs from a cached object
+ */
+export class RemoveDependentsObjectCacheAction implements Action {
+  type = ObjectCacheActionTypes.REMOVE_DEPENDENTS;
+  payload: string;
+
+  /**
+   * Create a new RemoveDependentsObjectCacheAction
+   *
+   * @param href  the self link of a cached object for which to remove all dependent request UUIDs
+   */
+  constructor(href: string) {
+    this.payload = href;
+  }
+}
 
 /**
  * A type to encompass all ObjectCacheActions
  */
 export type ObjectCacheAction
   = AddToObjectCacheAction
-  | RemoveFromObjectCacheAction
-  | ResetObjectCacheTimestampsAction
-  | AddPatchObjectCacheAction
-  | ApplyPatchObjectCacheAction;
+    | RemoveFromObjectCacheAction
+    | ResetObjectCacheTimestampsAction
+    | AddPatchObjectCacheAction
+    | ApplyPatchObjectCacheAction
+    | AddDependentsObjectCacheAction
+    | RemoveDependentsObjectCacheAction;

src/app/core/cache/object-cache.reducer.spec.ts

@@ -2,11 +2,13 @@ import * as deepFreeze from 'deep-freeze';
 import { Operation } from 'fast-json-patch';
 import { Item } from '../shared/item.model';
 import {
+  AddDependentsObjectCacheAction,
   AddPatchObjectCacheAction,
   AddToObjectCacheAction,
   ApplyPatchObjectCacheAction,
+  RemoveDependentsObjectCacheAction,
   RemoveFromObjectCacheAction,
-  ResetObjectCacheTimestampsAction
+  ResetObjectCacheTimestampsAction,
 } from './object-cache.actions';
 
 import { objectCacheReducer } from './object-cache.reducer';
@@ -42,20 +44,22 @@ describe('objectCacheReducer', () => {
       timeCompleted: new Date().getTime(),
       msToLive: 900000,
       requestUUIDs: [requestUUID1],
+      dependentRequestUUIDs: [],
       patches: [],
       isDirty: false,
     },
     [selfLink2]: {
       data: {
         type: Item.type,
-        self: requestUUID2,
+        self: selfLink2,
         foo: 'baz',
-        _links: { self: { href: requestUUID2 } }
+        _links: { self: { href: selfLink2 } }
       },
       alternativeLinks: [altLink3, altLink4],
       timeCompleted: new Date().getTime(),
       msToLive: 900000,
-      requestUUIDs: [selfLink2],
+      requestUUIDs: [requestUUID2],
+      dependentRequestUUIDs: [requestUUID1],
       patches: [],
       isDirty: false
     }
@@ -189,4 +193,20 @@ describe('objectCacheReducer', () => {
     expect((newState[selfLink1].data as any).name).toEqual(newName);
   });
 
+  it('should add dependent requests on ADD_DEPENDENTS', () => {
+    let newState = objectCacheReducer(testState, new AddDependentsObjectCacheAction(selfLink1, ['new', 'newer', 'newest']));
+    expect(newState[selfLink1].dependentRequestUUIDs).toEqual(['new', 'newer', 'newest']);
+
+    newState = objectCacheReducer(newState, new AddDependentsObjectCacheAction(selfLink2, ['more']));
+    expect(newState[selfLink2].dependentRequestUUIDs).toEqual([requestUUID1, 'more']);
+  });
+
+  it('should clear dependent requests on REMOVE_DEPENDENTS', () => {
+    let newState = objectCacheReducer(testState, new RemoveDependentsObjectCacheAction(selfLink1));
+    expect(newState[selfLink1].dependentRequestUUIDs).toEqual([]);
+
+    newState = objectCacheReducer(newState, new RemoveDependentsObjectCacheAction(selfLink2));
+    expect(newState[selfLink2].dependentRequestUUIDs).toEqual([]);
+  });
+
 });

src/app/core/cache/object-cache.reducer.ts

@@ -1,12 +1,13 @@
 /* eslint-disable max-classes-per-file */
 import {
+  AddDependentsObjectCacheAction,
   AddPatchObjectCacheAction,
   AddToObjectCacheAction,
   ApplyPatchObjectCacheAction,
   ObjectCacheAction,
-  ObjectCacheActionTypes,
+  ObjectCacheActionTypes, RemoveDependentsObjectCacheAction,
   RemoveFromObjectCacheAction,
-  ResetObjectCacheTimestampsAction
+  ResetObjectCacheTimestampsAction,
 } from './object-cache.actions';
 import { hasValue, isNotEmpty } from '../../shared/empty.util';
 import { CacheEntry } from './cache-entry';
@@ -69,6 +70,12 @@ export class ObjectCacheEntry implements CacheEntry {
    */
   requestUUIDs: string[];
 
+  /**
+   * A list of UUIDs for the requests that depend on this object.
+   * When this object is invalidated, these requests will be invalidated as well.
+   */
+  dependentRequestUUIDs: string[];
+
   /**
    * An array of patches that were made on the client side to this entry, but haven't been sent to the server yet
    */
@@ -134,6 +141,14 @@ export function objectCacheReducer(state = initialState, action: ObjectCacheActi
       return applyPatchObjectCache(state, action as ApplyPatchObjectCacheAction);
     }
 
+    case ObjectCacheActionTypes.ADD_DEPENDENTS: {
+      return addDependentsObjectCacheState(state, action as AddDependentsObjectCacheAction);
+    }
+
+    case ObjectCacheActionTypes.REMOVE_DEPENDENTS: {
+      return removeDependentsObjectCacheState(state, action as RemoveDependentsObjectCacheAction);
+    }
+
     default: {
       return state;
     }
@@ -159,6 +174,7 @@ function addToObjectCache(state: ObjectCacheState, action: AddToObjectCacheActio
       timeCompleted: action.payload.timeCompleted,
       msToLive: action.payload.msToLive,
       requestUUIDs: [action.payload.requestUUID, ...(existing.requestUUIDs || [])],
+      dependentRequestUUIDs: existing.dependentRequestUUIDs || [],
       isDirty: isNotEmpty(existing.patches),
       patches: existing.patches || [],
       alternativeLinks: [...(existing.alternativeLinks || []), ...newAltLinks]
@@ -252,3 +268,49 @@ function applyPatchObjectCache(state: ObjectCacheState, action: ApplyPatchObject
   }
   return newState;
 }
+
+/**
+ * Add a list of dependent request UUIDs to a cached object, used when defining new dependencies
+ *
+ * @param state   the current state
+ * @param action  an AddDependentsObjectCacheAction
+ * @return        the new state, with the dependent requests of the cached object updated
+ */
+function addDependentsObjectCacheState(state: ObjectCacheState, action: AddDependentsObjectCacheAction): ObjectCacheState {
+  const href = action.payload.href;
+  const newState = Object.assign({}, state);
+
+  if (hasValue(newState[href])) {
+    newState[href] = Object.assign({}, newState[href], {
+      dependentRequestUUIDs: [
+        ...new Set([
+          ...newState[href]?.dependentRequestUUIDs || [],
+          ...action.payload.dependentRequestUUIDs,
+        ])
+      ]
+    });
+  }
+
+  return newState;
+}
+
+
+/**
+ * Remove all dependent request UUIDs from a cached object, used to clear out-of-date depedencies
+ *
+ * @param state   the current state
+ * @param action  an AddDependentsObjectCacheAction
+ * @return        the new state, with the dependent requests of the cached object updated
+ */
+function removeDependentsObjectCacheState(state: ObjectCacheState, action: RemoveDependentsObjectCacheAction): ObjectCacheState {
+  const href = action.payload;
+  const newState = Object.assign({}, state);
+
+  if (hasValue(newState[href])) {
+    newState[href] = Object.assign({}, newState[href], {
+      dependentRequestUUIDs: []
+    });
+  }
+
+  return newState;
+}