@outputai/core 0.14.0 → 0.14.1-next.2947341.0

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

@@ -1,229 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod';
-import { EvaluationResult } from '../evaluation_result.js';
-import {
-  evaluatorOutputSchema,
-  evaluatorSchema,
-  executeInParallelSchema,
-  httpRequestSchema,
-  isZodSchema,
-  stepSchema,
-  workflowInvocationOptionsSchema,
-  workflowSchema
-} from './schemas.js';
-
-const fn = () => {};
-const validBase = {
-  name: 'valid_name',
-  description: 'Valid description',
-  inputSchema: z.object( { value: z.string() } ),
-  outputSchema: z.object( { result: z.string() } ),
-  fn,
-  options: {
-    activityOptions: {
-      startToCloseTimeout: '5m',
-      heartbeatTimeout: 1000,
-      retry: {
-        initialInterval: '10s',
-        backoffCoefficient: 2,
-        maximumInterval: '1m',
-        maximumAttempts: 3,
-        nonRetryableErrorTypes: [ 'FatalError' ]
-      },
-      priority: {
-        fairnessKey: 'tenant',
-        fairnessWeight: 1,
-        priorityKey: 2
-      },
-      summary: 'Short summary'
-    }
-  }
-};
-
-describe( 'validation schemas', () => {
-  describe( 'isZodSchema()', () => {
-    it( 'identifies Zod schemas', () => {
-      expect( isZodSchema( z.object( { name: z.string() } ) ) ).toBe( true );
-      expect( isZodSchema( z.string() ) ).toBe( true );
-      expect( isZodSchema( z.array( z.number() ) ) ).toBe( true );
-      expect( isZodSchema( z.union( [ z.string(), z.number() ] ) ) ).toBe( true );
-    } );
-
-    it( 'uses the Zod v4 runtime shape instead of instanceof', () => {
-      const schemaLikeFromAnotherPackageInstance = {
-        _zod: {
-          def: {
-            type: 'object'
-          }
-        },
-        safeParse: () => ( { success: true, data: {} } )
-      };
-
-      expect( isZodSchema( schemaLikeFromAnotherPackageInstance ) ).toBe( true );
-    } );
-
-    it( 'rejects non-Zod values', () => {
-      expect( isZodSchema( { type: 'object' } ) ).toBe( false );
-      expect( isZodSchema( {} ) ).toBe( false );
-      expect( isZodSchema( [] ) ).toBe( false );
-      expect( isZodSchema( null ) ).toBe( false );
-      expect( isZodSchema( undefined ) ).toBe( false );
-      expect( isZodSchema( 'string' ) ).toBe( false );
-    } );
-
-    it( 'rejects objects that only partially match the Zod shape', () => {
-      expect( isZodSchema( { safeParse: () => ( { success: true } ) } ) ).toBe( false );
-      expect( isZodSchema( { _zod: { def: { type: 'string' } } } ) ).toBe( false );
-      expect( isZodSchema( { _zod: { def: {} }, safeParse: () => ( { success: true } ) } ) ).toBe( false );
-      expect( isZodSchema( { _zod: null, safeParse: () => ( { success: true } ) } ) ).toBe( false );
-    } );
-  } );
-
-  describe( 'stepSchema', () => {
-    it( 'accepts a valid step definition', () => {
-      expect( stepSchema.safeParse( validBase ).success ).toBe( true );
-    } );
-
-    it( 'rejects invalid names, non-Zod schemas, invalid activity options, and unknown top-level keys', () => {
-      expect( stepSchema.safeParse( { ...validBase, name: 'invalid-name' } ).success ).toBe( false );
-      expect( stepSchema.safeParse( { ...validBase, inputSchema: { type: 'object' } } ).success ).toBe( false );
-      expect( stepSchema.safeParse( {
-        ...validBase,
-        options: { activityOptions: { retry: { maximumAttempts: 0 } } }
-      } ).success ).toBe( false );
-      expect( stepSchema.safeParse( { ...validBase, unexpected: true } ).success ).toBe( false );
-    } );
-  } );
-
-  describe( 'workflowSchema', () => {
-    it( 'accepts workflow-specific options and aliases', () => {
-      const result = workflowSchema.safeParse( {
-        ...validBase,
-        aliases: [ 'old_name' ],
-        options: {
-          ...validBase.options,
-          disableTrace: true
-        }
-      } );
-
-      expect( result.success ).toBe( true );
-    } );
-
-    it( 'defaults aliases and rejects invalid workflow fields', () => {
-      const result = workflowSchema.safeParse( validBase );
-      expect( result.success && result.data.aliases ).toEqual( [] );
-
-      expect( workflowSchema.safeParse( { ...validBase, aliases: [ 'bad-alias' ] } ).success ).toBe( false );
-      expect( workflowSchema.safeParse( {
-        ...validBase,
-        options: { ...validBase.options, disableTrace: 'yes' }
-      } ).success ).toBe( false );
-    } );
-  } );
-
-  describe( 'evaluatorSchema and evaluatorOutputSchema', () => {
-    it( 'accepts evaluator definitions without outputSchema', () => {
-      const { outputSchema: _outputSchema, ...validEvaluator } = validBase;
-      expect( evaluatorSchema.safeParse( validEvaluator ).success ).toBe( true );
-    } );
-
-    it( 'rejects evaluator definitions with outputSchema', () => {
-      expect( evaluatorSchema.safeParse( validBase ).success ).toBe( false );
-    } );
-
-    it( 'accepts only EvaluationResult instances as evaluator output', () => {
-      expect( evaluatorOutputSchema.safeParse( new EvaluationResult( { value: 'ok', confidence: 1 } ) ).success ).toBe( true );
-      expect( evaluatorOutputSchema.safeParse( { value: 'ok', confidence: 1 } ).success ).toBe( false );
-    } );
-  } );
-
-  describe( 'httpRequestSchema', () => {
-    it( 'accepts valid HTTP request payloads', () => {
-      expect( httpRequestSchema.safeParse( {
-        url: 'https://example.com',
-        method: 'POST',
-        payload: { ok: true },
-        headers: { authorization: 'Bearer token' },
-        responseOptions: { includeHeaders: true, includeBody: true }
-      } ).success ).toBe( true );
-    } );
-
-    it( 'defaults omitted response options to false', () => {
-      const result = httpRequestSchema.safeParse( {
-        url: 'https://example.com',
-        method: 'GET',
-        responseOptions: {}
-      } );
-
-      expect( result.success ).toBe( true );
-      expect( result.data.responseOptions ).toEqual( {
-        includeHeaders: false,
-        includeBody: false
-      } );
-    } );
-
-    it( 'rejects invalid URL protocols, methods, header values, and response options', () => {
-      expect( httpRequestSchema.safeParse( { url: 'ftp://example.com', method: 'GET' } ).success ).toBe( false );
-      expect( httpRequestSchema.safeParse( { url: 'https://example.com', method: 'OPTIONS' } ).success ).toBe( false );
-      expect( httpRequestSchema.safeParse( {
-        url: 'https://example.com',
-        method: 'GET',
-        headers: { count: 1 }
-      } ).success ).toBe( false );
-      expect( httpRequestSchema.safeParse( {
-        url: 'https://example.com',
-        method: 'GET',
-        responseOptions: { includeBody: 'yes' }
-      } ).success ).toBe( false );
-    } );
-  } );
-
-  describe( 'workflowInvocationOptionsSchema', () => {
-    it( 'accepts omitted options and valid invocation configuration', () => {
-      expect( workflowInvocationOptionsSchema.safeParse( undefined ).success ).toBe( true );
-      expect( workflowInvocationOptionsSchema.safeParse( {
-        detached: true,
-        activityOptions: { retry: { maximumAttempts: 1 } },
-        context: {
-          control: {
-            continueAsNew: fn,
-            isContinueAsNewSuggested: fn,
-            extraControl: true
-          },
-          info: {
-            workflowId: 'wf',
-            runId: 'run',
-            extraInfo: true
-          },
-          extraContext: true
-        }
-      } ).success ).toBe( true );
-    } );
-
-    it( 'rejects stale option shapes and invalid invocation values', () => {
-      expect( workflowInvocationOptionsSchema.safeParse( {
-        options: { activityOptions: { retry: { maximumAttempts: 1 } } }
-      } ).success ).toBe( false );
-      expect( workflowInvocationOptionsSchema.safeParse( { detached: 'true' } ).success ).toBe( false );
-      expect( workflowInvocationOptionsSchema.safeParse( {
-        activityOptions: { retry: { maximumAttempts: 0 } }
-      } ).success ).toBe( false );
-      expect( workflowInvocationOptionsSchema.safeParse( {
-        context: { control: { continueAsNew: 'nope' } }
-      } ).success ).toBe( false );
-    } );
-  } );
-
-  describe( 'executeInParallelSchema', () => {
-    it( 'accepts valid execution configs', () => {
-      expect( executeInParallelSchema.safeParse( { jobs: [ fn ], concurrency: 1 } ).success ).toBe( true );
-      expect( executeInParallelSchema.safeParse( { jobs: [ fn ], concurrency: Infinity, onJobCompleted: fn } ).success ).toBe( true );
-    } );
-
-    it( 'rejects invalid execution configs', () => {
-      expect( executeInParallelSchema.safeParse( { jobs: [], concurrency: 0 } ).success ).toBe( false );
-      expect( executeInParallelSchema.safeParse( { jobs: [ 'not-a-function' ], concurrency: 1 } ).success ).toBe( false );
-      expect( executeInParallelSchema.safeParse( { jobs: [ fn ], concurrency: 1, onJobCompleted: 'nope' } ).success ).toBe( false );
-    } );
-  } );
-} );

package/src/interface/webhook.spec.js

@@ -1,170 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ACTIVITY_SEND_HTTP_REQUEST } from '#consts';
-
-const validateRequestPayloadMock = vi.fn();
-vi.mock( './validations/index.js', () => ( {
-  validateRequestPayload: validateRequestPayloadMock
-} ) );
-
-// Minimal, legible mock of @temporalio/workflow APIs used by webhook.js
-const activityFnMock = vi.fn();
-const proxyActivitiesMock = vi.fn( () => ( { [ACTIVITY_SEND_HTTP_REQUEST]: activityFnMock } ) );
-
-const storedHandlers = new Map();
-const defineSignalMock = name => name;
-const setHandlerMock = ( signal, fn ) => {
-  storedHandlers.set( signal, fn );
-};
-
-const workflowInfoMock = vi.fn( () => ( { workflowId: 'wf-123' } ) );
-const sinks = { trace: { start: vi.fn(), end: vi.fn() } };
-const proxySinksMock = vi.fn( async () => sinks );
-
-class TestTrigger {
-  constructor() {
-    this.resolved = false;
-    this._resolve = () => {};
-    this.promise = new Promise( res => {
-      this._resolve = res;
-    } );
-  }
-  resolve( value ) {
-    if ( !this.resolved ) {
-      this.resolved = true;
-      this._resolve( value );
-    }
-  }
-  then( onFulfilled, onRejected ) {
-    return this.promise.then( onFulfilled, onRejected );
-  }
-}
-
-vi.mock( '@temporalio/workflow', () => ( {
-  defineSignal: defineSignalMock,
-  setHandler: setHandlerMock,
-  proxyActivities: proxyActivitiesMock,
-  workflowInfo: workflowInfoMock,
-  proxySinks: proxySinksMock,
-  uuid4: () => 'uuid-mock',
-  Trigger: TestTrigger
-} ) );
-
-describe( 'interface/webhook', () => {
-  beforeEach( () => {
-    vi.clearAllMocks();
-    storedHandlers.clear();
-  } );
-
-  it( 'sendHttpRequest validates input and calls activity with correct options and args', async () => {
-    const { sendHttpRequest } = await import( './webhook.js' );
-
-    const fakeSerializedResponse = {
-      url: 'https://example.com',
-      status: 200,
-      statusText: 'OK',
-      ok: true,
-      headers: { 'content-type': 'application/json' },
-      body: { ok: true }
-    };
-    activityFnMock.mockResolvedValueOnce( fakeSerializedResponse );
-
-    const args = { url: 'https://example.com/api', method: 'GET' };
-    const res = await sendHttpRequest( args );
-
-    // validated
-    expect( validateRequestPayloadMock ).toHaveBeenCalledWith( {
-      ...args,
-      payload: undefined,
-      headers: undefined,
-      responseOptions: {}
-    } );
-
-    // activity proxied with specified options
-    expect( proxyActivitiesMock ).toHaveBeenCalledTimes( 1 );
-    const optionsArg = proxyActivitiesMock.mock.calls[0][0];
-    expect( optionsArg.startToCloseTimeout ).toBe( '3m' );
-    expect( optionsArg.retry ).toEqual( expect.objectContaining( {
-      initialInterval: '15s',
-      maximumAttempts: 3,
-      nonRetryableErrorTypes: expect.arrayContaining( [ 'FatalError' ] )
-    } ) );
-
-    // activity invoked with the same args
-    expect( activityFnMock ).toHaveBeenCalledWith( {
-      ...args,
-      payload: undefined,
-      headers: undefined,
-      responseOptions: {}
-    } );
-    expect( res ).toEqual( fakeSerializedResponse );
-  } );
-
-  it( 'sendHttpRequest forwards response options', async () => {
-    const { sendHttpRequest } = await import( './webhook.js' );
-
-    activityFnMock.mockResolvedValueOnce( { ok: true } );
-
-    const args = {
-      url: 'https://example.com/api',
-      method: 'GET',
-      responseOptions: { includeHeaders: true, includeBody: true }
-    };
-
-    await sendHttpRequest( args );
-
-    expect( validateRequestPayloadMock ).toHaveBeenCalledWith( {
-      ...args,
-      payload: undefined,
-      headers: undefined
-    } );
-    expect( activityFnMock ).toHaveBeenCalledWith( {
-      ...args,
-      payload: undefined,
-      headers: undefined
-    } );
-  } );
-
-  it( 'sendPostRequestAndAwaitWebhook posts wrapped payload and resolves on resume signal', async () => {
-    const { sendPostRequestAndAwaitWebhook } = await import( './webhook.js' );
-
-    activityFnMock.mockResolvedValueOnce( {
-      url: 'https://webhook.site',
-      status: 200,
-      statusText: 'OK',
-      ok: true,
-      headers: {},
-      body: null
-    } );
-
-    const url = 'https://webhook.site/ingest';
-    const promise = sendPostRequestAndAwaitWebhook( { url, payload: { x: 1 }, headers: { a: 'b' } } );
-
-    // The activity was called via sendHttpRequest with POST and wrapped payload
-    const callArgs = activityFnMock.mock.calls[0][0];
-    expect( callArgs.method ).toBe( 'POST' );
-    expect( callArgs.url ).toBe( url );
-    expect( callArgs.payload ).toEqual( { workflowId: 'wf-123', payload: { x: 1 } } );
-    expect( callArgs.headers ).toEqual( { a: 'b' } );
-    expect( callArgs.responseOptions ).toEqual( {} );
-
-    await vi.waitFor( () => expect( storedHandlers.has( 'resume' ) ).toBe( true ) );
-
-    expect( sinks.trace.start ).toHaveBeenCalledWith( {
-      id: 'wf-123-https://webhook.site/ingest-uuid-mock',
-      name: 'resume',
-      kind: 'webhook'
-    } );
-
-    const webhookPayload = { status: 'completed' };
-    storedHandlers.get( 'resume' )( webhookPayload );
-
-    await expect( promise ).resolves.toEqual( webhookPayload );
-    expect( sinks.trace.end ).toHaveBeenCalledWith( {
-      id: 'wf-123-https://webhook.site/ingest-uuid-mock',
-      details: webhookPayload
-    } );
-
-    storedHandlers.get( 'resume' )( { status: 'duplicate' } );
-    expect( sinks.trace.end ).toHaveBeenCalledTimes( 1 );
-  } );
-} );