@outputai/core 0.10.1-next.b7b2fbe.0 → 0.10.1-next.bf95a6f.0

package/src/interface/workflow.js

@@ -1,110 +1,89 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
-import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, uuid4, ParentClosePolicy } from '@temporalio/workflow';
+import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, uuid4, ParentClosePolicy, upsertMemo } from '@temporalio/workflow';
 import { WorkflowValidator } from './validations/index.js';
 import { toUrlSafeBase64 } from '#helpers/string';
 import { WorkflowContext } from '#helpers/workflow_context';
-import { TraceInfo } from '#helpers/trace_info';
 import { deepMerge } from '#helpers/object';
 import { defaultOptions } from './workflow_activity_options.js';
 import { createWorkflow } from '#helpers/component';
-import {
-  ACTIVITY_GET_TRACE_DESTINATIONS,
-  METADATA_ACCESS_SYMBOL,
-  SHARED_STEP_PREFIX,
-  WORKFLOW_WRAPPER_VERSION_FIELD
-} from '#consts';
+import { enforceActivityOptions } from '#helpers/activity_options';
+import { FatalError } from '#errors';
+import * as C from '#consts';
 
 /**
- * Create a new workflow and return a wrapper function around its fn handler
+ * Add a global dispatcher function to be used to invoke activities.
+ * This will replace direct activity invocation in the user code by the webpack loader.
+ *
+ * Important: Keep this as a configurable global assignment (configurable=true, enumerable=true),
+ * so Temporal's reusable VM can delete it when switching workflow scopes.
  */
+const createGlobalDispatcher = ( { runId, workflowType, activities } ) => {
+  const dispatcher = async ( activityType, ...args ) => activities[`${workflowType}#${activityType}`]( ...args );
+  dispatcher.runId = runId;
+  globalThis[C.INVOKE_ACTIVITY_SYMBOL] = dispatcher;
+};
+
+/**  Validate if the global dispatcher wasn't set by another workflow, indicating global context contamination. */
+const checkGlobalContextContamination = runId => {
+  const globalContextRunId = globalThis?.[C.INVOKE_ACTIVITY_SYMBOL]?.runId;
+  if ( globalContextRunId && globalContextRunId !== runId ) {
+    throw new FatalError( 'Contamination of the workflow Node global context.' +
+      ` Var "globalThis[${String( C.INVOKE_ACTIVITY_SYMBOL )}]" was set by another workflow (${globalContextRunId})` );
+  }
+};
+
+/** Create a new workflow and return a wrapper function around its fn handler */
 export function workflow( { name, description, inputSchema, outputSchema, fn, options = {}, aliases = [] } ) {
   WorkflowValidator.validateDefinition( { name, description, inputSchema, outputSchema, fn, options, aliases } );
 
-  const { disableTrace, activityOptions } = deepMerge( defaultOptions, options );
   const validator = new WorkflowValidator( { name, inputSchema, outputSchema } );
 
-  return createWorkflow( {
-    name,
-    description,
-    inputSchema,
-    outputSchema,
-    options,
-    aliases,
-    handler: async ( input, extra = {} ) => {
-      validator.validateInvocationOptions( extra );
-
-      // this returns a plain function, for example, in unit tests
-      if ( !inWorkflowContext() ) {
-        validator.validateInput( input );
-        const output = await fn( input, deepMerge( WorkflowContext.build(), extra?.context ) );
-        validator.validateOutput( output );
-        return output;
-      }
-
-      const { workflowId, memo, root } = workflowInfo();
+  const handler = async ( input, rawInvocationOptions = {} ) => {
+    const invocationOptions = validator.parseInvocationOptions( rawInvocationOptions );
 
-      // if the stack already includes this workflowId, means the workflow() function was called
-      // from within a running workflow, meaning it is suppose to start a child workflow
-      const isChild = Array.isArray( memo.stack ) ? memo.stack.includes( workflowId ) : false;
-
-      if ( isChild ) {
-        const result = await executeChild( name, {
-          args: undefined === input ? [] : [ input ],
-          workflowId: `${workflowId}-${toUrlSafeBase64( uuid4() )}`,
-          parentClosePolicy: ParentClosePolicy[extra?.detached ? 'ABANDON' : 'TERMINATE'],
-          memo: {
-            ...memo, // Preserve memo and mix activityOptions, if provided
-            ...( extra?.activityOptions && {
-              activityOptions: deepMerge( memo?.activityOptions ?? {}, extra?.activityOptions )
-            } )
-          }
-        } );
-        return result.output;
-      }
+    // If called outside Temporal workflow context, just execute the handler function
+    if ( !inWorkflowContext() ) {
+      return validator.parseOutput(
+        await fn( validator.parseInput( input ), deepMerge( WorkflowContext.build(), invocationOptions?.context ) )
+      );
+    }
 
-      const isRoot = !root;
+    const { workflowId, runId, memo, root } = workflowInfo();
+    const isRoot = !root;
 
-      memo.stack = [ ...memo.stack ?? [], workflowId ];
-      // Parent options have prevalence on nested calls, child will be overwritten
-      memo.activityOptions = deepMerge( activityOptions, memo.activityOptions );
-      // Trace info is only added in the root and only when trace is not disabled
-      if ( isRoot && !disableTrace ) {
-        memo.traceInfo = TraceInfo.build();
-      }
+    checkGlobalContextContamination( runId );
 
-      const steps = proxyActivities( memo.activityOptions );
-      const traceDestinations = isRoot && {
-        trace: {
-          destinations: disableTrace ? {} : ( await steps[ACTIVITY_GET_TRACE_DESTINATIONS]( memo.traceInfo ) ).output ?? {}
-        }
-      };
+    // If the parent workflow already installed the activity dispatcher, it means that calls to workflow() will trigger child workflows
+    const isChildWorkflowCall = !!globalThis[C.INVOKE_ACTIVITY_SYMBOL];
+    if ( isChildWorkflowCall ) {
+      const parentClosePolicy = ParentClosePolicy[invocationOptions?.detached ? 'ABANDON' : 'TERMINATE'];
+      const childWorkflowId = `${workflowId}-${toUrlSafeBase64( uuid4() )}`;
+      const args = [ input, { activityOptions: invocationOptions?.activityOptions } ];
+      return executeChild( name, { args, workflowId: childWorkflowId, parentClosePolicy, memo } );
+    }
 
-      try {
-        validator.validateInput( input );
+    // Resolve the activity options: invocation options > definition options > parent options > default options, then enforce final SDK options
+    const activityOptions = enforceActivityOptions( deepMerge(
+      defaultOptions.activityOptions, // default
+      memo?.activityOptions, // parent options
+      options?.activityOptions, // definition options
+      invocationOptions.activityOptions // invocation options
+    ) );
 
-        // Creates an activity caller based on a prefix
-        const createCaller = prefix => async ( t, ...args ) => ( await steps[`${prefix}#${t}`]( ...args ) ).output;
+    const activities = proxyActivities( activityOptions );
+    createGlobalDispatcher( { runId, workflowType: name, activities } );
 
-        // This are functions used by the AST to replace direct activity (step/evaluator) calls
-        const dispatchers = {
-          invokeStep: createCaller( name ),
-          invokeSharedStep: createCaller( SHARED_STEP_PREFIX ),
-          invokeEvaluator: createCaller( name ),
-          invokeSharedEvaluator: createCaller( SHARED_STEP_PREFIX )
-        };
+    upsertMemo( {
+      activityOptions, // Resolved activity options are added to memo so child workflow executions can continue the policy chain
+      ...( isRoot && memo.traceInfo && {
+        trace: await activities[C.ACTIVITY_GET_TRACE_DESTINATIONS]( memo.traceInfo )
+      } )
+    } );
 
-        // The workflow function execution with "this" set with the dispatchers
-        const output = await fn.call( dispatchers, input, WorkflowContext.build() );
-        validator.validateOutput( output );
+    return validator.parseOutput(
+      await fn( validator.parseInput( input ), WorkflowContext.build() )
+    );
+  };
 
-        return { [WORKFLOW_WRAPPER_VERSION_FIELD]: 1, output, ...traceDestinations };
-      } catch ( error ) {
-        if ( traceDestinations ) {
-          // Append the trace destinations so it is carried to interceptor
-          error[METADATA_ACCESS_SYMBOL] = traceDestinations;
-        }
-        throw error;
-      }
-    }
-  } );
+  return createWorkflow( { name, description, inputSchema, outputSchema, options, aliases, handler } );
 }