chore: standardize chrono provider

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

src/services/collectionService.ts

@@ -2,9 +2,7 @@
  * Collection management service
  */
 
-import { createFetchWrapper } from '@KTXC/utils/helpers/fetch-wrapper-core';
-
-const fetchWrapper = createFetchWrapper();
+import { transceivePost } from './transceive';
 import type {
   CollectionListRequest,
   CollectionListResponse,
@@ -14,74 +12,119 @@ 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, CollectionPropertiesObject } from '../models/collection';
 
-const BASE_URL = '/m/chrono_manager/collection';
+/**
+ * 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 fetchWrapper.post(`${BASE_URL}/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> {
-    return await fetchWrapper.post(`${BASE_URL}/extant`, request);
-  },
-
-  /**
-   * Fetch a specific collection
-   * 
-   * @param request - Collection fetch request
-   * @returns Promise with collection details
-   */
-  async fetch(request: CollectionFetchRequest): Promise<CollectionFetchResponse> {
-    return await fetchWrapper.post(`${BASE_URL}/fetch`, request);
+    return await transceivePost<CollectionExtantRequest, CollectionExtantResponse>('collection.extant', request);
   },
 
   /**
    * Create a new collection
    * 
-   * @param request - Collection create request
-   * @returns Promise with created collection
+   * @param request - create request parameters
+   * 
+   * @returns Promise with created collection object
    */
-  async create(request: CollectionCreateRequest): Promise<CollectionCreateResponse> {
-    return await fetchWrapper.post(`${BASE_URL}/create`, request);
+  async create(request: CollectionCreateRequest): Promise<CollectionObject> {
+    if (request.properties instanceof CollectionPropertiesObject) {
+      request.properties = request.properties.toJson();
+    }
+    const response = await transceivePost<CollectionCreateRequest, CollectionCreateResponse>('collection.create', request);
+    return createCollectionObject(response);
   },
 
   /**
-   * Modify an existing collection
+   * Update an existing collection
    * 
-   * @param request - Collection modify request
-   * @returns Promise with modified collection
+   * @param request - update request parameters
+   * 
+   * @returns Promise with updated collection object
    */
-  async modify(request: CollectionModifyRequest): Promise<CollectionModifyResponse> {
-    return await fetchWrapper.post(`${BASE_URL}/modify`, request);
+  async update(request: CollectionUpdateRequest): Promise<CollectionObject> {
+    if (request.properties instanceof CollectionPropertiesObject) {
+      request.properties = request.properties.toJson();
+    }
+    const response = await transceivePost<CollectionUpdateRequest, CollectionUpdateResponse>('collection.update', request);
+    return createCollectionObject(response);
   },
 
   /**
    * Delete a collection
    * 
-   * @param request - Collection destroy request
+   * @param request - delete request parameters
+   * 
    * @returns Promise with deletion result
    */
-  async destroy(request: CollectionDestroyRequest): Promise<CollectionDestroyResponse> {
-    return await fetchWrapper.post(`${BASE_URL}/destroy`, request);
+  async delete(request: CollectionDeleteRequest): Promise<CollectionDeleteResponse> {
+    return await transceivePost<CollectionDeleteRequest, CollectionDeleteResponse>('collection.delete', request);
   },
 };