@memberjunction/server 5.30.1 → 5.32.0

package/src/generic/ResolverBase.ts

@@ -5,8 +5,10 @@ import {
   CompositeKey,
   DatabaseProviderBase,
   EntityFieldTSType,
+  EntityInfo,
   EntityPermissionType,
   EntitySaveOptions,
+  IMetadataProvider,
   IRunViewProvider,
   LogDebug,
   LogError,
@@ -65,7 +67,7 @@ export class ResolverBase {
    * @param contextUser - Optional user context for decryption (required for encrypted fields)
    * @returns The processed data object
    */
-  protected async MapFieldNamesToCodeNames(entityName: string, dataObject: any, contextUser?: UserInfo): Promise<any> {
+  protected async MapFieldNamesToCodeNames(entityName: string, dataObject: any, contextUser?: UserInfo, provider?: IMetadataProvider): Promise<any> {
     // Return null for empty objects (e.g. when no rows found due to RLS filtering)
     if (!dataObject || Object.keys(dataObject).length === 0) {
       return null;
@@ -77,8 +79,8 @@ export class ResolverBase {
     // with the CodeName, because we can't transfer those via GraphQL as they are not
     // valid property names in GraphQL
     {
-      const md = new Metadata();
-      const entityInfo = md.Entities.find((e) => e.Name === entityName);
+      const md = provider ?? new Metadata();
+      const entityInfo = md.EntityByName(entityName);
       if (!entityInfo) throw new Error(`Entity ${entityName} not found in metadata`);
       // const fields = entityInfo.Fields.filter((f) => f.Name !== f.CodeName || f.Name.startsWith('__mj_'));
       const mapper = new FieldMapper();
@@ -209,12 +211,13 @@ export class ResolverBase {
   protected async FilterEncryptedFieldsForAPI(
     entityName: string,
     dataObject: Record<string, unknown>,
-    contextUser: UserInfo
+    contextUser: UserInfo,
+    provider?: IMetadataProvider
   ): Promise<Record<string, unknown>> {
     if (!dataObject) return dataObject;
 
-    const md = new Metadata();
-    const entityInfo = md.Entities.find((e) => e.Name === entityName);
+    const md = provider ?? new Metadata();
+    const entityInfo = md.EntityByName(entityName);
     if (!entityInfo) return dataObject;
 
     // Find all encrypted fields that need filtering
@@ -269,13 +272,14 @@ export class ResolverBase {
   protected async ArrayFilterEncryptedFieldsForAPI(
     entityName: string,
     dataObjectArray: Record<string, unknown>[],
-    contextUser: UserInfo
+    contextUser: UserInfo,
+    provider?: IMetadataProvider
   ): Promise<Record<string, unknown>[]> {
     if (!dataObjectArray || dataObjectArray.length === 0) return dataObjectArray;
 
     // Check if entity has any encrypted fields first to avoid unnecessary processing
-    const md = new Metadata();
-    const entityInfo = md.Entities.find((e) => e.Name === entityName);
+    const md = provider ?? new Metadata();
+    const entityInfo = md.EntityByName(entityName);
     if (!entityInfo) return dataObjectArray;
 
     const encryptedFields = entityInfo.Fields.filter(f => f.Encrypt && !f.AllowDecryptInAPI);
@@ -283,7 +287,7 @@ export class ResolverBase {
 
     // Process each element
     for (const element of dataObjectArray) {
-      await this.FilterEncryptedFieldsForAPI(entityName, element, contextUser);
+      await this.FilterEncryptedFieldsForAPI(entityName, element, contextUser, provider);
     }
 
     return dataObjectArray;
@@ -562,9 +566,9 @@ export class ResolverBase {
     }
   }
 
-  protected CheckUserReadPermissions(entityName: string, userPayload: UserPayload | null) {
-    const md = new Metadata();
-    const entityInfo = md.Entities.find((e) => e.Name === entityName);
+  protected CheckUserReadPermissions(entityName: string, userPayload: UserPayload | null, provider?: IMetadataProvider) {
+    const md = provider ?? new Metadata();
+    const entityInfo = md.EntityByName(entityName);
     if (!userPayload) {
       throw new Error(`userPayload is null`);
     }
@@ -796,10 +800,10 @@ export class ResolverBase {
       // Skip processing if no params
       if (!params.length) return [];
 
-      let md: Metadata | null = null;
+      let md: IMetadataProvider | null = null;
       const rv = params[0].provider as any as IRunViewProvider;
       let runViewParams: RunViewParams[] = [];
-      
+
       // Fix #1: Get user info only once for all queries
       let contextUser: UserInfo | null = null;
       if (params[0]?.userPayload?.email) {
@@ -810,10 +814,12 @@ export class ResolverBase {
         }
         contextUser = user;
       }
-      
+
       // Create a map of entities to validate only once per entity
       const validatedEntities = new Set<string>();
-      md = new Metadata();
+      // Use the per-request provider that came in on params instead of `new Metadata()` so
+      // multi-tenant servers resolve metadata against the request's own connection.
+      md = params[0].provider as unknown as IMetadataProvider;
 
       // Transform parameters
       for (const param of params) {
@@ -821,7 +827,7 @@ export class ResolverBase {
           // Validate entity only once per entity type
           const entityName = param.viewInfo.Entity;
           if (!validatedEntities.has(entityName)) {
-            const entityInfo = md.Entities.find(e => e.Name === entityName);
+            const entityInfo = md.EntityByName(entityName);
             if (!entityInfo) {
               throw new Error(`Entity ${entityName} not found in metadata`);
             }
@@ -998,7 +1004,7 @@ export class ResolverBase {
   }
 
   public get MJCoreSchema(): string {
-    return Metadata.Provider.ConfigData.MJCoreSchemaName;
+    return Metadata.Provider.ConfigData.MJCoreSchemaName; // global-provider-ok: process-wide config (schema name) read once at module level
   }
 
   /**
@@ -1356,9 +1362,10 @@ export class ResolverBase {
           }
         });
 
-        // Create ErrorLog record in the database
+        // Create ErrorLog record in the database — use the entity's bound provider so the
+        // ErrorLog write goes to the same connection as the entity that triggered it.
         try {
-          const md = new Metadata();
+          const md = entityObject.ProviderToUse as unknown as IMetadataProvider;
           const errorLogEntity = await md.GetEntityObject<MJErrorLogEntity>('MJ: Error Logs', contextUser);
           errorLogEntity.Code = 'ENTITY_SAVE_INCONSISTENCY';
           errorLogEntity.Message = `Entity save inconsistency detected for ${entityObject.EntityInfo.Name}: ${JSON.stringify(msg)}`;

package/src/index.ts

@@ -100,6 +100,7 @@ export * from './resolvers/FetchEntityVectorsResolver.js';
 export * from './resolvers/PipelineProgressResolver.js';
 export * from './resolvers/ClientToolRequestResolver.js';
 export * from './resolvers/AutotagPipelineResolver.js';
+export * from './resolvers/TagGovernanceResolver.js';
 export * from './resolvers/TaskResolver.js';
 export * from './generic/KeyValuePairInput.js';
 export * from './generic/KeyInputOutputTypes.js';
@@ -284,7 +285,7 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
       return origExecuteSQLWithPool.call(this, pool, query, parameters, contextUser);
     };
 
-    const md = new Metadata();
+    const md = new Metadata(); // global-provider-ok: bootstrap
     console.log(`Data Source has been initialized. ${md?.Entities ? md.Entities.length : 0} entities loaded.`);
   } else {
     // ─── SQL Server Path (existing behavior) ───────────────────────
@@ -326,7 +327,7 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
     const config = new SQLServerProviderConfigData(pool, mj_core_schema, cacheRefreshInterval);
     await setupSQLServerClient(config);
     tPhase = lap('Metadata + Provider Setup', tPhase);
-    const md = new Metadata();
+    const md = new Metadata(); // global-provider-ok: bootstrap
     console.log(`Data Source has been initialized. ${md?.Entities ? md.Entities.length : 0} entities loaded.`);
 
     // Set up CodeGen-credentialed provider for RSU DDL operations (CREATE TABLE, CREATE SCHEMA, etc.)
@@ -418,7 +419,7 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
       enablePubSub: true,
       enableLogging: true,
     });
-    (Metadata.Provider as GenericDatabaseProvider).SetLocalStorageProvider(redisProvider);
+    (Metadata.Provider as GenericDatabaseProvider).SetLocalStorageProvider(redisProvider); // global-provider-ok: bootstrap (Redis cache wiring)
     await redisProvider.StartListening();
 
     // Connect Redis pub/sub events to LocalCacheManager callback dispatch
@@ -449,7 +450,7 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
   // LocalCacheManager may have already been initialized (with in-memory provider)
   // during engine loading. SetStorageProvider migrates cached data to Redis.
   if (process.env.REDIS_URL) {
-    await LocalCacheManager.Instance.SetStorageProvider(Metadata.Provider.LocalStorageProvider);
+    await LocalCacheManager.Instance.SetStorageProvider(Metadata.Provider.LocalStorageProvider); // global-provider-ok: bootstrap
     console.log('LocalCacheManager: storage provider swapped to Redis');
   }
   // Ensure LocalCacheManager is initialized (no-op if already done during engine loading)
@@ -463,7 +464,7 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
       evictionSweepIntervalMs: (cs.evictionSweepIntervalSeconds ?? 300) * 1000,
       verboseLogging: cs.verboseLogging ?? false,
     };
-    await LocalCacheManager.Instance.Initialize(Metadata.Provider.LocalStorageProvider, cacheConfig);
+    await LocalCacheManager.Instance.Initialize(Metadata.Provider.LocalStorageProvider, cacheConfig); // global-provider-ok: bootstrap
     console.log('LocalCacheManager initialized with cache config:', JSON.stringify({
       maxMemoryMB: cs.maxMemoryMB ?? 150,
       maxPercentOfCachePerEntity: cs.maxPercentOfCachePerEntity ?? 50,
@@ -943,8 +944,7 @@ async function processRSUPendingWork(): Promise<void> {
 
   for (const item of pendingItems) {
     try {
-      const md = new Metadata();
-
+      const md = new Metadata(); // global-provider-ok: server startup recovery — runs once before any per-request context exists
       // Get system user for server-side operations
       const systemUser = UserCache.Instance.Users.find(u => u.Type?.trim().toLowerCase() === 'owner') ?? UserCache.Instance.Users[0];
       if (!systemUser) {
@@ -952,7 +952,7 @@ async function processRSUPendingWork(): Promise<void> {
         continue;
       }
 
-      await Metadata.Provider.Refresh();
+      await Metadata.Provider.Refresh(); // global-provider-ok: server startup recovery — one-shot global cache refresh
 
       // Resolve connector
       const rv = new RunView();
@@ -1221,7 +1221,7 @@ async function refreshUserCacheFromPG(pgPool: import('pg').Pool, coreSchema: str
         ...user,
         UserRoles: roles.filter((role: Record<string, unknown>) => UUIDsEqual(role.UserID as string, user.ID as string)),
       };
-      return new UserInfo(Metadata.Provider, userWithRoles);
+      return new UserInfo(Metadata.Provider, userWithRoles); // global-provider-ok: bootstrap (UserCache initialization)
     });
     // Access the UserCache internals to set users
     const cache = UserCache.Instance;

package/src/multiTenancy/index.ts

@@ -67,7 +67,7 @@ export function attachTenantContext(
 function isEntityScoped(entityName: string, config: MultiTenancyConfig): boolean {
   // Auto-exclude core MJ entities (entities in the __mj schema)
   if (config.autoExcludeCoreEntities) {
-    const md = new Metadata();
+    const md = new Metadata(); // global-provider-ok: read-only schema check. Hooks (PreRunViewHook/PreSaveHook) don't carry per-request provider; reading the constant `__mj` schema flag is identical across every provider's catalog.
     const entity = md.Entities.find(
       e => e.Name.trim().toLowerCase() === entityName.trim().toLowerCase()
     );

package/src/resolvers/APIKeyResolver.ts

@@ -1,10 +1,11 @@
 import { Resolver, Mutation, Arg, Ctx } from "type-graphql";
 import { Field, InputType, ObjectType } from "type-graphql";
-import { LogError, Metadata } from "@memberjunction/core";
+import { IMetadataProvider, LogError, Metadata } from "@memberjunction/core";
 import { MJAPIKeyScopeEntity } from "@memberjunction/core-entities";
 import { GetAPIKeyEngine } from "@memberjunction/api-keys";
 import { AppContext } from "../types.js";
 import { ResolverBase } from "../generic/ResolverBase.js";
+import { GetReadWriteProvider } from "../util.js";
 
 /**
  * Input type for creating a new API key
@@ -144,7 +145,8 @@ export class APIKeyResolver extends ResolverBase {
 
             // Save scope associations if provided
             if (input.ScopeIDs && input.ScopeIDs.length > 0 && result.APIKeyId) {
-                await this.saveScopeAssociations(result.APIKeyId, input.ScopeIDs, user);
+                const writeProvider = GetReadWriteProvider(ctx.providers, { allowFallbackToReadOnly: true }) as unknown as IMetadataProvider;
+                await this.saveScopeAssociations(result.APIKeyId, input.ScopeIDs, user, writeProvider);
             }
 
             return {
@@ -219,9 +221,10 @@ export class APIKeyResolver extends ResolverBase {
     private async saveScopeAssociations(
         apiKeyId: string,
         scopeIds: string[],
-        user: any
+        user: any,
+        provider?: IMetadataProvider
     ): Promise<void> {
-        const md = new Metadata();
+        const md = provider ?? new Metadata();
 
         for (const scopeId of scopeIds) {
             try {

package/src/resolvers/AutotagPipelineResolver.ts

@@ -1,12 +1,13 @@
 import { Resolver, Mutation, Ctx, Arg, ObjectType, Field } from 'type-graphql';
 import { AppContext } from '../types.js';
-import { LogError, LogStatus, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { IMetadataProvider, LogError, LogStatus, Metadata, RunView, UserInfo } from '@memberjunction/core';
 import { MJContentProcessRunEntity } from '@memberjunction/core-entities';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { ActionEngineServer } from '@memberjunction/actions';
 import { PubSubManager } from '../generic/PubSubManager.js';
 import { PipelineProgressNotification } from './PipelineProgressResolver.js';
 import { v4 as uuidv4 } from 'uuid';
+import { GetReadWriteProvider } from '../util.js';
 
 const PIPELINE_PROGRESS_TOPIC = 'PIPELINE_PROGRESS';
 
@@ -31,7 +32,7 @@ export class AutotagPipelineResolver extends ResolverBase {
     async RunAutotagPipeline(
         @Arg('contentSourceIDs', () => [String], { nullable: true }) contentSourceIDs: string[] | undefined,
         @Arg('forceReprocess', { nullable: true }) forceReprocess: boolean | undefined,
-        @Ctx() { userPayload }: AppContext = {} as AppContext
+        @Ctx() { userPayload, providers }: AppContext = {} as AppContext
     ): Promise<AutotagPipelineResult> {
         try {
             const currentUser = this.GetUserFromPayload(userPayload);
@@ -42,8 +43,14 @@ export class AutotagPipelineResolver extends ResolverBase {
             const pipelineRunID = uuidv4();
             LogStatus(`RunAutotagPipeline: starting pipeline ${pipelineRunID}`);
 
+            // Capture the per-request provider snapshot before returning so the fire-and-forget
+            // background job binds to the same connection the caller used. Without this, the
+            // background job would silently use the global default — wrong for multi-tenant.
+            const provider = (GetReadWriteProvider(providers, { allowFallbackToReadOnly: true }) as unknown as IMetadataProvider)
+                ?? (new Metadata() as unknown as IMetadataProvider);
+
             // Fire-and-forget: start the pipeline in the background and return immediately
-            this.runPipelineInBackground(pipelineRunID, currentUser, contentSourceIDs, forceReprocess);
+            this.runPipelineInBackground(pipelineRunID, currentUser, provider, contentSourceIDs, forceReprocess);
 
             return {
                 Success: true,
@@ -68,11 +75,12 @@ export class AutotagPipelineResolver extends ResolverBase {
     private async runPipelineInBackground(
         pipelineRunID: string,
         currentUser: UserInfo,
+        provider: IMetadataProvider,
         contentSourceIDs?: string[],
         forceReprocess?: boolean
     ): Promise<void> {
         const startTime = Date.now();
-        const processRun = await this.createProcessRun(pipelineRunID, currentUser, contentSourceIDs);
+        const processRun = await this.createProcessRun(pipelineRunID, currentUser, provider, contentSourceIDs);
 
         try {
             this.publishProgress(pipelineRunID, 'autotag', 0, 0, startTime, 'Initializing pipeline...');
@@ -147,6 +155,7 @@ export class AutotagPipelineResolver extends ResolverBase {
     private async createProcessRun(
         pipelineRunID: string,
         currentUser: UserInfo,
+        provider: IMetadataProvider,
         contentSourceIDs?: string[]
     ): Promise<MJContentProcessRunEntity | null> {
         try {
@@ -156,7 +165,7 @@ export class AutotagPipelineResolver extends ResolverBase {
                 sourceID = contentSourceIDs[0];
             } else {
                 // Load content sources to get any available source ID (SourceID is NOT NULL)
-                const rv = new RunView();
+                const rv = RunView.FromMetadataProvider(provider);
                 const result = await rv.RunView<{ ID: string }>({
                     EntityName: 'MJ: Content Sources',
                     Fields: ['ID'],
@@ -173,7 +182,7 @@ export class AutotagPipelineResolver extends ResolverBase {
                 return null;
             }
 
-            const md = new Metadata();
+            const md = provider;
             const run = await md.GetEntityObject<MJContentProcessRunEntity>('MJ: Content Process Runs', currentUser);
             run.NewRecord();
             run.ID = pipelineRunID;
@@ -252,7 +261,7 @@ export class AutotagPipelineResolver extends ResolverBase {
     @Mutation(() => AutotagPipelineResult)
     async PauseClassificationPipeline(
         @Arg('processRunID') processRunID: string,
-        @Ctx() { userPayload }: AppContext = {} as AppContext
+        @Ctx() { userPayload, providers }: AppContext = {} as AppContext
     ): Promise<AutotagPipelineResult> {
         try {
             const currentUser = this.GetUserFromPayload(userPayload);
@@ -260,7 +269,7 @@ export class AutotagPipelineResolver extends ResolverBase {
                 return { Success: false, Status: 'Error', ErrorMessage: 'Unable to determine current user' };
             }
 
-            const md = new Metadata();
+            const md = (GetReadWriteProvider(providers, { allowFallbackToReadOnly: true }) as unknown as IMetadataProvider) ?? new Metadata();
             const run = await md.GetEntityObject<MJContentProcessRunEntity>('MJ: Content Process Runs', currentUser);
             const loaded = await run.Load(processRunID);
             if (!loaded) {
@@ -284,7 +293,7 @@ export class AutotagPipelineResolver extends ResolverBase {
     @Mutation(() => AutotagPipelineResult)
     async ResumeClassificationPipeline(
         @Arg('processRunID') processRunID: string,
-        @Ctx() { userPayload }: AppContext = {} as AppContext
+        @Ctx() { userPayload, providers }: AppContext = {} as AppContext
     ): Promise<AutotagPipelineResult> {
         try {
             const currentUser = this.GetUserFromPayload(userPayload);
@@ -292,7 +301,7 @@ export class AutotagPipelineResolver extends ResolverBase {
                 return { Success: false, Status: 'Error', ErrorMessage: 'Unable to determine current user' };
             }
 
-            const md = new Metadata();
+            const md = (GetReadWriteProvider(providers, { allowFallbackToReadOnly: true }) as unknown as IMetadataProvider) ?? new Metadata();
             const run = await md.GetEntityObject<MJContentProcessRunEntity>('MJ: Content Process Runs', currentUser);
             const loaded = await run.Load(processRunID);
             if (!loaded) {
@@ -312,7 +321,7 @@ export class AutotagPipelineResolver extends ResolverBase {
             const pipelineRunID = uuidv4();
             LogStatus(`ResumeClassificationPipeline: Resuming run ${processRunID} from offset ${run.LastProcessedOffset}`);
 
-            this.runPipelineInBackground(pipelineRunID, currentUser, undefined, undefined);
+            this.runPipelineInBackground(pipelineRunID, currentUser, md as unknown as IMetadataProvider, undefined, undefined);
 
             return { Success: true, Status: 'Resumed', PipelineRunID: pipelineRunID };
         } catch (error) {

package/src/resolvers/ComponentRegistryResolver.ts

@@ -1,5 +1,5 @@
 import { Arg, Ctx, Field, InputType, ObjectType, Query, Mutation, Resolver } from 'type-graphql';
-import { UserInfo, Metadata, LogError, LogStatus } from '@memberjunction/core';
+import { UserInfo, IMetadataProvider, Metadata, LogError, LogStatus } from '@memberjunction/core';
 import { UUIDsEqual } from '@memberjunction/global';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { MJComponentEntity, MJComponentRegistryEntity, ComponentMetadataEngine } from '@memberjunction/core-entities';
@@ -16,6 +16,7 @@ import {
 } from '@memberjunction/component-registry-client-sdk';
 import { AppContext } from '../types.js';
 import { configInfo } from '../config.js';
+import { GetReadWriteProvider } from '../util.js';
 
 /**
  * GraphQL types for Component Registry operations
@@ -181,7 +182,7 @@ export class ComponentRegistryExtendedResolver {
         @Arg('registryName') registryName: string,
         @Arg('namespace') namespace: string,
         @Arg('name') name: string,
-        @Ctx() { userPayload }: AppContext,
+        @Ctx() { userPayload, providers }: AppContext,
         @Arg('version', { nullable: true }) version?: string,
         @Arg('hash', { nullable: true }) hash?: string
     ): Promise<ComponentSpecWithHashType> {
@@ -234,7 +235,8 @@ export class ComponentRegistryExtendedResolver {
             
             // Optional: Cache in database if configured
             if (this.shouldCache(registry)) {
-                await this.cacheComponent(component, registry.ID, user);
+                const writeProvider = GetReadWriteProvider(providers, { allowFallbackToReadOnly: true }) as unknown as IMetadataProvider;
+                await this.cacheComponent(component, registry.ID, user, writeProvider);
             }
             
             // Return the ComponentSpec as a JSON string
@@ -505,11 +507,12 @@ export class ComponentRegistryExtendedResolver {
     private async cacheComponent(
         component: ComponentSpec,
         registryId: string,
-        userInfo: UserInfo
+        userInfo: UserInfo,
+        provider?: IMetadataProvider
     ): Promise<void> {
         try {
             // Find or create component entity
-            const md = new Metadata();
+            const md = provider ?? new Metadata();
             const componentEntity = await md.GetEntityObject<MJComponentEntity>('MJ: Components', userInfo);
             
             // Check if component already exists

package/src/resolvers/FileResolver.ts

@@ -1,4 +1,4 @@
-import { EntityPermissionType, Metadata, FieldValueCollection, EntitySaveOptions } from '@memberjunction/core';
+import { EntityPermissionType, FieldValueCollection, EntitySaveOptions } from '@memberjunction/core';
 import { NormalizeUUID } from '@memberjunction/global';
 import { MJFileEntity, MJFileStorageProviderEntity, MJFileStorageAccountEntity } from '@memberjunction/core-entities';
 import {
@@ -417,7 +417,7 @@ export class FileResolver extends FileResolverBase {
 
   @FieldResolver(() => String)
   async DownloadUrl(@Root() file: MJFile_, @Ctx() context: AppContext) {
-    const md = new Metadata();
+    const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
     const user = this.GetUserFromPayload(context.userPayload);
     const fileEntity = await md.GetEntityObject<MJFileEntity>('MJ: Files', user);
     fileEntity.CheckPermissions(EntityPermissionType.Read, true);

package/src/resolvers/GetDataContextDataResolver.ts

@@ -2,7 +2,6 @@ import { Arg, Ctx, Field, ObjectType, Query, Resolver } from "type-graphql";
 import { AppContext } from "../types.js";
 import { DataContext } from "@memberjunction/data-context";
 import { GetReadOnlyDataSource, GetReadOnlyProvider } from "../util.js";
-import { Metadata } from "@memberjunction/core";
 import { MJDataContextItemEntity } from "@memberjunction/core-entities";
 import { ResolverBase } from "../generic/ResolverBase.js";
 
@@ -62,7 +61,7 @@ export class GetDataContextDataResolver extends ResolverBase {
             const dciData = await md.GetEntityObject<MJDataContextItemEntity>("MJ: Data Context Items", appCtx.userPayload.userRecord);
             if (await dciData.Load(DataContextItemID)) {
                 const dci = DataContext.CreateDataContextItem(); // use class factory to get whatever lowest level sub-class is registered
-                await dci.LoadMetadataFromEntityRecord(dciData, Metadata.Provider, appCtx.userPayload.userRecord);
+                await dci.LoadMetadataFromEntityRecord(dciData, md, appCtx.userPayload.userRecord);
                 // now the metadata is loaded so we can call the regular load function
                 if (await dci.LoadData(ds)) {
                     return {

package/src/resolvers/ISAEntityResolver.ts

@@ -1,4 +1,4 @@
-import { EntityInfo, IEntityDataProvider, Metadata, UserInfo } from '@memberjunction/core';
+import { IEntityDataProvider } from '@memberjunction/core';
 import { Arg, Ctx, Field, ObjectType, Query, Resolver } from 'type-graphql';
 import { AppContext } from '../types.js';
 import { GetReadOnlyProvider } from '../util.js';
@@ -63,8 +63,7 @@ export class ISAEntityResolver {
     ): Promise<ISAChildEntityResult> {
         try {
             const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
-            const md = new Metadata();
-            const entityInfo = md.Entities.find(e => e.Name === EntityName);
+            const entityInfo = provider.Entities.find(e => e.Name === EntityName);
 
             if (!entityInfo) {
                 return {
@@ -127,8 +126,7 @@ export class ISAEntityResolver {
     ): Promise<ISAChildEntitiesResult> {
         try {
             const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
-            const md = new Metadata();
-            const entityInfo = md.Entities.find(e => e.Name === EntityName);
+            const entityInfo = provider.Entities.find(e => e.Name === EntityName);
 
             if (!entityInfo) {
                 return {