@memberjunction/server 2.75.0 → 2.77.0

package/src/resolvers/QueryResolver.ts

@@ -38,7 +38,7 @@ export class RunQueryResultType {
 
 @Resolver()
 export class RunQueryResolver {
-  private async findQuery(QueryID: string, QueryName?: string, CategoryID?: string, CategoryName?: string, refreshMetadataIfNotFound: boolean = false): Promise<QueryInfo | null> {
+  private async findQuery(QueryID: string, QueryName?: string, CategoryID?: string, CategoryPath?: string, refreshMetadataIfNotFound: boolean = false): Promise<QueryInfo | null> {
     const md = new Metadata();
     
     // Filter queries based on provided criteria
@@ -50,8 +50,8 @@ export class RunQueryResolver {
         if (CategoryID) {
           matches = matches && q.CategoryID?.trim().toLowerCase() === CategoryID.trim().toLowerCase();
         }
-        if (CategoryName) {
-          matches = matches && q.Category?.trim().toLowerCase() === CategoryName.trim().toLowerCase();
+        if (CategoryPath) {
+          matches = matches && q.Category?.trim().toLowerCase() === CategoryPath.trim().toLowerCase();
         }
         return matches;
       }
@@ -62,7 +62,7 @@ export class RunQueryResolver {
       if (refreshMetadataIfNotFound) {
         // If we didn't find the query, refresh metadata and try again
         await md.Refresh();
-        return this.findQuery(QueryID, QueryName, CategoryID, CategoryName, false); // change the refresh flag to false so we don't loop infinitely
+        return this.findQuery(QueryID, QueryName, CategoryID, CategoryPath, false); // change the refresh flag to false so we don't loop infinitely
       } 
       else {
         return null; // No query found and not refreshing metadata
@@ -76,7 +76,7 @@ export class RunQueryResolver {
   async GetQueryData(@Arg('QueryID', () => String) QueryID: string, 
                      @Ctx() context: AppContext,
                      @Arg('CategoryID', () => String, {nullable: true}) CategoryID?: string,
-                     @Arg('CategoryName', () => String, {nullable: true}) CategoryName?: string,
+                     @Arg('CategoryPath', () => String, {nullable: true}) CategoryPath?: string,
                      @Arg('Parameters', () => GraphQLJSONObject, {nullable: true}) Parameters?: Record<string, any>,
                      @Arg('MaxRows', () => Int, {nullable: true}) MaxRows?: number,
                      @Arg('StartRow', () => Int, {nullable: true}) StartRow?: number): Promise<RunQueryResultType> {
@@ -86,7 +86,7 @@ export class RunQueryResolver {
       { 
         QueryID: QueryID,
         CategoryID: CategoryID,
-        CategoryName: CategoryName,
+        CategoryPath: CategoryPath,
         Parameters: Parameters,
         MaxRows: MaxRows,
         StartRow: StartRow
@@ -102,7 +102,7 @@ export class RunQueryResolver {
     let queryName = result.QueryName;
     if (!queryName) {
       try {
-        const queryInfo = await this.findQuery(QueryID, undefined, CategoryID, CategoryName, true);
+        const queryInfo = await this.findQuery(QueryID, undefined, CategoryID, CategoryPath, true);
         if (queryInfo) {
           queryName = queryInfo.Name;
         }
@@ -128,7 +128,7 @@ export class RunQueryResolver {
   async GetQueryDataByName(@Arg('QueryName', () => String) QueryName: string, 
                            @Ctx() context: AppContext,
                            @Arg('CategoryID', () => String, {nullable: true}) CategoryID?: string,
-                           @Arg('CategoryName', () => String, {nullable: true}) CategoryName?: string,
+                           @Arg('CategoryPath', () => String, {nullable: true}) CategoryPath?: string,
                            @Arg('Parameters', () => GraphQLJSONObject, {nullable: true}) Parameters?: Record<string, any>,
                            @Arg('MaxRows', () => Int, {nullable: true}) MaxRows?: number,
                            @Arg('StartRow', () => Int, {nullable: true}) StartRow?: number): Promise<RunQueryResultType> {
@@ -137,7 +137,7 @@ export class RunQueryResolver {
       { 
         QueryName: QueryName, 
         CategoryID: CategoryID,
-        CategoryName: CategoryName,
+        CategoryPath: CategoryPath,
         Parameters: Parameters,
         MaxRows: MaxRows,
         StartRow: StartRow
@@ -162,7 +162,7 @@ export class RunQueryResolver {
   async GetQueryDataSystemUser(@Arg('QueryID', () => String) QueryID: string, 
                                @Ctx() context: AppContext,
                                @Arg('CategoryID', () => String, {nullable: true}) CategoryID?: string,
-                               @Arg('CategoryName', () => String, {nullable: true}) CategoryName?: string,
+                               @Arg('CategoryPath', () => String, {nullable: true}) CategoryPath?: string,
                                @Arg('Parameters', () => GraphQLJSONObject, {nullable: true}) Parameters?: Record<string, any>,
                                @Arg('MaxRows', () => Int, {nullable: true}) MaxRows?: number,
                                @Arg('StartRow', () => Int, {nullable: true}) StartRow?: number): Promise<RunQueryResultType> {
@@ -171,7 +171,7 @@ export class RunQueryResolver {
       { 
         QueryID: QueryID,
         CategoryID: CategoryID,
-        CategoryName: CategoryName,
+        CategoryPath: CategoryPath,
         Parameters: Parameters,
         MaxRows: MaxRows,
         StartRow: StartRow
@@ -182,7 +182,7 @@ export class RunQueryResolver {
     let queryName = result.QueryName;
     if (!queryName) {
       try {
-        const queryInfo = await this.findQuery(QueryID, undefined, CategoryID, CategoryName, true);
+        const queryInfo = await this.findQuery(QueryID, undefined, CategoryID, CategoryPath, true);
         if (queryInfo) {
           queryName = queryInfo.Name;
         }
@@ -209,7 +209,7 @@ export class RunQueryResolver {
   async GetQueryDataByNameSystemUser(@Arg('QueryName', () => String) QueryName: string, 
                                      @Ctx() context: AppContext,
                                      @Arg('CategoryID', () => String, {nullable: true}) CategoryID?: string,
-                                     @Arg('CategoryName', () => String, {nullable: true}) CategoryName?: string,
+                                     @Arg('CategoryPath', () => String, {nullable: true}) CategoryPath?: string,
                                      @Arg('Parameters', () => GraphQLJSONObject, {nullable: true}) Parameters?: Record<string, any>,
                                      @Arg('MaxRows', () => Int, {nullable: true}) MaxRows?: number,
                                      @Arg('StartRow', () => Int, {nullable: true}) StartRow?: number): Promise<RunQueryResultType> {
@@ -218,7 +218,7 @@ export class RunQueryResolver {
       { 
         QueryName: QueryName,
         CategoryID: CategoryID,
-        CategoryName: CategoryName,
+        CategoryPath: CategoryPath,
         Parameters: Parameters,
         MaxRows: MaxRows,
         StartRow: StartRow

package/src/resolvers/ReportResolver.ts

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

package/src/resolvers/SyncDataResolver.ts

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

package/src/resolvers/SyncRolesUsersResolver.ts

@@ -1,6 +1,6 @@
 import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType } from 'type-graphql';
-import { AppContext } from '../types.js';
-import { LogError, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { AppContext, UserPayload } from '../types.js';
+import { EntityDeleteOptions, EntitySaveOptions, LogError, Metadata, RunView, UserInfo } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { RoleEntity, UserEntity, UserRoleEntity } from '@memberjunction/core-entities';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
@@ -131,9 +131,9 @@ export class SyncRolesAndUsersResolver {
     
             if (result && result.Success) {
                 const currentRoles = result.Results;
-                if (await this.DeleteRemovedRoles(currentRoles, roles, context.userPayload.userRecord)) {
-                    if ( await this.AddNewRoles(currentRoles, roles, context.userPayload.userRecord)) {
-                        return await this.UpdateExistingRoles(currentRoles, roles, context.userPayload.userRecord);
+                if (await this.DeleteRemovedRoles(currentRoles, roles, context.userPayload.userRecord, context.userPayload)) {
+                    if ( await this.AddNewRoles(currentRoles, roles, context.userPayload.userRecord, context.userPayload)) {
+                        return await this.UpdateExistingRoles(currentRoles, roles, context.userPayload);
                     }
                 }
             }
@@ -145,7 +145,7 @@ export class SyncRolesAndUsersResolver {
         }
     }
 
-    protected async UpdateExistingRoles(currentRoles: RoleEntity[], futureRoles: RoleInputType[], user: UserInfo): Promise<SyncRolesAndUsersResultType> {
+    protected async UpdateExistingRoles(currentRoles: RoleEntity[], futureRoles: RoleInputType[], userPayload: UserPayload): Promise<SyncRolesAndUsersResultType> {
         // go through the future roles and update any that are in the current roles
         const md = new Metadata();
         let ok: boolean = true;
@@ -160,7 +160,7 @@ export class SyncRolesAndUsersResolver {
         return { Success: ok };
     }
 
-    protected async AddNewRoles(currentRoles: RoleEntity[], futureRoles: RoleInputType[], user: UserInfo): Promise<boolean> {
+    protected async AddNewRoles(currentRoles: RoleEntity[], futureRoles: RoleInputType[], user: UserInfo, userPayload: UserPayload): Promise<boolean> {
         // go through the future roles and add any that are not in the current roles
         const md = new Metadata();
         let ok: boolean = true;
@@ -177,7 +177,7 @@ export class SyncRolesAndUsersResolver {
     }
 
 
-    protected async DeleteRemovedRoles(currentRoles: RoleEntity[], futureRoles: RoleInputType[], user: UserInfo): Promise<boolean> {
+    protected async DeleteRemovedRoles(currentRoles: RoleEntity[], futureRoles: RoleInputType[], user: UserInfo, userPayload: UserPayload): Promise<boolean> {
         const rv = new RunView();
         let ok: boolean = true;
 
@@ -185,7 +185,7 @@ export class SyncRolesAndUsersResolver {
         for (const remove of currentRoles) {
             if (!this.IsStandardRole(remove.Name)) {
                 if (!futureRoles.find(r => r.Name.trim().toLowerCase() === remove.Name.trim().toLowerCase())) {
-                    ok = ok && await this.DeleteSingleRole(remove, rv, user);
+                    ok = ok && await this.DeleteSingleRole(remove, rv, user, userPayload);
                 }    
             }
         }
@@ -199,9 +199,10 @@ export class SyncRolesAndUsersResolver {
         return this.StandardRoles.find(r => r.toLowerCase() === roleName.toLowerCase()) !== undefined;
     }
 
-    protected async DeleteSingleRole(role: RoleEntity, rv: RunView, user: UserInfo): Promise<boolean> {
+    protected async DeleteSingleRole(role: RoleEntity, rv: RunView, user: UserInfo, userPayload: UserPayload): Promise<boolean> {
         // first, remove all the UserRole records that match this role
         let ok: boolean = true;
+
         const r2 = await rv.RunView<UserRoleEntity>({
             EntityName: "User Roles",
             ExtraFilter: "RoleID = '" + role.ID + "'",
@@ -238,10 +239,10 @@ export class SyncRolesAndUsersResolver {
             if (result && result.Success) {
                 // go through current users and remove those that are not in the input
                 const currentUsers = result.Results;
-                if (await this.DeleteRemovedUsers(currentUsers, users, context.userPayload.userRecord)) {
-                    if (await this.AddNewUsers(currentUsers, users, context.userPayload.userRecord)) {
-                        if (await this.UpdateExistingUsers(currentUsers, users, context.userPayload.userRecord)) {
-                            if (await this.SyncUserRoles(users, context.userPayload.userRecord)) {
+                if (await this.DeleteRemovedUsers(currentUsers, users, context.userPayload.userRecord, context.userPayload)) {
+                    if (await this.AddNewUsers(currentUsers, users, context.userPayload)) {
+                        if (await this.UpdateExistingUsers(currentUsers, users, context.userPayload)) {
+                            if (await this.SyncUserRoles(users, context.userPayload.userRecord, context.userPayload)) {
                                 return { Success: true };
                             }    
                         }
@@ -256,9 +257,10 @@ export class SyncRolesAndUsersResolver {
         }
     }
 
-    protected async UpdateExistingUsers(currentUsers: UserEntity[], futureUsers: UserInputType[], u: UserInfo): Promise<boolean> {  
+    protected async UpdateExistingUsers(currentUsers: UserEntity[], futureUsers: UserInputType[], userPayload: UserPayload): Promise<boolean> {  
         // go through the future users and update any that are in the current users
         let ok: boolean = true;
+
         for (const update of futureUsers) {
             const current = currentUsers.find(c => c.Email?.trim().toLowerCase() === update.Email?.trim().toLowerCase());
             if (current) {
@@ -272,7 +274,7 @@ export class SyncRolesAndUsersResolver {
         }
         return ok;
     }
-    protected async AddNewUsers(currentUsers: UserEntity[], futureUsers: UserInputType[], u: UserInfo): Promise<boolean> {
+    protected async AddNewUsers(currentUsers: UserEntity[], futureUsers: UserInputType[], userPayload: UserPayload): Promise<boolean> {
         // add users that are not in the current users
         const md = new Metadata();
         let ok: boolean = true;
@@ -285,7 +287,7 @@ export class SyncRolesAndUsersResolver {
                 ok = ok && await match.Save();  
             }  
             else {
-                const user = await md.GetEntityObject<UserEntity>("Users", u);
+                const user = await md.GetEntityObject<UserEntity>("Users", userPayload.userRecord);
                 user.Name = add.Name;
                 user.Type = add.Type;
                 user.Email = add.Email;
@@ -300,7 +302,7 @@ export class SyncRolesAndUsersResolver {
         return ok;
     }
 
-    protected async DeleteRemovedUsers(currentUsers: UserEntity[], futureUsers: UserInputType[], u: UserInfo): Promise<boolean> {
+    protected async DeleteRemovedUsers(currentUsers: UserEntity[], futureUsers: UserInputType[], u: UserInfo, userPayload: UserPayload): Promise<boolean> {
         // remove users that are not in the future users
         const rv = new RunView();
         const md = new Metadata();
@@ -310,16 +312,17 @@ export class SyncRolesAndUsersResolver {
         for (const remove of currentUsers) {
             if (remove.Type.trim().toLowerCase() !== 'owner') {
                 if (!futureUsers.find(r => r.Email.trim().toLowerCase() === remove.Email.trim().toLowerCase())) {
-                    ok = ok && await this.DeleteSingleUser(remove, rv, u);
+                    ok = ok && await this.DeleteSingleUser(remove, rv, u, userPayload);
                 }
             }
         }
         return ok;
     }
 
-    protected async DeleteSingleUser(user: UserEntity, rv: RunView, u: UserInfo): Promise<boolean> {
+    protected async DeleteSingleUser(user: UserEntity, rv: RunView, u: UserInfo, userPayload: UserPayload): Promise<boolean> {
         // first, remove all the UserRole records that match this user
         let ok: boolean = true;
+
         const r2 = await rv.RunView<UserRoleEntity>({
             EntityName: "User Roles",
             ExtraFilter: "UserID = '" + user.ID + "'",
@@ -341,7 +344,7 @@ export class SyncRolesAndUsersResolver {
         }
     }
 
-    protected async SyncUserRoles(users: UserInputType[], u: UserInfo): Promise<boolean> {
+    protected async SyncUserRoles(users: UserInputType[], u: UserInfo, userPayload: UserPayload): Promise<boolean> {
         // for each user in the users array, make sure there is a User Role that matches. First, get a list of all DATABASE user and roels so we have that for fast lookup in memory
         const rv = new RunView();
         const md = new Metadata();

package/src/resolvers/TransactionGroupResolver.ts

@@ -1,6 +1,6 @@
 import { Arg, Ctx, Field, InputType, Int, Mutation, ObjectType, registerEnumType } from 'type-graphql';
 import { AppContext } from '../types.js';
-import { CompositeKey, KeyValuePair, LogError, Metadata, TransactionVariable, BaseEntity } from '@memberjunction/core';
+import { CompositeKey, KeyValuePair, LogError, Metadata, TransactionVariable, BaseEntity, EntityDeleteOptions, EntitySaveOptions } from '@memberjunction/core';
 import { SafeJSONParse } from '@memberjunction/global';
 
 export enum TransactionVariableType {

package/src/resolvers/UserFavoriteResolver.ts

@@ -14,9 +14,9 @@ import {
   Resolver,
 } from '@memberjunction/server';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
-import { UserFavoriteEntity } from '@memberjunction/core-entities';
 
 import { UserFavorite_, UserFavoriteResolverBase } from '../generated/generated.js';
+import { GetReadOnlyProvider } from '../util.js';
 
 //****************************************************************************
 // INPUT TYPE for User Favorite Queries
@@ -69,13 +69,15 @@ export class UserFavoriteResult {
 @Resolver(UserFavorite_)
 export class UserFavoriteResolver extends UserFavoriteResolverBase {
   @Query(() => [UserFavorite_])
-  async UserFavoritesByUserID(@Arg('UserID', () => Int) UserID: number, @Ctx() { dataSource, userPayload }: AppContext) {
-    return await this.findBy(dataSource, 'User Favorites', { UserID }, userPayload.userRecord);
+  async UserFavoritesByUserID(@Arg('UserID', () => Int) UserID: number, @Ctx() { providers, userPayload }: AppContext) {
+    const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})    
+    return await this.findBy(provider, 'User Favorites', { UserID }, userPayload.userRecord);
   }
 
   @Query(() => [UserFavorite_])
-  async UserFavoriteSearchByParams(@Arg('params', () => Int) params: UserFavoriteSearchParams, @Ctx() { dataSource, userPayload }: AppContext) {
-    return await this.findBy(dataSource, 'User Favorites', params, userPayload.userRecord);
+  async UserFavoriteSearchByParams(@Arg('params', () => Int) params: UserFavoriteSearchParams, @Ctx() { providers, userPayload }: AppContext) {
+    const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})    
+    return await this.findBy(provider, 'User Favorites', params, userPayload.userRecord);
   }
 
   @Query(() => UserFavoriteResult)

package/src/resolvers/UserResolver.ts

@@ -1,5 +1,6 @@
 import { AppContext, Arg, Ctx, Int, Query, Resolver } from '@memberjunction/server';
 import { User_, UserResolverBase } from '../generated/generated.js';
+import { GetReadOnlyProvider } from '../util.js';
 
 @Resolver(User_)
 export class UserResolver extends UserResolverBase {
@@ -11,22 +12,25 @@ export class UserResolver extends UserResolverBase {
   }
 
   @Query(() => User_)
-  async UserByID(@Arg('ID', () => Int) ID: number, @Ctx() { dataSource, userPayload }: AppContext) {
-    const retVal = super.safeFirstArrayElement(await this.findBy(dataSource, 'Users', { ID }, userPayload.userRecord));
+  async UserByID(@Arg('ID', () => Int) ID: number, @Ctx() { providers, userPayload }: AppContext) {
+    const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})    
+    const retVal = super.safeFirstArrayElement(await this.findBy(provider, 'Users', { ID }, userPayload.userRecord));
     return this.MapFieldNamesToCodeNames('Users', retVal);
   }
 
   @Query(() => User_)
-  async UserByEmployeeID(@Arg('EmployeeID', () => Int) EmployeeID: number, @Ctx() { dataSource, userPayload }: AppContext) {
-    const retVal = super.safeFirstArrayElement(await this.findBy(dataSource, 'Users', { EmployeeID }, userPayload.userRecord));
+  async UserByEmployeeID(@Arg('EmployeeID', () => Int) EmployeeID: number, @Ctx() { providers, userPayload }: AppContext) {
+    const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})    
+    const retVal = super.safeFirstArrayElement(await this.findBy(provider, 'Users', { EmployeeID }, userPayload.userRecord));
     return this.MapFieldNamesToCodeNames('Users', retVal);
   }
 
   @Query(() => User_)
-  async UserByEmail(@Arg('Email', () => String) Email: string, @Ctx() { dataSource, userPayload }: AppContext) {
+  async UserByEmail(@Arg('Email', () => String) Email: string, @Ctx() { providers, userPayload }: AppContext) {
     // const searchEmail = userEmailMap[Email] ?? Email;
     const searchEmail = Email;
-    const returnVal = super.safeFirstArrayElement(await this.findBy(dataSource, 'Users', { Email: searchEmail }, userPayload.userRecord));
+    const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})    
+    const returnVal = super.safeFirstArrayElement(await this.findBy(provider, 'Users', { Email: searchEmail }, userPayload.userRecord));
     return this.MapFieldNamesToCodeNames('Users', returnVal);
   }
 }

package/src/resolvers/UserViewResolver.ts

@@ -1,29 +1,33 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Metadata } from '@memberjunction/core';
+import { EntitySaveOptions, Metadata } from '@memberjunction/core';
 import { AppContext, Arg, Ctx, Int, Query, Resolver, UserPayload } from '@memberjunction/server';
 import { UserView_, UserViewResolverBase } from '../generated/generated.js';
 import { UserResolver } from './UserResolver.js';
 import { UserViewEntity, UserViewEntityExtended } from '@memberjunction/core-entities';
+import { GetReadOnlyProvider } from '../util.js';
 
 @Resolver(UserView_)
 export class UserViewResolver extends UserViewResolverBase {
   @Query(() => [UserView_])
-  async UserViewsByUserID(@Arg('UserID', () => Int) UserID: number, @Ctx() { dataSource, userPayload }: AppContext) {
-    return await this.findBy(dataSource, 'User Views', { UserID }, userPayload.userRecord);
+  async UserViewsByUserID(@Arg('UserID', () => Int) UserID: number, @Ctx() { providers, userPayload }: AppContext) {
+    const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})    
+    return await this.findBy(provider, 'User Views', { UserID }, userPayload.userRecord);
   }
 
   @Query(() => [UserView_])
   async DefaultViewByUserAndEntity(
     @Arg('UserID', () => Int) UserID: number,
     @Arg('EntityID', () => Int) EntityID: number,
-    @Ctx() { dataSource, userPayload }: AppContext
+    @Ctx() { providers, userPayload }: AppContext
   ) {
-    return await this.findBy(dataSource, 'User Views', { UserID, EntityID, IsDefault: true }, userPayload.userRecord);
+    const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})    
+    return await this.findBy(provider, 'User Views', { UserID, EntityID, IsDefault: true }, userPayload.userRecord);
   }
 
   @Query(() => [UserView_])
   async CurrentUserDefaultViewByEntityID(@Arg('EntityID', () => Int) EntityID: number, @Ctx() context: AppContext) {
-    return await this.findBy(context.dataSource, 'User Views', {
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true})    
+    return await this.findBy(provider, 'User Views', {
       UserID: await this.getCurrentUserID(context),
       EntityID,
       IsDefault: true,
@@ -38,7 +42,8 @@ export class UserViewResolver extends UserViewResolverBase {
 
   @Query(() => [UserView_])
   async CurrentUserUserViewsByEntityID(@Arg('EntityID', () => Int) EntityID: number, @Ctx() context: AppContext) {
-    return this.findBy(context.dataSource, 'User Views', { UserID: await this.getCurrentUserID(context), EntityID}, context.userPayload.userRecord);
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true})    
+    return this.findBy(provider, 'User Views', { UserID: await this.getCurrentUserID(context), EntityID}, context.userPayload.userRecord);
   }
 
   @Query(() => [UserView_])
@@ -52,6 +57,7 @@ export class UserViewResolver extends UserViewResolverBase {
     const viewEntity = <UserViewEntityExtended>await md.GetEntityObject('User Views', u);
     await viewEntity.Load(ID);
     viewEntity.UpdateWhereClause();
+
     if (await viewEntity.Save()) {
       return viewEntity.GetAll();
     } else {

package/src/scheduler/LearningCycleScheduler.ts

@@ -1,10 +1,11 @@
 import { LogStatus, LogError } from '@memberjunction/core';
-import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { SQLServerDataProvider, SQLServerProviderConfigData, UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { GetReadWriteDataSource } from '../util.js';
 import { AskSkipResolver } from '../resolvers/AskSkipResolver.js';
-import { DataSourceInfo } from '../types.js';
+import { AppContext, DataSourceInfo } from '../types.js';
 import { getSystemUser } from '../auth/index.js';
 import { BaseSingleton } from '@memberjunction/global';
+import { mj_core_schema } from '../config.js';
 
 /**
  * A simple scheduler for the Skip AI learning cycle
@@ -89,7 +90,11 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
       }
       
       // Create context for the resolver
-      const context = {
+      const config = new SQLServerProviderConfigData(dataSource, mj_core_schema, 0, undefined, undefined, false);
+      const p = new SQLServerDataProvider();
+      await p.Config(config);
+
+      const context: AppContext = {
         dataSource: dataSource,
         dataSources: this.dataSources,
         userPayload: {
@@ -97,7 +102,8 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
           sessionId: `scheduler_${Date.now()}`,
           userRecord: systemUser,
           isSystemUser: true
-        }
+        },
+        providers: [{provider: p, type: 'Read-Write'}]
       };
       
       // Execute the learning cycle

package/src/types.ts

@@ -1,10 +1,11 @@
-import { UserInfo } from '@memberjunction/core';
+import { DatabaseProviderBase, UserInfo } from '@memberjunction/core';
 import { UserViewEntity } from '@memberjunction/core-entities';
 import { GraphQLSchema } from 'graphql';
 import { PubSubEngine } from 'type-graphql';
 import sql from 'mssql';
 import { getSystemUser } from './auth/index.js';
 import { MJEvent, MJEventType, MJGlobal } from '@memberjunction/global';
+import { SQLServerDataProvider } from '@memberjunction/sqlserver-dataprovider';
 
 export type UserPayload = {
   email: string;
@@ -28,8 +29,18 @@ export type AppContext = {
    * Array of connection pools that have additional information about their intended use e.g. Admin, Read-Write, Read-Only.
    */
   dataSources: DataSourceInfo[];
+
+  /**
+   * Per-request DatabaseProviderBase instances  
+   */
+  providers: Array<ProviderInfo>;
 };
 
+export class ProviderInfo {
+  provider: DatabaseProviderBase;
+  type: 'Admin' | 'Read-Write' | 'Read-Only' | 'Other';
+}
+
 export class DataSourceInfo  {
   dataSource: sql.ConnectionPool;
   host: string;
@@ -56,7 +67,7 @@ export type DirectiveBuilder = {
 
 export type RunViewGenericParams = {
   viewInfo: UserViewEntity;
-  dataSource: sql.ConnectionPool;
+  provider: DatabaseProviderBase;
   extraFilter: string;
   orderBy: string;
   userSearchString: string;
@@ -69,8 +80,7 @@ export type RunViewGenericParams = {
   forceAuditLog?: boolean;
   auditLogDescription?: string;
   resultType?: string;
-  userPayload?: UserPayload;
-  pubSub: PubSubEngine;
+  userPayload?: UserPayload; 
 };