@memberjunction/server 4.4.0 → 5.0.0

package/src/resolvers/ISAEntityResolver.ts

@@ -20,10 +20,27 @@ export class ISAChildEntityResult {
     ErrorMessage?: string;
 }
 
+/**
+ * Result type for the IS-A child entities discovery query (plural).
+ * Returns all child entity type names that have records matching the given
+ * parent entity's primary key. Used for overlapping subtype parents.
+ */
+@ObjectType()
+export class ISAChildEntitiesResult {
+    @Field(() => Boolean)
+    Success: boolean;
+
+    @Field(() => [String], { nullable: true })
+    ChildEntityNames?: string[];
+
+    @Field(() => String, { nullable: true })
+    ErrorMessage?: string;
+}
+
 /**
  * Resolver for IS-A entity hierarchy discovery.
  *
- * Provides a GraphQL endpoint for client-side code to discover child entity
+ * Provides GraphQL endpoints for client-side code to discover child entity
  * records in an IS-A hierarchy. This enables bidirectional chain construction
  * where a loaded entity discovers its more-derived child type.
  */
@@ -91,6 +108,65 @@ export class ISAEntityResolver {
             };
         }
     }
+
+    /**
+     * Discovers ALL IS-A child entities that have records with the given primary
+     * key value. Used for overlapping subtype parents (AllowMultipleSubtypes = true)
+     * where multiple children can coexist. The server executes a single UNION ALL
+     * query across all child entity tables for maximum efficiency.
+     *
+     * @param EntityName The parent entity name to check children for
+     * @param RecordID The primary key value to search for in child tables
+     * @returns Array of child entity names found (empty if none)
+     */
+    @Query(() => ISAChildEntitiesResult)
+    async FindISAChildEntities(
+        @Arg('EntityName', () => String) EntityName: string,
+        @Arg('RecordID', () => String) RecordID: string,
+        @Ctx() { providers, userPayload }: AppContext
+    ): Promise<ISAChildEntitiesResult> {
+        try {
+            const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+            const md = new Metadata();
+            const entityInfo = md.Entities.find(e => e.Name === EntityName);
+
+            if (!entityInfo) {
+                return {
+                    Success: false,
+                    ErrorMessage: `Entity '${EntityName}' not found`
+                };
+            }
+
+            if (!entityInfo.IsParentType) {
+                return { Success: true, ChildEntityNames: [] };
+            }
+
+            const entityProvider = provider as unknown as IEntityDataProvider;
+            if (!entityProvider.FindISAChildEntities) {
+                return {
+                    Success: false,
+                    ErrorMessage: 'Provider does not support FindISAChildEntities'
+                };
+            }
+
+            const results = await entityProvider.FindISAChildEntities(
+                entityInfo,
+                RecordID,
+                userPayload?.userRecord
+            );
+
+            return {
+                Success: true,
+                ChildEntityNames: results.map(r => r.ChildEntityName)
+            };
+        }
+        catch (e) {
+            return {
+                Success: false,
+                ErrorMessage: e instanceof Error ? e.message : String(e)
+            };
+        }
+    }
 }
 
 export default ISAEntityResolver;

package/src/resolvers/ReportResolver.ts

@@ -1,7 +1,7 @@
 import { EntitySaveOptions, IRunReportProvider, 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';
+import { MJConversationDetailEntity, MJReportEntity } from '@memberjunction/core-entities';
 import { SkipAPIAnalysisCompleteResponse } from '@memberjunction/skip-types';
 import { DataContext } from '@memberjunction/data-context';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
@@ -84,10 +84,10 @@ export class ReportResolverExtended extends ResolverBase {
       const u = UserCache.Users.find((u) => u.Email?.trim().toLowerCase() === userPayload?.email?.trim().toLowerCase());
       if (!u) throw new Error('Unable to find user');
 
-      const cde = md.Entities.find((e) => e.Name === 'Conversation Details');
+      const cde = md.Entities.find((e) => e.Name === 'MJ: Conversation Details');
       if (!cde) throw new Error('Unable to find Conversation Details Entity metadata');
 
-      const cd = md.Entities.find((e) => e.Name === 'Conversations');
+      const cd = md.Entities.find((e) => e.Name === 'MJ: Conversations');
       if (!cd) throw new Error('Unable to find Conversations Entity metadata');
 
       const sql = `SELECT
@@ -106,7 +106,7 @@ export class ReportResolverExtended extends ResolverBase {
       if (!result || !result.recordset || result.recordset.length === 0) throw new Error('Unable to retrieve converation details');
       const skipData = <SkipAPIAnalysisCompleteResponse>JSON.parse(result.recordset[0].Message);
 
-      const report = await md.GetEntityObject<ReportEntity>('Reports', u);
+      const report = await md.GetEntityObject<MJReportEntity>('MJ: Reports', u);
       report.NewRecord();
       // support the legacy report title as old conversation details had a reportTitle property
       // but the new SkipData object has a title property, so favor the title property

package/src/resolvers/RunAIAgentResolver.ts

@@ -1,7 +1,7 @@
 import { Resolver, Mutation, Query, Arg, Ctx, ObjectType, Field, PubSub, PubSubEngine, Subscription, Root, ResolverFilterData, ID, Int } from 'type-graphql';
 import { AppContext, UserPayload } from '../types.js';
 import { DatabaseProviderBase, LogError, LogStatus, Metadata, RunView, UserInfo } from '@memberjunction/core';
-import { ConversationDetailEntity, ConversationDetailAttachmentEntity } from '@memberjunction/core-entities';
+import { MJConversationDetailEntity, MJConversationDetailAttachmentEntity } from '@memberjunction/core-entities';
 import { AgentRunner } from '@memberjunction/ai-agents';
 import { AIAgentEntityExtended, AIAgentRunEntityExtended, ExecuteAgentResult, ConversationUtility, AttachmentData } from '@memberjunction/ai-core-plus';
 import { AIEngine } from '@memberjunction/aiengine';
@@ -646,8 +646,8 @@ export class RunAIAgentResolver extends ResolverBase {
             const agentName = agent?.Name || 'Agent';
 
             // Load conversation detail to get conversation info
-            const detail = await md.GetEntityObject<ConversationDetailEntity>(
-                'Conversation Details',
+            const detail = await md.GetEntityObject<MJConversationDetailEntity>(
+                'MJ: Conversation Details',
                 contextUser
             );
             if (!(await detail.Load(conversationDetailId))) {
@@ -815,8 +815,8 @@ export class RunAIAgentResolver extends ResolverBase {
         const attachmentService = getAttachmentService();
 
         // Load the current conversation detail to get the conversation ID
-        const currentDetail = await md.GetEntityObject<ConversationDetailEntity>(
-            'Conversation Details',
+        const currentDetail = await md.GetEntityObject<MJConversationDetailEntity>(
+            'MJ: Conversation Details',
             contextUser
         );
         if (!await currentDetail.Load(conversationDetailId)) {
@@ -826,8 +826,8 @@ export class RunAIAgentResolver extends ResolverBase {
         const conversationId = currentDetail.ConversationID;
 
         // Load recent conversation details (messages) for this conversation
-        const detailsResult = await rv.RunView<ConversationDetailEntity>({
-            EntityName: 'Conversation Details',
+        const detailsResult = await rv.RunView<MJConversationDetailEntity>({
+            EntityName: 'MJ: Conversation Details',
             ExtraFilter: `ConversationID='${conversationId}'`,
             OrderBy: '__mj_CreatedAt DESC',
             MaxRows: maxMessages,

package/src/resolvers/RunAIPromptResolver.ts

@@ -156,7 +156,7 @@ export class RunAIPromptResolver extends ResolverBase {
             }
 
             // Load the AI prompt entity
-            const promptEntity = await p.GetEntityObject<AIPromptEntityExtended>('AI Prompts', currentUser);
+            const promptEntity = await p.GetEntityObject<AIPromptEntityExtended>('MJ: AI Prompts', currentUser);
             await promptEntity.Load(promptId);
             
             if (!promptEntity.IsSaved) {

package/src/resolvers/RunTemplateResolver.ts

@@ -1,7 +1,7 @@
 import { Resolver, Mutation, Arg, Ctx, ObjectType, Field } from 'type-graphql';
 import { AppContext, UserPayload } from '../types.js';
 import { LogError, LogStatus, Metadata, RunView } from '@memberjunction/core';
-import { TemplateContentEntity, TemplateEntityExtended } from '@memberjunction/core-entities';
+import { MJTemplateContentEntity, TemplateEntityExtended } from '@memberjunction/core-entities';
 import { TemplateEngineServer } from '@memberjunction/templates';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { GetReadWriteProvider } from '../util.js';
@@ -63,7 +63,7 @@ export class RunTemplateResolver extends ResolverBase {
             
             const p = GetReadWriteProvider(providers);
             // Load the template entity
-            const templateEntity = await p.GetEntityObject<TemplateEntityExtended>('Templates', currentUser);
+            const templateEntity = await p.GetEntityObject<TemplateEntityExtended>('MJ: Templates', currentUser);
             await templateEntity.Load(templateId);
             
             if (!templateEntity.IsSaved) {
@@ -76,8 +76,8 @@ export class RunTemplateResolver extends ResolverBase {
 
             // Load template content (get the first/highest priority content)
             const rv = new RunView();
-            const templateContentResult = await rv.RunView<TemplateContentEntity>({
-                EntityName: 'Template Contents',
+            const templateContentResult = await rv.RunView<MJTemplateContentEntity>({
+                EntityName: 'MJ: Template Contents',
                 ExtraFilter: `TemplateID = '${templateId}'`,
                 OrderBy: 'Priority ASC',
                 MaxRows: 1,

package/src/resolvers/SyncDataResolver.ts

@@ -3,7 +3,7 @@ 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';
+import { MJDatasetItemEntity } from '@memberjunction/core-entities';
 
 
 
@@ -134,8 +134,8 @@ export class SyncDataResolver {
     protected async GetLowercaseMetadataEntitiesList(user: UserInfo, forceRefresh: boolean = false): Promise<string[]> {
         if (forceRefresh || __metadata_DatasetItems.length === 0) {
             const rv = new RunView(); // cache this, veyr simple - should use an engine for this stuff later
-            const result = await rv.RunView<DatasetItemEntity>({
-                EntityName: "Dataset Items",
+            const result = await rv.RunView<MJDatasetItemEntity>({
+                EntityName: "MJ: Dataset Items",
                 ExtraFilter: "Dataset = 'MJ_Metadata'",
             }, user)
             if (result && result.Success) {

package/src/resolvers/SyncRolesUsersResolver.ts

@@ -2,7 +2,7 @@ import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType } fr
 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 { MJRoleEntity, MJUserEntity, MJUserRoleEntity } from '@memberjunction/core-entities';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 
 @ObjectType()
@@ -124,8 +124,8 @@ export class SyncRolesAndUsersResolver {
             // we iterate through the provided roles and we remove roles that are not in the input and add roles that are new
             // and update roles that already exist
             const rv = new RunView();
-            const result = await rv.RunView<RoleEntity>({
-                EntityName: "Roles",
+            const result = await rv.RunView<MJRoleEntity>({
+                EntityName: "MJ: Roles",
                 ResultType: 'entity_object'
             }, context.userPayload.userRecord);
     
@@ -145,7 +145,7 @@ export class SyncRolesAndUsersResolver {
         }
     }
 
-    protected async UpdateExistingRoles(currentRoles: RoleEntity[], futureRoles: RoleInputType[], userPayload: UserPayload): Promise<SyncRolesAndUsersResultType> {
+    protected async UpdateExistingRoles(currentRoles: MJRoleEntity[], 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,14 +160,14 @@ export class SyncRolesAndUsersResolver {
         return { Success: ok };
     }
 
-    protected async AddNewRoles(currentRoles: RoleEntity[], futureRoles: RoleInputType[], user: UserInfo, userPayload: UserPayload): Promise<boolean> {
+    protected async AddNewRoles(currentRoles: MJRoleEntity[], 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;
 
         for (const add of futureRoles) {
             if (!currentRoles.find(r => r.Name.trim().toLowerCase() === add.Name.trim().toLowerCase())) {
-                const role = await md.GetEntityObject<RoleEntity>("Roles", user);
+                const role = await md.GetEntityObject<MJRoleEntity>("MJ: Roles", user);
                 role.Name = add.Name;
                 role.Description = add.Description;
                 ok = ok && await role.Save();  
@@ -177,7 +177,7 @@ export class SyncRolesAndUsersResolver {
     }
 
 
-    protected async DeleteRemovedRoles(currentRoles: RoleEntity[], futureRoles: RoleInputType[], user: UserInfo, userPayload: UserPayload): Promise<boolean> {
+    protected async DeleteRemovedRoles(currentRoles: MJRoleEntity[], futureRoles: RoleInputType[], user: UserInfo, userPayload: UserPayload): Promise<boolean> {
         const rv = new RunView();
         let ok: boolean = true;
 
@@ -199,12 +199,12 @@ export class SyncRolesAndUsersResolver {
         return this.StandardRoles.find(r => r.toLowerCase() === roleName.toLowerCase()) !== undefined;
     }
 
-    protected async DeleteSingleRole(role: RoleEntity, rv: RunView, user: UserInfo, userPayload: UserPayload): Promise<boolean> {
+    protected async DeleteSingleRole(role: MJRoleEntity, 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",
+        const r2 = await rv.RunView<MJUserRoleEntity>({
+            EntityName: "MJ: User Roles",
             ExtraFilter: "RoleID = '" + role.ID + "'",
             ResultType: 'entity_object'
         }, user);
@@ -232,8 +232,8 @@ export class SyncRolesAndUsersResolver {
             // first, we sync up the users and then the user roles. 
             // for syncing users we first remove users that are no longer in the input, then we add new users and update existing users
             const rv = new RunView();
-            const result = await rv.RunView<UserEntity>({
-                EntityName: "Users",
+            const result = await rv.RunView<MJUserEntity>({
+                EntityName: "MJ: Users",
                 ResultType: 'entity_object'
             }, context.userPayload.userRecord);
             if (result && result.Success) {
@@ -257,7 +257,7 @@ export class SyncRolesAndUsersResolver {
         }
     }
 
-    protected async UpdateExistingUsers(currentUsers: UserEntity[], futureUsers: UserInputType[], userPayload: UserPayload): Promise<boolean> {  
+    protected async UpdateExistingUsers(currentUsers: MJUserEntity[], futureUsers: UserInputType[], userPayload: UserPayload): Promise<boolean> {  
         // go through the future users and update any that are in the current users
         let ok: boolean = true;
 
@@ -274,7 +274,7 @@ export class SyncRolesAndUsersResolver {
         }
         return ok;
     }
-    protected async AddNewUsers(currentUsers: UserEntity[], futureUsers: UserInputType[], userPayload: UserPayload): Promise<boolean> {
+    protected async AddNewUsers(currentUsers: MJUserEntity[], futureUsers: UserInputType[], userPayload: UserPayload): Promise<boolean> {
         // add users that are not in the current users
         const md = new Metadata();
         let ok: boolean = true;
@@ -287,7 +287,7 @@ export class SyncRolesAndUsersResolver {
                 ok = ok && await match.Save();  
             }  
             else {
-                const user = await md.GetEntityObject<UserEntity>("Users", userPayload.userRecord);
+                const user = await md.GetEntityObject<MJUserEntity>("MJ: Users", userPayload.userRecord);
                 user.Name = add.Name;
                 user.Type = add.Type;
                 user.Email = add.Email;
@@ -302,7 +302,7 @@ export class SyncRolesAndUsersResolver {
         return ok;
     }
 
-    protected async DeleteRemovedUsers(currentUsers: UserEntity[], futureUsers: UserInputType[], u: UserInfo, userPayload: UserPayload): Promise<boolean> {
+    protected async DeleteRemovedUsers(currentUsers: MJUserEntity[], 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();
@@ -319,12 +319,12 @@ export class SyncRolesAndUsersResolver {
         return ok;
     }
 
-    protected async DeleteSingleUser(user: UserEntity, rv: RunView, u: UserInfo, userPayload: UserPayload): Promise<boolean> {
+    protected async DeleteSingleUser(user: MJUserEntity, 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",
+        const r2 = await rv.RunView<MJUserRoleEntity>({
+            EntityName: "MJ: User Roles",
             ExtraFilter: "UserID = '" + user.ID + "'",
             ResultType: 'entity_object'
         }, u);
@@ -349,16 +349,16 @@ export class SyncRolesAndUsersResolver {
         const rv = new RunView();
         const md = new Metadata();
 
-        const p1 = rv.RunView<UserEntity>({
-            EntityName: "Users",
+        const p1 = rv.RunView<MJUserEntity>({
+            EntityName: "MJ: Users",
             ResultType: 'entity_object'
         }, u);
-        const p2 = rv.RunView<RoleEntity>({
-            EntityName: "Roles",
+        const p2 = rv.RunView<MJRoleEntity>({
+            EntityName: "MJ: Roles",
             ResultType: 'entity_object'
         }, u);
-        const p3 = rv.RunView<UserRoleEntity>({
-            EntityName: "User Roles",
+        const p3 = rv.RunView<MJUserRoleEntity>({
+            EntityName: "MJ: User Roles",
             ResultType: 'entity_object'
         }, u);
 
@@ -384,7 +384,7 @@ export class SyncRolesAndUsersResolver {
                             // now we need to make sure there is a user role that matches this user and role
                             if (!dbUserRoles.find(ur => ur.UserID === dbUser.ID && ur.RoleID === dbRole.ID)) {
                                 // we need to add a user role
-                                const ur = await md.GetEntityObject<UserRoleEntity>("User Roles", u);
+                                const ur = await md.GetEntityObject<MJUserRoleEntity>("MJ: User Roles", u);
                                 ur.UserID = dbUser.ID;
                                 ur.RoleID = dbRole.ID;
                                 ok = ok && await ur.Save();  

package/src/resolvers/UserFavoriteResolver.ts

@@ -71,13 +71,13 @@ export class UserFavoriteResolver extends MJUserFavoriteResolverBase {
   @Query(() => [MJUserFavorite_])
   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);
+    return await this.findBy(provider, 'MJ: User Favorites', { UserID }, userPayload.userRecord);
   }
 
   @Query(() => [MJUserFavorite_])
   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);
+    return await this.findBy(provider, 'MJ: User Favorites', params, userPayload.userRecord);
   }
 
   @Query(() => UserFavoriteResult)

package/src/resolvers/UserResolver.ts

@@ -30,7 +30,7 @@ export class UserResolver extends MJUserResolverBase {
         __mj_CreatedAt: userRecord.__mj_CreatedAt,
         __mj_UpdatedAt: userRecord.__mj_UpdatedAt,
         // Include the UserRoles sub-array for the GraphQL response
-        UserRoles_UserIDArray: userRecord.UserRoles?.map((r: { ID: string; UserID: string; RoleID: string; RoleName?: string; __mj_CreatedAt?: Date; __mj_UpdatedAt?: Date }) => ({
+        MJUserRoles_UserIDArray: userRecord.UserRoles?.map((r: { ID: string; UserID: string; RoleID: string; RoleName?: string; __mj_CreatedAt?: Date; __mj_UpdatedAt?: Date }) => ({
           ID: r.ID,
           UserID: r.UserID,
           RoleID: r.RoleID,
@@ -41,7 +41,7 @@ export class UserResolver extends MJUserResolverBase {
         })) || [],
       };
       console.log('CurrentUser (from userRecord)', userData.Email);
-      return this.MapFieldNamesToCodeNames('Users', userData);
+      return this.MapFieldNamesToCodeNames('MJ: Users', userData);
     }
 
     // Fall back to email lookup for JWT-based auth
@@ -56,8 +56,8 @@ export class UserResolver extends MJUserResolverBase {
     await this.CheckAPIKeyScopeAuthorization('user:read', ID.toString(), userPayload);
 
     const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})
-    const retVal = super.safeFirstArrayElement(await this.findBy(provider, 'Users', { ID }, userPayload.userRecord));
-    return this.MapFieldNamesToCodeNames('Users', retVal);
+    const retVal = super.safeFirstArrayElement(await this.findBy(provider, 'MJ: Users', { ID }, userPayload.userRecord));
+    return this.MapFieldNamesToCodeNames('MJ: Users', retVal);
   }
 
   @Query(() => MJUser_)
@@ -66,8 +66,8 @@ export class UserResolver extends MJUserResolverBase {
     await this.CheckAPIKeyScopeAuthorization('user:read', EmployeeID.toString(), userPayload);
 
     const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})
-    const retVal = super.safeFirstArrayElement(await this.findBy(provider, 'Users', { EmployeeID }, userPayload.userRecord));
-    return this.MapFieldNamesToCodeNames('Users', retVal);
+    const retVal = super.safeFirstArrayElement(await this.findBy(provider, 'MJ: Users', { EmployeeID }, userPayload.userRecord));
+    return this.MapFieldNamesToCodeNames('MJ: Users', retVal);
   }
 
   @Query(() => MJUser_)
@@ -78,8 +78,8 @@ export class UserResolver extends MJUserResolverBase {
     // const searchEmail = userEmailMap[Email] ?? Email;
     const searchEmail = Email;
     const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})
-    const returnVal = super.safeFirstArrayElement(await this.findBy(provider, 'Users', { Email: searchEmail }, userPayload.userRecord));
-    return this.MapFieldNamesToCodeNames('Users', returnVal);
+    const returnVal = super.safeFirstArrayElement(await this.findBy(provider, 'MJ: Users', { Email: searchEmail }, userPayload.userRecord));
+    return this.MapFieldNamesToCodeNames('MJ: Users', returnVal);
   }
 }
 export default UserResolver;

package/src/resolvers/UserViewResolver.ts

@@ -3,7 +3,7 @@ import { EntitySaveOptions, Metadata } from '@memberjunction/core';
 import { AppContext, Arg, Ctx, Int, Query, Resolver, UserPayload } from '@memberjunction/server';
 import { MJUserView_, MJUserViewResolverBase } from '../generated/generated.js';
 import { UserResolver } from './UserResolver.js';
-import { UserViewEntity, UserViewEntityExtended } from '@memberjunction/core-entities';
+import { MJUserViewEntity, UserViewEntityExtended } from '@memberjunction/core-entities';
 import { GetReadOnlyProvider } from '../util.js';
 
 @Resolver(MJUserView_)
@@ -11,7 +11,7 @@ export class UserViewResolver extends MJUserViewResolverBase {
   @Query(() => [MJUserView_])
   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);
+    return await this.findBy(provider, 'MJ: User Views', { UserID }, userPayload.userRecord);
   }
 
   @Query(() => [MJUserView_])
@@ -21,13 +21,13 @@ export class UserViewResolver extends MJUserViewResolverBase {
     @Ctx() { providers, userPayload }: AppContext
   ) {
     const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})    
-    return await this.findBy(provider, 'User Views', { UserID, EntityID, IsDefault: true }, userPayload.userRecord);
+    return await this.findBy(provider, 'MJ: User Views', { UserID, EntityID, IsDefault: true }, userPayload.userRecord);
   }
 
   @Query(() => [MJUserView_])
   async CurrentUserDefaultViewByEntityID(@Arg('EntityID', () => Int) EntityID: number, @Ctx() context: AppContext) {
     const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true})    
-    return await this.findBy(provider, 'User Views', {
+    return await this.findBy(provider, 'MJ: User Views', {
       UserID: await this.getCurrentUserID(context),
       EntityID,
       IsDefault: true,
@@ -43,7 +43,7 @@ export class UserViewResolver extends MJUserViewResolverBase {
   @Query(() => [MJUserView_])
   async CurrentUserUserViewsByEntityID(@Arg('EntityID', () => Int) EntityID: number, @Ctx() context: AppContext) {
     const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true})    
-    return this.findBy(provider, 'User Views', { UserID: await this.getCurrentUserID(context), EntityID}, context.userPayload.userRecord);
+    return this.findBy(provider, 'MJ: User Views', { UserID: await this.getCurrentUserID(context), EntityID}, context.userPayload.userRecord);
   }
 
   @Query(() => [MJUserView_])
@@ -54,7 +54,7 @@ export class UserViewResolver extends MJUserViewResolverBase {
     // filter state which in turn will be used to update the where clause in the entity sub-class.
     const p = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
     const u = this.GetUserFromPayload(userPayload);
-    const viewEntity = <UserViewEntityExtended>await p.GetEntityObject('User Views', u);
+    const viewEntity = <UserViewEntityExtended>await p.GetEntityObject('MJ: User Views', u);
     await viewEntity.Load(ID);
     viewEntity.UpdateWhereClause();
 

package/src/rest/ViewOperationsHandler.ts

@@ -142,7 +142,7 @@ export class ViewOperationsHandler {
             
             // Run a view to get the available views
             const params: RunViewParams = {
-                EntityName: 'User Views',
+                EntityName: 'MJ: User Views',
                 ExtraFilter: `Entity = '${entityName}'`
             };