@outputai/core 0.10.1-next.fc0a41f.0 → 0.11.0

package/src/interface/workflow.spec.js

@@ -2,10 +2,7 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { z } from 'zod';
 import {
   ACTIVITY_GET_TRACE_DESTINATIONS,
-  ACTIVITY_WRAPPER_VERSION_FIELD,
-  INVOKE_ACTIVITY_SYMBOL,
-  METADATA_ACCESS_SYMBOL,
-  WORKFLOW_WRAPPER_VERSION_FIELD
+  INVOKE_ACTIVITY_SYMBOL
 } from '#consts';
 import { ValidationError } from '#errors';
 
@@ -13,11 +10,12 @@ const inWorkflowContextMock = vi.hoisted( () => vi.fn() );
 const proxyActivitiesMock = vi.hoisted( () => vi.fn() );
 const executeChildMock = vi.hoisted( () => vi.fn() );
 const workflowInfoMock = vi.hoisted( () => vi.fn() );
+const upsertMemoMock = vi.hoisted( () => vi.fn() );
 const continueAsNewMock = vi.hoisted( () => vi.fn() );
 const validateDefinitionMock = vi.hoisted( () => vi.fn() );
-const validateInputMock = vi.hoisted( () => vi.fn() );
-const validateOutputMock = vi.hoisted( () => vi.fn() );
-const validateInvocationOptionsMock = vi.hoisted( () => vi.fn() );
+const parseInputMock = vi.hoisted( () => vi.fn( input => input ) );
+const parseOutputMock = vi.hoisted( () => vi.fn( output => output ) );
+const parseInvocationOptionsMock = vi.hoisted( () => vi.fn( options => options ) );
 const validatorConstructorMock = vi.hoisted( () => vi.fn() );
 const createWorkflowMock = vi.hoisted( () => vi.fn( ( { handler } ) => handler ) );
 
@@ -29,9 +27,9 @@ vi.mock( './validations/index.js', () => {
 
     constructor( ...args ) {
       validatorConstructorMock( ...args );
-      this.validateInput = validateInputMock;
-      this.validateOutput = validateOutputMock;
-      this.validateInvocationOptions = validateInvocationOptionsMock;
+      this.parseInput = parseInputMock;
+      this.parseOutput = parseOutputMock;
+      this.parseInvocationOptions = parseInvocationOptionsMock;
     }
   }
 
@@ -50,6 +48,7 @@ vi.mock( '@temporalio/workflow', async importOriginal => {
     proxyActivities: proxyActivitiesMock,
     executeChild: executeChildMock,
     workflowInfo: workflowInfoMock,
+    upsertMemo: upsertMemoMock,
     continueAsNew: continueAsNewMock,
     uuid4: () => '550e8400e29b41d4a716446655440000'
   };
@@ -60,28 +59,24 @@ const baseWorkflowInfo = () => ( {
   workflowType: 'test_wf',
   runId: 'run-123',
   startTime: new Date( '2025-01-01T00:00:00.000Z' ),
-  memo: {},
+  memo: { traceInfo: { workflowId: 'workflow-123' } },
   continueAsNewSuggested: false
 } );
 
 const setWorkflowInfo = overrides => {
+  const base = baseWorkflowInfo();
   const info = {
-    ...baseWorkflowInfo(),
+    ...base,
     ...overrides,
-    memo: overrides?.memo ?? {}
+    memo: overrides?.memo ?? base.memo
   };
   workflowInfoMock.mockImplementation( () => info );
   return info;
 };
 
-const activityOutput = output => ( {
-  output,
-  [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
-} );
-
 const createActivities = handlers => new Proxy( {}, {
   get: ( _, prop ) => typeof prop === 'string' ?
-    handlers[prop] ?? vi.fn().mockResolvedValue( activityOutput( undefined ) ) :
+    handlers[prop] ?? vi.fn().mockResolvedValue( undefined ) :
     undefined
 } );
 
@@ -112,10 +107,10 @@ describe( 'workflow()', () => {
     vi.clearAllMocks();
     delete globalThis[INVOKE_ACTIVITY_SYMBOL];
     inWorkflowContextMock.mockReturnValue( true );
-    executeChildMock.mockResolvedValue( { output: {} } );
+    executeChildMock.mockResolvedValue( {} );
     setWorkflowInfo();
     mockActivities( {
-      [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( { local: '/tmp/trace' } ) )
+      [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( { local: '/tmp/trace' } )
     } );
   } );
 
@@ -210,9 +205,9 @@ describe( 'workflow()', () => {
         value: 'test-workflow-ok',
         extra: 'custom'
       } );
-      expect( validateInvocationOptionsMock ).toHaveBeenCalledWith( { context: { extra: 'custom' } } );
-      expect( validateInputMock ).toHaveBeenCalledWith( { suffix: '-ok' } );
-      expect( validateOutputMock ).toHaveBeenCalledWith( { value: 'test-workflow-ok', extra: 'custom' } );
+      expect( parseInvocationOptionsMock ).toHaveBeenCalledWith( { context: { extra: 'custom' } } );
+      expect( parseInputMock ).toHaveBeenCalledWith( { suffix: '-ok' } );
+      expect( parseOutputMock ).toHaveBeenCalledWith( { value: 'test-workflow-ok', extra: 'custom' } );
       expect( workflowInfoMock ).not.toHaveBeenCalled();
       expect( proxyActivitiesMock ).not.toHaveBeenCalled();
     } );
@@ -220,7 +215,7 @@ describe( 'workflow()', () => {
     it( 'does not run fn when plain function input validation fails', async () => {
       const { workflow } = await import( './workflow.js' );
       const error = new ValidationError( 'invalid input' );
-      validateInputMock.mockImplementationOnce( () => {
+      parseInputMock.mockImplementationOnce( () => {
         throw error;
       } );
       const fn = vi.fn();
@@ -234,13 +229,13 @@ describe( 'workflow()', () => {
 
       await expect( wf( { value: 1 } ) ).rejects.toBe( error );
       expect( fn ).not.toHaveBeenCalled();
-      expect( validateOutputMock ).not.toHaveBeenCalled();
+      expect( parseOutputMock ).not.toHaveBeenCalled();
     } );
 
     it( 'propagates plain function output validation errors after fn runs', async () => {
       const { workflow } = await import( './workflow.js' );
       const error = new ValidationError( 'invalid output' );
-      validateOutputMock.mockImplementationOnce( () => {
+      parseOutputMock.mockImplementationOnce( () => {
         throw error;
       } );
       const output = { result: 1 };
@@ -257,7 +252,7 @@ describe( 'workflow()', () => {
       expect( fn ).toHaveBeenCalledWith( { value: 'ok' }, expect.objectContaining( {
         info: { workflowId: 'test-workflow', runId: 'test-run' }
       } ) );
-      expect( validateOutputMock ).toHaveBeenCalledWith( output );
+      expect( parseOutputMock ).toHaveBeenCalledWith( output );
     } );
   } );
 
@@ -268,7 +263,7 @@ describe( 'workflow()', () => {
       installGlobalDispatcher( 'run-123' );
       const memo = {
         traceInfo: { workflowId: 'root-workflow' },
-        parentActivityOptions: {
+        activityOptions: {
           heartbeatTimeout: '30s',
           retry: {
             maximumInterval: '20s',
@@ -277,7 +272,7 @@ describe( 'workflow()', () => {
         }
       };
       setWorkflowInfo( { memo } );
-      executeChildMock.mockResolvedValueOnce( { output: { child: 'ok' } } );
+      executeChildMock.mockResolvedValueOnce( { child: 'ok' } );
 
       const wf = workflow( workflowDefinition( {
         name: 'child_target_wf',
@@ -294,7 +289,7 @@ describe( 'workflow()', () => {
           retry: { maximumAttempts: 7 }
         }
       } ) ).resolves.toEqual( { child: 'ok' } );
-      expect( validateInvocationOptionsMock ).toHaveBeenCalledWith( {
+      expect( parseInvocationOptionsMock ).toHaveBeenCalledWith( {
         detached: true,
         context: { testOnly: true },
         activityOptions: {
@@ -326,7 +321,7 @@ describe( 'workflow()', () => {
       const { ParentClosePolicy } = await import( '@temporalio/workflow' );
       installGlobalDispatcher( 'run-123' );
       setWorkflowInfo( { memo: { traceInfo: { workflowId: 'root-workflow' } } } );
-      executeChildMock.mockResolvedValueOnce( { output: 'done' } );
+      executeChildMock.mockResolvedValueOnce( 'done' );
 
       const wf = workflow( workflowDefinition( {
         name: 'no_input_child_wf',
@@ -356,6 +351,20 @@ describe( 'workflow()', () => {
   } );
 
   describe( 'workflow execution path', () => {
+    it( 'validates invocation options before reading workflow information', async () => {
+      const { workflow } = await import( './workflow.js' );
+      const error = new ValidationError( 'invalid invocation options' );
+      parseInvocationOptionsMock.mockImplementationOnce( () => {
+        throw error;
+      } );
+      const wf = workflow( workflowDefinition() );
+
+      await expect( wf( {}, { invalid: true } ) ).rejects.toBe( error );
+
+      expect( upsertMemoMock ).not.toHaveBeenCalled();
+      expect( workflowInfoMock ).not.toHaveBeenCalled();
+    } );
+
     it( 'rejects a global activity dispatcher left by another workflow run', async () => {
       const { workflow } = await import( './workflow.js' );
       const fn = vi.fn().mockResolvedValue( {} );
@@ -373,9 +382,9 @@ describe( 'workflow()', () => {
       expect( fn ).not.toHaveBeenCalled();
     } );
 
-    it( 'initializes root memo, skips trace destinations when trace is disabled, validates output, and returns an envelope', async () => {
+    it( 'skips trace destinations when trace is disabled and returns raw output', async () => {
       const { workflow } = await import( './workflow.js' );
-      const getTraceDestinations = vi.fn().mockResolvedValue( activityOutput( { local: '/tmp/root-trace' } ) );
+      const getTraceDestinations = vi.fn().mockResolvedValue( { local: '/tmp/root-trace' } );
       const info = setWorkflowInfo( { workflowType: 'root_wf', memo: {} } );
       mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: getTraceDestinations } );
 
@@ -392,32 +401,28 @@ describe( 'workflow()', () => {
         fn: async ( _, context ) => ( { ok: context.info.workflowId === 'workflow-123' } )
       } ) );
 
-      await expect( wf( {} ) ).resolves.toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { ok: true },
-        trace: { destinations: {} }
-      } );
+      await expect( wf( {} ) ).resolves.toEqual( { ok: true } );
       expect( info.memo.traceInfo ).toBeUndefined();
       expect( info.memo.activityOptions ).toBeUndefined();
-      expect( info.memo.parentActivityOptions ).toEqual( expect.objectContaining( {
-        startToCloseTimeout: '5m',
-        heartbeatTimeout: '5m',
-        retry: expect.objectContaining( { maximumAttempts: 5 } )
-      } ) );
       expect( proxyActivitiesMock ).toHaveBeenCalledWith( expect.objectContaining( {
         startToCloseTimeout: '5m',
         heartbeatTimeout: '5m',
         retry: expect.objectContaining( { maximumAttempts: 5 } )
       } ) );
       expect( getTraceDestinations ).not.toHaveBeenCalled();
+      expect( upsertMemoMock ).toHaveBeenCalledOnce();
+      expect( upsertMemoMock ).toHaveBeenCalledWith( {
+        activityOptions: proxyActivitiesMock.mock.calls[0][0]
+      } );
     } );
 
     it( 'resolves activity options by invocation, definition, inherited memo, then default precedence', async () => {
       const { workflow } = await import( './workflow.js' );
-      const info = setWorkflowInfo( {
+      setWorkflowInfo( {
         workflowType: 'activity_options_wf',
         memo: {
-          parentActivityOptions: {
+          traceInfo: { workflowId: 'workflow-123' },
+          activityOptions: {
             heartbeatTimeout: '30s',
             retry: {
               maximumInterval: '30s',
@@ -458,18 +463,22 @@ describe( 'workflow()', () => {
           backoffCoefficient: 3,
           maximumInterval: '30s',
           maximumAttempts: 9,
-          nonRetryableErrorTypes: [ ValidationError.name, 'FatalError' ]
+          nonRetryableErrorTypes: [ 'FatalError' ]
         }
       } );
-      expect( info.memo.parentActivityOptions ).toEqual( proxyActivitiesMock.mock.calls[0][0] );
+      expect( upsertMemoMock ).toHaveBeenCalledOnce();
+      expect( upsertMemoMock ).toHaveBeenCalledWith( {
+        activityOptions: proxyActivitiesMock.mock.calls[0][0],
+        trace: { local: '/tmp/trace' }
+      } );
     } );
 
     it( 'runs non-root workflow execution without rebuilding trace info or fetching trace destinations', async () => {
       const { workflow } = await import( './workflow.js' );
-      const getTraceDestinations = vi.fn().mockResolvedValue( activityOutput( { local: '/tmp/trace' } ) );
+      const getTraceDestinations = vi.fn().mockResolvedValue( { local: '/tmp/trace' } );
       const memo = {
         traceInfo: { workflowId: 'root-workflow' },
-        parentActivityOptions: {
+        activityOptions: {
           startToCloseTimeout: '9m',
           retry: { maximumAttempts: 8 }
         }
@@ -493,29 +502,27 @@ describe( 'workflow()', () => {
         fn: async () => ( { ok: true } )
       } ) );
 
-      await expect( wf( {} ) ).resolves.toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { ok: true }
-      } );
+      await expect( wf( {} ) ).resolves.toEqual( { ok: true } );
       expect( info.memo.traceInfo ).toBe( memo.traceInfo );
-      expect( info.memo.activityOptions ).toBeUndefined();
-      expect( info.memo.parentActivityOptions ).toEqual( expect.objectContaining( {
-        startToCloseTimeout: '1m',
-        heartbeatTimeout: '5m',
-        retry: expect.objectContaining( { maximumAttempts: 2 } )
-      } ) );
       expect( proxyActivitiesMock ).toHaveBeenCalledWith( expect.objectContaining( {
         startToCloseTimeout: '1m',
         heartbeatTimeout: '5m',
         retry: expect.objectContaining( { maximumAttempts: 2 } )
       } ) );
       expect( getTraceDestinations ).not.toHaveBeenCalled();
+      expect( upsertMemoMock ).toHaveBeenCalledOnce();
+      expect( upsertMemoMock ).toHaveBeenCalledWith( {
+        activityOptions: proxyActivitiesMock.mock.calls[0][0]
+      } );
     } );
 
-    it( 'returns empty trace destinations when getTraceDestinations returns no destinations', async () => {
+    it( 'stores empty trace destinations in memo and returns raw output', async () => {
       const { workflow } = await import( './workflow.js' );
-      setWorkflowInfo( { workflowType: 'no_trace_dest_wf' } );
-      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( {} ) ) } );
+      setWorkflowInfo( {
+        workflowType: 'no_trace_dest_wf',
+        memo: { traceInfo: { workflowId: 'workflow-123' } }
+      } );
+      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( {} ) } );
 
       const wf = workflow( workflowDefinition( {
         name: 'no_trace_dest_wf',
@@ -523,10 +530,11 @@ describe( 'workflow()', () => {
         fn: async () => ( { ok: true } )
       } ) );
 
-      await expect( wf( {} ) ).resolves.toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { ok: true },
-        trace: { destinations: {} }
+      await expect( wf( {} ) ).resolves.toEqual( { ok: true } );
+      expect( upsertMemoMock ).toHaveBeenCalledOnce();
+      expect( upsertMemoMock ).toHaveBeenCalledWith( {
+        activityOptions: proxyActivitiesMock.mock.calls[0][0],
+        trace: {}
       } );
     } );
 
@@ -543,30 +551,38 @@ describe( 'workflow()', () => {
         fn: async () => ( { result: 1 } )
       } ) );
 
-      validateInputMock.mockImplementationOnce( () => {
+      parseInputMock.mockImplementationOnce( () => {
         throw inputError;
       } );
       await expect( wf( { value: 1 } ) ).rejects.toBe( inputError );
-      expect( inputError[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: { local: '/tmp/trace' } } } );
+      expect( upsertMemoMock ).toHaveBeenCalledWith( expect.objectContaining( {
+        trace: { local: '/tmp/trace' }
+      } ) );
 
       delete globalThis[INVOKE_ACTIVITY_SYMBOL];
-      setWorkflowInfo( { workflowType: 'runtime_validation_wf', memo: {} } );
-      validateOutputMock.mockImplementationOnce( () => {
+      setWorkflowInfo( {
+        workflowType: 'runtime_validation_wf',
+        memo: { traceInfo: { workflowId: 'workflow-123' } }
+      } );
+      upsertMemoMock.mockClear();
+      parseOutputMock.mockImplementationOnce( () => {
         throw outputError;
       } );
       await expect( wf( { value: 'ok' } ) ).rejects.toBe( outputError );
-      expect( outputError[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: { local: '/tmp/trace' } } } );
+      expect( upsertMemoMock ).toHaveBeenCalledWith( expect.objectContaining( {
+        trace: { local: '/tmp/trace' }
+      } ) );
     } );
   } );
 
   describe( 'activity dispatchers', () => {
-    it( 'invokes workflow-scoped activities and unwraps activity output', async () => {
+    it( 'invokes workflow-scoped activities and returns their raw outputs', async () => {
       const { workflow } = await import( './workflow.js' );
       setWorkflowInfo( { workflowType: 'dispatch_wf' } );
-      const step = vi.fn().mockResolvedValue( activityOutput( 'step-output' ) );
-      const evaluator = vi.fn().mockResolvedValue( activityOutput( 'eval-output' ) );
+      const step = vi.fn().mockResolvedValue( 'step-output' );
+      const evaluator = vi.fn().mockResolvedValue( 'eval-output' );
       mockActivities( {
-        [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( null ) ),
+        [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( {} ),
         'dispatch_wf#stepA': step,
         'dispatch_wf#evalA': evaluator
       } );
@@ -582,11 +598,7 @@ describe( 'workflow()', () => {
         }
       } ) );
 
-      await expect( wf( {} ) ).resolves.toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { stepResult: 'step-output', evalResult: 'eval-output' },
-        trace: { destinations: {} }
-      } );
+      await expect( wf( {} ) ).resolves.toEqual( { stepResult: 'step-output', evalResult: 'eval-output' } );
       expect( step ).toHaveBeenCalledWith( { a: 1 }, { b: 2 } );
       expect( evaluator ).toHaveBeenCalledWith( { c: 3 } );
     } );
@@ -594,10 +606,10 @@ describe( 'workflow()', () => {
     it( 'invokes shared activities through the workflow namespace', async () => {
       const { workflow } = await import( './workflow.js' );
       setWorkflowInfo( { workflowType: 'shared_dispatch_wf' } );
-      const sharedStep = vi.fn().mockResolvedValue( activityOutput( 'shared-step-output' ) );
-      const sharedEvaluator = vi.fn().mockResolvedValue( activityOutput( 'shared-eval-output' ) );
+      const sharedStep = vi.fn().mockResolvedValue( 'shared-step-output' );
+      const sharedEvaluator = vi.fn().mockResolvedValue( 'shared-eval-output' );
       mockActivities( {
-        [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( null ) ),
+        [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( {} ),
         'shared_dispatch_wf#stepA': sharedStep,
         'shared_dispatch_wf#evalA': sharedEvaluator
       } );
@@ -614,9 +626,8 @@ describe( 'workflow()', () => {
       } ) );
 
       await expect( wf( {} ) ).resolves.toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { stepResult: 'shared-step-output', evalResult: 'shared-eval-output' },
-        trace: { destinations: {} }
+        stepResult: 'shared-step-output',
+        evalResult: 'shared-eval-output'
       } );
       expect( sharedStep ).toHaveBeenCalledWith();
       expect( sharedEvaluator ).toHaveBeenCalledWith( { x: 1 } );
@@ -624,7 +635,7 @@ describe( 'workflow()', () => {
   } );
 
   describe( 'error handling', () => {
-    it( 'attaches root trace destinations to root workflow errors and preserves existing details', async () => {
+    it( 'stores root trace destinations in memo and preserves workflow errors', async () => {
       const { workflow } = await import( './workflow.js' );
       const error = new Error( 'root failed with details' );
       error.details = [ { domain: { reason: 'bad-input' } } ];
@@ -640,27 +651,12 @@ describe( 'workflow()', () => {
       const thrown = await wf( {} ).catch( e => e );
       expect( thrown ).toBe( error );
       expect( error.details ).toEqual( [ { domain: { reason: 'bad-input' } } ] );
-      expect( error[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: { local: '/tmp/trace' } } } );
-    } );
-
-    it( 'attaches empty trace destinations to root workflow errors when no destinations are available', async () => {
-      const { workflow } = await import( './workflow.js' );
-      setWorkflowInfo( { workflowType: 'root_error_no_trace_wf' } );
-      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( {} ) ) } );
-      const error = new Error( 'root failed without trace' );
-
-      const wf = workflow( workflowDefinition( {
-        name: 'root_error_no_trace_wf',
-        fn: async () => {
-          throw error;
-        }
+      expect( upsertMemoMock ).toHaveBeenCalledWith( expect.objectContaining( {
+        trace: { local: '/tmp/trace' }
       } ) );
-
-      await expect( wf( {} ) ).rejects.toBe( error );
-      expect( error[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: {} } } );
     } );
 
-    it( 'attaches trace metadata to existing root ApplicationFailure without wrapping it', async () => {
+    it( 'preserves existing root ApplicationFailure metadata', async () => {
       const { workflow } = await import( './workflow.js' );
       const { ApplicationFailure } = await import( '@temporalio/workflow' );
       setWorkflowInfo( { workflowType: 'root_application_failure_wf' } );
@@ -683,7 +679,9 @@ describe( 'workflow()', () => {
       expect( thrown ).toBe( error );
       expect( error.type ).toBe( 'OriginalType' );
       expect( error.details ).toEqual( [ { domain: { reason: 'bad-input' } } ] );
-      expect( error[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: { local: '/tmp/trace' } } } );
+      expect( upsertMemoMock ).toHaveBeenCalledWith( expect.objectContaining( {
+        trace: { local: '/tmp/trace' }
+      } ) );
     } );
 
     it( 'rethrows non-root workflow errors without ApplicationFailure wrapping', async () => {
@@ -703,7 +701,10 @@ describe( 'workflow()', () => {
       } ) );
 
       await expect( wf( {} ) ).rejects.toBe( error );
-      expect( error[METADATA_ACCESS_SYMBOL] ).toBeUndefined();
+      expect( upsertMemoMock ).toHaveBeenCalledOnce();
+      expect( upsertMemoMock ).toHaveBeenCalledWith( {
+        activityOptions: proxyActivitiesMock.mock.calls[0][0]
+      } );
     } );
   } );
 } );

package/src/interface/workflow_activity_options.js

@@ -1,5 +1,3 @@
-import { FatalError, ValidationError } from '#errors';
-
 export const defaultOptions = {
   activityOptions: {
     startToCloseTimeout: '20m',
@@ -9,8 +7,7 @@ export const defaultOptions = {
       backoffCoefficient: 2.0,
       maximumInterval: '2m',
       maximumAttempts: 3,
-      nonRetryableErrorTypes: [ ValidationError.name, FatalError.name ]
+      nonRetryableErrorTypes: []
     }
-  },
-  disableTrace: false
+  }
 };

package/src/temporal/client.js

@@ -0,0 +1,47 @@
+import { Client } from '@temporalio/client';
+import { Storage } from '#async_storage';
+import { FatalError } from '#errors';
+
+// store the instance creation configs
+const config = {
+  connection: null,
+  namespace: null
+};
+
+// store a single instance that is created on demand
+const instance = {
+  client: null
+};
+
+// Adds the config necessary to init Clients
+export const setupClientConfig = ( { connection, namespace } ) => {
+  config.connection = new Proxy( connection, {
+    get( target, property, receiver ) {
+      if ( property === 'close' ) {
+        return async () => {
+          throw new FatalError( 'Client connection cannot be closed. It is owned by the worker.' );
+        };
+      }
+      return Reflect.get( target, property, receiver );
+    }
+  } );
+  config.namespace = namespace;
+};
+
+/** Return a new Temporal client instance */
+export const createTemporalClient = () => {
+  if ( !config.connection ) {
+    throw new FatalError( 'createTemporalClient() can only be called from within the worker runtime.' );
+  }
+  return new Client( { ...config } );
+};
+
+/** Get the workflow handle for the current workflow execution */
+export const getCurrentWorkflowHandle = () => {
+  const ctx = Storage.load();
+  if ( !ctx || !config.connection ) {
+    throw new FatalError( 'getCurrentWorkflowHandle() can only be called from Temporal activities running in the worker.' );
+  }
+  const { workflowId, runId } = ctx.activityInfo.workflowExecution;
+  return ( instance.client ??= new Client( config ) ).workflow.getHandle( workflowId, runId );
+};

package/src/temporal/client.spec.js

@@ -0,0 +1,124 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const loadMock = vi.fn();
+vi.mock( '#async_storage', () => ( {
+  Storage: { load: loadMock }
+} ) );
+
+const getHandleMock = vi.fn();
+const clientConstructorMock = vi.fn( function () {
+  this.workflow = { getHandle: getHandleMock };
+} );
+vi.mock( '@temporalio/client', () => ( {
+  Client: clientConstructorMock
+} ) );
+
+const connection = {
+  fake: 'native-connection',
+  close: vi.fn().mockResolvedValue( undefined )
+};
+const activityContext = {
+  activityInfo: {
+    workflowExecution: {
+      workflowId: 'workflow-1',
+      runId: 'run-1'
+    }
+  }
+};
+
+describe( 'Temporal client', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    vi.resetModules();
+  } );
+
+  describe( 'createTemporalClient', () => {
+    it( 'throws a FatalError outside the worker runtime', async () => {
+      const { createTemporalClient } = await import( './client.js' );
+      const { FatalError } = await import( '#errors' );
+
+      expect( () => createTemporalClient() ).toThrow( FatalError );
+    } );
+
+    it( 'creates a client with the worker connection and namespace', async () => {
+      const { createTemporalClient, setupClientConfig } = await import( './client.js' );
+      setupClientConfig( { connection, namespace: 'namespace-1' } );
+
+      const client = createTemporalClient();
+
+      expect( clientConstructorMock ).toHaveBeenCalledWith( {
+        connection: expect.anything(),
+        namespace: 'namespace-1'
+      } );
+      expect( clientConstructorMock.mock.calls[0][0].connection ).not.toBe( connection );
+      expect( client ).toBeInstanceOf( clientConstructorMock );
+    } );
+
+    it( 'delegates connection access but prevents closing the worker connection', async () => {
+      const { createTemporalClient, setupClientConfig } = await import( './client.js' );
+      const { FatalError } = await import( '#errors' );
+      setupClientConfig( { connection, namespace: 'namespace-1' } );
+
+      createTemporalClient();
+      const clientConnection = clientConstructorMock.mock.calls[0][0].connection;
+
+      expect( clientConnection.fake ).toBe( 'native-connection' );
+      await expect( clientConnection.close() ).rejects.toThrow( FatalError );
+      expect( connection.close ).not.toHaveBeenCalled();
+    } );
+
+    it( 'returns a new client on each call', async () => {
+      const { createTemporalClient, setupClientConfig } = await import( './client.js' );
+      setupClientConfig( { connection, namespace: 'namespace-1' } );
+
+      expect( createTemporalClient() ).not.toBe( createTemporalClient() );
+      expect( clientConstructorMock ).toHaveBeenCalledTimes( 2 );
+    } );
+  } );
+
+  describe( 'getCurrentWorkflowHandle', () => {
+    it( 'throws a FatalError outside a Temporal activity context', async () => {
+      loadMock.mockReturnValue( undefined );
+      const { getCurrentWorkflowHandle, setupClientConfig } = await import( './client.js' );
+      const { FatalError } = await import( '#errors' );
+      setupClientConfig( { connection, namespace: 'namespace-1' } );
+
+      expect( () => getCurrentWorkflowHandle() ).toThrow( FatalError );
+    } );
+
+    it( 'throws a FatalError outside the worker runtime', async () => {
+      loadMock.mockReturnValue( activityContext );
+      const { getCurrentWorkflowHandle } = await import( './client.js' );
+      const { FatalError } = await import( '#errors' );
+
+      expect( () => getCurrentWorkflowHandle() ).toThrow( FatalError );
+    } );
+
+    it( 'returns the handle for the current workflow execution', async () => {
+      const handle = { signal: vi.fn() };
+      loadMock.mockReturnValue( activityContext );
+      getHandleMock.mockReturnValue( handle );
+      const { getCurrentWorkflowHandle, setupClientConfig } = await import( './client.js' );
+      setupClientConfig( { connection, namespace: 'namespace-1' } );
+
+      expect( getCurrentWorkflowHandle() ).toBe( handle );
+      expect( clientConstructorMock ).toHaveBeenCalledWith( {
+        connection: expect.anything(),
+        namespace: 'namespace-1'
+      } );
+      expect( getHandleMock ).toHaveBeenCalledWith( 'workflow-1', 'run-1' );
+    } );
+
+    it( 'reuses its client across calls', async () => {
+      loadMock.mockReturnValue( activityContext );
+      const { getCurrentWorkflowHandle, setupClientConfig } = await import( './client.js' );
+      setupClientConfig( { connection, namespace: 'namespace-1' } );
+
+      getCurrentWorkflowHandle();
+      getCurrentWorkflowHandle();
+
+      expect( clientConstructorMock ).toHaveBeenCalledTimes( 1 );
+      expect( getHandleMock ).toHaveBeenCalledTimes( 2 );
+    } );
+  } );
+} );