@memberjunction/server 1.3.3 → 1.4.1

package/src/generic/DeleteOptionsInput.ts

@@ -0,0 +1,13 @@
+import { Field, InputType } from "type-graphql";
+
+/**
+ * GraphQL InputType for the DeleteOptions 
+ */
+@InputType()
+export class DeleteOptionsInput {
+    @Field(() => Boolean)
+    SkipEntityAIActions: boolean;
+    
+    @Field(() => Boolean) 
+    SkipEntityActions: boolean;
+}

package/src/generic/KeyInputOutputTypes.ts

@@ -0,0 +1,35 @@
+import { KeyValuePair } from "@memberjunction/core";
+import { Field, InputType, ObjectType } from "type-graphql";
+
+
+
+@InputType()
+export class KeyValuePairInputType {
+  @Field(() => String)
+  FieldName: string;
+
+  @Field(() => String)
+  Value: string;
+}
+
+@ObjectType()
+export class KeyValuePairOutputType {
+  @Field(() => String)
+  FieldName: string;
+
+  @Field(() => String)
+  Value: string;
+}
+ 
+
+@InputType()
+export class CompositeKeyInputType {
+  @Field(() => [KeyValuePairInputType])
+  KeyValuePairs: KeyValuePair[];
+}
+
+@ObjectType()
+export class CompositeKeyOutputType {
+  @Field(() => [KeyValuePairOutputType])
+  KeyValuePairs: KeyValuePair[];
+}

package/src/generic/KeyValuePairInput.ts

@@ -0,0 +1,14 @@
+import { Field, InputType } from "type-graphql";
+
+/**
+ * GraphQL InputType for the KeyValuePairInput - used for various situations where an input
+ * is required that has a combination of Key/Value pairs
+ */
+@InputType()
+export class KeyValuePairInput {
+    @Field(() => String)
+    Key: string;
+    
+    @Field(() => String, { nullable: true})
+    Value?: string;
+}

package/src/generic/ResolverBase.ts

@@ -1,11 +1,15 @@
-import { EntityPermissionType, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { BaseEntity, CompositeKey, EntityFieldTSType, EntityPermissionType, Metadata, RunView, UserInfo } from '@memberjunction/core';
 import { AuditLogEntity, UserViewEntity } from '@memberjunction/core-entities';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { PubSubEngine } from 'type-graphql';
+import { GraphQLError } from 'graphql';
 import { DataSource } from 'typeorm';
 
 import { UserPayload } from '../types';
 import { RunDynamicViewInput, RunViewByIDInput, RunViewByNameInput } from './RunViewResolver';
+import { DeleteOptionsInput } from './DeleteOptionsInput';
+import { MJGlobal } from '@memberjunction/global';
+import { PUSH_STATUS_UPDATES_TOPIC } from './PushStatusResolver';
 
 export class ResolverBase {
 
@@ -348,4 +352,238 @@ export class ResolverBase {
   public get MJCoreSchema(): string {
     return Metadata.Provider.ConfigData.MJCoreSchemaName;
   }
+
+  protected ListenForEntityMessages(entityObject: BaseEntity, pubSub: PubSubEngine, userPayload: UserPayload) {
+    // listen for events from the entityObject in case it is a long running task and we can push messages back to the client via pubSub
+    MJGlobal.Instance.GetEventListener(false).subscribe((event) => {
+      if (event) {
+        if (event.component === entityObject && event.args && event.args.message) {
+          // message from our entity object, relay it to the client
+          pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+            message: JSON.stringify({
+              status: 'OK',
+              type: 'EntityObjectStatusMessage',
+              entityName: entityObject.EntityInfo.Name,
+              primaryKey: entityObject.PrimaryKey,
+              message: event.args.message 
+            }),
+            sessionId: userPayload.sessionId
+          });          
+        }
+      }
+    });
+  }
+
+  protected async CreateRecord(entityName: string, input: any, dataSource: DataSource, userPayload: UserPayload, pubSub: PubSubEngine) {
+    if (await this.BeforeCreate(dataSource, input)) { // fire event and proceed if it wasn't cancelled
+        const entityObject = await new Metadata().GetEntityObject(entityName, this.GetUserFromPayload(userPayload));
+        entityObject.NewRecord();
+        entityObject.SetMany(input);
+
+        this.ListenForEntityMessages(entityObject, pubSub, userPayload);
+
+        if (await entityObject.Save()) {
+            // save worked, fire the AfterCreate event and then return all the data
+            await this.AfterCreate(dataSource, input); // fire event
+            return entityObject.GetAll();
+        }
+        else 
+            // save failed, return null
+            throw entityObject.LatestResult.Message;
+    }
+    else    
+        return null;
+  }
+
+  // Before/After CREATE Event Hooks for Sub-Classes to Override
+  protected async BeforeCreate(dataSource: DataSource, input: any): Promise<boolean> {
+      return true;
+  }
+  protected async AfterCreate(dataSource: DataSource, input: any) {
+  }  
+
+
+  protected async UpdateRecord(entityName: string, input: any, dataSource: DataSource, userPayload: UserPayload, pubSub: PubSubEngine) {
+      if (await this.BeforeUpdate(dataSource, input)) { // fire event and proceed if it wasn't cancelled
+        const md = new Metadata();
+        const userInfo = this.GetUserFromPayload(userPayload)
+        const entityObject = await md.GetEntityObject(entityName, userInfo);
+        const entityInfo = entityObject.EntityInfo;
+        const clientNewValues = {};
+        Object.keys(input).forEach((key) => { if (key !== 'OldValues___') clientNewValues[key] = input[key]; }); // grab all the props except for the OldValues property
+
+        if (entityInfo.TrackRecordChanges || !input.OldValues___) {
+          // the entity tracks record changes, so we need to load the old values from the DB to make sure they are not inconsistent
+          // with the old values from the input.OldValues property. If they are different, but on different fields, we allow it
+          // but if they are different on fields that the current UpdateRecord call is trying to update, we throw an error.
+          const cKey = new CompositeKey(entityInfo.PrimaryKeys.map((pk) => {
+            return { 
+              FieldName: pk.Name, 
+              Value: input[pk.CodeName]
+            }
+          }));
+
+          if (await entityObject.InnerLoad(cKey)) {
+            // load worked, now, if we HAVE OldValues, we need to check them against the values in the DB we just loaded. 
+            if (!input.OldValues___) {
+              // no OldValues, so we can just set the new values from input
+              entityObject.SetMany(input);
+            }
+            else {
+              // we DO have OldValues, so we need to do a more in depth analysis
+              this.TestAndSetClientOldValuesToDBValues(input, clientNewValues, entityObject);
+            }
+          }
+          else {
+            throw new Error(`Record not found for ${entityName} with key ${JSON.stringify(cKey)}`);
+          }
+        }
+        else {
+          // not tracking changes and we DO have OldValues, so we can load from them
+          const oldValues = {};
+          // for each item in the oldValues array, add it to the oldValues object
+          input.OldValues___?.forEach((item) => oldValues[item.Key] = item.Value);
+
+          // 1) load the old values, this will be the initial state of the object
+          entityObject.LoadFromData(oldValues); 
+
+          // 2) set the new values from the input, not including the OldValues property
+          entityObject.SetMany(clientNewValues);  
+        }
+
+        this.ListenForEntityMessages(entityObject, pubSub, userPayload);
+        if (await entityObject.Save()) {
+          // save worked, fire afterevent and return all the data
+          await this.AfterUpdate(dataSource, input); // fire event
+          return entityObject.GetAll();
+        }
+        else {
+          // save failed, return null
+          throw new GraphQLError(entityObject.LatestResult?.Message ?? 'Unknown error', {
+            extensions: { code: 'SAVE_ENTITY_ERROR', entityName },
+          });
+        }
+      }
+      else
+          return null; // update canceled by the BeforeUpdate event, return null
+  }
+
+  /**
+   * This routine compares the OldValues property in the input object to the values in the DB that we just loaded. If there are differences, we need to check to see if the client 
+   * is trying to update any of those fields (e.g. overlap). If there is overlap, we throw an error. If there is no overlap, we can proceed with the update even if the DB Values
+   * and the ClientOldValues are not 100% the same, so long as there is no overlap in the specific FIELDS that are different.
+   * 
+   * ASSUMES: input object has an OldValues___ property that is an array of Key/Value pairs that represent the old values of the record that the client is trying to update.
+   */
+  protected TestAndSetClientOldValuesToDBValues(input: any, clientNewValues: any, entityObject: BaseEntity) {
+    // we have OldValues, so we need to compare them to the values we just loaded from the DB
+    const clientOldValues = {};
+    // for each item in the oldValues array, add it to the clientOldValues object
+    input.OldValues___.forEach((item) => {
+      // we need to do a quick transform on the values to make sure they match the TS Type for the given field because item.Value will always be a string
+      const field = entityObject.EntityInfo.Fields.find((f) => f.CodeName === item.Key);
+      let val = item.Value;
+      if ( (val === null || val === undefined) && field.DefaultValue !== null && field.DefaultValue !== undefined) 
+        val = field.DefaultValue; // set default value as the field was never set
+
+      if (field) {
+        switch (field.TSType) {
+          case EntityFieldTSType.Number:
+            val = val !== null && val !== undefined ? parseInt(val) : null;
+            break;
+          case EntityFieldTSType.Boolean:
+            val = (val === null || val === undefined || val === 'false' || val === '0' || parseInt(val) === 0) ? false : true;
+            break;
+          case EntityFieldTSType.Date:
+            val = val !== null && val !== undefined ? new Date(val) : null;
+            break;
+          default:
+            break; // already a string
+        }
+      }
+      clientOldValues[item.Key] = val
+    });
+
+    // clientOldValues now has all of the oldValues the CLIENT passed us. Now we need to build the same kind of object
+    // with the DB values
+    const dbValues = entityObject.GetAll();
+
+    // now we need to compare clientOldValues and dbValues and have a new array that has entries for any differences and have FieldName, clientOldValue and dbValue as properties
+    const dbDifferences = [];
+    Object.keys(clientOldValues).forEach((key) => {
+      const f = entityObject.EntityInfo.Fields.find((f) => f.CodeName === key);
+      if (clientOldValues[key] !== dbValues[key] && f && f.AllowUpdateAPI && !f.IsPrimaryKey ) {
+        // only include updateable fields
+        dbDifferences.push({
+          FieldName: key,
+          ClientOldValue: clientOldValues[key],
+          DBValue: dbValues[key]
+        });
+      }
+    });
+
+    if (dbDifferences.length > 0) {
+      // now we have an array of any dbDifferences with length > 0, between the clientOldValues and the dbValues, we need to check to see if any of the differences are on fields that the client is trying to update
+      // first step is to get clientNewValues into an object that is like clientOldValues, get the diff and then compare that diff to the differences array that shows diff between DB and ClientOld
+      const clientDifferences = [];
+      Object.keys(clientOldValues).forEach((key) => {
+        const f = entityObject.EntityInfo.Fields.find((f) => f.CodeName === key);
+        if (clientOldValues[key] !== clientNewValues[key] && f && f.AllowUpdateAPI && !f.IsPrimaryKey) {
+          // only include updateable fields
+          clientDifferences.push({
+            FieldName: key,
+            ClientOldValue: clientOldValues[key],
+            ClientNewValue: clientNewValues[key]
+          });
+        }
+      });
+
+      // now we have clientDifferences which shows what the client thinks they are changing. And, we have the dbDifferences array that shows changes between the clientOldValues and the dbValues
+      // if there is ANY overlap in the FIELDS that appear in both arrays, we need to throw an error
+      const overlap = clientDifferences.filter((cd) => dbDifferences.find((dd) => dd.FieldName === cd.FieldName));
+      if (overlap.length > 0) {
+        const msg = {
+          Message: 'Inconsistency between old values provided for changed fields, and the values of one or more of those fields in the database. Update operation cancelled.',
+          ClientDifferences: clientDifferences,
+          DBDifferences: dbDifferences,
+          Overlap: overlap
+        };
+        throw new Error(JSON.stringify(msg));
+      }
+    }
+
+    // If we get here that means we've not thrown an exception, so there is 
+    // NO OVERLAP, so we can set the new values from the data provided from the client now...
+    entityObject.SetMany(clientNewValues);
+  }
+
+  protected async DeleteRecord(entityName: string, key: CompositeKey, options: DeleteOptionsInput, dataSource: DataSource, userPayload: UserPayload, pubSub: PubSubEngine) {
+    if (await this.BeforeDelete(dataSource, key)) { // fire event and proceed if it wasn't cancelled
+        const entityObject = await new Metadata().GetEntityObject(entityName, this.GetUserFromPayload(userPayload));
+        await entityObject.InnerLoad(key);
+        const returnValue = entityObject.GetAll(); // grab the values before we delete so we can return last state before delete if we are successful.
+        if (await entityObject.Delete(options)) {
+            await this.AfterDelete(dataSource, key); // fire event
+            return returnValue;
+        }
+        else 
+            return null; // delete failed, this will cause an exception
+    }
+    else
+        return null; // BeforeDelete canceled the operation, this will cause an exception
+  }
+
+  // Before/After DELETE Event Hooks for Sub-Classes to Override
+  protected async BeforeDelete(dataSource: DataSource, key: CompositeKey,): Promise<boolean> {
+      return true;
+  }
+  protected async AfterDelete(dataSource: DataSource, key: CompositeKey,) {
+  }
+
+  // Before/After UPDATE Event Hooks for Sub-Classes to Override
+  protected async BeforeUpdate(dataSource: DataSource, input: any): Promise<boolean> {
+      return true;
+  }
+  protected async AfterUpdate(dataSource: DataSource, input: any) {
+  }  
 }

package/src/index.ts

@@ -24,6 +24,12 @@ import { contextFunction, getUserPayload } from './context';
 import { publicDirective } from './directives';
 import orm from './orm';
 
+import { LoadActionEntityServer } from '@memberjunction/actions';
+LoadActionEntityServer(); // prevent tree shaking for this dynamic module
+
+import { LoadGeneratedActions } from '@memberjunction/core-actions';
+LoadGeneratedActions(); // prevent tree shaking for this dynamic module
+
 const cacheRefreshInterval = configInfo.databaseSettings.metadataCacheRefreshInterval;
 
 export { MaxLength } from 'class-validator';
@@ -34,12 +40,16 @@ export * from './directives';
 export * from './entitySubclasses/userViewEntity.server';
 export * from './entitySubclasses/entityPermissions.server';
 export * from './entitySubclasses/DuplicateRunEntity.server';
+export * from './entitySubclasses/EntityBehavior.server';
 export * from './types';
 export { TokenExpiredError } from './auth';
 
 export * from './generic/PushStatusResolver';
 export * from './generic/ResolverBase';
 export * from './generic/RunViewResolver';
+export * from './generic/KeyValuePairInput';
+export * from './generic/KeyInputOutputTypes'
+export * from './generic/DeleteOptionsInput';
 
 export * from './resolvers/AskSkipResolver';
 export * from './resolvers/ColorResolver';

package/src/resolvers/AskSkipResolver.ts

@@ -18,8 +18,7 @@ import { registerEnumType } from "type-graphql";
 import { MJGlobal, CopyScalarsAndArrays } from '@memberjunction/global';
 import { sendPostRequest } from '../util';
 import { GetAIAPIKey } from '@memberjunction/ai';
-import { KeyValuePairInputType } from './MergeRecordsResolver';
-import { CompositeKeyInputType } from './PotentialDuplicateRecordResolver';
+import { CompositeKeyInputType } from '../generic/KeyInputOutputTypes';
 
 
 enum SkipResponsePhase {
@@ -74,7 +73,7 @@ export class AskSkipResolver {
   async ExecuteAskSkipRecordChat(@Arg('UserQuestion', () => String) UserQuestion: string,
                                  @Arg('ConversationId', () => Int) ConversationId: number,
                                  @Arg('EntityName', () => String) EntityName: string,
-                                 @Arg('CompositeKey', () => CompositeKeyInputType) CompositeKey: CompositeKeyInputType,
+                                 @Arg('CompositeKey', () => CompositeKeyInputType) compositeKey: CompositeKeyInputType,
                                  @Ctx() { dataSource, userPayload }: AppContext,
                                  @PubSub() pubSub: PubSubEngine) {
     // In this function we're simply going to call the Skip API and pass along the message from the user
@@ -97,7 +96,9 @@ export class AskSkipResolver {
       dci.DataContextID = dataContext.ID;
       dci.Type = 'single_record';
       dci.EntityID = md.Entities.find((e) => e.Name === EntityName)?.ID;
-      dci.RecordID = CompositeKey.Values();
+      const ck = new CompositeKey();
+      ck.KeyValuePairs = compositeKey.KeyValuePairs;
+      dci.RecordID = ck.Values();
       await dci.Save();
   
       await dataContext.Load(dataContext.ID, dataSource, false, true, 10, user); // load again because we added a new data context item  
@@ -105,7 +106,7 @@ export class AskSkipResolver {
 
       // also, in the situation for a new convo, we need to update the Conversation ID to have a LinkedEntity and LinkedRecord
       convoEntity.LinkedEntityID = dci.EntityID;
-      convoEntity.LinkedRecordID = CompositeKey.Values();
+      convoEntity.LinkedRecordID = ck.Values();
       convoEntity.DataContextID = dataContext.ID;
       await convoEntity.Save();
     } 
@@ -120,7 +121,7 @@ export class AskSkipResolver {
   }
 
   protected async handleSimpleSkipPostRequest(input: SkipAPIRequest, conversationID: number = 0, UserMessageConversationDetailId: number = 0, createAIMessageConversationDetail: boolean = false, user: UserInfo = null): Promise<AskSkipResultType> {
-    LogStatus(`   >>> Sending request to Skip API: ${___skipAPIurl}`)
+    LogStatus(`   >>> HandleSimpleSkipPostRequest Sending request to Skip API: ${___skipAPIurl}`);
 
     const response = await sendPostRequest(___skipAPIurl, input, true, null);
 
@@ -222,7 +223,11 @@ export class AskSkipResolver {
       {
         vendorDriverName: 'GroqLLM',
         apiKey: GetAIAPIKey('GroqLLM')
-      }
+      },
+      {
+        vendorDriverName: 'MistralLLM',
+        apiKey: GetAIAPIKey('MistralLLM')
+      },
     ];
   }
 
@@ -527,18 +532,34 @@ export class AskSkipResolver {
                                     ConversationId: number, userPayload: UserPayload, pubSub: PubSubEngine, md: Metadata, 
                                     convoEntity: ConversationEntity, convoDetailEntity: ConversationDetailEntity,
                                     dataContext: DataContext, dataContextEntity: DataContextEntity): Promise<AskSkipResultType> {
-    LogStatus(`   >>> Sending request to Skip API: ${___skipAPIurl}`)
+    LogStatus(`   >>> HandleSkipRequest: Sending request to Skip API: ${___skipAPIurl}`);
 
-    const response = await sendPostRequest(___skipAPIurl, input, true, null, (message) => {
-      if (message.type==='status_update')
+    const response = await sendPostRequest(___skipAPIurl, input, true, null, (message: 
+      {
+        type: string, 
+        value: {
+          success: boolean, 
+          error: string, 
+          responsePhase: string, 
+          messages: {
+            role: string, 
+            content: string
+          }[]
+        }
+      }) => {
+      LogStatus(JSON.stringify(message, null, 4));
+      if (message.type ==='status_update'){
         pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
           message: JSON.stringify({
             type: 'AskSkip',
             status: 'OK',
+            conversationID: ConversationId,
+            ResponsePhase: message.value.responsePhase,
             message: message.value.messages[0].content
           }),
-          sessionId: userPayload.sessionId,
+          sessionId: userPayload.sessionId
         });
+      }
     });
 
     if (response && response.length > 0) { // response.status === 200) {
@@ -546,7 +567,7 @@ export class AskSkipResolver {
       const apiResponse = <SkipAPIResponse>response[response.length - 1].value;
       //const apiResponse = <SkipAPIResponse>response.data;
       LogStatus(`  Skip API response: ${apiResponse.responsePhase}`)
-      this.PublishApiResponseUserUpdateMessage(apiResponse, userPayload, pubSub);
+      this.PublishApiResponseUserUpdateMessage(apiResponse, userPayload, ConversationId, pubSub);
 
       // now, based on the result type, we will either wait for the next phase or we will process the results
       if (apiResponse.responsePhase === 'data_request') {
@@ -569,9 +590,10 @@ export class AskSkipResolver {
         message: JSON.stringify({
           type: 'AskSkip',
           status: 'Error',
+          conversationID: ConversationId,
           message: 'Analysis failed to run, please try again later and if this continues, contact your support desk.',
         }),
-        sessionId: userPayload.sessionId,
+        sessionId: userPayload.sessionId
       });
 
       return {
@@ -586,7 +608,7 @@ export class AskSkipResolver {
     }
   }
 
-  protected async PublishApiResponseUserUpdateMessage(apiResponse: SkipAPIResponse, userPayload: UserPayload, pubSub: PubSubEngine) {
+  protected async PublishApiResponseUserUpdateMessage(apiResponse: SkipAPIResponse, userPayload: UserPayload, conversationID: number, pubSub: PubSubEngine) {
     let sUserMessage: string = '';
     switch (apiResponse.responsePhase) {
       case 'data_request':
@@ -606,9 +628,10 @@ export class AskSkipResolver {
       message: JSON.stringify({
         type: 'AskSkip',
         status: 'OK',
+        conversationID,
         message: sUserMessage,
       }),
-      sessionId: userPayload.sessionId,
+      sessionId: userPayload.sessionId
     });
   }
 
@@ -837,10 +860,11 @@ export class AskSkipResolver {
       message: JSON.stringify({
         type: 'UserNotifications',
         status: 'OK',
+        conversationID: convoEntity.ID,
         details: {
           action: 'create',
           recordId: userNotification.ID,
-        },
+        }
       }),
       sessionId: userPayload.sessionId,
     });

package/src/resolvers/EntityRecordNameResolver.ts

@@ -1,7 +1,10 @@
-import { Metadata, CompositeKey } from '@memberjunction/core';
+import { Metadata, CompositeKey, UserInfo } from '@memberjunction/core';
 import { Arg, Ctx, Field, InputType, ObjectType, Query, Resolver } from 'type-graphql';
 import { AppContext } from '../types';
-import { CompositeKeyInputType, CompositeKeyOutputType } from './PotentialDuplicateRecordResolver';
+import { CompositeKeyInputType, CompositeKeyOutputType } from '../generic/KeyInputOutputTypes';
+import { CommunicationEngine } from '@memberjunction/communication-core';
+import { DocumentationEngine } from '@memberjunction/doc-utils';
+import { TemplateEngineService } from '@memberjunction/templates';
 
 @InputType()
 export class EntityRecordNameInput {
@@ -35,11 +38,16 @@ export class EntityRecordNameResolver {
   @Query(() => EntityRecordNameResult)
   async GetEntityRecordName(
     @Arg('EntityName', () => String) EntityName: string,
-    @Arg('CompositeKey', () => CompositeKeyInputType) CompositeKey: CompositeKey,
-    @Ctx() {}: AppContext
+    @Arg('CompositeKey', () => CompositeKeyInputType) primaryKey: CompositeKey,
+    @Ctx() {userPayload}: AppContext
   ): Promise<EntityRecordNameResult> {
+    //TEMPORARY: test harness for communication framework - dumb place but quick test grounds, will delete
+    //this.TestCommunicationFramework(userPayload.userRecord, EntityName, primaryKey);
+    //this.TestDocLibraries(userPayload.userRecord);
+    //this.TestTemplates();
+
     const md = new Metadata();
-    return await this.InnerGetEntityRecordName(md, EntityName, CompositeKey);
+    return await this.InnerGetEntityRecordName(md, EntityName, primaryKey);
   }
 
   @Query(() => [EntityRecordNameResult])
@@ -55,23 +63,53 @@ export class EntityRecordNameResolver {
     return result;
   }
 
-  async InnerGetEntityRecordName(md: Metadata, EntityName: string, CompositeKey: CompositeKey): Promise<EntityRecordNameResult> {
+  async InnerGetEntityRecordName(md: Metadata, EntityName: string, primaryKey: CompositeKeyInputType): Promise<EntityRecordNameResult> {
+    const pk = new CompositeKey(primaryKey.KeyValuePairs);
     const e = md.Entities.find((e) => e.Name === EntityName);
     if (e) {
-      const recordName = await md.GetEntityRecordName(e.Name, CompositeKey);
+      const recordName = await md.GetEntityRecordName(e.Name, pk);
       if (recordName) 
-        return { Success: true, Status: 'OK', CompositeKey, RecordName: recordName, EntityName };
+        return { Success: true, Status: 'OK', CompositeKey: pk, RecordName: recordName, EntityName };
       else
         return {
           Success: false,
-          Status: `Name for record, or record ${CompositeKey.ToString()} itself not found, could be an access issue if user doesn't have Row Level Access (RLS) if RLS is enabled for this entity`,
-          CompositeKey,
+          Status: `Name for record, or record ${pk.ToString()} itself not found, could be an access issue if user doesn't have Row Level Access (RLS) if RLS is enabled for this entity`,
+          CompositeKey: pk,
           EntityName
         };
     } 
     else 
-      return { Success: false, Status: `Entity ${EntityName} not found`, CompositeKey, EntityName };
+      return { Success: false, Status: `Entity ${EntityName} not found`, CompositeKey: pk, EntityName };
   }
+
+  // private async TestCommunicationFramework(user: UserInfo, EntityName: string, primaryKey: CompositeKeyInputType) {
+  //   const engine = CommunicationEngine.Instance;
+  //   await engine.Config(false, user);
+  //   await engine.SendSingleMessage('SendGrid', 'Email', {
+  //     To: 'user@domain.com',
+  //     Subject: `MJServer Notification: GetEntityRecordName Called For: ${EntityName}`,
+  //     Body: `Entity: ${EntityName}, Key: ${JSON.stringify(primaryKey)}`,
+  //     MessageType: null
+  //   });
+  // }
+
+  // private async TestDocLibraries(user: UserInfo) {
+  //   const engine = DocumentationEngine.Instance;
+  //   await engine.Config(false, user)
+  //   console.log(JSON.stringify(engine.Libraries));
+  // }
+
+
+  // private async TestTemplates() {
+  //   const templateEngine = new TemplateEngineService('server'); // Provide 'server'
+  
+  //   const template = `
+  //     <h1>Hello, {{context.name}}!</h1>
+  //   `;
+  
+  //   const renderedHtml = await templateEngine.render(template, { name: 'World' });
+  //   console.log(renderedHtml);
+  // }
 }
 
 export default EntityRecordNameResolver;

package/src/resolvers/FileCategoryResolver.ts

@@ -1,17 +1,19 @@
-import { EntityPermissionType, Metadata } from '@memberjunction/core';
+import { CompositeKey, EntityPermissionType, Metadata, RunView } from '@memberjunction/core';
 import { FileCategoryEntity, FileEntity } from '@memberjunction/core-entities';
-import { AppContext, Arg, Ctx, Int, Mutation } from '@memberjunction/server';
+import { AppContext, Arg, Ctx, DeleteOptionsInput, Int, Mutation } from '@memberjunction/server';
 import { mj_core_schema } from '../config';
 import { FileCategoryResolver as FileCategoryResolverBase, FileCategory_ } from '../generated/generated';
 
 export class FileResolver extends FileCategoryResolverBase {
   @Mutation(() => FileCategory_)
-  async DeleteFileCategory(@Arg('ID', () => Int) ID: number, @Ctx() { dataSource, userPayload }: AppContext) {
-    if (!(await this.BeforeDelete(dataSource, ID))) {
+  async DeleteFileCategory(@Arg('ID', () => Int) ID: number, @Arg('options___', () => DeleteOptionsInput) options: DeleteOptionsInput, @Ctx() { dataSource, userPayload }: AppContext) {
+    const key = new CompositeKey();
+    key.LoadFromSingleKeyValuePair('ID', ID);
+    if (!(await this.BeforeDelete(dataSource, key))) {
       return null;
     }
 
-    const md = await new Metadata();
+    const md = new Metadata();
     const user = this.GetUserFromPayload(userPayload);
     const fileEntity = await md.GetEntityObject<FileEntity>('Files', user);
     const fileCategoryEntity = await md.GetEntityObject<FileCategoryEntity>('File Categories', user);
@@ -24,15 +26,37 @@ export class FileResolver extends FileCategoryResolverBase {
 
     // Any files using the deleted category fall back to its parent
     await dataSource.transaction(async () => {
-      const sSQL = `UPDATE [${mj_core_schema}].[File] 
-                      SET [CategoryID]=${fileCategoryEntity.ParentID}
-                      WHERE [CategoryID]=${fileCategoryEntity.ID}`;
+      // 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
+      // Update statement, but it ensures that the object model is used everywhere
+      // in case there are sub-classes and business logic/etc for the updates
+      // the direct SQL would bypass that logic.
 
-      await dataSource.query(sSQL);
+      // const sSQL = `UPDATE [${mj_core_schema}].[File] 
+      //                 SET [CategoryID]=${fileCategoryEntity.ParentID}
+      //                 WHERE [CategoryID]=${fileCategoryEntity.ID}`;
+
+      // await dataSource.query(sSQL);
+      const rv = new RunView();
+      const filesResult = await rv.RunView({
+        EntityName: 'Files',
+        ExtraFilter: 'CategoryID=' + fileCategoryEntity.ID,
+        ResultType: 'entity_object'
+      }, user);
+      if (filesResult) {
+        // iterate through each of the files in filesResult.Results
+        // and update the CategoryID to fileCategoryEntity.ParentID
+        for (const file of filesResult.Results) {
+          const fileEntity = await md.GetEntityObject<FileEntity>('Files', user);
+          await fileEntity.Load(file.ID);
+          fileEntity.CategoryID = fileCategoryEntity.ParentID;
+          await fileEntity.Save();
+        }
+      }
       await fileCategoryEntity.Delete();
     });
 
-    await this.AfterDelete(dataSource, ID); // fire event
+    await this.AfterDelete(dataSource, key); // fire event
     return returnValue;
   }
 }