@memberjunction/server 2.111.1 → 2.112.0

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/core';
+import { LogError, LogStatus } from '@memberjunction/global';
 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,106 +38,101 @@ 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}`);
-                }
-            }
-
-            // 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: []
-            };
+  /**
+   * 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: [],
+      };
     }
+  }
 }

package/src/resolvers/TransactionGroupResolver.ts

@@ -1,178 +1,183 @@
 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/core';
+import {
+  CompositeKey,
+  KeyValuePair,
+  LogError,
+  Metadata,
+  TransactionVariable,
+  BaseEntity,
+  EntityDeleteOptions,
+  EntitySaveOptions,
+} from '@memberjunction/global';
 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() 
+@InputType()
 export class TransactionVariableInputType {
-    @Field(() => String)
-    Name!: string;
+  @Field(() => String)
+  Name!: string;
+
+  @Field(() => Int)
+  ItemIndex!: number;
 
-    @Field(() => Int)
-    ItemIndex!: number;
+  @Field(() => String)
+  FieldName!: string;
 
-    @Field(() => String)
-    FieldName!: string;
-  
-    @Field(() => TransactionVariableType) 
-    Type!: TransactionVariableType;
+  @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);
-                        }
-                        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)}"`);
-                    }
-                }
-            }
-
-            // 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());
+  @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;
         }
-
-        return {
-            Success: success,
-            ErrorMessages: entityObjects.map(e => JSON.stringify(e.LatestResult)),
-            ResultsJSON: jsonResults
+      }
+
+      // 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);
     }
- 
+  }
+
+  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/core';
+import { Metadata, KeyValuePair, CompositeKey, UserInfo } from '@memberjunction/global';
 import {
   AppContext,
   Arg,
@@ -70,19 +70,25 @@ 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);
@@ -98,8 +104,11 @@ 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);