Fix cache invalidation issues pt. 2

Old Bitstream UUID is not guaranteed to exist
We also have to invalidate the parent Item in order to refresh derived Bundle lists

Drop /replace URL from history after successful upload (won't be accessible anymore)

Author: ybnd

src/app/bitstream-page/replace-bitstream-page/replace-bitstream-page.component.spec.ts

@@ -16,12 +16,15 @@ import {
   Router,
 } from '@angular/router';
 import { AuthService } from '@dspace/core/auth/auth.service';
+import { LinkService } from '@dspace/core/cache/builders/link.service';
 import { RequestService } from '@dspace/core/data/request.service';
 import { LocaleService } from '@dspace/core/locale/locale.service';
 import { NotificationsService } from '@dspace/core/notification-system/notifications.service';
 import { Bitstream } from '@dspace/core/shared/bitstream.model';
 import { Bundle } from '@dspace/core/shared/bundle.model';
+import { Item } from '@dspace/core/shared/item.model';
 import { AuthServiceStub } from '@dspace/core/testing/auth-service.stub';
+import { getMockLinkService } from '@dspace/core/testing/link-service.mock';
 import { NotificationsServiceStub } from '@dspace/core/testing/notifications-service.stub';
 import { RouterStub } from '@dspace/core/testing/router.stub';
 import {
@@ -42,22 +45,44 @@ describe('ReplaceBitstreamPageComponent', () => {
   let fixture: ComponentFixture<ReplaceBitstreamPageComponent>;
   const locationObject = jasmine.createSpyObj('location', ['back']);
   let notificationsService;
-  const bitstreamSelfLink = 'bitstreams/123';
+  const oldBitstreamSelfLink = 'bitstreams/123';
+  const itemSelfLink = 'items/789';
+  const item = Object.assign(new Item(), {
+    _links: {
+      self: { href: itemSelfLink },
+    },
+  });
   const bundleSelfLink = 'bundles/456';
   const bundle = Object.assign(new Bundle(), {
     _links: {
       self: { href: bundleSelfLink },
     },
+    item: createSuccessfulRemoteDataObject$(item),
   });
-  const bitstream = Object.assign(new Bitstream(), {
+  const oldBitstream = Object.assign(new Bitstream(), {
     id: '123',
     _links: {
-      self: { href: bitstreamSelfLink },
+      self: { href: oldBitstreamSelfLink },
       bundle: { href: 'bitstreams/123/bundle' },
     },
     bundle: createSuccessfulRemoteDataObject$(bundle),
   });
-  const route = { data: of({ bitstream: createSuccessfulRemoteDataObject(bitstream) }) };
+  const newBitstream = Object.assign(new Bitstream(), {
+    id: '124',
+    metadata: {
+      ['dspace.bitstream.isReplacementOf']: [
+        {
+          authority: oldBitstream.id,
+        },
+      ],
+    },
+    _links: {
+      self: { href: oldBitstreamSelfLink },
+      bundle: { href: 'bitstreams/124/bundle' },
+    },
+    bundle: createSuccessfulRemoteDataObject$(bundle),
+  });
+  const route = { data: of({ bitstream: createSuccessfulRemoteDataObject(oldBitstream) }) };
   const requestService = jasmine.createSpyObj('requestService', ['setStaleByHrefSubstring']);
   const router = new RouterStub();
   let localeService;
@@ -82,6 +107,7 @@ describe('ReplaceBitstreamPageComponent', () => {
         { provide: Router, useValue: router },
         { provide: RequestService, useValue: requestService },
         { provide: LocaleService, useValue: mockLocaleService },
+        { provide: LinkService, useValue: getMockLinkService() },
       ],
     }).overrideComponent(ReplaceBitstreamPageComponent, {
       remove: { imports: [UploaderComponent] },
@@ -133,12 +159,13 @@ describe('ReplaceBitstreamPageComponent', () => {
 
   describe('calling onCompleteItem', () => {
     beforeEach(() => {
-      component.onCompleteItem(bitstream);
+      component.onCompleteItem(newBitstream);
     });
 
     it('should set the bitstream and bundle to stale in the cache', () => {
-      expect(requestService.setStaleByHrefSubstring).toHaveBeenCalledWith(bitstreamSelfLink);
+      expect(requestService.setStaleByHrefSubstring).toHaveBeenCalledWith(oldBitstream.id);
       expect(requestService.setStaleByHrefSubstring).toHaveBeenCalledWith(bundleSelfLink);
+      expect(requestService.setStaleByHrefSubstring).toHaveBeenCalledWith(itemSelfLink);
     });
 
     it('should fire a success notification', () => {

src/app/bitstream-page/replace-bitstream-page/replace-bitstream-page.component.ts

@@ -12,8 +12,12 @@ import {
   Router,
 } from '@angular/router';
 import { RestRequestMethod } from '@dspace/config/rest-request-method';
+import { LinkService } from '@dspace/core/cache/builders/link.service';
 import { NotificationsService } from '@dspace/core/notification-system/notifications.service';
 import { getBitstreamModuleRoute } from '@dspace/core/router/core-routing-paths';
+import { Bundle } from '@dspace/core/shared/bundle.model';
+import { followLink } from '@dspace/core/shared/follow-link-config.model';
+import { Item } from '@dspace/core/shared/item.model';
 import {
   hasValue,
   isEmpty,
@@ -91,12 +95,6 @@ export class ReplaceBitstreamPageComponent implements OnInit {
    */
   private uploadFilesUrlNoParam: string;
 
-  /**
-   * The bundle's self link, resolved from the route-resolved bitstream for cache invalidation.
-   * This is the bundle's own URL (e.g. bundles/{uuid}), not the bitstream-to-bundle link.
-   */
-  private bundleSelfLink: string;
-
   /**
    * The bitstream's remote data observable
    * Tracks changes and updates the view
@@ -108,19 +106,21 @@ export class ReplaceBitstreamPageComponent implements OnInit {
    */
   protected shouldReplaceName = true;
 
-  constructor(private route: ActivatedRoute,
-              private notificationService: NotificationsService,
-              private location: Location,
-              private translateService: TranslateService,
-              private authService: AuthService,
-              private requestService: RequestService,
-              private router: Router) {
+  constructor(
+    private route: ActivatedRoute,
+    private notificationService: NotificationsService,
+    private location: Location,
+    private translateService: TranslateService,
+    private authService: AuthService,
+    private requestService: RequestService,
+    private router: Router,
+    private linkService: LinkService,
+  ) {
   }
 
   ngOnInit(): void {
     this.bitstreamRD$ = this.route.data.pipe(map((data) => data.bitstream));
     this.setUploadUrl();
-    this.resolveBundleLink();
   }
 
   back() {
@@ -137,10 +137,11 @@ export class ReplaceBitstreamPageComponent implements OnInit {
    * @param bitstream
    */
   public onCompleteItem(bitstream: Bitstream) {
-    this.requestService.setStaleByHrefSubstring(bitstream.self);
-    this.requestService.setStaleByHrefSubstring(this.bundleSelfLink);
+    this.invalidate(bitstream);
     this.notificationService.success(this.translateService.instant(this.saveNotificationKey));
-    this.router.navigate([getBitstreamModuleRoute(), bitstream.id, 'edit']);
+    this.router.navigate([getBitstreamModuleRoute(), bitstream.id, 'edit'], {
+      replaceUrl: true,
+    });
   }
 
   /**
@@ -167,17 +168,25 @@ export class ReplaceBitstreamPageComponent implements OnInit {
   }
 
   /**
-   * Resolve the bundle from the route-resolved bitstream to store its self URL.
-   * The bundle's self URL (bundles/{uuid}) is needed for cache invalidation because it is a
-   * substring of the bundle's bitstreams list endpoint (bundles/{uuid}/bitstreams).
+   * Invalidate the old Bitstream that has been replaced (and thus deleted), as well as our owning Bundle and Item
    */
-  private resolveBundleLink() {
-    this.bitstreamRD$.pipe(
+  private invalidate(newBitstream: Bitstream) {
+    console.log(newBitstream); // todo: remove this
+    // the Bitstream returned after upload is not an instance of Bitstream yet
+    newBitstream = Object.assign(new Bitstream(), newBitstream)
+    this.linkService.resolveLink<Bitstream>(newBitstream, followLink('bundle'));
+    this.requestService.setStaleByHrefSubstring(newBitstream.firstMetadata('dspace.bitstream.isReplacementOf')?.authority);
+
+    newBitstream.bundle.pipe(
       getFirstSucceededRemoteDataPayload(),
-      switchMap((bitstream: Bitstream) => bitstream.bundle),
+      switchMap((bundle: Bundle) => {
+        this.requestService.setStaleByHrefSubstring(bundle.self);
+        this.linkService.resolveLink<Bundle>(bundle, followLink('item'));
+        return bundle.item;
+      }),
       getFirstSucceededRemoteDataPayload(),
-    ).subscribe((bundle) => {
-      this.bundleSelfLink = bundle._links.self.href;
+    ).subscribe((item: Item) => {
+      this.requestService.setStaleByHrefSubstring(item.self);
     });
   }