@memberjunction/server 2.128.0 → 2.130.0

package/src/resolvers/QueryResolver.ts

@@ -1,10 +1,44 @@
-import { Arg, Ctx, ObjectType, Query, Resolver, Field, Int } from 'type-graphql';
-import { RunQuery, QueryInfo, IRunQueryProvider, IMetadataProvider } from '@memberjunction/core';
+import { Arg, Ctx, ObjectType, Query, Resolver, Field, Int, InputType } from 'type-graphql';
+import { RunQuery, QueryInfo, IRunQueryProvider, IMetadataProvider, RunQueryParams, LogError, RunQueryWithCacheCheckParams, RunQueriesWithCacheCheckResponse, RunQueryWithCacheCheckResult } 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';
+import { SQLServerDataProvider } from '@memberjunction/sqlserver-dataprovider';
+
+/**
+ * Input type for batch query execution - allows running multiple queries in a single network call
+ */
+@InputType()
+export class RunQueryInput {
+  @Field(() => String, { nullable: true, description: 'Query ID to run - either QueryID or QueryName must be provided' })
+  QueryID?: string;
+
+  @Field(() => String, { nullable: true, description: 'Query Name to run - either QueryID or QueryName must be provided' })
+  QueryName?: string;
+
+  @Field(() => String, { nullable: true, description: 'Category ID to help disambiguate queries with the same name' })
+  CategoryID?: string;
+
+  @Field(() => String, { nullable: true, description: 'Category path to help disambiguate queries with the same name' })
+  CategoryPath?: string;
+
+  @Field(() => GraphQLJSONObject, { nullable: true, description: 'Parameters to pass to the query' })
+  Parameters?: Record<string, unknown>;
+
+  @Field(() => Int, { nullable: true, description: 'Maximum number of rows to return' })
+  MaxRows?: number;
+
+  @Field(() => Int, { nullable: true, description: 'Starting row offset for pagination' })
+  StartRow?: number;
+
+  @Field(() => Boolean, { nullable: true, description: 'Force audit logging regardless of query settings' })
+  ForceAuditLog?: boolean;
+
+  @Field(() => String, { nullable: true, description: 'Description to use in audit log' })
+  AuditLogDescription?: string;
+}
 
 @ObjectType()
 export class RunQueryResultType {
@@ -42,6 +76,70 @@ export class RunQueryResultType {
   CacheTTLRemaining?: number;
 }
 
+//****************************************************************************
+// INPUT/OUTPUT TYPES for RunQueriesWithCacheCheck
+//****************************************************************************
+
+@InputType()
+export class RunQueryCacheStatusInput {
+  @Field(() => String, { description: 'The maximum __mj_UpdatedAt value from cached results' })
+  maxUpdatedAt: string;
+
+  @Field(() => Int, { description: 'The number of rows in cached results' })
+  rowCount: number;
+}
+
+@InputType()
+export class RunQueryWithCacheCheckInput {
+  @Field(() => RunQueryInput, { description: 'The RunQuery parameters' })
+  params: RunQueryInput;
+
+  @Field(() => RunQueryCacheStatusInput, {
+    nullable: true,
+    description: 'Optional cache status - if provided, server will check if cache is current'
+  })
+  cacheStatus?: RunQueryCacheStatusInput;
+}
+
+@ObjectType()
+export class RunQueryWithCacheCheckResultOutput {
+  @Field(() => Int, { description: 'The index of this query in the batch request' })
+  queryIndex: number;
+
+  @Field(() => String, { description: 'The query ID' })
+  queryId: string;
+
+  @Field(() => String, { description: "'current', 'stale', 'no_validation', or 'error'" })
+  status: string;
+
+  @Field(() => String, {
+    nullable: true,
+    description: 'JSON-stringified results - only populated when status is stale or no_validation'
+  })
+  Results?: string;
+
+  @Field(() => String, { nullable: true, description: 'Max __mj_UpdatedAt from results when stale' })
+  maxUpdatedAt?: string;
+
+  @Field(() => Int, { nullable: true, description: 'Row count of results when stale' })
+  rowCount?: number;
+
+  @Field(() => String, { nullable: true, description: 'Error message if status is error' })
+  errorMessage?: string;
+}
+
+@ObjectType()
+export class RunQueriesWithCacheCheckOutput {
+  @Field(() => Boolean, { description: 'Whether the overall operation succeeded' })
+  success: boolean;
+
+  @Field(() => [RunQueryWithCacheCheckResultOutput], { description: 'Results for each query in the batch' })
+  results: RunQueryWithCacheCheckResultOutput[];
+
+  @Field(() => String, { nullable: true, description: 'Overall error message if success is false' })
+  errorMessage?: string;
+}
+
 @Resolver()
 export class RunQueryResolver {
   private async findQuery(md: IMetadataProvider, QueryID: string, QueryName?: string, CategoryID?: string, CategoryPath?: string, refreshMetadataIfNotFound: boolean = false): Promise<QueryInfo | null> {
@@ -273,4 +371,180 @@ export class RunQueryResolver {
       CacheTTLRemaining: (result as any).CacheTTLRemaining
     };
   }
+
+  /**
+   * Batch query execution - runs multiple queries in a single network call
+   * This is more efficient than making multiple individual query calls
+   */
+  @Query(() => [RunQueryResultType])
+  async RunQueries(
+    @Arg('input', () => [RunQueryInput]) input: RunQueryInput[],
+    @Ctx() context: AppContext
+  ): Promise<RunQueryResultType[]> {
+    const provider = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
+    const rq = new RunQuery(provider as unknown as IRunQueryProvider);
+
+    // Convert input to RunQueryParams array
+    const params: RunQueryParams[] = input.map(i => ({
+      QueryID: i.QueryID,
+      QueryName: i.QueryName,
+      CategoryID: i.CategoryID,
+      CategoryPath: i.CategoryPath,
+      Parameters: i.Parameters,
+      MaxRows: i.MaxRows,
+      StartRow: i.StartRow,
+      ForceAuditLog: i.ForceAuditLog,
+      AuditLogDescription: i.AuditLogDescription
+    }));
+
+    // Execute all queries in parallel using the batch method
+    const results = await rq.RunQueries(params, context.userPayload.userRecord);
+
+    // Map results to output format
+    return results.map((result, index) => {
+      const inputItem = input[index];
+      return {
+        QueryID: result.QueryID || inputItem.QueryID || '',
+        QueryName: result.QueryName || inputItem.QueryName || 'Unknown Query',
+        Success: result.Success ?? false,
+        Results: JSON.stringify(result.Results ?? null),
+        RowCount: result.RowCount ?? 0,
+        TotalRowCount: result.TotalRowCount ?? 0,
+        ExecutionTime: result.ExecutionTime ?? 0,
+        ErrorMessage: result.ErrorMessage || '',
+        AppliedParameters: result.AppliedParameters ? JSON.stringify(result.AppliedParameters) : undefined,
+        CacheHit: (result as Record<string, unknown>).CacheHit as boolean | undefined,
+        CacheTTLRemaining: (result as Record<string, unknown>).CacheTTLRemaining as number | undefined
+      };
+    });
+  }
+
+  /**
+   * Batch query execution with system user privileges
+   */
+  @RequireSystemUser()
+  @Query(() => [RunQueryResultType])
+  async RunQueriesSystemUser(
+    @Arg('input', () => [RunQueryInput]) input: RunQueryInput[],
+    @Ctx() context: AppContext
+  ): Promise<RunQueryResultType[]> {
+    const provider = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
+    const rq = new RunQuery(provider as unknown as IRunQueryProvider);
+
+    // Convert input to RunQueryParams array
+    const params: RunQueryParams[] = input.map(i => ({
+      QueryID: i.QueryID,
+      QueryName: i.QueryName,
+      CategoryID: i.CategoryID,
+      CategoryPath: i.CategoryPath,
+      Parameters: i.Parameters,
+      MaxRows: i.MaxRows,
+      StartRow: i.StartRow,
+      ForceAuditLog: i.ForceAuditLog,
+      AuditLogDescription: i.AuditLogDescription
+    }));
+
+    // Execute all queries in parallel using the batch method
+    const results = await rq.RunQueries(params, context.userPayload.userRecord);
+
+    // Map results to output format
+    return results.map((result, index) => {
+      const inputItem = input[index];
+      return {
+        QueryID: result.QueryID || inputItem.QueryID || '',
+        QueryName: result.QueryName || inputItem.QueryName || 'Unknown Query',
+        Success: result.Success ?? false,
+        Results: JSON.stringify(result.Results ?? null),
+        RowCount: result.RowCount ?? 0,
+        TotalRowCount: result.TotalRowCount ?? 0,
+        ExecutionTime: result.ExecutionTime ?? 0,
+        ErrorMessage: result.ErrorMessage || '',
+        AppliedParameters: result.AppliedParameters ? JSON.stringify(result.AppliedParameters) : undefined,
+        CacheHit: (result as Record<string, unknown>).CacheHit as boolean | undefined,
+        CacheTTLRemaining: (result as Record<string, unknown>).CacheTTLRemaining as number | undefined
+      };
+    });
+  }
+
+  /**
+   * RunQueriesWithCacheCheck - Smart cache validation for batch RunQueries.
+   * For each query, if cacheStatus is provided, the server checks if the cache is current
+   * using the Query's CacheValidationSQL. If current, returns status='current' with no data.
+   * If stale, returns status='stale' with fresh data.
+   * If the Query doesn't have CacheValidationSQL configured, returns 'no_validation' with data.
+   */
+  @Query(() => RunQueriesWithCacheCheckOutput)
+  async RunQueriesWithCacheCheck(
+    @Arg('input', () => [RunQueryWithCacheCheckInput]) input: RunQueryWithCacheCheckInput[],
+    @Ctx() context: AppContext
+  ): Promise<RunQueriesWithCacheCheckOutput> {
+    try {
+      const provider = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
+
+      // Cast provider to SQLServerDataProvider to access RunQueriesWithCacheCheck method
+      const sqlProvider = provider as unknown as SQLServerDataProvider;
+      if (!sqlProvider.RunQueriesWithCacheCheck) {
+        throw new Error('Provider does not support RunQueriesWithCacheCheck');
+      }
+
+      // Convert GraphQL input types to core types
+      const coreParams: RunQueryWithCacheCheckParams[] = input.map(item => ({
+        params: {
+          QueryID: item.params.QueryID,
+          QueryName: item.params.QueryName,
+          CategoryID: item.params.CategoryID,
+          CategoryPath: item.params.CategoryPath,
+          Parameters: item.params.Parameters,
+          MaxRows: item.params.MaxRows,
+          StartRow: item.params.StartRow,
+          ForceAuditLog: item.params.ForceAuditLog,
+          AuditLogDescription: item.params.AuditLogDescription,
+        },
+        cacheStatus: item.cacheStatus ? {
+          maxUpdatedAt: item.cacheStatus.maxUpdatedAt,
+          rowCount: item.cacheStatus.rowCount,
+        } : undefined,
+      }));
+
+      const response = await sqlProvider.RunQueriesWithCacheCheck(coreParams, context.userPayload.userRecord);
+
+      // Transform results to GraphQL output format
+      const transformedResults: RunQueryWithCacheCheckResultOutput[] = response.results.map(result => ({
+        queryIndex: result.queryIndex,
+        queryId: result.queryId,
+        status: result.status,
+        Results: result.results ? JSON.stringify(result.results) : undefined,
+        maxUpdatedAt: result.maxUpdatedAt,
+        rowCount: result.rowCount,
+        errorMessage: result.errorMessage,
+      }));
+
+      return {
+        success: response.success,
+        results: transformedResults,
+        errorMessage: response.errorMessage,
+      };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+      LogError(err);
+      return {
+        success: false,
+        results: [],
+        errorMessage,
+      };
+    }
+  }
+
+  /**
+   * RunQueriesWithCacheCheck with system user privileges
+   */
+  @RequireSystemUser()
+  @Query(() => RunQueriesWithCacheCheckOutput)
+  async RunQueriesWithCacheCheckSystemUser(
+    @Arg('input', () => [RunQueryWithCacheCheckInput]) input: RunQueryWithCacheCheckInput[],
+    @Ctx() context: AppContext
+  ): Promise<RunQueriesWithCacheCheckOutput> {
+    // Same implementation as regular version - RequireSystemUser handles auth
+    return this.RunQueriesWithCacheCheck(input, context);
+  }
 }

package/src/resolvers/RunAIAgentResolver.ts

@@ -1,15 +1,17 @@
-import { Resolver, Mutation, Query, Arg, Ctx, ObjectType, Field, PubSub, PubSubEngine, Subscription, Root, ResolverFilterData, ID } from 'type-graphql';
+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, UserInfo } from '@memberjunction/core';
-import { AIAgentEntityExtended, ConversationDetailEntity, UserNotificationEntity, AIAgentRunEntityExtended } from '@memberjunction/core-entities';
+import { DatabaseProviderBase, LogError, LogStatus, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { ConversationDetailEntity, ConversationDetailAttachmentEntity, UserNotificationEntity } from '@memberjunction/core-entities';
 import { AgentRunner } from '@memberjunction/ai-agents';
-import { ExecuteAgentResult } from '@memberjunction/ai-core-plus';
+import { AIAgentEntityExtended, AIAgentRunEntityExtended, ExecuteAgentResult, ConversationUtility, AttachmentData } from '@memberjunction/ai-core-plus';
 import { AIEngine } from '@memberjunction/aiengine';
+import { ChatMessage } from '@memberjunction/ai';
 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';
 import { SafeJSONParse } from '@memberjunction/global';
+import { getAttachmentService } from '@memberjunction/aiengine';
 
 @ObjectType()
 export class AIAgentRunResult {
@@ -699,4 +701,190 @@ export class RunAIAgentResolver extends ResolverBase {
         }
     }
 
+    /**
+     * Optimized mutation that loads conversation history server-side.
+     * This avoids sending large attachment data from client to server.
+     *
+     * @param conversationDetailId - The conversation detail ID (user's message already saved)
+     * @param agentId - The agent to execute
+     * @param maxHistoryMessages - Maximum number of history messages to include (default: 20)
+     */
+    @Mutation(() => AIAgentRunResult)
+    async RunAIAgentFromConversationDetail(
+        @Arg('conversationDetailId') conversationDetailId: string,
+        @Arg('agentId') agentId: string,
+        @Ctx() { userPayload, providers, dataSource }: AppContext,
+        @Arg('sessionId') sessionId: string,
+        @PubSub() pubSub: PubSubEngine,
+        @Arg('maxHistoryMessages', () => Int, { nullable: true }) maxHistoryMessages?: number,
+        @Arg('data', { nullable: true }) data?: string,
+        @Arg('payload', { nullable: true }) payload?: string,
+        @Arg('lastRunId', { nullable: true }) lastRunId?: string,
+        @Arg('autoPopulateLastRunPayload', { nullable: true }) autoPopulateLastRunPayload?: boolean,
+        @Arg('configurationId', { nullable: true }) configurationId?: string,
+        @Arg('createArtifacts', { nullable: true }) createArtifacts?: boolean,
+        @Arg('createNotification', { nullable: true }) createNotification?: boolean,
+        @Arg('sourceArtifactId', { nullable: true }) sourceArtifactId?: string,
+        @Arg('sourceArtifactVersionId', { nullable: true }) sourceArtifactVersionId?: string
+    ): Promise<AIAgentRunResult> {
+        const p = GetReadWriteProvider(providers);
+        const currentUser = this.GetUserFromPayload(userPayload);
+
+        if (!currentUser) {
+            return {
+                success: false,
+                errorMessage: 'Unable to determine current user',
+                result: JSON.stringify({ success: false, errorMessage: 'Unable to determine current user' })
+            };
+        }
+
+        try {
+            // Load conversation history with attachments from DB
+            const messages = await this.loadConversationHistoryWithAttachments(
+                conversationDetailId,
+                currentUser,
+                maxHistoryMessages || 20
+            );
+
+            // Convert to JSON string for the existing executeAIAgent method
+            const messagesJson = JSON.stringify(messages);
+
+            // Delegate to existing implementation
+            return this.executeAIAgent(
+                p,
+                dataSource,
+                agentId,
+                userPayload,
+                messagesJson,
+                sessionId,
+                pubSub,
+                data,
+                payload,
+                undefined, // templateData
+                lastRunId,
+                autoPopulateLastRunPayload,
+                configurationId,
+                conversationDetailId,
+                createArtifacts || false,
+                createNotification || false,
+                sourceArtifactId,
+                sourceArtifactVersionId
+            );
+        } catch (error) {
+            const errorMessage = (error as Error).message || 'Unknown error loading conversation history';
+            LogError(`RunAIAgentFromConversationDetail failed: ${errorMessage}`, undefined, error);
+            return {
+                success: false,
+                errorMessage,
+                result: JSON.stringify({ success: false, errorMessage })
+            };
+        }
+    }
+
+    /**
+     * Load conversation history with attachments from database.
+     * Builds ChatMessage[] with multimodal content blocks for attachments.
+     */
+    private async loadConversationHistoryWithAttachments(
+        conversationDetailId: string,
+        contextUser: UserInfo,
+        maxMessages: number
+    ): Promise<ChatMessage[]> {
+        const md = new Metadata();
+        const rv = new RunView();
+        const attachmentService = getAttachmentService();
+
+        // Load the current conversation detail to get the conversation ID
+        const currentDetail = await md.GetEntityObject<ConversationDetailEntity>(
+            'Conversation Details',
+            contextUser
+        );
+        if (!await currentDetail.Load(conversationDetailId)) {
+            throw new Error(`Conversation detail ${conversationDetailId} not found`);
+        }
+
+        const conversationId = currentDetail.ConversationID;
+
+        // Load recent conversation details (messages) for this conversation
+        const detailsResult = await rv.RunView<ConversationDetailEntity>({
+            EntityName: 'Conversation Details',
+            ExtraFilter: `ConversationID='${conversationId}'`,
+            OrderBy: '__mj_CreatedAt DESC',
+            MaxRows: maxMessages,
+            ResultType: 'entity_object'
+        }, contextUser);
+
+        if (!detailsResult.Success || !detailsResult.Results) {
+            throw new Error('Failed to load conversation history');
+        }
+
+        // Reverse to get chronological order (oldest first)
+        const details = detailsResult.Results.reverse();
+
+        // Get all message IDs for batch loading attachments
+        const messageIds = details.map(d => d.ID);
+
+        // Batch load all attachments for these messages
+        const attachmentsByDetailId = await attachmentService.getAttachmentsBatch(messageIds, contextUser);
+
+        // Build ChatMessage array with attachments
+        const messages: ChatMessage[] = [];
+
+        for (const detail of details) {
+            const role = this.mapDetailRoleToMessageRole(detail.Role);
+            const attachments = attachmentsByDetailId.get(detail.ID) || [];
+
+            // Get attachment data with content URLs (handles both inline and FileID storage)
+            const attachmentDataPromises = attachments.map(att =>
+                attachmentService.getAttachmentData(att, contextUser)
+            );
+            const attachmentDataResults = await Promise.all(attachmentDataPromises);
+
+            // Filter out nulls and convert to AttachmentData format
+            const validAttachments: AttachmentData[] = attachmentDataResults
+                .filter((result): result is NonNullable<typeof result> => result !== null)
+                .map(result => ({
+                    type: ConversationUtility.GetAttachmentTypeFromMime(result.attachment.MimeType),
+                    mimeType: result.attachment.MimeType,
+                    fileName: result.attachment.FileName ?? undefined,
+                    sizeBytes: result.attachment.FileSizeBytes ?? undefined,
+                    width: result.attachment.Width ?? undefined,
+                    height: result.attachment.Height ?? undefined,
+                    durationSeconds: result.attachment.DurationSeconds ?? undefined,
+                    content: result.contentUrl
+                }));
+
+            // Build message content (with or without attachments)
+            let content: string | ReturnType<typeof ConversationUtility.BuildChatMessageContent>;
+
+            if (validAttachments.length > 0) {
+                // Use ConversationUtility to build multimodal content blocks
+                content = ConversationUtility.BuildChatMessageContent(
+                    detail.Message || '',
+                    validAttachments
+                );
+            } else {
+                content = detail.Message || '';
+            }
+
+            messages.push({
+                role,
+                content
+            });
+        }
+
+        return messages;
+    }
+
+    /**
+     * Map ConversationDetail Role to ChatMessage role
+     */
+    private mapDetailRoleToMessageRole(role: string): 'user' | 'assistant' | 'system' {
+        const roleLower = (role || '').toLowerCase();
+        if (roleLower === 'user') return 'user';
+        if (roleLower === 'assistant' || roleLower === 'agent') return 'assistant';
+        if (roleLower === 'system') return 'system';
+        return 'user'; // Default to user
+    }
+
 }

package/src/resolvers/RunAIPromptResolver.ts

@@ -1,7 +1,7 @@
 import { Resolver, Mutation, Query, Arg, Ctx, ObjectType, Field, Int } from 'type-graphql';
 import { AppContext, UserPayload } from '../types.js';
 import { DatabaseProviderBase, LogError, LogStatus, Metadata } from '@memberjunction/core';
-import { AIPromptEntityExtended, AIModelEntityExtended } from '@memberjunction/core-entities';
+import { AIPromptEntityExtended, AIModelEntityExtended } from '@memberjunction/ai-core-plus';
 import { AIPromptRunner } from '@memberjunction/ai-prompts';
 import { AIPromptParams } from '@memberjunction/ai-core-plus';
 import { ResolverBase } from '../generic/ResolverBase.js';

package/src/resolvers/RunTestResolver.ts

@@ -104,6 +104,7 @@ export class RunTestResolver extends ResolverBase {
         @Arg('testId') testId: string,
         @Arg('verbose', { nullable: true }) verbose: boolean = true,
         @Arg('environment', { nullable: true }) environment?: string,
+        @Arg('tags', { nullable: true }) tags?: string,
         @PubSub() pubSub?: PubSubEngine,
         @Ctx() { userPayload }: AppContext = {} as AppContext
     ): Promise<TestRunResult> {
@@ -132,6 +133,7 @@ export class RunTestResolver extends ResolverBase {
             const options = {
                 verbose,
                 environment,
+                tags,
                 progressCallback
             };
 
@@ -210,6 +212,10 @@ export class RunTestResolver extends ResolverBase {
         @Arg('verbose', { nullable: true }) verbose: boolean = true,
         @Arg('environment', { nullable: true }) environment?: string,
         @Arg('parallel', { nullable: true }) parallel: boolean = false,
+        @Arg('tags', { nullable: true }) tags?: string,
+        @Arg('selectedTestIds', { nullable: true }) selectedTestIds?: string,
+        @Arg('sequenceStart', () => Int, { nullable: true }) sequenceStart?: number,
+        @Arg('sequenceEnd', () => Int, { nullable: true }) sequenceEnd?: number,
         @PubSub() pubSub?: PubSubEngine,
         @Ctx() { userPayload }: AppContext = {} as AppContext
     ): Promise<TestSuiteRunResult> {
@@ -231,10 +237,24 @@ export class RunTestResolver extends ResolverBase {
                 this.createProgressCallback(pubSub, userPayload, suiteId) :
                 undefined;
 
+            // Parse selectedTestIds from JSON string if provided
+            let parsedSelectedTestIds: string[] | undefined;
+            if (selectedTestIds) {
+                try {
+                    parsedSelectedTestIds = JSON.parse(selectedTestIds);
+                } catch (e) {
+                    LogError(`[RunTestResolver] Failed to parse selectedTestIds: ${selectedTestIds}`);
+                }
+            }
+
             const options = {
                 verbose,
                 environment,
                 parallel,
+                tags,
+                selectedTestIds: parsedSelectedTestIds,
+                sequenceStart,
+                sequenceEnd,
                 progressCallback
             };
 

package/src/resolvers/SyncDataResolver.ts

@@ -226,7 +226,7 @@ export class SyncDataResolver {
                 for (const entityObject of data.Results) {
                     if (!await entityObject.Delete()) {
                         overallSuccess = false;
-                        combinedErrorMessage += 'Failed to delete the item :' + entityObject.LatestResult.Message + '\n';
+                        combinedErrorMessage += 'Failed to delete the item :' + entityObject.LatestResult.CompleteMessage + '\n';
                     }
                 }
                 result.Success = overallSuccess
@@ -316,7 +316,7 @@ export class SyncDataResolver {
                     result.Success = true;
                 }
                 else {
-                    result.ErrorMessage = 'Failed to delete the item :' + entityObject.LatestResult.Message;
+                    result.ErrorMessage = 'Failed to delete the item :' + entityObject.LatestResult.CompleteMessage;
                 }
             }
         }
@@ -334,7 +334,7 @@ export class SyncDataResolver {
                 result.Success = true;
             }
             else {
-                result.ErrorMessage = 'Failed to delete the item :' + entityObject.LatestResult.Message;
+                result.ErrorMessage = 'Failed to delete the item :' + entityObject.LatestResult.CompleteMessage;
             }
         }
         else {
@@ -363,7 +363,7 @@ export class SyncDataResolver {
             });
         }
         else {
-            result.ErrorMessage = 'Failed to create the item :' + entityObject.LatestResult.Message;
+            result.ErrorMessage = 'Failed to create the item :' + entityObject.LatestResult.CompleteMessage;
         }
     }
 
@@ -406,7 +406,7 @@ export class SyncDataResolver {
             });
         }
         else {
-            result.ErrorMessage = 'Failed to update the item :' + entityObject.LatestResult.Message;
+            result.ErrorMessage = 'Failed to update the item :' + entityObject.LatestResult.CompleteMessage;
         }
     }
 }