@memberjunction/server 2.75.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,8 +1,11 @@
-import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType } from 'type-graphql';
-import { AppContext } from '../types.js';
-import { LogError, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType, Resolver, PubSub, PubSubEngine } from 'type-graphql';
+import { AppContext, UserPayload } from '../types.js';
+import { LogError, Metadata, RunView, UserInfo, CompositeKey, EntitySaveOptions } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
-import { QueryEntity, QueryCategoryEntity } from '@memberjunction/core-entities';
+import { QueryCategoryEntity } from '@memberjunction/core-entities';
+import { QueryResolver } from '../generated/generated.js';
+import { GetReadWriteProvider } from '../util.js';
+import { DeleteOptionsInput } from '../generic/DeleteOptionsInput.js';
 
 /**
  * Query status enumeration for GraphQL
@@ -20,7 +23,7 @@ registerEnumType(QueryStatus, {
 });
 
 @InputType()
-export class CreateQueryInputType {
+export class CreateQuerySystemUserInput {
     @Field(() => String)
     Name!: string;
 
@@ -73,88 +76,127 @@ export class CreateQueryResultType {
     QueryData?: string;
 }
 
-export class CreateQueryResolver {
+@ObjectType()
+export class DeleteQueryResultType {
+    @Field(() => Boolean)
+    Success!: boolean;
+
+    @Field(() => String, { nullable: true })
+    ErrorMessage?: string;
+
+    @Field(() => String, { nullable: true })
+    QueryData?: string;
+}
+
+@Resolver()
+export class QueryResolverExtended extends QueryResolver {
     /**
      * Creates a new query with the provided attributes. This mutation is restricted to system users only.
-     * @param input - CreateQueryInputType containing all the query attributes
+     * @param input - CreateQuerySystemUserInput containing all the query attributes
      * @param context - Application context containing user information
      * @returns CreateQueryResultType with success status and query data
      */
     @RequireSystemUser()
     @Mutation(() => CreateQueryResultType)
-    async CreateQuery(
-        @Arg('input', () => CreateQueryInputType) input: CreateQueryInputType,
-        @Ctx() context: AppContext
+    async CreateQuerySystemUser(
+        @Arg('input', () => CreateQuerySystemUserInput) input: CreateQuerySystemUserInput,
+        @Ctx() context: AppContext,
+        @PubSub() pubSub: PubSubEngine
     ): Promise<CreateQueryResultType> {
         try {
-            const md = new Metadata();
-            const newQuery = await md.GetEntityObject<QueryEntity>("Queries", context.userPayload.userRecord);
-
             // Handle CategoryPath if provided
             let finalCategoryID = input.CategoryID;
             if (input.CategoryPath) {
-                finalCategoryID = await this.findOrCreateCategoryPath(input.CategoryPath, md, context.userPayload.userRecord);
+                const md = new Metadata();
+                finalCategoryID = await this.findOrCreateCategoryPath(input.CategoryPath, md, context.userPayload.userRecord, context.userPayload);
             }
 
-            // Populate the query fields from input
-            newQuery.Name = input.Name;
-            
-            if (finalCategoryID != null) {
-                newQuery.CategoryID = finalCategoryID;
-            }
-            
-            if (input.UserQuestion != null) {
-                newQuery.UserQuestion = input.UserQuestion;
-            }
-            
-            if (input.Description != null) {
-                newQuery.Description = input.Description;
-            }
-            
-            if (input.SQL != null) {
-                newQuery.SQL = input.SQL;
-            }
-            
-            if (input.TechnicalDescription != null) {
-                newQuery.TechnicalDescription = input.TechnicalDescription;
-            }
+            // Create input for the inherited CreateRecord method
+            const createInput = {
+                Name: input.Name,
+                CategoryID: finalCategoryID,
+                UserQuestion: input.UserQuestion,
+                Description: input.Description,
+                SQL: input.SQL,
+                TechnicalDescription: input.TechnicalDescription,
+                OriginalSQL: input.OriginalSQL,
+                Feedback: input.Feedback,
+                Status: input.Status || 'Approved',
+                QualityRank: input.QualityRank || 0,
+                ExecutionCostRank: input.ExecutionCostRank,
+                UsesTemplate: input.UsesTemplate || false
+            };
             
-            if (input.OriginalSQL != null) {
-                newQuery.OriginalSQL = input.OriginalSQL;
-            }
+            // Use inherited CreateRecord method which bypasses AI processing
+            const provider = GetReadWriteProvider(context.providers);    
+            const createdQuery = await this.CreateRecord('Queries', createInput, provider, context.userPayload, pubSub);
             
-            if (input.Feedback != null) {
-                newQuery.Feedback = input.Feedback;
-            }
-            
-            if (input.Status != null) {
-                newQuery.Status = input.Status;
+            if (createdQuery) {
+                return {
+                    Success: true,
+                    QueryData: JSON.stringify(createdQuery)
+                };
+            } else {
+                return {
+                    Success: false,
+                    ErrorMessage: 'Failed to create query using CreateRecord method'
+                };
             }
-            
-            if (input.QualityRank != null) {
-                newQuery.QualityRank = input.QualityRank;
+
+        } catch (err) {
+            LogError(err);
+            return {
+                Success: false,
+                ErrorMessage: `QueryResolverExtended::CreateQuerySystemUser --- Error creating query: ${err instanceof Error ? err.message : String(err)}`
+            };
+        }
+    }
+
+    /**
+     * Deletes a query by ID. This mutation is restricted to system users only.
+     * @param ID - The ID of the query to delete
+     * @param options - Delete options controlling action execution
+     * @param context - Application context containing user information
+     * @returns DeleteQueryResultType with success status and deleted query data
+     */
+    @RequireSystemUser()
+    @Mutation(() => DeleteQueryResultType)
+    async DeleteQuerySystemResolver(
+        @Arg('ID', () => String) ID: string,
+        @Arg('options', () => DeleteOptionsInput, { nullable: true }) options: DeleteOptionsInput | null,
+        @Ctx() context: AppContext,
+        @PubSub() pubSub: PubSubEngine
+    ): Promise<DeleteQueryResultType> {
+        try {
+            // 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}]);
             
-            if (input.ExecutionCostRank != null) {
-                newQuery.ExecutionCostRank = input.ExecutionCostRank;
-            }
+            // Provide default options if none provided
+            const deleteOptions = options || {
+                SkipEntityAIActions: false,
+                SkipEntityActions: false
+            };
             
-            if (input.UsesTemplate != null) {
-                newQuery.UsesTemplate = input.UsesTemplate;
-            }
-
-            // Save the query
-            const saveResult = await newQuery.Save();
+            // Use inherited DeleteRecord method from ResolverBase
+            const deletedQuery = await this.DeleteRecord('Queries', key, deleteOptions, provider, context.userPayload, pubSub);
             
-            if (saveResult) {
+            if (deletedQuery) {
                 return {
                     Success: true,
-                    QueryData: JSON.stringify(newQuery.GetAll())
+                    QueryData: JSON.stringify(deletedQuery)
                 };
             } else {
                 return {
                     Success: false,
-                    ErrorMessage: `Failed to save query: ${newQuery.LatestResult?.Message || 'Unknown error'}`
+                    ErrorMessage: 'Failed to delete query using DeleteRecord method'
                 };
             }
 
@@ -162,7 +204,7 @@ export class CreateQueryResolver {
             LogError(err);
             return {
                 Success: false,
-                ErrorMessage: `CreateQueryResolver::CreateQuery --- Error creating query: ${err instanceof Error ? err.message : String(err)}`
+                ErrorMessage: `QueryResolverExtended::DeleteQuerySystemResolver --- Error deleting query: ${err instanceof Error ? err.message : String(err)}`
             };
         }
     }
@@ -175,7 +217,7 @@ export class CreateQueryResolver {
      * @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/GetDataResolver.ts

@@ -264,6 +264,9 @@ export function isTokenValid(token: string) {
 export function recordTokenUse(token: string, usePayload: any) {
     const t = __accessTokens.find((t) => t.Token === token);
     if (t) {
+        if (!t.TokenUses) {
+            t.TokenUses = [];
+        }
         t.TokenUses.push({ Token: token, UsedAt: new Date(), UsePayload: usePayload });
     }
     else {

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);