@memberjunction/server 2.94.0 → 2.96.0

package/src/resolvers/AskSkipResolver.ts

@@ -1,5 +1,5 @@
 import { Arg, Ctx, Field, Mutation, ObjectType, PubSub, PubSubEngine, Query, Resolver } from 'type-graphql';
-import { LogError, LogStatus, Metadata, RunView, UserInfo, CompositeKey, EntityFieldInfo, EntityInfo, EntityRelationshipInfo, EntitySaveOptions, EntityDeleteOptions } from '@memberjunction/core';
+import { LogError, LogStatus, Metadata, RunView, UserInfo, CompositeKey, EntityFieldInfo, EntityInfo, EntityRelationshipInfo, EntitySaveOptions, EntityDeleteOptions, IMetadataProvider } from '@memberjunction/core';
 import { AppContext, UserPayload, MJ_SERVER_EVENT_CODE } from '../types.js';
 import { BehaviorSubject } from 'rxjs';
 import { take } from 'rxjs/operators';
@@ -54,18 +54,145 @@ import {
   UserNotificationEntity,
   AIAgentEntityExtended
 } from '@memberjunction/core-entities';
-import { apiKey, baseUrl, configInfo, graphqlPort, mj_core_schema } from '../config.js';
+import { apiKey, baseUrl, publicUrl, configInfo, graphqlPort, graphqlRootPath, mj_core_schema } from '../config.js';
 import mssql from 'mssql';
 
 import { registerEnumType } from 'type-graphql';
 import { MJGlobal, CopyScalarsAndArrays } from '@memberjunction/global';
-import { sendPostRequest } from '../util.js';
+import { GetReadWriteProvider, sendPostRequest } from '../util.js';
 import { GetAIAPIKey } from '@memberjunction/ai';
 import { CompositeKeyInputType } from '../generic/KeyInputOutputTypes.js';
 import { AIEngine } from '@memberjunction/aiengine';
 import { deleteAccessToken, GetDataAccessToken, registerAccessToken, tokenExists } from './GetDataResolver.js';
 import e from 'express';
 
+/**
+ * Store for active conversation streams
+ * Maps conversationID to the last status message received
+ */
+class ActiveConversationStreams {
+  private static instance: ActiveConversationStreams;
+  private streams: Map<string, { 
+    lastStatus: string, 
+    lastUpdate: Date,
+    startTime: Date, // When processing actually started
+    sessionIds: Set<string> // Track which sessions are listening
+  }> = new Map();
+
+  private constructor() {}
+
+  static getInstance(): ActiveConversationStreams {
+    if (!ActiveConversationStreams.instance) {
+      ActiveConversationStreams.instance = new ActiveConversationStreams();
+    }
+    return ActiveConversationStreams.instance;
+  }
+
+  updateStatus(conversationId: string, status: string, sessionId?: string) {
+    const existing = this.streams.get(conversationId);
+    if (existing) {
+      existing.lastStatus = status;
+      existing.lastUpdate = new Date();
+      if (sessionId) {
+        existing.sessionIds.add(sessionId);
+      }
+    } else {
+      const now = new Date();
+      this.streams.set(conversationId, {
+        lastStatus: status,
+        lastUpdate: now,
+        startTime: now, // Track when processing started
+        sessionIds: sessionId ? new Set([sessionId]) : new Set()
+      });
+    }
+  }
+
+  getStatus(conversationId: string): string | null {
+    const stream = this.streams.get(conversationId);
+    return stream ? stream.lastStatus : null;
+  }
+
+  getStartTime(conversationId: string): Date | null {
+    const stream = this.streams.get(conversationId);
+    return stream ? stream.startTime : null;
+  }
+
+  addSession(conversationId: string, sessionId: string) {
+    const stream = this.streams.get(conversationId);
+    if (stream) {
+      stream.sessionIds.add(sessionId);
+    } else {
+      // If no stream exists yet, create one with default status
+      const now = new Date();
+      this.streams.set(conversationId, {
+        lastStatus: 'Processing...',
+        lastUpdate: now,
+        startTime: now, // Track when processing started
+        sessionIds: new Set([sessionId])
+      });
+    }
+  }
+
+  removeConversation(conversationId: string) {
+    this.streams.delete(conversationId);
+  }
+
+  isActive(conversationId: string): boolean {
+    const stream = this.streams.get(conversationId);
+    if (!stream) return false;
+    
+    // Consider a stream inactive if no update in last 5 minutes
+    const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
+    return stream.lastUpdate > fiveMinutesAgo;
+  }
+
+  getSessionIds(conversationId: string): string[] {
+    const stream = this.streams.get(conversationId);
+    return stream ? Array.from(stream.sessionIds) : [];
+  }
+
+  /**
+   * Clean up stale streams that haven't been updated in a while
+   * This prevents memory leaks from abandoned conversations
+   */
+  cleanupStaleStreams() {
+    const now = new Date();
+    const staleThreshold = new Date(now.getTime() - 30 * 60 * 1000); // 30 minutes
+    
+    const staleConversations: string[] = [];
+    this.streams.forEach((stream, conversationId) => {
+      if (stream.lastUpdate < staleThreshold) {
+        staleConversations.push(conversationId);
+      }
+    });
+    
+    staleConversations.forEach(conversationId => {
+      this.streams.delete(conversationId);
+      LogStatus(`Cleaned up stale stream for conversation ${conversationId}`);
+    });
+    
+    if (staleConversations.length > 0) {
+      LogStatus(`Cleaned up ${staleConversations.length} stale conversation streams`);
+    }
+  }
+}
+
+const activeStreams = ActiveConversationStreams.getInstance();
+
+// Set up periodic cleanup of stale streams (every 10 minutes)
+setInterval(() => {
+  activeStreams.cleanupStaleStreams();
+}, 10 * 60 * 1000);
+
+@ObjectType()
+class ReattachConversationResponse {
+  @Field(() => String, { nullable: true })
+  lastStatusMessage?: string;
+
+  @Field(() => Date, { nullable: true })
+  startTime?: Date;
+}
+
 /**
  * Enumeration representing the different phases of a Skip response
  * Corresponds to the lifecycle of a Skip AI interaction
@@ -352,7 +479,7 @@ export class AskSkipResolver {
     @Arg('ConversationId', () => String) ConversationId: string,
     @Arg('EntityName', () => String) EntityName: string,
     @Arg('CompositeKey', () => CompositeKeyInputType) compositeKey: CompositeKeyInputType,
-    @Ctx() { dataSource, userPayload }: AppContext,
+    @Ctx() { dataSource, userPayload, providers }: AppContext,
     @PubSub() pubSub: PubSubEngine
   ) {
     // In this function we're simply going to call the Skip API and pass along the message from the user
@@ -371,14 +498,14 @@ export class AskSkipResolver {
       );  
     }
 
-    const md = new Metadata();
+    const md = GetReadWriteProvider(providers);
     const { convoEntity, dataContextEntity, convoDetailEntity, dataContext } = await this.HandleSkipChatInitialObjectLoading(
       dataSource,
       ConversationId,
       UserQuestion,
       user,
       userPayload,
-      md,
+      md as unknown as Metadata,
       null
     );
 
@@ -431,7 +558,7 @@ export class AskSkipResolver {
    */
   @Mutation(() => AskSkipResultType)
   async ExecuteAskSkipLearningCycle(
-    @Ctx() { dataSource, userPayload }: AppContext,
+    @Ctx() { dataSource, userPayload, providers }: AppContext,
     @Arg('ForceEntityRefresh', () => Boolean, { nullable: true }) ForceEntityRefresh?: boolean
   ) {
       const skipConfigInfo = configInfo.askSkip;
@@ -485,7 +612,7 @@ export class AskSkipResolver {
       }
 
       // Get the Skip agent ID
-      const md = new Metadata();
+      const md = GetReadWriteProvider(providers);
       const skipAgent = AIEngine.Instance.GetAgentByName('Skip');
       if (!skipAgent) {
         throw new Error("Skip agent not found in AIEngine");
@@ -932,7 +1059,9 @@ cycle.`);
       organizationID: skipConfigInfo.orgID,
       organizationInfo: configInfo?.askSkip?.organizationInfo,
       apiKeys: this.buildSkipAPIKeys(),
-      callingServerURL: accessToken ? `${baseUrl}:${graphqlPort}` : undefined,
+      // Favors public URL for conciseness or when behind a proxy for local development
+      // otherwise uses base URL and GraphQL port/path from configuration
+      callingServerURL: accessToken ? (publicUrl || `${baseUrl}:${graphqlPort}${graphqlRootPath}`) : undefined,
       callingServerAPIKey: accessToken ? apiKey : undefined,
       callingServerAccessToken: accessToken ? accessToken.Token : undefined
     };
@@ -1331,6 +1460,110 @@ cycle.`);
     ];
   }
 
+  /**
+   * Re-attaches the current session to receive status updates for a processing conversation
+   * This is needed after page reloads to resume receiving push notifications
+   */
+  @Query(() => ReattachConversationResponse)
+  async ReattachToProcessingConversation(
+    @Arg('ConversationId', () => String) ConversationId: string,
+    @Ctx() { userPayload, providers }: AppContext,
+    @PubSub() pubSub: PubSubEngine
+  ): Promise<ReattachConversationResponse | null> {
+    try {
+      const md = GetReadWriteProvider(providers);
+      const user = UserCache.Instance.Users.find((u) => u.Email.trim().toLowerCase() === userPayload.email.trim().toLowerCase());
+      if (!user) {
+        LogError(`User ${userPayload.email} not found in UserCache`);
+        return null;
+      }
+      
+      // Load the conversation
+      const convoEntity = await md.GetEntityObject<ConversationEntity>('Conversations', user);
+      const loadResult = await convoEntity.Load(ConversationId);
+      
+      if (!loadResult) {
+        LogError(`Could not load conversation ${ConversationId} for re-attachment`);
+        return null;
+      }
+      
+      // Check if the conversation belongs to this user
+      if (convoEntity.UserID !== user.ID) {
+        LogError(`Conversation ${ConversationId} does not belong to user ${user.Email}`);
+        return null;
+      }
+      
+      // If the conversation is processing, reattach the session to receive updates
+      if (convoEntity.Status === 'Processing') {
+        // Add this session to the active streams for this conversation
+        activeStreams.addSession(ConversationId, userPayload.sessionId);
+        
+        // Get the last known status message and start time from our cache
+        const lastStatusMessage = activeStreams.getStatus(ConversationId) || 'Processing...';
+        const startTime = activeStreams.getStartTime(ConversationId);
+        
+        // Check if the stream is still active
+        const isStreamActive = activeStreams.isActive(ConversationId);
+        
+        if (isStreamActive) {
+          // Send the last known status to the frontend
+          const statusMessage = {
+            type: 'AskSkip',
+            status: 'OK',
+            ResponsePhase: 'Processing',
+            conversationID: convoEntity.ID,
+            message: lastStatusMessage,
+          };
+          
+          pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+            pushStatusUpdates: {
+              message: JSON.stringify(statusMessage),
+              sessionId: userPayload.sessionId
+            }
+          });
+          
+          LogStatus(`Re-attached session ${userPayload.sessionId} to active stream for conversation ${ConversationId}, last status: ${lastStatusMessage}`);
+          
+          // Return the status and start time
+          return {
+            lastStatusMessage,
+            startTime: startTime || convoEntity.__mj_UpdatedAt
+          };
+        } else {
+          // Stream is inactive or doesn't exist, just send default status
+          const statusMessage = {
+            type: 'AskSkip',
+            status: 'OK',
+            ResponsePhase: 'Processing',
+            conversationID: convoEntity.ID,
+            message: 'Processing...',
+          };
+          
+          pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+            pushStatusUpdates: {
+              message: JSON.stringify(statusMessage),
+              sessionId: userPayload.sessionId
+            }
+          });
+          
+          LogStatus(`Re-attached session ${userPayload.sessionId} to conversation ${ConversationId}, but stream is inactive`);
+          
+          // Return default start time since stream is inactive
+          return {
+            lastStatusMessage: 'Processing...',
+            startTime: convoEntity.__mj_UpdatedAt
+          };
+        }
+      } else {
+        LogStatus(`Conversation ${ConversationId} is not processing (Status: ${convoEntity.Status})`);
+        return null;
+      }
+    } catch (error) {
+      LogError(`Error re-attaching to conversation: ${error}`);
+      return null;
+    }
+  }
+
   /**
    * Executes an analysis query with Skip
    * This is the primary entry point for general Skip conversations
@@ -1348,13 +1581,13 @@ cycle.`);
   async ExecuteAskSkipAnalysisQuery(
     @Arg('UserQuestion', () => String) UserQuestion: string,
     @Arg('ConversationId', () => String) ConversationId: string,
-    @Ctx() { dataSource, userPayload }: AppContext,
+    @Ctx() { dataSource, userPayload, providers }: AppContext,
     @PubSub() pubSub: PubSubEngine,
     @Arg('DataContextId', () => String, { nullable: true }) DataContextId?: string,
     @Arg('ForceEntityRefresh', () => Boolean, { nullable: true }) ForceEntityRefresh?: boolean,
     @Arg('StartTime', () => Date, { nullable: true }) StartTime?: Date
   ) {
-    const md = new Metadata();
+    const md = GetReadWriteProvider(providers);
     const user = UserCache.Instance.Users.find((u) => u.Email.trim().toLowerCase() === userPayload.email.trim().toLowerCase());
     if (!user) throw new Error(`User ${userPayload.email} not found in UserCache`);
 
@@ -1367,12 +1600,12 @@ cycle.`);
       UserQuestion,
       user,
       userPayload,
-      md,
+      md as unknown as Metadata,
       DataContextId
     );
 
     // Set the conversation status to 'Processing' when a request is initiated
-    await this.setConversationStatus(convoEntity, 'Processing', userPayload);
+    await this.setConversationStatus(convoEntity, 'Processing', userPayload, pubSub);
 
     // now load up the messages. We will load up ALL of the messages for this conversation, and then pass them to the Skip API
     const messages: SkipMessage[] = await this.LoadConversationDetailsIntoSkipMessages(
@@ -1392,7 +1625,7 @@ cycle.`);
       ConversationId,
       userPayload,
       pubSub,
-      md,
+      md as unknown as Metadata,
       convoEntity,
       convoDetailEntity,
       dataContext,
@@ -2196,7 +2429,7 @@ cycle.`);
 
     if (conversationDetailCount > 10) {
       // Set status of conversation to Available since we still want to allow the user to ask questions
-      await this.setConversationStatus(convoEntity, 'Available', userPayload);
+      await this.setConversationStatus(convoEntity, 'Available', userPayload, pubSub);
 
       // At this point it is likely that we are stuck in a loop, so we stop here
       pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
@@ -2241,22 +2474,31 @@ cycle.`);
         }) => {
           LogStatus(JSON.stringify(message, null, 4));
           if (message.type === 'status_update') {
-            pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
-              message: JSON.stringify({
-                type: 'AskSkip',
-                status: 'OK',
-                conversationID: ConversationId,
-                ResponsePhase: message.value.responsePhase,
-                message: message.value.messages[0].content,
-              }),
-              sessionId: userPayload.sessionId,
-            });
+            const statusContent = message.value.messages[0].content;
+            
+            // Store the status in our active streams cache
+            activeStreams.updateStatus(ConversationId, statusContent, userPayload.sessionId);
+            
+            // Publish to all sessions listening to this conversation
+            const sessionIds = activeStreams.getSessionIds(ConversationId);
+            for (const sessionId of sessionIds) {
+              pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+                message: JSON.stringify({
+                  type: 'AskSkip',
+                  status: 'OK',
+                  conversationID: ConversationId,
+                  ResponsePhase: message.value.responsePhase,
+                  message: statusContent,
+                }),
+                sessionId: sessionId,
+              });
+            }
           }
         }
       );
     } catch (error) {
       // Set conversation status to Available on error so user can try again
-      await this.setConversationStatus(convoEntity, 'Available', userPayload);
+      await this.setConversationStatus(convoEntity, 'Available', userPayload, pubSub);
       
       // Log the error for debugging
       LogError(`Error in HandleSkipChatRequest sendPostRequest: ${error}`);
@@ -2339,7 +2581,7 @@ cycle.`);
       }
     } else {
       // Set status of conversation to Available since we still want to allow the user to ask questions
-      await this.setConversationStatus(convoEntity, 'Available', userPayload);
+      await this.setConversationStatus(convoEntity, 'Available', userPayload, pubSub);
 
       pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
         message: JSON.stringify({
@@ -2511,7 +2753,7 @@ cycle.`);
     convoDetailEntityAI.CompletionTime = endTime.getTime() - startTime.getTime();
     
     // Set conversation status back to Available since we need user input for the clarifying question
-    await this.setConversationStatus(convoEntity, 'Available', userPayload);
+    await this.setConversationStatus(convoEntity, 'Available', userPayload, pubSub);
     
     if (await convoDetailEntityAI.Save()) {
       return {
@@ -2908,13 +3150,42 @@ cycle.`);
     };
   }
 
-  private async setConversationStatus(convoEntity: ConversationEntity, status: 'Processing' | 'Available', userPayload: UserPayload): Promise<boolean> {
+  private async setConversationStatus(convoEntity: ConversationEntity, status: 'Processing' | 'Available', userPayload: UserPayload, pubSub?: PubSubEngine): Promise<boolean> {
     if (convoEntity.Status !== status) {
     convoEntity.Status = status;
 
     const convoSaveResult = await convoEntity.Save();
     if (!convoSaveResult) {
       LogError(`Error updating conversation status to '${status}'`, undefined, convoEntity.LatestResult);
+    } else {
+      // If conversation is now Available (completed), remove it from active streams
+      if (status === 'Available') {
+        activeStreams.removeConversation(convoEntity.ID);
+        LogStatus(`Removed conversation ${convoEntity.ID} from active streams (status changed to Available)`);
+      } else if (status === 'Processing') {
+        // If conversation is starting to process, add the session to active streams
+        activeStreams.addSession(convoEntity.ID, userPayload.sessionId);
+        LogStatus(`Added session ${userPayload.sessionId} to active streams for conversation ${convoEntity.ID}`);
+      }
+      
+      if (pubSub) {
+      // Publish status update to notify frontend of conversation status change
+      const statusMessage = {
+        type: 'ConversationStatusUpdate',
+        conversationID: convoEntity.ID,
+        status: status,
+        timestamp: new Date().toISOString()
+      };
+      
+      pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+        pushStatusUpdates: {
+          message: JSON.stringify(statusMessage),
+          sessionId: userPayload.sessionId
+        }
+      });
+      
+      LogStatus(`Published conversation status update for ${convoEntity.ID}: ${status}`);
+      }
     }
     return convoSaveResult;
     }

package/src/resolvers/CreateQueryResolver.ts

@@ -1,10 +1,10 @@
 import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType, Resolver, PubSub, PubSubEngine } from 'type-graphql';
 import { AppContext } from '../types.js';
-import { LogError, Metadata, RunView, UserInfo, CompositeKey } from '@memberjunction/core';
+import { LogError, Metadata, RunView, UserInfo, CompositeKey, DatabaseProviderBase } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { QueryCategoryEntity, QueryPermissionEntity } from '@memberjunction/core-entities';
 import { QueryResolver } from '../generated/generated.js';
-import { GetReadWriteProvider } from '../util.js';
+import { GetReadOnlyProvider, GetReadWriteProvider } from '../util.js';
 import { DeleteOptionsInput } from '../generic/DeleteOptionsInput.js';
 import { QueryEntityExtended } from '@memberjunction/core-entities-server';
 
@@ -312,8 +312,8 @@ export class QueryResolverExtended extends QueryResolver {
             // Handle CategoryPath if provided
             let finalCategoryID = input.CategoryID;
             if (input.CategoryPath) {
-                const md = new Metadata();
-                finalCategoryID = await this.findOrCreateCategoryPath(input.CategoryPath, md, context.userPayload.userRecord);
+                const p = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true});
+                finalCategoryID = await this.findOrCreateCategoryPath(input.CategoryPath, p, context.userPayload.userRecord);
             }
             
             // Use QueryEntityExtended which handles AI processing
@@ -345,7 +345,7 @@ export class QueryResolverExtended extends QueryResolver {
                 const queryID = record.ID;
                 
                 if (input.Permissions && input.Permissions.length > 0) {
-                    await this.createPermissions(input.Permissions, queryID, context.userPayload.userRecord);
+                    await this.createPermissions(provider, input.Permissions, queryID, context.userPayload.userRecord);
                     await record.RefreshRelatedMetadata(true); // force DB update since we just created new permissions
                 }                
 
@@ -374,13 +374,12 @@ export class QueryResolverExtended extends QueryResolver {
         }
     }
 
-    protected async createPermissions(permissions: QueryPermissionInputType[], queryID: string, contextUser: UserInfo): Promise<QueryPermissionType[]> {
+    protected async createPermissions(p: DatabaseProviderBase, permissions: QueryPermissionInputType[], queryID: string, contextUser: UserInfo): Promise<QueryPermissionType[]> {
         // Create permissions if provided
         const createdPermissions: QueryPermissionType[] = [];
         if (permissions && permissions.length > 0) {
-            const md = new Metadata();
             for (const perm of permissions) {
-                const permissionEntity = await md.GetEntityObject<QueryPermissionEntity>('Query Permissions', contextUser);
+                const permissionEntity = await p.GetEntityObject<QueryPermissionEntity>('Query Permissions', contextUser);
                 if (permissionEntity) {
                     permissionEntity.QueryID = queryID;
                     permissionEntity.RoleID = perm.RoleID;
@@ -427,8 +426,20 @@ export class QueryResolverExtended extends QueryResolver {
             // Handle CategoryPath if provided
             let finalCategoryID = input.CategoryID;
             if (input.CategoryPath) {
-                const md = new Metadata();
-                finalCategoryID = await this.findOrCreateCategoryPath(input.CategoryPath, md, context.userPayload.userRecord);
+                finalCategoryID = await this.findOrCreateCategoryPath(input.CategoryPath, provider, context.userPayload.userRecord);
+            }
+
+            // now make sure there is NO existing query by the same name in the specified category
+            const existingQueryResult = await provider.RunView({
+                EntityName: 'Queries',
+                ExtraFilter: `Name='${input.Name}' AND CategoryID='${finalCategoryID}'` 
+            }, context.userPayload.userRecord);
+            if (existingQueryResult.Success && existingQueryResult.Results?.length > 0) {
+                // we have a match! Let's return an error
+                return {
+                    Success: false,
+                    ErrorMessage: `Query with name '${input.Name}' already exists in the specified ${input.CategoryID ? 'category' : 'categoryPath'}`
+                };
             }
 
             // Update fields that were provided
@@ -481,7 +492,7 @@ export class QueryResolverExtended extends QueryResolver {
                 }
 
                 // Create new permissions
-                await this.createPermissions(input.Permissions, queryID, context.userPayload.userRecord);
+                await this.createPermissions(provider, input.Permissions, queryID, context.userPayload.userRecord);
                 
                 // Refresh the metadata to get updated permissions
                 await queryEntity.RefreshRelatedMetadata(true);
@@ -608,7 +619,7 @@ export class QueryResolverExtended extends QueryResolver {
      * @param contextUser - User context for operations
      * @returns The ID of the final category in the path
      */
-    private async findOrCreateCategoryPath(categoryPath: string, md: Metadata, contextUser: UserInfo): Promise<string> {
+    private async findOrCreateCategoryPath(categoryPath: string, p: DatabaseProviderBase, contextUser: UserInfo): Promise<string> {
         if (!categoryPath || categoryPath.trim() === '') {
             throw new Error('CategoryPath cannot be empty');
         }
@@ -625,7 +636,7 @@ export class QueryResolverExtended extends QueryResolver {
             const categoryName = pathParts[i];
             
             // Look for existing category at this level
-            const existingCategory = await this.findCategoryByNameAndParent(categoryName, currentParentID, contextUser);
+            const existingCategory = await this.findCategoryByNameAndParent(p, categoryName, currentParentID, contextUser);
             
             if (existingCategory) {
                 currentCategoryID = existingCategory.ID;
@@ -633,7 +644,7 @@ export class QueryResolverExtended extends QueryResolver {
             } else {
                 try {
                     // Create new category
-                    const newCategory = await md.GetEntityObject<QueryCategoryEntity>("Query Categories", contextUser);
+                    const newCategory = await p.GetEntityObject<QueryCategoryEntity>("Query Categories", contextUser);
                     if (!newCategory) {
                         throw new Error(`Failed to create entity object for Query Categories`);
                     }
@@ -652,7 +663,7 @@ export class QueryResolverExtended extends QueryResolver {
                     currentParentID = newCategory.ID;
 
                     // Refresh metadata after each category creation to ensure it's available for subsequent lookups
-                    await md.Refresh();
+                    await p.Refresh();
                 } catch (error) {
                     throw new Error(`Failed to create category '${categoryName}': ${error instanceof Error ? error.message : String(error)}`);
                 }
@@ -673,9 +684,9 @@ export class QueryResolverExtended extends QueryResolver {
      * @param contextUser - User context for database operations
      * @returns The matching category entity or null if not found
      */
-    private async findCategoryByNameAndParent(categoryName: string, parentID: string | null, contextUser: UserInfo): Promise<QueryCategoryEntity | null> {
+    private async findCategoryByNameAndParent(provider: DatabaseProviderBase, categoryName: string, parentID: string | null, contextUser: UserInfo): Promise<QueryCategoryEntity | null> {
         try {
-            const rv = new RunView();
+            const rv = provider;
             const parentFilter = parentID ? `ParentID='${parentID}'` : 'ParentID IS NULL';
             const nameFilter = `LOWER(Name) = LOWER('${categoryName.replace(/'/g, "''")}')`; // Escape single quotes
             

package/src/resolvers/DatasetResolver.ts

@@ -1,6 +1,7 @@
 import { Arg, Ctx, Field, InputType, Int, ObjectType, Query, Resolver } from 'type-graphql';
 import { AppContext } from '../types.js';
 import { LogError, Metadata } from '@memberjunction/core';
+import { GetReadOnlyProvider } from '../util.js';
 
 @ObjectType()
 export class DatasetResultType {
@@ -38,11 +39,11 @@ export class DatasetResolverExtended {
   @Query(() => DatasetResultType)
   async GetDatasetByName(
     @Arg('DatasetName', () => String) DatasetName: string,
-    @Ctx() {}: AppContext,
+    @Ctx() {providers}: AppContext,
     @Arg('ItemFilters', () => [DatasetItemFilterTypeGQL], { nullable: 'itemsAndList' }) ItemFilters?: DatasetItemFilterTypeGQL[]
   ) {
     try {
-      const md = new Metadata();
+      const md = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
       const result = await md.GetDatasetByName(DatasetName, ItemFilters);
       if (result) {
         return {
@@ -89,11 +90,11 @@ export class DatasetStatusResolver {
   @Query(() => DatasetStatusResultType)
   async GetDatasetStatusByName(
     @Arg('DatasetName', () => String) DatasetName: string,
-    @Ctx() {}: AppContext,
+    @Ctx() {providers}: AppContext,
     @Arg('ItemFilters', () => [DatasetItemFilterTypeGQL], { nullable: 'itemsAndList' }) ItemFilters?: DatasetItemFilterTypeGQL[]
   ) {
     try {
-      const md = new Metadata();
+      const md = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
       const result = await md.GetDatasetStatusByName(DatasetName, ItemFilters);
       if (result) {
         return {

package/src/resolvers/EntityRecordNameResolver.ts

@@ -1,7 +1,8 @@
-import { Metadata, CompositeKey } from '@memberjunction/core';
+import { Metadata, CompositeKey, DatabaseProviderBase } from '@memberjunction/core';
 import { Arg, Ctx, Field, InputType, ObjectType, Query, Resolver } from 'type-graphql';
 import { AppContext } from '../types.js';
 import { CompositeKeyInputType, CompositeKeyOutputType } from '../generic/KeyInputOutputTypes.js';
+import { GetReadOnlyProvider } from '../util.js';
 
 @InputType()
 export class EntityRecordNameInput {
@@ -36,26 +37,27 @@ export class EntityRecordNameResolver {
   async GetEntityRecordName(
     @Arg('EntityName', () => String) EntityName: string,
     @Arg('CompositeKey', () => CompositeKeyInputType) primaryKey: CompositeKey,
-    @Ctx() { userPayload }: AppContext
+    @Ctx() { providers, userPayload }: AppContext
   ): Promise<EntityRecordNameResult> {
-    const md = new Metadata();
+    const md = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
+
     return await this.InnerGetEntityRecordName(md, EntityName, primaryKey);
   }
 
   @Query(() => [EntityRecordNameResult])
   async GetEntityRecordNames(
     @Arg('info', () => [EntityRecordNameInput]) info: EntityRecordNameInput[],
-    @Ctx() {}: AppContext
+    @Ctx() {providers}: AppContext
   ): Promise<EntityRecordNameResult[]> {
     const result: EntityRecordNameResult[] = [];
-    const md = new Metadata();
+    const md = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
     for (const i of info) {
       result.push(await this.InnerGetEntityRecordName(md, i.EntityName, i.CompositeKey));
     }
     return result;
   }
 
-  async InnerGetEntityRecordName(md: Metadata, EntityName: string, primaryKey: CompositeKeyInputType): Promise<EntityRecordNameResult> {
+  async InnerGetEntityRecordName(md: DatabaseProviderBase, EntityName: string, primaryKey: CompositeKeyInputType): Promise<EntityRecordNameResult> {
     const pk = new CompositeKey(primaryKey.KeyValuePairs);
     const e = md.Entities.find((e) => e.Name === EntityName);
     if (e) {