@memberjunction/react-runtime 2.111.1 → 2.112.0

package/src/registry/component-registry-service.ts

@@ -6,20 +6,20 @@
 import { ComponentSpec, ComponentObject } from '@memberjunction/interactive-component-types';
 import { ComponentCompiler } from '../compiler';
 import { RuntimeContext } from '../types';
-import { 
-  RegistryProvider, 
+import {
+  RegistryProvider,
   RegistryComponentResponse,
   ComponentDependencyInfo,
-  DependencyTree, 
-  RegistryComponentMetadata
+  DependencyTree,
+  RegistryComponentMetadata,
 } from './registry-provider';
-import { UserInfo, Metadata } from '@memberjunction/core';
-import { 
-  ComponentEntity, 
+import { UserInfo, Metadata } from '@memberjunction/global';
+import {
+  ComponentEntity,
   ComponentRegistryEntity,
   ComponentDependencyEntity,
   ComponentLibraryLinkEntity,
-  ComponentMetadataEngine
+  ComponentMetadataEngine,
 } from '@memberjunction/core-entities';
 
 // Type-only import for TypeScript - won't be included in UMD bundle
@@ -28,7 +28,6 @@ import type { GraphQLDataProvider } from '@memberjunction/graphql-dataprovider';
 // Dynamic import of GraphQLComponentRegistryClient to avoid breaking UMD build
 let GraphQLComponentRegistryClient: any;
 
-
 /**
  * Cached compiled component with metadata
  */
@@ -38,7 +37,7 @@ interface CachedCompiledComponent {
   compiledAt: Date;
   lastUsed: Date;
   useCount: number;
-  specHash?: string;  // SHA-256 hash of the spec used for compilation
+  specHash?: string; // SHA-256 hash of the spec used for compilation
 }
 
 /**
@@ -59,11 +58,11 @@ export interface IComponentRegistryClient {
  */
 export class ComponentRegistryService {
   private static instance: ComponentRegistryService | null = null;
-  
+
   // Caches
   private compiledComponentCache = new Map<string, CachedCompiledComponent>();
   private componentReferences = new Map<string, Set<string>>();
-  
+
   // Dependencies
   private compiler: ComponentCompiler;
   private runtimeContext: RuntimeContext;
@@ -71,7 +70,7 @@ export class ComponentRegistryService {
   private registryProviders = new Map<string, RegistryProvider>();
   private debug: boolean = false;
   private graphQLClient?: IComponentRegistryClient;
-  
+
   private constructor(
     compiler: ComponentCompiler,
     runtimeContext: RuntimeContext,
@@ -83,12 +82,12 @@ export class ComponentRegistryService {
     this.debug = debug;
     this.graphQLClient = graphQLClient;
   }
-  
+
   /**
    * Get or create the singleton instance
    */
   static getInstance(
-    compiler: ComponentCompiler, 
+    compiler: ComponentCompiler,
     context: RuntimeContext,
     debug: boolean = false,
     graphQLClient?: IComponentRegistryClient
@@ -98,7 +97,7 @@ export class ComponentRegistryService {
     }
     return ComponentRegistryService.instance;
   }
-  
+
   /**
    * Set the GraphQL client for registry operations
    */
@@ -108,12 +107,12 @@ export class ComponentRegistryService {
       console.log('✅ GraphQL client configured for component registry');
     }
   }
-  
+
   /**
    * Cached GraphQL client instance created from Metadata.Provider
    */
   private cachedProviderClient: IComponentRegistryClient | null = null;
-  
+
   /**
    * Get the GraphQL client, using the provided one or falling back to creating one with Metadata.Provider
    * @returns The GraphQL client if available
@@ -123,12 +122,12 @@ export class ComponentRegistryService {
     if (this.graphQLClient) {
       return this.graphQLClient;
     }
-    
+
     // If we've already created one from the provider, reuse it
     if (this.cachedProviderClient) {
       return this.cachedProviderClient;
     }
-    
+
     // Try to create GraphQLComponentRegistryClient with Metadata.Provider
     try {
       const provider = Metadata?.Provider;
@@ -145,7 +144,7 @@ export class ComponentRegistryService {
             return null;
           }
         }
-        
+
         // Create the client if we have the class
         if (GraphQLComponentRegistryClient) {
           try {
@@ -168,10 +167,10 @@ export class ComponentRegistryService {
         console.log('⚠️ [ComponentRegistryService] Could not access Metadata.Provider:', error);
       }
     }
-    
+
     return null;
   }
-  
+
   /**
    * Initialize the service with metadata
    */
@@ -179,7 +178,7 @@ export class ComponentRegistryService {
     // Initialize metadata engine
     await this.componentEngine.Config(false, contextUser);
   }
-  
+
   /**
    * Calculate SHA-256 hash of a component spec for cache comparison
    * Uses Web Crypto API which is available in modern browsers and Node.js 15+
@@ -189,93 +188,88 @@ export class ComponentRegistryService {
     if (typeof crypto === 'undefined' || !crypto.subtle) {
       throw new Error(
         'Web Crypto API not available. This typically happens when running in an insecure context. ' +
-        'Please use HTTPS or localhost for development. ' +
-        'Note: crypto.subtle is available in Node.js 15+ and all modern browsers on secure contexts.'
+          'Please use HTTPS or localhost for development. ' +
+          'Note: crypto.subtle is available in Node.js 15+ and all modern browsers on secure contexts.'
       );
     }
-    
+
     const specString = JSON.stringify(spec);
     const encoder = new TextEncoder();
     const data = encoder.encode(specString);
-    
+
     // Calculate SHA-256 hash using Web Crypto API
     const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-    
+
     // Convert ArrayBuffer to hex string
     const hashArray = Array.from(new Uint8Array(hashBuffer));
-    const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
-    
+    const hashHex = hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
+
     return hashHex;
   }
-  
+
   /**
    * Get a compiled component, using cache if available
    */
-  async getCompiledComponent(
-    componentId: string,
-    referenceId?: string,
-    contextUser?: UserInfo
-  ): Promise<ComponentObject> {
+  async getCompiledComponent(componentId: string, referenceId?: string, contextUser?: UserInfo): Promise<ComponentObject> {
     await this.initialize(contextUser);
-    
+
     // Find component in metadata
     const component = this.componentEngine.Components.find((c: ComponentEntity) => c.ID === componentId);
     if (!component) {
       throw new Error(`Component not found: ${componentId}`);
     }
-    
+
     const key = this.getComponentKey(component.Name, component.Namespace, component.Version, component.SourceRegistryID);
-    
+
     // Check if already compiled and cached
     if (this.compiledComponentCache.has(key)) {
       const cached = this.compiledComponentCache.get(key)!;
       cached.lastUsed = new Date();
       cached.useCount++;
-      
+
       // Track reference if provided
       if (referenceId) {
         this.addComponentReference(key, referenceId);
       }
-      
+
       if (this.debug) {
         console.log(`✅ Reusing compiled component from cache: ${key} (use count: ${cached.useCount})`);
       }
       // Call the factory function to get the ComponentObject
       return cached.component(this.runtimeContext);
     }
-    
+
     // Not in cache, need to load and compile
     if (this.debug) {
       console.log(`🔄 Loading and compiling component: ${key}`);
     }
-    
+
     // Get the component specification
     const spec = await this.getComponentSpec(componentId, contextUser);
-    
+
     // Compile the component
     // Load all libraries from metadata engine
     const allLibraries = this.componentEngine.ComponentLibraries || [];
-    
+
     let compilationResult;
     try {
       compilationResult = await this.compiler.compile({
         componentName: component.Name,
         componentCode: spec.code,
         libraries: spec.libraries,
-        allLibraries
+        allLibraries,
       });
-    }
-    catch (compileEx) {
+    } catch (compileEx) {
       // log then throw
-      console.error(`🔴 Error compiling component ${component.Name}`,compileEx);
+      console.error(`🔴 Error compiling component ${component.Name}`, compileEx);
       throw compileEx;
     }
-    
+
     if (!compilationResult.success) {
       console.error(`🔴 Error compiling component ${component.Name}`, compilationResult, 'Code', spec.code);
       throw new Error(`Failed to compile component ${component.Name}: ${compilationResult.error}`);
     }
-    
+
     // Cache the compiled component
     const metadata: RegistryComponentMetadata = {
       name: component.Name,
@@ -290,9 +284,9 @@ export class ComponentRegistryService {
       libraries: spec.libraries,
       dependencies: spec.dependencies,
       sourceRegistryID: component.SourceRegistryID,
-      isLocal: !component.SourceRegistryID
+      isLocal: !component.SourceRegistryID,
     };
-    
+
     if (!compilationResult.component) {
       throw new Error(`Component compilation succeeded but no component returned`);
     }
@@ -302,18 +296,18 @@ export class ComponentRegistryService {
       metadata,
       compiledAt: new Date(),
       lastUsed: new Date(),
-      useCount: 1
+      useCount: 1,
     });
-    
+
     // Track reference
     if (referenceId) {
       this.addComponentReference(key, referenceId);
     }
-    
+
     // Call the factory function to get the ComponentObject
     return compiledComponentFactory(this.runtimeContext);
   }
-  
+
   /**
    * Get compiled component from external registry by registry name
    * This is used when spec.registry field is populated
@@ -327,45 +321,45 @@ export class ComponentRegistryService {
     contextUser?: UserInfo
   ): Promise<any> {
     await this.initialize(contextUser);
-    
+
     if (this.debug) {
       console.log(`🌐 [ComponentRegistryService] Fetching from external registry: ${registryName}/${namespace}/${name}@${version}`);
     }
-    
+
     // Find the registry by name in ComponentRegistries
-    const registry = this.componentEngine.ComponentRegistries?.find(
-      r => r.Name === registryName && r.Status === 'Active'
-    );
-    
+    const registry = this.componentEngine.ComponentRegistries?.find((r) => r.Name === registryName && r.Status === 'Active');
+
     if (!registry) {
       throw new Error(`Registry not found or inactive: ${registryName}`);
     }
-    
+
     if (this.debug) {
       console.log(`✅ [ComponentRegistryService] Found registry: ${registry.Name} (ID: ${registry.ID})`);
     }
-    
+
     // Get GraphQL client - use provided one or fallback to Metadata.Provider
     const graphQLClient = await this.getGraphQLClient();
     if (!graphQLClient) {
-      throw new Error('GraphQL client not available for external registry fetching. No client provided and Metadata.Provider is not a GraphQLDataProvider.');
+      throw new Error(
+        'GraphQL client not available for external registry fetching. No client provided and Metadata.Provider is not a GraphQLDataProvider.'
+      );
     }
-    
+
     // Check if we have a cached version first
     const key = `external:${registryName}:${namespace}:${name}:${version}`;
     const cached = this.compiledComponentCache.get(key);
-    
+
     try {
       // Fetch component spec from external registry via MJServer
       // Pass cached hash if available for efficient caching
       const spec = await graphQLClient.GetRegistryComponent({
-        registryName: registry.Name,  // Pass registry name, not ID
+        registryName: registry.Name, // Pass registry name, not ID
         namespace,
         name,
         version,
-        hash: cached?.specHash  // Pass cached hash if available
+        hash: cached?.specHash, // Pass cached hash if available
       });
-      
+
       // If null returned, it means not modified (304)
       if (!spec && cached?.specHash) {
         if (this.debug) {
@@ -373,27 +367,27 @@ export class ComponentRegistryService {
         }
         cached.lastUsed = new Date();
         cached.useCount++;
-        
+
         // Track reference
         if (referenceId) {
           this.addComponentReference(key, referenceId);
         }
-        
+
         // Call the factory function to get the ComponentObject
         return cached.component(this.runtimeContext);
       }
-      
+
       if (!spec) {
         throw new Error(`Component not found in registry ${registryName}: ${namespace}/${name}@${version}`);
       }
-      
+
       if (this.debug) {
         console.log(`✅ [ComponentRegistryService] Fetched spec from external registry: ${spec.name}`);
       }
-      
+
       // Calculate hash of the fetched spec
       const specHash = await this.calculateSpecHash(spec);
-      
+
       // Check if hash matches cached version (shouldn't happen if server works correctly)
       if (cached && cached.specHash === specHash) {
         if (this.debug) {
@@ -401,35 +395,37 @@ export class ComponentRegistryService {
         }
         cached.lastUsed = new Date();
         cached.useCount++;
-        
+
         // Track reference
         if (referenceId) {
           this.addComponentReference(key, referenceId);
         }
-        
+
         // Call the factory function to get the ComponentObject
         return cached.component(this.runtimeContext);
       }
-      
+
       // Spec has changed or is new, need to compile
       if (cached && this.debug) {
-        console.log(`🔄 [ComponentRegistryService] Spec changed for: ${key}, recompiling (old hash: ${cached.specHash?.substring(0, 8)}..., new hash: ${specHash.substring(0, 8)}...)`);
+        console.log(
+          `🔄 [ComponentRegistryService] Spec changed for: ${key}, recompiling (old hash: ${cached.specHash?.substring(0, 8)}..., new hash: ${specHash.substring(0, 8)}...)`
+        );
       }
-      
+
       // Load all libraries from metadata engine
       const allLibraries = this.componentEngine.ComponentLibraries || [];
-      
+
       // Compile the component
       const compilationResult = await this.compiler.compile({
         componentName: spec.name,
         componentCode: spec.code || '',
-        allLibraries: allLibraries
+        allLibraries: allLibraries,
       });
-      
+
       if (!compilationResult.success || !compilationResult.component) {
         throw new Error(`Failed to compile component: ${compilationResult.error?.message || 'Unknown error'}`);
       }
-      
+
       // Cache the compiled component with spec hash
       this.compiledComponentCache.set(key, {
         component: compilationResult.component.factory,
@@ -439,23 +435,23 @@ export class ComponentRegistryService {
           version: spec.version || '1.0.0',
           description: spec.description || '',
           type: spec.type,
-          isLocal: false  // This is from an external registry
+          isLocal: false, // This is from an external registry
         },
         compiledAt: new Date(),
         lastUsed: new Date(),
         useCount: 1,
-        specHash: specHash  // Store the hash for future comparison
+        specHash: specHash, // Store the hash for future comparison
       });
-      
+
       // Track reference
       if (referenceId) {
         this.addComponentReference(key, referenceId);
       }
-      
+
       if (this.debug) {
         console.log(`🎯 [ComponentRegistryService] Successfully compiled external component: ${spec.name}`);
       }
-      
+
       // Call the factory function to get the ComponentObject
       return compilationResult.component.factory(this.runtimeContext);
     } catch (error) {
@@ -463,21 +459,18 @@ export class ComponentRegistryService {
       throw error;
     }
   }
-  
+
   /**
    * Get component specification from database or external registry
    */
-  async getComponentSpec(
-    componentId: string,
-    contextUser?: UserInfo
-  ): Promise<ComponentSpec> {
+  async getComponentSpec(componentId: string, contextUser?: UserInfo): Promise<ComponentSpec> {
     await this.initialize(contextUser);
-    
+
     const component = this.componentEngine.Components.find((c: ComponentEntity) => c.ID === componentId);
     if (!component) {
       throw new Error(`Component not found: ${componentId}`);
     }
-    
+
     if (!component.SourceRegistryID) {
       // LOCAL: Use specification from database
       if (!component.Specification) {
@@ -485,7 +478,7 @@ export class ComponentRegistryService {
       }
       return JSON.parse(component.Specification);
     }
-    
+
     // EXTERNAL: Check if we have a cached version
     if (component.Specification && component.LastSyncedAt) {
       // For now, always use cached version (no expiration)
@@ -494,35 +487,33 @@ export class ComponentRegistryService {
       }
       return JSON.parse(component.Specification);
     }
-    
+
     // Need to fetch from external registry
-    const registry = this.componentEngine.ComponentRegistries?.find(
-      r => r.ID === component.SourceRegistryID
-    );
-    
+    const registry = this.componentEngine.ComponentRegistries?.find((r) => r.ID === component.SourceRegistryID);
+
     if (!registry) {
       throw new Error(`Registry not found: ${component.SourceRegistryID}`);
     }
-    
+
     // Try GraphQL client first if available
     let spec: ComponentSpec;
-    
+
     if (this.graphQLClient) {
       if (this.debug) {
         console.log(`Fetching from registry via GraphQL: ${component.Name}`);
       }
-      
+
       const result = await this.graphQLClient.GetRegistryComponent({
         registryName: registry.Name,
         namespace: component.Namespace || '',
         name: component.Name,
-        version: component.Version
+        version: component.Version,
       });
-      
+
       if (!result) {
         throw new Error(`Component not found in registry: ${component.Name}`);
       }
-      
+
       spec = result;
     } else {
       // Fallback to direct HTTP if no GraphQL client
@@ -534,13 +525,13 @@ export class ComponentRegistryService {
         this.getRegistryApiKey(registry.ID)
       );
     }
-    
+
     // Store in local database for future use
     await this.cacheExternalComponent(componentId, spec, contextUser);
-    
+
     return spec;
   }
-  
+
   /**
    * Fetch component from external registry via HTTP
    */
@@ -552,141 +543,132 @@ export class ComponentRegistryService {
     apiKey?: string
   ): Promise<ComponentSpec> {
     const url = `${uri}/components/${encodeURIComponent(namespace)}/${encodeURIComponent(name)}/${version}`;
-    
+
     const headers: HeadersInit = {
-      'Accept': 'application/json'
+      Accept: 'application/json',
     };
-    
+
     if (apiKey) {
       headers['Authorization'] = `Bearer ${apiKey}`;
     }
-    
+
     if (this.debug) {
       console.log(`Fetching from external registry: ${url}`);
     }
-    
+
     const response = await fetch(url, { headers });
-    
+
     if (!response.ok) {
       throw new Error(`Registry fetch failed: ${response.status} ${response.statusText}`);
     }
-    
-    const spec = await response.json() as ComponentSpec;
+
+    const spec = (await response.json()) as ComponentSpec;
     return spec;
   }
-  
+
   /**
    * Cache an external component in the local database
    */
-  private async cacheExternalComponent(
-    componentId: string,
-    spec: ComponentSpec,
-    contextUser?: UserInfo
-  ): Promise<void> {
+  private async cacheExternalComponent(componentId: string, spec: ComponentSpec, contextUser?: UserInfo): Promise<void> {
     // Get the actual entity object to save
     const md = new Metadata();
     const componentEntity = await md.GetEntityObject<ComponentEntity>('MJ: Components', contextUser);
-    
+
     // Load the existing component
-    if (!await componentEntity.Load(componentId)) {
+    if (!(await componentEntity.Load(componentId))) {
       throw new Error(`Failed to load component entity: ${componentId}`);
     }
-    
+
     // Update with fetched specification and all fields from spec
     componentEntity.Specification = JSON.stringify(spec);
     componentEntity.LastSyncedAt = new Date();
-    
+
     // Set ReplicatedAt only on first fetch
     if (!componentEntity.ReplicatedAt) {
       componentEntity.ReplicatedAt = new Date();
     }
-    
+
     // Update all fields from the spec with strong typing
     if (spec.name) {
       componentEntity.Name = spec.name;
     }
-    
+
     if (spec.namespace) {
       componentEntity.Namespace = spec.namespace;
     }
-    
+
     if (spec.version) {
       componentEntity.Version = spec.version;
     }
-    
+
     if (spec.title) {
       componentEntity.Title = spec.title;
     }
-    
+
     if (spec.description) {
       componentEntity.Description = spec.description;
     }
-    
+
     if (spec.type) {
       // Map spec type to entity type (entity has specific enum values)
       const typeMap: Record<string, ComponentEntity['Type']> = {
-        'report': 'Report',
-        'dashboard': 'Dashboard',
-        'form': 'Form',
-        'table': 'Table',
-        'chart': 'Chart',
-        'navigation': 'Navigation',
-        'search': 'Search',
-        'widget': 'Widget',
-        'utility': 'Utility',
-        'other': 'Other'
+        report: 'Report',
+        dashboard: 'Dashboard',
+        form: 'Form',
+        table: 'Table',
+        chart: 'Chart',
+        navigation: 'Navigation',
+        search: 'Search',
+        widget: 'Widget',
+        utility: 'Utility',
+        other: 'Other',
       };
-      
+
       const mappedType = typeMap[spec.type.toLowerCase()];
       if (mappedType) {
         componentEntity.Type = mappedType;
       }
     }
-    
+
     if (spec.functionalRequirements) {
       componentEntity.FunctionalRequirements = spec.functionalRequirements;
     }
-    
+
     if (spec.technicalDesign) {
       componentEntity.TechnicalDesign = spec.technicalDesign;
     }
-    
+
     // Save back to database
     const result = await componentEntity.Save();
     if (!result) {
-      throw new Error(`Failed to save cached component: ${componentEntity.Name}\n${componentEntity.LatestResult.Message || componentEntity.LatestResult.Error || componentEntity.LatestResult.Errors?.join(',')}`);
+      throw new Error(
+        `Failed to save cached component: ${componentEntity.Name}\n${componentEntity.LatestResult.Message || componentEntity.LatestResult.Error || componentEntity.LatestResult.Errors?.join(',')}`
+      );
     }
-    
+
     if (this.debug) {
       console.log(`Cached external component: ${componentEntity.Name} at ${componentEntity.LastSyncedAt}`);
     }
-    
+
     // Refresh metadata cache after saving
     await this.componentEngine.Config(true, contextUser);
   }
-  
+
   /**
    * Load component dependencies from database
    */
-  async loadDependencies(
-    componentId: string,
-    contextUser?: UserInfo
-  ): Promise<ComponentDependencyInfo[]> {
+  async loadDependencies(componentId: string, contextUser?: UserInfo): Promise<ComponentDependencyInfo[]> {
     await this.initialize(contextUser);
-    
+
     // Get dependencies from metadata cache
-    const dependencies = this.componentEngine.ComponentDependencies?.filter(
-      d => d.ComponentID === componentId
-    ) || [];
-    
+    const dependencies = this.componentEngine.ComponentDependencies?.filter((d) => d.ComponentID === componentId) || [];
+
     const result: ComponentDependencyInfo[] = [];
-    
+
     for (const dep of dependencies) {
       // Find the dependency component
-      const depComponent = this.componentEngine.Components.find(
-        (c: ComponentEntity) => c.ID === dep.DependencyComponentID
-      );
-      
+      const depComponent = this.componentEngine.Components.find((c: ComponentEntity) => c.ID === dep.DependencyComponentID);
+
       if (depComponent) {
         result.push({
           name: depComponent.Name,
@@ -694,78 +676,68 @@ export class ComponentRegistryService {
           version: depComponent.Version, // Version comes from the linked Component record
           isRequired: true, // All dependencies are required in MemberJunction
           location: depComponent.SourceRegistryID ? 'registry' : 'embedded',
-          sourceRegistryID: depComponent.SourceRegistryID
+          sourceRegistryID: depComponent.SourceRegistryID,
         });
       }
     }
-    
+
     return result;
   }
-  
+
   /**
    * Resolve full dependency tree for a component
    */
-  async resolveDependencyTree(
-    componentId: string,
-    contextUser?: UserInfo,
-    visited = new Set<string>()
-  ): Promise<DependencyTree> {
+  async resolveDependencyTree(componentId: string, contextUser?: UserInfo, visited = new Set<string>()): Promise<DependencyTree> {
     if (visited.has(componentId)) {
-      return { 
-        componentId, 
-        circular: true 
+      return {
+        componentId,
+        circular: true,
       };
     }
     visited.add(componentId);
-    
+
     await this.initialize(contextUser);
-    
+
     const component = this.componentEngine.Components.find((c: ComponentEntity) => c.ID === componentId);
     if (!component) {
       return { componentId, dependencies: [] };
     }
-    
+
     // Get direct dependencies
     const directDeps = await this.loadDependencies(componentId, contextUser);
-    
+
     // Recursively resolve each dependency
     const dependencies: DependencyTree[] = [];
     for (const dep of directDeps) {
       // Find the dependency component
       const depComponent = this.componentEngine.Components.find(
-        c => c.Name.trim().toLowerCase() === dep.name.trim().toLowerCase() && 
-             c.Namespace?.trim().toLowerCase() === dep.namespace?.trim().toLowerCase()
+        (c) =>
+          c.Name.trim().toLowerCase() === dep.name.trim().toLowerCase() &&
+          c.Namespace?.trim().toLowerCase() === dep.namespace?.trim().toLowerCase()
       );
-      
+
       if (depComponent) {
-        const subTree = await this.resolveDependencyTree(
-          depComponent.ID, 
-          contextUser, 
-          visited
-        );
+        const subTree = await this.resolveDependencyTree(depComponent.ID, contextUser, visited);
         dependencies.push(subTree);
       }
     }
-    
+
     return {
       componentId,
       name: component.Name,
       namespace: component.Namespace || undefined,
       version: component.Version,
       dependencies,
-      totalCount: dependencies.reduce((sum, d) => sum + (d.totalCount || 1), 1)
+      totalCount: dependencies.reduce((sum, d) => sum + (d.totalCount || 1), 1),
     };
   }
-  
+
   /**
    * Get components to load in dependency order
    */
-  async getComponentsToLoad(
-    rootComponentId: string,
-    contextUser?: UserInfo
-  ): Promise<string[]> {
+  async getComponentsToLoad(rootComponentId: string, contextUser?: UserInfo): Promise<string[]> {
     const tree = await this.resolveDependencyTree(rootComponentId, contextUser);
-    
+
     // Flatten tree in dependency order (depth-first)
     const ordered: string[] = [];
     const processNode = (node: DependencyTree) => {
@@ -777,10 +749,10 @@ export class ComponentRegistryService {
       }
     };
     processNode(tree);
-    
+
     return ordered;
   }
-  
+
   /**
    * Add a reference to a component
    */
@@ -790,7 +762,7 @@ export class ComponentRegistryService {
     }
     this.componentReferences.get(componentKey)!.add(referenceId);
   }
-  
+
   /**
    * Remove a reference to a component
    */
@@ -798,14 +770,14 @@ export class ComponentRegistryService {
     const refs = this.componentReferences.get(componentKey);
     if (refs) {
       refs.delete(referenceId);
-      
+
       // If no more references and cache cleanup is enabled
       if (refs.size === 0) {
         this.considerCacheEviction(componentKey);
       }
     }
   }
-  
+
   /**
    * Consider evicting a component from cache
    */
@@ -814,7 +786,7 @@ export class ComponentRegistryService {
     if (cached) {
       const timeSinceLastUse = Date.now() - cached.lastUsed.getTime();
       const evictionThreshold = 5 * 60 * 1000; // 5 minutes
-      
+
       if (timeSinceLastUse > evictionThreshold) {
         if (this.debug) {
           console.log(`🗑️ Evicting unused component from cache: ${componentKey}`);
@@ -823,7 +795,7 @@ export class ComponentRegistryService {
       }
     }
   }
-  
+
   /**
    * Get API key for a registry from secure configuration
    * @param registryId - Registry ID
@@ -836,7 +808,7 @@ export class ComponentRegistryService {
     const envKey = `REGISTRY_API_KEY_${registryId.replace(/-/g, '_').toUpperCase()}`;
     return process.env[envKey];
   }
-  
+
   /**
    * Get cache statistics
    */
@@ -846,17 +818,17 @@ export class ComponentRegistryService {
     memoryEstimate: string;
   } {
     let totalUseCount = 0;
-    this.compiledComponentCache.forEach(cached => {
+    this.compiledComponentCache.forEach((cached) => {
       totalUseCount += cached.useCount;
     });
-    
+
     return {
       compiledComponents: this.compiledComponentCache.size,
       totalUseCount,
-      memoryEstimate: `~${(this.compiledComponentCache.size * 50)}KB` // Rough estimate
+      memoryEstimate: `~${this.compiledComponentCache.size * 50}KB`, // Rough estimate
     };
   }
-  
+
   /**
    * Clear all caches
    */
@@ -888,18 +860,18 @@ export class ComponentRegistryService {
       ComponentRegistryService.instance = null;
     }
   }
-  
+
   /**
    * Generate a cache key for a component
    */
   private getComponentKey(
-    name: string, 
-    namespace: string | null | undefined, 
-    version: string, 
+    name: string,
+    namespace: string | null | undefined,
+    version: string,
     sourceRegistryId: string | null | undefined
   ): string {
     const registryPart = sourceRegistryId || 'local';
     const namespacePart = namespace || 'global';
     return `${registryPart}/${namespacePart}/${name}@${version}`;
   }
-}
+}