@memberjunction/server 2.95.0 → 2.96.0

package/src/resolvers/PotentialDuplicateRecordResolver.ts

@@ -14,6 +14,7 @@ import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { LoadMistralEmbedding } from '@memberjunction/ai-mistral';
 import { LoadPineconeVectorDB } from '@memberjunction/ai-vectors-pinecone';
 import { CompositeKeyInputType, CompositeKeyOutputType, KeyValuePairOutputType } from '../generic/KeyInputOutputTypes.js';
+import { GetReadOnlyProvider } from '../util.js';
 LoadMistralEmbedding();
 LoadPineconeVectorDB();
 
@@ -75,10 +76,10 @@ export class PotentialDuplicateResponseType extends PotentialDuplicateResponse {
 export class DuplicateRecordResolver {
   @Query(() => PotentialDuplicateResponseType)
   async GetRecordDuplicates(
-    @Ctx() { dataSource, userPayload }: AppContext,
+    @Ctx() { dataSource, userPayload, providers }: AppContext,
     @Arg('params') params: PotentialDuplicateRequestType
   ): Promise<PotentialDuplicateResponseType> {
-    const md = new Metadata();
+    const md = GetReadOnlyProvider(providers);
 
     const user = UserCache.Instance.Users.find((u) => u.Email.trim().toLowerCase() === userPayload.email.trim().toLowerCase());
     if (!user) {

package/src/resolvers/QueryResolver.ts

@@ -1,9 +1,10 @@
 import { Arg, Ctx, ObjectType, Query, Resolver, Field, Int } from 'type-graphql';
-import { RunQuery, QueryInfo } from '@memberjunction/core';
+import { RunQuery, QueryInfo, IRunQueryProvider, IMetadataProvider } from '@memberjunction/core';
 import { AppContext } from '../types.js';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { GraphQLJSONObject } from 'graphql-type-json';
 import { Metadata } from '@memberjunction/core';
+import { GetReadOnlyProvider } from '../util.js';
 
 @ObjectType()
 export class RunQueryResultType {
@@ -43,9 +44,7 @@ export class RunQueryResultType {
 
 @Resolver()
 export class RunQueryResolver {
-  private async findQuery(QueryID: string, QueryName?: string, CategoryID?: string, CategoryPath?: string, refreshMetadataIfNotFound: boolean = false): Promise<QueryInfo | null> {
-    const md = new Metadata();
-    
+  private async findQuery(md: IMetadataProvider, QueryID: string, QueryName?: string, CategoryID?: string, CategoryPath?: string, refreshMetadataIfNotFound: boolean = false): Promise<QueryInfo | null> {
     // Filter queries based on provided criteria
     const queries = md.Queries.filter(q => {
       if (QueryID) {
@@ -67,7 +66,7 @@ export class RunQueryResolver {
       if (refreshMetadataIfNotFound) {
         // If we didn't find the query, refresh metadata and try again
         await md.Refresh();
-        return this.findQuery(QueryID, QueryName, CategoryID, CategoryPath, false); // change the refresh flag to false so we don't loop infinitely
+        return this.findQuery(md, QueryID, QueryName, CategoryID, CategoryPath, false); // change the refresh flag to false so we don't loop infinitely
       } 
       else {
         return null; // No query found and not refreshing metadata
@@ -87,9 +86,11 @@ export class RunQueryResolver {
                      @Arg('StartRow', () => Int, {nullable: true}) StartRow?: number,
                      @Arg('ForceAuditLog', () => Boolean, {nullable: true}) ForceAuditLog?: boolean,
                      @Arg('AuditLogDescription', () => String, {nullable: true}) AuditLogDescription?: string): Promise<RunQueryResultType> {
-    const runQuery = new RunQuery();
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true});
+    const md = provider as unknown as IMetadataProvider;
+    const rq = new RunQuery(provider as unknown as IRunQueryProvider);
     console.log('GetQueryData called with:', { QueryID, Parameters, MaxRows, StartRow, ForceAuditLog, AuditLogDescription });
-    const result = await runQuery.RunQuery(
+    const result = await rq.RunQuery(
       { 
         QueryID: QueryID,
         CategoryID: CategoryID,
@@ -111,7 +112,7 @@ export class RunQueryResolver {
     let queryName = result.QueryName;
     if (!queryName) {
       try {
-        const queryInfo = await this.findQuery(QueryID, undefined, CategoryID, CategoryPath, true);
+        const queryInfo = await this.findQuery(md, QueryID, undefined, CategoryID, CategoryPath, true);
         if (queryInfo) {
           queryName = queryInfo.Name;
         }
@@ -145,8 +146,9 @@ export class RunQueryResolver {
                            @Arg('StartRow', () => Int, {nullable: true}) StartRow?: number,
                            @Arg('ForceAuditLog', () => Boolean, {nullable: true}) ForceAuditLog?: boolean,
                            @Arg('AuditLogDescription', () => String, {nullable: true}) AuditLogDescription?: string): Promise<RunQueryResultType> {
-    const runQuery = new RunQuery();
-    const result = await runQuery.RunQuery(
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true});
+    const rq = new RunQuery(provider as unknown as IRunQueryProvider);
+    const result = await rq.RunQuery(
       { 
         QueryName: QueryName, 
         CategoryID: CategoryID,
@@ -185,8 +187,11 @@ export class RunQueryResolver {
                                @Arg('StartRow', () => Int, {nullable: true}) StartRow?: number,
                                @Arg('ForceAuditLog', () => Boolean, {nullable: true}) ForceAuditLog?: boolean,
                                @Arg('AuditLogDescription', () => String, {nullable: true}) AuditLogDescription?: string): Promise<RunQueryResultType> {
-    const runQuery = new RunQuery();
-    const result = await runQuery.RunQuery(
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true});
+    const md = provider as unknown as IMetadataProvider;
+    const rq = new RunQuery(provider as unknown as IRunQueryProvider);
+
+    const result = await rq.RunQuery(
       { 
         QueryID: QueryID,
         CategoryID: CategoryID,
@@ -203,7 +208,7 @@ export class RunQueryResolver {
     let queryName = result.QueryName;
     if (!queryName) {
       try {
-        const queryInfo = await this.findQuery(QueryID, undefined, CategoryID, CategoryPath, true);
+        const queryInfo = await this.findQuery(md, QueryID, undefined, CategoryID, CategoryPath, true);
         if (queryInfo) {
           queryName = queryInfo.Name;
         }
@@ -238,8 +243,10 @@ export class RunQueryResolver {
                                      @Arg('StartRow', () => Int, {nullable: true}) StartRow?: number,
                                      @Arg('ForceAuditLog', () => Boolean, {nullable: true}) ForceAuditLog?: boolean,
                                      @Arg('AuditLogDescription', () => String, {nullable: true}) AuditLogDescription?: string): Promise<RunQueryResultType> {
-    const runQuery = new RunQuery();
-    const result = await runQuery.RunQuery(
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true});
+    const rq = new RunQuery(provider as unknown as IRunQueryProvider);
+
+    const result = await rq.RunQuery(
       { 
         QueryName: QueryName,
         CategoryID: CategoryID,

package/src/resolvers/ReportResolver.ts

@@ -1,4 +1,4 @@
-import { EntitySaveOptions, Metadata, RunReport } from '@memberjunction/core';
+import { EntitySaveOptions, IRunReportProvider, Metadata, RunReport } from '@memberjunction/core';
 import { Arg, Ctx, Field, Int, Mutation, ObjectType, Query, Resolver } from 'type-graphql';
 import { AppContext } from '../types.js';
 import { ConversationDetailEntity, ReportEntity } from '@memberjunction/core-entities';
@@ -7,6 +7,7 @@ import { DataContext } from '@memberjunction/data-context';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { z } from 'zod';
 import mssql from 'mssql';
+import { GetReadOnlyProvider, GetReadWriteProvider } from '../util.js';
 
 @ObjectType()
 export class RunReportResultType {
@@ -47,9 +48,11 @@ export class CreateReportResultType {
 @Resolver(RunReportResultType)
 export class ReportResolverExtended {
   @Query(() => RunReportResultType)
-  async GetReportData(@Arg('ReportID', () => String) ReportID: string, @Ctx() {}: AppContext): Promise<RunReportResultType> {
-    const runReport = new RunReport();
-    const result = await runReport.RunReport({ ReportID: ReportID });
+  async GetReportData(@Arg('ReportID', () => String) ReportID: string, @Ctx() context: AppContext): Promise<RunReportResultType> {
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true});
+    const rp = new RunReport(provider as unknown as IRunReportProvider);
+
+    const result = await rp.RunReport({ ReportID: ReportID });
     return {
       ReportID: ReportID,
       Success: result.Success,
@@ -66,10 +69,10 @@ export class ReportResolverExtended {
   @Mutation(() => CreateReportResultType)
   async CreateReportFromConversationDetailID(
     @Arg('ConversationDetailID', () => String) ConversationDetailID: string,
-    @Ctx() { dataSource, userPayload }: AppContext
+    @Ctx() { dataSource, userPayload, providers }: AppContext
   ): Promise<CreateReportResultType> {
     try {
-      const md = new Metadata();
+      const md = GetReadWriteProvider(providers);
 
       const u = UserCache.Users.find((u) => u.Email?.trim().toLowerCase() === userPayload?.email?.trim().toLowerCase());
       if (!u) throw new Error('Unable to find user');

package/src/resolvers/RunAIAgentResolver.ts

@@ -1,6 +1,6 @@
 import { Resolver, Mutation, Query, Arg, Ctx, ObjectType, Field, PubSub, PubSubEngine, Subscription, Root, ResolverFilterData, ID } from 'type-graphql';
-import { UserPayload } from '../types.js';
-import { LogError, LogStatus } from '@memberjunction/core';
+import { AppContext, UserPayload } from '../types.js';
+import { DatabaseProviderBase, LogError, LogStatus } from '@memberjunction/core';
 import { AIAgentEntityExtended } from '@memberjunction/core-entities';
 import { AgentRunner } from '@memberjunction/ai-agents';
 import { ExecuteAgentResult } from '@memberjunction/ai-core-plus';
@@ -8,6 +8,7 @@ import { AIEngine } from '@memberjunction/aiengine';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver.js';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
+import { GetReadWriteProvider } from '../util.js';
 
 @ObjectType()
 export class AIAgentRunResult {
@@ -304,6 +305,7 @@ export class RunAIAgentResolver extends ResolverBase {
      * @private
      */
     private async executeAIAgent(
+        p: DatabaseProviderBase,
         agentId: string,
         userPayload: UserPayload,
         messagesJson: string,
@@ -339,6 +341,8 @@ export class RunAIAgentResolver extends ResolverBase {
             // Validate agent
             const agentEntity = await this.validateAgent(agentId, currentUser);
 
+            // @jordanfanapour IMPORTANT TO-DO for various engine classes (via base engine class) and here for AI Agent Runner and for AI Prompt Runner, need to be able to pass in a IMetadataProvider for it to use
+            // for multi-user server environments like this one
             // Create AI agent runner
             const agentRunner = new AgentRunner();
             
@@ -453,7 +457,7 @@ export class RunAIAgentResolver extends ResolverBase {
     @Mutation(() => AIAgentRunResult)
     async RunAIAgent(
         @Arg('agentId') agentId: string,
-        @Ctx() { userPayload }: { userPayload: UserPayload },
+        @Ctx() { userPayload, providers }: AppContext,
         @Arg('messages') messagesJson: string,
         @Arg('sessionId') sessionId: string,
         @PubSub() pubSub: PubSubEngine,
@@ -463,7 +467,9 @@ export class RunAIAgentResolver extends ResolverBase {
         @Arg('autoPopulateLastRunPayload', { nullable: true }) autoPopulateLastRunPayload?: boolean,
         @Arg('configurationId', { nullable: true }) configurationId?: string
     ): Promise<AIAgentRunResult> {
+        const p = GetReadWriteProvider(providers);
         return this.executeAIAgent(
+            p,
             agentId,
             userPayload,
             messagesJson,
@@ -485,7 +491,7 @@ export class RunAIAgentResolver extends ResolverBase {
     @Query(() => AIAgentRunResult)
     async RunAIAgentSystemUser(
         @Arg('agentId') agentId: string,
-        @Ctx() { userPayload }: { userPayload: UserPayload },
+        @Ctx() { userPayload, providers }: AppContext,
         @Arg('messages') messagesJson: string,
         @Arg('sessionId') sessionId: string,
         @PubSub() pubSub: PubSubEngine,
@@ -495,7 +501,9 @@ export class RunAIAgentResolver extends ResolverBase {
         @Arg('autoPopulateLastRunPayload', { nullable: true }) autoPopulateLastRunPayload?: boolean,
         @Arg('configurationId', { nullable: true }) configurationId?: string
     ): Promise<AIAgentRunResult> {
+        const p = GetReadWriteProvider(providers);
         return this.executeAIAgent(
+            p,
             agentId,
             userPayload,
             messagesJson,

package/src/resolvers/RunAIPromptResolver.ts

@@ -1,6 +1,6 @@
 import { Resolver, Mutation, Query, Arg, Ctx, ObjectType, Field, Int } from 'type-graphql';
-import { UserPayload } from '../types.js';
-import { LogError, LogStatus, Metadata } from '@memberjunction/core';
+import { AppContext, UserPayload } from '../types.js';
+import { DatabaseProviderBase, LogError, LogStatus, Metadata } from '@memberjunction/core';
 import { AIPromptEntityExtended, AIModelEntityExtended } from '@memberjunction/core-entities';
 import { AIPromptRunner } from '@memberjunction/ai-prompts';
 import { AIPromptParams } from '@memberjunction/ai-core-plus';
@@ -9,6 +9,7 @@ import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { AIEngine } from '@memberjunction/aiengine';
 import { ChatParams, ChatMessage, ChatMessageRole, GetAIAPIKey, BaseLLM } from '@memberjunction/ai';
 import { MJGlobal } from '@memberjunction/global';
+import { GetReadWriteProvider } from '../util.js';
 
 @ObjectType()
 export class AIPromptRunResult {
@@ -87,6 +88,7 @@ export class RunAIPromptResolver extends ResolverBase {
      * @private
      */
     private async executeAIPrompt(
+        p: DatabaseProviderBase,
         promptId: string,
         userPayload: UserPayload,
         data?: string,
@@ -152,11 +154,9 @@ export class RunAIPromptResolver extends ResolverBase {
                     executionTimeMs: Date.now() - startTime
                 };
             }
-            
-            const md = new Metadata();
-            
+
             // Load the AI prompt entity
-            const promptEntity = await md.GetEntityObject<AIPromptEntityExtended>('AI Prompts', currentUser);
+            const promptEntity = await p.GetEntityObject<AIPromptEntityExtended>('AI Prompts', currentUser);
             await promptEntity.Load(promptId);
             
             if (!promptEntity.IsSaved) {
@@ -283,7 +283,7 @@ export class RunAIPromptResolver extends ResolverBase {
     @Mutation(() => AIPromptRunResult)
     async RunAIPrompt(
         @Arg('promptId') promptId: string,
-        @Ctx() { userPayload }: { userPayload: UserPayload },
+        @Ctx() { userPayload, providers }: AppContext,
         @Arg('data', { nullable: true }) data?: string,
         @Arg('overrideModelId', { nullable: true }) overrideModelId?: string,
         @Arg('overrideVendorId', { nullable: true }) overrideVendorId?: string,
@@ -305,7 +305,9 @@ export class RunAIPromptResolver extends ResolverBase {
         @Arg('rerunFromPromptRunID', { nullable: true }) rerunFromPromptRunID?: string,
         @Arg('systemPromptOverride', { nullable: true }) systemPromptOverride?: string
     ): Promise<AIPromptRunResult> {
+        const p = GetReadWriteProvider(providers);
         return this.executeAIPrompt(
+            p,
             promptId,
             userPayload,
             data,
@@ -339,7 +341,7 @@ export class RunAIPromptResolver extends ResolverBase {
     @Query(() => AIPromptRunResult)
     async RunAIPromptSystemUser(
         @Arg('promptId') promptId: string,
-        @Ctx() { userPayload }: { userPayload: UserPayload },
+        @Ctx() { userPayload, providers }: AppContext,
         @Arg('data', { nullable: true }) data?: string,
         @Arg('overrideModelId', { nullable: true }) overrideModelId?: string,
         @Arg('overrideVendorId', { nullable: true }) overrideVendorId?: string,
@@ -361,7 +363,9 @@ export class RunAIPromptResolver extends ResolverBase {
         @Arg('rerunFromPromptRunID', { nullable: true }) rerunFromPromptRunID?: string,
         @Arg('systemPromptOverride', { nullable: true }) systemPromptOverride?: string
     ): Promise<AIPromptRunResult> {
+        const p = GetReadWriteProvider(providers);
         return this.executeAIPrompt(
+            p,
             promptId,
             userPayload,
             data,

package/src/resolvers/RunTemplateResolver.ts

@@ -1,10 +1,11 @@
 import { Resolver, Mutation, Arg, Ctx, ObjectType, Field } from 'type-graphql';
-import { UserPayload } from '../types.js';
+import { AppContext, UserPayload } from '../types.js';
 import { LogError, LogStatus, Metadata, RunView } from '@memberjunction/core';
 import { TemplateContentEntity } from '@memberjunction/core-entities';
 import { TemplateEngineServer } from '@memberjunction/templates';
 import { TemplateEntityExtended } from '@memberjunction/templates-base-types';
 import { ResolverBase } from '../generic/ResolverBase.js';
+import { GetReadWriteProvider } from '../util.js';
 
 @ObjectType()
 export class TemplateRunResult {
@@ -26,7 +27,7 @@ export class RunTemplateResolver extends ResolverBase {
     @Mutation(() => TemplateRunResult)
     async RunTemplate(
         @Arg('templateId') templateId: string,
-        @Ctx() { userPayload }: { userPayload: UserPayload },
+        @Ctx() { userPayload, providers }: AppContext,
         @Arg('contextData', { nullable: true }) contextData?: string
     ): Promise<TemplateRunResult> {
         const startTime = Date.now();
@@ -58,10 +59,9 @@ export class RunTemplateResolver extends ResolverBase {
                 };
             }
             
-            const md = new Metadata();
-            
+            const p = GetReadWriteProvider(providers);
             // Load the template entity
-            const templateEntity = await md.GetEntityObject<TemplateEntityExtended>('Templates', currentUser);
+            const templateEntity = await p.GetEntityObject<TemplateEntityExtended>('Templates', currentUser);
             await templateEntity.Load(templateId);
             
             if (!templateEntity.IsSaved) {

package/src/resolvers/SqlLoggingConfigResolver.ts

@@ -8,6 +8,7 @@ import * as path from 'path';
 import * as fs from 'fs/promises';
 import { loadConfig } from '../config.js';
 import { ResolverBase } from '../generic/ResolverBase.js';
+import { GetReadOnlyProvider } from '../util.js';
 
 /**
  * Configuration options for SQL logging sessions.
@@ -279,7 +280,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
   async sqlLoggingConfig(@Ctx() context: AppContext): Promise<SqlLoggingConfig> {
     await this.checkOwnerAccess(context);
     const config = await loadConfig();
-    const provider = Metadata.Provider as SQLServerDataProvider;
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as SQLServerDataProvider;
     const activeSessions = provider.GetActiveSqlLoggingSessions();
 
     return {
@@ -334,7 +335,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
   @Query(() => [SqlLoggingSession])
   async activeSqlLoggingSessions(@Ctx() context: AppContext): Promise<SqlLoggingSession[]> {
     await this.checkOwnerAccess(context);
-    const provider = Metadata.Provider as SQLServerDataProvider;
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as SQLServerDataProvider;
     const sessions = provider.GetActiveSqlLoggingSessions();
 
     return sessions.map(session => ({
@@ -399,7 +400,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
     }
 
     // Check max active sessions
-    const provider = Metadata.Provider as SQLServerDataProvider;
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as SQLServerDataProvider;
     const activeSessions = provider.GetActiveSqlLoggingSessions();
     if (activeSessions.length >= (config.sqlLogging.maxActiveSessions ?? 5)) {
       throw new Error(`Maximum number of active SQL logging sessions (${config.sqlLogging.maxActiveSessions}) reached`);
@@ -480,7 +481,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
     @Ctx() context: AppContext
   ): Promise<boolean> {
     await this.checkOwnerAccess(context);
-    const provider = Metadata.Provider as SQLServerDataProvider;
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as SQLServerDataProvider;
     
     // Get the actual session from the private map to call dispose
     const sessionMap = (provider as any)._sqlLoggingSessions as Map<string, any>;
@@ -517,7 +518,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
   @Mutation(() => Boolean)
   async stopAllSqlLogging(@Ctx() context: AppContext): Promise<boolean> {
     await this.checkOwnerAccess(context);
-    const provider = Metadata.Provider as SQLServerDataProvider;
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as SQLServerDataProvider;
     await provider.DisposeAllSqlLoggingSessions();
     return true;
   }
@@ -607,7 +608,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
     }
 
     // Find the session
-    const provider = Metadata.Provider as SQLServerDataProvider;
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as SQLServerDataProvider;
     const sessions = provider.GetActiveSqlLoggingSessions();
     const session = sessions.find(s => s.id === sessionId);
     

package/src/resolvers/UserFavoriteResolver.ts

@@ -81,30 +81,30 @@ export class UserFavoriteResolver extends UserFavoriteResolverBase {
   }
 
   @Query(() => UserFavoriteResult)
-  async GetRecordFavoriteStatus(@Arg('params', () => UserFavoriteSearchParams) params: UserFavoriteSearchParams, @Ctx() {userPayload}: AppContext) {
-    const md = new Metadata();
+  async GetRecordFavoriteStatus(@Arg('params', () => UserFavoriteSearchParams) params: UserFavoriteSearchParams, @Ctx() {providers, userPayload}: AppContext) {
+    const p = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
     const pk = new CompositeKey(params.CompositeKey.KeyValuePairs);
 
-    const e = md.Entities.find((e) => e.ID === params.EntityID);
+    const e = p.Entities.find((e) => e.ID === params.EntityID);
     if (e)
       return {
         EntityID: params.EntityID,
         UserID: params.UserID,
         CompositeKey: pk,
-        IsFavorite: await md.GetRecordFavoriteStatus(params.UserID, e.Name, pk, userPayload.userRecord),
+        IsFavorite: await p.GetRecordFavoriteStatus(params.UserID, e.Name, pk, userPayload.userRecord),
         Success: true,
       };
     else throw new Error(`Entity ID:${params.EntityID} not found`);
   }
 
   @Mutation(() => UserFavoriteResult)
-  SetRecordFavoriteStatus(@Arg('params', () => UserFavoriteSetParams) params: UserFavoriteSetParams, @Ctx() { userPayload }: AppContext) {
-    const md = new Metadata();
+  async SetRecordFavoriteStatus(@Arg('params', () => UserFavoriteSetParams) params: UserFavoriteSetParams, @Ctx() { userPayload, providers }: AppContext) {
+    const p = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
     const pk = new CompositeKey(params.CompositeKey.KeyValuePairs);
-    const e = md.Entities.find((e) => e.ID === params.EntityID);
+    const e = p.Entities.find((e) => e.ID === params.EntityID);
     const u = UserCache.Users.find((u) => u.ID === userPayload.userRecord.ID);
     if (e) {
-      md.SetRecordFavoriteStatus(params.UserID, e.Name, pk, params.IsFavorite, u);
+      await p.SetRecordFavoriteStatus(params.UserID, e.Name, pk, params.IsFavorite, u);
       return {
         Success: true,
         EntityID: params.EntityID,
@@ -114,65 +114,6 @@ export class UserFavoriteResolver extends UserFavoriteResolverBase {
       };
     } else throw new Error(`Entity ID:${params.EntityID} not found`);
   }
-
-  private GetTestData() {
-    return [
-      {
-        firstName: 'John',
-        lastName: 'Doe',
-        title: 'Software Engineer II',
-        email: 'amith+john.doe@nagarajan.org',
-        age: 25,
-        address: {
-          street: '123 Main St',
-          city: 'Springfield',
-          state: 'IL',
-          zip: '62701',
-        },
-        recommendedArticles: [
-          {
-            title: 'How to Write Better Code',
-            url: 'https://example.com/article1',
-          },
-          {
-            title: 'The Art of Debugging',
-            url: 'https://example.com/article2',
-          },
-          {
-            title: 'Using Templates Effectively',
-            url: 'https://example.com/article3',
-          },
-        ],
-      },
-      {
-        firstName: 'Jane',
-        lastName: 'Smith',
-        title: 'Executive Vice President of Software Development',
-        email: 'amith+jane.smith@nagarajan.org',
-        age: 30,
-        address: {
-          street: '456 Elm St',
-          city: 'Chicago',
-          state: 'IL',
-          zip: '62702',
-        },
-        recommendedArticles: [
-          {
-            title: 'Exemplifying the Importance of Code Reviews',
-            url: 'https://example.com/article1',
-          },
-          {
-            title: 'AI and Software Development: A New Frontier',
-            url: 'https://example.com/article2',
-          },
-          {
-            title: 'Gardening Tips for Fun Loving Software Developers',
-            url: 'https://example.com/article3',
-          },
-        ],
-      },
-    ];
-  }
 }
 
 export default UserFavoriteResolver;

package/src/resolvers/UserViewResolver.ts

@@ -47,14 +47,14 @@ export class UserViewResolver extends UserViewResolverBase {
   }
 
   @Query(() => [UserView_])
-  async UpdateWhereClause(@Arg('ID', () => String) ID: string, @Ctx() { userPayload }: AppContext) {
+  async UpdateWhereClause(@Arg('ID', () => String) ID: string, @Ctx() { userPayload, providers }: AppContext) {
     // in this query we want to update the uesrView record in the DB with a new where clause
     // this should normally not be a factor but we have this exposed in the GraphQL API so that
     // a dev can force the update if desired from the client. The normal path is just to update
     // filter state which in turn will be used to update the where clause in the entity sub-class.
-    const md = new Metadata();
+    const p = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
     const u = this.GetUserFromPayload(userPayload);
-    const viewEntity = <UserViewEntityExtended>await md.GetEntityObject('User Views', u);
+    const viewEntity = <UserViewEntityExtended>await p.GetEntityObject('User Views', u);
     await viewEntity.Load(ID);
     viewEntity.UpdateWhereClause();