refactor: front end

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

src/services/serviceService.ts

@@ -2,46 +2,161 @@
  * Service management service
  */
 
-import { fileManagerApi } from './api';
-import type { SourceSelector } from '@/types/common';
-import type { ServiceInterface, ServiceRecord } from '@/types/service';
+import type {
+  ServiceListRequest,
+  ServiceListResponse,
+  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';
+
+/**
+ * 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('documents_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 sources - Optional source selector to filter services
-   * @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(sources?: SourceSelector): Promise<ServiceRecord> {
-    return await fileManagerApi.execute<ServiceRecord>('service.list', { 
-      sources: sources || null 
+  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 sources - Source selector with service IDs to check
    * @returns Promise with service availability status
    */
-  async extant(sources: SourceSelector): Promise<Record<string, boolean>> {
-    return await fileManagerApi.execute<Record<string, boolean>>('service.extant', { sources });
+  async extant(request: ServiceExtantRequest): Promise<ServiceExtantResponse> {
+    return await transceivePost<ServiceExtantRequest, ServiceExtantResponse>('service.extant', request);
   },
 
   /**
-   * Fetch a specific service
+   * Retrieve discoverable services for a given source selector, sorted by provider
    * 
-   * @param provider - Provider identifier
-   * @param identifier - Service identifier
-   * @returns Promise with service details
+   * @param request - discover request parameters
+   * 
+   * @returns Promise with array of discovered services sorted by provider
    */
-  async fetch(provider: string, identifier: string): Promise<ServiceInterface> {
-    return await fileManagerApi.execute<ServiceInterface>('service.fetch', { 
-      provider, 
-      identifier 
+  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': 'documents: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);
   },
 };