@memberjunction/server 2.76.0 → 2.78.0

package/src/generic/ResolverBase.ts

@@ -2,8 +2,11 @@ import {
   BaseEntity,
   BaseEntityEvent,
   CompositeKey,
+  DatabaseProviderBase,
   EntityFieldTSType,
   EntityPermissionType,
+  EntitySaveOptions,
+  IRunViewProvider,
   LogDebug,
   LogError,
   LogStatus,
@@ -80,65 +83,82 @@ export class ResolverBase {
     return dataObjectArray;
   }
 
-  protected async findBy(dataSource: sql.ConnectionPool, entity: string, params: any, contextUser: UserInfo) {
+  protected async findBy<T = any>(provider: DatabaseProviderBase, entity: string, params: any, contextUser: UserInfo): Promise<Array<T>> {
     // build the SQL query based on the params passed in
-    const md = new Metadata();
-    const e = md.Entities.find((e) => e.Name === entity);
+    const rv = provider as any as IRunViewProvider;
+    const e = provider.Entities.find((e) => e.Name === entity);
     if (!e) throw new Error(`Entity ${entity} not found in metadata`);
     // now build a SQL string using the entityInfo and using the properties in the params object
-    let sqlQuery = `SELECT * FROM ${e.SchemaName}.${e.BaseView} WHERE `;
+    let extraFilter = "";
     const keys = Object.keys(params);
     keys.forEach((k, i) => {
-      if (i > 0) sqlQuery += ' AND ';
+      if (i > 0) extraFilter += ' AND ';
       // look up the field in the entityInfo to see if it needs quotes
       const field = e.Fields.find((f) => f.Name === k);
       if (!field) throw new Error(`Field ${k} not found in entity ${entity}`);
       const quotes = field.NeedsQuotes ? "'" : '';
-      sqlQuery += `${k} = ${quotes}${params[k]}${quotes}`;
+      extraFilter += `${k} = ${quotes}${params[k]}${quotes}`;
     });
 
     // ok, now we have a SQL string, run it and return the results
     // use the SQLServerDataProvider
-    const result = await SQLServerDataProvider.ExecuteSQLWithPool(dataSource, sqlQuery, undefined, contextUser);
-    return result;
+    const result = await rv.RunView({
+      EntityName: entity,
+      ExtraFilter: extraFilter,
+    }, contextUser)
+    if (result && result.Success && result.Results.length > 0) {
+      return result.Results;
+    }
+    else {
+      return [];
+    }
   }
 
-  async RunViewByNameGeneric(viewInput: RunViewByNameInput, dataSource: sql.ConnectionPool, userPayload: UserPayload, pubSub: PubSubEngine) {
+  async RunViewByNameGeneric(viewInput: RunViewByNameInput, provider: DatabaseProviderBase, userPayload: UserPayload, pubSub: PubSubEngine) {
     try {
-      const viewInfo: UserViewEntity = this.safeFirstArrayElement(
-        await this.findBy(dataSource, 'User Views', { Name: viewInput.ViewName }, userPayload.userRecord)
-      );
-      return this.RunViewGenericInternal(
-        viewInfo,
-        dataSource,
-        viewInput.ExtraFilter,
-        viewInput.OrderBy,
-        viewInput.UserSearchString,
-        viewInput.ExcludeUserViewRunID,
-        viewInput.OverrideExcludeFilter,
-        viewInput.SaveViewResults,
-        viewInput.Fields,
-        viewInput.IgnoreMaxRows,
-        viewInput.ExcludeDataFromAllPriorViewRuns,
-        viewInput.ForceAuditLog,
-        viewInput.AuditLogDescription,
-        viewInput.ResultType,
-        userPayload,
-        pubSub,
-        viewInput.MaxRows
-      );
+      const rv = provider as any as IRunViewProvider;
+      const result = await rv.RunView<UserViewEntity>({
+        EntityName: 'User Views',
+        ExtraFilter: "Name='" + viewInput.ViewName + "'",
+      }, userPayload.userRecord);
+      if (result && result.Success && result.Results.length > 0) {
+        const viewInfo = result.Results[0];
+        return this.RunViewGenericInternal(
+          provider,
+          viewInfo,
+          viewInput.ExtraFilter,
+          viewInput.OrderBy,
+          viewInput.UserSearchString,
+          viewInput.ExcludeUserViewRunID,
+          viewInput.OverrideExcludeFilter,
+          viewInput.SaveViewResults,
+          viewInput.Fields,
+          viewInput.IgnoreMaxRows,
+          viewInput.ExcludeDataFromAllPriorViewRuns,
+          viewInput.ForceAuditLog,
+          viewInput.AuditLogDescription,
+          viewInput.ResultType,
+          userPayload,
+          viewInput.MaxRows
+        );
+      }
+      else {
+        LogError(`RunViewByNameGeneric: View ${viewInput.ViewName} not found or no results returned`);
+        return null;
+      }
     } catch (err) {
       console.log(err);
       return null;
     }
   }
 
-  async RunViewByIDGeneric(viewInput: RunViewByIDInput, dataSource: sql.ConnectionPool, userPayload: UserPayload, pubSub: PubSubEngine) {
+  async RunViewByIDGeneric(viewInput: RunViewByIDInput, provider: DatabaseProviderBase, userPayload: UserPayload, pubSub: PubSubEngine) {
     try {
-      const viewInfo: UserViewEntity = this.safeFirstArrayElement(await this.findBy(dataSource, 'User Views', { ID: viewInput.ViewID }, userPayload.userRecord));
+      const viewInfo = await provider.GetEntityObject<UserViewEntity>('User Views');
+      await viewInfo.Load(viewInput.ViewID);
       return this.RunViewGenericInternal(
+        provider,
         viewInfo,
-        dataSource,
         viewInput.ExtraFilter,
         viewInput.OrderBy,
         viewInput.UserSearchString,
@@ -152,7 +172,6 @@ export class ResolverBase {
         viewInput.AuditLogDescription,
         viewInput.ResultType,
         userPayload,
-        pubSub,
         viewInput.MaxRows
       );
     } catch (err) {
@@ -161,9 +180,9 @@ export class ResolverBase {
     }
   }
 
-  async RunDynamicViewGeneric(viewInput: RunDynamicViewInput, dataSource: sql.ConnectionPool, userPayload: UserPayload, pubSub: PubSubEngine) {
+  async RunDynamicViewGeneric(viewInput: RunDynamicViewInput, provider: DatabaseProviderBase, userPayload: UserPayload, pubSub: PubSubEngine) {
     try {
-      const md = new Metadata();
+      const md = provider;
       const entity = md.Entities.find((e) => e.Name === viewInput.EntityName);
       if (!entity) throw new Error(`Entity ${viewInput.EntityName} not found in metadata`);
 
@@ -175,8 +194,8 @@ export class ResolverBase {
       } as UserViewEntity; // only providing a few bits of data here, but it's enough to get the view to run
 
       return this.RunViewGenericInternal(
+        provider,
         viewInfo,
-        dataSource,
         viewInput.ExtraFilter,
         viewInput.OrderBy,
         viewInput.UserSearchString,
@@ -190,7 +209,6 @@ export class ResolverBase {
         viewInput.AuditLogDescription,
         viewInput.ResultType,
         userPayload,
-        pubSub,
         viewInput.MaxRows
       );
     } catch (err) {
@@ -201,22 +219,21 @@ export class ResolverBase {
 
   async RunViewsGeneric(
     viewInputs: (RunViewByNameInput & RunViewByIDInput & RunDynamicViewInput)[],
-    dataSource: sql.ConnectionPool,
-    userPayload: UserPayload,
-    pubSub: PubSubEngine
+    provider: DatabaseProviderBase,
+    userPayload: UserPayload
   ) {
-    let md: Metadata | null = null;
+    const md = provider;
     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 }, userPayload.userRecord));
+          viewInfo = this.safeFirstArrayElement(await this.findBy(provider, 'User Views', { Name: viewInput.ViewName }, userPayload.userRecord));
         } else if (viewInput.ViewID) {
-          viewInfo = this.safeFirstArrayElement(await this.findBy(dataSource, 'User Views', { ID: viewInput.ViewID }, userPayload.userRecord));
+          viewInfo = await provider.GetEntityObject<UserViewEntity>('User Views');
+          await viewInfo.Load(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`);
@@ -234,8 +251,8 @@ export class ResolverBase {
         }
 
         params.push({
-          viewInfo: viewInfo,
-          dataSource: dataSource,
+          viewInfo,
+          provider,
           extraFilter: viewInput.ExtraFilter,
           orderBy: viewInput.OrderBy,
           userSearchString: viewInput.UserSearchString,
@@ -248,8 +265,7 @@ export class ResolverBase {
           forceAuditLog: viewInput.ForceAuditLog,
           auditLogDescription: viewInput.AuditLogDescription,
           resultType: viewInput.ResultType,
-          userPayload,
-          pubSub,
+          userPayload, 
         });
       } catch (err) {
         LogError(err);
@@ -335,8 +351,8 @@ export class ResolverBase {
    * - Improved error handling (Fix #9)
    */
   protected async RunViewGenericInternal(
+    provider: DatabaseProviderBase,
     viewInfo: UserViewEntity,
-    dataSource: sql.ConnectionPool,
     extraFilter: string,
     orderBy: string,
     userSearchString: string,
@@ -350,20 +366,19 @@ export class ResolverBase {
     auditLogDescription: string | undefined,
     resultType: string | undefined,
     userPayload: UserPayload | null,
-    pubSub: PubSubEngine,
     maxRows: number | undefined
   ) {
     try {
       if (!viewInfo || !userPayload) return null;
 
-      const md = new Metadata();
+      const md = provider
       const user = UserCache.Users.find((u) => u.Email.toLowerCase().trim() === userPayload?.email.toLowerCase().trim());
       if (!user) throw new Error(`User ${userPayload?.email} not found in metadata`);
 
       const entityInfo = md.Entities.find((e) => e.Name === viewInfo.Entity);
       if (!entityInfo) throw new Error(`Entity ${viewInfo.Entity} not found in metadata`);
 
-      const rv = new RunView();
+      const rv = md as any as IRunViewProvider;
 
       // Determine result type
       let rt: 'simple' | 'entity_object' | 'count_only' = 'simple';
@@ -445,7 +460,7 @@ export class ResolverBase {
       if (!params.length) return [];
 
       let md: Metadata | null = null;
-      const rv = new RunView();
+      const rv = params[0].provider as any as IRunViewProvider;
       let runViewParams: RunViewParams[] = [];
       
       // Fix #1: Get user info only once for all queries
@@ -524,9 +539,9 @@ export class ResolverBase {
     }
   }
 
-  protected async createRecordAccessAuditLogRecord(userPayload: UserPayload, entityName: string, recordId: any): Promise<any> {
+  protected async createRecordAccessAuditLogRecord(provider: DatabaseProviderBase, userPayload: UserPayload, entityName: string, recordId: any): Promise<any> {
     try {
-      const md = new Metadata();
+      const md = provider;
       const entityInfo = md.Entities.find((e) => e.Name.trim().toLowerCase() === entityName.trim().toLowerCase());
       if (!entityInfo) throw new Error(`Entity ${entityName} not found in metadata`);
 
@@ -538,15 +553,15 @@ export class ResolverBase {
         if (!userInfo) throw new Error(`User ${userPayload?.email} not found in metadata`);
         if (!auditLogType) throw new Error(`Audit Log Type ${auditLogTypeName} not found in metadata`);
 
-        return await this.createAuditLogRecord(userPayload, null, auditLogTypeName, 'Success', null, entityInfo.ID, recordId);
+        return await this.createAuditLogRecord(provider, userPayload, null, auditLogTypeName, 'Success', null, entityInfo.ID, recordId);
       }
     } catch (e) {
       console.log(e);
     }
   }
 
-  protected getRowLevelSecurityWhereClause(entityName: string, userPayload: UserPayload, type: EntityPermissionType, returnPrefix: string) {
-    const md = new Metadata();
+  protected getRowLevelSecurityWhereClause(provider: DatabaseProviderBase, entityName: string, userPayload: UserPayload, type: EntityPermissionType, returnPrefix: string) {
+    const md = provider;
     const entityInfo = md.Entities.find((e) => e.Name.trim().toLowerCase() === entityName.trim().toLowerCase());
     if (!entityInfo) throw new Error(`Entity ${entityName} not found in metadata`);
     const user = UserCache.Users.find((u) => u.Email.toLowerCase().trim() === userPayload?.email.toLowerCase().trim());
@@ -556,6 +571,7 @@ export class ResolverBase {
   }
 
   protected async createAuditLogRecord(
+    provider: DatabaseProviderBase,
     userPayload: UserPayload,
     authorizationName: string | null,
     auditLogTypeName: string,
@@ -565,7 +581,7 @@ export class ResolverBase {
     recordId: any | null
   ): Promise<any> {
     try {
-      const md = new Metadata();
+      const md = provider;
       const userInfo = UserCache.Users.find((u) => u.Email.toLowerCase().trim() === userPayload?.email.toLowerCase().trim());
       const authorization = authorizationName
         ? md.Authorizations.find((a) => a.Name.trim().toLowerCase() === authorizationName.trim().toLowerCase())
@@ -593,15 +609,17 @@ export class ResolverBase {
 
       if (recordId) auditLog.RecordID = recordId;
 
-      if (await auditLog.Save()) return auditLog;
-      else throw new Error(`Error saving audit log record`);
+      if (await auditLog.Save()) 
+        return auditLog;
+      else 
+        throw new Error(`Error saving audit log record`);
     } catch (err) {
       console.log(err);
       return null;
     }
   }
 
-  protected safeFirstArrayElement(arr: any[]) {
+  protected safeFirstArrayElement<T = any>(arr: T[]) {
     if (arr && arr.length > 0) {
       return arr[0];
     }
@@ -613,7 +631,6 @@ export class ResolverBase {
   }
 
   protected GetUserFromEmail(email: string): UserInfo | undefined {
-    const md = new Metadata();
     return UserCache.Users.find((u) => u.Email.toLowerCase().trim() === email.toLowerCase().trim());
   }
   protected GetUserFromPayload(userPayload: UserPayload): UserInfo | undefined {
@@ -626,7 +643,6 @@ export class ResolverBase {
     if (!userPayload.email) 
       return undefined;
 
-    const md = new Metadata();
     return UserCache.Users.find((u) => u.Email.toLowerCase().trim() === userPayload.email.toLowerCase().trim());
   }
 
@@ -673,18 +689,19 @@ export class ResolverBase {
     }
   }
 
-  protected async CreateRecord(entityName: string, input: any, dataSource: sql.ConnectionPool, userPayload: UserPayload, pubSub: PubSubEngine) {
-    if (await this.BeforeCreate(dataSource, input)) {
+  protected async CreateRecord(entityName: string, input: any, provider: DatabaseProviderBase, userPayload: UserPayload, pubSub: PubSubEngine) {
+    if (await this.BeforeCreate(provider, input)) {
       // fire event and proceed if it wasn't cancelled
-      const entityObject = await new Metadata().GetEntityObject(entityName, this.GetUserFromPayload(userPayload));
+      const entityObject = await provider.GetEntityObject(entityName, this.GetUserFromPayload(userPayload));
       entityObject.NewRecord();
       entityObject.SetMany(input);
 
       this.ListenForEntityMessages(entityObject, pubSub, userPayload);
 
+      // Pass the transactionScopeId from the user payload to the save operation
       if (await entityObject.Save()) {
         // save worked, fire the AfterCreate event and then return all the data
-        await this.AfterCreate(dataSource, input); // fire event
+        await this.AfterCreate(provider, input); // fire event
         return this.MapFieldNamesToCodeNames(entityName, entityObject.GetAll());
       }
       // save failed, return null
@@ -693,17 +710,16 @@ export class ResolverBase {
   }
 
   // Before/After CREATE Event Hooks for Sub-Classes to Override
-  protected async BeforeCreate(dataSource: sql.ConnectionPool, input: any): Promise<boolean> {
+  protected async BeforeCreate(provider: DatabaseProviderBase, input: any): Promise<boolean> {
     return true;
   }
-  protected async AfterCreate(dataSource: sql.ConnectionPool, input: any) {}
+  protected async AfterCreate(provider: DatabaseProviderBase, input: any) {}
 
-  protected async UpdateRecord(entityName: string, input: any, dataSource: sql.ConnectionPool, userPayload: UserPayload, pubSub: PubSubEngine) {
-    if (await this.BeforeUpdate(dataSource, input)) {
+  protected async UpdateRecord(entityName: string, input: any, provider: DatabaseProviderBase, userPayload: UserPayload, pubSub: PubSubEngine) {
+    if (await this.BeforeUpdate(provider, 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 entityObject = await provider.GetEntityObject(entityName, userInfo);
       const entityInfo = entityObject.EntityInfo;
       const clientNewValues = {};
       Object.keys(input).forEach((key) => {
@@ -752,9 +768,10 @@ export class 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
+        await this.AfterUpdate(provider, input); // fire event
         
         return this.MapFieldNamesToCodeNames(entityName, entityObject.GetAll());
       } else {
@@ -937,20 +954,20 @@ export class ResolverBase {
     entityName: string,
     key: CompositeKey,
     options: DeleteOptionsInput,
-    dataSource: sql.ConnectionPool,
+    provider: DatabaseProviderBase,
     userPayload: UserPayload,
     pubSub: PubSubEngine
   ) {
-    if (await this.BeforeDelete(dataSource, key)) {
+    if (await this.BeforeDelete(provider, key)) {
       // fire event and proceed if it wasn't cancelled
-      const entityObject = await new Metadata().GetEntityObject(entityName, this.GetUserFromPayload(userPayload));
+      const entityObject = await provider.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.
 
       this.ListenForEntityMessages(entityObject, pubSub, userPayload);
-
+      
       if (await entityObject.Delete(options)) {
-        await this.AfterDelete(dataSource, key); // fire event
+        await this.AfterDelete(provider, key); // fire event
         return returnValue;
       } else {
         throw new GraphQLError(entityObject.LatestResult?.Message ?? 'Unknown error', {
@@ -965,14 +982,14 @@ export class ResolverBase {
   }
 
   // Before/After DELETE Event Hooks for Sub-Classes to Override
-  protected async BeforeDelete(dataSource: sql.ConnectionPool, key: CompositeKey): Promise<boolean> {
+  protected async BeforeDelete(provider: DatabaseProviderBase, key: CompositeKey): Promise<boolean> {
     return true;
   }
-  protected async AfterDelete(dataSource: sql.ConnectionPool, key: CompositeKey) {}
+  protected async AfterDelete(provider: DatabaseProviderBase, key: CompositeKey) {}
 
   // Before/After UPDATE Event Hooks for Sub-Classes to Override
-  protected async BeforeUpdate(dataSource: sql.ConnectionPool, input: any): Promise<boolean> {
+  protected async BeforeUpdate(provider: DatabaseProviderBase, input: any): Promise<boolean> {
     return true;
   }
-  protected async AfterUpdate(dataSource: sql.ConnectionPool, input: any) {}
+  protected async AfterUpdate(provider: DatabaseProviderBase, input: any) {}
 }

package/src/generic/RunViewResolver.ts

@@ -3,6 +3,8 @@ import { AppContext } from '../types.js';
 import { ResolverBase } from './ResolverBase.js';
 import { LogError, LogStatus } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
+import { GetReadOnlyProvider } from '../util.js';
+import { UserViewEntity } from '@memberjunction/core-entities';
 
 /********************************************************************************
  * The PURPOSE of this resolver is to provide a generic way to run a view and return the results.
@@ -457,17 +459,17 @@ export class RunViewResolver extends ResolverBase {
   @Query(() => RunViewResult)
   async RunViewByName(
     @Arg('input', () => RunViewByNameInput) input: RunViewByNameInput,
-    @Ctx() { dataSource, userPayload }: AppContext,
+    @Ctx() { providers, userPayload }: AppContext,
     pubSub: PubSubEngine
   ) {
     try {
-      const rawData = await super.RunViewByNameGeneric(input, dataSource, userPayload, pubSub);
-      if (rawData === null) return null;
+      const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+      const rawData = await super.RunViewByNameGeneric(input, provider, userPayload, pubSub);
+      if (rawData === null) 
+        return null;
 
-      const request = dataSource.request();
-      const entityIdResult = await request.query(`SELECT EntityID from [${this.MJCoreSchema}].vwUserViews WHERE Name='${input.ViewName}'`);
-      const entityId = entityIdResult.recordset;
-      const returnData = this.processRawData(rawData.Results, entityId[0].EntityID);
+      const viewInfo = super.safeFirstArrayElement<UserViewEntity>(await super.findBy<UserViewEntity>(provider, "User Views", { Name: input.ViewName }, userPayload.userRecord));
+      const returnData = this.processRawData(rawData.Results, viewInfo.EntityID);
       return {
         Results: returnData,
         UserViewRunID: rawData?.UserViewRunID,
@@ -484,17 +486,17 @@ export class RunViewResolver extends ResolverBase {
   @Query(() => RunViewResult)
   async RunViewByID(
     @Arg('input', () => RunViewByIDInput) input: RunViewByIDInput,
-    @Ctx() { dataSource, userPayload }: AppContext,
+    @Ctx() { providers, userPayload }: AppContext,
     pubSub: PubSubEngine
   ) {
     try {
-      const rawData = await super.RunViewByIDGeneric(input, dataSource, userPayload, pubSub);
-      if (rawData === null) return null;
+      const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+      const rawData = await super.RunViewByIDGeneric(input, provider, userPayload, pubSub);
+      if (rawData === null) 
+        return null;
 
-      const request = dataSource.request();
-      const entityIdResult = await request.query(`SELECT EntityID from [${this.MJCoreSchema}].vwUserViews WHERE ID=${input.ViewID}`);
-      const entityId = entityIdResult.recordset;
-      const returnData = this.processRawData(rawData.Results, entityId[0].EntityID);
+      const viewInfo = super.safeFirstArrayElement<UserViewEntity>(await super.findBy<UserViewEntity>(provider, "User Views", { ID: input.ViewID }, userPayload.userRecord));
+      const returnData = this.processRawData(rawData.Results, viewInfo.EntityID);
       return {
         Results: returnData,
         UserViewRunID: rawData?.UserViewRunID,
@@ -511,17 +513,16 @@ export class RunViewResolver extends ResolverBase {
   @Query(() => RunViewResult)
   async RunDynamicView(
     @Arg('input', () => RunDynamicViewInput) input: RunDynamicViewInput,
-    @Ctx() { dataSource, userPayload }: AppContext,
+    @Ctx() { providers, userPayload }: AppContext,
     pubSub: PubSubEngine
   ) {
     try {
-      const rawData = await super.RunDynamicViewGeneric(input, dataSource, userPayload, pubSub);
+      const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+      const rawData = await super.RunDynamicViewGeneric(input, provider, userPayload, pubSub);
       if (rawData === null) return null;
 
-      const request = dataSource.request();
-      const entityIdResult = await request.query(`SELECT ID from [${this.MJCoreSchema}].vwEntities WHERE Name='${input.EntityName}'`);
-      const entityId = entityIdResult.recordset;
-      const returnData = this.processRawData(rawData.Results, entityId[0].EntityID);
+      const entity = provider.Entities.find((e) => e.Name === input.EntityName);
+      const returnData = this.processRawData(rawData.Results, entity.ID);
       return {
         Results: returnData,
         UserViewRunID: rawData?.UserViewRunID,
@@ -538,23 +539,20 @@ export class RunViewResolver extends ResolverBase {
   @Query(() => [RunViewGenericResult])
   async RunViews(
     @Arg('input', () => [RunViewGenericInput]) input: (RunViewByNameInput & RunViewByIDInput & RunDynamicViewInput)[],
-    @Ctx() { dataSource, userPayload }: AppContext,
+    @Ctx() { providers, userPayload }: AppContext,
     pubSub: PubSubEngine
   ) {
     try {
-      const rawData: RunViewGenericResult[] = await super.RunViewsGeneric(input, dataSource, userPayload, pubSub);
+      const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+      const rawData: RunViewGenericResult[] = await super.RunViewsGeneric(input, provider, userPayload);
       if (!rawData) {
         return null;
       }
 
       let results: RunViewGenericResult[] = [];
       for (const [index, data] of rawData.entries()) {
-        const request = dataSource.request();
-        const entityIdResult = await request.query(
-          `SELECT TOP 1 ID from [${this.MJCoreSchema}].vwEntities WHERE Name='${input[index].EntityName}'`
-        );
-        const entityId = entityIdResult.recordset;
-        const returnData: any[] = this.processRawData(data.Results, entityId[0].ID);
+        const entity = provider.Entities.find((e) => e.Name === input[index].EntityName);
+        const returnData: any[] = this.processRawData(data.Results, entity.ID);
 
         results.push({
           Results: returnData,
@@ -577,17 +575,17 @@ export class RunViewResolver extends ResolverBase {
   @Query(() => RunViewResult)
   async RunViewByNameSystemUser(
     @Arg('input', () => RunViewByNameInput) input: RunViewByNameInput,
-    @Ctx() { dataSource, userPayload }: AppContext,
+    @Ctx() { providers, userPayload }: AppContext,
     pubSub: PubSubEngine
   ) {
     try {
-      const rawData = await super.RunViewByNameGeneric(input, dataSource, userPayload, pubSub);
+      const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+      const rawData = await super.RunViewByNameGeneric(input, provider, userPayload, pubSub);
       if (rawData === null) return null;
 
-      const request = dataSource.request();
-      const entityIdResult = await request.query(`SELECT EntityID from [${this.MJCoreSchema}].vwUserViews WHERE Name='${input.ViewName}'`);
-      const entityId = entityIdResult.recordset;
-      const returnData = this.processRawData(rawData.Results, entityId[0].EntityID);
+      const entity = provider.Entities.find((e) => e.Name === input.ViewName);
+      const entityId = entity ? entity.ID : null;
+      const returnData = this.processRawData(rawData.Results, entityId);
       return {
         Results: returnData,
         UserViewRunID: rawData?.UserViewRunID,
@@ -607,17 +605,16 @@ export class RunViewResolver extends ResolverBase {
   @Query(() => RunViewResult)
   async RunViewByIDSystemUser(
     @Arg('input', () => RunViewByIDInput) input: RunViewByIDInput,
-    @Ctx() { dataSource, userPayload }: AppContext,
+    @Ctx() { providers, userPayload }: AppContext,
     pubSub: PubSubEngine
   ) {
     try {
-      const rawData = await super.RunViewByIDGeneric(input, dataSource, userPayload, pubSub);
+      const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+      const rawData = await super.RunViewByIDGeneric(input, provider, userPayload, pubSub);
       if (rawData === null) return null;
 
-      const request = dataSource.request();
-      const entityIdResult = await request.query(`SELECT EntityID from [${this.MJCoreSchema}].vwUserViews WHERE ID=${input.ViewID}`);
-      const entityId = entityIdResult.recordset;
-      const returnData = this.processRawData(rawData.Results, entityId[0].EntityID);
+      const viewInfo = super.safeFirstArrayElement<UserViewEntity>(await super.findBy<UserViewEntity>(provider, "User Views", { ID: input.ViewID }, userPayload.userRecord));
+      const returnData = this.processRawData(rawData.Results, viewInfo.EntityID);
       return {
         Results: returnData,
         UserViewRunID: rawData?.UserViewRunID,
@@ -637,17 +634,20 @@ export class RunViewResolver extends ResolverBase {
   @Query(() => RunViewResult)
   async RunDynamicViewSystemUser(
     @Arg('input', () => RunDynamicViewInput) input: RunDynamicViewInput,
-    @Ctx() { dataSource, userPayload }: AppContext,
+    @Ctx() { providers, userPayload }: AppContext,
     pubSub: PubSubEngine
   ) {
     try {
-      const rawData = await super.RunDynamicViewGeneric(input, dataSource, userPayload, pubSub);
+      const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+      const rawData = await super.RunDynamicViewGeneric(input, provider, userPayload, pubSub);
       if (rawData === null) return null;
 
-      const request = dataSource.request();
-      const entityIdResult = await request.query(`SELECT ID from [${this.MJCoreSchema}].vwEntities WHERE Name='${input.EntityName}'`);
-      const entityId = entityIdResult.recordset;
-      const returnData = this.processRawData(rawData.Results, entityId[0].ID);
+      const entity = provider.Entities.find((e) => e.Name === input.EntityName);
+      if (!entity) {
+        LogError(new Error(`Entity with name ${input.EntityName} not found`));
+        return null;
+      }
+      const returnData = this.processRawData(rawData.Results, entity.ID);
       return {
         Results: returnData,
         UserViewRunID: rawData?.UserViewRunID,
@@ -667,23 +667,24 @@ export class RunViewResolver extends ResolverBase {
   @Query(() => [RunViewGenericResult])
   async RunViewsSystemUser(
     @Arg('input', () => [RunViewGenericInput]) input: (RunViewByNameInput & RunViewByIDInput & RunDynamicViewInput)[],
-    @Ctx() { dataSource, userPayload }: AppContext,
+    @Ctx() { providers, userPayload }: AppContext,
     pubSub: PubSubEngine
   ) {
     try {
-      const rawData: RunViewGenericResult[] = await super.RunViewsGeneric(input, dataSource, userPayload, pubSub);
+      const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+      const rawData: RunViewGenericResult[] = await super.RunViewsGeneric(input, provider, userPayload);
       if (!rawData) {
         return null;
       }
 
       let results: RunViewGenericResult[] = [];
       for (const [index, data] of rawData.entries()) {
-        const request = dataSource.request();
-        const entityIdResult = await request.query(
-          `SELECT TOP 1 ID from [${this.MJCoreSchema}].vwEntities WHERE Name='${input[index].EntityName}'`
-        );
-        const entityId = entityIdResult.recordset;
-        const returnData: any[] = this.processRawData(data.Results, entityId[0].ID);
+        const entity = provider.Entities.find((e) => e.Name === input[index].EntityName);
+        if (!entity) {
+          LogError(new Error(`Entity with name ${input[index].EntityName} not found`));
+          continue;
+        }
+        const returnData: any[] = this.processRawData(data.Results, entity.ID);
 
         results.push({
           Results: returnData,