@memberjunction/server 1.8.1 → 2.1.1

package/src/generic/ResolverBase.ts

@@ -1,18 +1,18 @@
-import { BaseEntity, CompositeKey, EntityFieldTSType, EntityPermissionType, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { BaseEntity, CompositeKey, EntityFieldTSType, EntityPermissionType, LogError, Metadata, RunView, RunViewParams, RunViewResult, 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 { RunViewGenericParams, 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';
-
+import { FieldMapper } from '@memberjunction/graphql-dataprovider';
+ 
 export class ResolverBase {
-
   protected MapFieldNamesToCodeNames(entityName: string, dataObject: any) {
     // for the given entity name provided, check to see if there are any fields
     // where the code name is different from the field name, and for just those
@@ -22,21 +22,19 @@ export class ResolverBase {
     if (dataObject) {
       const md = new Metadata();
       const entityInfo = md.Entities.find((e) => e.Name === entityName);
-      if (!entityInfo) 
-        throw new Error(`Entity ${entityName} not found in metadata`);
-      const fields = entityInfo.Fields.filter((f) => f.Name !== f.CodeName || f.Name.startsWith('__mj_'));
-      fields.forEach((f) => {
+      if (!entityInfo) throw new Error(`Entity ${entityName} not found in metadata`);
+      // const fields = entityInfo.Fields.filter((f) => f.Name !== f.CodeName || f.Name.startsWith('__mj_'));
+      const mapper = new FieldMapper();
+      entityInfo.Fields.forEach((f) => {
         if (dataObject.hasOwnProperty(f.Name)) {
-          if (f.CodeName.startsWith('__mj_')) { // GraphQL doesn't allow us to pass back fields with __ so we are mapping our special field cases that start with __mj_ to _mj__ for transport - they are converted back on the other side automatically
-            const newCodeName = `_mj__${f.CodeName.substring(5)}`;
-            dataObject[newCodeName] = dataObject[f.Name];
-          } 
-          else {
-            dataObject[f.CodeName] = dataObject[f.Name];
+          // GraphQL doesn't allow us to pass back fields with __ so we are mapping our special field cases that start with __mj_ to _mj__ for transport - they are converted back on the other side automatically
+          const mappedFieldName = mapper.MapFieldName(f.CodeName)
+          if (mappedFieldName !== f.Name) {
+            dataObject[mappedFieldName] = dataObject[f.Name];
+            delete dataObject[f.Name];
           }
-          delete dataObject[f.Name];
         }
-      });  
+      });
     }
     return dataObject;
   }
@@ -46,7 +44,7 @@ export class ResolverBase {
     if (dataObjectArray && dataObjectArray.length > 0) {
       dataObjectArray.forEach((element) => {
         this.MapFieldNamesToCodeNames(entityName, element);
-      });  
+      });
     }
     return dataObjectArray;
   }
@@ -75,7 +73,9 @@ export class ResolverBase {
 
   async RunViewByNameGeneric(viewInput: RunViewByNameInput, dataSource: DataSource, userPayload: UserPayload, pubSub: PubSubEngine) {
     try {
-      const viewInfo: UserViewEntity = this.safeFirstArrayElement(await this.findBy(dataSource, 'User Views', { Name: viewInput.ViewName }));;
+      const viewInfo: UserViewEntity = this.safeFirstArrayElement(
+        await this.findBy(dataSource, 'User Views', { Name: viewInput.ViewName })
+      );
       return this.RunViewGenericInternal(
         viewInfo,
         dataSource,
@@ -134,9 +134,9 @@ export class ResolverBase {
       if (!entity) throw new Error(`Entity ${viewInput.EntityName} not found in metadata`);
 
       const viewInfo: UserViewEntity = {
-        ID: -1,
+        ID: "",
         Entity: viewInput.EntityName,
-        EntityID: entity.ID as number,
+        EntityID: entity.ID,
         EntityBaseView: entity.BaseView as string,
       } as UserViewEntity; // only providing a few bits of data here, but it's enough to get the view to run
 
@@ -164,6 +164,71 @@ export class ResolverBase {
     }
   }
 
+  async RunViewsGeneric(viewInputs: (RunViewByNameInput & RunViewByIDInput & RunDynamicViewInput)[], dataSource: DataSource, userPayload: UserPayload, pubSub: PubSubEngine) {
+    let md: Metadata | null = null;
+    let params: RunViewGenericParams[] = [];
+    for(const viewInput of viewInputs) {
+      try {
+        let viewInfo: UserViewEntity | null = null;
+
+        if(viewInput.ViewName) {
+          viewInfo = this.safeFirstArrayElement(
+            await this.findBy(dataSource, 'User Views', { Name: viewInput.ViewName })
+          );
+        }
+        else if(viewInput.ViewID) {
+          viewInfo = this.safeFirstArrayElement(await this.findBy(dataSource, 'User Views', { ID: viewInput.ViewID }));
+        }
+        else if(viewInput.EntityName) {
+          md = md || new Metadata();
+          const entity = md.Entities.find((e) => e.Name === viewInput.EntityName);
+          if (!entity) {
+            throw new Error(`Entity ${viewInput.EntityName} not found in metadata`);
+          }
+
+          // only providing a few bits of data here, but it's enough to get the view to run
+          viewInfo = {
+            ID: "",
+            Entity: viewInput.EntityName,
+            EntityID: entity.ID,
+            EntityBaseView: entity.BaseView,
+          } as UserViewEntity;
+        }
+        else{
+          throw new Error("Unable to determine input type");
+        }
+
+        params.push({
+          viewInfo: viewInfo,
+          dataSource: dataSource,
+          extraFilter: viewInput.ExtraFilter,
+          orderBy: viewInput.OrderBy,
+          userSearchString: viewInput.UserSearchString,
+          excludeUserViewRunID: viewInput.ExcludeUserViewRunID,
+          overrideExcludeFilter: viewInput.OverrideExcludeFilter,
+          saveViewResults: viewInput.EntityName ? false : viewInput.SaveViewResults,
+          fields: viewInput.Fields,
+          ignoreMaxRows: viewInput.IgnoreMaxRows,
+          excludeDataFromAllPriorViewRuns: viewInput.EntityName ? false : viewInput.ExcludeDataFromAllPriorViewRuns,
+          forceAuditLog: viewInput.ForceAuditLog,
+          auditLogDescription: viewInput.AuditLogDescription,
+          resultType: viewInput.ResultType,
+          userPayload,
+          pubSub
+        });
+
+      } catch (err) {
+        LogError(err);
+        return null;
+      }
+    }
+
+    let results: RunViewResult[] = await this.RunViewsGenericInternal(params);
+    return results;
+  }
+
+
+
   protected CheckUserReadPermissions(entityName: string, userPayload: UserPayload | null) {
     const md = new Metadata();
     const entityInfo = md.Entities.find((e) => e.Name === entityName);
@@ -185,7 +250,7 @@ export class ResolverBase {
     extraFilter: string,
     orderBy: string,
     userSearchString: string,
-    excludeUserViewRunID: number | undefined,
+    excludeUserViewRunID: string | undefined,
     overrideExcludeFilter: string | undefined,
     saveViewResults: boolean | undefined,
     fields: string[] | undefined,
@@ -241,22 +306,90 @@ export class ResolverBase {
           user
         );
         // go through the result and convert all fields that start with __mj_*** to _mj__*** for GraphQL transport
+        const mapper = new FieldMapper();
         if (result && result.Success) {
           for (const r of result.Results) {
-            const keys = Object.keys(r);
-            keys.forEach((k) => {
-              if (k.trim().toLowerCase().startsWith('__mj_')) {
-                r[`_mj__${k.substring(5)}`] = r[k];
-                delete r[k];
-              }
-            });
-          
+            mapper.MapFields(r);
           }
         }
         return result;
-      } 
-      else 
-        return null;
+      } else return null;
+    } catch (err) {
+      console.log(err);
+      throw err;
+    }
+  }
+
+  protected async RunViewsGenericInternal(params: RunViewGenericParams[]): Promise<RunViewResult[]> {
+    try {
+      let md: Metadata | null = null;
+      const rv = new RunView();
+      let RunViewParams: RunViewParams[] = [];
+      let contextUser: UserInfo | null = null;
+      for(const param of params){
+        if (param.viewInfo && param.userPayload) {
+          md = md || new Metadata();
+          const user: UserInfo = UserCache.Users.find((u) => u.Email.toLowerCase().trim() === param.userPayload?.email.toLowerCase().trim());
+          if (!user) {
+            throw new Error(`User ${param.userPayload?.email} not found in metadata`);
+          }
+
+          contextUser = contextUser || user;
+  
+          const entityInfo = md.Entities.find((e) => e.Name === param.viewInfo.Entity);
+          if (!entityInfo){
+            throw new Error(`Entity ${param.viewInfo.Entity} not found in metadata`);
+          }
+        }
+
+        // figure out the result type from the input string (if provided)
+        let rt: 'simple' | 'entity_object' | 'count_only' = 'simple';
+        switch (param.resultType?.trim().toLowerCase()) {
+          case 'count_only':
+            rt = 'count_only';
+            break;
+          // use simple as the default AND for entity_object 
+          // becuase on teh server we don't really pass back 
+          // a true entity_object anyway, just passing back 
+          // the simple object anyway
+          case 'entity_object':
+          default:
+            rt = 'simple';
+            break;
+        }
+
+        RunViewParams.push({
+          ViewID: param.viewInfo.ID,
+          ViewName: param.viewInfo.Name,
+          EntityName: param.viewInfo.Entity,
+          ExtraFilter: param.extraFilter,
+          OrderBy: param.orderBy,
+          Fields: param.fields,
+          UserSearchString: param.userSearchString,
+          ExcludeUserViewRunID: param.excludeUserViewRunID,
+          OverrideExcludeFilter: param.overrideExcludeFilter,
+          SaveViewResults: param.saveViewResults,
+          ExcludeDataFromAllPriorViewRuns: param.excludeDataFromAllPriorViewRuns,
+          IgnoreMaxRows: param.ignoreMaxRows,
+          ForceAuditLog: param.forceAuditLog,
+          AuditLogDescription: param.auditLogDescription,
+          ResultType: rt,
+        });
+      }
+
+      let runViewResults: RunViewResult[] = await rv.RunViews(RunViewParams, contextUser);
+
+      // go through the result and convert all fields that start with __mj_*** to _mj__*** for GraphQL transport
+      const mapper = new FieldMapper();
+      for(const runViewResult of runViewResults){
+        if (runViewResult && runViewResult.Success) {
+          for (const result of runViewResult.Results) {
+            mapper.MapFields(result);
+          }
+        }
+      }
+
+      return runViewResults;
     } 
     catch (err) {
       console.log(err);
@@ -301,7 +434,7 @@ export class ResolverBase {
     auditLogTypeName: string,
     status: string,
     details: string | null,
-    entityId: number,
+    entityId: string,
     recordId: any | null
   ): Promise<any> {
     try {
@@ -318,30 +451,23 @@ export class ResolverBase {
       const auditLog = await md.GetEntityObject<AuditLogEntity>('Audit Logs', userInfo); // must pass user context on back end as we're not authenticated the same way as the front end
       auditLog.NewRecord();
       auditLog.UserID = userInfo.ID;
-      auditLog.AuditLogTypeName = auditLogType.Name;
+      auditLog.AuditLogTypeID = auditLogType.ID;
 
       if (authorization) 
-        auditLog.AuthorizationName = authorization.Name;
+        auditLog.AuthorizationID = authorization.ID;
 
-      if (status?.trim().toLowerCase() === 'success') 
-        auditLog.Status = "Success"
-      else
-        auditLog.Status = "Failed";
+      if (status?.trim().toLowerCase() === 'success') auditLog.Status = 'Success';
+      else auditLog.Status = 'Failed';
 
-      if (details) 
-        auditLog.Details = details;
+      if (details) auditLog.Details = details;
 
       auditLog.EntityID = entityId;
 
-      if (recordId) 
-        auditLog.RecordID = recordId;
+      if (recordId) auditLog.RecordID = recordId;
 
-      if (await auditLog.Save()) 
-        return auditLog;
-      else 
-        throw new Error(`Error saving audit log record`);
-    } 
-    catch (err) {
+      if (await auditLog.Save()) return auditLog;
+      else throw new Error(`Error saving audit log record`);
+    } catch (err) {
       console.log(err);
       return null;
     }
@@ -385,118 +511,115 @@ export class ResolverBase {
               type: 'EntityObjectStatusMessage',
               entityName: entityObject.EntityInfo.Name,
               primaryKey: entityObject.PrimaryKey,
-              message: event.args.message 
+              message: event.args.message,
             }),
-            sessionId: userPayload.sessionId
-          });          
+            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 this.MapFieldNamesToCodeNames(entityName, entityObject.GetAll());
-        }
-        else 
-            // save failed, return null
-            throw entityObject.LatestResult.Message;
-    }
-    else    
-        return null;
+    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 this.MapFieldNamesToCodeNames(entityName, entityObject.GetAll());
+      }
+      // save failed, return null
+      else 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;
+    return true;
   }
-  protected async AfterCreate(dataSource: DataSource, input: any) {
-  }  
-
+  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 {
-            // save failed, return null
-            throw new GraphQLError(`Record not found for ${entityName} with key ${JSON.stringify(cKey)}`, {
-              extensions: { code: 'LOAD_ENTITY_ERROR', entityName },
-            });
+    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 {
+          // save failed, return null
+          throw new GraphQLError(`Record not found for ${entityName} with key ${JSON.stringify(cKey)}`, {
+            extensions: { code: 'LOAD_ENTITY_ERROR', entityName },
+          });
         }
-        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); 
+      } 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));
 
-          // 2) set the new values from the input, not including the OldValues property
-          entityObject.SetMany(clientNewValues);  
-        }
+        // 1) load the old values, this will be the initial state of the object
+        entityObject.LoadFromData(oldValues);
 
-        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 this.MapFieldNamesToCodeNames(entityName, entityObject.GetAll());
-        }
-        else {
-          throw new GraphQLError(entityObject.LatestResult?.Message ?? 'Unknown error', {
-            extensions: { code: 'SAVE_ENTITY_ERROR', entityName },
-          });
-        }
+        // 2) set the new values from the input, not including the OldValues property
+        entityObject.SetMany(clientNewValues);
       }
-      else
-        throw new GraphQLError('Save Canceled by BeforeSave() handler in ResolverBase', {
+
+      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 this.MapFieldNamesToCodeNames(entityName, entityObject.GetAll());
+      } else {
+        throw new GraphQLError(entityObject.LatestResult?.Message ?? 'Unknown error', {
           extensions: { code: 'SAVE_ENTITY_ERROR', entityName },
         });
-}
+      }
+    } else
+      throw new GraphQLError('Save Canceled by BeforeSave() handler in ResolverBase', {
+        extensions: { code: 'SAVE_ENTITY_ERROR', entityName },
+      });
+  }
 
   /**
-   * 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 
+   * 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) {
@@ -507,8 +630,8 @@ export class ResolverBase {
       // 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 ((val === null || val === undefined) && field.DefaultValue !== null && field.DefaultValue !== undefined && !field.AllowsNull) 
+        val = field.DefaultValue; // set default value as the field was never set and it does NOT allow nulls
 
       if (field) {
         switch (field.TSType) {
@@ -516,12 +639,11 @@ export class ResolverBase {
             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;
+            val = val === null || val === undefined || val === 'false' || val === '0' || parseInt(val) === 0 ? false : true;
             break;
           case EntityFieldTSType.Date:
-            // first, if val is a string and it is actually a number (milliseconds since epoch), convert it to a number. 
-            if (val !== null && val !== undefined && val.toString().trim() !== '' && !isNaN(val)) 
-              val = parseInt(val);
+            // first, if val is a string and it is actually a number (milliseconds since epoch), convert it to a number.
+            if (val !== null && val !== undefined && val.toString().trim() !== '' && !isNaN(val)) val = parseInt(val);
 
             val = val !== null && val !== undefined ? new Date(val) : null;
             break;
@@ -529,7 +651,7 @@ export class ResolverBase {
             break; // already a string
         }
       }
-      clientOldValues[item.Key] = val
+      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
@@ -557,12 +679,12 @@ export class ResolverBase {
           different = clientOldValues[key] !== dbValues[key];
           break;
       }
-      if (different && f && !f.ReadOnly ) {
+      if (different && f && !f.ReadOnly) {
         // only include updateable fields
         dbDifferences.push({
           FieldName: key,
           ClientOldValue: clientOldValues[key],
-          DBValue: dbValues[key]
+          DBValue: dbValues[key],
         });
       }
     });
@@ -578,7 +700,7 @@ export class ResolverBase {
           clientDifferences.push({
             FieldName: key,
             ClientOldValue: clientOldValues[key],
-            ClientNewValue: clientNewValues[key]
+            ClientNewValue: clientNewValues[key],
           });
         }
       });
@@ -588,36 +710,43 @@ export class ResolverBase {
       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.',
+          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
+          Overlap: overlap,
         };
         throw new Error(JSON.stringify(msg));
       }
     }
 
-    // If we get here that means we've not thrown an exception, so there is 
+    // 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 {
-          throw new GraphQLError(entityObject.LatestResult?.Message ?? 'Unknown error', {
-            extensions: { code: 'DELETE_ENTITY_ERROR', entityName },
-          });
-        }
-    }
-    else {
+  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 {
+        throw new GraphQLError(entityObject.LatestResult?.Message ?? 'Unknown error', {
+          extensions: { code: 'DELETE_ENTITY_ERROR', entityName },
+        });
+      }
+    } else {
       throw new GraphQLError('Delete operation canceled by BeforeDelete() handler in ResolverBase', {
         extensions: { code: 'DELETE_ENTITY_ERROR', entityName },
       });
@@ -625,16 +754,14 @@ export class ResolverBase {
   }
 
   // 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,) {
+  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;
+    return true;
   }
-  protected async AfterUpdate(dataSource: DataSource, input: any) {
-  }  
+  protected async AfterUpdate(dataSource: DataSource, input: any) {}
 }