@memberjunction/server 2.128.0 → 2.129.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,9 +1,9 @@
 import { Resolver, Mutation, Query, Arg, Ctx, ObjectType, Field, PubSub, PubSubEngine, Subscription, Root, ResolverFilterData, ID } 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 { ConversationDetailEntity, UserNotificationEntity } from '@memberjunction/core-entities';
 import { AgentRunner } from '@memberjunction/ai-agents';
-import { ExecuteAgentResult } from '@memberjunction/ai-core-plus';
+import { AIAgentEntityExtended, AIAgentRunEntityExtended, ExecuteAgentResult } from '@memberjunction/ai-core-plus';
 import { AIEngine } from '@memberjunction/aiengine';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver.js';

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/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;
         }
     }
 }