@memberjunction/react-runtime 5.33.0 → 5.34.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memberjunction/react-runtime",
-  "version": "5.33.0",
+  "version": "5.34.1",
   "description": "Platform-agnostic React component runtime for MemberJunction. Provides core compilation, registry, and execution capabilities for React components in any JavaScript environment.",
   "type": "module",
   "main": "dist/index.js",
@@ -29,11 +29,11 @@
   },
   "homepage": "https://github.com/MemberJunction/MJ#readme",
   "dependencies": {
-    "@memberjunction/core": "5.33.0",
-    "@memberjunction/global": "5.33.0",
-    "@memberjunction/interactive-component-types": "5.33.0",
-    "@memberjunction/core-entities": "5.33.0",
-    "@memberjunction/graphql-dataprovider": "5.33.0",
+    "@memberjunction/core": "5.34.1",
+    "@memberjunction/global": "5.34.1",
+    "@memberjunction/interactive-component-types": "5.34.1",
+    "@memberjunction/core-entities": "5.34.1",
+    "@memberjunction/graphql-dataprovider": "5.34.1",
     "@babel/standalone": "^7.29.1",
     "rxjs": "^7.8.2"
   },

package/src/component-manager/component-manager.ts

@@ -5,7 +5,7 @@
 
 import { ComponentSpec, ComponentLibraryDependency } from '@memberjunction/interactive-component-types';
 import { UserInfo, Metadata, LogError } from '@memberjunction/core';
-import { ComponentMetadataEngine, MJComponentLibraryEntity, MJComponentEntityExtended } from '@memberjunction/core-entities';
+import { ComponentMetadataEngine, MJComponentLibraryEntity } from '@memberjunction/core-entities';
 
 import { ComponentCompiler } from '../compiler';
 import { ComponentRegistry } from '../registry';
@@ -424,12 +424,7 @@ export class ComponentManager {
         }
       }
       
-      // Load dependencies
-      // Prefer the input spec's dependencies over the cached result's dependencies.
-      // When a parent component is served from cache, result.spec contains stale
-      // dependency code. The input spec has the latest dependency code from the caller.
-      // Each dependency still gets its own individual cache check via loadComponent.
-      const dependencies = spec.dependencies || result.spec?.dependencies;
+      const dependencies = this.resolveDependencies(spec.dependencies, result.spec?.dependencies);
       if (dependencies) {
         for (const dep of dependencies) {
           // Normalize dependency spec for local registry lookup
@@ -489,6 +484,29 @@ export class ComponentManager {
     return results;
   }
   
+  /**
+   * Determines which dependency list to use when loading a component's children.
+   *
+   * - Input deps with code take priority (caller has the latest version).
+   * - When input has no deps at all, fall back to fetched/cached deps
+   *   (e.g., a registry reference spec with no dependency list).
+   * - When input has only stubs (no code), prefer fetched deps if they
+   *   contain code (registry-populated hierarchies from Skip where the
+   *   full tree is returned in one response).
+   */
+  private resolveDependencies(
+      inputDeps: ComponentSpec[] | undefined,
+      fetchedDeps: ComponentSpec[] | undefined
+  ): ComponentSpec[] | undefined {
+      const inputHasDeps = inputDeps && inputDeps.length > 0;
+      const inputHasCode = inputHasDeps && inputDeps.some(d => !!d.code);
+
+      if (inputHasCode) return inputDeps;
+      if (!inputHasDeps) return fetchedDeps || inputDeps;
+      if (fetchedDeps?.some(d => !!d.code)) return fetchedDeps;
+      return inputDeps;
+  }
+
   /**
    * Check if a component needs to be fetched from a registry
    */
@@ -515,87 +533,82 @@ export class ComponentManager {
     // Check cache first
     const cacheKey = this.getComponentKey(spec, {});
     const cached = this.fetchCache.get(cacheKey);
-    
+
     if (cached && this.isCacheValid(cached)) {
       this.log(`Using cached spec for: ${spec.name}`);
       return cached.spec;
     }
-    
+
     // Handle LOCAL registry components (registry is null/undefined)
     if (!spec.registry) {
-      this.log(`Fetching from local registry: ${spec.name}`);
-      
-      // Find component in local ComponentMetadataEngine
-      const localComponent = this.componentEngine.Components?.find(
-        (c: MJComponentEntityExtended) => {
-          // Match by name (case-insensitive for better compatibility)
-          const nameMatch = c.Name?.toLowerCase() === spec.name?.toLowerCase();
-          
-          // Match by namespace if provided (handle different formats)
-          const namespaceMatch = !spec.namespace || c.Namespace?.toLowerCase() === spec.namespace?.toLowerCase();
+      const localComponent = await this.componentEngine.FindComponent(spec.name, spec.namespace);
 
-          if (nameMatch && !namespaceMatch) {
-          }
-          
-          return nameMatch && namespaceMatch;
-        }
-      );
-      
       if (!localComponent) {
         throw new Error(`Local component not found: ${spec.name}`);
       }
-      
-      // Parse specification from local component
+
       if (!localComponent.Specification) {
         throw new Error(`Local component ${spec.name} has no specification`);
       }
-      
+
       const fullSpec = JSON.parse(localComponent.Specification);
-      
-      // Cache it
+
       this.fetchCache.set(cacheKey, {
         spec: fullSpec,
         fetchedAt: new Date(),
         usageNotified: false
       });
-      
+
       return fullSpec;
     }
-    
+
     // Handle EXTERNAL registry components (registry has a name)
-    // Initialize GraphQL client if needed
     if (!this.graphQLClient) {
       await this.initializeGraphQLClient();
     }
-    
+
     if (!this.graphQLClient) {
       throw new Error('GraphQL client not available for registry fetching');
     }
-    
-    // Fetch from external registry
+
+    // Fetch from external registry, passing the cached hash (if any) so the
+    // server can return 304 Not Modified when the spec hasn't changed
     this.log(`Fetching from external registry: ${spec.registry}/${spec.name}`);
-    
-    const fullSpec = await this.graphQLClient.GetRegistryComponent({
+    const cachedHash = cached?.hash;
+
+    const response = await this.graphQLClient.GetRegistryComponentWithHash({
       registryName: spec.registry,
       namespace: spec.namespace || 'Global',
       name: spec.name,
-      version: spec.version || 'latest'
+      version: spec.version || 'latest',
+      hash: cachedHash
     });
-    
-    if (!fullSpec) {
+
+    // If not modified (304), reuse the cached spec and refresh the TTL
+    if (response.notModified && cached) {
+      this.log(`Registry returned 304 for ${spec.name}, reusing cached spec`);
+      this.fetchCache.set(cacheKey, {
+        ...cached,
+        fetchedAt: new Date()
+      });
+      return cached.spec;
+    }
+
+    if (!response.specification) {
       throw new Error(`Component not found in registry: ${spec.registry}/${spec.name}`);
     }
-    
-    // Apply resolution mode if specified
+
+    const fullSpec = response.specification as ComponentSpec;
     const processedSpec = this.applyResolutionMode(fullSpec, spec, options?.resolutionMode);
-    
-    // Cache it
+
+    // Cache it with the registry hash for future 304 checks
     this.fetchCache.set(cacheKey, {
       spec: processedSpec,
       fetchedAt: new Date(),
+      hash: response.hash,
       usageNotified: false
     });
-    
+
     return processedSpec;
   }
   

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

@@ -232,8 +232,8 @@ export class ComponentRegistryService {
   ): Promise<ComponentObject> {
     await this.initialize(contextUser);
     
-    // Find component in metadata
-    const component = this.componentEngine.Components.find((c: MJComponentEntity) => UUIDsEqual(c.ID, componentId));
+    // Find component in metadata via targeted query
+    const component = await this.componentEngine.FindComponentByID(componentId, contextUser);
     if (!component) {
       throw new Error(`Component not found: ${componentId}`);
     }
@@ -487,7 +487,7 @@ export class ComponentRegistryService {
   ): Promise<ComponentSpec> {
     await this.initialize(contextUser);
     
-    const component = this.componentEngine.Components.find((c: MJComponentEntity) => UUIDsEqual(c.ID, componentId));
+    const component = await this.componentEngine.FindComponentByID(componentId, contextUser);
     if (!component) {
       throw new Error(`Component not found: ${componentId}`);
     }
@@ -697,16 +697,14 @@ export class ComponentRegistryService {
     
     for (const dep of dependencies) {
       // Find the dependency component
-      const depComponent = this.componentEngine.Components.find(
-        (c: MJComponentEntity) => UUIDsEqual(c.ID, dep.DependencyComponentID)
-      );
-      
+      const depComponent = await this.componentEngine.FindComponentByID(dep.DependencyComponentID, contextUser);
+
       if (depComponent) {
         result.push({
           name: depComponent.Name,
           namespace: depComponent.Namespace || '',
-          version: depComponent.Version, // Version comes from the linked Component record
-          isRequired: true, // All dependencies are required in MemberJunction
+          version: depComponent.Version,
+          isRequired: true,
           location: depComponent.SourceRegistryID ? 'registry' : 'embedded',
           sourceRegistryID: depComponent.SourceRegistryID
         });
@@ -734,27 +732,23 @@ export class ComponentRegistryService {
     
     await this.initialize(contextUser);
     
-    const component = this.componentEngine.Components.find((c: MJComponentEntity) => UUIDsEqual(c.ID, componentId));
+    const component = await this.componentEngine.FindComponentByID(componentId, contextUser);
     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()
-      );
-      
+      const depComponent = await this.componentEngine.FindComponent(dep.name, dep.namespace, undefined, contextUser);
+
       if (depComponent) {
         const subTree = await this.resolveDependencyTree(
-          depComponent.ID, 
-          contextUser, 
+          depComponent.ID,
+          contextUser,
           visited
         );
         dependencies.push(subTree);

package/src/registry/component-resolver.ts

@@ -95,7 +95,7 @@ export class ComponentResolver {
       }
       await this.componentEngine.Config(false, contextUser);
       if (this.debug) {
-        console.log(`✅ [ComponentResolver] Component engine initialized with ${this.componentEngine.Components?.length || 0} components`);
+        console.log(`✅ [ComponentResolver] Component engine initialized`);
       }
     }
     
@@ -243,36 +243,18 @@ export class ComponentResolver {
             console.error(`❌ [ComponentResolver] Failed to fetch from external registry: ${spec.name} from ${spec.registry}`);
           }
         } else {
-          // LOCAL REGISTRY: Get from local database
+          // LOCAL REGISTRY: Get from local database via targeted RunView
           if (this.debug) {
-            console.log(`💾 [ComponentResolver] Looking for locally registered component`);
+            console.log(`💾 [ComponentResolver] Looking for locally registered component: ${spec.name}`);
           }
-          
-          // First, try to find the component in the metadata engine
-          const allComponents = this.componentEngine.Components || [];
-          if (this.debug) {
-            console.log(`📊 [ComponentResolver] Total components in engine: ${allComponents.length}`);
-          }
-          
-          // Log all matching names to see duplicates
-          const matchingNames = allComponents.filter((c: any) => c.Name === spec.name);
-          if (matchingNames.length > 0 && this.debug) {
-            console.log(`🔎 [ComponentResolver] Found ${matchingNames.length} components with name "${spec.name}":`, 
-              matchingNames.map((c: any) => ({
-                ID: c.ID,
-                Name: c.Name,
-                Namespace: c.Namespace,
-                Version: c.Version,
-                Status: c.Status
-              }))
-            );
-          }
-          
-          const component = this.componentEngine.Components?.find(
-            (c: any) => c.Name === spec.name && 
-                 c.Namespace === (spec.namespace || namespace)
+
+          const component = await this.componentEngine.FindComponent(
+            spec.name,
+            spec.namespace || namespace,
+            undefined,
+            contextUser
           );
-          
+
           if (component) {
             if (this.debug) {
               console.log(`✅ [ComponentResolver] Found component in local DB:`, {
@@ -282,7 +264,7 @@ export class ComponentResolver {
                 Version: component.Version
               });
             }
-            
+
             // Get compiled component from registry service (local compilation)
             const compiledComponent = await this.registryService.getCompiledComponent(
               component.ID,
@@ -295,9 +277,6 @@ export class ComponentResolver {
             }
           } else {
             console.error(`❌ [ComponentResolver] Local registry component NOT found in database: ${spec.name} with namespace: ${spec.namespace || namespace}`);
-            if (this.debug) {
-              console.warn(`Local registry component not found in database: ${spec.name}`);
-            }
           }
         }
       } catch (error) {