@memberjunction/server 2.47.0 → 2.49.0

package/src/resolvers/ReportResolver.ts

@@ -6,6 +6,7 @@ import { SkipAPIAnalysisCompleteResponse } from '@memberjunction/skip-types';
 import { DataContext } from '@memberjunction/data-context';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { z } from 'zod';
+import mssql from 'mssql';
 
 @ObjectType()
 export class RunReportResultType {
@@ -90,9 +91,10 @@ export class ReportResolverExtended {
                    WHERE
                       cd.ID='${ConversationDetailID}'`;
 
-      const result = await dataSource.query(sql);
-      if (!result || result.length === 0) throw new Error('Unable to retrieve converation details');
-      const skipData = <SkipAPIAnalysisCompleteResponse>JSON.parse(result[0].Message);
+      const request = new mssql.Request(dataSource);
+      const result = await request.query(sql);
+      if (!result || !result.recordset || result.recordset.length === 0) throw new Error('Unable to retrieve converation details');
+      const skipData = <SkipAPIAnalysisCompleteResponse>JSON.parse(result.recordset[0].Message);
 
       const report = await md.GetEntityObject<ReportEntity>('Reports', u);
       report.NewRecord();

package/src/resolvers/RunAIAgentResolver.ts

@@ -0,0 +1,174 @@
+import { Resolver, Mutation, Arg, Ctx, ObjectType, Field } from 'type-graphql';
+import { UserPayload } from '../types.js';
+import { LogError, LogStatus, Metadata } from '@memberjunction/core';
+import { AIAgentEntity } from '@memberjunction/core-entities';
+import { AgentRunner } from '@memberjunction/ai-agents';
+import { ResolverBase } from '../generic/ResolverBase.js';
+
+@ObjectType()
+export class AIAgentRunResult {
+    @Field()
+    success: boolean;
+
+    @Field({ nullable: true })
+    output?: string;
+
+    @Field({ nullable: true })
+    parsedResult?: string;
+
+    @Field({ nullable: true })
+    error?: string;
+
+    @Field({ nullable: true })
+    executionTimeMs?: number;
+
+    @Field({ nullable: true })
+    tokensUsed?: number;
+
+    @Field({ nullable: true })
+    agentRunId?: string;
+
+    @Field({ nullable: true })
+    rawResult?: string;
+
+    @Field({ nullable: true })
+    nextStep?: string;
+}
+
+@Resolver()
+export class RunAIAgentResolver extends ResolverBase {
+    @Mutation(() => AIAgentRunResult)
+    async RunAIAgent(
+        @Arg('agentId') agentId: string,
+        @Ctx() { userPayload }: { userPayload: UserPayload },
+        @Arg('messages') messagesJson: string,
+        @Arg('data', { nullable: true }) data?: string,
+        @Arg('templateData', { nullable: true }) templateData?: string
+    ): Promise<AIAgentRunResult> {
+        const startTime = Date.now();
+        
+        try {
+            LogStatus(`=== RUNNING AI AGENT FOR ID: ${agentId} ===`);
+
+            // Parse messages (required)
+            let parsedMessages;
+            try {
+                parsedMessages = JSON.parse(messagesJson);
+                if (!Array.isArray(parsedMessages)) {
+                    throw new Error('Messages must be an array');
+                }
+            } catch (parseError) {
+                return {
+                    success: false,
+                    error: `Invalid JSON in messages: ${(parseError as Error).message}`,
+                    executionTimeMs: Date.now() - startTime
+                };
+            }
+
+            // Parse data contexts (JSON strings)
+            let parsedData = {};
+            let parsedTemplateData = {};
+            
+            if (data) {
+                try {
+                    parsedData = JSON.parse(data);
+                } catch (parseError) {
+                    return {
+                        success: false,
+                        error: `Invalid JSON in data: ${(parseError as Error).message}`,
+                        executionTimeMs: Date.now() - startTime
+                    };
+                }
+            }
+
+            if (templateData) {
+                try {
+                    parsedTemplateData = JSON.parse(templateData);
+                } catch (parseError) {
+                    return {
+                        success: false,
+                        error: `Invalid JSON in template data: ${(parseError as Error).message}`,
+                        executionTimeMs: Date.now() - startTime
+                    };
+                }
+            }
+
+            // Get current user from payload
+            const currentUser = this.GetUserFromPayload(userPayload);
+            if (!currentUser) {
+                return {
+                    success: false,
+                    error: 'Unable to determine current user',
+                    executionTimeMs: Date.now() - startTime
+                };
+            }
+            
+            const md = new Metadata();
+            
+            // Load the AI agent entity
+            const agentEntity = await md.GetEntityObject<AIAgentEntity>('AI Agents', currentUser);
+            await agentEntity.Load(agentId);
+            
+            if (!agentEntity.IsSaved) {
+                return {
+                    success: false,
+                    error: `AI Agent with ID ${agentId} not found`,
+                    executionTimeMs: Date.now() - startTime
+                };
+            }
+
+            // Check if agent is active
+            if (agentEntity.Status !== 'Active') {
+                return {
+                    success: false,
+                    error: `AI Agent "${agentEntity.Name}" is not active (Status: ${agentEntity.Status})`,
+                    executionTimeMs: Date.now() - startTime
+                };
+            }
+
+            // Create AI agent runner and execute
+            const agentRunner = new AgentRunner();
+            
+            // Execute the agent with the parsed messages and optional data
+            const result = await agentRunner.RunAgent({
+                agent: agentEntity,
+                conversationMessages: parsedMessages,
+                contextUser: currentUser,
+                ...(Object.keys(parsedData).length > 0 && { data: parsedData }),
+                ...(Object.keys(parsedTemplateData).length > 0 && { templateData: parsedTemplateData })
+            });
+
+            const executionTime = Date.now() - startTime;
+
+            if (result.nextStep !== 'failed') {
+                LogStatus(`=== AI AGENT RUN COMPLETED FOR: ${agentEntity.Name} (${executionTime}ms) ===`);
+                
+                return {
+                    success: true,
+                    output: result.rawResult,
+                    parsedResult: typeof result.returnValue === 'string' ? result.returnValue : JSON.stringify(result.returnValue),
+                    rawResult: result.rawResult,
+                    executionTimeMs: executionTime,
+                    nextStep: result.nextStep
+                };
+            } else {
+                LogError(`AI Agent run failed for ${agentEntity.Name}: ${result.errorMessage}`);
+                return {
+                    success: false,
+                    error: result.errorMessage,
+                    executionTimeMs: executionTime,
+                    nextStep: result.nextStep
+                };
+            }
+
+        } catch (error) {
+            const executionTime = Date.now() - startTime;
+            LogError(`AI Agent run failed:`, undefined, error);
+            return {
+                success: false,
+                error: (error as Error).message || 'Unknown error occurred',
+                executionTimeMs: executionTime
+            };
+        }
+    }
+}

package/src/resolvers/UserViewResolver.ts

@@ -1,7 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Metadata } from '@memberjunction/core';
 import { AppContext, Arg, Ctx, Int, Query, Resolver, UserPayload } from '@memberjunction/server';
-import { DataSource } from 'typeorm';
 import { UserView_, UserViewResolverBase } from '../generated/generated.js';
 import { UserResolver } from './UserResolver.js';
 import { UserViewEntity, UserViewEntityExtended } from '@memberjunction/core-entities';

package/src/types.ts

@@ -2,7 +2,7 @@ import { UserInfo } from '@memberjunction/core';
 import { UserViewEntity } from '@memberjunction/core-entities';
 import { GraphQLSchema } from 'graphql';
 import { PubSubEngine } from 'type-graphql';
-import { DataSource, QueryRunner } from 'typeorm';
+import sql from 'mssql';
 import { getSystemUser } from './auth/index.js';
 import { MJEvent, MJEventType, MJGlobal } from '@memberjunction/global';
 
@@ -19,19 +19,19 @@ export type UserPayload = {
  */
 export type AppContext = {
   /**
-   * The default and backwards compatible data source.
+   * The default and backwards compatible connection pool.
    */
-  dataSource: DataSource;
+  dataSource: sql.ConnectionPool;
   userPayload: UserPayload;
-  queryRunner?: QueryRunner;
+  queryRunner?: sql.Request;
   /**
-   * Array of data sources that have additional information about their intended use e.g. Admin, Read-Write, Read-Only.
+   * Array of connection pools that have additional information about their intended use e.g. Admin, Read-Write, Read-Only.
    */
   dataSources: DataSourceInfo[];
 };
 
 export class DataSourceInfo  {
-  dataSource: DataSource;
+  dataSource: sql.ConnectionPool;
   host: string;
   port: number;
   instance?: string;
@@ -39,7 +39,7 @@ export class DataSourceInfo  {
   userName: string;
   type: "Admin" | "Read-Write" | "Read-Only" | "Other";
 
-  constructor(init: {dataSource: DataSource, type: "Admin" | "Read-Write" | "Read-Only" | "Other", host: string, port: number, database: string, userName: string} ) {
+  constructor(init: {dataSource: sql.ConnectionPool, type: "Admin" | "Read-Write" | "Read-Only" | "Other", host: string, port: number, database: string, userName: string} ) {
     this.dataSource = init.dataSource;
     this.host = init.host;
     this.port = init.port;
@@ -56,7 +56,7 @@ export type DirectiveBuilder = {
 
 export type RunViewGenericParams = {
   viewInfo: UserViewEntity;
-  dataSource: DataSource;
+  dataSource: sql.ConnectionPool;
   extraFilter: string;
   orderBy: string;
   userSearchString: string;

package/src/util.ts

@@ -5,7 +5,7 @@ import { promisify } from 'util';
 import { URL } from 'url';
 import { z } from 'zod';
 import { DataSourceInfo } from './types';
-import { DataSource } from 'typeorm';
+import sql from 'mssql';
 
 const gzip = promisify(gzipCallback);
 
@@ -120,17 +120,17 @@ export async function sendPostRequest(url: string, payload: any, useCompression:
    * @param options 
    * @returns 
    */
-  export function GetReadOnlyDataSource(dataSources: DataSourceInfo[], options?: {allowFallbackToReadWrite: boolean}): DataSource {
+  export function GetReadOnlyDataSource(dataSources: DataSourceInfo[], options?: {allowFallbackToReadWrite: boolean}): sql.ConnectionPool & { query: (sql: string, params?: any) => Promise<any[]> } {
     const readOnlyDataSource = dataSources.find((ds) => ds.type === 'Read-Only');
     if (readOnlyDataSource) {
-      return readOnlyDataSource.dataSource;
+      return extendConnectionPoolWithQuery(readOnlyDataSource.dataSource);
     } 
     else if (!options || options.allowFallbackToReadWrite) {
       // default behavior for backward compatibility prior to MJ 2.22.3 where we introduced this functionality was to have a single
       // connection, so for back-compatability, if we don't have a read-only data source, we'll fall back to the read-write data source
       const readWriteDataSource = dataSources.find((ds) => ds.type === 'Read-Write');
       if (readWriteDataSource) {
-        return readWriteDataSource.dataSource;
+        return extendConnectionPoolWithQuery(readWriteDataSource.dataSource);
       }
     }
     throw new Error('No suitable data source found');
@@ -141,10 +141,35 @@ export async function sendPostRequest(url: string, payload: any, useCompression:
    * @param dataSources 
    * @returns 
    */
-  export function GetReadWriteDataSource(dataSources: DataSourceInfo[]): DataSource {
+  export function GetReadWriteDataSource(dataSources: DataSourceInfo[]): sql.ConnectionPool & { query: (sql: string, params?: any) => Promise<any[]> } {
     const readWriteDataSource = dataSources.find((ds) => ds.type === 'Read-Write');
     if (readWriteDataSource) {
-      return readWriteDataSource.dataSource;
+      return extendConnectionPoolWithQuery(readWriteDataSource.dataSource);
     }
     throw new Error('No suitable read-write data source found');
+  }
+
+  /**
+   * Extends a ConnectionPool with a query method that returns results in the format expected by generated code
+   * This provides backwards compatibility with code that expects TypeORM-style query results
+   */
+  export function extendConnectionPoolWithQuery(pool: sql.ConnectionPool): sql.ConnectionPool & { query: (sql: string, params?: any) => Promise<any[]> } {
+    const extendedPool = pool as any;
+    extendedPool.query = async (sqlQuery: string, parameters?: any): Promise<any[]> => {
+      const request = new sql.Request(pool);
+      // Add parameters if provided
+      if (parameters) {
+        if (Array.isArray(parameters)) {
+          parameters.forEach((value, index) => {
+            request.input(`p${index}`, value);
+          });
+          // Replace ? with @p0, @p1, etc. in the query
+          let paramIndex = 0;
+          sqlQuery = sqlQuery.replace(/\?/g, () => `@p${paramIndex++}`);
+        }
+      }
+      const result = await request.query(sqlQuery);
+      return result.recordset || [];
+    };
+    return extendedPool;
   }