@umbraco-cms/backoffice 14.0.0--preview004-24474e88 → 14.0.0--preview004-19e302a4

package/dist-cms/custom-elements.json

@@ -6138,6 +6138,39 @@
         }
       ]
     },
+    {
+      "name": "umb-media-type-design-workspace-view",
+      "path": "./../src/packages/media/media-types/workspace/views/details/media-type-design-workspace-view.element.ts",
+      "properties": [
+        {
+          "name": "styles",
+          "type": "array",
+          "default": "[\"UmbTextStyles\",null]"
+        }
+      ]
+    },
+    {
+      "name": "umb-media-type-list-view-workspace-view",
+      "path": "./../src/packages/media/media-types/workspace/views/details/media-type-list-view-workspace-view.element.ts",
+      "properties": [
+        {
+          "name": "styles",
+          "type": "array",
+          "default": "[\"UmbTextStyles\",null]"
+        }
+      ]
+    },
+    {
+      "name": "umb-media-type-permissions-workspace-view",
+      "path": "./../src/packages/media/media-types/workspace/views/details/media-type-permissions-workspace-view.element.ts",
+      "properties": [
+        {
+          "name": "styles",
+          "type": "array",
+          "default": "[\"UmbTextStyles\",null]"
+        }
+      ]
+    },
     {
       "name": "umb-collection-view-media-test",
       "path": "./../src/packages/media/media/collection-view/collection-view-media-test.element.ts",

package/dist-cms/mocks/browser-handlers.js

@@ -16,7 +16,7 @@ import { handlers as profilingHandlers } from './handlers/performance-profiling.
 import { handlers as documentHandlers } from './handlers/document/index.js';
 import { handlers as mediaHandlers } from './handlers/media.handlers.js';
 import { handlers as dictionaryHandlers } from './handlers/dictionary.handlers.js';
-import { handlers as mediaTypeHandlers } from './handlers/media-type.handlers.js';
+import { handlers as mediaTypeHandlers } from './handlers/media-type/index.js';
 import { handlers as memberGroupHandlers } from './handlers/member-group.handlers.js';
 import { handlers as memberHandlers } from './handlers/member.handlers.js';
 import { handlers as memberTypeHandlers } from './handlers/member-type.handlers.js';

package/dist-cms/mocks/data/media-type.data.d.ts

@@ -1,12 +1,17 @@
-import type { MediaTypeDetails } from '../../packages/media/media-types/types.js';
 import { UmbEntityData } from './entity.data.js';
-import { FolderTreeItemResponseModel, PagedMediaTreeItemResponseModel } from '../../external/backend-api/index.js';
-export declare const data: Array<MediaTypeDetails>;
-declare class UmbMediaTypeData extends UmbEntityData<MediaTypeDetails> {
+import { MediaTypeResponseModel, MediaTypeTreeItemResponseModel } from '../../external/backend-api/index.js';
+export declare const data: Array<MediaTypeResponseModel>;
+export declare const treeData: Array<MediaTypeTreeItemResponseModel>;
+declare class UmbMediaTypeData extends UmbEntityData<MediaTypeResponseModel> {
+    private treeData;
     constructor();
-    getTreeRoot(): PagedMediaTreeItemResponseModel;
-    getTreeItemChildren(id: string): PagedMediaTreeItemResponseModel;
-    getTreeItem(ids: Array<string>): Array<FolderTreeItemResponseModel>;
+    insert(item: MediaTypeResponseModel): import("../../external/backend-api/index.js").ContentTypeResponseModelBaseMediaTypePropertyTypeResponseModelMediaTypePropertyTypeContainerResponseModel;
+    update(id: string, item: MediaTypeResponseModel): import("../../external/backend-api/index.js").ContentTypeResponseModelBaseMediaTypePropertyTypeResponseModelMediaTypePropertyTypeContainerResponseModel;
+    getItems(ids: Array<string>): Array<MediaTypeTreeItemResponseModel>;
+    getTreeRoot(): Array<MediaTypeTreeItemResponseModel>;
+    getTreeItemChildren(id: string): Array<MediaTypeTreeItemResponseModel>;
+    getTreeItems(ids: Array<string>): Array<MediaTypeTreeItemResponseModel>;
+    getAllowedTypesOf(id: string): Array<MediaTypeTreeItemResponseModel>;
 }
 export declare const umbMediaTypeData: UmbMediaTypeData;
 export {};

package/dist-cms/mocks/data/media-type.data.js

@@ -1,27 +1,25 @@
 import { UmbEntityData } from './entity.data.js';
-import { createFolderTreeItem } from './utils.js';
+import { createMediaTypeTreeItem } from './utils.js';
 export const data = [
     {
         name: 'Media Type 1',
-        type: 'media-type',
-        hasChildren: false,
         id: 'c5159663-eb82-43ee-bd23-e42dc5e71db6',
-        isContainer: false,
-        parentId: null,
-        isFolder: false,
+        description: 'Media type 1 description',
         alias: 'mediaType1',
+        icon: 'umb:bug',
         properties: [],
+        containers: [],
     },
+];
+export const treeData = [
     {
-        name: 'Media Type 2',
+        name: data[0].name,
+        id: data[0].id,
+        icon: data[0].icon,
         type: 'media-type',
         hasChildren: false,
-        id: '22da1b0b-c310-4730-9912-c30b3eb9802e',
         isContainer: false,
         parentId: null,
-        isFolder: false,
-        alias: 'mediaType2',
-        properties: [],
     },
 ];
 // Temp mocked database
@@ -31,22 +29,48 @@ export const data = [
 class UmbMediaTypeData extends UmbEntityData {
     constructor() {
         super(data);
+        this.treeData = treeData;
+    }
+    // TODO: Can we do this smarter so we don't need to make this for each mock data:
+    insert(item) {
+        const result = super.insert(item);
+        this.treeData.push(createMediaTypeTreeItem(result));
+        return result;
+    }
+    update(id, item) {
+        const result = super.save(id, item);
+        this.treeData = this.treeData.map((x) => {
+            if (x.id === result.id) {
+                return createMediaTypeTreeItem(result);
+            }
+            else {
+                return x;
+            }
+        });
+        return result;
+    }
+    getItems(ids) {
+        const items = this.data.filter((item) => ids.includes(item.id ?? ''));
+        return items.map((item) => item);
     }
     getTreeRoot() {
-        const items = this.data.filter((item) => item.parentId === null);
-        const treeItems = items.map((item) => createFolderTreeItem(item));
-        const total = items.length;
-        return { items: treeItems, total };
+        const rootItems = this.treeData.filter((item) => item.parentId === null);
+        const result = rootItems.map((item) => createMediaTypeTreeItem(item));
+        return result;
     }
     getTreeItemChildren(id) {
-        const items = this.data.filter((item) => item.parentId === id);
-        const treeItems = items.map((item) => createFolderTreeItem(item));
-        const total = items.length;
-        return { items: treeItems, total };
+        const childItems = this.treeData.filter((item) => item.parentId === id);
+        return childItems.map((item) => item);
     }
-    getTreeItem(ids) {
-        const items = this.data.filter((item) => ids.includes(item.id ?? ''));
-        return items.map((item) => createFolderTreeItem(item));
+    getTreeItems(ids) {
+        const items = this.treeData.filter((item) => ids.includes(item.id ?? ''));
+        return items.map((item) => item);
+    }
+    getAllowedTypesOf(id) {
+        const mediaType = this.getById(id);
+        const allowedTypeKeys = mediaType?.allowedContentTypes?.map((mediaType) => mediaType.id) ?? [];
+        const items = this.treeData.filter((item) => allowedTypeKeys.includes(item.id ?? ''));
+        return items.map((item) => item);
     }
 }
 export const umbMediaTypeData = new UmbMediaTypeData();

package/dist-cms/mocks/data/utils.d.ts

@@ -1,4 +1,4 @@
-import type { ContentTreeItemResponseModel, DocumentTreeItemResponseModel, DocumentTypeTreeItemResponseModel, EntityTreeItemResponseModel, FolderTreeItemResponseModel, DocumentTypeResponseModel, FileSystemTreeItemPresentationModel, DocumentResponseModel, TextFileResponseModelBaseModel, FileItemResponseModelBaseModel } from '../../external/backend-api/index.js';
+import type { ContentTreeItemResponseModel, DocumentTreeItemResponseModel, DocumentTypeTreeItemResponseModel, EntityTreeItemResponseModel, FolderTreeItemResponseModel, DocumentTypeResponseModel, FileSystemTreeItemPresentationModel, DocumentResponseModel, TextFileResponseModelBaseModel, FileItemResponseModelBaseModel, MediaTypeResponseModel, MediaTypeTreeItemResponseModel } from '../../external/backend-api/index.js';
 export declare const createEntityTreeItem: (item: any) => EntityTreeItemResponseModel;
 export declare const createFolderTreeItem: (item: any) => FolderTreeItemResponseModel;
 export declare const createContentTreeItem: (item: any) => ContentTreeItemResponseModel & {
@@ -8,6 +8,7 @@ export declare const createDocumentTreeItem: (item: DocumentResponseModel) => Do
     isTrashed: boolean;
 };
 export declare const createDocumentTypeTreeItem: (item: DocumentTypeResponseModel) => DocumentTypeTreeItemResponseModel;
+export declare const createMediaTypeTreeItem: (item: MediaTypeResponseModel) => MediaTypeTreeItemResponseModel;
 export declare const createFileSystemTreeItem: (item: any) => FileSystemTreeItemPresentationModel;
 export declare const createTextFileItem: (item: any) => TextFileResponseModelBaseModel;
 export declare const createFileItemResponseModelBaseModel: (item: any) => FileItemResponseModelBaseModel;

package/dist-cms/mocks/data/utils.js

@@ -46,6 +46,12 @@ export const createDocumentTypeTreeItem = (item) => {
         isElement: item.isElement,
     };
 };
+export const createMediaTypeTreeItem = (item) => {
+    return {
+        ...createEntityTreeItem(item),
+        type: 'media-type',
+    };
+};
 export const createFileSystemTreeItem = (item) => {
     return {
         name: item.name,

package/dist-cms/mocks/handlers/media-type/detail.handlers.d.ts

@@ -0,0 +1 @@
+export declare const detailHandlers: import("msw").RestHandler<import("msw/lib/glossary-de6278a9.js").M<import("msw/lib/glossary-de6278a9.js").h>>[];

package/dist-cms/mocks/handlers/media-type/detail.handlers.js

@@ -0,0 +1,37 @@
+const { rest } = window.MockServiceWorker;
+import { umbMediaTypeData } from '../../data/media-type.data.js';
+import { slug } from './slug.js';
+import { umbracoPath } from '../../../shared/utils/index.js';
+export const detailHandlers = [
+    rest.post(umbracoPath(`${slug}`), async (req, res, ctx) => {
+        const data = await req.json();
+        if (!data)
+            return;
+        umbMediaTypeData.insert(data);
+        return res(ctx.status(200));
+    }),
+    rest.get(umbracoPath(`${slug}/:id`), (req, res, ctx) => {
+        const id = req.params.id;
+        if (!id)
+            return;
+        const data = umbMediaTypeData.getById(id);
+        return res(ctx.status(200), ctx.json(data));
+    }),
+    rest.put(umbracoPath(`${slug}/:id`), async (req, res, ctx) => {
+        const id = req.params.id;
+        if (!id)
+            return;
+        const data = await req.json();
+        if (!data)
+            return;
+        const saved = umbMediaTypeData.save(id, data);
+        return res(ctx.status(200), ctx.json(saved));
+    }),
+    rest.delete(umbracoPath(`${slug}/:id`), async (req, res, ctx) => {
+        const id = req.params.id;
+        if (!id)
+            return;
+        umbMediaTypeData.delete([id]);
+        return res(ctx.status(200));
+    }),
+];

package/dist-cms/mocks/handlers/media-type/index.js

@@ -0,0 +1,4 @@
+import { treeHandlers } from './tree.handlers.js';
+import { itemHandlers } from './item.handlers.js';
+import { detailHandlers } from './detail.handlers.js';
+export const handlers = [...treeHandlers, ...itemHandlers, ...detailHandlers];

package/dist-cms/mocks/handlers/media-type/item.handlers.d.ts

@@ -0,0 +1 @@
+export declare const itemHandlers: import("msw").RestHandler<import("msw/lib/glossary-de6278a9.js").M<import("msw/lib/glossary-de6278a9.js").h>>[];

package/dist-cms/mocks/handlers/media-type/item.handlers.js

@@ -0,0 +1,20 @@
+const { rest } = window.MockServiceWorker;
+import { umbMediaTypeData } from '../../data/media-type.data.js';
+import { slug } from './slug.js';
+import { umbracoPath } from '../../../shared/utils/index.js';
+export const itemHandlers = [
+    rest.get(umbracoPath(`${slug}/item`), (req, res, ctx) => {
+        const ids = req.url.searchParams.getAll('id');
+        if (!ids)
+            return;
+        const items = umbMediaTypeData.getItems(ids);
+        return res(ctx.status(200), ctx.json(items));
+    }),
+    rest.get(umbracoPath(`/tree${slug}/item`), (req, res, ctx) => {
+        const ids = req.url.searchParams.getAll('id');
+        if (!ids)
+            return;
+        const items = umbMediaTypeData.getTreeItems(ids);
+        return res(ctx.status(200), ctx.json(items));
+    }),
+];

package/dist-cms/mocks/handlers/media-type/slug.d.ts

@@ -0,0 +1 @@
+export declare const slug = "/media-type";

package/dist-cms/mocks/handlers/media-type/slug.js

@@ -0,0 +1 @@
+export const slug = '/media-type';

package/dist-cms/mocks/handlers/media-type/tree.handlers.d.ts

@@ -0,0 +1 @@
+export declare const treeHandlers: import("msw").RestHandler<import("msw/lib/glossary-de6278a9.js").M<import("msw/lib/glossary-de6278a9.js").h>>[];

package/dist-cms/mocks/handlers/media-type/tree.handlers.js

@@ -0,0 +1,25 @@
+const { rest } = window.MockServiceWorker;
+import { umbMediaTypeData } from '../../data/media-type.data.js';
+import { slug } from './slug.js';
+import { umbracoPath } from '../../../shared/utils/index.js';
+export const treeHandlers = [
+    rest.get(umbracoPath(`/tree${slug}/root`), (req, res, ctx) => {
+        const rootItems = umbMediaTypeData.getTreeRoot();
+        const response = {
+            total: rootItems.length,
+            items: rootItems,
+        };
+        return res(ctx.status(200), ctx.json(response));
+    }),
+    rest.get(umbracoPath(`/tree${slug}/children`), (req, res, ctx) => {
+        const parentId = req.url.searchParams.get('parentId');
+        if (!parentId)
+            return;
+        const children = umbMediaTypeData.getTreeItemChildren(parentId);
+        const response = {
+            total: children.length,
+            items: children,
+        };
+        return res(ctx.status(200), ctx.json(response));
+    }),
+];

package/dist-cms/packages/media/media-types/repository/media-type-item.store.d.ts

@@ -0,0 +1,20 @@
+import { MediaTypeItemResponseModel } from '../../../../external/backend-api/index.js';
+import { UmbContextToken } from '../../../../libs/context-api/index.js';
+import { UmbControllerHostElement } from '../../../../libs/controller-api/index.js';
+import { UmbItemStore, UmbStoreBase } from '../../../core/store/index.js';
+/**
+ * @export
+ * @class UmbMediaTypeItemStore
+ * @extends {UmbStoreBase}
+ * @description - Data Store for Media Type items
+ */
+export declare class UmbMediaTypeItemStore extends UmbStoreBase<MediaTypeItemResponseModel> implements UmbItemStore<MediaTypeItemResponseModel> {
+    /**
+     * Creates an instance of UmbMediaTypeItemStore.
+     * @param {UmbControllerHostElement} host
+     * @memberof UmbMediaTypeItemStore
+     */
+    constructor(host: UmbControllerHostElement);
+    items(ids: Array<string>): import("rxjs").Observable<MediaTypeItemResponseModel[]>;
+}
+export declare const UMB_MEDIA_TYPE_ITEM_STORE_CONTEXT_TOKEN: UmbContextToken<UmbMediaTypeItemStore, UmbMediaTypeItemStore>;

package/dist-cms/packages/media/media-types/repository/media-type-item.store.js

@@ -0,0 +1,23 @@
+import { UmbContextToken } from '../../../../libs/context-api/index.js';
+import { UmbStoreBase } from '../../../core/store/index.js';
+import { UmbArrayState } from '../../../../libs/observable-api/index.js';
+/**
+ * @export
+ * @class UmbMediaTypeItemStore
+ * @extends {UmbStoreBase}
+ * @description - Data Store for Media Type items
+ */
+export class UmbMediaTypeItemStore extends UmbStoreBase {
+    /**
+     * Creates an instance of UmbMediaTypeItemStore.
+     * @param {UmbControllerHostElement} host
+     * @memberof UmbMediaTypeItemStore
+     */
+    constructor(host) {
+        super(host, UMB_MEDIA_TYPE_ITEM_STORE_CONTEXT_TOKEN.toString(), new UmbArrayState([], (x) => x.id));
+    }
+    items(ids) {
+        return this._data.asObservablePart((items) => items.filter((item) => ids.includes(item.id ?? '')));
+    }
+}
+export const UMB_MEDIA_TYPE_ITEM_STORE_CONTEXT_TOKEN = new UmbContextToken('UmbMediaTypeItemStore');

package/dist-cms/packages/media/media-types/repository/media-type.detail.store.d.ts

@@ -1,7 +1,7 @@
-import type { MediaTypeDetails } from '../types.js';
 import { UmbContextToken } from '../../../../libs/context-api/index.js';
 import { UmbStoreBase } from '../../../core/store/index.js';
 import { UmbControllerHostElement } from '../../../../libs/controller-api/index.js';
+import { MediaTypeResponseModel } from '../../../../external/backend-api/index.js';
 /**
  * @export
  * @class UmbMediaTypeDetailStore
@@ -10,7 +10,8 @@ import { UmbControllerHostElement } from '../../../../libs/controller-api/index.
  */
 export declare class UmbMediaTypeStore extends UmbStoreBase {
     constructor(host: UmbControllerHostElement);
-    append(mediaType: MediaTypeDetails): void;
+    byId(id: MediaTypeResponseModel['id']): import("rxjs").Observable<any>;
+    append(mediaType: MediaTypeResponseModel): void;
     remove(uniques: string[]): void;
 }
 export declare const UMB_MEDIA_TYPE_STORE_CONTEXT_TOKEN: UmbContextToken<UmbMediaTypeStore, UmbMediaTypeStore>;

package/dist-cms/packages/media/media-types/repository/media-type.detail.store.js

@@ -11,6 +11,9 @@ export class UmbMediaTypeStore extends UmbStoreBase {
     constructor(host) {
         super(host, UMB_MEDIA_TYPE_STORE_CONTEXT_TOKEN.toString(), new UmbArrayState([], (x) => x.id));
     }
+    byId(id) {
+        return this._data.asObservablePart((x) => x.find((y) => y.id === id));
+    }
     append(mediaType) {
         this._data.append([mediaType]);
     }

package/dist-cms/packages/media/media-types/repository/media-type.repository.d.ts

@@ -1,8 +1,7 @@
-import type { MediaTypeDetails } from '../types.js';
 import { UmbControllerHostElement } from '../../../../libs/controller-api/index.js';
-import { UmbTreeRepository } from '../../../core/repository/index.js';
-import { EntityTreeItemResponseModel } from '../../../../external/backend-api/index.js';
-export declare class UmbMediaTypeRepository implements UmbTreeRepository<EntityTreeItemResponseModel> {
+import { UmbTreeRepository, UmbItemRepository, UmbDetailRepository } from '../../../core/repository/index.js';
+import { CreateMediaTypeRequestModel, FolderTreeItemResponseModel, MediaTypeItemResponseModel, MediaTypeResponseModel, UpdateMediaTypeRequestModel } from '../../../../external/backend-api/index.js';
+export declare class UmbMediaTypeRepository implements UmbItemRepository<MediaTypeItemResponseModel>, UmbTreeRepository<FolderTreeItemResponseModel>, UmbDetailRepository<CreateMediaTypeRequestModel, any, UpdateMediaTypeRequestModel, MediaTypeResponseModel> {
     #private;
     constructor(host: UmbControllerHostElement);
     requestTreeRoot(): Promise<{
@@ -17,35 +16,39 @@ export declare class UmbMediaTypeRepository implements UmbTreeRepository<EntityT
     requestRootTreeItems(): Promise<{
         data: import("../../../core/repository/index.js").UmbPagedData<any> | undefined;
         error: import("../../../../external/backend-api/index.js").ApiError | import("../../../../external/backend-api/index.js").CancelError | undefined;
-        asObservable: () => import("rxjs").Observable<EntityTreeItemResponseModel[]>;
+        asObservable: () => import("rxjs").Observable<import("../../../../external/backend-api/index.js").EntityTreeItemResponseModel[]>;
     }>;
     requestTreeItemsOf(parentId: string | null): Promise<{
         data: import("../../../core/repository/index.js").UmbPagedData<any> | undefined;
         error: import("../../../../external/backend-api/index.js").ApiError | import("../../../../external/backend-api/index.js").CancelError | undefined;
-        asObservable: () => import("rxjs").Observable<EntityTreeItemResponseModel[]>;
+        asObservable: () => import("rxjs").Observable<import("../../../../external/backend-api/index.js").EntityTreeItemResponseModel[]>;
     }>;
+    byId(id: string): Promise<import("rxjs").Observable<any>>;
     requestItemsLegacy(ids: Array<string>): Promise<{
         data: any[] | undefined;
         error: import("../../../../external/backend-api/index.js").ApiError | import("../../../../external/backend-api/index.js").CancelError | undefined;
-        asObservable: () => import("rxjs").Observable<EntityTreeItemResponseModel[]>;
-    }>;
-    rootTreeItems(): Promise<import("rxjs").Observable<EntityTreeItemResponseModel[]>>;
-    treeItemsOf(parentId: string | null): Promise<import("rxjs").Observable<EntityTreeItemResponseModel[]>>;
-    itemsLegacy(ids: Array<string>): Promise<import("rxjs").Observable<EntityTreeItemResponseModel[]>>;
-    createScaffold(): Promise<{
-        data: MediaTypeDetails;
+        asObservable: () => import("rxjs").Observable<import("../../../../external/backend-api/index.js").EntityTreeItemResponseModel[]>;
+    }>;
+    rootTreeItems(): Promise<import("rxjs").Observable<import("../../../../external/backend-api/index.js").EntityTreeItemResponseModel[]>>;
+    treeItemsOf(parentId: string | null): Promise<import("rxjs").Observable<import("../../../../external/backend-api/index.js").EntityTreeItemResponseModel[]>>;
+    itemsLegacy(ids: Array<string>): Promise<import("rxjs").Observable<import("../../../../external/backend-api/index.js").EntityTreeItemResponseModel[]>>;
+    createScaffold(parentId: string | null): Promise<import("../../../core/repository/index.js").DataSourceResponse<import("../../../../external/backend-api/index.js").CreateContentTypeRequestModelBaseCreateMediaTypePropertyTypeRequestModelCreateMediaTypePropertyTypeContainerRequestModel>>;
+    requestById(id: string): Promise<{
+        data: import("../../../../external/backend-api/index.js").ContentTypeResponseModelBaseMediaTypePropertyTypeResponseModelMediaTypePropertyTypeContainerResponseModel | undefined;
+        error: import("../../../../external/backend-api/index.js").ApiError | import("../../../../external/backend-api/index.js").CancelError | undefined;
     }>;
-    requestDetails(id: string): Promise<{
-        data: any;
-        error: any;
+    requestItems(ids: Array<string>): Promise<{
+        data: MediaTypeItemResponseModel[] | undefined;
+        error: import("../../../../external/backend-api/index.js").ApiError | import("../../../../external/backend-api/index.js").CancelError | undefined;
+        asObservable: () => import("rxjs").Observable<MediaTypeItemResponseModel[]>;
     }>;
-    delete(id: string): Promise<any>;
-    save(mediaType: MediaTypeDetails): Promise<{
-        error: any;
+    items(ids: Array<string>): Promise<import("rxjs").Observable<MediaTypeItemResponseModel[]>>;
+    delete(id: string): Promise<import("../../../core/repository/index.js").DataSourceResponse<unknown>>;
+    save(id: string, item: UpdateMediaTypeRequestModel): Promise<{
+        error: import("../../../../external/backend-api/index.js").ApiError | import("../../../../external/backend-api/index.js").CancelError | undefined;
     }>;
-    create(mediaType: MediaTypeDetails): Promise<{
-        data: any;
-        error: any;
+    create(mediaType: CreateMediaTypeRequestModel): Promise<{
+        error: import("../../../../external/backend-api/index.js").ApiError | import("../../../../external/backend-api/index.js").CancelError | undefined;
     }>;
     move(): Promise<void>;
     copy(): Promise<void>;

package/dist-cms/packages/media/media-types/repository/media-type.repository.js

@@ -2,6 +2,8 @@ import { UMB_MEDIA_TYPE_TREE_STORE_CONTEXT_TOKEN } from './media-type.tree.store
 import { UmbMediaTypeDetailServerDataSource } from './sources/media-type.detail.server.data.js';
 import { UMB_MEDIA_TYPE_STORE_CONTEXT_TOKEN } from './media-type.detail.store.js';
 import { UmbMediaTypeTreeServerDataSource } from './sources/media-type.tree.server.data.js';
+import { UMB_MEDIA_TYPE_ITEM_STORE_CONTEXT_TOKEN } from './media-type-item.store.js';
+import { UmbMediaTypeItemServerDataSource } from './sources/media-type-item.server.data.js';
 import { UmbContextConsumerController } from '../../../../libs/context-api/index.js';
 import { UMB_NOTIFICATION_CONTEXT_TOKEN } from '../../../core/notification/index.js';
 export class UmbMediaTypeRepository {
@@ -10,26 +12,31 @@ export class UmbMediaTypeRepository {
     #treeSource;
     #treeStore;
     #detailSource;
-    #store;
+    #detailStore;
+    #itemSource;
+    #itemStore;
     #notificationContext;
     constructor(host) {
         this.#host = host;
         // TODO: figure out how spin up get the correct data source
         this.#treeSource = new UmbMediaTypeTreeServerDataSource(this.#host);
         this.#detailSource = new UmbMediaTypeDetailServerDataSource(this.#host);
+        this.#itemSource = new UmbMediaTypeItemServerDataSource(this.#host);
         this.#init = Promise.all([
             new UmbContextConsumerController(this.#host, UMB_MEDIA_TYPE_STORE_CONTEXT_TOKEN, (instance) => {
-                this.#store = instance;
+                this.#detailStore = instance;
             }),
             new UmbContextConsumerController(this.#host, UMB_MEDIA_TYPE_TREE_STORE_CONTEXT_TOKEN, (instance) => {
                 this.#treeStore = instance;
             }),
+            new UmbContextConsumerController(this.#host, UMB_MEDIA_TYPE_ITEM_STORE_CONTEXT_TOKEN, (instance) => {
+                this.#itemStore = instance;
+            }),
             new UmbContextConsumerController(this.#host, UMB_NOTIFICATION_CONTEXT_TOKEN, (instance) => {
                 this.#notificationContext = instance;
             }),
         ]);
     }
-    // TREE:
     async requestTreeRoot() {
         await this.#init;
         const data = {
@@ -59,6 +66,12 @@ export class UmbMediaTypeRepository {
         }
         return { data, error, asObservable: () => this.#treeStore.childrenOf(parentId) };
     }
+    async byId(id) {
+        if (!id)
+            throw new Error('Key is missing');
+        await this.#init;
+        return this.#detailStore.byId(id);
+    }
     async requestItemsLegacy(ids) {
         await this.#init;
         if (!ids) {
@@ -80,58 +93,76 @@ export class UmbMediaTypeRepository {
         return this.#treeStore.items(ids);
     }
     // DETAILS
-    async createScaffold() {
+    async createScaffold(parentId) {
+        if (parentId === undefined)
+            throw new Error('Parent id is missing');
         await this.#init;
-        return this.#detailSource.createScaffold();
+        return this.#detailSource.createScaffold(parentId);
     }
-    async requestDetails(id) {
+    async requestById(id) {
         await this.#init;
-        // TODO: should we show a notification if the id is missing?
-        // Investigate what is best for Acceptance testing, cause in that perspective a thrown error might be the best choice?
         if (!id) {
             throw new Error('Id is missing');
         }
         const { data, error } = await this.#detailSource.get(id);
         if (data) {
-            this.#store?.append(data);
+            this.#detailStore?.append(data);
         }
         return { data, error };
     }
+    async requestItems(ids) {
+        if (!ids)
+            throw new Error('Keys are missing');
+        await this.#init;
+        const { data, error } = await this.#itemSource.getItems(ids);
+        if (data) {
+            this.#itemStore?.appendItems(data);
+        }
+        return { data, error, asObservable: () => this.#itemStore.items(ids) };
+    }
+    async items(ids) {
+        await this.#init;
+        return this.#itemStore.items(ids);
+    }
     async delete(id) {
         await this.#init;
         return this.#detailSource.delete(id);
     }
-    async save(mediaType) {
+    async save(id, item) {
+        if (!id)
+            throw new Error('Data Type id is missing');
+        if (!item)
+            throw new Error('Media Type is missing');
         await this.#init;
-        // TODO: should we show a notification if the media type is missing?
-        // Investigate what is best for Acceptance testing, cause in that perspective a thrown error might be the best choice?
-        if (!mediaType || !mediaType.id) {
-            throw new Error('Media type is missing');
-        }
-        const { error } = await this.#detailSource.update(mediaType);
+        const { error } = await this.#detailSource.update(id, item);
         if (!error) {
-            const notification = { data: { message: `Media type '${mediaType.name}' saved` } };
+            this.#detailStore?.append(item);
+            this.#treeStore?.updateItem(id, item);
+            const notification = { data: { message: `Media type '${item.name}' saved` } };
             this.#notificationContext?.peek('positive', notification);
         }
-        // TODO: we currently don't use the detail store for anything.
-        // Consider to look up the data before fetching from the server
-        // Consider notify a workspace if a media type is updated in the store while someone is editing it.
-        this.#store?.append(mediaType);
-        this.#treeStore?.updateItem(mediaType.id, { name: mediaType.name });
-        // TODO: would be nice to align the stores on methods/methodNames.
         return { error };
     }
     async create(mediaType) {
+        if (!mediaType || !mediaType.id)
+            throw new Error('Document Type is missing');
         await this.#init;
-        if (!mediaType.name) {
-            throw new Error('Name is missing');
-        }
-        const { data, error } = await this.#detailSource.insert(mediaType);
+        const { error } = await this.#detailSource.insert(mediaType);
         if (!error) {
-            const notification = { data: { message: `Media type '${mediaType.name}' created` } };
-            this.#notificationContext?.peek('positive', notification);
+            //TODO: Model mismatch. FIX
+            this.#detailStore?.append(mediaType);
+            const treeItem = {
+                type: 'media-type',
+                parentId: null,
+                name: mediaType.name,
+                id: mediaType.id,
+                isFolder: false,
+                isContainer: false,
+                hasChildren: false,
+            };
+            this.#treeStore?.appendItems([treeItem]);
         }
-        return { data, error };
+        return { error };
     }
     async move() {
         alert('move me!');