Port #1280 to dtq-dev-9-base: Refresh file listings on breadcrumb navigation after bitstream upload (#1498)

ADAPT completion of the #1280 port. The v9 squash carried 3 of the 9 files
(clarin-files-section, preview-section runtime, and nothing else); the other six
are byte-identical with vanilla dspace-9.3 on the base, i.e. the fork hunks were
never applied. Without them the cache invalidation that did land is inert: the
item resolver still asks for a cached item and never re-requests a stale one, so
a file uploaded or deleted is not visible until a hard refresh.

Only the missing hunks are applied here; clarin-files-section.component.ts and
preview-section.component.ts are verified line by line as already complete and
are not touched.

- item.resolver.ts: findById(..., useCachedVersionIfAvailable=true,
  reRequestOnStale=false -> true). This is the load-bearing hunk - every
  setStaleByHrefSubstring below does nothing without it.
- upload-bitstream.component.ts onCompleteItem: removeByHrefSubstring ->
  five setStaleByHrefSubstring calls (bundle bitstreams endpoint, item bundles
  endpoint, item self link, and metadatabitstreams/search/byHandle in both the
  encoded and the raw handle form).
- item-bitstreams.component.ts submit(): the same invalidation after a delete.
- bitstream-breadcrumbs.service.ts: hasValue(bitstream.bundle) /
  hasValue(bundle.item) guards, so a stale re-request that resolves an
  incomplete bitstream cannot throw in the breadcrumb resolver.
- edit-bitstream-page.component.ts: the ngOnInit guards (bundle$,
  primaryBitstream$, item$, format$ each fall back to of(undefined); the
  combineLatest subscriber only assigns what it actually received) and
  setIiifStatus operating on its bitstream argument behind a null guard.
- upload-bitstream.component.spec.ts: +5 tests, getBundlesEndpoint stub,
  mockItem._links.self, removeByHrefSubstring -> setStaleByHrefSubstring spy.
- preview-section.component.spec.ts: restored (dropped whole by the squash),
  converted to a standalone TestBed.

v9 notes:
- rxjs `of` instead of the fork's `observableOf` alias (eslint
  dspace-angular-ts/alias-imports).
- item.resolver.ts is a functional ResolveFn on v9; the flip is the same
  positional argument.
- item-bitstreams.component.ts already imports hasValue, so the source's import
  hunk is a no-op here.
- The vanilla-9 onSubmit() bundle$/combineLatest([bundle$, bitstream$]) save
  path is deliberately untouched - it is a different local bundle$.
- preview-section.component.spec.ts: declarations -> imports:[PreviewSectionComponent],
  trailing commas and simple-import-sort order for the v9 eslint config. The three
  assertions are the fork's, unchanged.

Card PB-01 (tranche T3).

Source: 3a219e4 (dtq-dev PR #1280)

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: milanmajchrak

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

@@ -476,23 +476,38 @@ export class EditBitstreamPageComponent implements OnInit, OnDestroy {
     );
 
     const bundle$ = bitstream$.pipe(
-      switchMap((bitstream: Bitstream) => bitstream.bundle),
-      getFirstSucceededRemoteDataPayload(),
+      switchMap((bitstream: Bitstream) => {
+        if (hasValue(bitstream) && hasValue(bitstream.bundle)) {
+          return bitstream.bundle.pipe(getFirstSucceededRemoteDataPayload());
+        }
+        return of(undefined);
+      }),
     );
 
     const primaryBitstream$ = bundle$.pipe(
-      hasValueOperator(),
-      switchMap((bundle: Bundle) => this.bitstreamService.findByHref(bundle._links.primaryBitstream.href)),
-      getFirstSucceededRemoteDataPayload(),
+      switchMap((bundle: Bundle) => {
+        if (hasValue(bundle) && hasValue(bundle._links) && hasValue(bundle._links.primaryBitstream) && hasValue(bundle._links.primaryBitstream.href)) {
+          return this.bitstreamService.findByHref(bundle._links.primaryBitstream.href).pipe(getFirstSucceededRemoteDataPayload());
+        }
+        return of(undefined);
+      }),
     );
 
     const item$ = bundle$.pipe(
-      switchMap((bundle: Bundle) => bundle.item),
-      getFirstSucceededRemoteDataPayload(),
+      switchMap((bundle: Bundle) => {
+        if (hasValue(bundle) && hasValue(bundle.item)) {
+          return bundle.item.pipe(getFirstSucceededRemoteDataPayload());
+        }
+        return of(undefined);
+      }),
     );
     const format$ = bitstream$.pipe(
-      switchMap(bitstream => bitstream.format),
-      getFirstSucceededRemoteDataPayload(),
+      switchMap((bitstream: Bitstream) => {
+        if (hasValue(bitstream) && hasValue(bitstream.format)) {
+          return bitstream.format.pipe(getFirstSucceededRemoteDataPayload());
+        }
+        return of(undefined);
+      }),
     );
 
     this.subs.push(
@@ -505,15 +520,23 @@ export class EditBitstreamPageComponent implements OnInit, OnDestroy {
       ).subscribe(([bitstream, bundle, primaryBitstream, item, format]) => {
         this.bitstream = bitstream as Bitstream;
         this.bundle = bundle;
-        this.selectedFormat = format;
+        if (hasValue(format)) {
+          this.selectedFormat = format;
+        }
         // hasValue(primaryBitstream) because if there's no primaryBitstream on the bundle it will
         // be a success response, but empty
         this.primaryBitstreamUUID = hasValue(primaryBitstream) ? primaryBitstream.uuid : null;
-        this.itemId = item.uuid;
+        if (hasValue(item)) {
+          this.itemId = item.uuid;
+        }
         this.setIiifStatus(this.bitstream);
       }),
       format$.pipe(take(1)).subscribe(
-        (format) => this.originalFormat = format,
+        (format) => {
+          if (hasValue(format)) {
+            this.originalFormat = format;
+          }
+        },
       ),
     );
 
@@ -788,26 +811,38 @@ export class EditBitstreamPageComponent implements OnInit, OnDestroy {
    */
   setIiifStatus(bitstream: Bitstream) {
 
+    if (!hasValue(bitstream) || !hasValue(bitstream.bundle) || !hasValue(bitstream.format)) {
+      this.isIIIF = false;
+      return;
+    }
+
     const regexExcludeBundles = /OTHERCONTENT|THUMBNAIL|LICENSE/;
     const regexIIIFItem = /true|yes/i;
 
-    const isImage$ = this.bitstream.format.pipe(
+    const isImage$ = bitstream.format.pipe(
       getFirstSucceededRemoteData(),
       map((format: RemoteData<BitstreamFormat>) => format.payload.mimetype.includes('image/')));
 
-    const isIIIFBundle$ = this.bitstream.bundle.pipe(
+    const isIIIFBundle$ = bitstream.bundle.pipe(
       getFirstSucceededRemoteData(),
       map((bundle: RemoteData<Bundle>) =>
         this.dsoNameService.getName(bundle.payload).match(regexExcludeBundles) == null));
 
-    const isEnabled$ = this.bitstream.bundle.pipe(
-      getFirstSucceededRemoteData(),
-      map((bundle: RemoteData<Bundle>) => bundle.payload.item.pipe(
-        getFirstSucceededRemoteData(),
-        map((item: RemoteData<Item>) =>
-          (item.payload.firstMetadataValue('dspace.iiif.enabled') &&
-            item.payload.firstMetadataValue('dspace.iiif.enabled').match(regexIIIFItem) !== null),
-        ))));
+    const isEnabled$ = bitstream.bundle.pipe(
+      getFirstSucceededRemoteDataPayload(),
+      switchMap((bundle: Bundle) => {
+        if (hasValue(bundle) && hasValue(bundle.item)) {
+          return bundle.item.pipe(
+            getFirstSucceededRemoteDataPayload(),
+            map((item: Item) => {
+              const iiifEnabledValue = item.firstMetadataValue('dspace.iiif.enabled');
+              return hasValue(iiifEnabledValue) && iiifEnabledValue.match(regexIIIFItem) !== null;
+            }),
+          );
+        }
+        return of(false);
+      }),
+    );
 
     const iiifSub = combineLatest(
       isImage$,

src/app/core/breadcrumbs/bitstream-breadcrumbs.service.ts

@@ -73,12 +73,12 @@ export class BitstreamBreadcrumbsService extends DSOBreadcrumbsService {
       getFirstCompletedRemoteData(),
       getRemoteDataPayload(),
       switchMap((bitstream: Bitstream) => {
-        if (hasValue(bitstream)) {
+        if (hasValue(bitstream) && hasValue(bitstream.bundle)) {
           return bitstream.bundle.pipe(
             getFirstCompletedRemoteData(),
             getRemoteDataPayload(),
             switchMap((bundle: Bundle) => {
-              if (hasValue(bundle)) {
+              if (hasValue(bundle) && hasValue(bundle.item)) {
                 return bundle.item.pipe(
                   getFirstCompletedRemoteData(),
                 );

src/app/item-page/bitstreams/upload/upload-bitstream.component.spec.ts

@@ -80,6 +80,11 @@ describe('UploadBitstreamComponent', () => {
   const mockItem = Object.assign(new Item(), {
     id: 'fake-id',
     handle: 'fake/handle',
+    _links: {
+      self: {
+        href: '/api/core/items/fake-id',
+      },
+    },
     metadata: {
       'dc.title': [
         {
@@ -96,6 +101,7 @@ describe('UploadBitstreamComponent', () => {
   const restEndpoint = 'fake-rest-endpoint';
   const mockItemDataService = jasmine.createSpyObj('mockItemDataService', {
     getBitstreamsEndpoint: of(restEndpoint),
+    getBundlesEndpoint: of('/api/core/items/fake-id/bundles'),
     createBundle: createSuccessfulRemoteDataObject$(createdBundle),
     getBundles: createSuccessfulRemoteDataObject$(buildPaginatedList(new PageInfo(), [bundle])),
   });
@@ -110,7 +116,7 @@ describe('UploadBitstreamComponent', () => {
   const notificationsServiceStub = new NotificationsServiceStub();
   const uploaderComponent = jasmine.createSpyObj('uploaderComponent', ['ngOnInit', 'ngAfterViewInit']);
   const requestService = jasmine.createSpyObj('requestService', {
-    removeByHrefSubstring: {},
+    setStaleByHrefSubstring: {},
   });
 
   describe('when a file is uploaded', () => {
@@ -144,6 +150,28 @@ describe('UploadBitstreamComponent', () => {
       it('should navigate the user to the next page', () => {
         expect(routerStub.navigate).toHaveBeenCalled();
       });
+
+      it('should clear cached requests for the selected bundle bitstreams endpoint', () => {
+        expect(requestService.setStaleByHrefSubstring).toHaveBeenCalledWith(restEndpoint);
+      });
+
+      it('should clear cached requests for the item bundles endpoint', () => {
+        expect(requestService.setStaleByHrefSubstring).toHaveBeenCalledWith('/api/core/items/fake-id/bundles');
+      });
+
+      it('should clear cached requests for the item self endpoint', () => {
+        expect(requestService.setStaleByHrefSubstring).toHaveBeenCalledWith('/api/core/items/fake-id');
+      });
+
+      it('should clear cached requests for the metadatabitstreams byHandle endpoint with encoded handle', () => {
+        expect(requestService.setStaleByHrefSubstring)
+          .toHaveBeenCalledWith('/api/core/metadatabitstreams/search/byHandle?handle=fake%2Fhandle&fileGrpType=ORIGINAL');
+      });
+
+      it('should clear cached requests for the metadatabitstreams byHandle endpoint with raw handle', () => {
+        expect(requestService.setStaleByHrefSubstring)
+          .toHaveBeenCalledWith('/api/core/metadatabitstreams/search/byHandle?handle=fake/handle&fileGrpType=ORIGINAL');
+      });
     });
   });
 

src/app/item-page/bitstreams/upload/upload-bitstream.component.ts

@@ -248,7 +248,28 @@ export class UploadBitstreamComponent implements OnInit, OnDestroy {
   public onCompleteItem(bitstream) {
     // Clear cached requests for this bundle's bitstreams to ensure lists on all pages are up-to-date
     this.bundleService.getBitstreamsEndpoint(this.selectedBundleId).pipe(take(1)).subscribe((href: string) => {
-      this.requestService.removeByHrefSubstring(href);
+      this.requestService.setStaleByHrefSubstring(href);
+    });
+
+    // Clear cached requests for this item's bundles to ensure bundle resolution uses fresh data
+    this.itemService.getBundlesEndpoint(this.itemId).pipe(take(1)).subscribe((href: string) => {
+      this.requestService.setStaleByHrefSubstring(href);
+    });
+
+    // Clear cached requests for this item to ensure breadcrumb navigation resolves a fresh item
+    this.itemRD$.pipe(
+      getFirstSucceededRemoteDataPayload(),
+      take(1),
+    ).subscribe((item: Item) => {
+      this.requestService.setStaleByHrefSubstring(item._links.self.href);
+
+      // Clear metadatabitstreams search cache used by preview and CLARIN files sections
+      if (item?.handle) {
+        const byHandleBase = '/api/core/metadatabitstreams/search/byHandle';
+        const encodedHandle = encodeURIComponent(item.handle);
+        this.requestService.setStaleByHrefSubstring(`${byHandleBase}?handle=${encodedHandle}&fileGrpType=ORIGINAL`);
+        this.requestService.setStaleByHrefSubstring(`${byHandleBase}?handle=${item.handle}&fileGrpType=ORIGINAL`);
+      }
     });
 
     // Bring over the item ID as a query parameter

src/app/item-page/edit-item-page/item-bitstreams/item-bitstreams.component.ts

@@ -274,6 +274,24 @@ export class ItemBitstreamsComponent extends AbstractItemUpdateComponent impleme
     removedResponses$.subscribe((responses: RemoteData<NoContent>) => {
       this.itemBitstreamsService.displayNotifications('item.edit.bitstreams.notifications.remove', [responses]);
       this.submitting = false;
+
+      // Clear caches to ensure file lists are refreshed after bitstream removal (same as upload)
+      this.bundles$.pipe(take(1)).subscribe((bundles: Bundle[]) => {
+        if (!hasValue(bundles)) { return; }
+        bundles.forEach((bundle: Bundle) => {
+          if (bundle?._links?.bitstreams?.href) {
+            this.requestService.setStaleByHrefSubstring(bundle._links.bitstreams.href);
+          }
+        });
+      });
+
+      // Clear metadatabitstreams search cache used by preview and CLARIN files sections
+      if (this.item?.handle) {
+        const byHandleBase = '/api/core/metadatabitstreams/search/byHandle';
+        const encodedHandle = encodeURIComponent(this.item.handle);
+        this.requestService.setStaleByHrefSubstring(`${byHandleBase}?handle=${encodedHandle}&fileGrpType=ORIGINAL`);
+        this.requestService.setStaleByHrefSubstring(`${byHandleBase}?handle=${this.item.handle}&fileGrpType=ORIGINAL`);
+      }
     });
   }
 

src/app/item-page/item.resolver.ts

@@ -48,7 +48,7 @@ export const itemResolver: ResolveFn<RemoteData<Item>> = (
   const itemRD$ = itemService.findById(
     route.params.id,
     true,
-    false,
+    true,
     ...getItemPageLinksToFollow(),
   ).pipe(
     getFirstCompletedRemoteData(),

src/app/item-page/simple/field-components/preview-section/preview-section.component.spec.ts

@@ -0,0 +1,103 @@
+import { SimpleChange } from '@angular/core';
+import {
+  ComponentFixture,
+  TestBed,
+} from '@angular/core/testing';
+import {
+  TranslateLoader,
+  TranslateModule,
+} from '@ngx-translate/core';
+import {
+  BehaviorSubject,
+  of,
+} from 'rxjs';
+import { MetadataBitstream } from 'src/app/core/metadata/metadata-bitstream.model';
+import { RegistryService } from 'src/app/core/registry/registry.service';
+import { HALLink } from 'src/app/core/shared/hal-link.model';
+import { Item } from 'src/app/core/shared/item.model';
+import { ResourceType } from 'src/app/core/shared/resource-type';
+
+import { ConfigurationDataService } from '../../../../core/data/configuration-data.service';
+import { TranslateLoaderMock } from '../../../../shared/mocks/translate-loader.mock';
+import { PreviewSectionComponent } from './preview-section.component';
+
+describe('PreviewSectionComponent', () => {
+  let component: PreviewSectionComponent;
+  let fixture: ComponentFixture<PreviewSectionComponent>;
+  let mockRegistryService: any;
+  let mockConfigService: any;
+
+  beforeEach(async () => {
+    mockConfigService = jasmine.createSpyObj(['findByPropertyName']);
+    mockRegistryService = jasmine.createSpyObj('RegistryService', [
+      'getMetadataBitstream',
+    ]);
+
+    await TestBed.configureTestingModule({
+      imports: [
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useClass: TranslateLoaderMock,
+          },
+        }),
+        PreviewSectionComponent,
+      ],
+      providers: [
+        { provide: RegistryService, useValue: mockRegistryService },
+        { provide: ConfigurationDataService, useValue: mockConfigService }],
+    }).compileComponents();
+  });
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(PreviewSectionComponent);
+    component = fixture.componentInstance;
+
+    // Set up the mock service's getMetadataBitstream method to return a simple stream
+    const metadatabitstream = new MetadataBitstream();
+    metadatabitstream.id = '5974f1cf-f2ef-4e4c-8f6d-85ad6c52efde';
+    metadatabitstream.name = 'test';
+    metadatabitstream.description = 'test';
+    metadatabitstream.fileSize = 1024;
+    metadatabitstream.checksum = 'abc';
+    metadatabitstream.type = new ResourceType('item');
+    metadatabitstream.fileInfo = [];
+    metadatabitstream.format = 'text';
+    metadatabitstream.canPreview = false;
+    metadatabitstream._links = {
+      self: new HALLink(),
+      schema: new HALLink(),
+    };
+
+    metadatabitstream._links.self.href = '';
+    metadatabitstream._links.schema.href = '';
+    const metadataBitstreams: MetadataBitstream[] = [metadatabitstream];
+    const bitstreamStream = new BehaviorSubject(metadataBitstreams);
+    mockRegistryService.getMetadataBitstream.and.returnValue(
+      of(bitstreamStream),
+    );
+
+    component.item = new Item();
+    component.item.handle = '12345';
+
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+
+  it('should call getMetadataBitstream on item input change', () => {
+    component.ngOnChanges({
+      item: new SimpleChange(undefined, component.item, true),
+    });
+    expect(mockRegistryService.getMetadataBitstream).toHaveBeenCalled();
+  });
+
+  it('should set listOfFiles on init', (done) => {
+    component.listOfFiles.subscribe((files) => {
+      expect(files).toEqual([]);
+      done();
+    });
+  });
+});