@memberjunction/server 3.1.0 → 3.2.0

package/src/resolvers/RunAIAgentResolver.ts

@@ -1,7 +1,7 @@
 import { Resolver, Mutation, Query, Arg, Ctx, ObjectType, Field, PubSub, PubSubEngine, Subscription, Root, ResolverFilterData, ID, Int } from 'type-graphql';
 import { AppContext, UserPayload } from '../types.js';
 import { DatabaseProviderBase, LogError, LogStatus, Metadata, RunView, UserInfo } from '@memberjunction/core';
-import { ConversationDetailEntity, ConversationDetailAttachmentEntity, UserNotificationEntity } from '@memberjunction/core-entities';
+import { ConversationDetailEntity, ConversationDetailAttachmentEntity } from '@memberjunction/core-entities';
 import { AgentRunner } from '@memberjunction/ai-agents';
 import { AIAgentEntityExtended, AIAgentRunEntityExtended, ExecuteAgentResult, ConversationUtility, AttachmentData } from '@memberjunction/ai-core-plus';
 import { AIEngine } from '@memberjunction/aiengine';
@@ -12,6 +12,7 @@ import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { GetReadWriteProvider } from '../util.js';
 import { SafeJSONParse } from '@memberjunction/global';
 import { getAttachmentService } from '@memberjunction/aiengine';
+import { NotificationEngine } from '@memberjunction/notifications';
 
 @ObjectType()
 export class AIAgentRunResult {
@@ -650,55 +651,64 @@ export class RunAIAgentResolver extends ResolverBase {
                 throw new Error(`Failed to load conversation detail ${conversationDetailId}`);
             }
 
-            // Create notification entity
-            const notification = await md.GetEntityObject<UserNotificationEntity>(
-                'User Notifications',
-                contextUser
-            );
-
-            notification.UserID = contextUser.ID;
-            notification.Title = `${agentName} completed your request`;
+            // Build conversation URL for email/SMS templates
+            const baseUrl = process.env.APP_BASE_URL || 'http://localhost:4201';
+            const conversationUrl = `${baseUrl}/conversations/${detail.ConversationID}?artifact=${artifactInfo.artifactId}`;
 
             // Craft message based on versioning
-            if (artifactInfo.versionNumber > 1) {
-                notification.Message = `${agentName} has finished processing and created version ${artifactInfo.versionNumber}`;
-            } else {
-                notification.Message = `${agentName} has finished processing and created a new artifact`;
-            }
-
-            // Store navigation configuration as JSON
-            // Client will parse this to navigate to the conversation with artifact visible
-            notification.ResourceConfiguration = JSON.stringify({
-                type: 'conversation',
-                conversationId: detail.ConversationID,
-                messageId: conversationDetailId,
-                artifactId: artifactInfo.artifactId,
-                versionNumber: artifactInfo.versionNumber
-            });
-
-            notification.Unread = true;  // Default unread
-            // ResourceTypeID and ResourceRecordID left null - using custom navigation
-
-            if (!(await notification.Save())) {
-                throw new Error('Failed to save notification');
+            const message = artifactInfo.versionNumber > 1
+                ? `${agentName} has finished processing and created version ${artifactInfo.versionNumber}`
+                : `${agentName} has finished processing and created a new artifact`;
+
+            // Use unified notification engine (Config called to ensure loaded)
+            const notificationEngine = NotificationEngine.Instance;
+            await notificationEngine.Config(false, contextUser);
+            const result = await notificationEngine.SendNotification({
+                userId: contextUser.ID,
+                typeNameOrId: 'Agent Completion',
+                title: `${agentName} completed your request`,
+                message: message,
+                resourceConfiguration: {
+                    type: 'conversation',
+                    conversationId: detail.ConversationID,
+                    messageId: conversationDetailId,
+                    artifactId: artifactInfo.artifactId,
+                    versionId: artifactInfo.versionId,
+                    versionNumber: artifactInfo.versionNumber
+                },
+                templateData: {
+                    agentName: agentName,
+                    artifactTitle: artifactInfo.artifactId,
+                    conversationUrl: conversationUrl,
+                    versionNumber: artifactInfo.versionNumber > 1 ? artifactInfo.versionNumber : undefined
+                }
+            }, contextUser);
+
+            if (result.success && result.inAppNotificationId) {
+                const channels = [];
+                if (result.deliveryChannels.inApp) channels.push('InApp');
+                if (result.deliveryChannels.email) channels.push('Email');
+                if (result.deliveryChannels.sms) channels.push('SMS');
+                const channelList = channels.length > 0 ? channels.join(', ') : 'None';
+                LogStatus(`📬 Notification sent via ${channelList} (ID: ${result.inAppNotificationId})`);
+
+                // Publish real-time notification event so client updates immediately
+                pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+                    userPayload: JSON.stringify(userPayload),
+                    message: JSON.stringify({
+                        type: 'notification',
+                        notificationId: result.inAppNotificationId,
+                        action: 'create',
+                        title: `${agentName} completed your request`,
+                        message: message
+                    })
+                });
+
+                LogStatus(`📡 Published notification event to client`);
+            } else if (!result.success) {
+                LogError(`Notification failed: ${result.errors?.join(', ')}`);
             }
 
-            LogStatus(`📬 Created notification ${notification.ID} for user ${contextUser.ID}`);
-
-            // Publish real-time notification event so client updates immediately
-            pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
-                userPayload: JSON.stringify(userPayload),
-                message: JSON.stringify({
-                    type: 'notification',
-                    notificationId: notification.ID,
-                    action: 'create',
-                    title: notification.Title,
-                    message: notification.Message
-                })
-            });
-
-            LogStatus(`📡 Published notification event to client`);
-
         } catch (error) {
             LogError(`Failed to create completion notification: ${(error as Error).message}`);
             // Don't throw - notification failure shouldn't fail the agent run

package/src/resolvers/SqlLoggingConfigResolver.ts

@@ -48,6 +48,22 @@ export class SqlLoggingOptions {
   @Field(() => String, { nullable: true })
   filterByUserId?: string;
 
+  /** Array of regex/wildcard patterns to filter SQL statements */
+  @Field(() => [String], { nullable: true })
+  filterPatterns?: string[];
+
+  /** How to apply patterns: 'include' or 'exclude' (default: exclude) */
+  @Field(() => String, { nullable: true })
+  filterType?: 'include' | 'exclude';
+
+  /** Whether to output verbose debug information to console */
+  @Field(() => Boolean, { nullable: true })
+  verboseOutput?: boolean;
+
+  /** Default schema name for Flyway migration placeholder replacement */
+  @Field(() => String, { nullable: true })
+  defaultSchemaName?: string;
+
   /** Human-readable name for the logging session */
   @Field(() => String, { nullable: true })
   sessionName?: string;
@@ -118,6 +134,22 @@ export class SqlLoggingOptionsInput {
   @Field(() => String, { nullable: true })
   filterByUserId?: string;
 
+  /** Array of regex/wildcard patterns to filter SQL statements */
+  @Field(() => [String], { nullable: true })
+  filterPatterns?: string[];
+
+  /** How to apply patterns: 'include' or 'exclude' (default: exclude) */
+  @Field(() => String, { nullable: true })
+  filterType?: 'include' | 'exclude';
+
+  /** Whether to output verbose debug information to console */
+  @Field(() => Boolean, { nullable: true })
+  verboseOutput?: boolean;
+
+  /** Default schema name for Flyway migration placeholder replacement */
+  @Field(() => String, { nullable: true })
+  defaultSchemaName?: string;
+
   /** Human-readable name for the logging session */
   @Field(() => String, { nullable: true })
   sessionName?: string;
@@ -201,6 +233,9 @@ export class SqlLoggingConfig {
 export class SqlLoggingConfigResolver extends ResolverBase {
   /** Default prefix for auto-generated SQL log filenames */
   private static readonly LOG_FILE_PREFIX = 'sql-log-';
+
+  /** Track active session timeouts for proper cleanup when sessions are manually stopped */
+  private static sessionTimeouts = new Map<string, NodeJS.Timeout>();
   
   /**
    * Validates that the current user has Owner-level privileges required for SQL logging operations.
@@ -343,7 +378,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
       filePath: session.filePath,
       startTime: session.startTime,
       statementCount: session.statementCount,
-      options: session.options,
+      options: this.convertOptionsToGraphQL(session.options),
       sessionName: session.options.sessionName,
       filterByUserId: session.options.filterByUserId
     }));
@@ -409,7 +444,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
     // Prepare file path
     const allowedDir = path.resolve(config.sqlLogging.allowedLogDirectory ?? './logs/sql');
     await this.ensureDirectoryExists(allowedDir);
-    
+
     const fileName = input.fileName || `${SqlLoggingConfigResolver.LOG_FILE_PREFIX}${new Date().toISOString().replace(/[:.]/g, '-')}.sql`;
     const filePath = path.join(allowedDir, fileName);
 
@@ -432,15 +467,20 @@ export class SqlLoggingConfigResolver extends ResolverBase {
     // Create the logging session
     const session = await provider.CreateSqlLogger(filePath, sessionOptions);
 
-    // Set up auto-cleanup after timeout
+    // Set up auto-cleanup after timeout with proper tracking
     if (config.sqlLogging.sessionTimeout > 0) {
-      setTimeout(async () => {
+      const timeoutId = setTimeout(async () => {
         try {
           await session.dispose();
+          SqlLoggingConfigResolver.sessionTimeouts.delete(session.id);
         } catch (e) {
-          // Session might already be disposed
+          // Session might already be disposed - log for debugging
+          console.warn(`Auto-cleanup failed for SQL logging session ${session.id}:`, e);
         }
       }, config.sqlLogging.sessionTimeout);
+
+      // Track the timeout so we can cancel it if session is manually stopped
+      SqlLoggingConfigResolver.sessionTimeouts.set(session.id, timeoutId);
     }
 
     return {
@@ -448,9 +488,9 @@ export class SqlLoggingConfigResolver extends ResolverBase {
       filePath: session.filePath,
       startTime: session.startTime,
       statementCount: session.statementCount,
-      options: session.options,
+      options: this.convertOptionsToGraphQL(session.options),
       sessionName: session.options.sessionName,
-      filterByUserId: session.options.filterByUserId
+      filterByUserId: session.options.filterByUserId,
     };
   }
 
@@ -482,15 +522,21 @@ export class SqlLoggingConfigResolver extends ResolverBase {
   ): Promise<boolean> {
     await this.checkOwnerAccess(context);
     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>;
-    const session = sessionMap.get(sessionId);
-    
+
+    // Use the public method to get and dispose the session
+    const session = provider.GetSqlLoggingSessionById(sessionId);
+
     if (!session) {
       throw new Error(`SQL logging session ${sessionId} not found`);
     }
 
+    // Clear any scheduled timeout for this session
+    const timeoutId = SqlLoggingConfigResolver.sessionTimeouts.get(sessionId);
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      SqlLoggingConfigResolver.sessionTimeouts.delete(sessionId);
+    }
+
     await session.dispose();
     return true;
   }
@@ -610,7 +656,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
     // Find the session
     const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as SQLServerDataProvider;
     const sessions = provider.GetActiveSqlLoggingSessions();
-    const session = sessions.find(s => s.id === sessionId);
+    const session = sessions.find((s) => s.id === sessionId);
     
     if (!session) {
       throw new Error(`SQL logging session ${sessionId} not found`);
@@ -689,4 +735,31 @@ export class SqlLoggingConfigResolver extends ResolverBase {
       await fs.mkdir(dir, { recursive: true });
     }
   }
+
+  /**
+   * Converts SqlLoggingOptions from the provider to the GraphQL-compatible type.
+   * The provider's filterPatterns can contain RegExp objects, but GraphQL only supports strings.
+   *
+   * @param options - Options from SQLServerDataProvider
+   * @returns GraphQL-compatible SqlLoggingOptions
+   * @private
+   */
+  private convertOptionsToGraphQL(options: import('@memberjunction/sqlserver-dataprovider').SqlLoggingOptions): SqlLoggingOptions {
+    return {
+      formatAsMigration: options.formatAsMigration,
+      description: options.description,
+      statementTypes: options.statementTypes,
+      batchSeparator: options.batchSeparator,
+      prettyPrint: options.prettyPrint,
+      logRecordChangeMetadata: options.logRecordChangeMetadata,
+      retainEmptyLogFiles: options.retainEmptyLogFiles,
+      filterByUserId: options.filterByUserId,
+      sessionName: options.sessionName,
+      verboseOutput: options.verboseOutput,
+      defaultSchemaName: options.defaultSchemaName,
+      // Convert RegExp objects to their string representation
+      filterPatterns: options.filterPatterns?.map((p) => (p instanceof RegExp ? p.toString() : String(p))),
+      filterType: options.filterType,
+    };
+  }
 }

package/src/util.ts

@@ -60,7 +60,27 @@ export async function sendPostRequest(url: string, payload: any, useCompression:
       const req = request(options, (res) => {
         const gunzip = createGunzip();
         const stream = res.headers['content-encoding'] === 'gzip' ? res.pipe(gunzip) : res;
-  
+        let streamEnded = false;
+
+        const handleStreamEnd = () => {
+          if (streamEnded) return; // Prevent double-resolution
+          streamEnded = true;
+
+          // Attempt to parse any remaining data in buffer in case it's a complete JSON object
+          if (buffer.trim()) {
+            try {
+              const jsonObject = JSON.parse(buffer.trim());
+              jsonObjects.push(jsonObject);
+              streamCallback?.(jsonObject);
+            } catch (e) {
+              const err = z.object({ message: z.string() }).safeParse(e);
+              // Handle JSON parse error for the last chunk
+              console.warn(`Error in postRequest().stream(end) while parsing JSON object: ${err.success ? err.data.message : e}`);
+            }
+          }
+          resolve(jsonObjects);
+        };
+
         stream.on('data', (chunk) => {
           buffer += chunk;
           let boundary;
@@ -78,28 +98,38 @@ export async function sendPostRequest(url: string, payload: any, useCompression:
             }
           }
         });
-  
-        stream.on('end', () => {
-          // Attempt to parse any remaining data in buffer in case it's a complete JSON object
-          if (buffer.trim()) {
-            try {
-              const jsonObject = JSON.parse(buffer.trim());
-              jsonObjects.push(jsonObject);
-              streamCallback?.(jsonObject);
-            } catch (e) {
-              const err = z.object({ message: z.string() }).safeParse(e);
-              // Handle JSON parse error for the last chunk
-              console.warn(`Error in postRequest().stream(end) while parsing JSON object: ${err.success ? err.data.message : e}`);
-            }
+
+        stream.on('end', handleStreamEnd);
+
+        // Handle premature connection close (e.g., server crashes mid-response)
+        stream.on('close', () => {
+          if (!streamEnded) {
+            console.warn(`Stream closed prematurely for ${url}`);
+            handleStreamEnd();
+          }
+        });
+
+        // Handle stream errors (decompression failures, etc.)
+        stream.on('error', (e) => {
+          if (!streamEnded) {
+            console.error(`Stream error for ${url}:`, e);
+            reject(new Error(`Stream error: ${e.message}`));
           }
-          resolve(jsonObjects);
         });
       });
   
       req.on('error', (e) => {
         const err = z.object({ message: z.string() }).safeParse(e);
-        console.error(`Error in sendPostRequest().req.on(error): ${err.success ? err.data.message : e}`);
-        reject(e);
+        const errorMessage = err.success ? err.data.message : String(e);
+        console.error(`Error in sendPostRequest().req.on(error) for ${hostname}:${port}${pathname}: ${errorMessage}`);
+
+        // Create a more informative error for the rejection
+        const contextualError = new Error(`HTTP request failed to ${url}: ${errorMessage}`);
+        // Preserve the original error as the cause
+        if (e instanceof Error) {
+          (contextualError as any).cause = e;
+        }
+        reject(contextualError);
       });
   
       req.write(data);