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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.10.1-next.b7b2fbe.0",
+  "version": "0.10.1-next.eaf62a3.0",
   "description": "The core module of the output framework",
   "type": "module",
   "engines": {

package/src/consts.js

@@ -4,11 +4,12 @@ export const ACTIVITY_SEND_HTTP_REQUEST = '__internal#sendHttpRequest';
 export const ACTIVITY_WRAPPER_VERSION_FIELD = '__output_activity_wrapper_version';
 export const ACTIVITY_LOGGER_SYMBOL = Symbol.for( '__activity_logger' );
 export const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
-export const SHARED_STEP_PREFIX = '$shared';
 export const WORKFLOW_CATALOG = '$catalog';
 export const WORKFLOWS_INDEX_FILENAME = '__workflows_entrypoint.js';
 export const WORKFLOW_WRAPPER_VERSION_FIELD = '__output_workflow_wrapper_version';
 
+export const INVOKE_ACTIVITY_SYMBOL = Symbol.for( '@outputai/core:__invoke_activity' );
+
 export const ComponentType = {
   EVALUATOR: 'evaluator',
   INTERNAL_STEP: 'internal_step',

package/src/helpers/object.js

@@ -24,58 +24,71 @@ export const clone = v => {
 };
 
 /**
- * Creates a new object merging object "b" onto object "a", using a resolver function to define the value to keep.
- * - Object "b" fields that also exists on "a" will have their value defined by the "resolver" function
- * - Object "b" fields that don't exist on object "a" will be added;
- * - Object "a" fields that don't exist on object "b" will be preserved;
+ * Creates a new object recursively merging the rightmost object over the previous one using a resolver function.
+ * Give two objects, (L)eft and (R)right
+ * - Object "R" will overwrite fields on object "L" based on the result of the resolver function;
+ * - Object "R" fields that don't exist on object "L" will be added;
+ * - Object "L" fields that don't exist on object "R" will be preserved;
  *
- * If "b" isn't an object, a new object equal to "a" is returned
+ * If "R" isn't an object, a new object equal to "L" is returned.
  *
- * @param {object} a - The base object
- * @param {object} b - The target object
- * @param {function} resolver - A function that return the value to be kept. First argument is value a, second is value b
+ * The resolver function will define the final value of the merge, it receives two args value "L" and "R".
+ *
+ *
+ * @param {object} base - The base object
+ * @param {...(object|function)} args - Target objects followed by the resolver function
  * @returns {object} A new object
  */
-export const deepMergeWithResolver = ( a, b, resolver ) => {
-  if ( !isPlainObject( a ) ) {
-    throw new Error( 'Parameter "a" is not an object.' );
+export const deepMergeWithResolver = ( base, ...args ) => {
+  const objects = args.slice( 0, -1 );
+  const resolver = args.at( -1 );
+
+  if ( !isPlainObject( base ) ) {
+    throw new Error( 'First argument (base object) is not an object.' );
   }
-  if ( !isPlainObject( b ) ) {
-    return clone( a );
+
+  if ( typeof resolver !== 'function' ) {
+    throw new Error( 'Last argument (resolver) is not a function.' );
   }
-  return Object.entries( b ).reduce( ( obj, [ k, v ] ) =>
-    Object.assign( obj, {
-      [k]: ( () => {
-        if ( isPlainObject( v ) && isPlainObject( a[k] ) ) {
-          return deepMergeWithResolver( a[k], v, resolver );
-        }
-        if ( Object.hasOwn( a, k ) ) {
-          return resolver( a[k], v );
-        }
-        return v;
-      } )()
-    } )
-  , clone( a ) );
+
+  return objects.reduce( ( merged, object ) => {
+    if ( !isPlainObject( object ) ) {
+      return merged;
+    }
+
+    for ( const [ k, v ] of Object.entries( object ) ) {
+      if ( isPlainObject( v ) && isPlainObject( merged[k] ) ) {
+        merged[k] = deepMergeWithResolver( merged[k], v, resolver );
+      } else if ( Object.hasOwn( merged, k ) ) {
+        merged[k] = resolver( merged[k], v );
+      } else {
+        merged[k] = v;
+      }
+    }
+    return merged;
+  }, clone( base ) );
 };
 
 /**
- * Creates a new object merging object "b" onto object "a" biased to "b":
- * - Object "b" will overwrite fields on object "a";
- * - Object "b" fields that don't exist on object "a" will be added;
- * - Object "a" fields that don't exist on object "b" will be preserved;
+ * Creates a new object recursively merging the rightmost object over the previous one.
+ * Give two objects, (L)eft and (R)right
+ * - Object "R" will overwrite fields on object "L";
+ * - Object "R" fields that don't exist on object "L" will be added;
+ * - Object "L" fields that don't exist on object "R" will be preserved;
  *
- * If "b" isn't an object, a new object equal to "a" is returned
+ * If "R" isn't an object, a new object equal to "L" is returned.
  *
- * @param {object} a - The base object
- * @param {object} b - The target object
+ * @param {object} base - The base object
+ * @param {...object} rest - The target objects
  * @returns {object} A new object
  */
-export const deepMerge = ( a, b ) => deepMergeWithResolver( a, b, ( _, b ) => b );
+export const deepMerge = ( base, ...rest ) =>
+  deepMergeWithResolver( base, ...rest, ( _, b ) => b );
 
 /**
  * Adds an non-writable, non-configurable and non-enumerable property to an object
  * @param {object} obj
- * @param {string} key
+ * @param {string|Symbol} key
  * @param {any} value
  * @returns
  */

package/src/helpers/object.spec.js

@@ -95,98 +95,86 @@ describe( 'clone', () => {
 } );
 
 describe( 'deepMerge', () => {
-  it( 'Overwrites properties in object "a"', () => {
+  it( 'returns a clone when only the base object is provided', () => {
     const a = {
-      a: 1,
-      b: {
-        c: 2
-      }
+      nested: { value: 1 }
     };
-    const b = {
-      a: false,
-      b: {
-        c: true
-      }
-    };
-    expect( deepMerge( a, b ) ).toEqual( {
-      a: false,
-      b: {
-        c: true
-      }
-    } );
-  } );
+    const result = deepMerge( a );
 
-  it( 'Adds properties existing in "b" but absent in "a"', () => {
-    const a = {
-      a: 1
-    };
-    const b = {
-      a: false,
-      b: true
-    };
-    expect( deepMerge( a, b ) ).toEqual( {
-      a: false,
-      b: true
+    a.nested.value = 2;
+
+    expect( result ).toEqual( {
+      nested: { value: 1 }
     } );
   } );
 
-  it( 'Keep extra properties in "a"', () => {
-    const a = {
-      a: 1
-    };
-    const b = {
-      b: true
-    };
-    expect( deepMerge( a, b ) ).toEqual( {
-      a: 1,
-      b: true
+  it( 'Throws when first argument is not a plain object', () => {
+    expect( () => deepMerge( null ) ).toThrow( Error );
+  } );
+
+  it( 'merges multiple objects from left to right using rightmost values', () => {
+    expect( deepMerge(
+      {
+        a: 1,
+        nested: {
+          a: 'base',
+          kept: true
+        }
+      },
+      {
+        b: 2,
+        nested: {
+          a: 'first',
+          b: 'first'
+        }
+      },
+      {
+        a: 3,
+        nested: {
+          b: 'second',
+          c: 'second'
+        }
+      }
+    ) ).toEqual( {
+      a: 3,
+      b: 2,
+      nested: {
+        a: 'first',
+        b: 'second',
+        c: 'second',
+        kept: true
+      }
     } );
   } );
 
-  it( 'Merge object is a clone', () => {
-    const a = {
-      a: 1
-    };
-    const b = {
-      b: 1
-    };
-    const result = deepMerge( a, b );
-    a.a = 2;
-    b.b = 2;
-    expect( result.a ).toEqual( 1 );
+  it( 'ignores non-object values among multiple overlays', () => {
+    expect( deepMerge(
+      { a: 1 },
+      null,
+      { b: 2 },
+      undefined,
+      { a: 3 }
+    ) ).toEqual( {
+      a: 3,
+      b: 2
+    } );
   } );
+} );
 
-  it( 'Returns copy of "a" if "b" is not an object', () => {
+describe( 'deepMergeWithResolver', () => {
+  it( 'returns a clone when only the base object and resolver are provided', () => {
     const a = {
-      a: 1
+      nested: { value: 1 }
     };
-    expect( deepMerge( a, null ) ).toEqual( { a: 1 } );
-    expect( deepMerge( a, undefined ) ).toEqual( { a: 1 } );
-  } );
+    const result = deepMergeWithResolver( a, ( x, y ) => x + y );
 
-  it( 'Copy of object "a" is a clone', () => {
-    const a = {
-      a: 1
-    };
-    const result = deepMerge( a, null );
-    a.a = 2;
-    expect( result.a ).toEqual( 1 );
-  } );
+    a.nested.value = 2;
 
-  it( 'Throws when first argument is not a plain object', () => {
-    expect( () => deepMerge( Function ) ).toThrow( Error );
-    expect( () => deepMerge( () => {} ) ).toThrow( Error );
-    expect( () => deepMerge( 'a' ) ).toThrow( Error );
-    expect( () => deepMerge( true ) ).toThrow( Error );
-    expect( () => deepMerge( /a/ ) ).toThrow( Error );
-    expect( () => deepMerge( [] ) ).toThrow( Error );
-    expect( () => deepMerge( class Foo {}, class Foo {} ) ).toThrow( Error );
-    expect( () => deepMerge( Number.constructor, Number.constructor ) ).toThrow( Error );
-    expect( () => deepMerge( Number.constructor.prototype, Number.constructor.prototype ) ).toThrow( Error );
+    expect( result ).toEqual( {
+      nested: { value: 1 }
+    } );
   } );
-} );
 
-describe( 'deepMergeWithResolver', () => {
   it( 'uses resolver for existing leaf values, including nested leaves', () => {
     const a = {
       cost: { total: 1 },
@@ -235,6 +223,66 @@ describe( 'deepMergeWithResolver', () => {
     expect( () => deepMergeWithResolver( [], {}, ( x, y ) => x + y ) ).toThrow( Error );
     expect( () => deepMergeWithResolver( 'a', {}, ( x, y ) => x + y ) ).toThrow( Error );
   } );
+
+  it( 'throws when last argument is not a resolver function', () => {
+    expect( () => deepMergeWithResolver( { a: 1 }, { a: 2 } ) )
+      .toThrow( 'Last argument (resolver) is not a function.' );
+  } );
+
+  it( 'merges multiple objects using the resolver from left to right', () => {
+    const resolver = vi.fn( ( x, y ) => `${ x }:${ y }` );
+
+    expect( deepMergeWithResolver(
+      {
+        a: 'base',
+        nested: {
+          count: 1,
+          kept: 'yes'
+        }
+      },
+      {
+        a: 'first',
+        nested: {
+          count: 2,
+          firstOnly: true
+        }
+      },
+      {
+        a: 'second',
+        nested: {
+          count: 3,
+          secondOnly: true
+        }
+      },
+      resolver
+    ) ).toEqual( {
+      a: 'base:first:second',
+      nested: {
+        count: '1:2:3',
+        firstOnly: true,
+        kept: 'yes',
+        secondOnly: true
+      }
+    } );
+    expect( resolver ).toHaveBeenCalledTimes( 4 );
+  } );
+
+  it( 'ignores non-object values among multiple resolver overlays', () => {
+    const resolver = vi.fn( ( x, y ) => x + y );
+
+    expect( deepMergeWithResolver(
+      { a: 1 },
+      null,
+      { a: 2 },
+      undefined,
+      { b: 3 },
+      resolver
+    ) ).toEqual( {
+      a: 3,
+      b: 3
+    } );
+    expect( resolver ).toHaveBeenCalledOnce();
+  } );
 } );
 
 describe( 'isPlainObject', () => {

package/src/interface/workflow.js

@@ -7,104 +7,111 @@ 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 { FatalError } from '#errors';
+import * as C from '#consts';
 
 /**
- * Create a new workflow and return a wrapper function around its fn handler
+ * Execute the workflow without temporal, using the fn handler function.
+ * This is important to allow for workflows to have unit tests
  */
+const executeWithoutTemporal = async ( { input, validator, handler, contextOverrides = {} } ) => {
+  validator.validateInput( input );
+  const output = await handler( input, deepMerge( WorkflowContext.build(), contextOverrides ) );
+  validator.validateOutput( output );
+  return output;
+};
+
+/**
+ * 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 ).then( r => r.output );
+  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 );
+  // Disable trace can only be defined at the definition level
+  const disableTrace = options.disableTrace ?? defaultOptions.disableTrace;
   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 handler = async ( input, invocationOptions = {} ) => {
+    validator.validateInvocationOptions( invocationOptions );
 
-      const { workflowId, memo, root } = workflowInfo();
-
-      // 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 executeWithoutTemporal( { input, validator, handler: fn, contextOverrides: invocationOptions?.context } );
+    }
+
+    const { workflowId, runId, memo, root } = workflowInfo();
 
-      const isRoot = !root;
+    checkGlobalContextContamination( runId );
 
-      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();
+    // 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 } ).then( r => r.output );
+    }
+
+    const isRoot = !root; // Check if this is the root most workflow
+
+    // Trace info is only added in the root and only when trace is not disabled
+    if ( isRoot && !disableTrace ) {
+      memo.traceInfo = TraceInfo.build();
+    }
+
+    // Resolve the activity options: invocation options > definition options > parent options > default options
+    const activityOptions = deepMerge(
+      defaultOptions.activityOptions, // default
+      memo?.parentActivityOptions, // parent options
+      options?.activityOptions, // definition options
+      invocationOptions.activityOptions // invocation options
+    );
+    // Resolved activity options are added to memo so child workflow executions can continue the policy chain.
+    memo.parentActivityOptions = activityOptions;
+    const activities = proxyActivities( activityOptions );
+
+    createGlobalDispatcher( { runId, workflowType: name, activities } );
+
+    const traceDestinations = isRoot && {
+      trace: {
+        destinations: disableTrace ? {} : await activities[C.ACTIVITY_GET_TRACE_DESTINATIONS]( memo.traceInfo ).then( r => r.output ) ?? {}
       }
+    };
 
-      const steps = proxyActivities( memo.activityOptions );
-      const traceDestinations = isRoot && {
-        trace: {
-          destinations: disableTrace ? {} : ( await steps[ACTIVITY_GET_TRACE_DESTINATIONS]( memo.traceInfo ) ).output ?? {}
-        }
-      };
-
-      try {
-        validator.validateInput( input );
-
-        // Creates an activity caller based on a prefix
-        const createCaller = prefix => async ( t, ...args ) => ( await steps[`${prefix}#${t}`]( ...args ) ).output;
-
-        // 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 )
-        };
-
-        // The workflow function execution with "this" set with the dispatchers
-        const output = await fn.call( dispatchers, input, WorkflowContext.build() );
-        validator.validateOutput( output );
-
-        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;
+    try {
+      validator.validateInput( input );
+      const output = await fn( input, WorkflowContext.build() );
+      validator.validateOutput( output );
+
+      return { [C.WORKFLOW_WRAPPER_VERSION_FIELD]: 1, output, ...traceDestinations };
+    } catch ( error ) {
+      if ( traceDestinations ) {
+        // Append the trace destinations so it is carried to interceptor
+        error[C.METADATA_ACCESS_SYMBOL] = traceDestinations;
       }
+      throw error;
     }
-  } );
+  };
+
+  return createWorkflow( { name, description, inputSchema, outputSchema, options, aliases, handler } );
 }