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

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;

src/services/index.ts

@@ -1,16 +1,4 @@
-/**
- * Central export point for all Chrono Manager services
- */
-
-// Services
 export { providerService } from './providerService';
 export { serviceService } from './serviceService';
 export { collectionService } from './collectionService';
 export { entityService } from './entityService';
-
-// Type exports
-export type * from '../types/common';
-export type * from '../types/provider';
-export type * from '../types/service';
-export type * from '../types/collection';
-export type * from '../types/entity';

src/services/providerService.ts

@@ -2,34 +2,74 @@
  * Provider management service
  */
 
-import { createFetchWrapper } from '@KTXC/utils/helpers/fetch-wrapper-core';
+import type {
+  ProviderListRequest,
+  ProviderListResponse,
+  ProviderExtantRequest,
+  ProviderExtantResponse,
+  ProviderFetchRequest,
+  ProviderFetchResponse,
+  ProviderInterface,
+} from '../types/provider';
+import { useIntegrationStore } from '@KTXC/stores/integrationStore';
+import { transceivePost } from './transceive';
+import { ProviderObject } from '../models/provider';
 
-const fetchWrapper = createFetchWrapper();
-import type { ProviderListResponse, ProviderExtantResponse } from '../types/provider';
-import type { SourceSelector } from '../types/common';
-
-const BASE_URL = '/m/chrono_manager/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('chrono_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 all available providers
+   * Retrieve list of providers, optionally filtered by source selector
    * 
-   * @returns Promise with provider list keyed by provider ID
+   * @param request - list request parameters
+   * 
+   * @returns Promise with provider object list keyed by provider identifier
    */
-  async list(): Promise<ProviderListResponse> {
-    return await fetchWrapper.get(`${BASE_URL}/list`);
+  async list(request: ProviderListRequest = {}): Promise<Record<string, ProviderObject>> {
+    const response = await transceivePost<ProviderListRequest, ProviderListResponse>('provider.list', request);
+    
+    // Convert response to ProviderObject instances
+    const list: Record<string, ProviderObject> = {};
+    Object.entries(response).forEach(([providerId, providerData]) => {
+      list[providerId] = createProviderObject(providerData);
+    });
+    
+    return list;
   },
 
   /**
-   * Check which providers exist/are available
+   * Retrieve specific provider by identifier
    * 
-   * @param sources - Source selector with provider IDs to check
+   * @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 createProviderObject(response);
+  },
+
+  /**
+   * Retrieve provider availability status for a given source selector
+   * 
+   * @param request - extant request parameters
    * 
    * @returns Promise with provider availability status
    */
-  async extant(sources: SourceSelector): Promise<ProviderExtantResponse> {
-    return await fetchWrapper.post(`${BASE_URL}/extant`, { sources });
+  async extant(request: ProviderExtantRequest): Promise<ProviderExtantResponse> {
+    return await transceivePost<ProviderExtantRequest, ProviderExtantResponse>('provider.extant', request);
   },
 };
 

src/services/serviceService.ts

@@ -2,50 +2,161 @@
  * Service management service
  */
 
-import { createFetchWrapper } from '@KTXC/utils/helpers/fetch-wrapper-core';
-
-const fetchWrapper = createFetchWrapper();
 import type {
   ServiceListRequest,
   ServiceListResponse,
-  ServiceExtantRequest,
-  ServiceExtantResponse,
   ServiceFetchRequest,
   ServiceFetchResponse,
+  ServiceExtantRequest,
+  ServiceExtantResponse,
+  ServiceCreateResponse,
+  ServiceCreateRequest,
+  ServiceUpdateResponse,
+  ServiceUpdateRequest,
+  ServiceDeleteResponse,
+  ServiceDeleteRequest,
+  ServiceDiscoverRequest,
+  ServiceDiscoverResponse,
+  ServiceTestRequest,
+  ServiceTestResponse,
+  ServiceInterface,
 } from '../types/service';
+import { useIntegrationStore } from '@KTXC/stores/integrationStore';
+import { transceivePost } from './transceive';
+import { ServiceObject } from '../models/service';
 
-const BASE_URL = '/m/chrono_manager/service';
+/**
+ * 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 {
+  const integrationStore = useIntegrationStore();
+  const factoryItem = integrationStore.getItemById('chrono_service_factory', data.provider) as any;
+  const factory = factoryItem?.factory;
+  
+  // Use provider factory if available, otherwise base class
+  return factory ? factory(data) : new ServiceObject().fromJson(data);
+}
 
 export const serviceService = {
 
   /**
-   * List all available services
+   * Retrieve list of services, optionally filtered by source selector
    * 
-   * @param request - Service list request parameters
-   * @returns Promise with service list grouped by provider
+   * @param request - list request parameters
+   * 
+   * @returns Promise with service object list grouped by provider and keyed by service identifier
    */
-  async list(request: ServiceListRequest = {}): Promise<ServiceListResponse> {
-    return await fetchWrapper.post(`${BASE_URL}/list`, request);
+  async list(request: ServiceListRequest = {}): Promise<Record<string, Record<string, ServiceObject>>> {
+    const response = await transceivePost<ServiceListRequest, ServiceListResponse>('service.list', request);
+    
+    // Convert nested response to ServiceObject instances
+    const providerList: Record<string, Record<string, ServiceObject>> = {};
+    Object.entries(response).forEach(([providerId, providerServices]) => {
+      const serviceList: Record<string, ServiceObject> = {};
+      Object.entries(providerServices).forEach(([serviceId, serviceData]) => {
+        serviceList[serviceId] = createServiceObject(serviceData);
+      });
+      providerList[providerId] = serviceList;
+    });
+    
+    return providerList;
   },
 
   /**
-   * Check which services exist/are available
+   * Retrieve a specific service by provider and identifier
+   * 
+   * @param request - fetch request parameters
+   * 
+   * @returns Promise with service object
+   */
+  async fetch(request: ServiceFetchRequest): Promise<ServiceObject> {
+    const response = await transceivePost<ServiceFetchRequest, ServiceFetchResponse>('service.fetch', request);
+    return createServiceObject(response);
+  },
+
+  /**
+   * Retrieve service availability status for a given source selector
+   * 
+   * @param request - extant request parameters
    * 
-   * @param request - Service extant request with source selector
    * @returns Promise with service availability status
    */
   async extant(request: ServiceExtantRequest): Promise<ServiceExtantResponse> {
-    return await fetchWrapper.post(`${BASE_URL}/extant`, request);
+    return await transceivePost<ServiceExtantRequest, ServiceExtantResponse>('service.extant', request);
   },
 
   /**
-   * Fetch a specific service
+   * Retrieve discoverable services for a given source selector, sorted by provider
    * 
-   * @param request - Service fetch request with provider and service IDs
-   * @returns Promise with service details
+   * @param request - discover request parameters
+   * 
+   * @returns Promise with array of discovered services sorted by provider
    */
-  async fetch(request: ServiceFetchRequest): Promise<ServiceFetchResponse> {
-    return await fetchWrapper.post(`${BASE_URL}/fetch`, request);
+  async discover(request: ServiceDiscoverRequest): Promise<ServiceObject[]> {
+    const response = await transceivePost<ServiceDiscoverRequest, ServiceDiscoverResponse>('service.discover', request);
+    
+    // Convert discovery results to ServiceObjects
+    const services: ServiceObject[] = [];
+    Object.entries(response).forEach(([providerId, location]) => {
+      const serviceData: ServiceInterface = {
+        '@type': 'chrono:service',
+        provider: providerId,
+        identifier: null,
+        label: null,
+        enabled: false,
+        location: location,
+      };
+      services.push(createServiceObject(serviceData));
+    });
+    
+    // Sort by provider
+    return services.sort((a, b) => a.provider.localeCompare(b.provider));
+  },
+
+  /**
+   * Test service connectivity and configuration
+   * 
+   * @param request - Service test request
+   * @returns Promise with test results
+   */
+  async test(request: ServiceTestRequest): Promise<ServiceTestResponse> {
+    return await transceivePost<ServiceTestRequest, ServiceTestResponse>('service.test', request);
+  },
+
+  /**
+   * Create a new service
+   * 
+   * @param request - create request parameters
+   * 
+   * @returns Promise with created service object
+   */
+  async create(request: ServiceCreateRequest): Promise<ServiceObject> {
+    const response = await transceivePost<ServiceCreateRequest, ServiceCreateResponse>('service.create', request);
+    return createServiceObject(response);
+  },
+
+  /**
+   * Update a existing service
+   * 
+   * @param request - update request parameters
+   * 
+   * @returns Promise with updated service object
+   */
+  async update(request: ServiceUpdateRequest): Promise<ServiceObject> {
+    const response = await transceivePost<ServiceUpdateRequest, ServiceUpdateResponse>('service.update', request);
+    return createServiceObject(response);
+  },
+
+  /**
+   * Delete a service
+   * 
+   * @param request - delete request parameters
+   * 
+   * @returns Promise with deletion result
+   */
+  async delete(request: { provider: string; identifier: string | number }): Promise<any> {
+    return await transceivePost<ServiceDeleteRequest, ServiceDeleteResponse>('service.delete', request);
   },
 };
 

src/services/transceive.ts

@@ -0,0 +1,50 @@
+/**
+ * API Client for Chrono Manager
+ * Provides a centralized way to make API calls with envelope wrapping/unwrapping
+ */
+
+import { createFetchWrapper } from '@KTXC/utils/helpers/fetch-wrapper-core';
+import type { ApiRequest, ApiResponse } from '../types/common';
+
+const fetchWrapper = createFetchWrapper();
+const API_URL = '/m/chrono_manager/v1';
+const API_VERSION = 1;
+
+/**
+ * Generate a unique transaction ID
+ */
+export function generateTransactionId(): string {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+
+/**
+ * Make an API call with automatic envelope wrapping and unwrapping
+ * 
+ * @param operation - Operation name (e.g., 'provider.list', 'service.autodiscover')
+ * @param data - Operation-specific request data
+ * @param user - Optional user identifier override
+ * @returns Promise with unwrapped response data
+ * @throws Error if the API returns an error status
+ */
+export async function transceivePost<TRequest, TResponse>(
+  operation: string,
+  data: TRequest,
+  user?: string
+): Promise<TResponse> {
+  const request: ApiRequest<TRequest> = {
+    version: API_VERSION,
+    transaction: generateTransactionId(),
+    operation,
+    data,
+    user
+  };
+  
+  const response: ApiResponse<TResponse> = await fetchWrapper.post(API_URL, request);
+  
+  if (response.status === 'error') {
+    const errorMessage = `[${operation}] ${response.data.message}${response.data.code ? ` (code: ${response.data.code})` : ''}`;
+    throw new Error(errorMessage);
+  }
+  
+  return response.data;
+}