made provider registry functional

apps/data-service/src/services/provider-registry.service.ts

@@ -29,50 +29,60 @@ export interface ProviderConfig {
   scheduledJobs?: ScheduledJob[];
 }
 
-export class ProviderRegistry {
+export interface ProviderRegistry {
-  private logger = getLogger('provider-registry');
+  registerProvider: (config: ProviderConfig) => void;
-  private providers = new Map<string, ProviderConfig>();
+  getHandler: (provider: string, operation: string) => JobHandler | null;
+  getAllScheduledJobs: () => Array<{ provider: string; job: ScheduledJob }>;
+  getProviders: () => Array<{ key: string; config: ProviderConfig }>;
+  hasProvider: (provider: string) => boolean;
+  clear: () => void;
+}
+
+/**
+ * Create a new provider registry instance
+ */
+export function createProviderRegistry(): ProviderRegistry {
+  const logger = getLogger('provider-registry');
+  const providers = new Map<string, ProviderConfig>();
 
   /**
    * Register a provider with its operations
    */
-  registerProvider(config: ProviderConfig): void {
+  function registerProvider(config: ProviderConfig): void {
-    // const key = `${config.service}:${config.name}`;
+    providers.set(config.name, config);
-    this.providers.set(config.name, config);
+    logger.info(`Registered provider: ${config.name}`, { 
-    this.logger.info(`Registered provider: ${config.name}`, { 
       operations: Object.keys(config.operations),
       scheduledJobs: config.scheduledJobs?.length || 0
     });
   }
+
   /**
    * Get a job handler for a specific provider and operation
    */
-  getHandler(provider: string, operation: string): JobHandler | null {
+  function getHandler(provider: string, operation: string): JobHandler | null {
-    const providerConfig = this.providers.get(provider);
+    const providerConfig = providers.get(provider);
     
     if (!providerConfig) {
-      this.logger.warn(`Provider not found: ${provider}`);
+      logger.warn(`Provider not found: ${provider}`);
       return null;
     }
 
     const handler = providerConfig.operations[operation];
     if (!handler) {
-      this.logger.warn(`Operation not found: ${operation} in provider ${provider}`);
+      logger.warn(`Operation not found: ${operation} in provider ${provider}`);
       return null;
     }
 
     return handler;
   }
+
   /**
    * Get all scheduled jobs from all providers
    */
-  getAllScheduledJobs(): Array<{
+  function getAllScheduledJobs(): Array<{ provider: string; job: ScheduledJob }> {
-    provider: string;
-    job: ScheduledJob;
-  }> {
     const allJobs: Array<{ provider: string; job: ScheduledJob }> = [];
     
-    for (const [key, config] of this.providers) {
+    for (const [key, config] of providers) {
       if (config.scheduledJobs) {
         for (const job of config.scheduledJobs) {
           allJobs.push({
@@ -86,25 +96,40 @@ export class ProviderRegistry {
     return allJobs;
   }
 
-  getProviders(): Array<{ key: string; config: ProviderConfig }> {
+  /**
-    return Array.from(this.providers.entries()).map(([key, config]) => ({
+   * Get all registered providers with their configurations
+   */
+  function getProviders(): Array<{ key: string; config: ProviderConfig }> {
+    return Array.from(providers.entries()).map(([key, config]) => ({
       key,
       config
     }));
   }
+
   /**
    * Check if a provider exists
    */
-  hasProvider(provider: string): boolean {
+  function hasProvider(provider: string): boolean {
-    return this.providers.has(provider);
+    return providers.has(provider);
   }
+
   /**
    * Clear all providers (useful for testing)
    */
-  clear(): void {
+  function clear(): void {
-    this.providers.clear();
+    providers.clear();
-    this.logger.info('All providers cleared');
+    logger.info('All providers cleared');
   }
+
+  return {
+    registerProvider,
+    getHandler,
+    getAllScheduledJobs,
+    getProviders,
+    hasProvider,
+    clear
+  };
 }
 
-export const providerRegistry = new ProviderRegistry();
+// Create the default shared registry instance
+export const providerRegistry = createProviderRegistry();