@outputai/core 0.14.0 → 0.14.1-next.1ec4416.0

package/src/interface/logger.spec.js

@@ -1,172 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { ACTIVITY_LOGGER_SYMBOL } from '#consts';
-
-const workflowLogMock = vi.fn();
-const proxySinksMock = vi.fn( () => ( {
-  workflow: {
-    log: workflowLogMock
-  }
-} ) );
-const inWorkflowContextMock = vi.fn( () => false );
-
-vi.mock( '@temporalio/workflow', () => ( {
-  inWorkflowContext: inWorkflowContextMock,
-  proxySinks: proxySinksMock
-} ) );
-
-const logLevels = [
-  'error',
-  'warn',
-  'info',
-  'http',
-  'verbose',
-  'debug',
-  'silly'
-];
-
-const consoleMethodsByLevel = {
-  error: 'error',
-  warn: 'warn',
-  info: 'info',
-  http: 'log',
-  verbose: 'log',
-  debug: 'debug',
-  silly: 'log'
-};
-
-const loadLogger = async () => ( await import( './logger.js' ) ).Logger;
-
-describe( 'interface/logger', () => {
-  beforeEach( () => {
-    vi.clearAllMocks();
-    inWorkflowContextMock.mockReturnValue( false );
-    delete globalThis[ACTIVITY_LOGGER_SYMBOL];
-  } );
-
-  afterEach( () => {
-    delete globalThis[ACTIVITY_LOGGER_SYMBOL];
-    vi.restoreAllMocks();
-  } );
-
-  it( 'proxies sinks once when the module is loaded', async () => {
-    await loadLogger();
-
-    expect( proxySinksMock ).toHaveBeenCalledTimes( 1 );
-  } );
-
-  it( 'logs every level through workflow sinks inside workflow context', async () => {
-    const logger = await loadLogger();
-    inWorkflowContextMock.mockReturnValue( true );
-
-    logLevels.forEach( level => {
-      logger[level]( `${level} message`, { requestId: level } );
-    } );
-
-    logLevels.forEach( ( level, index ) => {
-      const payload = {
-        level,
-        message: `${level} message`,
-        metadata: { requestId: level }
-      };
-
-      expect( workflowLogMock ).toHaveBeenNthCalledWith( index + 1, payload );
-    } );
-  } );
-
-  it( 'sanitizes messages and metadata before logging', async () => {
-    const logger = await loadLogger();
-    inWorkflowContextMock.mockReturnValue( true );
-
-    logger.info( 123, {
-      requestId: 'req-1',
-      level: 'error',
-      message: 'metadata message'
-    } );
-
-    expect( workflowLogMock ).toHaveBeenCalledWith( {
-      level: 'info',
-      message: '123',
-      metadata: { requestId: 'req-1' }
-    } );
-  } );
-
-  it( 'logs every level through the activity global logger when it is set outside workflow context', async () => {
-    const logger = await loadLogger();
-    const activityLoggerMock = vi.fn();
-    globalThis[ACTIVITY_LOGGER_SYMBOL] = activityLoggerMock;
-
-    logLevels.forEach( level => {
-      logger[level]( `${level} message`, { requestId: level } );
-    } );
-
-    logLevels.forEach( ( level, index ) => {
-      expect( activityLoggerMock ).toHaveBeenNthCalledWith( index + 1, {
-        level,
-        message: `${level} message`,
-        metadata: { requestId: level }
-      } );
-    } );
-    expect( workflowLogMock ).not.toHaveBeenCalled();
-  } );
-
-  it( 'logs every level to its native console method when no workflow or activity logger is available', async () => {
-    const logger = await loadLogger();
-    const consoleMocks = Object.fromEntries(
-      [ 'debug', 'error', 'info', 'log', 'warn' ].map( method => [
-        method,
-        vi.spyOn( console, method ).mockImplementation( () => {} )
-      ] )
-    );
-
-    logLevels.forEach( level => {
-      logger[level]( `${level} message`, { requestId: level } );
-    } );
-
-    logLevels.forEach( level => {
-      expect( consoleMocks[consoleMethodsByLevel[level]] ).toHaveBeenCalledWith(
-        `${level} message`,
-        { requestId: level }
-      );
-    } );
-    expect( consoleMocks.error ).toHaveBeenCalledTimes( 1 );
-    expect( consoleMocks.warn ).toHaveBeenCalledTimes( 1 );
-    expect( consoleMocks.info ).toHaveBeenCalledTimes( 1 );
-    expect( consoleMocks.debug ).toHaveBeenCalledTimes( 1 );
-    expect( consoleMocks.log ).toHaveBeenCalledTimes( 3 );
-    expect( workflowLogMock ).not.toHaveBeenCalled();
-  } );
-
-  it( 'creates a logger with a default namespace for every level', async () => {
-    const logger = await loadLogger();
-    inWorkflowContextMock.mockReturnValue( true );
-
-    const namespacedLogger = logger.createLogger( 'Namespace' );
-    logLevels.forEach( level => {
-      namespacedLogger[level]( `${level} message`, { requestId: level } );
-    } );
-
-    logLevels.forEach( ( level, index ) => {
-      expect( workflowLogMock ).toHaveBeenNthCalledWith( index + 1, {
-        level,
-        message: `${level} message`,
-        metadata: {
-          namespace: 'Namespace',
-          requestId: level
-        }
-      } );
-    } );
-  } );
-
-  it( 'lets log metadata override the default namespace', async () => {
-    const logger = await loadLogger();
-    inWorkflowContextMock.mockReturnValue( true );
-
-    logger.createLogger( 'Default namespace' ).info( 'message', { namespace: 'Inline namespace' } );
-
-    expect( workflowLogMock ).toHaveBeenCalledWith( {
-      level: 'info',
-      message: 'message',
-      metadata: { namespace: 'Inline namespace' }
-    } );
-  } );
-} );

package/src/interface/step.spec.js

@@ -1,128 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ValidationError } from '#errors';
-
-const validateDefinitionMock = vi.hoisted( () => vi.fn() );
-const parseInputMock = vi.hoisted( () => vi.fn( input => input ) );
-const parseOutputMock = vi.hoisted( () => vi.fn( output => output ) );
-const validatorConstructorMock = vi.hoisted( () => vi.fn() );
-const createStepMock = vi.hoisted( () => vi.fn( ( { handler } ) => handler ) );
-
-vi.mock( './validations/index.js', () => {
-  class StepValidator {
-    static validateDefinition( ...args ) {
-      return validateDefinitionMock( ...args );
-    }
-
-    constructor( ...args ) {
-      validatorConstructorMock( ...args );
-      this.parseInput = parseInputMock;
-      this.parseOutput = parseOutputMock;
-    }
-  }
-
-  return { StepValidator };
-} );
-
-vi.mock( '#helpers/component', () => ( {
-  createStep: createStepMock
-} ) );
-
-describe( 'step()', () => {
-  beforeEach( () => {
-    vi.clearAllMocks();
-  } );
-
-  it( 'validates the definition, creates a runtime validator, and creates a step component', async () => {
-    const { step } = await import( './step.js' );
-    const inputSchema = { safeParse: vi.fn() };
-    const outputSchema = { safeParse: vi.fn() };
-    const fn = vi.fn().mockResolvedValue( { ok: true } );
-    const options = { activityOptions: { startToCloseTimeout: '1m' } };
-
-    const wrapper = step( {
-      name: 'test_step',
-      description: 'Test step',
-      inputSchema,
-      outputSchema,
-      fn,
-      options
-    } );
-
-    expect( validateDefinitionMock ).toHaveBeenCalledWith( {
-      name: 'test_step',
-      description: 'Test step',
-      inputSchema,
-      outputSchema,
-      fn,
-      options
-    } );
-    expect( validatorConstructorMock ).toHaveBeenCalledWith( {
-      name: 'test_step',
-      inputSchema,
-      outputSchema
-    } );
-
-    expect( createStepMock ).toHaveBeenCalledWith( {
-      name: 'test_step',
-      description: 'Test step',
-      inputSchema,
-      outputSchema,
-      options,
-      handler: expect.any( Function )
-    } );
-    expect( wrapper ).toBe( createStepMock.mock.calls[0][0].handler );
-  } );
-
-  it( 'validates input and output around the step function', async () => {
-    const { step } = await import( './step.js' );
-    const output = { ok: true };
-    const fn = vi.fn().mockResolvedValue( output );
-    const wrapper = step( {
-      name: 'runtime_step',
-      inputSchema: undefined,
-      outputSchema: undefined,
-      fn
-    } );
-
-    await expect( wrapper( { value: 'input' } ) ).resolves.toBe( output );
-
-    expect( parseInputMock ).toHaveBeenCalledWith( { value: 'input' } );
-    expect( fn ).toHaveBeenCalledWith( { value: 'input' } );
-    expect( parseOutputMock ).toHaveBeenCalledWith( output );
-  } );
-
-  it( 'does not call the step function when input validation throws', async () => {
-    const { step } = await import( './step.js' );
-    const error = new ValidationError( 'invalid input' );
-    parseInputMock.mockImplementationOnce( () => {
-      throw error;
-    } );
-    const fn = vi.fn();
-    const wrapper = step( {
-      name: 'invalid_input_step',
-      fn
-    } );
-
-    await expect( wrapper( { value: 'bad' } ) ).rejects.toBe( error );
-    expect( fn ).not.toHaveBeenCalled();
-    expect( parseOutputMock ).not.toHaveBeenCalled();
-  } );
-
-  it( 'propagates output validation errors after the step function runs', async () => {
-    const { step } = await import( './step.js' );
-    const error = new ValidationError( 'invalid output' );
-    parseOutputMock.mockImplementationOnce( () => {
-      throw error;
-    } );
-    const output = { ok: false };
-    const fn = vi.fn().mockResolvedValue( output );
-    const wrapper = step( {
-      name: 'invalid_output_step',
-      fn
-    } );
-
-    await expect( wrapper( { value: 'input' } ) ).rejects.toBe( error );
-    expect( fn ).toHaveBeenCalledOnce();
-    expect( parseOutputMock ).toHaveBeenCalledWith( output );
-  } );
-} );

package/src/interface/validations/index.spec.js

@@ -1,197 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod';
-import { ValidationError } from '#errors';
-import { EvaluationResult } from '../evaluation_result.js';
-import {
-  EvaluatorValidator,
-  StepValidator,
-  WorkflowValidator,
-  validateExecuteInParallel,
-  validateRequestPayload
-} from './index.js';
-
-const fn = async () => {};
-
-const workflowArgs = {
-  name: 'valid_workflow',
-  description: 'Valid workflow',
-  inputSchema: z.object( { value: z.string() } ),
-  outputSchema: z.object( { result: z.string() } ),
-  fn,
-  options: {
-    activityOptions: {
-      startToCloseTimeout: '5m',
-      retry: { maximumAttempts: 2 }
-    },
-    disableTrace: true
-  },
-  aliases: [ 'old_workflow' ]
-};
-
-const stepArgs = {
-  name: 'valid_step',
-  description: 'Valid step',
-  inputSchema: z.object( { value: z.string() } ),
-  outputSchema: z.object( { result: z.string() } ),
-  fn,
-  options: {
-    activityOptions: {
-      heartbeatTimeout: '30s'
-    }
-  }
-};
-
-const evaluatorArgs = {
-  name: 'valid_evaluator',
-  description: 'Valid evaluator',
-  inputSchema: z.object( { value: z.string() } ),
-  fn
-};
-
-describe( 'interface validators', () => {
-  describe( 'WorkflowValidator', () => {
-    it( 'validates workflow definitions, input, output, and invocation options', () => {
-      expect( () => WorkflowValidator.validateDefinition( workflowArgs ) ).not.toThrow();
-      const validator = new WorkflowValidator( workflowArgs );
-      const input = { value: 'ok' };
-      const output = { result: 'ok' };
-
-      expect( validator.parseInput( input ) ).toEqual( input );
-      expect( validator.parseOutput( output ) ).toEqual( output );
-      expect( () => validator.parseInvocationOptions( {
-        detached: true,
-        activityOptions: { retry: { maximumAttempts: 1 } },
-        context: { info: { workflowId: 'test-workflow' } }
-      } ) ).not.toThrow();
-    } );
-
-    it( 'throws ValidationError with useful prefixes for invalid workflow data', () => {
-      expect( () => WorkflowValidator.validateDefinition( { ...workflowArgs, name: 'bad-name' } ) ).toThrow( ValidationError );
-      expect( () => WorkflowValidator.validateDefinition( { ...workflowArgs, name: 'bad-name' } ) ).toThrow(
-        /Workflow validation failed/
-      );
-
-      const validator = new WorkflowValidator( workflowArgs );
-
-      expect( () => validator.parseInput( { value: 1 } ) ).toThrow( ValidationError );
-      expect( () => validator.parseInput( { value: 1 } ) ).toThrow( /Workflow "valid_workflow" input validation failed/ );
-      expect( () => validator.parseOutput( { result: 1 } ) ).toThrow( /Workflow "valid_workflow" output validation failed/ );
-      expect( () => validator.parseInvocationOptions( {
-        options: { activityOptions: { retry: { maximumAttempts: 1 } } }
-      } ) ).toThrow( /Workflow "valid_workflow" invocation options validation failed/ );
-    } );
-
-    it( 'skips input and output validation when schemas are omitted', () => {
-      const validator = new WorkflowValidator( {
-        name: 'schema_less_workflow',
-        fn
-      } );
-      const input = { anything: true };
-      const output = { anything: true };
-
-      expect( validator.parseInput( input ) ).toBe( input );
-      expect( validator.parseOutput( output ) ).toBe( output );
-    } );
-  } );
-
-  describe( 'StepValidator', () => {
-    it( 'validates step definitions, input, and output', () => {
-      expect( () => StepValidator.validateDefinition( stepArgs ) ).not.toThrow();
-      const validator = new StepValidator( stepArgs );
-      const input = { value: 'ok' };
-      const output = { result: 'ok' };
-
-      expect( validator.parseInput( input ) ).toEqual( input );
-      expect( validator.parseOutput( output ) ).toEqual( output );
-    } );
-
-    it( 'throws ValidationError with useful prefixes for invalid step data', () => {
-      expect( () => StepValidator.validateDefinition( { ...stepArgs, fn: 'not-a-function' } ) ).toThrow(
-        /Step validation failed/
-      );
-
-      const validator = new StepValidator( stepArgs );
-
-      expect( () => validator.parseInput( { value: 1 } ) ).toThrow( /Step "valid_step" input validation failed/ );
-      expect( () => validator.parseOutput( { result: 1 } ) ).toThrow( /Step "valid_step" output validation failed/ );
-    } );
-  } );
-
-  describe( 'EvaluatorValidator', () => {
-    it( 'validates evaluator definitions, input, and EvaluationResult output', () => {
-      expect( () => EvaluatorValidator.validateDefinition( evaluatorArgs ) ).not.toThrow();
-      const validator = new EvaluatorValidator( evaluatorArgs );
-      const input = { value: 'ok' };
-      const output = new EvaluationResult( { value: 'pass', confidence: 1 } );
-
-      expect( validator.parseInput( input ) ).toEqual( input );
-      expect( validator.parseOutput( output ) ).toEqual( output );
-    } );
-
-    it( 'throws ValidationError for output schemas and invalid evaluator output', () => {
-      expect( () => EvaluatorValidator.validateDefinition( {
-        ...evaluatorArgs,
-        outputSchema: z.string()
-      } ) ).toThrow( /Evaluator validation failed/ );
-
-      const validator = new EvaluatorValidator( evaluatorArgs );
-
-      expect( () => validator.parseInput( { value: 1 } ) ).toThrow( /Evaluator "valid_evaluator" input validation failed/ );
-      expect( () => validator.parseOutput( { value: 'pass', confidence: 1 } ) ).toThrow(
-        /Evaluator "valid_evaluator" output validation failed/
-      );
-    } );
-  } );
-
-  describe( 'validateRequestPayload()', () => {
-    it( 'accepts valid request payloads', () => {
-      expect( () => validateRequestPayload( {
-        url: 'https://example.com',
-        method: 'POST',
-        payload: { ok: true },
-        headers: { authorization: 'Bearer token' },
-        responseOptions: { includeHeaders: true, includeBody: true }
-      } ) ).not.toThrow();
-    } );
-
-    it( 'throws ValidationError for invalid request payloads', () => {
-      expect( () => validateRequestPayload( {
-        url: 'ftp://example.com',
-        method: 'POST'
-      } ) ).toThrow( /Request payload validation failed/ );
-
-      expect( () => validateRequestPayload( {
-        url: 'https://example.com',
-        method: 'OPTIONS'
-      } ) ).toThrow( ValidationError );
-
-      expect( () => validateRequestPayload( {
-        url: 'https://example.com',
-        method: 'GET',
-        responseOptions: { includeHeaders: 'yes' }
-      } ) ).toThrow( ValidationError );
-    } );
-  } );
-
-  describe( 'validateExecuteInParallel()', () => {
-    it( 'accepts valid parallel execution configs', () => {
-      expect( () => validateExecuteInParallel( {
-        jobs: [ () => 'ok' ],
-        concurrency: Infinity,
-        onJobCompleted: () => {}
-      } ) ).not.toThrow();
-    } );
-
-    it( 'throws ValidationError for invalid parallel execution configs', () => {
-      expect( () => validateExecuteInParallel( {
-        jobs: [ () => 'ok' ],
-        concurrency: 0
-      } ) ).toThrow( /ExecuteInParallel validation failed/ );
-
-      expect( () => validateExecuteInParallel( {
-        jobs: [ 'not-a-function' ],
-        concurrency: 1
-      } ) ).toThrow( ValidationError );
-    } );
-  } );
-} );