@outputai/core 0.14.0 → 0.14.1-next.2947341.0

package/src/worker/interceptors/workflow.spec.js

@@ -1,357 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ApplicationFailure } from '@temporalio/common';
-import { FatalError, TransparentFatalError, ValidationError } from '#errors';
-
-const workflowInfoMock = vi.fn();
-const workflowStartMock = vi.fn();
-const workflowEndMock = vi.fn();
-const workflowErrorMock = vi.fn();
-const isCancellationMock = vi.fn();
-const upsertMemoMock = vi.fn();
-const traceInfoBuildMock = vi.fn();
-const startTime = new Date( '2026-06-02T09:00:00.000Z' );
-const runStartTime = new Date( '2026-06-02T09:05:00.000Z' );
-const workflowDetails = {
-  attempt: 1,
-  continuedFromExecutionRunId: undefined,
-  firstExecutionRunId: 'first-run',
-  parent: undefined,
-  root: undefined,
-  runId: 'run-1',
-  runStartTime: runStartTime.getTime(),
-  startTime: startTime.getTime(),
-  workflowId: 'workflow-1',
-  workflowType: 'MyWorkflow'
-};
-
-const workflowInfo = {
-  attempt: 1,
-  continuedFromExecutionRunId: undefined,
-  firstExecutionRunId: 'first-run',
-  parent: undefined,
-  root: undefined,
-  runId: 'run-1',
-  runStartTime,
-  startTime,
-  workflowId: 'workflow-1',
-  workflowType: 'MyWorkflow',
-  memo: { traceInfo: { runId: 'root-run' } }
-};
-
-vi.mock( '@temporalio/workflow', async importOriginal => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    workflowInfo: ( ...args ) => workflowInfoMock( ...args ),
-    proxySinks: () => ( {
-      workflow: { start: workflowStartMock, end: workflowEndMock, error: workflowErrorMock }
-    } ),
-    ContinueAsNew: class ContinueAsNew extends Error {
-      constructor() {
-        super( 'ContinueAsNew' );
-        this.name = 'ContinueAsNew';
-      }
-    },
-    isCancellation: ( ...args ) => isCancellationMock( ...args ),
-    upsertMemo: ( ...args ) => upsertMemoMock( ...args )
-  };
-} );
-
-vi.mock( '#helpers/trace_info', () => ( { TraceInfo: { build: ( ...args ) => traceInfoBuildMock( ...args ) } } ) );
-
-const memoToHeadersMock = vi.fn( memo => ( memo ? { ...memo, __asHeaders: true } : {} ) );
-vi.mock( './headers.js', () => ( { memoToHeaders: ( ...args ) => memoToHeadersMock( ...args ) } ) );
-
-const deepMergeMock = vi.fn( ( a, b ) => ( { ...( a || {} ), ...( b || {} ) } ) );
-vi.mock( '#helpers/object', () => ( { deepMerge: ( ...args ) => deepMergeMock( ...args ) } ) );
-
-const activityOptionsDefault = {};
-vi.mock( '../temp/__activity_options.js', () => ( { default: activityOptionsDefault } ) );
-
-const workflowOptionsDefault = {};
-vi.mock( '../temp/__workflow_options.js', () => ( { default: workflowOptionsDefault } ) );
-
-describe( 'workflow interceptors', () => {
-  beforeEach( () => {
-    vi.clearAllMocks();
-    Object.keys( activityOptionsDefault ).forEach( key => delete activityOptionsDefault[key] );
-    Object.keys( workflowOptionsDefault ).forEach( key => delete workflowOptionsDefault[key] );
-    workflowOptionsDefault.MyWorkflow = { disableTrace: false };
-    isCancellationMock.mockReturnValue( false );
-    traceInfoBuildMock.mockReturnValue( { workflowId: 'workflow-1', runId: 'run-1' } );
-    workflowInfoMock.mockReturnValue( workflowInfo );
-  } );
-
-  describe( 'HeadersInjectionInterceptor', () => {
-    it( 'assigns memo as headers via memoToHeaders and calls next', async () => {
-      const { interceptors } = await import( './workflow.js' );
-      const { outbound } = interceptors();
-      const interceptor = outbound[0];
-      const input = { headers: { existing: 'header' }, activityType: 'MyWorkflow#step1', options: {} };
-      const next = vi.fn().mockResolvedValue( 'result' );
-
-      memoToHeadersMock.mockReturnValue( { traceInfo: workflowInfo.memo.traceInfo, workflowDetails } );
-
-      const out = await interceptor.scheduleActivity( input, next );
-
-      expect( memoToHeadersMock ).toHaveBeenCalledWith( {
-        traceInfo: workflowInfo.memo.traceInfo,
-        workflowDetails
-      } );
-      expect( input.headers ).toEqual( {
-        existing: 'header',
-        traceInfo: workflowInfo.memo.traceInfo,
-        workflowDetails
-      } );
-      expect( next ).toHaveBeenCalledWith( input );
-      expect( out ).toBe( 'result' );
-    } );
-
-    it( 'merges component activity options over the scheduled activity input options', async () => {
-      activityOptionsDefault['MyWorkflow#step1'] = { scheduleToCloseTimeout: 60 };
-      workflowInfoMock.mockReturnValue( {
-        ...workflowInfo,
-        memo: { traceInfo: workflowInfo.memo.traceInfo }
-      } );
-      memoToHeadersMock.mockReturnValue( {} );
-      deepMergeMock.mockReturnValue( {
-        heartbeatTimeout: 10,
-        scheduleToCloseTimeout: 60,
-        retry: { maximumAttempts: 2, nonRetryableErrorTypes: [ 'StepError' ] }
-      } );
-
-      const { interceptors } = await import( './workflow.js' );
-      const { outbound } = interceptors();
-      const interceptor = outbound[0];
-      const input = { headers: {}, activityType: 'MyWorkflow#step1', options: { heartbeatTimeout: 10 } };
-      const next = vi.fn().mockResolvedValue( undefined );
-
-      await interceptor.scheduleActivity( input, next );
-
-      expect( deepMergeMock ).toHaveBeenCalledWith( { heartbeatTimeout: 10 }, { scheduleToCloseTimeout: 60 } );
-      expect( input.options ).toEqual( {
-        heartbeatTimeout: 10,
-        scheduleToCloseTimeout: 60,
-        retry: {
-          maximumAttempts: 2,
-          nonRetryableErrorTypes: [ 'StepError', 'FatalError' ]
-        }
-      } );
-    } );
-
-    it( 'adds FatalError to activity retry options without duplicates', async () => {
-      const { interceptors } = await import( './workflow.js' );
-      const { outbound } = interceptors();
-      const interceptor = outbound[0];
-      const input = {
-        headers: {},
-        activityType: 'MyWorkflow#step1',
-        options: {
-          retry: {
-            maximumAttempts: 4,
-            nonRetryableErrorTypes: [ 'DomainError', 'FatalError' ]
-          }
-        }
-      };
-      const next = vi.fn().mockResolvedValue( undefined );
-
-      await interceptor.scheduleActivity( input, next );
-
-      expect( input.options.retry ).toEqual( {
-        maximumAttempts: 4,
-        nonRetryableErrorTypes: [ 'DomainError', 'FatalError' ]
-      } );
-    } );
-  } );
-
-  describe( 'WorkflowExecutionInterceptor', () => {
-    it( 'upserts root trace info before starting the workflow trace', async () => {
-      const { interceptors } = await import( './workflow.js' );
-      const { inbound } = interceptors();
-      const traceInfo = { workflowId: 'workflow-1', runId: 'run-1' };
-      traceInfoBuildMock.mockReturnValue( traceInfo );
-
-      await inbound[0].execute( { args: [ {} ] }, vi.fn().mockResolvedValue( undefined ) );
-
-      expect( traceInfoBuildMock ).toHaveBeenCalledOnce();
-      expect( upsertMemoMock ).toHaveBeenCalledWith( { payloadVersion: '2', traceInfo } );
-      expect( upsertMemoMock.mock.invocationCallOrder[0] ).toBeLessThan( workflowStartMock.mock.invocationCallOrder[0] );
-    } );
-
-    it.each( [
-      {
-        name: 'tracing is disabled',
-        info: workflowInfo,
-        options: { disableTrace: true }
-      },
-      {
-        name: 'the workflow has a root',
-        info: { ...workflowInfo, root: { workflowId: 'root-workflow', runId: 'root-run' } },
-        options: { disableTrace: false }
-      }
-    ] )( 'does not build trace info when $name', async ( { info, options } ) => {
-      workflowInfoMock.mockReturnValue( info );
-      workflowOptionsDefault.MyWorkflow = options;
-      const { interceptors } = await import( './workflow.js' );
-      const { inbound } = interceptors();
-
-      await inbound[0].execute( { args: [ {} ] }, vi.fn().mockResolvedValue( undefined ) );
-
-      expect( traceInfoBuildMock ).not.toHaveBeenCalled();
-      expect( upsertMemoMock ).toHaveBeenCalledOnce();
-      expect( upsertMemoMock ).toHaveBeenCalledWith( { payloadVersion: '2' } );
-    } );
-
-    it( 'calls sinks.workflow.start, next, then sinks.workflow.end on success', async () => {
-      const { interceptors } = await import( './workflow.js' );
-      const { inbound } = interceptors();
-      const interceptor = inbound[0];
-      const input = { args: [ { input: 'data' } ] };
-      const next = vi.fn().mockResolvedValue( { output: 'ok' } );
-
-      const result = await interceptor.execute( input, next );
-
-      expect( workflowStartMock ).toHaveBeenCalledWith( { input: 'data' } );
-      expect( next ).toHaveBeenCalledWith( input );
-      expect( workflowEndMock ).toHaveBeenCalledWith( { output: 'ok' } );
-      expect( result ).toEqual( { output: 'ok' } );
-      expect( workflowErrorMock ).not.toHaveBeenCalled();
-    } );
-
-    it( 'rethrows native errors as Workflow Task failures without a terminal sink event', async () => {
-      const { interceptors } = await import( './workflow.js' );
-      const { inbound } = interceptors();
-      const interceptor = inbound[0];
-      const input = { args: [ {} ] };
-      const err = new Error( 'workflow failed' );
-      const next = vi.fn().mockRejectedValue( err );
-
-      await expect( interceptor.execute( input, next ) ).rejects.toBe( err );
-      expect( workflowStartMock ).toHaveBeenCalled();
-      expect( workflowErrorMock ).not.toHaveBeenCalled();
-      expect( workflowEndMock ).not.toHaveBeenCalled();
-    } );
-
-    it.each( [
-      { ErrorType: FatalError, type: 'FatalError' },
-      { ErrorType: ValidationError, type: 'ValidationError' }
-    ] )( 'converts $type into a non-retryable ApplicationFailure with serialized details', async ( { ErrorType, type } ) => {
-      const { interceptors } = await import( './workflow.js' );
-      const { inbound } = interceptors();
-      const interceptor = inbound[0];
-      const err = new ErrorType( 'workflow failed' );
-      err.code = 'EWORKFLOW';
-      const next = vi.fn().mockRejectedValue( err );
-
-      const thrown = await interceptor.execute( { args: [ {} ] }, next ).catch( e => e );
-
-      expect( thrown ).toBeInstanceOf( ApplicationFailure );
-      expect( thrown ).toMatchObject( {
-        message: 'workflow failed',
-        type,
-        nonRetryable: true,
-        details: [ {
-          error: {
-            name: type,
-            message: 'workflow failed',
-            code: 'EWORKFLOW'
-          }
-        } ],
-        cause: err
-      } );
-      expect( workflowErrorMock ).toHaveBeenCalledWith( expect.objectContaining( {
-        name: type,
-        message: 'workflow failed',
-        code: 'EWORKFLOW',
-        stack: expect.any( String )
-      } ) );
-      expect( workflowErrorMock.mock.calls[0][0] ).not.toBeInstanceOf( Error );
-      expect( workflowEndMock ).not.toHaveBeenCalled();
-    } );
-
-    it( 'uses a transparent error cause for the sink and ApplicationFailure', async () => {
-      const { interceptors } = await import( './workflow.js' );
-      const { inbound } = interceptors();
-      const interceptor = inbound[0];
-      const cause = new TypeError( 'provider rejected request' );
-      cause.code = 'EAUTH';
-      const error = new TransparentFatalError( cause );
-      const next = vi.fn().mockRejectedValue( error );
-
-      const thrown = await interceptor.execute( { args: [ {} ] }, next ).catch( e => e );
-
-      expect( thrown ).toMatchObject( {
-        message: 'provider rejected request',
-        type: 'TypeError',
-        nonRetryable: true,
-        cause,
-        details: [ {
-          error: {
-            name: 'TypeError',
-            message: 'provider rejected request',
-            code: 'EAUTH'
-          }
-        } ]
-      } );
-      expect( workflowErrorMock ).toHaveBeenCalledWith( expect.objectContaining( {
-        name: 'TypeError',
-        message: 'provider rejected request',
-        code: 'EAUTH',
-        stack: expect.any( String )
-      } ) );
-      expect( workflowErrorMock.mock.calls[0][0] ).not.toHaveProperty( 'cause' );
-      expect( workflowEndMock ).not.toHaveBeenCalled();
-    } );
-
-    it( 'sinks and rethrows existing Temporal failures unchanged', async () => {
-      const { interceptors } = await import( './workflow.js' );
-      const { inbound } = interceptors();
-      const interceptor = inbound[0];
-      const err = ApplicationFailure.retryable( 'domain failed', 'DomainFailure', { reason: 'invalid' } );
-      const next = vi.fn().mockRejectedValue( err );
-
-      await expect( interceptor.execute( { args: [ {} ] }, next ) ).rejects.toBe( err );
-      expect( workflowErrorMock ).toHaveBeenCalledWith( expect.objectContaining( {
-        name: 'ApplicationFailure',
-        message: 'domain failed',
-        type: 'DomainFailure',
-        details: [ { reason: 'invalid' } ],
-        stack: expect.any( String )
-      } ) );
-      expect( workflowErrorMock.mock.calls[0][0] ).not.toBeInstanceOf( Error );
-      expect( workflowEndMock ).not.toHaveBeenCalled();
-    } );
-
-    it( 'calls sinks.workflow.error and rethrows cancellation errors without wrapping', async () => {
-      const { interceptors } = await import( './workflow.js' );
-      const { inbound } = interceptors();
-      const interceptor = inbound[0];
-      const cancellation = new Error( 'Workflow cancelled' );
-      const next = vi.fn().mockRejectedValue( cancellation );
-      isCancellationMock.mockReturnValue( true );
-
-      await expect( interceptor.execute( { args: [ {} ] }, next ) ).rejects.toBe( cancellation );
-      expect( isCancellationMock ).toHaveBeenCalledWith( cancellation );
-      expect( workflowErrorMock ).toHaveBeenCalledWith( {
-        name: 'Error',
-        message: 'Workflow cancelled'
-      } );
-      expect( workflowErrorMock.mock.calls[0][0] ).not.toBeInstanceOf( Error );
-      expect( workflowEndMock ).not.toHaveBeenCalled();
-    } );
-
-    it( 'ends the workflow trace and rethrows ContinueAsNew', async () => {
-      const { ContinueAsNew } = await import( '@temporalio/workflow' );
-      const { WorkflowSpecialOutput } = await import( '#consts' );
-      const { interceptors } = await import( './workflow.js' );
-      const { inbound } = interceptors();
-      const interceptor = inbound[0];
-      const continueErr = new ContinueAsNew();
-      const next = vi.fn().mockRejectedValue( continueErr );
-
-      await expect( interceptor.execute( { args: [ {} ] }, next ) ).rejects.toThrow( ContinueAsNew );
-      expect( workflowEndMock ).toHaveBeenCalledWith( WorkflowSpecialOutput.CONTINUED_AS_NEW );
-      expect( workflowErrorMock ).not.toHaveBeenCalled();
-    } );
-  } );
-} );

package/src/worker/interruption.spec.js

@@ -1,177 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-const DOUBLE_SIGNAL_IGNORE_TIME = 1000;
-const KILL_AFTER_UNCAUGHT_TIME = 60_000;
-
-const { mockLog, serializeErrorMock } = vi.hoisted( () => ( {
-  mockLog: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-  serializeErrorMock: vi.fn( () => 'serialized' )
-} ) );
-
-vi.mock( '#logger', () => ( { createChildLogger: () => mockLog } ) );
-vi.mock( '#helpers/error_serializer', () => ( { serializeError: serializeErrorMock } ) );
-
-// The module keeps its attachment state at module scope, so every test needs a fresh copy.
-const loadModule = async () => {
-  vi.resetModules();
-  return import( './interruption.js' );
-};
-
-describe( 'setupInterruptionHandler', () => {
-  const handlers = {};
-  const spies = {};
-
-  beforeEach( () => {
-    vi.clearAllMocks();
-    Object.keys( handlers ).forEach( key => delete handlers[key] );
-
-    spies.on = vi.spyOn( process, 'on' ).mockImplementation( ( event, handler ) => {
-      handlers[event] = handler;
-      return process;
-    } );
-    spies.exit = vi.spyOn( process, 'exit' ).mockImplementation( () => undefined );
-  } );
-
-  afterEach( () => {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-  } );
-
-  it( 'attaches a handler for every signal and uncaught error type', async () => {
-    const { setupInterruptionHandler } = await loadModule();
-
-    setupInterruptionHandler( new AbortController() );
-
-    expect( Object.keys( handlers ) ).toEqual( [
-      'SIGTERM',
-      'SIGINT',
-      'SIGUSR2',
-      'uncaughtException',
-      'unhandledRejection'
-    ] );
-  } );
-
-  it( 'attaches once and keeps the first abort controller', async () => {
-    const { setupInterruptionHandler } = await loadModule();
-    const first = new AbortController();
-    const second = new AbortController();
-
-    setupInterruptionHandler( first );
-    const attachedCalls = spies.on.mock.calls.length;
-    setupInterruptionHandler( second );
-
-    expect( spies.on ).toHaveBeenCalledTimes( attachedCalls );
-
-    handlers.SIGTERM();
-
-    expect( first.signal.aborted ).toBe( true );
-    expect( second.signal.aborted ).toBe( false );
-  } );
-
-  describe( 'signals', () => {
-    it( 'aborts with a kill signal error naming the signal', async () => {
-      const { setupInterruptionHandler, KillSignError } = await loadModule();
-      const controller = new AbortController();
-
-      setupInterruptionHandler( controller );
-      handlers.SIGTERM();
-
-      expect( mockLog.info ).toHaveBeenCalledWith( 'Signal Received', { signal: 'SIGTERM' } );
-      expect( controller.signal.reason ).toBeInstanceOf( KillSignError );
-      expect( controller.signal.reason.message ).toBe( 'SIGTERM' );
-      expect( spies.exit ).not.toHaveBeenCalled();
-    } );
-
-    it( 'ignores a second signal received within the grace window', async () => {
-      vi.useFakeTimers();
-      const { setupInterruptionHandler } = await loadModule();
-      const controller = new AbortController();
-
-      setupInterruptionHandler( controller );
-      handlers.SIGINT();
-      vi.advanceTimersByTime( DOUBLE_SIGNAL_IGNORE_TIME - 1 );
-      handlers.SIGINT();
-
-      expect( mockLog.warn ).not.toHaveBeenCalledWith( 'Force quitting...' );
-      expect( spies.exit ).not.toHaveBeenCalled();
-    } );
-
-    it( 'force quits on a second signal received after the grace window', async () => {
-      vi.useFakeTimers();
-      const { setupInterruptionHandler } = await loadModule();
-      const controller = new AbortController();
-
-      setupInterruptionHandler( controller );
-      handlers.SIGINT();
-      vi.advanceTimersByTime( DOUBLE_SIGNAL_IGNORE_TIME + 1 );
-      handlers.SIGINT();
-
-      expect( mockLog.warn ).toHaveBeenCalledWith( 'Force quitting...' );
-      expect( spies.exit ).toHaveBeenCalledWith( 1 );
-    } );
-  } );
-
-  describe( 'uncaught errors', () => {
-    it( 'aborts with an uncaught error wrapping the original', async () => {
-      const { setupInterruptionHandler, UncaughtError } = await loadModule();
-      const controller = new AbortController();
-      const error = new TypeError( 'boom' );
-
-      setupInterruptionHandler( controller );
-      handlers.uncaughtException( error );
-
-      // Recorded here because a prior abort would leave the reason handler with nothing to report.
-      expect( mockLog.warn ).toHaveBeenCalledWith( 'Uncaught exception', { type: 'uncaughtException', error: 'serialized' } );
-      expect( serializeErrorMock ).toHaveBeenCalledWith( error );
-      expect( mockLog.error ).not.toHaveBeenCalled();
-      expect( controller.signal.reason ).toBeInstanceOf( UncaughtError );
-      expect( controller.signal.reason.message ).toBe( 'uncaughtException' );
-      expect( controller.signal.reason.cause ).toBe( error );
-    } );
-
-    it( 'wraps non error rejection values for unhandled rejections', async () => {
-      const { setupInterruptionHandler, UncaughtError } = await loadModule();
-      const controller = new AbortController();
-
-      setupInterruptionHandler( controller );
-      handlers.unhandledRejection( 'not an error' );
-
-      expect( mockLog.warn ).toHaveBeenCalledWith( 'Uncaught exception', { type: 'unhandledRejection', error: 'serialized' } );
-      expect( serializeErrorMock ).toHaveBeenCalledWith( 'not an error' );
-      expect( mockLog.error ).not.toHaveBeenCalled();
-      expect( controller.signal.reason ).toBeInstanceOf( UncaughtError );
-      expect( controller.signal.reason.message ).toBe( 'unhandledRejection' );
-      expect( controller.signal.reason.cause ).toBe( 'not an error' );
-    } );
-
-    it( 'forces an exit when the shutdown outlives the watchdog', async () => {
-      vi.useFakeTimers();
-      const { setupInterruptionHandler } = await loadModule();
-
-      setupInterruptionHandler( new AbortController() );
-      handlers.uncaughtException( new Error( 'boom' ) );
-
-      vi.advanceTimersByTime( KILL_AFTER_UNCAUGHT_TIME - 1 );
-
-      expect( spies.exit ).not.toHaveBeenCalled();
-
-      vi.advanceTimersByTime( 1 );
-
-      expect( mockLog.warn ).toHaveBeenCalledWith( 'Uncaught exception handling timed out, force quitting...' );
-      expect( spies.exit ).toHaveBeenCalledWith( 1 );
-    } );
-
-    it( 'keeps the watchdog from holding the process open', async () => {
-      const { setupInterruptionHandler } = await loadModule();
-      setupInterruptionHandler( new AbortController() );
-
-      const timer = { unref: vi.fn() };
-      const setTimeoutSpy = vi.spyOn( globalThis, 'setTimeout' ).mockReturnValue( timer );
-
-      handlers.uncaughtException( new Error( 'boom' ) );
-
-      expect( setTimeoutSpy ).toHaveBeenCalledWith( expect.any( Function ), KILL_AFTER_UNCAUGHT_TIME );
-      expect( timer.unref ).toHaveBeenCalledOnce();
-    } );
-  } );
-} );