chore: standardize protocol

Signed-off-by: Sebastian Krupinski <krupinski01@gmail.com>

src/services/collectionService.ts

@@ -12,28 +12,74 @@ import type {
   CollectionFetchResponse,
   CollectionCreateRequest,
   CollectionCreateResponse,
-  CollectionModifyRequest,
-  CollectionModifyResponse,
-  CollectionDestroyRequest,
-  CollectionDestroyResponse
+  CollectionUpdateResponse,
+  CollectionUpdateRequest,
+  CollectionDeleteResponse,
+  CollectionDeleteRequest,
+  CollectionInterface,
 } from '../types/collection';
+import { useIntegrationStore } from '@KTXC/stores/integrationStore';
+import { CollectionObject } from '../models';
+
+/**
+ * Helper to create the right collection model class based on provider identifier
+ * Uses provider-specific factory if available, otherwise returns base CollectionObject
+ */
+function createCollectionObject(data: CollectionInterface): CollectionObject {
+  const integrationStore = useIntegrationStore();
+  const factoryItem = integrationStore.getItemById('mail_collection_factory', data.provider) as any;
+  const factory = factoryItem?.factory;
+  
+  // Use provider factory if available, otherwise base class
+  return factory ? factory(data) : new CollectionObject().fromJson(data);
+}
 
 export const collectionService = {
 
   /**
-   * List all available collections
+   * Retrieve list of collections, optionally filtered by source selector
    * 
-   * @param request - Collection list request parameters
-   * @returns Promise with collection list grouped by provider and service
+   * @param request - list request parameters
+   * 
+   * @returns Promise with collection object list grouped by provider, service, and collection identifier
    */
-  async list(request: CollectionListRequest = {}): Promise<CollectionListResponse> {
-    return await transceivePost<CollectionListRequest, CollectionListResponse>('collection.list', request);
+  async list(request: CollectionListRequest = {}): Promise<Record<string, Record<string, Record<string, CollectionObject>>>> {
+    const response = await transceivePost<CollectionListRequest, CollectionListResponse>('collection.list', request);
+    
+    // Convert nested response to CollectionObject instances
+    const providerList: Record<string, Record<string, Record<string, CollectionObject>>> = {};
+    Object.entries(response).forEach(([providerId, providerServices]) => {
+      const serviceList: Record<string, Record<string, CollectionObject>> = {};
+      Object.entries(providerServices).forEach(([serviceId, serviceCollections]) => {
+        const collectionList: Record<string, CollectionObject> = {};
+        Object.entries(serviceCollections).forEach(([collectionId, collectionData]) => {
+          collectionList[collectionId] = createCollectionObject(collectionData);
+        });
+        serviceList[serviceId] = collectionList;
+      });
+      providerList[providerId] = serviceList;
+    });
+    
+    return providerList;
   },
 
   /**
-   * Check which collections exist/are available
+   * Retrieve a specific collection by provider and identifier
+   * 
+   * @param request - fetch request parameters
+   * 
+   * @returns Promise with collection object
+   */
+  async fetch(request: CollectionFetchRequest): Promise<CollectionObject> {
+    const response = await transceivePost<CollectionFetchRequest, CollectionFetchResponse>('collection.fetch', request);
+    return createCollectionObject(response);
+  },
+
+  /**
+   * Retrieve collection availability status for a given source selector
+   * 
+   * @param request - extant request parameters
    * 
-   * @param request - Collection extant request with source selector
    * @returns Promise with collection availability status
    */
   async extant(request: CollectionExtantRequest): Promise<CollectionExtantResponse> {
@@ -41,43 +87,38 @@ export const collectionService = {
   },
 
   /**
-   * Fetch a specific collection
+   * Create a new collection
    * 
-   * @param request - Collection fetch request
-   * @returns Promise with collection details
+   * @param request - create request parameters
+   * 
+   * @returns Promise with created collection object
    */
-  async fetch(request: CollectionFetchRequest): Promise<CollectionFetchResponse> {
-    return await transceivePost<CollectionFetchRequest, CollectionFetchResponse>('collection.fetch', request);
+  async create(request: CollectionCreateRequest): Promise<CollectionObject> {
+    const response = await transceivePost<CollectionCreateRequest, CollectionCreateResponse>('collection.create', request);
+    return createCollectionObject(response);
   },
 
   /**
-   * Create a new collection/folder
+   * Update an existing collection
    * 
-   * @param request - Collection creation parameters
-   * @returns Promise with created collection details
+   * @param request - update request parameters
+   * 
+   * @returns Promise with updated collection object
    */
-  async create(request: CollectionCreateRequest): Promise<CollectionCreateResponse> {
-    return await transceivePost<CollectionCreateRequest, CollectionCreateResponse>('collection.create', request);
+  async update(request: CollectionUpdateRequest): Promise<CollectionObject> {
+    const response = await transceivePost<CollectionUpdateRequest, CollectionUpdateResponse>('collection.update', request);
+    return createCollectionObject(response);
   },
 
   /**
-   * Modify an existing collection/folder
+   * Delete a collection
    * 
-   * @param request - Collection modification parameters
-   * @returns Promise with modified collection details
-   */
-  async modify(request: CollectionModifyRequest): Promise<CollectionModifyResponse> {
-    return await transceivePost<CollectionModifyRequest, CollectionModifyResponse>('collection.modify', request);
-  },
-
-  /**
-   * Destroy/delete a collection/folder
+   * @param request - delete request parameters
    * 
-   * @param request - Collection destroy parameters
-   * @returns Promise with destroy operation result
+   * @returns Promise with deletion result
    */
-  async destroy(request: CollectionDestroyRequest): Promise<CollectionDestroyResponse> {
-    return await transceivePost<CollectionDestroyRequest, CollectionDestroyResponse>('collection.destroy', request);
+  async delete(request: CollectionDeleteRequest): Promise<CollectionDeleteResponse> {
+    return await transceivePost<CollectionDeleteRequest, CollectionDeleteResponse>('collection.delete', request);
   },
 };