@outputai/core 0.14.0 → 0.14.1-next.2947341.0

package/src/helpers/temporal_context.spec.ts

@@ -1,83 +0,0 @@
-import type { WorkflowInfo } from '@temporalio/workflow';
-import { describe, expect, it } from 'vitest';
-import { createWorkflowDetails } from './temporal_context.js';
-
-/*
-  This spec is TypeScript on purpose.
-  createWorkflowDetails() accepts a small projection of Temporal's WorkflowInfo,
-  so the fixture below uses Pick<WorkflowInfo, ...> to catch Temporal type drift
-  without exposing or maintaining the full native object in hook payloads.
-*/
-type WorkflowDetailsSource = Pick<
-  WorkflowInfo,
-  'attempt' |
-  'continuedFromExecutionRunId' |
-  'firstExecutionRunId' |
-  'parent' |
-  'root' |
-  'runId' |
-  'runStartTime' |
-  'startTime' |
-  'workflowId' |
-  'workflowType'
->;
-
-describe( 'createWorkflowDetails', () => {
-  it( 'creates hook-safe workflow details from Temporal workflow info', () => {
-    const parent = { workflowId: 'parent-wf', runId: 'parent-run', namespace: 'default' };
-    const root = { workflowId: 'root-wf', runId: 'root-run' };
-    const workflowInfo = {
-      attempt: 2,
-      continuedFromExecutionRunId: 'previous-run',
-      firstExecutionRunId: 'first-run',
-      parent,
-      root,
-      runId: 'current-run',
-      runStartTime: new Date( '2026-06-02T09:30:00.000Z' ),
-      startTime: new Date( '2026-06-02T09:00:00.000Z' ),
-      workflowId: 'workflow-id',
-      workflowType: 'prompt'
-    } satisfies WorkflowDetailsSource;
-
-    expect( createWorkflowDetails( workflowInfo ) ).toEqual( {
-      attempt: 2,
-      continuedFromExecutionRunId: 'previous-run',
-      firstExecutionRunId: 'first-run',
-      parent,
-      root,
-      runId: 'current-run',
-      runStartTime: Date.parse( '2026-06-02T09:30:00.000Z' ),
-      startTime: Date.parse( '2026-06-02T09:00:00.000Z' ),
-      workflowId: 'workflow-id',
-      workflowType: 'prompt'
-    } );
-  } );
-
-  it( 'preserves absent optional workflow relationships as undefined', () => {
-    const workflowInfo = {
-      attempt: 1,
-      continuedFromExecutionRunId: undefined,
-      firstExecutionRunId: 'first-run',
-      parent: undefined,
-      root: undefined,
-      runId: 'current-run',
-      runStartTime: new Date( '2026-06-02T09:30:00.000Z' ),
-      startTime: new Date( '2026-06-02T09:00:00.000Z' ),
-      workflowId: 'workflow-id',
-      workflowType: 'prompt'
-    } satisfies WorkflowDetailsSource;
-
-    expect( createWorkflowDetails( workflowInfo ) ).toEqual( {
-      attempt: 1,
-      continuedFromExecutionRunId: undefined,
-      firstExecutionRunId: 'first-run',
-      parent: undefined,
-      root: undefined,
-      runId: 'current-run',
-      runStartTime: Date.parse( '2026-06-02T09:30:00.000Z' ),
-      startTime: Date.parse( '2026-06-02T09:00:00.000Z' ),
-      workflowId: 'workflow-id',
-      workflowType: 'prompt'
-    } );
-  } );
-} );

package/src/helpers/trace_info.spec.js

@@ -1,45 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-import { TraceInfo } from './trace_info.js';
-
-const inWorkflowContextMock = vi.hoisted( () => vi.fn() );
-const workflowInfoMock = vi.hoisted( () => vi.fn() );
-
-vi.mock( '@temporalio/workflow', () => ( {
-  inWorkflowContext: inWorkflowContextMock,
-  workflowInfo: workflowInfoMock
-} ) );
-
-describe( 'TraceInfo', () => {
-  beforeEach( () => {
-    vi.clearAllMocks();
-  } );
-
-  it( 'builds trace info from Temporal workflow info in workflow context', () => {
-    inWorkflowContextMock.mockReturnValue( true );
-    workflowInfoMock.mockReturnValue( {
-      workflowId: 'workflow-id',
-      workflowType: 'workflow-type',
-      runId: 'run-id',
-      startTime: new Date( '2026-06-02T09:00:00.000Z' )
-    } );
-
-    expect( TraceInfo.build() ).toEqual( {
-      workflowId: 'workflow-id',
-      workflowType: 'workflow-type',
-      runId: 'run-id',
-      startTime: Date.parse( '2026-06-02T09:00:00.000Z' )
-    } );
-  } );
-
-  it( 'builds trace info without Temporal fields outside workflow context', () => {
-    inWorkflowContextMock.mockReturnValue( false );
-
-    expect( TraceInfo.build() ).toEqual( {
-      workflowId: undefined,
-      workflowType: undefined,
-      runId: undefined,
-      startTime: undefined
-    } );
-    expect( workflowInfoMock ).not.toHaveBeenCalled();
-  } );
-} );

package/src/helpers/workflow_context.spec.js

@@ -1,46 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-import { WorkflowContext } from './workflow_context.js';
-
-const inWorkflowContextMock = vi.hoisted( () => vi.fn() );
-const workflowInfoMock = vi.hoisted( () => vi.fn() );
-const continueAsNewMock = vi.hoisted( () => vi.fn() );
-
-vi.mock( '@temporalio/workflow', () => ( {
-  continueAsNew: continueAsNewMock,
-  inWorkflowContext: inWorkflowContextMock,
-  workflowInfo: workflowInfoMock
-} ) );
-
-describe( 'WorkflowContext', () => {
-  beforeEach( () => {
-    vi.clearAllMocks();
-  } );
-
-  it( 'builds a test context outside Temporal workflow context', async () => {
-    inWorkflowContextMock.mockReturnValue( false );
-
-    const context = WorkflowContext.build();
-
-    expect( context.info ).toEqual( { workflowId: 'test-workflow', runId: 'test-run' } );
-    expect( context.control.isContinueAsNewSuggested() ).toBe( false );
-    await expect( context.control.continueAsNew() ).resolves.toBeUndefined();
-    expect( workflowInfoMock ).not.toHaveBeenCalled();
-    expect( continueAsNewMock ).not.toHaveBeenCalled();
-  } );
-
-  it( 'builds a workflow context from Temporal workflow info', () => {
-    inWorkflowContextMock.mockReturnValue( true );
-    workflowInfoMock.mockReturnValue( {
-      workflowId: 'workflow-id',
-      runId: 'run-id',
-      continueAsNewSuggested: true
-    } );
-
-    const context = WorkflowContext.build();
-
-    expect( context.info ).toEqual( { workflowId: 'workflow-id', runId: 'run-id' } );
-    expect( context.control.continueAsNew ).toBe( continueAsNewMock );
-    expect( context.control.isContinueAsNewSuggested() ).toBe( true );
-    expect( workflowInfoMock ).toHaveBeenCalledTimes( 2 );
-  } );
-} );

package/src/hooks/index.spec.js

@@ -1,265 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { BusEventType } from '#consts';
-
-const logErrorMock = vi.hoisted( () => vi.fn() );
-const createChildLoggerMock = vi.hoisted( () =>
-  vi.fn( () => ( { error: logErrorMock } ) )
-);
-const serializeErrorMock = vi.hoisted( () => vi.fn( error => ( {
-  name: error.name,
-  message: error.message,
-  stack: error.stack
-} ) ) );
-
-const mainOnHandlers = vi.hoisted( () => ( {} ) );
-const stepOnHandlers = vi.hoisted( () => ( {} ) );
-const mainEventBusMock = vi.hoisted( () => ( {
-  on: vi.fn( ( eventType, handler ) => {
-    mainOnHandlers[eventType] = handler;
-  } )
-} ) );
-const stepEventBusMock = vi.hoisted( () => ( {
-  emit: vi.fn( () => true ),
-  on: vi.fn( ( eventType, handler ) => {
-    stepOnHandlers[eventType] = handler;
-  } )
-} ) );
-
-vi.mock( '#logger', () => ( { createChildLogger: createChildLoggerMock } ) );
-vi.mock( '#helpers/error_serializer', () => ( { serializeError: serializeErrorMock } ) );
-vi.mock( '#bus', () => ( {
-  mainEventBus: mainEventBusMock,
-  stepEventBus: stepEventBusMock
-} ) );
-
-import {
-  emit,
-  on,
-  onActivityEnd,
-  onActivityError,
-  onActivityStart,
-  onBeforeWorkerStart,
-  onError,
-  onWorkflowEnd,
-  onWorkflowError,
-  onWorkflowStart
-} from './index.js';
-import { pendingHooks } from './pending_hooks.js';
-
-const workflowDetails = {
-  workflowId: 'wf-1',
-  runId: 'run-1',
-  workflowType: 'myWorkflow',
-  firstExecutionRunId: 'run-1',
-  startTime: 1710000000000,
-  runStartTime: 1710000000000,
-  attempt: 1
-};
-
-const activityInfo = {
-  activityId: 'act-1',
-  activityType: 'wf#step',
-  workflowExecution: { workflowId: 'wf-1', runId: 'run-1' },
-  workflowType: 'myWorkflow'
-};
-
-const eventDate = 1710000001234;
-
-describe( 'hooks/index', () => {
-  beforeEach( () => {
-    vi.clearAllMocks();
-    pendingHooks.clear();
-    Object.keys( mainOnHandlers ).forEach( k => {
-      delete mainOnHandlers[k];
-    } );
-    Object.keys( stepOnHandlers ).forEach( k => {
-      delete stepOnHandlers[k];
-    } );
-  } );
-
-  describe( 'onError', () => {
-    it( 'registers activity, workflow, and runtime error listeners', () => {
-      const handler = vi.fn().mockResolvedValue( undefined );
-      onError( handler );
-
-      expect( mainEventBusMock.on ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, expect.any( Function ) );
-      expect( mainEventBusMock.on ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, expect.any( Function ) );
-      expect( mainEventBusMock.on ).toHaveBeenCalledWith( BusEventType.RUNTIME_ERROR, expect.any( Function ) );
-    } );
-
-    it( 'invokes handler with activity-shaped payload, forwarding bus fields', async () => {
-      const handler = vi.fn().mockResolvedValue( undefined );
-      onError( handler );
-
-      const err = new Error( 'act-fail' );
-      await mainOnHandlers[BusEventType.ACTIVITY_ERROR]( {
-        eventId: 'evt-act-1',
-        eventDate,
-        activityInfo,
-        workflowDetails,
-        outputActivityKind: 'step',
-        error: err,
-        extra: 'passthrough'
-      } );
-
-      expect( handler ).toHaveBeenCalledWith( {
-        eventId: 'evt-act-1',
-        eventDate,
-        source: 'activity',
-        activityInfo,
-        workflowDetails,
-        outputActivityKind: 'step',
-        error: err,
-        extra: 'passthrough'
-      } );
-    } );
-
-    it( 'invokes handler with workflow-shaped payload, forwarding bus fields', async () => {
-      const handler = vi.fn().mockResolvedValue( undefined );
-      onError( handler );
-
-      const err = new Error( 'wf-fail' );
-      await mainOnHandlers[BusEventType.WORKFLOW_ERROR]( {
-        eventId: 'evt-wf-1',
-        eventDate,
-        workflowDetails,
-        error: err,
-        extra: 'passthrough'
-      } );
-
-      expect( handler ).toHaveBeenCalledWith( {
-        eventId: 'evt-wf-1',
-        eventDate,
-        source: 'workflow',
-        workflowDetails,
-        error: err,
-        extra: 'passthrough'
-      } );
-    } );
-
-    it( 'logs and does not rethrow when handler rejects', async () => {
-      const handler = vi.fn().mockRejectedValue( new Error( 'boom' ) );
-      onError( handler );
-
-      const error = new Error( 'rt' );
-      await mainOnHandlers[BusEventType.RUNTIME_ERROR]( { eventId: 'evt-rt-1', eventDate, error } );
-
-      expect( handler ).toHaveBeenCalledWith( { eventId: 'evt-rt-1', eventDate, source: 'runtime', error } );
-      expect( logErrorMock ).toHaveBeenCalledWith( 'onError hook error', {
-        error: {
-          name: 'Error',
-          message: 'boom',
-          stack: expect.any( String )
-        }
-      } );
-      expect( serializeErrorMock ).toHaveBeenCalledWith( expect.objectContaining( { message: 'boom' } ) );
-    } );
-  } );
-
-  describe( 'onBeforeWorkerStart', () => {
-    it( 'registers and invokes handler with undefined payload', async () => {
-      const handler = vi.fn().mockResolvedValue( undefined );
-      onBeforeWorkerStart( handler );
-
-      expect( mainEventBusMock.on ).toHaveBeenCalledWith( BusEventType.WORKER_BEFORE_START, expect.any( Function ) );
-      await mainOnHandlers[BusEventType.WORKER_BEFORE_START]();
-
-      expect( handler ).toHaveBeenCalledWith( undefined );
-    } );
-  } );
-
-  it( 'tracks a hook callback until it settles', async () => {
-    const deferred = { resolve: null };
-    const handlerPromise = new Promise( resolve => {
-      deferred.resolve = resolve;
-    } );
-    const handler = vi.fn( () => handlerPromise );
-    onActivityEnd( handler );
-
-    const callbackPromise = mainOnHandlers[BusEventType.ACTIVITY_END]( { activityInfo } );
-
-    expect( pendingHooks.size ).toBe( 1 );
-
-    deferred.resolve();
-    await callbackPromise;
-    expect( pendingHooks.size ).toBe( 0 );
-  } );
-
-  describe( 'workflow lifecycle hooks', () => {
-    const cases = [
-      [ 'onWorkflowStart', onWorkflowStart, BusEventType.WORKFLOW_START, {} ],
-      [ 'onWorkflowEnd', onWorkflowEnd, BusEventType.WORKFLOW_END, {} ],
-      [ 'onWorkflowError', onWorkflowError, BusEventType.WORKFLOW_ERROR, { error: new Error( 'workflow failed' ) } ]
-    ];
-
-    it.each( cases )( '%s forwards bus fields', async ( _name, registerHook, eventType, extraFields ) => {
-      const handler = vi.fn().mockResolvedValue( undefined );
-      const payload = {
-        eventId: 'evt-workflow-1',
-        eventDate,
-        workflowDetails,
-        extra: 'passthrough',
-        ...extraFields
-      };
-      registerHook( handler );
-
-      expect( mainEventBusMock.on ).toHaveBeenCalledWith( eventType, expect.any( Function ) );
-      await mainOnHandlers[eventType]( payload );
-
-      expect( handler ).toHaveBeenCalledWith( payload );
-    } );
-  } );
-
-  describe( 'activity lifecycle hooks', () => {
-    const cases = [
-      [ 'onActivityStart', onActivityStart, BusEventType.ACTIVITY_START, undefined ],
-      [ 'onActivityEnd', onActivityEnd, BusEventType.ACTIVITY_END ],
-      [ 'onActivityError', onActivityError, BusEventType.ACTIVITY_ERROR, { error: new Error( 'activity failed' ) } ]
-    ];
-
-    it.each( cases )( '%s forwards internal activity bus fields', async ( _name, registerHook, eventType, extraFields = {} ) => {
-      const handler = vi.fn().mockResolvedValue( undefined );
-      const payload = {
-        eventId: 'evt-activity-1',
-        eventDate,
-        activityInfo,
-        workflowDetails,
-        outputActivityKind: 'internal_step',
-        extra: 'passthrough',
-        ...extraFields
-      };
-      registerHook( handler );
-
-      expect( mainEventBusMock.on ).toHaveBeenCalledWith( eventType, expect.any( Function ) );
-      await mainOnHandlers[eventType]( payload );
-
-      expect( handler ).toHaveBeenCalledWith( payload );
-    } );
-  } );
-
-  describe( 'on', () => {
-    it( 'subscribes to SDK and user event channels and forwards payloads', async () => {
-      const handler = vi.fn().mockResolvedValue( undefined );
-      on( 'myEvent', handler );
-
-      expect( stepEventBusMock.on ).toHaveBeenCalledWith( 'sdk:myEvent', expect.any( Function ) );
-      expect( stepEventBusMock.on ).toHaveBeenCalledWith( 'usr:myEvent', expect.any( Function ) );
-      await stepOnHandlers['sdk:myEvent']( { payload: { source: 'sdk' } } );
-      await stepOnHandlers['usr:myEvent']( { payload: { source: 'user' } } );
-
-      expect( handler ).toHaveBeenNthCalledWith( 1, { payload: { source: 'sdk' } } );
-      expect( handler ).toHaveBeenNthCalledWith( 2, { payload: { source: 'user' } } );
-    } );
-  } );
-
-  describe( 'emit', () => {
-    it( 'emits payloads on the user event channel', () => {
-      const payload = { foo: 1 };
-
-      const emitted = emit( 'myEvent', payload );
-
-      expect( stepEventBusMock.emit ).toHaveBeenCalledWith( 'usr:myEvent', payload );
-      expect( emitted ).toBe( true );
-    } );
-  } );
-} );

package/src/hooks/pending_hooks.spec.js

@@ -1,62 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-const logMock = vi.hoisted( () => ( { warn: vi.fn() } ) );
-
-vi.mock( '#logger', () => ( { createChildLogger: () => logMock } ) );
-
-import { flushPendingHooks, pendingHooks } from './pending_hooks.js';
-
-describe( 'pending hooks', () => {
-  beforeEach( () => {
-    pendingHooks.clear();
-    vi.clearAllMocks();
-  } );
-
-  afterEach( () => {
-    pendingHooks.clear();
-    vi.useRealTimers();
-  } );
-
-  it( 'waits for pending hooks to settle', async () => {
-    const deferred = { resolve: null };
-    const hookPromise = new Promise( resolve => {
-      deferred.resolve = resolve;
-    } );
-    pendingHooks.add( hookPromise );
-
-    const flushPromise = flushPendingHooks( 5000 );
-    const state = { flushed: false };
-    flushPromise.then( () => {
-      state.flushed = true;
-    } );
-
-    await Promise.resolve();
-    expect( state.flushed ).toBe( false );
-
-    deferred.resolve();
-    await flushPromise;
-    expect( state.flushed ).toBe( true );
-  } );
-
-  it( 'stops waiting after the timeout', async () => {
-    vi.useFakeTimers();
-    pendingHooks.add( new Promise( () => {} ) );
-
-    const flushPromise = flushPendingHooks( 5000 );
-    await vi.advanceTimersByTimeAsync( 5000 );
-
-    await expect( flushPromise ).resolves.toBeUndefined();
-  } );
-
-  it( 'logs the number of hooks that exceeded the timeout', async () => {
-    vi.useFakeTimers();
-    pendingHooks.add( new Promise( () => {} ) );
-    pendingHooks.add( new Promise( () => {} ) );
-
-    const flushPromise = flushPendingHooks( 5000 );
-    await vi.advanceTimersByTimeAsync( 5000 );
-    await flushPromise;
-
-    expect( logMock.warn ).toHaveBeenCalledWith( expect.any( String ), { count: 2 } );
-  } );
-} );