@memberjunction/server 2.104.0 → 2.106.0

package/src/index.ts

@@ -44,28 +44,10 @@ LoadAgentManagementActions();
 import { resolve } from 'node:path';
 import { DataSourceInfo, raiseEvent } from './types.js';
 import { LoadAIEngine } from '@memberjunction/aiengine';
-import { LoadOpenAILLM } from '@memberjunction/ai-openai';
-import { LoadAnthropicLLM } from '@memberjunction/ai-anthropic';
-import { LoadGroqLLM } from '@memberjunction/ai-groq';
-import { LoadCerebrasLLM } from '@memberjunction/ai-cerebras';
-import { LoadMistralLLM } from '@memberjunction/ai-mistral';
-import { LoadLMStudioLLM } from '@memberjunction/ai-lmstudio';
-import { LoadOpenRouterLLM } from '@memberjunction/ai-openrouter';
-import { LoadOllamaLLM } from '@memberjunction/ai-ollama';
-import { LoadLocalEmbedding } from '@memberjunction/ai-local-embeddings';
-// Load AI LLMs and Base AI Engine
-// These imports are necessary to ensure the LLMs are registered in the MemberJunction AI
-// system. They are not tree-shaken because they are dynamically loaded at runtime.
+import { LoadAIProviders } from '@memberjunction/ai-provider-bundle';
+// Load AI Engine and all providers to prevent tree shaking
 LoadAIEngine();
-LoadOpenAILLM();
-LoadAnthropicLLM();
-LoadGroqLLM();
-LoadCerebrasLLM();
-LoadMistralLLM();
-LoadLMStudioLLM();
-LoadOpenRouterLLM();
-LoadOllamaLLM();
-LoadLocalEmbedding();
+LoadAIProviders();
 
 import { ExternalChangeDetectorEngine } from '@memberjunction/external-change-detection';
 
@@ -86,10 +68,14 @@ export * from './generic/RunViewResolver.js';
 export * from './resolvers/RunTemplateResolver.js';
 export * from './resolvers/RunAIPromptResolver.js';
 export * from './resolvers/RunAIAgentResolver.js';
+export * from './resolvers/TaskResolver.js';
 export * from './generic/KeyValuePairInput.js';
 export * from './generic/KeyInputOutputTypes.js';
 export * from './generic/DeleteOptionsInput.js';
 
+export * from './agents/skip-agent.js';
+export * from './agents/skip-sdk.js';
+
 export * from './resolvers/AskSkipResolver.js';
 export * from './resolvers/ColorResolver.js';
 export * from './resolvers/ComponentRegistryResolver.js';

package/src/resolvers/CreateQueryResolver.ts

@@ -3,7 +3,7 @@ import { AppContext } from '../types.js';
 import { LogError, Metadata, RunView, UserInfo, CompositeKey, DatabaseProviderBase } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { QueryCategoryEntity, QueryPermissionEntity } from '@memberjunction/core-entities';
-import { QueryResolver } from '../generated/generated.js';
+import { MJQueryResolver } from '../generated/generated.js';
 import { GetReadOnlyProvider, GetReadWriteProvider } from '../util.js';
 import { DeleteOptionsInput } from '../generic/DeleteOptionsInput.js';
 import { QueryEntityExtended } from '@memberjunction/core-entities-server';
@@ -294,7 +294,7 @@ export class DeleteQueryResultType {
 }
 
 @Resolver()
-export class QueryResolverExtended extends QueryResolver {
+export class MJQueryResolverExtended extends MJQueryResolver {
     /**
      * Creates a new query with the provided attributes. This mutation is restricted to system users only.
      * @param input - CreateQuerySystemUserInput containing all the query attributes
@@ -373,7 +373,7 @@ export class QueryResolverExtended extends QueryResolver {
             LogError(err);
             return {
                 Success: false,
-                ErrorMessage: `QueryResolverExtended::CreateQuerySystemUser --- Error creating query: ${err instanceof Error ? err.message : String(err)}`
+                ErrorMessage: `MJQueryResolverExtended::CreateQuerySystemUser --- Error creating query: ${err instanceof Error ? err.message : String(err)}`
             };
         }
     }
@@ -553,7 +553,7 @@ export class QueryResolverExtended extends QueryResolver {
             LogError(err);
             return {
                 Success: false,
-                ErrorMessage: `QueryResolverExtended::UpdateQuerySystemUser --- Error updating query: ${err instanceof Error ? err.message : String(err)}`
+                ErrorMessage: `MJQueryResolverExtended::UpdateQuerySystemUser --- Error updating query: ${err instanceof Error ? err.message : String(err)}`
             };
         }
     }
@@ -578,7 +578,7 @@ export class QueryResolverExtended extends QueryResolver {
             if (!ID || ID.trim() === '') {
                 return {
                     Success: false,
-                    ErrorMessage: 'QueryResolverExtended::DeleteQuerySystemResolver --- Invalid query ID: ID cannot be null or empty'
+                    ErrorMessage: 'MJQueryResolverExtended::DeleteQuerySystemResolver --- Invalid query ID: ID cannot be null or empty'
                 };
             }
 
@@ -610,7 +610,7 @@ export class QueryResolverExtended extends QueryResolver {
             LogError(err);
             return {
                 Success: false,
-                ErrorMessage: `QueryResolverExtended::DeleteQuerySystemResolver --- Error deleting query: ${err instanceof Error ? err.message : String(err)}`
+                ErrorMessage: `MJQueryResolverExtended::DeleteQuerySystemResolver --- Error deleting query: ${err instanceof Error ? err.message : String(err)}`
             };
         }
     }

package/src/resolvers/EntityResolver.ts

@@ -1,13 +1,13 @@
 import { EntityPermissionType, IRunViewProvider } from '@memberjunction/core';
 import { AppContext } from '../types.js';
 import { Arg, Ctx, Query, Resolver, InputType, Field } from 'type-graphql';
-import { Entity_, EntityResolverBase } from '../generated/generated.js';
+import { MJEntity_, MJEntityResolverBase } from '../generated/generated.js';
 import sql from 'mssql';
 import { GetReadOnlyProvider } from '../util.js';
 
-@Resolver(Entity_)
-export class EntityResolver extends EntityResolverBase {
-  @Query(() => [Entity_])
+@Resolver(MJEntity_)
+export class EntityResolver extends MJEntityResolverBase {
+  @Query(() => [MJEntity_])
   async EntitiesBySchemas(
     @Ctx() { providers, userPayload }: AppContext,
     @Arg('IncludeSchemas', () => [String], { nullable: true }) IncludeSchemas?: string[],

package/src/resolvers/FileCategoryResolver.ts

@@ -2,13 +2,13 @@ import { CompositeKey, EntityDeleteOptions, EntityPermissionType, EntitySaveOpti
 import { FileCategoryEntity, FileEntity } from '@memberjunction/core-entities';
 import { AppContext, Arg, Ctx, DeleteOptionsInput, Int, Mutation } from '@memberjunction/server';
 import { mj_core_schema } from '../config.js';
-import { FileCategoryResolver as FileCategoryResolverBase, FileCategory_ } from '../generated/generated.js';
+import { MJFileCategoryResolver as FileCategoryResolverBase, MJFileCategory_ } from '../generated/generated.js';
 import sql from 'mssql';
 import { SQLServerDataProvider } from '@memberjunction/sqlserver-dataprovider';
 import { GetReadWriteProvider } from '../util.js';
 
 export class FileResolver extends FileCategoryResolverBase {
-  @Mutation(() => FileCategory_)
+  @Mutation(() => MJFileCategory_)
   async DeleteFileCategory(
     @Arg('ID', () => String) ID: string,
     @Arg('options___', () => DeleteOptionsInput) options: DeleteOptionsInput,

package/src/resolvers/FileResolver.ts

@@ -17,7 +17,7 @@ import {
   Root,
 } from '@memberjunction/server';
 import { createDownloadUrl, createUploadUrl, deleteObject, moveObject } from '@memberjunction/storage';
-import { CreateFileInput, FileResolver as FileResolverBase, File_, UpdateFileInput } from '../generated/generated.js';
+import { CreateMJFileInput, MJFileResolver as FileResolverBase, MJFile_, UpdateMJFileInput } from '../generated/generated.js';
 import { FieldMapper } from '@memberjunction/graphql-dataprovider';
 import { GetReadOnlyProvider } from '../util.js';
 
@@ -29,8 +29,8 @@ export class CreateUploadURLInput {
 
 @ObjectType()
 export class CreateFilePayload {
-  @Field(() => File_)
-  File: File_;
+  @Field(() => MJFile_)
+  File: MJFile_;
   @Field(() => String)
   UploadUrl: string;
   @Field(() => Boolean)
@@ -38,16 +38,16 @@ export class CreateFilePayload {
 }
 
 @ObjectType()
-export class FileExt extends File_ {
+export class FileExt extends MJFile_ {
   @Field(() => String)
   DownloadUrl: string;
 }
 
-@Resolver(File_)
+@Resolver(MJFile_)
 export class FileResolver extends FileResolverBase {
   @Mutation(() => CreateFilePayload)
   async CreateFile(
-    @Arg('input', () => CreateFileInput) input: CreateFileInput,
+    @Arg('input', () => CreateMJFileInput) input: CreateMJFileInput,
     @Ctx() context: AppContext,
     @PubSub() pubSub: PubSubEngine
   ) {
@@ -86,7 +86,7 @@ export class FileResolver extends FileResolverBase {
   }
 
   @FieldResolver(() => String)
-  async DownloadUrl(@Root() file: File_, @Ctx() { userPayload }: AppContext) {
+  async DownloadUrl(@Root() file: MJFile_, @Ctx() { userPayload }: AppContext) {
     const md = new Metadata();
     const user = this.GetUserFromPayload(userPayload);
     const fileEntity = await md.GetEntityObject<FileEntity>('Files', user);
@@ -100,9 +100,9 @@ export class FileResolver extends FileResolverBase {
     return url;
   }
 
-  @Mutation(() => File_)
+  @Mutation(() => MJFile_)
   async UpdateFile(
-    @Arg('input', () => UpdateFileInput) input: UpdateFileInput,
+    @Arg('input', () => UpdateMJFileInput) input: UpdateMJFileInput,
     @Ctx() context: AppContext,
     @PubSub() pubSub: PubSubEngine
   ) {
@@ -124,11 +124,11 @@ export class FileResolver extends FileResolverBase {
       }
     }
 
-    const updatedFile = await super.UpdateFile(input, context, pubSub);
+    const updatedFile = await super.UpdateMJFile(input, context, pubSub);
     return updatedFile;
   }
 
-  @Mutation(() => File_)
+  @Mutation(() => MJFile_)
   async DeleteFile(
     @Arg('ID', () => String) ID: string,
     @Arg('options___', () => DeleteOptionsInput) options: DeleteOptionsInput,
@@ -152,6 +152,6 @@ export class FileResolver extends FileResolverBase {
       await deleteObject(providerEntity, fileEntity.ProviderKey ?? fileEntity.Name);
     }
 
-    return super.DeleteFile(ID, options, context, pubSub);
+    return super.DeleteMJFile(ID, options, context, pubSub);
   }
 }

package/src/resolvers/PotentialDuplicateRecordResolver.ts

@@ -10,12 +10,11 @@ import {
 import { AppContext } from '../types.js';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 
-//load the default vectorDB and embedding model
-import { LoadMistralEmbedding } from '@memberjunction/ai-mistral';
+//load the default vectorDB
 import { LoadPineconeVectorDB } from '@memberjunction/ai-vectors-pinecone';
 import { CompositeKeyInputType, CompositeKeyOutputType, KeyValuePairOutputType } from '../generic/KeyInputOutputTypes.js';
 import { GetReadOnlyProvider } from '../util.js';
-LoadMistralEmbedding();
+// AI provider loading now handled by @memberjunction/aiengine
 LoadPineconeVectorDB();
 
 @InputType()

package/src/resolvers/RunAIAgentResolver.ts

@@ -9,6 +9,7 @@ import { ResolverBase } from '../generic/ResolverBase.js';
 import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver.js';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { GetReadWriteProvider } from '../util.js';
+import { SafeJSONParse } from '@memberjunction/global';
 
 @ObjectType()
 export class AIAgentRunResult {
@@ -312,6 +313,7 @@ export class RunAIAgentResolver extends ResolverBase {
         sessionId: string,
         pubSub: PubSubEngine,
         data?: string,
+        payload?: string,   
         templateData?: string,
         lastRunId?: string,
         autoPopulateLastRunPayload?: boolean,
@@ -356,6 +358,7 @@ export class RunAIAgentResolver extends ResolverBase {
             const result = await agentRunner.RunAgent({
                 agent: agentEntity,
                 conversationMessages: parsedMessages,
+                payload: payload ? SafeJSONParse(payload) : undefined,
                 contextUser: currentUser,
                 onProgress: this.createProgressCallback(pubSub, sessionId, userPayload, agentRunRef),
                 onStreaming: this.createStreamingCallback(pubSub, sessionId, userPayload, agentRunRef),
@@ -464,6 +467,7 @@ export class RunAIAgentResolver extends ResolverBase {
         @Arg('sessionId') sessionId: string,
         @PubSub() pubSub: PubSubEngine,
         @Arg('data', { nullable: true }) data?: string,
+        @Arg('payload', { nullable: true }) payload?: string,
         @Arg('templateData', { nullable: true }) templateData?: string,
         @Arg('lastRunId', { nullable: true }) lastRunId?: string,
         @Arg('autoPopulateLastRunPayload', { nullable: true }) autoPopulateLastRunPayload?: boolean,
@@ -479,6 +483,7 @@ export class RunAIAgentResolver extends ResolverBase {
             sessionId,
             pubSub,
             data,
+            payload,
             templateData,
             lastRunId,
             autoPopulateLastRunPayload,
@@ -500,6 +505,7 @@ export class RunAIAgentResolver extends ResolverBase {
         @Arg('sessionId') sessionId: string,
         @PubSub() pubSub: PubSubEngine,
         @Arg('data', { nullable: true }) data?: string,
+        @Arg('payload', { nullable: true }) payload?: string,
         @Arg('templateData', { nullable: true }) templateData?: string,
         @Arg('lastRunId', { nullable: true }) lastRunId?: string,
         @Arg('autoPopulateLastRunPayload', { nullable: true }) autoPopulateLastRunPayload?: boolean,
@@ -515,6 +521,7 @@ export class RunAIAgentResolver extends ResolverBase {
             sessionId,
             pubSub,
             data,
+            payload,
             templateData,
             lastRunId,
             autoPopulateLastRunPayload,

package/src/resolvers/RunTemplateResolver.ts

@@ -1,9 +1,8 @@
 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 } from '@memberjunction/core-entities';
+import { TemplateContentEntity, TemplateEntityExtended } from '@memberjunction/core-entities';
 import { TemplateEngineServer } from '@memberjunction/templates';
-import { TemplateEntityExtended } from '@memberjunction/templates-base-types';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { GetReadWriteProvider } from '../util.js';
 

package/src/resolvers/TaskResolver.ts

@@ -0,0 +1,142 @@
+import { Resolver, Mutation, Arg, Ctx, ObjectType, Field, PubSub, PubSubEngine } from 'type-graphql';
+import { AppContext } from '../types.js';
+import { LogError, LogStatus } from '@memberjunction/core';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import { TaskOrchestrator, TaskGraphResponse, TaskExecutionResult } from '../services/TaskOrchestrator.js';
+
+@ObjectType()
+export class TaskExecutionResultType {
+    @Field()
+    taskId: string;
+
+    @Field()
+    success: boolean;
+
+    @Field({ nullable: true })
+    output?: string;
+
+    @Field({ nullable: true })
+    error?: string;
+}
+
+@ObjectType()
+export class ExecuteTaskGraphResult {
+    @Field()
+    success: boolean;
+
+    @Field({ nullable: true })
+    errorMessage?: string;
+
+    @Field(() => [TaskExecutionResultType])
+    results: TaskExecutionResultType[];
+}
+
+/**
+ * TaskOrchestrationResolver handles multi-step task orchestration.
+ * This resolver is called when the Conversation Manager returns a task graph
+ * for complex workflows that require multiple agents working in sequence or parallel.
+ */
+@Resolver()
+export class TaskOrchestrationResolver extends ResolverBase {
+    /**
+     * Execute a task graph from the Conversation Manager.
+     * This creates tasks in the database, manages dependencies, and executes them in proper order.
+     *
+     * @param taskGraphJson - JSON string containing the task graph from Conversation Manager
+     * @param conversationDetailId - ID of the conversation detail that triggered this workflow
+     * @param environmentId - Environment ID for the tasks
+     */
+    @Mutation(() => ExecuteTaskGraphResult)
+    async ExecuteTaskGraph(
+        @Arg('taskGraphJson') taskGraphJson: string,
+        @Arg('conversationDetailId') conversationDetailId: string,
+        @Arg('environmentId') environmentId: string,
+        @Arg('sessionId') sessionId: string,
+        @PubSub() pubSub: PubSubEngine,
+        @Ctx() { userPayload }: AppContext
+    ): Promise<ExecuteTaskGraphResult> {
+        try {
+            LogStatus(`=== EXECUTING TASK GRAPH FOR CONVERSATION: ${conversationDetailId} ===`);
+
+            // Parse task graph
+            const taskGraph: TaskGraphResponse = JSON.parse(taskGraphJson);
+
+            // Validate task graph
+            if (!taskGraph.workflowName || !taskGraph.tasks || taskGraph.tasks.length === 0) {
+                throw new Error('Invalid task graph: must have workflowName and at least one task');
+            }
+
+            // Get current user
+            const currentUser = this.GetUserFromPayload(userPayload);
+            if (!currentUser) {
+                throw new Error('Unable to determine current user');
+            }
+
+            LogStatus(`Workflow: ${taskGraph.workflowName} (${taskGraph.tasks.length} tasks)`);
+            if (taskGraph.reasoning) {
+                LogStatus(`Reasoning: ${taskGraph.reasoning}`);
+            }
+
+            // Create task orchestrator with PubSub for progress updates
+            const orchestrator = new TaskOrchestrator(currentUser, pubSub, sessionId, userPayload);
+
+            // Create parent task and child tasks with dependencies
+            const { parentTaskId, taskIdMap } = await orchestrator.createTasksFromGraph(
+                taskGraph,
+                conversationDetailId,
+                environmentId
+            );
+
+            LogStatus(`Created parent task ${parentTaskId} with ${taskIdMap.size} child tasks`);
+
+            // Execute tasks in proper order
+            const results = await orchestrator.executeTasksForParent(
+                parentTaskId
+            );
+
+            // Log results
+            const successCount = results.filter(r => r.success).length;
+            LogStatus(`Completed ${successCount} of ${results.length} tasks successfully`);
+
+            for (const result of results) {
+                if (result.success) {
+                    LogStatus(`✅ Task ${result.taskId} completed successfully`);
+                } else {
+                    LogError(`❌ Task ${result.taskId} failed: ${result.error}`);
+                }
+            }
+
+            // Convert results to GraphQL types
+            const graphqlResults: TaskExecutionResultType[] = results.map(r => ({
+                taskId: r.taskId,
+                success: r.success,
+                output: r.output ? JSON.stringify(r.output) : undefined,
+                error: r.error
+            }));
+
+            LogStatus(`=== TASK GRAPH EXECUTION COMPLETE ===`);
+
+            const result = {
+                success: true,
+                results: graphqlResults
+            };
+
+            LogStatus(`Returning ExecuteTaskGraph result: ${JSON.stringify({
+                success: result.success,
+                resultsCount: result.results.length,
+                firstResult: result.results[0]
+            })}`);
+
+            return result;
+
+        } catch (error) {
+            LogError(`Task graph execution failed:`, undefined, error);
+
+            return {
+                success: false,
+                errorMessage: (error as Error).message || 'Unknown error occurred',
+                results: []
+            };
+        }
+    }
+}

package/src/resolvers/UserFavoriteResolver.ts

@@ -15,7 +15,7 @@ import {
 } from '@memberjunction/server';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 
-import { UserFavorite_, UserFavoriteResolverBase } from '../generated/generated.js';
+import { MJUserFavorite_, MJUserFavoriteResolverBase } from '../generated/generated.js';
 import { GetReadOnlyProvider } from '../util.js';
 
 //****************************************************************************
@@ -66,15 +66,15 @@ export class UserFavoriteResult {
   Success: boolean;
 }
 
-@Resolver(UserFavorite_)
-export class UserFavoriteResolver extends UserFavoriteResolverBase {
-  @Query(() => [UserFavorite_])
+@Resolver(MJUserFavorite_)
+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);
   }
 
-  @Query(() => [UserFavorite_])
+  @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);

package/src/resolvers/UserResolver.ts

@@ -1,31 +1,31 @@
 import { AppContext, Arg, Ctx, Int, Query, Resolver } from '@memberjunction/server';
-import { User_, UserResolverBase } from '../generated/generated.js';
+import { MJUser_, MJUserResolverBase } from '../generated/generated.js';
 import { GetReadOnlyProvider } from '../util.js';
 
-@Resolver(User_)
-export class UserResolver extends UserResolverBase {
-  @Query(() => User_)
+@Resolver(MJUser_)
+export class UserResolver extends MJUserResolverBase {
+  @Query(() => MJUser_)
   async CurrentUser(@Ctx() context: AppContext) {
     const result = await this.UserByEmail(context.userPayload.email, context);
     console.log('CurrentUser', result);
     return result;
   }
 
-  @Query(() => User_)
+  @Query(() => MJUser_)
   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_)
+  @Query(() => MJUser_)
   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_)
+  @Query(() => MJUser_)
   async UserByEmail(@Arg('Email', () => String) Email: string, @Ctx() { providers, userPayload }: AppContext) {
     // const searchEmail = userEmailMap[Email] ?? Email;
     const searchEmail = Email;

package/src/resolvers/UserViewResolver.ts

@@ -1,20 +1,20 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 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 { MJUserView_, MJUserViewResolverBase } 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_])
+@Resolver(MJUserView_)
+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);
   }
 
-  @Query(() => [UserView_])
+  @Query(() => [MJUserView_])
   async DefaultViewByUserAndEntity(
     @Arg('UserID', () => Int) UserID: number,
     @Arg('EntityID', () => Int) EntityID: number,
@@ -24,7 +24,7 @@ export class UserViewResolver extends UserViewResolverBase {
     return await this.findBy(provider, 'User Views', { UserID, EntityID, IsDefault: true }, userPayload.userRecord);
   }
 
-  @Query(() => [UserView_])
+  @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', {
@@ -40,13 +40,13 @@ export class UserViewResolver extends UserViewResolverBase {
     return user.ID;
   }
 
-  @Query(() => [UserView_])
+  @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);
   }
 
-  @Query(() => [UserView_])
+  @Query(() => [MJUserView_])
   async UpdateWhereClause(@Arg('ID', () => String) ID: string, @Ctx() { userPayload, providers }: AppContext) {
     // in this query we want to update the uesrView record in the DB with a new where clause
     // this should normally not be a factor but we have this exposed in the GraphQL API so that