@memberjunction/react-runtime 5.30.1 → 5.32.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memberjunction/react-runtime",
-  "version": "5.30.1",
+  "version": "5.32.0",
   "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.30.1",
-    "@memberjunction/global": "5.30.1",
-    "@memberjunction/interactive-component-types": "5.30.1",
-    "@memberjunction/core-entities": "5.30.1",
-    "@memberjunction/graphql-dataprovider": "5.30.1",
+    "@memberjunction/core": "5.32.0",
+    "@memberjunction/global": "5.32.0",
+    "@memberjunction/interactive-component-types": "5.32.0",
+    "@memberjunction/core-entities": "5.32.0",
+    "@memberjunction/graphql-dataprovider": "5.32.0",
     "@babel/standalone": "^7.29.1",
     "rxjs": "^7.8.2"
   },

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

@@ -115,8 +115,9 @@ export class ComponentManager {
       // STEP 1: Check if already loaded in ComponentRegistry
       const namespace = spec.namespace || options.defaultNamespace || 'Global';
       const version = spec.version || options.defaultVersion || 'latest';
-      
-      const existing = this.registry.get(spec.name, namespace, version);
+      const contentHash = this.calculateHash(spec);
+
+      const existing = this.registry.get(spec.name, namespace, version, contentHash);
       if (existing && !options.forceRefresh && !options.forceRecompile) {
         this.log(`Component found in registry: ${spec.name}`);
         
@@ -149,7 +150,7 @@ export class ComponentManager {
           this.fetchCache.set(componentKey, {
             spec: fullSpec,
             fetchedAt: new Date(),
-            hash: await this.calculateHash(fullSpec),
+            hash: this.calculateHash(fullSpec),
             usageNotified: false
           });
         } catch (error) {
@@ -173,7 +174,7 @@ export class ComponentManager {
           this.fetchCache.set(componentKey, {
             spec: fullSpec,
             fetchedAt: new Date(),
-            hash: await this.calculateHash(fullSpec),
+            hash: this.calculateHash(fullSpec),
             usageNotified: false
           });
         }
@@ -203,11 +204,16 @@ export class ComponentManager {
       // STEP 5: Register in ComponentRegistry
       if (!existing || options.forceRefresh || options.forceRecompile) {
         this.log(`Registering component: ${spec.name}`);
+        // Register under the INPUT spec's hash so callers passing the same
+        // spec shape on subsequent loads hit the cache. If we keyed by the
+        // post-fetch fullSpec hash instead, registry-stub callers would
+        // never re-find the entry they just cached.
         this.registry.register(
           fullSpec.name,
           compiledComponent,
           namespace,
-          version
+          version,
+          contentHash
         );
       }
       
@@ -720,9 +726,14 @@ export class ComponentManager {
   }
   
   /**
-   * Calculate a hash for a component spec (for cache validation)
+   * Calculate a content fingerprint for a component spec. Used both as a
+   * cache-validation marker on `CacheEntry` and as part of the cache key so
+   * specs that share `(registry, namespace, name, version)` but carry
+   * different `code` (e.g. a registry-reference stub vs. an inline-code
+   * Studio export of the same artifact) do not collide on a single cache
+   * slot. Sync because callers use it to build keys in non-async paths.
    */
-  private async calculateHash(spec: ComponentSpec): Promise<string> {
+  private calculateHash(spec: ComponentSpec): string {
     // Simple hash based on spec content
     const content = JSON.stringify({
       name: spec.name,
@@ -730,25 +741,30 @@ export class ComponentManager {
       code: spec.code,
       libraries: spec.libraries
     });
-    
-    // Simple hash function (in production, use crypto)
+
+    // FNV-style 32-bit integer hash
     let hash = 0;
     for (let i = 0; i < content.length; i++) {
       const char = content.charCodeAt(i);
       hash = ((hash << 5) - hash) + char;
-      hash = hash & hash; // Convert to 32bit integer
+      hash = hash & hash;
     }
     return hash.toString(16);
   }
   
   /**
-   * Generate a unique key for a component
+   * Generate a unique key for a component. Includes a content fingerprint so
+   * specs that share `(registry, namespace, name, version)` but carry
+   * different `code` (e.g. a registry-reference stub vs. an inline-code
+   * Studio export of the same artifact) are cached as separate entries
+   * instead of clobbering each other on a single slot.
    */
   private getComponentKey(spec: ComponentSpec, options: LoadOptions): string {
     const registry = spec.registry || 'local';
     const namespace = spec.namespace || options.defaultNamespace || 'Global';
     const version = spec.version || options.defaultVersion || 'latest';
-    return `${registry}:${namespace}:${spec.name}:${version}`;
+    const hash = this.calculateHash(spec);
+    return `${registry}:${namespace}:${spec.name}:${version}#${hash}`;
   }
   
   /**

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

@@ -13,7 +13,7 @@ import {
   DependencyTree, 
   RegistryComponentMetadata
 } from './registry-provider';
-import { UserInfo, Metadata } from '@memberjunction/core';
+import { UserInfo, Metadata, IMetadataProvider } from '@memberjunction/core';
 import { UUIDsEqual } from '@memberjunction/global';
 import { 
   MJComponentEntity, 
@@ -72,6 +72,19 @@ export class ComponentRegistryService {
   private registryProviders = new Map<string, RegistryProvider>();
   private debug: boolean = false;
   private graphQLClient?: IComponentRegistryClient;
+  private _provider: IMetadataProvider | null = null;
+
+  /**
+   * Optional metadata provider override. Callers should set
+   * `instance.Provider = providerToUse` before invoking registry methods
+   * in multi-provider contexts. Falls back to the global default provider when unset.
+   */
+  public get Provider(): IMetadataProvider {
+    return this._provider ?? (new Metadata() as unknown as IMetadataProvider);
+  }
+  public set Provider(value: IMetadataProvider | null) {
+    this._provider = value;
+  }
   
   private constructor(
     compiler: ComponentCompiler,
@@ -153,7 +166,7 @@ export class ComponentRegistryService {
             const client = new GraphQLComponentRegistryClient(provider as GraphQLDataProvider);
             this.cachedProviderClient = client;
             if (this.debug) {
-              console.log('📡 [ComponentRegistryService] Created GraphQL client from Metadata.Provider');
+              console.log('📡 [ComponentRegistryService] Created GraphQL client from active metadata provider');
             }
             return client;
           } catch (error) {
@@ -166,7 +179,7 @@ export class ComponentRegistryService {
     } catch (error) {
       // Provider might not be available in all environments
       if (this.debug) {
-        console.log('⚠️ [ComponentRegistryService] Could not access Metadata.Provider:', error);
+        console.log('⚠️ [ComponentRegistryService] Could not access metadata provider:', error);
       }
     }
     
@@ -349,7 +362,7 @@ export class ComponentRegistryService {
     // 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 the active metadata provider is not a GraphQLDataProvider.');
     }
     
     // Check if we have a cached version first
@@ -585,7 +598,7 @@ export class ComponentRegistryService {
     contextUser?: UserInfo
   ): Promise<void> {
     // Get the actual entity object to save
-    const md = new Metadata();
+    const md = this.Provider;
     const componentEntity = await md.GetEntityObject<MJComponentEntity>('MJ: Components', contextUser);
     
     // Load the existing component

package/src/registry/component-registry.ts

@@ -53,6 +53,11 @@ export class ComponentRegistry {
    * @param component - Compiled component object
    * @param namespace - Component namespace (default: 'Global')
    * @param version - Component version (default: 'v1')
+   * @param contentHash - Optional content fingerprint. When provided, the entry
+   *   is keyed by `(name, namespace, version, contentHash)` so multiple specs
+   *   that share `(name, namespace, version)` but carry different `code` (e.g.
+   *   a registry-reference stub vs. an inline-code Studio export of the same
+   *   artifact) coexist in the cache instead of clobbering each other.
    * @param tags - Optional tags for categorization
    * @returns The registered component's metadata
    */
@@ -61,10 +66,11 @@ export class ComponentRegistry {
     component: ComponentObject,
     namespace: string = 'Global',
     version: string = 'v1',
+    contentHash?: string,
     tags?: string[]
   ): ComponentMetadata {
-    const id = this.generateRegistryKey(name, namespace, version);
-    
+    const id = this.generateRegistryKey(name, namespace, version, contentHash);
+
     // Create metadata
     const metadata: ComponentMetadata = {
       id,
@@ -99,12 +105,14 @@ export class ComponentRegistry {
    * @param name - Component name
    * @param namespace - Component namespace
    * @param version - Component version
+   * @param contentHash - Optional content fingerprint. When provided, looks up
+   *   the exact `(name, namespace, version, contentHash)` entry. When omitted,
+   *   falls back to the most recently registered entry matching the other keys
+   *   (existing behavior).
    * @returns The component object if found, undefined otherwise
    */
-  get(name: string, namespace: string = 'Global', version?: string): ComponentObject | undefined {
-    const id = version 
-      ? this.generateRegistryKey(name, namespace, version)
-      : this.findLatestVersion(name, namespace);
+  get(name: string, namespace: string = 'Global', version?: string, contentHash?: string): ComponentObject | undefined {
+    const id = this.resolveLookupKey(name, namespace, version, contentHash);
 
     if (!id) return undefined;
 
@@ -124,13 +132,11 @@ export class ComponentRegistry {
    * @param name - Component name
    * @param namespace - Component namespace
    * @param version - Component version
+   * @param contentHash - Optional content fingerprint (see {@link get})
    * @returns true if the component exists
    */
-  has(name: string, namespace: string = 'Global', version?: string): boolean {
-    const id = version 
-      ? this.generateRegistryKey(name, namespace, version)
-      : this.findLatestVersion(name, namespace);
-
+  has(name: string, namespace: string = 'Global', version?: string, contentHash?: string): boolean {
+    const id = this.resolveLookupKey(name, namespace, version, contentHash);
     return id ? this.registry.has(id) : false;
   }
 
@@ -139,15 +145,12 @@ export class ComponentRegistry {
    * @param name - Component name
    * @param namespace - Component namespace
    * @param version - Component version
+   * @param contentHash - Optional content fingerprint (see {@link get})
    * @returns true if the component was removed
    */
-  unregister(name: string, namespace: string = 'Global', version?: string): boolean {
-    const id = version 
-      ? this.generateRegistryKey(name, namespace, version)
-      : this.findLatestVersion(name, namespace);
-
+  unregister(name: string, namespace: string = 'Global', version?: string, contentHash?: string): boolean {
+    const id = this.resolveLookupKey(name, namespace, version, contentHash);
     if (!id) return false;
-
     return this.registry.delete(id);
   }
 
@@ -222,12 +225,10 @@ export class ComponentRegistry {
    * @param name - Component name
    * @param namespace - Component namespace
    * @param version - Component version
+   * @param contentHash - Optional content fingerprint (see {@link get})
    */
-  release(name: string, namespace: string = 'Global', version?: string): void {
-    const id = version 
-      ? this.generateRegistryKey(name, namespace, version)
-      : this.findLatestVersion(name, namespace);
-
+  release(name: string, namespace: string = 'Global', version?: string, contentHash?: string): void {
+    const id = this.resolveLookupKey(name, namespace, version, contentHash);
     if (!id) return;
 
     const entry = this.registry.get(id);
@@ -352,17 +353,55 @@ export class ComponentRegistry {
   }
 
   /**
-   * Generates a unique registry key
-   * @param name - Component name
-   * @param namespace - Component namespace
-   * @param version - Component version
-   * @returns Registry key
+   * Generates a unique registry key. When `contentHash` is supplied, it is
+   * appended so two specs that share `(name, namespace, version)` but have
+   * different code body don't collide.
+   */
+  private generateRegistryKey(name: string, namespace: string, version: string, contentHash?: string): string {
+    const base = this.config.enableNamespaces ? `${namespace}::${name}@${version}` : `${name}@${version}`;
+    return contentHash ? `${base}#${contentHash}` : base;
+  }
+
+  /**
+   * Resolves a lookup to an exact internal key. Centralizes the four
+   * lookup-shape variants used by `get`, `has`, `unregister`, and `release`:
+   *
+   * - hash + version  → exact hash-suffixed key
+   * - version only    → latest entry matching `(name, namespace, version)` across all hashes
+   * - hash only       → no version → fall back to latest version (hash isn't enough alone)
+   * - neither         → latest entry matching `(name, namespace)`
+   */
+  private resolveLookupKey(name: string, namespace: string, version?: string, contentHash?: string): string | undefined {
+    if (version && contentHash) {
+      return this.generateRegistryKey(name, namespace, version, contentHash);
+    }
+    if (version) {
+      return this.findLatestForVersion(name, namespace, version);
+    }
+    return this.findLatestVersion(name, namespace);
+  }
+
+  /**
+   * Find the most recently registered entry whose metadata matches
+   * `(name, namespace, version)`. Different content hashes for the same
+   * version are scanned and the newest by `registeredAt` wins.
    */
-  private generateRegistryKey(name: string, namespace: string, version: string): string {
-    if (this.config.enableNamespaces) {
-      return `${namespace}::${name}@${version}`;
+  private findLatestForVersion(name: string, namespace: string, version: string): string | undefined {
+    let latestKey: string | undefined;
+    let latestDate: Date | undefined;
+
+    for (const [key, entry] of this.registry) {
+      if (entry.metadata.name === name &&
+          entry.metadata.namespace === namespace &&
+          entry.metadata.version === version) {
+        if (!latestDate || entry.metadata.registeredAt > latestDate) {
+          latestDate = entry.metadata.registeredAt;
+          latestKey = key;
+        }
+      }
     }
-    return `${name}@${version}`;
+
+    return latestKey;
   }
 
   /**
@@ -376,7 +415,7 @@ export class ComponentRegistry {
     let latestDate: Date | undefined;
 
     for (const [key, entry] of this.registry) {
-      if (entry.metadata.name === name && 
+      if (entry.metadata.name === name &&
           entry.metadata.namespace === namespace) {
         if (!latestDate || entry.metadata.registeredAt > latestDate) {
           latestDate = entry.metadata.registeredAt;