@memberjunction/server 2.112.0 → 2.113.1

package/src/resolvers/TaskResolver.ts

@@ -1,34 +1,34 @@
 import { Resolver, Mutation, Arg, Ctx, ObjectType, Field, PubSub, PubSubEngine } from 'type-graphql';
 import { AppContext } from '../types.js';
-import { LogError, LogStatus } from '@memberjunction/global';
+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()
+    taskId: string;
 
-  @Field()
-  success: boolean;
+    @Field()
+    success: boolean;
 
-  @Field({ nullable: true })
-  output?: string;
+    @Field({ nullable: true })
+    output?: string;
 
-  @Field({ nullable: true })
-  error?: string;
+    @Field({ nullable: true })
+    error?: string;
 }
 
 @ObjectType()
 export class ExecuteTaskGraphResult {
-  @Field()
-  success: boolean;
+    @Field()
+    success: boolean;
 
-  @Field({ nullable: true })
-  errorMessage?: string;
+    @Field({ nullable: true })
+    errorMessage?: string;
 
-  @Field(() => [TaskExecutionResultType])
-  results: TaskExecutionResultType[];
+    @Field(() => [TaskExecutionResultType])
+    results: TaskExecutionResultType[];
 }
 
 /**
@@ -38,101 +38,106 @@ export class ExecuteTaskGraphResult {
  */
 @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,
-    @Arg('createNotifications', { nullable: true }) createNotifications?: boolean
-  ): 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, createNotifications || false);
-
-      // 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}`);
+    /**
+     * 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,
+        @Arg('createNotifications', { nullable: true }) createNotifications?: boolean
+    ): 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, createNotifications || false);
+
+            // 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: []
+            };
         }
-      }
-
-      // 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/TransactionGroupResolver.ts

@@ -1,183 +1,178 @@
 import { Arg, Ctx, Field, InputType, Int, Mutation, ObjectType, registerEnumType } from 'type-graphql';
 import { AppContext } from '../types.js';
-import {
-  CompositeKey,
-  KeyValuePair,
-  LogError,
-  Metadata,
-  TransactionVariable,
-  BaseEntity,
-  EntityDeleteOptions,
-  EntitySaveOptions,
-} from '@memberjunction/global';
+import { CompositeKey, KeyValuePair, LogError, Metadata, TransactionVariable, BaseEntity, EntityDeleteOptions, EntitySaveOptions } from '@memberjunction/core';
 import { SafeJSONParse } from '@memberjunction/global';
 
 export enum TransactionVariableType {
-  Define = 'Define',
-  Use = 'Use',
+    Define = "Define",
+    Use = "Use",
 }
 
 registerEnumType(TransactionVariableType, {
-  name: 'TransactionVariableType',
-  description: 'Specifies the type of variable: Define or Use',
+    name: "TransactionVariableType",  
+    description: "Specifies the type of variable: Define or Use",
 });
 
 export enum TransactionOperationType {
-  Create = 'Create',
-  Update = 'Update',
-  Delete = 'Delete',
+    Create = "Create",
+    Update = "Update",
+    Delete = "Delete"
 }
 
 registerEnumType(TransactionOperationType, {
-  name: 'TransactionOperationType',
-  description: 'Specifies the type of operation: Create, Update, or Delete',
+    name: "TransactionOperationType",  
+    description: "Specifies the type of operation: Create, Update, or Delete",
 });
 
-@InputType()
-export class TransactionVariableInputType {
-  @Field(() => String)
-  Name!: string;
 
-  @Field(() => Int)
-  ItemIndex!: number;
+@InputType() 
+export class TransactionVariableInputType {
+    @Field(() => String)
+    Name!: string;
 
-  @Field(() => String)
-  FieldName!: string;
+    @Field(() => Int)
+    ItemIndex!: number;
 
-  @Field(() => TransactionVariableType)
-  Type!: TransactionVariableType;
+    @Field(() => String)
+    FieldName!: string;
+  
+    @Field(() => TransactionVariableType) 
+    Type!: TransactionVariableType;
 }
-
-@InputType()
+  
+@InputType() 
 export class TransactionItemInputType {
-  @Field(() => String)
-  EntityName: string;
+    @Field(() => String)
+    EntityName: string;
 
-  @Field(() => String)
-  EntityObjectJSON: string;
+    @Field(() => String)
+    EntityObjectJSON: string;
 
-  @Field(() => TransactionOperationType)
-  OperationType: TransactionOperationType;
+    @Field(() => TransactionOperationType)
+    OperationType: TransactionOperationType;
 }
-
-@InputType()
+  
+@InputType() 
 export class TransactionInputType {
-  @Field(() => [TransactionItemInputType])
-  Items: TransactionItemInputType[];
+    @Field(() => [TransactionItemInputType])
+    Items: TransactionItemInputType[];
 
-  @Field(() => [TransactionVariableInputType], { nullable: true })
-  Variables?: TransactionVariableInputType[] | null;
+    @Field(() => [TransactionVariableInputType], {nullable: true})
+    Variables?: TransactionVariableInputType[] | null;
 }
 
+
 @ObjectType()
 export class TransactionOutputType {
-  @Field(() => Boolean)
-  Success: boolean;
+    @Field(() => Boolean)
+    Success: boolean;
 
-  @Field(() => [String])
-  ErrorMessages: string[];
+    @Field(() => [String])
+    ErrorMessages: string[];
 
-  @Field(() => [String])
-  ResultsJSON: string[];
+    @Field(() => [String])
+    ResultsJSON: string[];
 }
 
+
+
 export class TransactionResolver {
-  @Mutation(() => TransactionOutputType)
-  async ExecuteTransactionGroup(@Arg('group', () => TransactionInputType) group: TransactionInputType, @Ctx() context: AppContext) {
-    try {
-      // we have received the transaction group information via the network, now we need to reconstruct our TransactionGroup object and run it
-      const md = new Metadata();
-      const tg = await md.CreateTransactionGroup();
-      const entityObjects: BaseEntity[] = [];
-      const objectValues: any[] = [];
-
-      for (const item of group.Items) {
-        // instantiate a new entity object for the item
-        const entity = await md.GetEntityObject(item.EntityName, context.userPayload.userRecord);
-        entityObjects.push(entity); // save for later for mapping variables if needed
-
-        // get the values from the payload
-        const itemValues = SafeJSONParse(item.EntityObjectJSON);
-        // build a primary key for the item
-        const pkey = new CompositeKey(
-          entity.PrimaryKeys.map((pk) => {
-            const kv = new KeyValuePair();
-            kv.FieldName = pk.Name;
-            kv.Value = itemValues[pk.Name];
-            return kv;
-          })
-        );
-        switch (item.OperationType) {
-          case 'Update':
-          case 'Create':
-            if (item.OperationType === 'Update') {
-              await entity.InnerLoad(pkey);
+    @Mutation(() => TransactionOutputType)
+    async ExecuteTransactionGroup(
+    @Arg('group', () => TransactionInputType ) group: TransactionInputType,
+    @Ctx() context: AppContext
+    ) {
+        try { 
+            // we have received the transaction group information via the network, now we need to reconstruct our TransactionGroup object and run it
+            const md = new Metadata();
+            const tg = await md.CreateTransactionGroup();
+            const entityObjects: BaseEntity[] = [];
+            const objectValues: any[] = [];
+
+            for (const item of group.Items) {
+                // instantiate a new entity object for the item
+                const entity = await md.GetEntityObject(item.EntityName, context.userPayload.userRecord);
+                entityObjects.push(entity); // save for later for mapping variables if needed
+
+                // get the values from the payload
+                const itemValues = SafeJSONParse(item.EntityObjectJSON);
+                // build a primary key for the item
+                const pkey = new CompositeKey(entity.PrimaryKeys.map(pk => {
+                    const kv = new KeyValuePair();
+                    kv.FieldName = pk.Name;
+                    kv.Value = itemValues[pk.Name];
+                    return kv;
+                }));
+                switch (item.OperationType) {
+                    case "Update":
+                    case "Create":
+                        if (item.OperationType === "Update") {
+                            await entity.InnerLoad(pkey);
+                        }
+                        objectValues.push(itemValues);
+                        entity.SetMany(itemValues, true);
+                        entity.TransactionGroup = tg;
+                        await entity.Save();
+                        break;
+                    case "Delete":
+                        await entity.InnerLoad(pkey);
+                        objectValues.push(entity.GetDataObject());
+                        entity.TransactionGroup = tg;
+                        await entity.Delete();
+                        break;
+                }
             }
-            objectValues.push(itemValues);
-            entity.SetMany(itemValues, true);
-            entity.TransactionGroup = tg;
-            await entity.Save();
-            break;
-          case 'Delete':
-            await entity.InnerLoad(pkey);
-            objectValues.push(entity.GetDataObject());
-            entity.TransactionGroup = tg;
-            await entity.Delete();
-            break;
-        }
-      }
-
-      // now, we need to set the variables
-      if (group.Variables && group.Variables.length > 0) {
-        for (const networkVar of group.Variables) {
-          // for each variable, add it to the transaction group and map the index from the network payload to the specific entity object loaded up above
-          if (networkVar.ItemIndex >= 0 && networkVar.ItemIndex < entityObjects.length) {
-            const entityObject = entityObjects[networkVar.ItemIndex];
-            const newVar = new TransactionVariable(networkVar.Name, entityObject, networkVar.FieldName, networkVar.Type);
-            tg.AddVariable(newVar);
-          } else {
-            throw new Error(
-              `TransactionResolver::ExecuteTransactionGroup --- Error\n\n' + 'Invalid ItemIndex ${networkVar.ItemIndex} in TransactionVariable "${JSON.stringify(networkVar)}"`
-            );
-          }
+
+            // now, we need to set the variables
+            if (group.Variables && group.Variables.length > 0) {
+                for (const networkVar of group.Variables) {
+                    // for each variable, add it to the transaction group and map the index from the network payload to the specific entity object loaded up above
+                    if (networkVar.ItemIndex >= 0 && networkVar.ItemIndex < entityObjects.length) {
+                        const entityObject = entityObjects[networkVar.ItemIndex];
+                        const newVar = new TransactionVariable(networkVar.Name, entityObject, networkVar.FieldName, networkVar.Type);
+                        tg.AddVariable(newVar);
+                    }
+                    else {
+                        throw new Error(`TransactionResolver::ExecuteTransactionGroup --- Error\n\n' + 'Invalid ItemIndex ${networkVar.ItemIndex} in TransactionVariable "${JSON.stringify(networkVar)}"`);
+                    }
+                }
+            }
+
+            // after all that, we are ready to roll, so let's run the TG
+            if (await tg.Submit()) {
+                // success!
+                return await this.PrepareReturnValue(true, entityObjects, objectValues, group);
+            }
+            else {
+                // failure, send back the results
+                return await this.PrepareReturnValue(false, entityObjects, objectValues, group);
+            }
+        } 
+        catch (err) {
+            LogError(err);
+            throw new Error('TransactionResolver::ExecuteTransactionGroup --- Error\n\n' + err);
         }
-      }
-
-      // after all that, we are ready to roll, so let's run the TG
-      if (await tg.Submit()) {
-        // success!
-        return await this.PrepareReturnValue(true, entityObjects, objectValues, group);
-      } else {
-        // failure, send back the results
-        return await this.PrepareReturnValue(false, entityObjects, objectValues, group);
-      }
-    } catch (err) {
-      LogError(err);
-      throw new Error('TransactionResolver::ExecuteTransactionGroup --- Error\n\n' + err);
-    }
-  }
-
-  protected async PrepareReturnValue(
-    success: boolean,
-    entityObjects: BaseEntity[],
-    objectValues: any[],
-    group: TransactionInputType
-  ): Promise<TransactionOutputType> {
-    const jsonResults = [];
-    for (let i = 0; i < group.Items.length; i++) {
-      const item = group.Items[i];
-      if (item.OperationType === 'Delete') {
-        jsonResults.push(JSON.stringify(objectValues[i]));
-      } else {
-        // create or update, return what is in the database
-        jsonResults.push(await entityObjects[i].GetDataObjectJSON());
-      }
     }
 
-    return {
-      Success: success,
-      ErrorMessages: entityObjects.map((e) => JSON.stringify(e.LatestResult)),
-      ResultsJSON: jsonResults,
-    };
-  }
+    protected async PrepareReturnValue(success: boolean, entityObjects: BaseEntity[], objectValues: any[], group: TransactionInputType): Promise<TransactionOutputType> {
+        const jsonResults = [];
+        for (let i = 0; i < group.Items.length; i++) {
+            const item = group.Items[i];
+            if (item.OperationType==='Delete') {
+                jsonResults.push(JSON.stringify(objectValues[i]));
+            }
+            else {
+                // create or update, return what is in the database
+                jsonResults.push(await entityObjects[i].GetDataObjectJSON());
+            }
+        }
+
+        return {
+            Success: success,
+            ErrorMessages: entityObjects.map(e => JSON.stringify(e.LatestResult)),
+            ResultsJSON: jsonResults
+        }
+    }
+ 
 }
+ 

package/src/resolvers/UserFavoriteResolver.ts

@@ -1,4 +1,4 @@
-import { Metadata, KeyValuePair, CompositeKey, UserInfo } from '@memberjunction/global';
+import { Metadata, KeyValuePair, CompositeKey, UserInfo } from '@memberjunction/core';
 import {
   AppContext,
   Arg,
@@ -70,25 +70,19 @@ export class UserFavoriteResult {
 export class UserFavoriteResolver extends MJUserFavoriteResolverBase {
   @Query(() => [MJUserFavorite_])
   async UserFavoritesByUserID(@Arg('UserID', () => Int) UserID: number, @Ctx() { providers, userPayload }: AppContext) {
-    const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+    const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})    
     return await this.findBy(provider, 'User Favorites', { UserID }, userPayload.userRecord);
   }
 
   @Query(() => [MJUserFavorite_])
-  async UserFavoriteSearchByParams(
-    @Arg('params', () => Int) params: UserFavoriteSearchParams,
-    @Ctx() { providers, userPayload }: AppContext
-  ) {
-    const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+  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)
-  async GetRecordFavoriteStatus(
-    @Arg('params', () => UserFavoriteSearchParams) params: UserFavoriteSearchParams,
-    @Ctx() { providers, userPayload }: AppContext
-  ) {
-    const p = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+  async GetRecordFavoriteStatus(@Arg('params', () => UserFavoriteSearchParams) params: UserFavoriteSearchParams, @Ctx() {providers, userPayload}: AppContext) {
+    const p = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
     const pk = new CompositeKey(params.CompositeKey.KeyValuePairs);
 
     const e = p.Entities.find((e) => e.ID === params.EntityID);
@@ -104,11 +98,8 @@ export class UserFavoriteResolver extends MJUserFavoriteResolverBase {
   }
 
   @Mutation(() => UserFavoriteResult)
-  async SetRecordFavoriteStatus(
-    @Arg('params', () => UserFavoriteSetParams) params: UserFavoriteSetParams,
-    @Ctx() { userPayload, providers }: AppContext
-  ) {
-    const p = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+  async SetRecordFavoriteStatus(@Arg('params', () => UserFavoriteSetParams) params: UserFavoriteSetParams, @Ctx() { userPayload, providers }: AppContext) {
+    const p = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
     const pk = new CompositeKey(params.CompositeKey.KeyValuePairs);
     const e = p.Entities.find((e) => e.ID === params.EntityID);
     const u = UserCache.Users.find((u) => u.ID === userPayload.userRecord.ID);