@umbraco-cms/backoffice 17.5.3 → 17.6.0-rc

package/dist-cms/packages/documents/documents/publishing/workspace-context/document-publishing.workspace-context.js

@@ -3,15 +3,15 @@ import { UmbDocumentPublishingRepository } from '../repository/index.js';
 import { UmbDocumentPublishedPendingChangesManager } from '../pending-changes/index.js';
 import { UMB_DOCUMENT_SCHEDULE_MODAL } from '../schedule-publish/constants.js';
 import { UMB_DOCUMENT_PUBLISH_WITH_DESCENDANTS_MODAL } from '../publish-with-descendants/constants.js';
-import { UMB_DOCUMENT_PUBLISH_MODAL } from '../publish/constants.js';
-import { UmbUnpublishDocumentEntityAction } from '../unpublish/index.js';
+import { UmbDocumentUnpublishManifestEntityActionMeta } from '../unpublish/entity-action/constants.js';
 import { UMB_DOCUMENT_ENTITY_TYPE, UMB_DOCUMENT_WORKSPACE_ALIAS } from '../../constants.js';
 import { UMB_DOCUMENT_PUBLISHING_WORKSPACE_CONTEXT } from './document-publishing.workspace-context.token.js';
 import { UMB_DOCUMENT_PUBLISHING_SHORTCUT_UNIQUE } from './constants.js';
+import { UmbDocumentVariantState } from '../../variant-state.js';
 import { firstValueFrom } from '../../../../../external/rxjs/index.js';
 import { observeMultiple } from '../../../../../libs/observable-api/index.js';
 import { umbOpenModal } from '../../../../core/modal/index.js';
-import { DocumentVariantStateModel } from '../../../../core/backend-api/index.js';
+import { UMB_CONTENT_PUBLISH_MODAL, UmbContentUnpublishEntityAction } from '../../../../content/content/index.js';
 import { UmbContextBase } from '../../../../../libs/class-api/index.js';
 import { UmbLocalizationController } from '../../../../../libs/localization-api/index.js';
 import { UmbRequestReloadChildrenOfEntityEvent, UmbRequestReloadStructureForEntityEvent, } from '../../../../core/entity-action/index.js';
@@ -146,27 +146,40 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
             return;
         const variantIds = variants.map((x) => x.variantId);
         const saveData = await this.#documentWorkspaceContext.constructSaveData(variantIds);
-        await this.#documentWorkspaceContext.runMandatoryValidationForSaveData(saveData);
+        await this.#documentWorkspaceContext.runMandatoryValidationForSaveData(saveData, variantIds);
         await this.#documentWorkspaceContext.askServerToValidate(saveData, variantIds);
         return this.#documentWorkspaceContext.validateVariantsAndSubmit(variantIds, async () => {
-            if (!this.#documentWorkspaceContext) {
-                throw new Error('Document workspace context is missing');
+            try {
+                if (!this.#documentWorkspaceContext) {
+                    throw new Error('Document workspace context is missing');
+                }
+                // Save the document before scheduling
+                await this.#documentWorkspaceContext.performCreateOrUpdate(variantIds, saveData);
+                // Schedule the document
+                const { error } = await this.#publishingRepository.publish(unique, variants);
+                if (error) {
+                    throw error;
+                }
+                const notification = {
+                    data: { message: this.#localize.term('speechBubbles_editContentScheduledSavedText') },
+                };
+                this.#notificationContext?.peek('positive', notification);
+                // reload the document so all states are updated after the publish operation
+                // TODO: It seems wrong to make a full reload, In this case I think we can just update the variants status? [NL]
+                await this.#documentWorkspaceContext.reload();
+                this.#loadAndProcessLastPublished();
+                // request reload of this entity
+                const structureEvent = new UmbRequestReloadStructureForEntityEvent({ entityType, unique });
+                this.#eventContext?.dispatchEvent(structureEvent);
             }
-            // Save the document before scheduling
-            await this.#documentWorkspaceContext.performCreateOrUpdate(variantIds, saveData);
-            // Schedule the document
-            const { error } = await this.#publishingRepository.publish(unique, variants);
-            if (error) {
+            catch (error) {
+                // Notify only on the publish path. The validation-failure path below already
+                // notifies, so a shared top-level .catch would fire a second toast. [JOV]
+                this.#notificationContext?.peek('danger', {
+                    data: { message: this.#localize.term('speechBubbles_editContentScheduledNotSavedText') },
+                });
                 return Promise.reject(error);
             }
-            const notification = { data: { message: this.#localize.term('speechBubbles_editContentScheduledSavedText') } };
-            this.#notificationContext?.peek('positive', notification);
-            // reload the document so all states are updated after the publish operation
-            await this.#documentWorkspaceContext.reload();
-            this.#loadAndProcessLastPublished();
-            // request reload of this entity
-            const structureEvent = new UmbRequestReloadStructureForEntityEvent({ entityType, unique });
-            this.#eventContext?.dispatchEvent(structureEvent);
         }, async (reason) => {
             const notificationContext = await this.getContext(UMB_NOTIFICATION_CONTEXT);
             if (!notificationContext) {
@@ -243,6 +256,7 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
                 },
             });
             // reload the document so all states are updated after the publish operation
+            // TODO: It seems wrong to make a full reload, I think we should only load the selected variants. [NL]
             await this.#documentWorkspaceContext.reload();
             await this.#loadAndProcessLastPublished();
             // request reload of this entity
@@ -268,9 +282,16 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         const entityType = this.#documentWorkspaceContext.getEntityType();
         if (!entityType)
             throw new Error('Entity type is missing');
-        // TODO: remove meta
-        await new UmbUnpublishDocumentEntityAction(this, { unique, entityType, meta: {} }).execute();
+        const action = new UmbContentUnpublishEntityAction(this, {
+            unique,
+            entityType,
+            meta: UmbDocumentUnpublishManifestEntityActionMeta,
+        });
+        const didUnpublish = await action.executeWithResult();
+        if (!didUnpublish)
+            return;
         // Reload workspace data to reflect the unpublished state
+        // TODO: It seems wrong to make a full reload, In this case I think we can just update the variants status? [NL]
         await this.#documentWorkspaceContext.reload();
         await this.#loadAndProcessLastPublished();
     }
@@ -293,11 +314,13 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         }
         else {
             // If there are multiple variants, we will open the modal to let the user pick which variants to publish.
-            const result = await umbOpenModal(this, UMB_DOCUMENT_PUBLISH_MODAL, {
+            const result = await umbOpenModal(this, UMB_CONTENT_PUBLISH_MODAL, {
                 data: {
                     headline: this.#localize.term('content_saveAndPublishModalTitle'),
                     options,
-                    pickableFilter: this.#publishableVariantsFilter,
+                    // The shared modal's pickableFilter is typed against the generic UmbEntityVariantOptionModel, but
+                    // #determineVariantOptions() (which supplies `options` above) only ever returns document variants here.
+                    pickableFilter: (option) => this.#publishableVariantsFilter(option),
                 },
                 value: { selection: selected },
             }).catch(() => undefined);
@@ -310,8 +333,15 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         const saveData = await this.#documentWorkspaceContext.constructSaveData(variantIds);
         await this.#documentWorkspaceContext.runMandatoryValidationForSaveData(saveData, variantIds);
         await this.#documentWorkspaceContext.askServerToValidate(saveData, variantIds);
-        return this.#documentWorkspaceContext.validateVariantsAndSubmit(variantIds, async () => {
-            return this.#performSaveAndPublish(variantIds, saveData);
+        return this.#documentWorkspaceContext.validateVariantsAndSubmit(variantIds, () => {
+            // Notify only on the publish path. The validation-failure path below already
+            // notifies, so a shared top-level .catch would fire a second, contradictory toast. [JOV]
+            return this.#performSaveAndPublish(variantIds, saveData).catch((error) => {
+                this.#notificationContext?.peek('danger', {
+                    data: { message: this.#localize.term('speechBubbles_editContentPublishedFailed') },
+                });
+                return Promise.reject(error);
+            });
         }, async (reason) => {
             // If data of the selection is not valid Then just save:
             await this.#documentWorkspaceContext.performCreateOrUpdate(variantIds, saveData);
@@ -338,25 +368,47 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         const entityType = this.#documentWorkspaceContext.getEntityType();
         if (!entityType)
             throw new Error('Entity type is missing');
-        await this.#documentWorkspaceContext.performCreateOrUpdate(variantIds, saveData);
-        const { error } = await this.#publishingRepository.publish(unique, variantIds.map((variantId) => ({ variantId })));
-        if (!error) {
-            this.#notificationContext?.peek('positive', {
+        // The publish already succeeded server-side once we reach the read-back; a failed read-back must not be
+        // reported as a publish failure, so we fall back to the submitted data and flag the editor as stale.
+        let reloadAfterPublishFailed = false;
+        const loadAfterPublish = async () => {
+            try {
+                return await this.#documentWorkspaceContext.loadWithoutPersist();
+            }
+            catch {
+                reloadAfterPublishFailed = true;
+                return saveData;
+            }
+        };
+        await this.#documentWorkspaceContext.performCreateOrUpdate(variantIds, saveData, {
+            create: async (data, ids, parent) => {
+                const { error } = await this.#publishingRepository.createAndPublish(data, ids, parent.unique);
+                if (error)
+                    throw new Error('Error creating and publishing document', { cause: error });
+                return loadAfterPublish();
+            },
+            update: async (data, ids) => {
+                const { error } = await this.#publishingRepository.updateAndPublish(data, ids);
+                if (error)
+                    throw new Error('Error updating and publishing document', { cause: error });
+                return loadAfterPublish();
+            },
+        });
+        this.#notificationContext?.peek('positive', {
+            data: {
+                message: this.#localize.term('speechBubbles_editContentPublishedHeader'),
+            },
+        });
+        if (reloadAfterPublishFailed) {
+            this.#notificationContext?.peek('warning', {
                 data: {
-                    message: this.#localize.term('speechBubbles_editContentPublishedHeader'),
+                    message: this.#localize.term('speechBubbles_editContentPublishedReloadFailed'),
                 },
             });
-            // Clear stale published data and pending changes state so the
-            // persistedData observer does not run a comparison against outdated
-            // data during reload, which would briefly show a false-positive
-            // "pending changes" state.
-            this.#clear();
-            // reload the document so all states are updated after the publish operation
-            await this.#documentWorkspaceContext.reload();
-            await this.#loadAndProcessLastPublished();
-            const event = new UmbRequestReloadStructureForEntityEvent({ unique, entityType });
-            this.#eventContext?.dispatchEvent(event);
         }
+        await this.#loadAndProcessLastPublished();
+        const event = new UmbRequestReloadStructureForEntityEvent({ unique, entityType });
+        this.#eventContext?.dispatchEvent(event);
     }
     #publishableVariantsFilter;
     async #determineVariantOptions() {
@@ -426,8 +478,8 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         // Use persisted data (falls back to current) because this may be called
         // from the persistedData observer before setCurrent has run.
         const variants = this.#documentWorkspaceContext?.getPersistedData()?.variants ?? this.#documentWorkspaceContext?.getVariants();
-        return (variants?.some((variant) => variant.state === DocumentVariantStateModel.PUBLISHED ||
-            variant.state === DocumentVariantStateModel.PUBLISHED_PENDING_CHANGES) ?? false);
+        return (variants?.some((variant) => variant.state === UmbDocumentVariantState.PUBLISHED ||
+            variant.state === UmbDocumentVariantState.PUBLISHED_PENDING_CHANGES) ?? false);
     }
     async #loadAndProcessLastPublished() {
         if (!this.#documentWorkspaceContext)

package/dist-cms/packages/documents/documents/recycle-bin/menu/manifests.js

@@ -1,6 +1,6 @@
 import { UMB_CONTENT_MENU_ALIAS } from '../../menu/manifests.js';
 import { UMB_DOCUMENT_RECYCLE_BIN_TREE_ALIAS } from '../constants.js';
-import { UMB_DOCUMENT_WORKSPACE_ALIAS } from '../../constants.js';
+import { UMB_DOCUMENT_USER_PERMISSION_CONDITION_ALIAS, UMB_DOCUMENT_WORKSPACE_ALIAS, UMB_USER_PERMISSION_DOCUMENT_READ, } from '../../constants.js';
 import { UMB_DOCUMENT_RECYCLE_BIN_MENU_ITEM_ALIAS } from './constants.js';
 import { UMB_ENTITY_IS_TRASHED_CONDITION_ALIAS } from '../../../../core/recycle-bin/index.js';
 import { UMB_WORKSPACE_CONDITION_ALIAS } from '../../../../core/workspace/index.js';
@@ -21,6 +21,10 @@ export const manifests = [
             {
                 alias: 'Umb.Condition.CurrentUser.AllowDocumentRecycleBin',
             },
+            {
+                alias: UMB_DOCUMENT_USER_PERMISSION_CONDITION_ALIAS,
+                allOf: [UMB_USER_PERMISSION_DOCUMENT_READ],
+            },
         ],
     },
     {

package/dist-cms/packages/documents/documents/recycle-bin/root/workspace/manifests.js

@@ -1,3 +1,4 @@
+import { UMB_DOCUMENT_USER_PERMISSION_CONDITION_ALIAS, UMB_USER_PERMISSION_DOCUMENT_READ, } from '../../../user-permissions/constants.js';
 import { UMB_DOCUMENT_RECYCLE_BIN_TREE_ITEM_CHILDREN_COLLECTION_ALIAS } from '../../tree/constants.js';
 import { UMB_DOCUMENT_RECYCLE_BIN_ROOT_ENTITY_TYPE } from '../entity.js';
 import { UMB_DOCUMENT_RECYCLE_BIN_ROOT_WORKSPACE_ALIAS } from './constants.js';
@@ -29,6 +30,10 @@ export const manifests = [
                 alias: UMB_WORKSPACE_CONDITION_ALIAS,
                 match: UMB_DOCUMENT_RECYCLE_BIN_ROOT_WORKSPACE_ALIAS,
             },
+            {
+                alias: UMB_DOCUMENT_USER_PERMISSION_CONDITION_ALIAS,
+                allOf: [UMB_USER_PERMISSION_DOCUMENT_READ],
+            },
         ],
     },
 ];

package/dist-cms/packages/documents/documents/redirect-management/repository/document-redirect-management.repository.d.ts

@@ -25,6 +25,9 @@ export declare class UmbDocumentRedirectManagementRepository extends UmbControll
      * @param {boolean} enabled - Whether the tracker should be enabled.
      * @returns {*}
      * @memberof UmbDocumentRedirectManagementRepository
+     * @deprecated Deprecated since v17. The backend endpoint is now a no-op; set the
+     *   `Umbraco:CMS:WebRouting:DisableRedirectUrlTracking` configuration key instead.
+     *   Scheduled for removal in Umbraco 19.
      */
     setStatus(enabled: boolean): Promise<{
         error: import("../../../../core/resources/index.js").UmbCancelError | import("../../../../core/resources/index.js").UmbApiError | undefined;

package/dist-cms/packages/documents/documents/redirect-management/repository/document-redirect-management.repository.js

@@ -1,5 +1,6 @@
 import { UmbDocumentRedirectManagementServerDataSource } from './document-redirect-management.server.data-source.js';
 import { UmbControllerBase } from '../../../../../libs/class-api/index.js';
+import { UmbDeprecation } from '../../../../core/utils/index.js';
 /**
  * Repository for managing document redirect URLs.
  * @class UmbDocumentRedirectManagementRepository
@@ -20,8 +21,16 @@ export class UmbDocumentRedirectManagementRepository extends UmbControllerBase {
      * @param {boolean} enabled - Whether the tracker should be enabled.
      * @returns {*}
      * @memberof UmbDocumentRedirectManagementRepository
+     * @deprecated Deprecated since v17. The backend endpoint is now a no-op; set the
+     *   `Umbraco:CMS:WebRouting:DisableRedirectUrlTracking` configuration key instead.
+     *   Scheduled for removal in Umbraco 19.
      */
     async setStatus(enabled) {
+        new UmbDeprecation({
+            deprecated: 'UmbDocumentRedirectManagementRepository.setStatus()',
+            removeInVersion: '19.0.0',
+            solution: 'The backend endpoint is now a no-op. Set the Umbraco:CMS:WebRouting:DisableRedirectUrlTracking configuration key instead.',
+        }).warn();
         return this.#dataSource.setStatus(enabled);
     }
     /**

package/dist-cms/packages/documents/documents/redirect-management/repository/document-redirect-management.server.data-source.d.ts

@@ -29,6 +29,9 @@ export declare class UmbDocumentRedirectManagementServerDataSource {
      * @param {boolean} enabled - Whether the tracker should be enabled.
      * @returns {*}
      * @memberof UmbDocumentRedirectManagementServerDataSource
+     * @deprecated Deprecated since v17. The backend endpoint is now a no-op; set the
+     *   `Umbraco:CMS:WebRouting:DisableRedirectUrlTracking` configuration key instead.
+     *   Scheduled for removal in Umbraco 19.
      */
     setStatus(enabled: boolean): Promise<{
         error: import("../../../../core/resources/index.js").UmbCancelError | import("../../../../core/resources/index.js").UmbApiError | undefined;

package/dist-cms/packages/documents/documents/redirect-management/repository/document-redirect-management.server.data-source.js

@@ -34,6 +34,9 @@ export class UmbDocumentRedirectManagementServerDataSource {
      * @param {boolean} enabled - Whether the tracker should be enabled.
      * @returns {*}
      * @memberof UmbDocumentRedirectManagementServerDataSource
+     * @deprecated Deprecated since v17. The backend endpoint is now a no-op; set the
+     *   `Umbraco:CMS:WebRouting:DisableRedirectUrlTracking` configuration key instead.
+     *   Scheduled for removal in Umbraco 19.
      */
     async setStatus(enabled) {
         const status = enabled ? RedirectStatusModel.ENABLED : RedirectStatusModel.DISABLED;

package/dist-cms/packages/documents/documents/repository/detail/document-detail-request.mappers.d.ts

@@ -0,0 +1,17 @@
+import type { UmbDocumentDetailModel } from '../../types.js';
+import type { CreateDocumentRequestModel, UpdateDocumentRequestModel } from '../../../../core/backend-api/index.js';
+/**
+ * Maps a Document detail model to the create request body.
+ * Shared by the detail create endpoint and the publishing create-and-publish endpoint.
+ * @param {UmbDocumentDetailModel} model - The Document to create
+ * @param {string | null} parentUnique - The unique of the parent to create under
+ * @returns {CreateDocumentRequestModel} The create request body
+ */
+export declare function umbMapDocumentCreateRequestBody(model: UmbDocumentDetailModel, parentUnique: string | null): CreateDocumentRequestModel;
+/**
+ * Maps a Document detail model to the update request body.
+ * Shared by the detail update endpoint and the publishing update-and-publish endpoint.
+ * @param {UmbDocumentDetailModel} model - The Document to update
+ * @returns {UpdateDocumentRequestModel} The update request body
+ */
+export declare function umbMapDocumentUpdateRequestBody(model: UmbDocumentDetailModel): UpdateDocumentRequestModel;

package/dist-cms/packages/documents/documents/repository/detail/document-detail-request.mappers.js

@@ -0,0 +1,30 @@
+/**
+ * Maps a Document detail model to the create request body.
+ * Shared by the detail create endpoint and the publishing create-and-publish endpoint.
+ * @param {UmbDocumentDetailModel} model - The Document to create
+ * @param {string | null} parentUnique - The unique of the parent to create under
+ * @returns {CreateDocumentRequestModel} The create request body
+ */
+export function umbMapDocumentCreateRequestBody(model, parentUnique) {
+    return {
+        id: model.unique,
+        parent: parentUnique ? { id: parentUnique } : null,
+        documentType: { id: model.documentType.unique },
+        template: model.template ? { id: model.template.unique } : null,
+        values: model.values,
+        variants: model.variants,
+    };
+}
+/**
+ * Maps a Document detail model to the update request body.
+ * Shared by the detail update endpoint and the publishing update-and-publish endpoint.
+ * @param {UmbDocumentDetailModel} model - The Document to update
+ * @returns {UpdateDocumentRequestModel} The update request body
+ */
+export function umbMapDocumentUpdateRequestBody(model) {
+    return {
+        template: model.template ? { id: model.template.unique } : null,
+        values: model.values,
+        variants: model.variants,
+    };
+}

package/dist-cms/packages/documents/documents/repository/detail/document-detail.repository.d.ts

@@ -1,7 +1,8 @@
 import type { UmbDocumentDetailModel } from '../../types.js';
+import { UmbDocumentServerDataSource } from './document-detail.server.data-source.js';
 import type { UmbControllerHost } from '../../../../../libs/controller-api/index.js';
 import { UmbDetailRepositoryBase } from '../../../../core/repository/index.js';
-export declare class UmbDocumentDetailRepository extends UmbDetailRepositoryBase<UmbDocumentDetailModel> {
+export declare class UmbDocumentDetailRepository extends UmbDetailRepositoryBase<UmbDocumentDetailModel, UmbDocumentServerDataSource> {
     constructor(host: UmbControllerHost);
 }
 export { UmbDocumentDetailRepository as api };

package/dist-cms/packages/documents/documents/repository/detail/document-detail.server.data-source.js

@@ -5,6 +5,7 @@ import { tryExecute } from '../../../../core/resources/index.js';
 import { umbDeepMerge } from '../../../../core/utils/index.js';
 import { UmbDocumentTypeDetailServerDataSource } from '../../../document-types/index.js';
 import { UmbControllerBase } from '../../../../../libs/class-api/index.js';
+import { umbMapDocumentCreateRequestBody, umbMapDocumentUpdateRequestBody } from './document-detail-request.mappers.js';
 /**
  * A data source for the Document that fetches data from the server
  * @class UmbDocumentServerDataSource
@@ -26,10 +27,11 @@ export class UmbDocumentServerDataSource extends UmbControllerBase {
         const { data } = await new UmbDocumentTypeDetailServerDataSource(this).read(documentTypeUnique);
         const documentTypeIcon = data?.icon ?? null;
         const documentTypeCollection = data?.collection ?? null;
+        const defaultTemplate = data?.defaultTemplate ? { unique: data.defaultTemplate.id } : null;
         const defaultData = {
             entityType: UMB_DOCUMENT_ENTITY_TYPE,
             unique: UmbId.new(),
-            template: null,
+            template: defaultTemplate,
             documentType: {
                 unique: documentTypeUnique,
                 collection: documentTypeCollection,
@@ -106,15 +108,7 @@ export class UmbDocumentServerDataSource extends UmbControllerBase {
             throw new Error('Document is missing');
         if (!model.unique)
             throw new Error('Document unique is missing');
-        // TODO: make data mapper to prevent errors
-        const body = {
-            id: model.unique,
-            parent: parentUnique ? { id: parentUnique } : null,
-            documentType: { id: model.documentType.unique },
-            template: model.template ? { id: model.template.unique } : null,
-            values: model.values,
-            variants: model.variants,
-        };
+        const body = umbMapDocumentCreateRequestBody(model, parentUnique);
         const { data, error } = await tryExecute(this, DocumentService.postDocument({
             body: body,
         }));
@@ -132,12 +126,7 @@ export class UmbDocumentServerDataSource extends UmbControllerBase {
     async update(model) {
         if (!model.unique)
             throw new Error('Unique is missing');
-        // TODO: make data mapper to prevent errors
-        const body = {
-            template: model.template ? { id: model.template.unique } : null,
-            values: model.values,
-            variants: model.variants,
-        };
+        const body = umbMapDocumentUpdateRequestBody(model);
         const { error } = await tryExecute(this, DocumentService.putDocumentById({
             path: { id: model.unique },
             body: body,

package/dist-cms/packages/documents/documents/search/document-search-result-item.element.js

@@ -5,7 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { classMap, css, customElement, html, nothing, property, state, when, } from '../../../../external/lit/index.js';
-import { DocumentVariantStateModel } from '../../../core/backend-api/index.js';
+import { UmbDocumentVariantState } from '../variant-state.js';
 import { UmbLitElement } from '../../../core/lit-element/index.js';
 import { UMB_APP_LANGUAGE_CONTEXT } from '../../../language/index.js';
 let UmbDocumentSearchResultItemElement = class UmbDocumentSearchResultItemElement extends UmbLitElement {
@@ -40,8 +40,8 @@ let UmbDocumentSearchResultItemElement = class UmbDocumentSearchResultItemElemen
     #getDraftState() {
         if (this.item?.isTrashed)
             return false;
-        return (this._variant?.state === DocumentVariantStateModel.DRAFT ||
-            this.item?.variants[0]?.state === DocumentVariantStateModel.DRAFT);
+        return (this._variant?.state === UmbDocumentVariantState.DRAFT ||
+            this.item?.variants[0]?.state === UmbDocumentVariantState.DRAFT);
     }
     #getAncestorPath() {
         return this.item?.ancestors

package/dist-cms/packages/documents/documents/search/document-search.server.data-source.js

@@ -1,6 +1,7 @@
 import { UMB_DOCUMENT_ENTITY_TYPE } from '../entity.js';
 import { DocumentService } from '../../../core/backend-api/index.js';
 import { tryExecute } from '../../../core/resources/index.js';
+import { UmbItemDataApiGetRequestController } from '../../../core/entity-item/index.js';
 /**
  * A data source for the Rollback that fetches data from the server
  * @class UmbDocumentSearchServerDataSource
@@ -19,32 +20,22 @@ export class UmbDocumentSearchServerDataSource {
     async #fetchAncestors(ids) {
         if (!ids.length)
             return { data: new Map() };
-        const { data, error } = await tryExecute(this.#host, DocumentService.getItemDocumentAncestors({ query: { id: ids } }));
+        const requestController = new UmbItemDataApiGetRequestController(this.#host, {
+            uniques: ids,
+            // eslint-disable-next-line local-rules/no-direct-api-import
+            api: ({ uniques }) => DocumentService.getItemDocumentAncestors({ query: { id: uniques } }),
+        });
+        const { data, error } = await requestController.request();
         if (error)
             return { error };
+        // A failed batch resolves without rejecting, leaving an `undefined` hole in `data` rather than
+        // surfacing an error, so guard against it before mapping below.
+        if (data?.some((entry) => entry == null))
+            return { error: new Error('Error fetching ancestors for one or more document items.') };
         const ancestorsByItemId = new Map();
         if (data) {
             for (const entry of data) {
-                ancestorsByItemId.set(entry.id, entry.ancestors.map((ancestor) => ({
-                    documentType: {
-                        unique: ancestor.documentType.id,
-                        icon: ancestor.documentType.icon,
-                        collection: ancestor.documentType.collection ? { unique: ancestor.documentType.collection.id } : null,
-                    },
-                    entityType: UMB_DOCUMENT_ENTITY_TYPE,
-                    hasChildren: ancestor.hasChildren,
-                    isProtected: ancestor.isProtected,
-                    isTrashed: ancestor.isTrashed,
-                    parent: ancestor.parent ? { unique: ancestor.parent.id } : null,
-                    unique: ancestor.id,
-                    variants: ancestor.variants.map((variant) => ({
-                        name: variant.name,
-                        culture: variant.culture || null,
-                        state: variant.state,
-                        flags: variant.flags,
-                    })),
-                    flags: ancestor.flags,
-                })));
+                ancestorsByItemId.set(entry.id, entry.ancestors.map(mapAncestorToItemModel));
             }
         }
         return { data: ancestorsByItemId };
@@ -105,3 +96,25 @@ export class UmbDocumentSearchServerDataSource {
         return { error };
     }
 }
+function mapAncestorToItemModel(ancestor) {
+    return {
+        documentType: {
+            unique: ancestor.documentType.id,
+            icon: ancestor.documentType.icon,
+            collection: ancestor.documentType.collection ? { unique: ancestor.documentType.collection.id } : null,
+        },
+        entityType: UMB_DOCUMENT_ENTITY_TYPE,
+        hasChildren: ancestor.hasChildren,
+        isProtected: ancestor.isProtected,
+        isTrashed: ancestor.isTrashed,
+        parent: ancestor.parent ? { unique: ancestor.parent.id } : null,
+        unique: ancestor.id,
+        variants: ancestor.variants.map((variant) => ({
+            name: variant.name,
+            culture: variant.culture || null,
+            state: variant.state,
+            flags: variant.flags,
+        })),
+        flags: ancestor.flags,
+    };
+}

package/dist-cms/packages/documents/documents/tree/server-data-source/document-tree.server.request-manager.d.ts

@@ -13,6 +13,7 @@ interface UmbManagementApiDocumentTreeSiblingsFromRequestArgs extends UmbManagem
     };
 }
 export declare class UmbManagementApiDocumentTreeDataRequestManager extends UmbManagementApiTreeDataRequestManager<DocumentTreeItemResponseModel, UmbManagementApiDocumentTreeRootItemsRequestArgs, PagedDocumentTreeItemResponseModel, UmbManagementApiDocumentTreeChildrenOfRequestArgs, PagedDocumentTreeItemResponseModel, UmbManagementApiTreeAncestorsOfRequestArgs, Array<DocumentTreeItemResponseModel>, UmbManagementApiDocumentTreeSiblingsFromRequestArgs, SubsetDocumentTreeItemResponseModel> {
+    #private;
     constructor(host: UmbControllerHost);
 }
 export {};

package/dist-cms/packages/documents/documents/tree/server-data-source/document-tree.server.request-manager.js

@@ -1,7 +1,8 @@
 /* eslint-disable local-rules/no-direct-api-import */
 import { DocumentService } from '../../../../core/backend-api/index.js';
-import { UmbManagementApiTreeDataRequestManager } from '../../../../management-api/index.js';
+import { UmbManagementApiInFlightRequestCache, UmbManagementApiTreeDataRequestManager, } from '../../../../management-api/index.js';
 export class UmbManagementApiDocumentTreeDataRequestManager extends UmbManagementApiTreeDataRequestManager {
+    static #inflightRequestCache = new UmbManagementApiInFlightRequestCache();
     constructor(host) {
         super(host, {
             getRootItems: (args) => DocumentService.getTreeDocumentRoot({
@@ -32,6 +33,7 @@ export class UmbManagementApiDocumentTreeDataRequestManager extends UmbManagemen
                     after: args.paging.takeAfter,
                 },
             }),
+            inflightRequestCache: UmbManagementApiDocumentTreeDataRequestManager.#inflightRequestCache,
         });
     }
 }

package/dist-cms/packages/documents/documents/tree/tree-item/document-tree-item.context.d.ts

@@ -12,7 +12,6 @@ export declare class UmbDocumentTreeItemContext extends UmbDefaultTreeItemContex
     readonly flags: import("rxjs").Observable<import("../../../../core/entity-flag/index.js").UmbEntityFlag[]>;
     readonly ancestors: import("rxjs").Observable<import("../../../../core/entity/index.js").UmbEntityModel[]>;
     readonly isTrashed: import("rxjs").Observable<boolean>;
-    readonly noAccess: import("rxjs").Observable<boolean>;
     setIsMenu(isMenu: boolean): void;
     constructor(host: UmbControllerHost);
     setTreeItem(treeItem: UmbDocumentTreeItemModel | undefined): void;

package/dist-cms/packages/documents/documents/tree/tree-item/document-tree-item.context.js

@@ -12,11 +12,15 @@ export class UmbDocumentTreeItemContext extends UmbDefaultTreeItemContext {
     #ancestorsContext;
     #entityContentTypeContext;
     #item;
+    // A collection is only browsed via its Collection view when the user can actually access it.
+    // When the node is a "no access" ancestor of the user's start node, it must remain expandable
+    // in the tree so the user can browse down to their start node.
+    #collapsibleCollection;
     setIsMenu(isMenu) {
         super.setIsMenu(isMenu);
         if (isMenu) {
-            this.observe(this.hasCollection, (hasCollection) => {
-                if (hasCollection) {
+            this.observe(this.#collapsibleCollection, (collapsibleCollection) => {
+                if (collapsibleCollection) {
                     this._treeItemChildrenManager.setTargetTakeSize(1, 1);
                     this.observe(this.hasActiveDescendant, (active) => {
                         if (active === false) {
@@ -24,6 +28,9 @@ export class UmbDocumentTreeItemContext extends UmbDefaultTreeItemContext {
                         }
                     }, 'observeCollectionHasActiveDescendant');
                 }
+                else {
+                    this.removeUmbControllerByAlias('observeCollectionHasActiveDescendant');
+                }
             }, '_whenMenuObserveHasCollection');
         }
     }
@@ -46,7 +53,10 @@ export class UmbDocumentTreeItemContext extends UmbDefaultTreeItemContext {
         // TODO: Move to API
         this.ancestors = this._treeItem.asObservablePart((item) => item?.ancestors ?? []);
         this.isTrashed = this._treeItem.asObservablePart((item) => item?.isTrashed ?? false);
-        this.noAccess = this._treeItem.asObservablePart((item) => item?.noAccess ?? false);
+        // A collection is only browsed via its Collection view when the user can actually access it.
+        // When the node is a "no access" ancestor of the user's start node, it must remain expandable
+        // in the tree so the user can browse down to their start node.
+        this.#collapsibleCollection = mergeObservables([this.hasCollection, this.noAccess], ([hasCollection, noAccess]) => hasCollection && !noAccess);
         this.observe(this.isTrashed, (isTrashed) => {
             this.#isTrashedContext.setIsTrashed(isTrashed);
         });
@@ -65,7 +75,7 @@ export class UmbDocumentTreeItemContext extends UmbDefaultTreeItemContext {
         return this.#item.getHasCollection();
     }
     showChildren() {
-        if (this.getIsMenu() && this.#item.getHasCollection()) {
+        if (this.getIsMenu() && this.#getCollapsibleCollection()) {
             // Collections cannot be expanded via a menu, instead we open the Collection for the user.
             this.#openCollection();
             return;
@@ -73,12 +83,15 @@ export class UmbDocumentTreeItemContext extends UmbDefaultTreeItemContext {
         super.showChildren();
     }
     hideChildren() {
-        if (this.getIsMenu() && this.#item.getHasCollection()) {
+        if (this.getIsMenu() && this.#getCollapsibleCollection()) {
             // Collections in a menu will collapse when already showing children, and instead we open the Collection for the user.
             this.#openCollection();
         }
         super.hideChildren();
     }
+    #getCollapsibleCollection() {
+        return this.#item.getHasCollection() && this.getTreeItem()?.noAccess !== true;
+    }
     #openCollection() {
         // open the collection view for this item:
         history.pushState(null, '', ensureSlash(this.getPath()) + '?openCollection=true');