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);
   },
 };
 

src/services/entityService.ts

@@ -1,119 +1,161 @@
 /**
- * Message/Entity management service
+ * Entity management service
  */
 
 import { transceivePost } from './transceive';
 import type {
-  MessageListRequest,
-  MessageListResponse,
-  MessageDeltaRequest,
-  MessageDeltaResponse,
-  MessageExtantRequest,
-  MessageExtantResponse,
-  MessageFetchRequest,
-  MessageFetchResponse,
-  MessageSearchRequest,
-  MessageSearchResponse,
-  MessageSendRequest,
-  MessageSendResponse,
-  MessageCreateRequest,
-  MessageCreateResponse,
-  MessageUpdateRequest,
-  MessageUpdateResponse,
-  MessageDestroyRequest,
-  MessageDestroyResponse,
+  EntityListRequest,
+  EntityListResponse,
+  EntityFetchRequest,
+  EntityFetchResponse,
+  EntityExtantRequest,
+  EntityExtantResponse,
+  EntityCreateRequest,
+  EntityCreateResponse,
+  EntityUpdateRequest,
+  EntityUpdateResponse,
+  EntityDeleteRequest,
+  EntityDeleteResponse,
+  EntityDeltaRequest,
+  EntityDeltaResponse,
+  EntityTransmitRequest,
+  EntityTransmitResponse,
+  EntityInterface,
 } from '../types/entity';
+import { useIntegrationStore } from '@KTXC/stores/integrationStore';
+import { EntityObject } from '../models';
+
+/**
+ * Helper to create the right entity model class based on provider identifier
+ * Uses provider-specific factory if available, otherwise returns base EntityObject
+ */
+function createEntityObject(data: EntityInterface): EntityObject {
+  const integrationStore = useIntegrationStore();
+  const factoryItem = integrationStore.getItemById('mail_entity_factory', data.provider) as any;
+  const factory = factoryItem?.factory;
+  
+  // Use provider factory if available, otherwise base class
+  return factory ? factory(data) : new EntityObject().fromJson(data);
+}
 
 export const entityService = {
 
   /**
-   * List all available messages
+   * Retrieve list of entities, optionally filtered by source selector
    * 
-   * @param request - Message list request parameters
-   * @returns Promise with message list grouped by provider, service, and collection
+   * @param request - list request parameters
+   * 
+   * @returns Promise with entity object list grouped by provider, service, collection, and entity identifier
    */
-  async list(request: MessageListRequest = {}): Promise<MessageListResponse> {
-    return await transceivePost<MessageListRequest, MessageListResponse>('entity.list', request);
+  async list(request: EntityListRequest = {}): Promise<Record<string, Record<string, Record<string, Record<string, EntityObject>>>>> {
+    const response = await transceivePost<EntityListRequest, EntityListResponse>('entity.list', request);
+    
+    // Convert nested response to EntityObject instances
+    const providerList: Record<string, Record<string, Record<string, Record<string, EntityObject>>>> = {};
+    Object.entries(response).forEach(([providerId, providerServices]) => {
+      const serviceList: Record<string, Record<string, Record<string, EntityObject>>> = {};
+      Object.entries(providerServices).forEach(([serviceId, serviceCollections]) => {
+        const collectionList: Record<string, Record<string, EntityObject>> = {};
+        Object.entries(serviceCollections).forEach(([collectionId, collectionEntities]) => {
+          const entityList: Record<string, EntityObject> = {};
+          Object.entries(collectionEntities).forEach(([entityId, entityData]) => {
+            entityList[entityId] = createEntityObject(entityData);
+          });
+          collectionList[collectionId] = entityList;
+        });
+        serviceList[serviceId] = collectionList;
+      });
+      providerList[providerId] = serviceList;
+    });
+    
+    return providerList;
   },
 
   /**
-   * Get delta changes for messages
+   * Retrieve a specific entity by provider and identifier
+   * 
+   * @param request - fetch request parameters
+   * 
+   * @returns Promise with entity objects keyed by identifier
+   */
+  async fetch(request: EntityFetchRequest): Promise<Record<string, EntityObject>> {
+    const response = await transceivePost<EntityFetchRequest, EntityFetchResponse>('entity.fetch', request);
+    
+    // Convert response to EntityObject instances
+    const list: Record<string, EntityObject> = {};
+    Object.entries(response).forEach(([identifier, entityData]) => {
+      list[identifier] = createEntityObject(entityData);
+    });
+    
+    return list;
+  },
+
+  /**
+   * Retrieve entity availability status for a given source selector
+   * 
+   * @param request - extant request parameters
+   * 
+   * @returns Promise with entity availability status
+   */
+  async extant(request: EntityExtantRequest): Promise<EntityExtantResponse> {
+    return await transceivePost<EntityExtantRequest, EntityExtantResponse>('entity.extant', request);
+  },
+
+  /**
+   * Create a new entity
+   * 
+   * @param request - create request parameters
+   * 
+   * @returns Promise with created entity object
+   */
+  async create(request: EntityCreateRequest): Promise<EntityObject> {
+    const response = await transceivePost<EntityCreateRequest, EntityCreateResponse>('entity.create', request);
+    return createEntityObject(response);
+  },
+
+  /**
+   * Update an existing entity
+   * 
+   * @param request - update request parameters
+   * 
+   * @returns Promise with updated entity object
+   */
+  async update(request: EntityUpdateRequest): Promise<EntityObject> {
+    const response = await transceivePost<EntityUpdateRequest, EntityUpdateResponse>('entity.update', request);
+    return createEntityObject(response);
+  },
+
+  /**
+   * Delete an entity
+   * 
+   * @param request - delete request parameters
+   * 
+   * @returns Promise with deletion result
+   */
+  async delete(request: EntityDeleteRequest): Promise<EntityDeleteResponse> {
+    return await transceivePost<EntityDeleteRequest, EntityDeleteResponse>('entity.delete', request);
+  },
+
+  /**
+   * Retrieve delta changes for entities
+   * 
+   * @param request - delta request parameters
    * 
-   * @param request - Message delta request with source selector
    * @returns Promise with delta changes (created, modified, deleted)
    */
-  async delta(request: MessageDeltaRequest): Promise<MessageDeltaResponse> {
-    return await transceivePost('entity.delta', request);
+  async delta(request: EntityDeltaRequest): Promise<EntityDeltaResponse> {
+    return await transceivePost<EntityDeltaRequest, EntityDeltaResponse>('entity.delta', request);
   },
 
   /**
-   * Check which messages exist/are available
+   * Send an entity
    * 
-   * @param request - Message extant request with source selector
-   * @returns Promise with message availability status
-   */
-  async extant(request: MessageExtantRequest): Promise<MessageExtantResponse> {
-    return await transceivePost('entity.extant', request);
-  },
-
-  /**
-   * Fetch specific messages
+   * @param request - transmit request parameters
    * 
-   * @param request - Message fetch request
-   * @returns Promise with message details
+   * @returns Promise with transmission result
    */
-  async fetch(request: MessageFetchRequest): Promise<MessageFetchResponse> {
-    return await transceivePost('entity.fetch', request);
-  },
-
-  /**
-   * Search messages
-   * 
-   * @param request - Message search request
-   * @returns Promise with search results
-   */
-  async search(request: MessageSearchRequest): Promise<MessageSearchResponse> {
-    return await transceivePost('entity.search', request);
-  },
-
-  /**
-   * Send a message
-   * 
-   * @param request - Message send request
-   * @returns Promise with send result
-   */
-  async send(request: MessageSendRequest): Promise<MessageSendResponse> {
-    return await transceivePost('entity.send', request);
-  },
-
-  /**
-   * Create a new message (draft)
-   * 
-   * @param request - Message create request
-   * @returns Promise with created message details
-   */
-  async create(request: MessageCreateRequest): Promise<MessageCreateResponse> {
-    return await transceivePost('entity.create', request);
-  },
-
-  /**
-   * Update an existing message (flags, labels, etc.)
-   * 
-   * @param request - Message update request
-   * @returns Promise with update result
-   */
-  async update(request: MessageUpdateRequest): Promise<MessageUpdateResponse> {
-    return await transceivePost('entity.update', request);
-  },
-
-  /**
-   * Delete/destroy a message
-   * 
-   * @param request - Message destroy request
-   * @returns Promise with destroy result
-   */
-  async destroy(request: MessageDestroyRequest): Promise<MessageDestroyResponse> {
-    return await transceivePost('entity.destroy', request);
+  async transmit(request: EntityTransmitRequest): Promise<EntityTransmitResponse> {
+    return await transceivePost<EntityTransmitRequest, EntityTransmitResponse>('entity.transmit', request);
   },
 };
 

src/services/providerService.ts

@@ -8,18 +8,32 @@ import type {
   ProviderExtantRequest,
   ProviderExtantResponse,
   ProviderFetchRequest,
-  ProviderFetchResponse, 
+  ProviderFetchResponse,
+  ProviderInterface,
 } from '../types/provider';
+import { useIntegrationStore } from '@KTXC/stores/integrationStore';
 import { transceivePost } from './transceive';
 import { ProviderObject } from '../models/provider';
 
+/**
+ * Helper to create the right provider model class based on provider identifier
+ * Uses provider-specific factory if available, otherwise returns base ProviderObject
+ */
+function createProviderObject(data: ProviderInterface): ProviderObject {
+  const integrationStore = useIntegrationStore();
+  const factoryItem = integrationStore.getItemById('mail_provider_factory', data.identifier) as any;
+  const factory = factoryItem?.factory;
+  
+  // Use provider factory if available, otherwise base class
+  return factory ? factory(data) : new ProviderObject().fromJson(data);
+}
 
 export const providerService = {
 
   /**
-   * List available providers
+   * Retrieve list of providers, optionally filtered by source selector
    * 
-   * @param request - List request parameters
+   * @param request - list request parameters
    * 
    * @returns Promise with provider object list keyed by provider identifier
    */
@@ -29,28 +43,28 @@ export const providerService = {
     // Convert response to ProviderObject instances
     const list: Record<string, ProviderObject> = {};
     Object.entries(response).forEach(([providerId, providerData]) => {
-      list[providerId] = new ProviderObject().fromJson(providerData);
+      list[providerId] = createProviderObject(providerData);
     });
     
     return list;
   },
 
   /**
-   * Fetch a specific provider
+   * Retrieve specific provider by identifier
    * 
-   * @param request - Fetch request parameters
+   * @param request - fetch request parameters
    * 
    * @returns Promise with provider object
    */
   async fetch(request: ProviderFetchRequest): Promise<ProviderObject> {
     const response = await transceivePost<ProviderFetchRequest, ProviderFetchResponse>('provider.fetch', request);
-    return new ProviderObject().fromJson(response);
+    return createProviderObject(response);
   },
 
   /**
-   * Check which providers exist/are available
+   * Retrieve provider availability status for a given source selector
    * 
-   * @param request - Extant request parameters
+   * @param request - extant request parameters
    * 
    * @returns Promise with provider availability status
    */

src/services/serviceService.ts

@@ -18,13 +18,15 @@ import type {
   ServiceCreateRequest,
   ServiceUpdateResponse,
   ServiceUpdateRequest,
+  ServiceDeleteResponse,
+  ServiceDeleteRequest,
 } from '../types/service';
+import { useIntegrationStore } from '@KTXC/stores/integrationStore';
 import { transceivePost } from './transceive';
 import { ServiceObject } from '../models/service';
-import { useIntegrationStore } from '@KTXC/stores/integrationStore';
 
 /**
- * Helper to create the right service model class based on provider
+ * Helper to create the right service model class based on provider identifier
  * Uses provider-specific factory if available, otherwise returns base ServiceObject
  */
 function createServiceObject(data: ServiceInterface): ServiceObject {
@@ -39,9 +41,9 @@ function createServiceObject(data: ServiceInterface): ServiceObject {
 export const serviceService = {
 
   /**
-   * List available services
+   * Retrieve list of services, optionally filtered by source selector
    * 
-   * @param request - Service list request parameters
+   * @param request - list request parameters
    * 
    * @returns Promise with service object list grouped by provider and keyed by service identifier
    */
@@ -49,31 +51,23 @@ export const serviceService = {
     const response = await transceivePost<ServiceListRequest, ServiceListResponse>('service.list', request);
     
     // Convert nested response to ServiceObject instances
-    const list: Record<string, Record<string, ServiceObject>> = {};
+    const providerList: Record<string, Record<string, ServiceObject>> = {};
     Object.entries(response).forEach(([providerId, providerServices]) => {
-      list[providerId] = {};
+      const serviceList: Record<string, ServiceObject> = {};
       Object.entries(providerServices).forEach(([serviceId, serviceData]) => {
-        list[providerId][serviceId] = createServiceObject(serviceData);
+        serviceList[serviceId] = createServiceObject(serviceData);
       });
+      providerList[providerId] = serviceList;
     });
     
-    return list;
+    return providerList;
   },
 
   /**
-   * Check which services exist/are available
+   * Retrieve a specific service by provider and identifier
    * 
-   * @param request - Service extant request with source selector
-   * @returns Promise with service availability status
-   */
-  async extant(request: ServiceExtantRequest): Promise<ServiceExtantResponse> {
-    return await transceivePost<ServiceExtantRequest, ServiceExtantResponse>('service.extant', request);
-  },
-
-  /**
-   * Fetch a specific service
+   * @param request - fetch request parameters
    * 
-   * @param request - Service fetch request with provider and service IDs
    * @returns Promise with service object
    */
   async fetch(request: ServiceFetchRequest): Promise<ServiceObject> {
@@ -82,9 +76,21 @@ export const serviceService = {
   },
 
   /**
-   * Discover mail service configuration from identity
+   * Retrieve service availability status for a given source selector
+   * 
+   * @param request - extant request parameters
+   * 
+   * @returns Promise with service availability status
+   */
+  async extant(request: ServiceExtantRequest): Promise<ServiceExtantResponse> {
+    return await transceivePost<ServiceExtantRequest, ServiceExtantResponse>('service.extant', request);
+  },
+
+  /**
+   * Retrieve discoverable services for a given source selector, sorted by provider
+   * 
+   * @param request - discover request parameters
    * 
-   * @param request - Discovery request with identity and optional hints
    * @returns Promise with array of discovered services sorted by provider
    */
   async discover(request: ServiceDiscoverRequest): Promise<ServiceObject[]> {
@@ -109,7 +115,7 @@ export const serviceService = {
   },
 
   /**
-   * Test a mail service connection
+   * Test service connectivity and configuration
    * 
    * @param request - Service test request
    * @returns Promise with test results
@@ -121,7 +127,8 @@ export const serviceService = {
   /**
    * Create a new service
    * 
-   * @param request - Service create request with provider ID and service data
+   * @param request - create request parameters
+   * 
    * @returns Promise with created service object
    */
   async create(request: ServiceCreateRequest): Promise<ServiceObject> {
@@ -132,7 +139,8 @@ export const serviceService = {
   /**
    * Update a existing service
    * 
-   * @param request - Service update request with provider ID, service ID, and updated data
+   * @param request - update request parameters
+   * 
    * @returns Promise with updated service object
    */
   async update(request: ServiceUpdateRequest): Promise<ServiceObject> {
@@ -143,11 +151,12 @@ export const serviceService = {
   /**
    * Delete a service
    * 
-   * @param request - Service delete request with provider ID and service ID
+   * @param request - delete request parameters
+   * 
    * @returns Promise with deletion result
    */
   async delete(request: { provider: string; identifier: string | number }): Promise<any> {
-    return await transceivePost('service.delete', request);
+    return await transceivePost<ServiceDeleteRequest, ServiceDeleteResponse>('service.delete', request);
   },
 };