refactor: front end

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

src/services/providerService.ts

@@ -2,32 +2,74 @@
  * Provider management service
  */
 
-import { fileManagerApi } from './api';
-import type { SourceSelector } from '@/types/common';
-import type { ProviderRecord } from '@/types/provider';
+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';
+
+/**
+ * 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('documents_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
    * 
-   * @param sources - Optional source selector to filter providers
-   * @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(sources?: SourceSelector): Promise<ProviderRecord> {
-    return await fileManagerApi.execute<ProviderRecord>('provider.list', { 
-      sources: sources || null 
+  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 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
    * 
-   * @param sources - Source selector with provider IDs to check
    * @returns Promise with provider availability status
    */
-  async extant(sources: SourceSelector): Promise<Record<string, boolean>> {
-    return await fileManagerApi.execute<Record<string, boolean>>('provider.extant', { sources });
+  async extant(request: ProviderExtantRequest): Promise<ProviderExtantResponse> {
+    return await transceivePost<ProviderExtantRequest, ProviderExtantResponse>('provider.extant', request);
   },
 };