@umbraco-cms/backoffice 16.0.0 → 16.1.0-rc

package/dist-cms/packages/core/manifests.js

@@ -4,6 +4,7 @@ import { manifests as cultureManifests } from './culture/manifests.js';
 import { manifests as debugManifests } from './debug/manifests.js';
 import { manifests as entityActionManifests } from './entity-action/manifests.js';
 import { manifests as entityBulkActionManifests } from './entity-bulk-action/manifests.js';
+import { manifests as entityManifests } from './entity/manifests.js';
 import { manifests as extensionManifests } from './extension-registry/manifests.js';
 import { manifests as iconRegistryManifests } from './icon-registry/manifests.js';
 import { manifests as localizationManifests } from './localization/manifests.js';
@@ -27,6 +28,7 @@ export const manifests = [
     ...debugManifests,
     ...entityActionManifests,
     ...entityBulkActionManifests,
+    ...entityManifests,
     ...extensionManifests,
     ...iconRegistryManifests,
     ...localizationManifests,

package/dist-cms/packages/core/menu/section-sidebar-menu/section-sidebar-menu.element.js

@@ -41,8 +41,12 @@ let UmbSectionSidebarMenuElement = class UmbSectionSidebarMenuElement extends Um
         UmbTextStyles,
         css `
 			h3 {
-				margin: var(--uui-size-5) 0;
+				display: flex;
+				align-items: center;
+				height: var(--umb-header-layout-height);
+				margin: 0;
 				padding: var(--uui-size-4) var(--uui-size-8);
+				box-sizing: border-box;
 				font-size: 14px;
 			}
 		`,

package/dist-cms/packages/core/object-type/object-type.repository.d.ts

@@ -6,6 +6,6 @@ export declare class UmbObjectTypeRepository extends UmbControllerBase implement
     constructor(host: UmbControllerHost);
     read(): Promise<{
         data: import("@umbraco-cms/backoffice/external/backend-api").PagedObjectTypeResponseModel;
-        error: Error | import("@umbraco-cms/backoffice/resources").UmbError | import("@umbraco-cms/backoffice/resources").UmbApiError | import("@umbraco-cms/backoffice/resources").UmbCancelError | undefined;
+        error: import("@umbraco-cms/backoffice/resources").UmbApiError | import("@umbraco-cms/backoffice/resources").UmbCancelError | undefined;
     }>;
 }

package/dist-cms/packages/core/openapi-ts.config.js

@@ -18,7 +18,9 @@ export default defineConfig({
         },
         {
             name: '@hey-api/sdk',
-            asClass: true
+            asClass: true,
+            classNameBuilder: (name) => `${name}Service`,
+            responseStyle: 'fields',
         }
     ]
 });

package/dist-cms/packages/core/package.json

@@ -10,9 +10,9 @@
         "@types/diff": "^7.0.2",
         "diff": "^7.0.0",
         "uuid": "^11.1.0",
-        "@hey-api/client-fetch": "^0.10.0"
+        "@hey-api/client-fetch": "^0.12.0"
     },
     "devDependencies": {
-        "@hey-api/openapi-ts": "^0.66.6"
+        "@hey-api/openapi-ts": "^0.71.0"
     }
 }

package/dist-cms/packages/core/property/components/unsupported-property/utils.js

@@ -1,3 +1,3 @@
 export const UMB_UNSUPPORTED_EDITOR_SCHEMA_ALIASES = {
-    block: ['Umbraco.ImageCropper', 'Umbraco.UploadField'],
+    block: ['Umbraco.ImageCropper'],
 };

package/dist-cms/packages/core/recycle-bin/recycle-bin-repository-base.d.ts

@@ -25,9 +25,7 @@ export declare abstract class UmbRecycleBinRepositoryBase extends UmbRepositoryB
      * @returns {*}
      * @memberof UmbRecycleBinRepositoryBase
      */
-    requestTrash(args: UmbRecycleBinTrashRequestArgs): Promise<{
-        error: Error | import("../resources/umb-error.js").UmbError | import("../resources/umb-error.js").UmbApiError | import("../resources/umb-error.js").UmbCancelError | undefined;
-    }>;
+    requestTrash(args: UmbRecycleBinTrashRequestArgs): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<unknown>>;
     /**
      * Requests to restore an item.
      * @param {UmbRecycleBinRestoreRequestArgs} args
@@ -35,7 +33,7 @@ export declare abstract class UmbRecycleBinRepositoryBase extends UmbRepositoryB
      * @memberof UmbRecycleBinRepositoryBase
      */
     requestRestore(args: UmbRecycleBinRestoreRequestArgs): Promise<{
-        error: Error | import("../resources/umb-error.js").UmbError | import("../resources/umb-error.js").UmbApiError | import("../resources/umb-error.js").UmbCancelError | undefined;
+        error: Error | import("../resources/umb-error.js").UmbApiError | import("../resources/umb-error.js").UmbCancelError | import("../resources/umb-error.js").UmbError | undefined;
     }>;
     /**
      * Requests to empty the recycle bin.

package/dist-cms/packages/core/recycle-bin/recycle-bin-repository-base.js

@@ -10,7 +10,6 @@ import { UmbRepositoryBase } from '@umbraco-cms/backoffice/repository';
 export class UmbRecycleBinRepositoryBase extends UmbRepositoryBase {
     #recycleBinSource;
     #notificationContext;
-    #requestTrashSuccessNotification;
     #requestRestoreSuccessNotification;
     /**
      * Creates an instance of UmbRecycleBinRepositoryBase.
@@ -32,13 +31,7 @@ export class UmbRecycleBinRepositoryBase extends UmbRepositoryBase {
      * @memberof UmbRecycleBinRepositoryBase
      */
     async requestTrash(args) {
-        const { error } = await this.#recycleBinSource.trash(args);
-        if (!error) {
-            this.#requestTrashSuccessNotification?.close();
-            const notification = { data: { message: `Trashed` } };
-            this.#requestTrashSuccessNotification = this.#notificationContext?.peek('positive', notification);
-        }
-        return { error };
+        return this.#recycleBinSource.trash(args);
     }
     /**
      * Requests to restore an item.
@@ -49,6 +42,7 @@ export class UmbRecycleBinRepositoryBase extends UmbRepositoryBase {
     async requestRestore(args) {
         const { error } = await this.#recycleBinSource.restore(args);
         if (!error) {
+            // TODO: keep this notification until we refresh the tree/structure correctly after the action
             this.#requestRestoreSuccessNotification?.close();
             const notification = { data: { message: `Restored` } };
             this.#requestRestoreSuccessNotification = this.#notificationContext?.peek('positive', notification);
@@ -61,11 +55,6 @@ export class UmbRecycleBinRepositoryBase extends UmbRepositoryBase {
      * @memberof UmbRecycleBinRepositoryBase
      */
     async requestEmpty() {
-        const { error } = await this.#recycleBinSource.empty();
-        if (!error) {
-            const notification = { data: { message: `Recycle Bin Emptied` } };
-            this.#notificationContext?.peek('positive', notification);
-        }
         return this.#recycleBinSource.empty();
     }
     /**

package/dist-cms/packages/core/repository/detail/detail-data-source.interface.d.ts

@@ -1,11 +1,12 @@
 import type { UmbDataSourceResponse } from '../data-source-response.interface.js';
 import type { UmbReadDetailDataSource } from './read/index.js';
+import type { UmbDeepPartialObject } from '@umbraco-cms/backoffice/utils';
 import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
 export interface UmbDetailDataSourceConstructor<DetailType = any, UmbDetailDataSourceType extends UmbDetailDataSource<DetailType> = UmbDetailDataSource<DetailType>> {
     new (host: UmbControllerHost): UmbDetailDataSourceType;
 }
 export interface UmbDetailDataSource<DetailType> extends UmbReadDetailDataSource<DetailType> {
-    createScaffold(preset?: Partial<DetailType>): Promise<UmbDataSourceResponse<DetailType>>;
+    createScaffold(preset?: UmbDeepPartialObject<DetailType>): Promise<UmbDataSourceResponse<DetailType>>;
     create(data: DetailType, parentUnique: string | null): Promise<UmbDataSourceResponse<DetailType>>;
     update(data: DetailType): Promise<UmbDataSourceResponse<DetailType>>;
     delete(unique: string): Promise<UmbDataSourceResponse<unknown>>;

package/dist-cms/packages/core/repository/detail/detail-repository-base.d.ts

@@ -6,24 +6,25 @@ import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
 import type { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
 import type { UmbApi } from '@umbraco-cms/backoffice/extension-api';
 import type { UmbEntityModel } from '@umbraco-cms/backoffice/entity';
+import type { UmbDeepPartialObject } from '@umbraco-cms/backoffice/utils';
 export declare abstract class UmbDetailRepositoryBase<DetailModelType extends UmbEntityModel, UmbDetailDataSourceType extends UmbDetailDataSource<DetailModelType> = UmbDetailDataSource<DetailModelType>> extends UmbRepositoryBase implements UmbDetailRepository<DetailModelType>, UmbApi {
     #private;
     protected detailDataSource: UmbDetailDataSourceType;
     constructor(host: UmbControllerHost, detailSource: UmbDetailDataSourceConstructor<DetailModelType>, detailStoreContextAlias: string | UmbContextToken<any, any>);
     /**
      * Creates a scaffold
-     * @param {Partial<DetailModelType>} [preset]
+     * @param {UmbDeepPartialObject<DetailModelType>} [preset]
      * @returns {*}
      * @memberof UmbDetailRepositoryBase
      */
-    createScaffold(preset?: Partial<DetailModelType>): Promise<UmbRepositoryResponse<DetailModelType>>;
+    createScaffold(preset?: UmbDeepPartialObject<DetailModelType>): Promise<UmbRepositoryResponse<DetailModelType>>;
     /**
      * Requests the detail for the given unique
      * @param {string} unique
      * @returns {*}
      * @memberof UmbDetailRepositoryBase
      */
-    requestByUnique(unique: string): Promise<UmbRepositoryResponseWithAsObservable<DetailModelType>>;
+    requestByUnique(unique: string): Promise<UmbRepositoryResponseWithAsObservable<DetailModelType | undefined>>;
     /**
      * Returns a promise with an observable of the detail for the given unique
      * @param {DetailModelType} model
@@ -40,7 +41,7 @@ export declare abstract class UmbDetailRepositoryBase<DetailModelType extends Um
      */
     save(model: DetailModelType): Promise<{
         data: DetailModelType | undefined;
-        error: Error | import("../../resources/umb-error.js").UmbError | import("../../resources/umb-error.js").UmbApiError | import("../../resources/umb-error.js").UmbCancelError | undefined;
+        error: Error | import("../../resources/umb-error.js").UmbApiError | import("../../resources/umb-error.js").UmbCancelError | import("../../resources/umb-error.js").UmbError | undefined;
     }>;
     /**
      * Deletes the detail for the given unique
@@ -49,7 +50,7 @@ export declare abstract class UmbDetailRepositoryBase<DetailModelType extends Um
      * @memberof UmbDetailRepositoryBase
      */
     delete(unique: string): Promise<{
-        error: Error | import("../../resources/umb-error.js").UmbError | import("../../resources/umb-error.js").UmbApiError | import("../../resources/umb-error.js").UmbCancelError | undefined;
+        error: Error | import("../../resources/umb-error.js").UmbApiError | import("../../resources/umb-error.js").UmbCancelError | import("../../resources/umb-error.js").UmbError | undefined;
     }>;
     /**
      * Returns a promise with an observable of the detail for the given unique

package/dist-cms/packages/core/repository/detail/detail-repository-base.js

@@ -19,7 +19,7 @@ export class UmbDetailRepositoryBase extends UmbRepositoryBase {
     }
     /**
      * Creates a scaffold
-     * @param {Partial<DetailModelType>} [preset]
+     * @param {UmbDeepPartialObject<DetailModelType>} [preset]
      * @returns {*}
      * @memberof UmbDetailRepositoryBase
      */
@@ -43,7 +43,7 @@ export class UmbDetailRepositoryBase extends UmbRepositoryBase {
         return {
             data,
             error,
-            asObservable: () => this.#detailStore.byUnique(unique),
+            asObservable: () => this.#detailStore?.byUnique(unique),
         };
     }
     /**

package/dist-cms/packages/core/repository/detail/read/read-detail-repository.interface.d.ts

@@ -2,6 +2,6 @@ import type { UmbRepositoryResponseWithAsObservable } from '../../types.js';
 import type { UmbApi } from '@umbraco-cms/backoffice/extension-api';
 import type { Observable } from '@umbraco-cms/backoffice/external/rxjs';
 export interface UmbReadDetailRepository<DetailModelType> extends UmbApi {
-    requestByUnique(unique: string): Promise<UmbRepositoryResponseWithAsObservable<DetailModelType>>;
+    requestByUnique(unique: string): Promise<UmbRepositoryResponseWithAsObservable<DetailModelType | undefined>>;
     byUnique(unique: string): Promise<Observable<DetailModelType | undefined>>;
 }

package/dist-cms/packages/core/repository/item/item-repository-base.d.ts

@@ -18,13 +18,13 @@ export declare class UmbItemRepositoryBase<ItemType extends {
      * @memberof UmbItemRepositoryBase
      */
     requestItems(uniques: Array<string>): Promise<{
+        asObservable: () => undefined;
         data?: undefined;
         error?: undefined;
-        asObservable?: undefined;
     } | {
         data: ItemType[] | undefined;
-        error: any;
-        asObservable: () => import("rxjs").Observable<ItemType[]>;
+        error: Error | import("../../resources/umb-error.js").UmbApiError | import("../../resources/umb-error.js").UmbCancelError | import("../../resources/umb-error.js").UmbError | undefined;
+        asObservable: () => import("rxjs").Observable<ItemType[]> | undefined;
     }>;
     /**
      * Returns a promise with an observable of the items for the given uniques

package/dist-cms/packages/core/repository/item/item-repository-base.js

@@ -25,18 +25,15 @@ export class UmbItemRepositoryBase extends UmbRepositoryBase {
             await this._init;
         }
         catch {
-            return {};
+            return {
+                asObservable: () => undefined,
+            };
         }
         const { data, error } = await this.#itemSource.getItems(uniques);
-        if (!this._itemStore) {
-            // If store is gone, then we are most likely in a disassembled state.
-            return {};
-        }
         if (data) {
-            this._itemStore.appendItems(data);
+            this._itemStore?.appendItems(data);
         }
-        // TODO: Fix the type of error, it should be UmbApiError, but currently it is any.
-        return { data, error: error, asObservable: () => this._itemStore.items(uniques) };
+        return { data, error, asObservable: () => this._itemStore?.items(uniques) };
     }
     /**
      * Returns a promise with an observable of the items for the given uniques

package/dist-cms/packages/core/repository/item/item-repository.interface.d.ts

@@ -1,11 +1,7 @@
+import type { UmbRepositoryResponseWithAsObservable } from '../types.js';
 import type { Observable } from '@umbraco-cms/backoffice/external/rxjs';
 import type { UmbApi } from '@umbraco-cms/backoffice/extension-api';
-import type { UmbProblemDetails } from '@umbraco-cms/backoffice/resources';
 export interface UmbItemRepository<ItemType> extends UmbApi {
-    requestItems: (uniques: string[]) => Promise<{
-        data?: Array<ItemType> | undefined;
-        error?: UmbProblemDetails | undefined;
-        asObservable?: () => Observable<Array<ItemType>>;
-    }>;
+    requestItems: (uniques: string[]) => Promise<UmbRepositoryResponseWithAsObservable<ItemType[] | undefined>>;
     items: (uniques: string[]) => Promise<Observable<Array<ItemType>> | undefined>;
 }

package/dist-cms/packages/core/repository/item/item-server-data-source-base.d.ts

@@ -32,7 +32,7 @@ export declare abstract class UmbItemServerDataSourceBase<ServerItemType, Client
      */
     getItems(uniques: Array<string>): Promise<{
         data: ClientItemType[] | undefined;
-        error: Error | import("@umbraco-cms/backoffice/resources").UmbError | import("@umbraco-cms/backoffice/resources").UmbApiError | import("@umbraco-cms/backoffice/resources").UmbCancelError | undefined;
+        error: ((Error | import("@umbraco-cms/backoffice/resources").UmbApiError | import("@umbraco-cms/backoffice/resources").UmbCancelError | import("@umbraco-cms/backoffice/resources").UmbError) & (import("@umbraco-cms/backoffice/resources").UmbApiError | import("@umbraco-cms/backoffice/resources").UmbCancelError)) | undefined;
     }>;
     protected _getMappedItems(items: Array<ServerItemType> | undefined): Array<ClientItemType> | undefined;
 }

package/dist-cms/packages/core/repository/repository-items.manager.js

@@ -184,6 +184,8 @@ export class UmbRepositoryItemsManager extends UmbControllerBase {
         }
     }
     #sortByUniques(data) {
+        if (!data)
+            return [];
         const uniques = this.getUniques();
         return [...data].sort((a, b) => {
             const aIndex = uniques.indexOf(this.#getUnique(a) ?? '');

package/dist-cms/packages/core/repository/types.d.ts

@@ -8,7 +8,12 @@ export interface UmbRepositoryResponse<T> extends UmbDataSourceResponse<T> {
 }
 export interface UmbRepositoryErrorResponse extends UmbDataSourceErrorResponse {
 }
-export interface UmbRepositoryResponseWithAsObservable<T> extends UmbRepositoryResponse<T> {
-    asObservable: () => Observable<T | undefined>;
+/**
+ * Interface for a repository that can return a paged model.
+ * @template T - The type of items in the paged model.
+ * @template T$ - The type of items returned by the asObservable method, defaults to T. You should only use this if you want to return a different type from the asObservable method.
+ */
+export interface UmbRepositoryResponseWithAsObservable<T, T$ = T> extends UmbRepositoryResponse<T> {
+    asObservable: () => Observable<T$> | undefined;
 }
 export type * from './data-mapper/mapping/types.js';

package/dist-cms/packages/core/resources/api-interceptor.controller.d.ts

@@ -38,4 +38,11 @@ export declare class UmbApiInterceptorController extends UmbControllerBase {
      * @internal
      */
     addUmbNotificationsInterceptor(client: typeof umbHttpClient): void;
+    /**
+     * Listen for authorization signal to retry GET-requests that received a 401 Unauthorized response.
+     * This will retry all pending requests that received a 401 Unauthorized response after re-authentication.
+     * It will also notify the user about non-GET requests that received a 401 Unauthorized response.
+     * @internal
+     */
+    handleUnauthorizedAuthRetry(): void;
 }

package/dist-cms/packages/core/resources/api-interceptor.controller.js

@@ -3,17 +3,33 @@ import { isUmbNotifications, UMB_NOTIFICATION_HEADER } from './isUmbNotification
 import { isProblemDetailsLike } from './apiTypeValidators.function.js';
 import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
 import { UMB_AUTH_CONTEXT } from '@umbraco-cms/backoffice/auth';
+const MAX_RETRIES = 3;
 export class UmbApiInterceptorController extends UmbControllerBase {
+    /**
+     * Store pending requests that received a 401 response and are waiting for re-authentication.
+     * This is used to retry the requests after re-authentication.
+     */
+    #pending401Requests = [];
+    /**
+     * Store non-GET requests that received a 401 response.
+     * This is used to notify the user about actions that could not be completed due to session expiration.
+     * These requests will not be retried, as they are not idempotent.
+     * Instead, we will notify the user about these requests after re-authentication.
+     */
+    #nonGet401Requests = [];
     /**
      * Binds the default interceptors to the client.
      * This includes the auth response interceptor, the error interceptor and the umb-notifications interceptor.
      * @param {umbHttpClient} client The OpenAPI client to add the interceptor to. It can be any client supporting Response and Request interceptors.
      */
     bindDefaultInterceptors(client) {
+        // Add the default observables to the instance
+        this.handleUnauthorizedAuthRetry();
+        // Add the default interceptors to the client
         this.addAuthResponseInterceptor(client);
+        this.addForbiddenResponseInterceptor(client);
         this.addUmbGeneratedResourceInterceptor(client);
         this.addUmbNotificationsInterceptor(client);
-        this.addForbiddenResponseInterceptor(client);
         this.addErrorInterceptor(client);
     }
     /**
@@ -22,16 +38,57 @@ export class UmbApiInterceptorController extends UmbControllerBase {
      * @internal
      */
     addAuthResponseInterceptor(client) {
-        client.interceptors.response.use(async (response) => {
-            if (response.status === 401) {
-                // See if we can get the UmbAuthContext and let it know the user is timed out
-                const authContext = await this.getContext(UMB_AUTH_CONTEXT, { preventTimeout: true });
-                if (!authContext) {
-                    throw new Error('Could not get the auth context');
-                }
+        client.interceptors.response.use(async (response, request, requestConfig) => {
+            if (response.status !== 401)
+                return response;
+            // Build a plain ProblemDetails object for the response body
+            const problemDetails = {
+                status: response.status,
+                title: response.statusText || 'Unauthorized request, waiting for re-authentication.',
+                detail: undefined,
+                errors: undefined,
+                type: 'Unauthorized',
+                stack: undefined,
+            };
+            const newResponse = this.#createResponse(problemDetails, response);
+            const authContext = await this.getContext(UMB_AUTH_CONTEXT, { preventTimeout: true });
+            if (!authContext)
+                throw new Error('Could not get the auth context');
+            // Only retry for GET requests
+            if (request.method !== 'GET') {
+                // Collect info for later notification
+                this.#nonGet401Requests.push({ request, requestConfig });
+                // Show login overlay (only once per burst, as before)
                 authContext.timeOut();
+                return newResponse;
             }
-            return response;
+            // Find if this request is already in the queue and increment retries
+            let retries = 1;
+            const existing = this.#pending401Requests.find((req) => req.request === request && req.requestConfig === requestConfig);
+            if (existing) {
+                retries = existing.retries + 1;
+                if (retries > MAX_RETRIES) {
+                    return newResponse;
+                }
+                existing.retries = retries;
+            }
+            // Return a promise that will resolve when re-auth completes
+            return new Promise((resolve, reject) => {
+                this.#pending401Requests.push({
+                    request,
+                    requestConfig,
+                    retry: async () => {
+                        const { data, response: retryResponse } = await client.request(requestConfig);
+                        return this.#createResponse(data, retryResponse);
+                    },
+                    resolve,
+                    reject,
+                    retries,
+                });
+                // Show login overlay
+                authContext.timeOut();
+                console.log('[Interceptor] 401 Unauthorized - queuing request for re-authentication and have tried', retries - 1, 'times before', requestConfig);
+            });
         });
     }
     /**
@@ -40,13 +97,20 @@ export class UmbApiInterceptorController extends UmbControllerBase {
      * @internal
      */
     addForbiddenResponseInterceptor(client) {
-        client.interceptors.response.use(async (response) => {
-            if (response.status === 403) {
-                const headline = 'Permission Denied';
-                const message = 'You do not have the necessary permissions to complete the requested action. If you believe this is in error, please reach out to your administrator.';
-                this.#peekError(headline, message, null);
-            }
-            return response;
+        client.interceptors.response.use((response) => {
+            if (response.status !== 403)
+                return response;
+            // Build a plain ProblemDetails object for the response body
+            const problemDetails = {
+                status: response.status,
+                title: response.statusText ||
+                    'You do not have the necessary permissions to complete the requested action. If you believe this is in error, please reach out to your administrator.',
+                detail: undefined,
+                errors: undefined,
+                type: 'Unauthorized',
+                stack: undefined,
+            };
+            return this.#createResponse(problemDetails, response);
         });
     }
     /**
@@ -55,19 +119,15 @@ export class UmbApiInterceptorController extends UmbControllerBase {
      * @internal
      */
     addUmbGeneratedResourceInterceptor(client) {
-        client.interceptors.response.use(async (response) => {
-            if (!response.headers.has('Umb-Generated-Resource')) {
+        client.interceptors.response.use((response) => {
+            if (!response.headers.has('Umb-Generated-Resource'))
                 return response;
-            }
             const generatedResource = response.headers.get('Umb-Generated-Resource');
             if (generatedResource === null) {
                 return response;
             }
-            // Generate new response body with the generated resource, which is a guid
-            const newResponse = new Response(generatedResource, {
-                ...response,
-            });
-            return newResponse;
+            // Return a new response with the generated resource in the body (plain text)
+            return this.#createResponse(generatedResource, response);
         });
     }
     /**
@@ -77,40 +137,49 @@ export class UmbApiInterceptorController extends UmbControllerBase {
      */
     addErrorInterceptor(client) {
         client.interceptors.response.use(async (response) => {
+            // If the response is ok, we just return the response
             if (response.ok)
                 return response;
-            // Handle 500 errors - we need to show a notification
-            if (response.status === 500) {
-                try {
-                    // Clones the response to read the body
-                    const origResponse = response.clone();
-                    const error = await origResponse.json();
-                    // If there is no JSON in the error, we just return the response
-                    if (!error)
-                        return response;
-                    // Check if the error is a problem details object
-                    if (!isProblemDetailsLike(error)) {
-                        // If not, we just return the response
-                        return response;
-                    }
-                    let headline = error.title ?? 'Server Error';
-                    let message = 'A fatal server error occurred. If this continues, please reach out to your administrator.';
-                    // Special handling for ObjectCacheAppCache corruption errors, which we are investigating
-                    if (error.detail?.includes('ObjectCacheAppCache') ||
-                        error.detail?.includes('Umbraco.Cms.Infrastructure.Scoping.Scope.DisposeLastScope()')) {
-                        headline = 'Please restart the server';
-                        message =
-                            'The Umbraco object cache is corrupt, but your action may still have been executed. Please restart the server to reset the cache. This is a work in progress.';
-                    }
-                    this.#peekError(headline, message, error.errors);
-                }
-                catch (e) {
-                    // Ignore JSON parse error
-                    console.error('[Interceptor] Caught a 500 Error, but failed parsing error body (expected JSON)', e);
+            // We will check if it is not a 401 or 403 error, as that is handled by other interceptors
+            if (response.status === 401 || response.status === 403)
+                return response;
+            // Special handling for 404 Not Found
+            if (response.status === 404) {
+                const notFoundProblemDetails = {
+                    status: response.status,
+                    title: response.statusText || 'The requested resource was not found.',
+                    detail: undefined,
+                    errors: undefined,
+                    type: 'NotFound',
+                    stack: undefined,
+                };
+                return this.#createResponse(notFoundProblemDetails, response);
+            }
+            // For all other errors, we will build a ProblemDetails object
+            let problemDetails = {
+                status: response.status,
+                title: response.statusText ||
+                    'A fatal server error occurred. If this continues, please reach out to your administrator.',
+                detail: undefined,
+                errors: undefined,
+                type: 'ServerError',
+                stack: undefined,
+            };
+            try {
+                // Clones the response to read the body
+                const origResponse = response.clone();
+                const errorBody = await origResponse.json();
+                // If there is JSON in the error, we will try to parse it as a ProblemDetails object
+                if (errorBody && isProblemDetailsLike(errorBody)) {
+                    // Merge the parsed problem details into our default
+                    problemDetails = errorBody;
                 }
             }
-            // Return original response
-            return response;
+            catch (e) {
+                // Ignore JSON parse error
+                console.error('[Interceptor] Caught a server error, but failed parsing error body (expected JSON)', e);
+            }
+            return this.#createResponse(problemDetails, response);
         });
     }
     /**
@@ -141,6 +210,63 @@ export class UmbApiInterceptorController extends UmbControllerBase {
             return response;
         });
     }
+    /**
+     * Listen for authorization signal to retry GET-requests that received a 401 Unauthorized response.
+     * This will retry all pending requests that received a 401 Unauthorized response after re-authentication.
+     * It will also notify the user about non-GET requests that received a 401 Unauthorized response.
+     * @internal
+     */
+    handleUnauthorizedAuthRetry() {
+        this.consumeContext(UMB_AUTH_CONTEXT, (context) => {
+            this.observe(context?.authorizationSignal, () => {
+                console.log('[Interceptor] 401 Unauthorized - re-authentication completed');
+                // On auth, retry all pending requests
+                const requests = this.#pending401Requests.splice(0, this.#pending401Requests.length);
+                requests.forEach((req) => {
+                    console.log('[Interceptor] 401 Unauthorized - retrying request after re-authentication', req.requestConfig);
+                    req.retry().then(req.resolve).catch(req.reject);
+                });
+                // Notify about non-GET 401s after successful re-auth
+                if (this.#nonGet401Requests.length > 0) {
+                    const errors = {};
+                    this.#nonGet401Requests.forEach((req) => {
+                        errors[`${req.request.method} ${req.request.url}`] = `Request failed with 401 Unauthorized.`;
+                    });
+                    this.#peekError('Some actions were not completed', 'Some actions could not be completed because your session expired. Please try again.', errors, 'warning');
+                    this.#nonGet401Requests.length = 0; // Clear after notifying
+                }
+            }, '_authClearNonGet401Requests');
+        });
+    }
+    /**
+     * Helper to create a new Response with correct Content-Type.
+     * @param {unknown} body The body of the response, can be a string or an object.
+     * @param {Response} originalResponse The original response to copy status and headers from.
+     * @returns {Response} The new Response object with the correct Content-Type and body.
+     */
+    #createResponse(body, originalResponse) {
+        const isString = typeof body === 'string';
+        const contentType = isString ? 'text/plain' : 'application/json';
+        const responseBody = isString ? body : JSON.stringify(body);
+        // Construct new headers but preserve "X-" headers from the original response
+        const headersOverride = {};
+        originalResponse.headers.forEach((value, key) => {
+            if (key.toLowerCase().startsWith('x-')) {
+                headersOverride[key] = value;
+            }
+        });
+        return new Response(responseBody, {
+            status: originalResponse.status,
+            statusText: originalResponse.statusText,
+            headers: {
+                ...headersOverride,
+                'Content-Type': contentType,
+            },
+        });
+    }
+    /**
+     * Helper to show a notification error.
+     */
     async #peekError(headline, message, details, color) {
         // Store the host for usage in the following async context
         const host = this._host;