@memberjunction/server 2.76.0 → 2.77.0

package/src/index.ts

@@ -93,7 +93,7 @@ export * from './resolvers/GetDataResolver.js';
 export * from './resolvers/GetDataContextDataResolver.js';
 export * from './resolvers/TransactionGroupResolver.js';
 export * from './resolvers/CreateQueryResolver.js';
-export { GetReadOnlyDataSource, GetReadWriteDataSource } from './util.js';
+export { GetReadOnlyDataSource, GetReadWriteDataSource, GetReadWriteProvider, GetReadOnlyProvider } from './util.js';
 
 export * from './generated/generated.js';
 

package/src/resolvers/AskSkipResolver.ts

@@ -1,5 +1,5 @@
 import { Arg, Ctx, Field, Mutation, ObjectType, PubSub, PubSubEngine, Query, Resolver } from 'type-graphql';
-import { LogError, LogStatus, Metadata, RunView, UserInfo, CompositeKey, EntityFieldInfo, EntityInfo, EntityRelationshipInfo } from '@memberjunction/core';
+import { LogError, LogStatus, Metadata, RunView, UserInfo, CompositeKey, EntityFieldInfo, EntityInfo, EntityRelationshipInfo, EntitySaveOptions, EntityDeleteOptions } from '@memberjunction/core';
 import { AppContext, UserPayload, MJ_SERVER_EVENT_CODE } from '../types.js';
 import { BehaviorSubject } from 'rxjs';
 import { take } from 'rxjs/operators';
@@ -390,6 +390,7 @@ export class AskSkipResolver {
       const ck = new CompositeKey();
       ck.KeyValuePairs = compositeKey.KeyValuePairs;
       dci.RecordID = ck.Values();
+
       let dciSaveResult: boolean = await dci.Save();
       if (!dciSaveResult) {
         LogError(`Error saving DataContextItemEntity for record chat: ${EntityName} ${ck.Values()}`, undefined, dci.LatestResult);
@@ -415,7 +416,7 @@ export class AskSkipResolver {
       conversationDetailID: convoDetailEntity.ID,
     });
 
-    return this.handleSimpleSkipChatPostRequest(input, convoEntity, convoDetailEntity, true, user);
+    return this.handleSimpleSkipChatPostRequest(input, convoEntity, convoDetailEntity, true, user, userPayload);
   }
 
   /**
@@ -536,7 +537,7 @@ export class AskSkipResolver {
         }
         else {
           // Make the API request
-          const response = await this.handleSimpleSkipLearningPostRequest(input, user, learningCycleId, agentID);
+          const response = await this.handleSimpleSkipLearningPostRequest(input, user, learningCycleId, agentID, userPayload);
 
           // Update learning cycle to completed
           const endTime = new Date();
@@ -594,7 +595,8 @@ export class AskSkipResolver {
     input: SkipAPILearningCycleRequest, 
     user: UserInfo, 
     learningCycleId: string,
-    agentID: string
+    agentID: string,
+    userPayload: UserPayload
   ): Promise<SkipAPILearningCycleResponse> {
     const skipConfigInfo = configInfo.askSkip;
     LogStatus(`   >>> HandleSimpleSkipLearningPostRequest Sending request to Skip API: ${skipConfigInfo.learningCycleURL}`);
@@ -608,7 +610,7 @@ export class AskSkipResolver {
 
       // Process any note changes, if any
       if (apiResponse.noteChanges && apiResponse.noteChanges.length > 0) {
-        await this.processLearningCycleNoteChanges(apiResponse.noteChanges, agentID, user);
+        await this.processLearningCycleNoteChanges(apiResponse.noteChanges, agentID, user, userPayload);
       }
 
       // Not yet implemented
@@ -653,7 +655,8 @@ export class AskSkipResolver {
     convoEntity: ConversationEntity = null,
     convoDetailEntity: ConversationDetailEntity = null,
     createAIMessageConversationDetail: boolean = false,
-    user: UserInfo = null
+    user: UserInfo = null,
+    userPayload: UserPayload = null
   ): Promise<AskSkipResultType> {
     const skipConfigInfo = configInfo.askSkip;
     LogStatus(`   >>> HandleSimpleSkipChatPostRequest Sending request to Skip API: ${skipConfigInfo.chatURL}`);
@@ -665,7 +668,7 @@ export class AskSkipResolver {
         // the last object in the response array is the final response from the Skip API
         const apiResponse = <SkipAPIResponse>response[response.length - 1].value;
         const AIMessageConversationDetailID = createAIMessageConversationDetail && convoEntity
-          ? await this.CreateAIMessageConversationDetail(apiResponse, convoEntity.ID, user)
+          ? await this.CreateAIMessageConversationDetail(apiResponse, convoEntity.ID, user, userPayload)
           : '';
         //      const apiResponse = <SkipAPIResponse>response.data;
         LogStatus(`  Skip API response: ${apiResponse.responsePhase}`);
@@ -681,7 +684,7 @@ export class AskSkipResolver {
       } else {
         // Set conversation status to Available on failure so user can try again (if conversation exists)
         if (convoEntity) {
-          await this.setConversationStatus(convoEntity, 'Available');
+          await this.setConversationStatus(convoEntity, 'Available', userPayload);
         }
         
         return {
@@ -697,7 +700,7 @@ export class AskSkipResolver {
     } catch (error) {
       // Set conversation status to Available on error so user can try again (if conversation exists)
       if (convoEntity) {
-        await this.setConversationStatus(convoEntity, 'Available');
+        await this.setConversationStatus(convoEntity, 'Available', userPayload);
       }
       
       // Log the error for debugging
@@ -720,7 +723,8 @@ export class AskSkipResolver {
   protected async processLearningCycleNoteChanges(
     noteChanges: SkipLearningCycleNoteChange[], 
     agentID: string,
-    user: UserInfo
+    user: UserInfo,
+    userPayload: UserPayload
     ): Promise<void> {
       const md = new Metadata();
 
@@ -739,9 +743,9 @@ export class AskSkipResolver {
       await Promise.all(validNoteChanges.map(async (change) => {
         try {
           if (change.changeType === 'add' || change.changeType === 'update') {
-            await this.processAddOrUpdateSkipNote(change, agentID, user);
+            await this.processAddOrUpdateSkipNote(change, agentID, user, userPayload);
           } else if (change.changeType === 'delete') {
-            await this.processDeleteSkipNote(change, user);
+            await this.processDeleteSkipNote(change, user, userPayload);
           }
         } catch (e) {
           LogError(`Error processing note change: ${e}`);
@@ -758,7 +762,7 @@ export class AskSkipResolver {
    * @param user User context for the operation
    * @returns Whether the operation was successful
    */
-  protected async processAddOrUpdateSkipNote(change: SkipLearningCycleNoteChange, agentID: string, user: UserInfo): Promise<boolean> {
+  protected async processAddOrUpdateSkipNote(change: SkipLearningCycleNoteChange, agentID: string, user: UserInfo, userPayload: UserPayload): Promise<boolean> {
     try {  
       // Get the note entity object
       const md = new Metadata();
@@ -805,7 +809,7 @@ export class AskSkipResolver {
    * @param user User context for the operation
    * @returns Whether the deletion was successful
    */
-  protected async processDeleteSkipNote(change: SkipLearningCycleNoteChange, user: UserInfo): Promise<boolean> {
+  protected async processDeleteSkipNote(change: SkipLearningCycleNoteChange, user: UserInfo, userPayload: UserPayload): Promise<boolean> {
     // Get the note entity object
     const md = new Metadata();
     const noteEntity = await md.GetEntityObject<AIAgentNoteEntity>('AI Agent Notes', user);
@@ -843,7 +847,7 @@ cycle.`);
    * @param user User context for the operation
    * @returns ID of the created conversation detail, or empty string if creation failed
    */
-  protected async CreateAIMessageConversationDetail(apiResponse: SkipAPIResponse, conversationID: string, user: UserInfo): Promise<string> {
+  protected async CreateAIMessageConversationDetail(apiResponse: SkipAPIResponse, conversationID: string, user: UserInfo, userPayload: UserPayload): Promise<string> {
     const md = new Metadata();
     const convoDetailEntityAI = <ConversationDetailEntity>await md.GetEntityObject('Conversation Details', user);
     convoDetailEntityAI.NewRecord();
@@ -853,6 +857,7 @@ cycle.`);
     const lastSystemMessage = systemMessages[systemMessages.length - 1];
     convoDetailEntityAI.Message = lastSystemMessage?.content;
     convoDetailEntityAI.Role = 'AI';
+
     if (await convoDetailEntityAI.Save()) {
       return convoDetailEntityAI.ID;
     } else {
@@ -1287,7 +1292,7 @@ cycle.`);
     await dataContext.Load(DataContextId, dataSource, true, false, 0, user);
     const input = <SkipAPIRunScriptRequest>await this.buildSkipChatAPIRequest([], '', dataContext, 'run_existing_script', false, false, false, false, user, dataSource, false, false);
     input.scriptText = ScriptText;
-    return this.handleSimpleSkipChatPostRequest(input);
+    return this.handleSimpleSkipChatPostRequest(input, undefined, undefined, undefined, userPayload.userRecord, userPayload);
   }
 
   /**
@@ -1366,7 +1371,7 @@ cycle.`);
     );
 
     // Set the conversation status to 'Processing' when a request is initiated
-    await this.setConversationStatus(convoEntity, 'Processing');
+    await this.setConversationStatus(convoEntity, 'Processing', userPayload);
 
     // now load up the messages. We will load up ALL of the messages for this conversation, and then pass them to the Skip API
     const messages: SkipMessage[] = await this.LoadConversationDetailsIntoSkipMessages(
@@ -1455,7 +1460,19 @@ cycle.`);
             updatedAt: f.__mj_UpdatedAt,
           };
         }),
-      };
+        params: q.Parameters.map((p) => {
+          return {
+            id: p.ID,
+            name: p.Name,
+            description: p.Description,
+            type: p.Type,
+            isRequired: p.IsRequired,
+            defaultValue: p.DefaultValue,
+            createdAt: p.__mj_CreatedAt,
+            updatedAt: p.__mj_UpdatedAt,
+          };
+        })
+      }
     });
   }
 
@@ -1986,6 +2003,7 @@ cycle.`);
     convoDetailEntity.Message = UserQuestion;
     convoDetailEntity.Role = 'User';
     convoDetailEntity.HiddenToUser = false;
+
     let convoDetailSaveResult: boolean = await convoDetailEntity.Save();
     if (!convoDetailSaveResult) {
       LogError(`Error saving conversation detail entity for user message: ${UserQuestion}`, undefined, convoDetailEntity.LatestResult);
@@ -2162,7 +2180,7 @@ cycle.`);
 
     if (conversationDetailCount > 10) {
       // Set status of conversation to Available since we still want to allow the user to ask questions
-      await this.setConversationStatus(convoEntity, 'Available');
+      await this.setConversationStatus(convoEntity, 'Available', userPayload);
 
       // At this point it is likely that we are stuck in a loop, so we stop here
       pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
@@ -2222,7 +2240,7 @@ cycle.`);
       );
     } catch (error) {
       // Set conversation status to Available on error so user can try again
-      await this.setConversationStatus(convoEntity, 'Available');
+      await this.setConversationStatus(convoEntity, 'Available', userPayload);
       
       // Log the error for debugging
       LogError(`Error in HandleSkipChatRequest sendPostRequest: ${error}`);
@@ -2305,7 +2323,7 @@ cycle.`);
       }
     } else {
       // Set status of conversation to Available since we still want to allow the user to ask questions
-      await this.setConversationStatus(convoEntity, 'Available');
+      await this.setConversationStatus(convoEntity, 'Available', userPayload);
 
       pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
         message: JSON.stringify({
@@ -2477,7 +2495,7 @@ cycle.`);
     convoDetailEntityAI.CompletionTime = endTime.getTime() - startTime.getTime();
     
     // Set conversation status back to Available since we need user input for the clarifying question
-    await this.setConversationStatus(convoEntity, 'Available');
+    await this.setConversationStatus(convoEntity, 'Available', userPayload);
     
     if (await convoDetailEntityAI.Save()) {
       return {
@@ -2765,6 +2783,7 @@ cycle.`);
         artifactVersionEntity.ConversationArtifactID = artifactId;
         artifactVersionEntity.Version = newVersion;
         artifactVersionEntity.Configuration = sResult; // store the full response here
+
         if (await artifactVersionEntity.Save()) {
           // success saving the new version, set the artifactVersionId
           artifactVersionId = artifactVersionEntity.ID;
@@ -2792,6 +2811,7 @@ cycle.`);
         convoDetailEntityAI.ArtifactVersionID = artifactVersionId;
       }
     }    
+
     const convoDetailSaveResult: boolean = await convoDetailEntityAI.Save();
     if (!convoDetailSaveResult) {
       LogError(`Error saving conversation detail entity for AI message: ${sResult}`, undefined, convoDetailEntityAI.LatestResult);
@@ -2872,9 +2892,10 @@ cycle.`);
     };
   }
 
-  private async setConversationStatus(convoEntity: ConversationEntity, status: 'Processing' | 'Available'): Promise<boolean> {
+  private async setConversationStatus(convoEntity: ConversationEntity, status: 'Processing' | 'Available', userPayload: UserPayload): Promise<boolean> {
     if (convoEntity.Status !== status) {
     convoEntity.Status = status;
+
     const convoSaveResult = await convoEntity.Save();
     if (!convoSaveResult) {
       LogError(`Error updating conversation status to '${status}'`, undefined, convoEntity.LatestResult);

package/src/resolvers/CreateQueryResolver.ts

@@ -1,10 +1,10 @@
 import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType, Resolver, PubSub, PubSubEngine } from 'type-graphql';
-import { AppContext } from '../types.js';
-import { LogError, Metadata, RunView, UserInfo, CompositeKey } from '@memberjunction/core';
+import { AppContext, UserPayload } from '../types.js';
+import { LogError, Metadata, RunView, UserInfo, CompositeKey, EntitySaveOptions } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { QueryCategoryEntity } from '@memberjunction/core-entities';
 import { QueryResolver } from '../generated/generated.js';
-import { GetReadWriteDataSource } from '../util.js';
+import { GetReadWriteProvider } from '../util.js';
 import { DeleteOptionsInput } from '../generic/DeleteOptionsInput.js';
 
 /**
@@ -108,7 +108,7 @@ export class QueryResolverExtended extends QueryResolver {
             let finalCategoryID = input.CategoryID;
             if (input.CategoryPath) {
                 const md = new Metadata();
-                finalCategoryID = await this.findOrCreateCategoryPath(input.CategoryPath, md, context.userPayload.userRecord);
+                finalCategoryID = await this.findOrCreateCategoryPath(input.CategoryPath, md, context.userPayload.userRecord, context.userPayload);
             }
 
             // Create input for the inherited CreateRecord method
@@ -128,8 +128,8 @@ export class QueryResolverExtended extends QueryResolver {
             };
             
             // Use inherited CreateRecord method which bypasses AI processing
-            const connPool = GetReadWriteDataSource(context.dataSources);
-            const createdQuery = await this.CreateRecord('Queries', createInput, connPool, context.userPayload, pubSub);
+            const provider = GetReadWriteProvider(context.providers);    
+            const createdQuery = await this.CreateRecord('Queries', createInput, provider, context.userPayload, pubSub);
             
             if (createdQuery) {
                 return {
@@ -162,14 +162,22 @@ export class QueryResolverExtended extends QueryResolver {
     @RequireSystemUser()
     @Mutation(() => DeleteQueryResultType)
     async DeleteQuerySystemResolver(
-        @Arg('ID', () => String) queryID: string,
+        @Arg('ID', () => String) ID: string,
         @Arg('options', () => DeleteOptionsInput, { nullable: true }) options: DeleteOptionsInput | null,
         @Ctx() context: AppContext,
         @PubSub() pubSub: PubSubEngine
     ): Promise<DeleteQueryResultType> {
         try {
-            const connPool = GetReadWriteDataSource(context.dataSources);
-            const key = new CompositeKey([{FieldName: 'ID', Value: queryID}]);
+            // Validate ID is not null/undefined/empty
+            if (!ID || ID.trim() === '') {
+                return {
+                    Success: false,
+                    ErrorMessage: 'QueryResolverExtended::DeleteQuerySystemResolver --- Invalid query ID: ID cannot be null or empty'
+                };
+            }
+
+            const provider = GetReadWriteProvider(context.providers);    
+            const key = new CompositeKey([{FieldName: 'ID', Value: ID}]);
             
             // Provide default options if none provided
             const deleteOptions = options || {
@@ -178,7 +186,7 @@ export class QueryResolverExtended extends QueryResolver {
             };
             
             // Use inherited DeleteRecord method from ResolverBase
-            const deletedQuery = await this.DeleteRecord('Queries', key, deleteOptions, connPool, context.userPayload, pubSub);
+            const deletedQuery = await this.DeleteRecord('Queries', key, deleteOptions, provider, context.userPayload, pubSub);
             
             if (deletedQuery) {
                 return {
@@ -209,7 +217,7 @@ export class QueryResolverExtended extends QueryResolver {
      * @param contextUser - User context for operations
      * @returns The ID of the final category in the path
      */
-    private async findOrCreateCategoryPath(categoryPath: string, md: Metadata, contextUser: UserInfo): Promise<string> {
+    private async findOrCreateCategoryPath(categoryPath: string, md: Metadata, contextUser: UserInfo, userPayload: UserPayload): Promise<string> {
         if (!categoryPath || categoryPath.trim() === '') {
             throw new Error('CategoryPath cannot be empty');
         }

package/src/resolvers/EntityResolver.ts

@@ -1,19 +1,21 @@
-import { EntityPermissionType } from '@memberjunction/core';
+import { EntityPermissionType, IRunViewProvider } from '@memberjunction/core';
 import { AppContext } from '../types.js';
 import { Arg, Ctx, Query, Resolver, InputType, Field } from 'type-graphql';
 import { Entity_, EntityResolverBase } from '../generated/generated.js';
 import sql from 'mssql';
+import { GetReadOnlyProvider } from '../util.js';
 
 @Resolver(Entity_)
 export class EntityResolver extends EntityResolverBase {
   @Query(() => [Entity_])
   async EntitiesBySchemas(
-    @Ctx() { dataSource, userPayload }: AppContext,
+    @Ctx() { providers, userPayload }: AppContext,
     @Arg('IncludeSchemas', () => [String], { nullable: true }) IncludeSchemas?: string[],
     @Arg('ExcludeSchemas', () => [String], { nullable: true }) ExcludeSchemas?: string[]
   ) {
     this.CheckUserReadPermissions('Entities', userPayload);
-    const rlsWhere = this.getRowLevelSecurityWhereClause('Entities', userPayload, EntityPermissionType.Read, ' WHERE');
+    const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+    const rlsWhere = this.getRowLevelSecurityWhereClause(provider, 'Entities', userPayload, EntityPermissionType.Read, ' WHERE');
     const includeSchemaSQL =
       IncludeSchemas && IncludeSchemas.length > 0 ? `SchemaName IN (${IncludeSchemas.map((s) => `'${s}'`).join(',')})` : '';
     const excludeSchemaSQL =
@@ -25,14 +27,21 @@ export class EntityResolver extends EntityResolverBase {
       else schemaSQL = excludeSchemaSQL;
     }
     let totalWhere = '';
-    if (schemaSQL) totalWhere = ` WHERE ${schemaSQL}`;
+    if (schemaSQL) totalWhere = `${schemaSQL}`;
     if (rlsWhere) {
       if (totalWhere) totalWhere = `${totalWhere} AND ${rlsWhere}`;
-      else totalWhere = ` WHERE ${rlsWhere}`;
+      else totalWhere = ` ${rlsWhere}`;
+    }
+    const rv = provider as any as IRunViewProvider;
+    const result = await rv.RunView({
+      EntityName: 'Entities',
+      ExtraFilter: totalWhere,
+    }, userPayload.userRecord);
+    if (result && result.Success) {
+      return result.Results;
+    }
+    else {
+      throw new Error(`Failed to fetch entities: ${result?.ErrorMessage || 'Unknown error'}`);
     }
-    const sSQL = `SELECT * FROM [${this.MJCoreSchema}].vwEntities${totalWhere}`;
-    const request = new sql.Request(dataSource);
-    const result = await request.query(sSQL);
-    return result.recordset;
   }
 }

package/src/resolvers/FileCategoryResolver.ts

@@ -1,20 +1,24 @@
-import { CompositeKey, EntityPermissionType, Metadata, RunView } from '@memberjunction/core';
+import { CompositeKey, EntityDeleteOptions, EntityPermissionType, EntitySaveOptions, Metadata, RunView } from '@memberjunction/core';
 import { FileCategoryEntity, FileEntity } from '@memberjunction/core-entities';
 import { AppContext, Arg, Ctx, DeleteOptionsInput, Int, Mutation } from '@memberjunction/server';
 import { mj_core_schema } from '../config.js';
 import { FileCategoryResolver as FileCategoryResolverBase, FileCategory_ } from '../generated/generated.js';
 import sql from 'mssql';
+import { SQLServerDataProvider } from '@memberjunction/sqlserver-dataprovider';
+import { GetReadWriteProvider } from '../util.js';
 
 export class FileResolver extends FileCategoryResolverBase {
   @Mutation(() => FileCategory_)
   async DeleteFileCategory(
     @Arg('ID', () => String) ID: string,
     @Arg('options___', () => DeleteOptionsInput) options: DeleteOptionsInput,
-    @Ctx() { dataSource, userPayload }: AppContext
+    @Ctx() { providers, userPayload }: AppContext
   ) {
     const key = new CompositeKey();
     key.LoadFromSingleKeyValuePair('ID', ID);
-    if (!(await this.BeforeDelete(dataSource, key))) {
+    const provider = GetReadWriteProvider(providers);    
+
+    if (!(await this.BeforeDelete(provider, key))) {
       return null;
     }
 
@@ -30,8 +34,7 @@ export class FileResolver extends FileCategoryResolverBase {
     const returnValue = fileCategoryEntity.GetAll();
 
     // Any files using the deleted category fall back to its parent
-    const transaction = new sql.Transaction(dataSource);
-    await transaction.begin();
+    await provider.BeginTransaction();
     try {
       // SHOULD USE BaseEntity for each of these records to ensure object model
       // is used everywhere - new code below. The below is SLOWER than a single
@@ -63,14 +66,14 @@ export class FileResolver extends FileCategoryResolverBase {
           await fileEntity.Save();
         }
       }
-      await fileCategoryEntity.Delete();
-      await transaction.commit();
+      await fileCategoryEntity.Delete(options);
+      await provider.CommitTransaction();
     } catch (error) {
-      await transaction.rollback();
+      await provider.RollbackTransaction();
       throw error;
     }
 
-    await this.AfterDelete(dataSource, key); // fire event
+    await this.AfterDelete(provider, key); // fire event
     return returnValue;
   }
 }

package/src/resolvers/FileResolver.ts

@@ -1,4 +1,4 @@
-import { EntityPermissionType, Metadata, FieldValueCollection } from '@memberjunction/core';
+import { EntityPermissionType, Metadata, FieldValueCollection, EntitySaveOptions } from '@memberjunction/core';
 import { FileEntity, FileStorageProviderEntity } from '@memberjunction/core-entities';
 import {
   AppContext,
@@ -19,6 +19,7 @@ import {
 import { createDownloadUrl, createUploadUrl, deleteObject, moveObject } from '@memberjunction/storage';
 import { CreateFileInput, FileResolver as FileResolverBase, File_, UpdateFileInput } from '../generated/generated.js';
 import { FieldMapper } from '@memberjunction/graphql-dataprovider';
+import { GetReadOnlyProvider } from '../util.js';
 
 @InputType()
 export class CreateUploadURLInput {
@@ -57,8 +58,9 @@ export class FileResolver extends FileResolverBase {
     fileEntity.CheckPermissions(EntityPermissionType.Create, true);
 
     // Check to see if there's already an object with that name
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true})    
     const [sameName] = await this.findBy(
-      context.dataSource,
+      provider,
       'Files',
       { Name: input.Name, ProviderID: input.ProviderID },
       context.userPayload.userRecord

package/src/resolvers/MergeRecordsResolver.ts

@@ -163,7 +163,8 @@ export class RecordMergeResolver {
   ) {
     try {
       const md = new Metadata();
-      const result = await md.MergeRecords(request, userPayload.userRecord);
+      const options = {};
+      const result = await md.MergeRecords(request, userPayload.userRecord, options);
       return result;
     } catch (e) {
       LogError(e);

package/src/resolvers/ReportResolver.ts

@@ -1,4 +1,4 @@
-import { Metadata, RunReport } from '@memberjunction/core';
+import { EntitySaveOptions, Metadata, RunReport } from '@memberjunction/core';
 import { Arg, Ctx, Field, Int, Mutation, ObjectType, Query, Resolver } from 'type-graphql';
 import { AppContext } from '../types.js';
 import { ConversationDetailEntity, ReportEntity } from '@memberjunction/core-entities';

package/src/resolvers/SyncDataResolver.ts

@@ -1,6 +1,6 @@
 import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType } from 'type-graphql';
-import { AppContext } from '../types.js';
-import { BaseEntity, CompositeKey, LogError, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { AppContext, UserPayload } from '../types.js';
+import { BaseEntity, CompositeKey, EntityDeleteOptions, EntitySaveOptions, LogError, Metadata, RunView, UserInfo } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { CompositeKeyInputType, CompositeKeyOutputType } from '../generic/KeyInputOutputTypes.js';
 import { DatasetItemEntity } from '@memberjunction/core-entities';
@@ -115,7 +115,7 @@ export class SyncDataResolver {
             const md = new Metadata();
             const results: ActionItemOutputType[] = [];
             for (const item of items) {
-                results.push(await this.SyncSingleItem(item, context, md)); 
+                results.push(await this.SyncSingleItem(item, context, md, context.userPayload)); 
             }
 
             if (await this.DoSyncItemsAffectMetadata(context.userPayload.userRecord, items)) {
@@ -160,7 +160,7 @@ export class SyncDataResolver {
         return false; // didn't find any
     }
 
-    protected async SyncSingleItem(item: ActionItemInputType, context: AppContext, md: Metadata): Promise<ActionItemOutputType> {
+    protected async SyncSingleItem(item: ActionItemInputType, context: AppContext, md: Metadata, userPayload: UserPayload): Promise<ActionItemOutputType> {
         const result = new ActionItemOutputType();
         result.AlternateKey = item.AlternateKey;
         result.PrimaryKey = item.PrimaryKey;
@@ -179,20 +179,20 @@ export class SyncDataResolver {
                 const fieldValues = item.RecordJSON ? JSON.parse(item.RecordJSON) : {};
                 switch (item.Type) {
                     case SyncDataActionType.Create:
-                        await this.SyncSingleItemCreate(entityObject, fieldValues, result);
+                        await this.SyncSingleItemCreate(entityObject, fieldValues, result, userPayload);
                         break;
                     case SyncDataActionType.Update:
-                        await this.SyncSingleItemUpdate(entityObject, pk, ak, fieldValues, result);
+                        await this.SyncSingleItemUpdate(entityObject, pk, ak, fieldValues, result, userPayload);
                         break;
                     case SyncDataActionType.CreateOrUpdate:
                         // in this case we attempt to load the item first, if it is not possible to load the item, then we create it
-                        await this.SyncSingleItemCreateOrUpdate(entityObject, pk, ak, fieldValues, result);
+                        await this.SyncSingleItemCreateOrUpdate(entityObject, pk, ak, fieldValues, result, userPayload);
                         break;
                     case SyncDataActionType.Delete:
-                        await this.SyncSingleItemDelete(entityObject, pk, ak, result);
+                        await this.SyncSingleItemDelete(entityObject, pk, ak, result, userPayload);
                         break;
                     case SyncDataActionType.DeleteWithFilter:
-                        await this.SyncSingleItemDeleteWithFilter(item.EntityName, item.DeleteFilter, result, context.userPayload.userRecord);
+                        await this.SyncSingleItemDeleteWithFilter(item.EntityName, item.DeleteFilter, result, context.userPayload.userRecord, userPayload);
                         break;
                     default:
                         throw new Error('Invalid SyncDataActionType');
@@ -211,7 +211,7 @@ export class SyncDataResolver {
     }
 
 
-    protected async SyncSingleItemDeleteWithFilter(entityName: string, filter: string, result: ActionItemOutputType, user: UserInfo) {
+    protected async SyncSingleItemDeleteWithFilter(entityName: string, filter: string, result: ActionItemOutputType, user: UserInfo, userPayload: UserPayload) {
         try {
             // here we will iterate through the result of a RunView on the entityname/filter and delete each matching record
             let overallSuccess: boolean = true;
@@ -273,30 +273,30 @@ export class SyncDataResolver {
         }
     }
 
-    protected async SyncSingleItemCreateOrUpdate(entityObject: BaseEntity, pk: CompositeKey, ak: CompositeKey, fieldValues: any, result: ActionItemOutputType) {
+    protected async SyncSingleItemCreateOrUpdate(entityObject: BaseEntity, pk: CompositeKey, ak: CompositeKey, fieldValues: any, result: ActionItemOutputType, userPayload: UserPayload) {
         if (!pk || pk.KeyValuePairs.length === 0) {
             // no primary key try to load from alt key
             const altKeyResult = await this.LoadFromAlternateKey(entityObject.EntityInfo.Name, ak, entityObject.ContextCurrentUser);
             if (!altKeyResult) {
                 // no record found, create a new one
-                await this.SyncSingleItemCreate(entityObject, fieldValues, result);
+                await this.SyncSingleItemCreate(entityObject, fieldValues, result, userPayload);
             }
             else {
-                await this.InnerSyncSingleItemUpdate(altKeyResult, fieldValues, result);
+                await this.InnerSyncSingleItemUpdate(altKeyResult, fieldValues, result, userPayload);
             }
         }
         else {
             // have a primary key do the usual load
             if (await entityObject.InnerLoad(pk)) {
-                await this.InnerSyncSingleItemUpdate(entityObject, fieldValues, result);
+                await this.InnerSyncSingleItemUpdate(entityObject, fieldValues, result, userPayload);
             }
             else {
-                await this.SyncSingleItemCreate(entityObject, fieldValues, result);
+                await this.SyncSingleItemCreate(entityObject, fieldValues, result, userPayload);
             }    
         }
     }
 
-    protected async SyncSingleItemDelete(entityObject: BaseEntity, pk: CompositeKey, ak: CompositeKey, result: ActionItemOutputType) {
+    protected async SyncSingleItemDelete(entityObject: BaseEntity, pk: CompositeKey, ak: CompositeKey, result: ActionItemOutputType, userPayload: UserPayload) {
         if (!pk || pk.KeyValuePairs.length === 0) {
             const altKeyResult = await this.LoadFromAlternateKey(entityObject.EntityInfo.Name, ak, entityObject.ContextCurrentUser);
             if (!altKeyResult) {
@@ -342,7 +342,7 @@ export class SyncDataResolver {
         }
     }
 
-    protected async SyncSingleItemCreate(entityObject: BaseEntity, fieldValues: any, result: ActionItemOutputType) {
+    protected async SyncSingleItemCreate(entityObject: BaseEntity, fieldValues: any, result: ActionItemOutputType, userPayload: UserPayload) {
         // make sure we strip out the primary key from fieldValues before we pass it in because otherwise it will appear to be an existing record to the BaseEntity
         const noPKValues = {...fieldValues};
         entityObject.EntityInfo.PrimaryKeys.forEach((pk) => {
@@ -367,7 +367,7 @@ export class SyncDataResolver {
         }
     }
 
-    protected async SyncSingleItemUpdate(entityObject: BaseEntity, pk: CompositeKey, ak: CompositeKey, fieldValues: any, result: ActionItemOutputType) {
+    protected async SyncSingleItemUpdate(entityObject: BaseEntity, pk: CompositeKey, ak: CompositeKey, fieldValues: any, result: ActionItemOutputType, userPayload: UserPayload) {
         if (!pk || pk.KeyValuePairs.length === 0) {
             // no pk, attempt to load by alt key
             const altKeyResult = await this.LoadFromAlternateKey(entityObject.EntityInfo.Name, ak, entityObject.ContextCurrentUser);
@@ -376,11 +376,11 @@ export class SyncDataResolver {
                 result.ErrorMessage = 'Failed to load the item, it is possible the record with the specified alternate key does not exist';
             }
             else {
-                await this.InnerSyncSingleItemUpdate(altKeyResult, fieldValues, result);
+                await this.InnerSyncSingleItemUpdate(altKeyResult, fieldValues, result, userPayload);
             }
         }
         else if (await entityObject.InnerLoad(pk)) {
-            await this.InnerSyncSingleItemUpdate(entityObject, fieldValues, result);
+            await this.InnerSyncSingleItemUpdate(entityObject, fieldValues, result, userPayload);
         }
         else {
             // failed to load the item
@@ -388,7 +388,7 @@ export class SyncDataResolver {
         }
     }
 
-    protected async InnerSyncSingleItemUpdate(entityObject: BaseEntity, fieldValues: any, result: ActionItemOutputType) {
+    protected async InnerSyncSingleItemUpdate(entityObject: BaseEntity, fieldValues: any, result: ActionItemOutputType, userPayload: UserPayload) {
         entityObject.SetMany(fieldValues);
         if (await entityObject.Save()) {
             result.Success = true;