@memberjunction/server 2.127.0 → 2.129.0

package/src/generic/ResolverBase.ts

@@ -26,7 +26,8 @@ import { httpTransport, CloudEvent, emitterFor } from 'cloudevents';
 import { RunViewGenericParams, UserPayload } from '../types.js';
 import { RunDynamicViewInput, RunViewByIDInput, RunViewByNameInput } from './RunViewResolver.js';
 import { DeleteOptionsInput } from './DeleteOptionsInput.js';
-import { MJEvent, MJEventType, MJGlobal } from '@memberjunction/global';
+import { MJEvent, MJEventType, MJGlobal, ENCRYPTED_SENTINEL, IsValueEncrypted, IsOnlyTimezoneShift } from '@memberjunction/global';
+import { EncryptionEngine } from '@memberjunction/encryption';
 import { PUSH_STATUS_UPDATES_TOPIC } from './PushStatusResolver.js';
 import { FieldMapper } from '@memberjunction/graphql-dataprovider';
 import { Subscription } from 'rxjs';
@@ -47,7 +48,20 @@ export class ResolverBase {
     return g[ResolverBase._eventSubscriptionKey];
   }
 
-  protected MapFieldNamesToCodeNames(entityName: string, dataObject: any) {
+  /**
+   * Maps field names to their GraphQL-safe CodeNames and handles encryption for API responses.
+   *
+   * For encrypted fields coming from raw SQL queries (not entity objects):
+   * - AllowDecryptInAPI=true: Decrypt the value before sending to client
+   * - AllowDecryptInAPI=false + SendEncryptedValue=true: Keep encrypted ciphertext
+   * - AllowDecryptInAPI=false + SendEncryptedValue=false: Replace with sentinel
+   *
+   * @param entityName - The entity name
+   * @param dataObject - The data object with field values
+   * @param contextUser - Optional user context for decryption (required for encrypted fields)
+   * @returns The processed data object
+   */
+  protected async MapFieldNamesToCodeNames(entityName: string, dataObject: any, contextUser?: UserInfo): Promise<any> {
     // for the given entity name provided, check to see if there are any fields
     // where the code name is different from the field name, and for just those
     // fields, iterate through the dataObject and REPLACE the property that has the field name
@@ -69,17 +83,153 @@ export class ResolverBase {
           }
         }
       });
+
+      // Handle encrypted fields - data from raw SQL queries is still encrypted
+      const encryptedFields = entityInfo.EncryptedFields;
+      if (encryptedFields.length > 0) {
+        for (const field of encryptedFields) {
+          const fieldName = field.CodeName;
+          const value = dataObject[fieldName];
+
+          // Skip null/undefined values
+          if (value === null || value === undefined) continue;
+
+          // Check if value is encrypted (raw SQL returns encrypted values)
+          const engine = EncryptionEngine.Instance;
+          await engine.Config(false, contextUser);
+          const keyMarker = field.EncryptionKeyID ? engine.GetKeyByID(field.EncryptionKeyID)?.Marker : undefined;
+          if (typeof value === 'string' && IsValueEncrypted(value, keyMarker)) {
+            if (field.AllowDecryptInAPI) {
+              // Decrypt the value for the client
+              if (contextUser) {
+                try {
+                  const decryptedValue = await engine.Decrypt(value, contextUser);
+                  dataObject[fieldName] = decryptedValue;
+                } catch (err) {
+                  LogError(`Failed to decrypt field ${fieldName} for API response: ${err}`);
+                  // On decryption failure, use sentinel for safety
+                  dataObject[fieldName] = ENCRYPTED_SENTINEL;
+                }
+              } else {
+                // No context user, can't decrypt - use sentinel
+                dataObject[fieldName] = ENCRYPTED_SENTINEL;
+              }
+            } else if (!field.SendEncryptedValue) {
+              // AllowDecryptInAPI=false and SendEncryptedValue=false - use sentinel
+              dataObject[fieldName] = ENCRYPTED_SENTINEL;
+            }
+            // else: AllowDecryptInAPI=false and SendEncryptedValue=true - keep encrypted value as-is
+          }
+        }
+      }
     }
     return dataObject;
   }
 
-  protected ArrayMapFieldNamesToCodeNames(entityName: string, dataObjectArray: any[]) {
+  protected async ArrayMapFieldNamesToCodeNames(entityName: string, dataObjectArray: any[], contextUser?: UserInfo): Promise<any[]> {
     // iterate through the array and call MapFieldNamesToCodeNames for each element
     if (dataObjectArray && dataObjectArray.length > 0) {
-      dataObjectArray.forEach((element) => {
-        this.MapFieldNamesToCodeNames(entityName, element);
-      });
+      for (const element of dataObjectArray) {
+        await this.MapFieldNamesToCodeNames(entityName, element, contextUser);
+      }
+    }
+    return dataObjectArray;
+  }
+
+  /**
+   * Filters encrypted field values before sending to the API client.
+   *
+   * For each encrypted field in the entity:
+   * - If AllowDecryptInAPI is true: value passes through unchanged (already decrypted by data provider)
+   * - If AllowDecryptInAPI is false and SendEncryptedValue is true: re-encrypt and send ciphertext
+   * - If AllowDecryptInAPI is false and SendEncryptedValue is false: replace with sentinel value
+   *
+   * @param entityName - Name of the entity
+   * @param dataObject - The data object containing field values
+   * @param encryptionEngine - Optional encryption engine for re-encryption (lazy loaded if needed)
+   * @param contextUser - User context for encryption operations
+   * @returns The filtered data object
+   */
+  protected async FilterEncryptedFieldsForAPI(
+    entityName: string,
+    dataObject: Record<string, unknown>,
+    contextUser: UserInfo
+  ): Promise<Record<string, unknown>> {
+    if (!dataObject) return dataObject;
+
+    const md = new Metadata();
+    const entityInfo = md.Entities.find((e) => e.Name === entityName);
+    if (!entityInfo) return dataObject;
+
+    // Find all encrypted fields that need filtering
+    const encryptedFields = entityInfo.EncryptedFields;
+    if (encryptedFields.length === 0) return dataObject;
+
+    // Process each encrypted field
+    for (const field of encryptedFields) {
+      const fieldName = field.CodeName;
+      const value = dataObject[fieldName];
+
+      // Skip null/undefined values
+      if (value === null || value === undefined) continue;
+
+      // If AllowDecryptInAPI is true, the decrypted value passes through
+      if (field.AllowDecryptInAPI) continue;
+
+      // AllowDecryptInAPI is false - we need to filter the value
+      const engine = EncryptionEngine.Instance;
+      await engine.Config(false, contextUser);
+      const keyMarker = field.EncryptionKeyID ? engine.GetKeyByID(field.EncryptionKeyID)?.Marker : undefined;
+      if (field.SendEncryptedValue) {
+        // Re-encrypt the value before sending
+        // Only re-encrypt if it's not already encrypted (data provider decrypted it)
+        if (typeof value === 'string' && !IsValueEncrypted(value, keyMarker)) {
+          try {
+            const encryptedValue = await engine.Encrypt(
+              value,
+              field.EncryptionKeyID as string,
+              contextUser
+            );
+            dataObject[fieldName] = encryptedValue;
+          } catch (err) {
+            // If re-encryption fails, use sentinel for safety
+            LogError(`Failed to re-encrypt field ${fieldName} for API response: ${err}`);
+            dataObject[fieldName] = ENCRYPTED_SENTINEL;
+          }
+        }
+        // If already encrypted (shouldn't happen normally), keep as-is
+      } else {
+        // SendEncryptedValue is false - replace with sentinel
+        dataObject[fieldName] = ENCRYPTED_SENTINEL;
+      }
     }
+
+    return dataObject;
+  }
+
+  /**
+   * Filters encrypted fields for an array of data objects
+   */
+  protected async ArrayFilterEncryptedFieldsForAPI(
+    entityName: string,
+    dataObjectArray: Record<string, unknown>[],
+    contextUser: UserInfo
+  ): Promise<Record<string, unknown>[]> {
+    if (!dataObjectArray || dataObjectArray.length === 0) return dataObjectArray;
+
+    // Check if entity has any encrypted fields first to avoid unnecessary processing
+    const md = new Metadata();
+    const entityInfo = md.Entities.find((e) => e.Name === entityName);
+    if (!entityInfo) return dataObjectArray;
+
+    const encryptedFields = entityInfo.Fields.filter(f => f.Encrypt && !f.AllowDecryptInAPI);
+    if (encryptedFields.length === 0) return dataObjectArray;
+
+    // Process each element
+    for (const element of dataObjectArray) {
+      await this.FilterEncryptedFieldsForAPI(entityName, element, contextUser);
+    }
+
     return dataObjectArray;
   }
 
@@ -438,8 +588,14 @@ export class ResolverBase {
         for (const r of result.Results) {
           mapper.MapFields(r);
         }
+        // Filter encrypted fields before sending to API client
+        await this.ArrayFilterEncryptedFieldsForAPI(
+          viewInfo.Entity,
+          result.Results as Record<string, unknown>[],
+          user
+        );
       }
-      
+
       return result;
     } catch (err) {
       // Fix #9: Improved error handling with structured logging
@@ -534,11 +690,22 @@ export class ResolverBase {
 
       // Process results
       const mapper = new FieldMapper();
-      for (const runViewResult of runViewResults) {
+      for (let i = 0; i < runViewResults.length; i++) {
+        const runViewResult = runViewResults[i];
         if (runViewResult?.Success && runViewResult.Results?.length) {
           for (const result of runViewResult.Results) {
             mapper.MapFields(result);
           }
+          // Filter encrypted fields before sending to API client
+          // Use the corresponding param's entity name
+          const entityName = params[i]?.viewInfo?.Entity;
+          if (entityName && contextUser) {
+            await this.ArrayFilterEncryptedFieldsForAPI(
+              entityName,
+              runViewResult.Results as Record<string, unknown>[],
+              contextUser
+            );
+          }
         }
       }
 
@@ -720,7 +887,9 @@ export class ResolverBase {
       if (await entityObject.Save()) {
         // save worked, fire the AfterCreate event and then return all the data
         await this.AfterCreate(provider, input); // fire event
-        return this.MapFieldNamesToCodeNames(entityName, entityObject.GetAll());
+        const contextUser = this.GetUserFromPayload(userPayload);
+        // MapFieldNamesToCodeNames now handles encryption filtering as well
+        return await this.MapFieldNamesToCodeNames(entityName, entityObject.GetAll(), contextUser);
       }
       // save failed, return null
       else throw entityObject.LatestResult?.Message;
@@ -790,8 +959,9 @@ export class ResolverBase {
       if (await entityObject.Save()) {
         // save worked, fire afterevent and return all the data
         await this.AfterUpdate(provider, input); // fire event
-        
-        return this.MapFieldNamesToCodeNames(entityName, entityObject.GetAll());
+
+        // MapFieldNamesToCodeNames now handles encryption filtering as well
+        return await this.MapFieldNamesToCodeNames(entityName, entityObject.GetAll(), userInfo);
       } else {
         throw new GraphQLError(entityObject.LatestResult?.Message ?? 'Unknown error', {
           extensions: { code: 'SAVE_ENTITY_ERROR', entityName },
@@ -884,7 +1054,26 @@ export class ResolverBase {
           break;
         case 'object':
           if (clientOldValues[key] instanceof Date) {
-            different = clientOldValues[key].getTime() !== dbValues[key].getTime();
+            const clientDate = clientOldValues[key] as Date;
+            const dbDate = dbValues[key];
+            if (dbDate == null || !(dbDate instanceof Date)) {
+              different = true;
+            } else if (clientDate.getTime() !== dbDate.getTime()) {
+              // Check if this is a datetime/datetime2 field with only a timezone hour shift
+              const sqlType = f?.SQLFullType?.trim().toLowerCase() || '';
+              if (sqlType !== 'datetimeoffset' && IsOnlyTimezoneShift(clientDate, dbDate)) {
+                console.warn(
+                  `Timezone hour shift detected on field "${key}" (${sqlType || 'datetime'}). ` +
+                  `Client: ${clientDate.toISOString()}, DB: ${dbDate.toISOString()}. ` +
+                  `Consider using datetimeoffset to avoid timezone ambiguity.`
+                );
+                different = false; // Allow timezone shifts through for non-datetimeoffset fields
+              } else {
+                different = true;
+              }
+            }
+          } else if (clientOldValues[key] === null) {
+            different = dbValues[key] !== null;
           }
           break;
         default:

package/src/generic/RunViewResolver.ts

@@ -1,11 +1,12 @@
 import { Arg, Ctx, Field, InputType, Int, ObjectType, PubSubEngine, Query, Resolver } from 'type-graphql';
 import { AppContext } from '../types.js';
 import { ResolverBase } from './ResolverBase.js';
-import { LogError, LogStatus, EntityInfo } from '@memberjunction/core';
+import { LogError, LogStatus, EntityInfo, RunViewWithCacheCheckResult, RunViewsWithCacheCheckResponse, RunViewWithCacheCheckParams } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { GetReadOnlyProvider } from '../util.js';
 import { UserViewEntityExtended } from '@memberjunction/core-entities';
 import { KeyValuePairOutputType } from './KeyInputOutputTypes.js';
+import { SQLServerDataProvider } from '@memberjunction/sqlserver-dataprovider';
 
 /********************************************************************************
  * The PURPOSE of this resolver is to provide a generic way to run a view and return the results.
@@ -383,10 +384,75 @@ export class RunViewGenericInput {
   StartRow?: number;
 }
 
+//****************************************************************************
+// INPUT/OUTPUT TYPES for RunViewsWithCacheCheck
+//****************************************************************************
+
+@InputType()
+export class RunViewCacheStatusInput {
+  @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 RunViewWithCacheCheckInput {
+  @Field(() => RunDynamicViewInput, { description: 'The RunView parameters' })
+  params: RunDynamicViewInput;
+
+  @Field(() => RunViewCacheStatusInput, {
+    nullable: true,
+    description: 'Optional cache status - if provided, server will check if cache is current'
+  })
+  cacheStatus?: RunViewCacheStatusInput;
+}
+
+@ObjectType()
+export class RunViewWithCacheCheckResultOutput {
+  @Field(() => Int, { description: 'The index of this view in the batch request' })
+  viewIndex: number;
+
+  @Field(() => String, { description: "'current', 'stale', or 'error'" })
+  status: string;
+
+  @Field(() => [RunViewGenericResultRow], {
+    nullable: true,
+    description: 'Fresh results - only populated when status is stale'
+  })
+  Results?: RunViewGenericResultRow[];
+
+  @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 RunViewsWithCacheCheckOutput {
+  @Field(() => Boolean, { description: 'Whether the overall operation succeeded' })
+  success: boolean;
+
+  @Field(() => [RunViewWithCacheCheckResultOutput], { description: 'Results for each view in the batch' })
+  results: RunViewWithCacheCheckResultOutput[];
+
+  @Field(() => String, { nullable: true, description: 'Overall error message if success is false' })
+  errorMessage?: string;
+}
+
+//****************************************************************************
+// OUTPUT TYPES for RunView Results
+//****************************************************************************
+
 @ObjectType()
 export class RunViewResultRow {
-  @Field(() => [KeyValuePairOutputType], { 
-    description: 'Primary key values for the record' 
+  @Field(() => [KeyValuePairOutputType], {
+    description: 'Primary key values for the record'
   })
   PrimaryKey: KeyValuePairOutputType[];
 
@@ -771,6 +837,94 @@ export class RunViewResolver extends ResolverBase {
     }
   }
 
+  /**
+   * RunViewsWithCacheCheck - Smart cache validation for batch RunViews.
+   * For each view, if cacheStatus is provided, the server checks if the cache is current.
+   * If current, returns status='current' with no data. If stale, returns status='stale' with fresh data.
+   */
+  @Query(() => RunViewsWithCacheCheckOutput)
+  async RunViewsWithCacheCheck(
+    @Arg('input', () => [RunViewWithCacheCheckInput]) input: RunViewWithCacheCheckInput[],
+    @Ctx() { providers, userPayload }: AppContext
+  ): Promise<RunViewsWithCacheCheckOutput> {
+    try {
+      const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+
+      // Cast provider to SQLServerDataProvider to access RunViewsWithCacheCheck method
+      const sqlProvider = provider as unknown as SQLServerDataProvider;
+      if (!sqlProvider.RunViewsWithCacheCheck) {
+        throw new Error('Provider does not support RunViewsWithCacheCheck');
+      }
+
+      // Convert GraphQL input types to core types
+      const coreParams: RunViewWithCacheCheckParams[] = input.map(item => ({
+        params: {
+          EntityName: item.params.EntityName,
+          ExtraFilter: item.params.ExtraFilter,
+          OrderBy: item.params.OrderBy,
+          Fields: item.params.Fields,
+          UserSearchString: item.params.UserSearchString,
+          ExcludeUserViewRunID: item.params.ExcludeUserViewRunID,
+          OverrideExcludeFilter: item.params.OverrideExcludeFilter,
+          IgnoreMaxRows: item.params.IgnoreMaxRows,
+          MaxRows: item.params.MaxRows,
+          ForceAuditLog: item.params.ForceAuditLog,
+          AuditLogDescription: item.params.AuditLogDescription,
+          ResultType: (item.params.ResultType || 'simple') as 'simple' | 'entity_object' | 'count_only',
+          StartRow: item.params.StartRow,
+        },
+        cacheStatus: item.cacheStatus ? {
+          maxUpdatedAt: item.cacheStatus.maxUpdatedAt,
+          rowCount: item.cacheStatus.rowCount,
+        } : undefined,
+      }));
+
+      const response = await sqlProvider.RunViewsWithCacheCheck(coreParams, userPayload.userRecord);
+
+      // Transform results to include processed data rows
+      const transformedResults: RunViewWithCacheCheckResultOutput[] = response.results.map((result, index) => {
+        const inputItem = input[index];
+        const entity = provider.Entities.find(e => e.Name === inputItem.params.EntityName);
+
+        if (result.status === 'stale' && result.results && entity) {
+          // Process raw data into GraphQL-compatible format
+          const processedRows = this.processRawData(result.results as Record<string, unknown>[], entity.ID, entity);
+          return {
+            viewIndex: result.viewIndex,
+            status: result.status,
+            Results: processedRows,
+            maxUpdatedAt: result.maxUpdatedAt,
+            rowCount: result.rowCount,
+            errorMessage: result.errorMessage,
+          };
+        }
+
+        return {
+          viewIndex: result.viewIndex,
+          status: result.status,
+          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,
+      };
+    }
+  }
+
   protected processRawData(rawData: any[], entityId: string, entityInfo: EntityInfo): RunViewResultRow[] {
     const returnResult = [];
     for (let i = 0; i < rawData.length; i++) {

package/src/index.ts

@@ -69,6 +69,8 @@ LoadSendGridProvider();
 
 import { ExternalChangeDetectorEngine } from '@memberjunction/external-change-detection';
 import { ScheduledJobsService } from './services/ScheduledJobsService.js';
+import { LocalCacheManager, StartupManager, TelemetryManager, TelemetryLevel } from '@memberjunction/core';
+import { getSystemUser } from './auth/index.js';
 
 const cacheRefreshInterval = configInfo.databaseSettings.metadataCacheRefreshInterval;
 
@@ -110,6 +112,7 @@ export * from './resolvers/GetDataResolver.js';
 export * from './resolvers/GetDataContextDataResolver.js';
 export * from './resolvers/TransactionGroupResolver.js';
 export * from './resolvers/CreateQueryResolver.js';
+export * from './resolvers/TelemetryResolver.js';
 export { GetReadOnlyDataSource, GetReadWriteDataSource, GetReadWriteProvider, GetReadOnlyProvider } from './util.js';
 
 export * from './generated/generated.js';
@@ -147,11 +150,6 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
   const setupComplete$ = new ReplaySubject(1);
   await pool.connect();
 
-  const config = new SQLServerProviderConfigData(pool, mj_core_schema, cacheRefreshInterval);
-  await setupSQLServerClient(config); // datasource is already initialized, so we can setup the client right away
-  const md = new Metadata();
-  console.log(`Data Source has been initialized. ${md?.Entities ? md.Entities.length : 0} entities loaded.`);
-
   const dataSources = [new DataSourceInfo({dataSource: pool, type: 'Read-Write', host: dbHost, port: dbPort, database: dbDatabase, userName: dbUsername})];
   
   // Establish a second read-only connection to the database if dbReadOnlyUsername and dbReadOnlyPassword exist
@@ -170,6 +168,28 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
     console.log('Read-only Connection Pool has been initialized.');
   }
 
+  const config = new SQLServerProviderConfigData(pool, mj_core_schema, cacheRefreshInterval);
+  await setupSQLServerClient(config); // datasource is already initialized, so we can setup the client right away
+  const md = new Metadata();
+  console.log(`Data Source has been initialized. ${md?.Entities ? md.Entities.length : 0} entities loaded.`);
+
+  // Initialize server telemetry based on config
+  const tm = TelemetryManager.Instance;
+  if (configInfo.telemetry?.enabled) {
+    tm.SetEnabled(true);
+    if (configInfo.telemetry?.level) {
+      tm.UpdateSettings({ level: configInfo.telemetry.level as TelemetryLevel });
+    }
+    console.log(`Server telemetry enabled with level: ${configInfo.telemetry.level || 'standard'}`);
+  } else {
+    tm.SetEnabled(false);
+    console.log('Server telemetry disabled');
+  }
+
+  // Initialize LocalCacheManager with the server-side storage provider (in-memory)
+  await LocalCacheManager.Instance.Initialize(Metadata.Provider.LocalStorageProvider);
+  console.log('LocalCacheManager initialized');
+
   setupComplete$.next(true);
   raiseEvent('setupComplete', dataSources, null,  this);
 

package/src/resolvers/AskSkipResolver.ts

@@ -1,11 +1,10 @@
-import { Arg, Ctx, Field, InputType, Mutation, ObjectType, PubSub, PubSubEngine, Query, Resolver } from 'type-graphql';
+import { Arg, Ctx, Field, ObjectType, PubSub, PubSubEngine, Query, Resolver } from 'type-graphql';
 import { LogError, LogStatus, Metadata, RunView, UserInfo, CompositeKey, EntityFieldInfo, EntityInfo, EntityRelationshipInfo, EntitySaveOptions, EntityDeleteOptions, IMetadataProvider } from '@memberjunction/core';
-import { AppContext, UserPayload, MJ_SERVER_EVENT_CODE } from '../types.js';
+import { AppContext, UserPayload } from '../types.js';
 import { BehaviorSubject } from 'rxjs';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { DataContext } from '@memberjunction/data-context';
-import { LoadDataContextItemsServer } from '@memberjunction/data-context-server';
-import { LearningCycleScheduler } from '../scheduler/LearningCycleScheduler.js';
+import { LoadDataContextItemsServer } from '@memberjunction/data-context-server'; 
 LoadDataContextItemsServer(); // prevent tree shaking since the DataContextItemServer class is not directly referenced in this file or otherwise statically instantiated, so it could be removed by the build process
 
 import {
@@ -16,8 +15,7 @@ import {
   SkipAPIDataRequestResponse,
   SkipAPIClarifyingQuestionResponse,
   SkipEntityInfo,
-  SkipQueryInfo,
-  SkipQueryEntityInfo,
+  SkipQueryInfo, 
   SkipAPIRunScriptRequest,
   SkipAPIRequestAPIKey,
   SkipRequestPhase,
@@ -26,13 +24,10 @@ import {
   SkipEntityFieldInfo,
   SkipEntityRelationshipInfo,
   SkipEntityFieldValueInfo,
-  SkipAPILearningCycleRequest,
-  SkipAPILearningCycleResponse,
-  SkipLearningCycleNoteChange,
+  SkipAPILearningCycleRequest, 
   SkipConversation,
   SkipAPIArtifact,
-  SkipAPIAgentRequest,
-  SkipAPIArtifactRequest,
+  SkipAPIAgentRequest, 
   SkipAPIArtifactType,
   SkipAPIArtifactVersion,
 } from '@memberjunction/skip-types';
@@ -50,10 +45,9 @@ import {
   ConversationEntity,
   DataContextEntity,
   DataContextItemEntity,
-  UserNotificationEntity,
-  AIAgentEntityExtended
+  UserNotificationEntity
 } from '@memberjunction/core-entities';
-import { apiKey as callbackAPIKey, AskSkipInfo, baseUrl, publicUrl, configInfo, graphqlPort, graphqlRootPath, mj_core_schema } from '../config.js';
+import { apiKey as callbackAPIKey, baseUrl, publicUrl, configInfo, graphqlPort, graphqlRootPath } from '../config.js';
 import mssql from 'mssql';
 
 import { registerEnumType } from 'type-graphql';
@@ -656,7 +650,7 @@ export class AskSkipResolver {
   //     learningCycleEntity.StartedAt = startTime;
 
   //     if (!(await learningCycleEntity.Save())) {
-  //       throw new Error(`Failed to create learning cycle record: ${learningCycleEntity.LatestResult.Error}`);
+  //       throw new Error(`Failed to create learning cycle record: ${learningCycleEntity.LatestResult.CompleteMessage}`);
   //     }
 
   //     const learningCycleId = learningCycleEntity.ID;
@@ -676,7 +670,7 @@ export class AskSkipResolver {
   //         learningCycleEntity.AgentSummary = 'No new conversations to process, learning cycle skipped, but recorded for audit purposes.';
   //         learningCycleEntity.EndedAt = new Date();
   //         if (!(await learningCycleEntity.Save())) {
-  //           LogError(`Failed to update learning cycle record: ${learningCycleEntity.LatestResult.Error}`);
+  //           LogError(`Failed to update learning cycle record: ${learningCycleEntity.LatestResult.CompleteMessage}`);
   //         }
   //         const result: SkipAPILearningCycleResponse = {
   //           success: true,
@@ -702,7 +696,7 @@ export class AskSkipResolver {
   //         learningCycleEntity.EndedAt = endTime;
 
   //         if (!(await learningCycleEntity.Save())) {
-  //           LogError(`Failed to update learning cycle record: ${learningCycleEntity.LatestResult.Error}`);
+  //           LogError(`Failed to update learning cycle record: ${learningCycleEntity.LatestResult.CompleteMessage}`);
   //         }
           
   //         return response;
@@ -945,7 +939,7 @@ export class AskSkipResolver {
 
 //       // Save the note
 //       if (!(await noteEntity.Save())) {
-//         LogError(`Error saving AI Agent Note: ${noteEntity.LatestResult.Error}`);
+//         LogError(`Error saving AI Agent Note: ${noteEntity.LatestResult.CompleteMessage}`);
 //         return false;
 //       }
 
@@ -986,7 +980,7 @@ export class AskSkipResolver {
 
 //     // Proceed with deletion
 //     if (!(await noteEntity.Delete())) {
-//       LogError(`Error deleting AI Agent Note: ${noteEntity.LatestResult.Error}`);
+//       LogError(`Error deleting AI Agent Note: ${noteEntity.LatestResult.CompleteMessage}`);
 //       return false;
 //     }
 
@@ -1732,7 +1726,11 @@ export class AskSkipResolver {
         QueryID: e.QueryID,
         EntityID: e.EntityID,
         Entity: e.Entity
-      }))
+      })),
+      CacheEnabled: q.CacheEnabled,
+      CacheMaxSize: q.CacheMaxSize,
+      CacheTTLMinutes: q.CacheMaxSize,
+      CacheValidationSQL: q.CacheValidationSQL
     }));
   }