@memberjunction/server 2.40.0 → 2.41.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memberjunction/server",
-  "version": "2.40.0",
+  "version": "2.41.0",
   "description": "MemberJunction: This project provides API access via GraphQL to the common data store.",
   "main": "./dist/index.js",
   "types": "./src/index.ts",
@@ -22,27 +22,27 @@
   "dependencies": {
     "@apollo/server": "^4.9.1",
     "@graphql-tools/utils": "^10.0.1",
-    "@memberjunction/actions": "2.40.0",
-    "@memberjunction/ai": "2.40.0",
-    "@memberjunction/ai-mistral": "2.40.0",
-    "@memberjunction/ai-openai": "2.40.0",
-    "@memberjunction/ai-vectors-pinecone": "2.40.0",
-    "@memberjunction/aiengine": "2.40.0",
-    "@memberjunction/core": "2.40.0",
-    "@memberjunction/core-actions": "2.40.0",
-    "@memberjunction/core-entities": "2.40.0",
-    "@memberjunction/data-context": "2.40.0",
-    "@memberjunction/data-context-server": "2.40.0",
-    "@memberjunction/doc-utils": "2.40.0",
-    "@memberjunction/entity-communications-server": "2.40.0",
-    "@memberjunction/external-change-detection": "2.40.0",
-    "@memberjunction/global": "2.40.0",
-    "@memberjunction/graphql-dataprovider": "2.40.0",
-    "@memberjunction/queue": "2.40.0",
-    "@memberjunction/skip-types": "2.40.0",
-    "@memberjunction/sqlserver-dataprovider": "2.40.0",
-    "@memberjunction/storage": "2.40.0",
-    "@memberjunction/templates": "2.40.0",
+    "@memberjunction/actions": "2.41.0",
+    "@memberjunction/ai": "2.41.0",
+    "@memberjunction/ai-mistral": "2.41.0",
+    "@memberjunction/ai-openai": "2.41.0",
+    "@memberjunction/ai-vectors-pinecone": "2.41.0",
+    "@memberjunction/aiengine": "2.41.0",
+    "@memberjunction/core": "2.41.0",
+    "@memberjunction/core-actions": "2.41.0",
+    "@memberjunction/core-entities": "2.41.0",
+    "@memberjunction/data-context": "2.41.0",
+    "@memberjunction/data-context-server": "2.41.0",
+    "@memberjunction/doc-utils": "2.41.0",
+    "@memberjunction/entity-communications-server": "2.41.0",
+    "@memberjunction/external-change-detection": "2.41.0",
+    "@memberjunction/global": "2.41.0",
+    "@memberjunction/graphql-dataprovider": "2.41.0",
+    "@memberjunction/queue": "2.41.0",
+    "@memberjunction/skip-types": "2.41.0",
+    "@memberjunction/sqlserver-dataprovider": "2.41.0",
+    "@memberjunction/storage": "2.41.0",
+    "@memberjunction/templates": "2.41.0",
     "@types/compression": "^1.7.5",
     "@types/cors": "^2.8.13",
     "@types/jsonwebtoken": "9.0.6",

package/src/generated/generated.ts

@@ -6271,15 +6271,15 @@ export class User_ {
     @Field(() => [UserFavorite_])
     UserFavorites_UserIDArray: UserFavorite_[]; // Link to UserFavorites
     
-    @Field(() => [ResourceLink_])
-    ResourceLinks_UserIDArray: ResourceLink_[]; // Link to ResourceLinks
-    
     @Field(() => [ListCategory_])
     ListCategories_UserIDArray: ListCategory_[]; // Link to ListCategories
     
     @Field(() => [ScheduledAction_])
     ScheduledActions_CreatedByUserIDArray: ScheduledAction_[]; // Link to ScheduledActions
     
+    @Field(() => [ResourceLink_])
+    ResourceLinks_UserIDArray: ResourceLink_[]; // Link to ResourceLinks
+    
     @Field(() => [AIAgentRequest_])
     AIAgentRequests_ResponseByUserIDArray: AIAgentRequest_[]; // Link to AIAgentRequests
     
@@ -6720,15 +6720,6 @@ export class UserResolverBase extends ResolverBase {
         return result;
     }
         
-    @FieldResolver(() => [ResourceLink_])
-    async ResourceLinks_UserIDArray(@Root() user_: User_, @Ctx() { dataSources, userPayload }: AppContext, @PubSub() pubSub: PubSubEngine) {
-        this.CheckUserReadPermissions('Resource Links', userPayload);
-        const dataSource = GetReadOnlyDataSource(dataSources, { allowFallbackToReadWrite: true });
-        const sSQL = `SELECT * FROM [${Metadata.Provider.ConfigData.MJCoreSchemaName}].[vwResourceLinks] WHERE [UserID]='${user_.ID}' ` + this.getRowLevelSecurityWhereClause('Resource Links', userPayload, EntityPermissionType.Read, 'AND');
-        const result = this.ArrayMapFieldNamesToCodeNames('Resource Links', await dataSource.query(sSQL));
-        return result;
-    }
-        
     @FieldResolver(() => [ListCategory_])
     async ListCategories_UserIDArray(@Root() user_: User_, @Ctx() { dataSources, userPayload }: AppContext, @PubSub() pubSub: PubSubEngine) {
         this.CheckUserReadPermissions('List Categories', userPayload);
@@ -6747,6 +6738,15 @@ export class UserResolverBase extends ResolverBase {
         return result;
     }
         
+    @FieldResolver(() => [ResourceLink_])
+    async ResourceLinks_UserIDArray(@Root() user_: User_, @Ctx() { dataSources, userPayload }: AppContext, @PubSub() pubSub: PubSubEngine) {
+        this.CheckUserReadPermissions('Resource Links', userPayload);
+        const dataSource = GetReadOnlyDataSource(dataSources, { allowFallbackToReadWrite: true });
+        const sSQL = `SELECT * FROM [${Metadata.Provider.ConfigData.MJCoreSchemaName}].[vwResourceLinks] WHERE [UserID]='${user_.ID}' ` + this.getRowLevelSecurityWhereClause('Resource Links', userPayload, EntityPermissionType.Read, 'AND');
+        const result = this.ArrayMapFieldNamesToCodeNames('Resource Links', await dataSource.query(sSQL));
+        return result;
+    }
+        
     @FieldResolver(() => [AIAgentRequest_])
     async AIAgentRequests_ResponseByUserIDArray(@Root() user_: User_, @Ctx() { dataSources, userPayload }: AppContext, @PubSub() pubSub: PubSubEngine) {
         this.CheckUserReadPermissions('AI Agent Requests', userPayload);
@@ -15717,6 +15717,9 @@ export class ConversationDetail_ {
     @MaxLength(16)
     ArtifactVersionID?: string;
         
+    @Field(() => Int, {nullable: true, description: `Duration in milliseconds representing how long the AI response processing took to complete for this conversation detail.`}) 
+    CompletionTime?: number;
+        
     @Field({nullable: true}) 
     @MaxLength(510)
     Conversation?: string;
@@ -15777,6 +15780,9 @@ export class CreateConversationDetailInput {
 
     @Field({ nullable: true })
     ArtifactVersionID: string | null;
+
+    @Field(() => Int, { nullable: true })
+    CompletionTime: number | null;
 }
     
 
@@ -15827,6 +15833,9 @@ export class UpdateConversationDetailInput {
     @Field({ nullable: true })
     ArtifactVersionID?: string | null;
 
+    @Field(() => Int, { nullable: true })
+    CompletionTime?: number | null;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 }
@@ -15976,6 +15985,10 @@ export class Conversation_ {
     @MaxLength(10)
     _mj__UpdatedAt: Date;
         
+    @Field({description: `Tracks the processing status of the conversation: Available, Processing`}) 
+    @MaxLength(40)
+    Status: string;
+        
     @Field() 
     @MaxLength(200)
     User: string;
@@ -16030,6 +16043,9 @@ export class CreateConversationInput {
 
     @Field({ nullable: true })
     DataContextID: string | null;
+
+    @Field({ nullable: true })
+    Status?: string;
 }
     
 
@@ -16068,6 +16084,9 @@ export class UpdateConversationInput {
     @Field({ nullable: true })
     DataContextID?: string | null;
 
+    @Field({ nullable: true })
+    Status?: string;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 }

package/src/resolvers/AskSkipResolver.ts

@@ -63,7 +63,6 @@ import { CompositeKeyInputType } from '../generic/KeyInputOutputTypes.js';
 import { AIAgentEntityExtended, AIEngine } from '@memberjunction/aiengine';
 import { deleteAccessToken, GetDataAccessToken, registerAccessToken, tokenExists } from './GetDataResolver.js';
 import e from 'express';
-import { Skip } from '@graphql-tools/utils';
 
 /**
  * Enumeration representing the different phases of a Skip response
@@ -1323,12 +1322,16 @@ cycle.`);
     @Ctx() { dataSource, userPayload }: AppContext,
     @PubSub() pubSub: PubSubEngine,
     @Arg('DataContextId', () => String, { nullable: true }) DataContextId?: string,
-    @Arg('ForceEntityRefresh', () => Boolean, { nullable: true }) ForceEntityRefresh?: boolean
+    @Arg('ForceEntityRefresh', () => Boolean, { nullable: true }) ForceEntityRefresh?: boolean,
+    @Arg('StartTime', () => Date, { nullable: true }) StartTime?: Date
   ) {
     const md = new Metadata();
     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`);
 
+    // Record the start time if not provided
+    const requestStartTime = StartTime || new Date();
+
     const { convoEntity, dataContextEntity, convoDetailEntity, dataContext } = await this.HandleSkipChatInitialObjectLoading(
       dataSource,
       ConversationId,
@@ -1339,6 +1342,9 @@ cycle.`);
       DataContextId
     );
 
+    // Set the conversation status to 'Processing' when a request is initiated
+    this.setConversationStatus(convoEntity, 'Processing');
+
     // 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(
       dataSource,
@@ -1363,6 +1369,7 @@ cycle.`);
       dataContext,
       dataContextEntity,
       conversationDetailCount,
+      requestStartTime
     );
   }
 
@@ -1843,6 +1850,8 @@ cycle.`);
       if (user) {
         convoEntity.UserID = user.ID;
         convoEntity.Name = AskSkipResolver._defaultNewChatName;
+        // Set initial status to Available since no processing has started yet
+        convoEntity.Status = 'Available';
 
         dataContextEntity = await md.GetEntityObject<DataContextEntity>('Data Contexts', user);
         if (!DataContextId || DataContextId.length === 0) {
@@ -1957,7 +1966,8 @@ cycle.`);
   protected async LoadConversationDetailsIntoSkipMessages(
     dataSource: DataSource,
     ConversationId: string,
-    maxHistoricalMessages?: number
+    maxHistoricalMessages?: number,
+    roleFilter?: string
   ): Promise<SkipMessage[]> {
     try {
       if (!ConversationId || ConversationId.length === 0) {
@@ -1967,12 +1977,16 @@ cycle.`);
       // load up all the conversation details from the database server
       const md = new Metadata();
       const e = md.Entities.find((e) => e.Name === 'Conversation Details');
+      
+      // Add role filter if specified
+      const roleFilterClause = roleFilter ? ` AND Role = '${roleFilter}'` : '';
+      
       const sql = `SELECT
                       ${maxHistoricalMessages ? 'TOP ' + maxHistoricalMessages : ''} *
                    FROM
                       ${e.SchemaName}.${e.BaseView}
                    WHERE
-                      ConversationID = '${ConversationId}'
+                      ConversationID = '${ConversationId}'${roleFilterClause}
                    ORDER
                       BY __mj_CreatedAt DESC`;
       const result = await dataSource.query(sql);
@@ -2095,12 +2109,16 @@ cycle.`);
     convoDetailEntity: ConversationDetailEntity,
     dataContext: DataContext,
     dataContextEntity: DataContextEntity, 
-    conversationDetailCount: number
+    conversationDetailCount: number,
+    startTime: Date
   ): Promise<AskSkipResultType> {
     const skipConfigInfo = configInfo.askSkip;
     LogStatus(`   >>> HandleSkipRequest: Sending request to Skip API: ${skipConfigInfo.chatURL}`);
 
     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');
+
       // At this point it is likely that we are stuck in a loop, so we stop here
       pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
         message: JSON.stringify({
@@ -2179,7 +2197,8 @@ cycle.`);
           convoDetailEntity,
           dataContext,
           dataContextEntity, 
-          conversationDetailCount
+          conversationDetailCount,
+          startTime
         );
       } else if (apiResponse.responsePhase === 'clarifying_question') {
         // need to send the request back to the user for a clarifying question
@@ -2193,7 +2212,8 @@ cycle.`);
           userPayload,
           pubSub,
           convoEntity,
-          convoDetailEntity
+          convoDetailEntity,
+          startTime,
         );
       } else if (apiResponse.responsePhase === 'analysis_complete') {
         return await this.HandleAnalysisComplete(
@@ -2208,13 +2228,17 @@ cycle.`);
           convoEntity,
           convoDetailEntity,
           dataContext,
-          dataContextEntity
+          dataContextEntity,
+          startTime
         );
       } else {
         // unknown response phase
         throw new Error(`Unknown Skip API response phase: ${apiResponse.responsePhase}`);
       }
     } else {
+      // Set status of conversation to Available since we still want to allow the user to ask questions
+      await this.setConversationStatus(convoEntity, 'Available');
+
       pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
         message: JSON.stringify({
           type: 'AskSkip',
@@ -2308,7 +2332,8 @@ cycle.`);
     convoEntity: ConversationEntity,
     convoDetailEntity: ConversationDetailEntity,
     dataContext: DataContext,
-    dataContextEntity: DataContextEntity
+    dataContextEntity: DataContextEntity,
+    startTime: Date
   ): Promise<AskSkipResultType> {
     // analysis is complete
     // all done, wrap things up
@@ -2328,7 +2353,8 @@ cycle.`);
       convoEntity,
       pubSub,
       userPayload,
-      dataSource
+      dataSource,
+      startTime
     );
     const response: AskSkipResultType = {
       Success: true,
@@ -2368,9 +2394,11 @@ cycle.`);
     userPayload: UserPayload,
     pubSub: PubSubEngine,
     convoEntity: ConversationEntity,
-    convoDetailEntity: ConversationDetailEntity
+    convoDetailEntity: ConversationDetailEntity,
+    startTime: Date
   ): Promise<AskSkipResultType> {
     // need to create a message here in the COnversation and then pass that id below
+    const endTime = new Date();
     const md = new Metadata();
     const convoDetailEntityAI = <ConversationDetailEntity>await md.GetEntityObject('Conversation Details', user);
     convoDetailEntityAI.NewRecord();
@@ -2378,6 +2406,11 @@ cycle.`);
     convoDetailEntityAI.Message = JSON.stringify(apiResponse); //.clarifyingQuestion;
     convoDetailEntityAI.Role = 'AI';
     convoDetailEntityAI.HiddenToUser = false;
+    convoDetailEntityAI.CompletionTime = endTime.getTime() - startTime.getTime();
+    
+    // Set conversation status back to Available since we need user input for the clarifying question
+    this.setConversationStatus(convoEntity, 'Available');
+    
     if (await convoDetailEntityAI.Save()) {
       return {
         Success: true,
@@ -2438,7 +2471,8 @@ cycle.`);
     convoDetailEntity: ConversationDetailEntity,
     dataContext: DataContext,
     dataContextEntity: DataContextEntity, 
-    conversationDetailCount: number
+    conversationDetailCount: number,
+    startTime: Date
   ): Promise<AskSkipResultType> {
     // our job in this method is to go through each of the data requests from the Skip API, get the data, and then go back to the Skip API again and to the next phase
     try {
@@ -2567,7 +2601,8 @@ cycle.`);
         convoDetailEntity,
         dataContext,
         dataContextEntity, 
-        conversationDetailCount
+        conversationDetailCount,
+        startTime
       );
     } catch (e) {
       LogError(e);
@@ -2599,7 +2634,8 @@ cycle.`);
     convoEntity: ConversationEntity,
     pubSub: PubSubEngine,
     userPayload: UserPayload,
-    dataSource: DataSource
+    dataSource: DataSource,
+    startTime: Date
   ): Promise<{ AIMessageConversationDetailID: string }> {
     const sTitle = apiResponse.reportTitle;
     const sResult = JSON.stringify(apiResponse);
@@ -2670,12 +2706,15 @@ cycle.`);
     }
 
     // Create a conversation detail record for the Skip response
+    const endTime = new Date();
     const convoDetailEntityAI = <ConversationDetailEntity>await md.GetEntityObject('Conversation Details', user);
     convoDetailEntityAI.NewRecord();
     convoDetailEntityAI.ConversationID = convoEntity.ID;
     convoDetailEntityAI.Message = sResult;
     convoDetailEntityAI.Role = 'AI';
     convoDetailEntityAI.HiddenToUser = false;
+    convoDetailEntityAI.CompletionTime = endTime.getTime() - startTime.getTime();
+    
     if (artifactId && artifactId.length > 0) {
       // bind the new convo detail record to the artifact + version for this response
       convoDetailEntityAI.ArtifactID = artifactId;
@@ -2688,9 +2727,23 @@ cycle.`);
       LogError(`Error saving conversation detail entity for AI message: ${sResult}`, undefined, convoDetailEntityAI.LatestResult);
     }
 
-    // finally update the convo name if it is still the default
+    // Update the conversation properties: name if it's the default, and set status back to 'Available'
+    let needToSaveConvo = false;
+    
+    // Update name if still default
     if (convoEntity.Name === AskSkipResolver._defaultNewChatName && sTitle && sTitle !== AskSkipResolver._defaultNewChatName) {
       convoEntity.Name = sTitle; // use the title from the response
+      needToSaveConvo = true;
+    }
+    
+    // Set status back to 'Available' since processing is complete
+    if (convoEntity.Status === 'Processing') {
+      convoEntity.Status = 'Available';
+      needToSaveConvo = true;
+    }
+    
+    // Save if any changes were made
+    if (needToSaveConvo) {
       const convoEntitySaveResult: boolean = await convoEntity.Save();
       if (!convoEntitySaveResult) {
         LogError(`Error saving conversation entity for AI message: ${sResult}`, undefined, convoEntity.LatestResult);
@@ -2749,6 +2802,18 @@ cycle.`);
     };
   }
 
+  private async setConversationStatus(convoEntity: ConversationEntity, status: 'Processing' | 'Available'): 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);
+      }
+      return convoSaveResult;
+    }
+    return true;
+  }
+
   /**
    * Gets the ID of an agent note type by its name
    * Falls back to a default note type if the specified one is not found