chore: standardize chrono provider

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

src/services/entityService.ts

@@ -2,99 +2,149 @@
  * Entity management service
  */
 
-import { createFetchWrapper } from '@KTXC/utils/helpers/fetch-wrapper-core';
-
-const fetchWrapper = createFetchWrapper();
+import { transceivePost } from './transceive';
 import type {
   EntityListRequest,
   EntityListResponse,
-  EntityDeltaRequest,
-  EntityDeltaResponse,
-  EntityExtantRequest,
-  EntityExtantResponse,
   EntityFetchRequest,
   EntityFetchResponse,
+  EntityExtantRequest,
+  EntityExtantResponse,
   EntityCreateRequest,
   EntityCreateResponse,
-  EntityModifyRequest,
-  EntityModifyResponse,
-  EntityDestroyRequest,
-  EntityDestroyResponse,
+  EntityUpdateRequest,
+  EntityUpdateResponse,
+  EntityDeleteRequest,
+  EntityDeleteResponse,
+  EntityDeltaRequest,
+  EntityDeltaResponse,
+  EntityInterface,
 } from '../types/entity';
+import { useIntegrationStore } from '@KTXC/stores/integrationStore';
+import { EntityObject } from '../models';
 
-const BASE_URL = '/m/chrono_manager/entity';
+/**
+ * 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('chrono_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 entities (events, tasks, journals)
+   * Retrieve list of entities, optionally filtered by source selector
    * 
-   * @param request - Entity list request parameters
-   * @returns Promise with entity 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: EntityListRequest = {}): Promise<EntityListResponse> {
-    return await fetchWrapper.post(`${BASE_URL}/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 entities
+   * Retrieve a specific entity by provider and identifier
    * 
-   * @param request - Entity delta request with source selector
-   * @returns Promise with delta changes (created, modified, deleted)
+   * @param request - fetch request parameters
+   * 
+   * @returns Promise with entity objects keyed by identifier
    */
-  async delta(request: EntityDeltaRequest): Promise<EntityDeltaResponse> {
-    return await fetchWrapper.post(`${BASE_URL}/delta`, request);
+  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;
   },
 
   /**
-   * Check which entities exist/are available
+   * Retrieve entity availability status for a given source selector
+   * 
+   * @param request - extant request parameters
    * 
-   * @param request - Entity extant request with source selector
    * @returns Promise with entity availability status
    */
   async extant(request: EntityExtantRequest): Promise<EntityExtantResponse> {
-    return await fetchWrapper.post(`${BASE_URL}/extant`, request);
-  },
-
-  /**
-   * Fetch specific entities
-   * 
-   * @param request - Entity fetch request
-   * @returns Promise with entity details
-   */
-  async fetch(request: EntityFetchRequest): Promise<EntityFetchResponse> {
-    return await fetchWrapper.post(`${BASE_URL}/fetch`, request);
+    return await transceivePost<EntityExtantRequest, EntityExtantResponse>('entity.extant', request);
   },
 
   /**
    * Create a new entity
    * 
-   * @param request - Entity create request
-   * @returns Promise with created entity
+   * @param request - create request parameters
+   * 
+   * @returns Promise with created entity object
    */
-  async create(request: EntityCreateRequest): Promise<EntityCreateResponse> {
-    return await fetchWrapper.post(`${BASE_URL}/create`, request);
+  async create(request: EntityCreateRequest): Promise<EntityObject> {
+    const response = await transceivePost<EntityCreateRequest, EntityCreateResponse>('entity.create', request);
+    return createEntityObject(response);
   },
 
   /**
-   * Modify an existing entity
+   * Update an existing entity
    * 
-   * @param request - Entity modify request
-   * @returns Promise with modified entity
+   * @param request - update request parameters
+   * 
+   * @returns Promise with updated entity object
    */
-  async modify(request: EntityModifyRequest): Promise<EntityModifyResponse> {
-    return await fetchWrapper.post(`${BASE_URL}/modify`, request);
+  async update(request: EntityUpdateRequest): Promise<EntityObject> {
+    const response = await transceivePost<EntityUpdateRequest, EntityUpdateResponse>('entity.update', request);
+    return createEntityObject(response);
   },
 
   /**
    * Delete an entity
    * 
-   * @param request - Entity destroy request
+   * @param request - delete request parameters
+   * 
    * @returns Promise with deletion result
    */
-  async destroy(request: EntityDestroyRequest): Promise<EntityDestroyResponse> {
-    return await fetchWrapper.post(`${BASE_URL}/destroy`, request);
+  async delete(request: EntityDeleteRequest): Promise<EntityDeleteResponse> {
+    return await transceivePost<EntityDeleteRequest, EntityDeleteResponse>('entity.delete', request);
   },
+
+  /**
+   * Retrieve delta changes for entities
+   * 
+   * @param request - delta request parameters
+   * 
+   * @returns Promise with delta changes (created, modified, deleted)
+   */
+  async delta(request: EntityDeltaRequest): Promise<EntityDeltaResponse> {
+    return await transceivePost<EntityDeltaRequest, EntityDeltaResponse>('entity.delta', request);
+  },
+
 };
 
 export default entityService;