@output.ai/core 0.5.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {

package/src/interface/workflow.js

@@ -3,7 +3,7 @@ import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, uuid4,
 import { validateWorkflow } from './validations/static.js';
 import { validateWithSchema } from './validations/runtime.js';
 import { SHARED_STEP_PREFIX, ACTIVITY_GET_TRACE_DESTINATIONS, METADATA_ACCESS_SYMBOL } from '#consts';
-import { deepMerge, mergeActivityOptions, setMetadata, toUrlSafeBase64 } from '#utils';
+import { deepMerge, setMetadata, toUrlSafeBase64 } from '#utils';
 import { FatalError, ValidationError } from '#errors';
 
 /**
@@ -53,10 +53,10 @@ const defaultOptions = {
   disableTrace: false
 };
 
-export function workflow( { name, description, inputSchema, outputSchema, fn, options } ) {
+export function workflow( { name, description, inputSchema, outputSchema, fn, options = {} } ) {
   validateWorkflow( { name, description, inputSchema, outputSchema, fn, options } );
 
-  const activityOptions = mergeActivityOptions( defaultOptions.activityOptions, options?.activityOptions );
+  const { disableTrace, activityOptions } = deepMerge( defaultOptions, options );
   const steps = proxyActivities( activityOptions );
 
   /**
@@ -71,7 +71,7 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
     if ( !inWorkflowContext() ) {
       validateWithSchema( inputSchema, input, `Workflow ${name} input` );
       const context = Context.build( { workflowId: 'test-workflow', continueAsNew: async () => {}, isContinueAsNewSuggested: () => false } );
-      const output = await fn( input, deepMerge( context, extra.context ?? {} ) );
+      const output = await fn( input, deepMerge( context, extra.context ) );
       validateWithSchema( outputSchema, output, `Workflow ${name} output` );
       return output;
     }
@@ -89,7 +89,7 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
     const executionContext = memo.executionContext ?? {
       workflowId,
       workflowName: name,
-      disableTrace: options.disableTrace,
+      disableTrace,
       startTime: startTime.getTime()
     };
 
@@ -131,7 +131,7 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
               executionContext,
               parentId: workflowId,
               // new configuration for activities of the child workflow, this will be omitted so it will use what that workflow have defined
-              ...( extra?.options?.activityOptions && { activityOptions: mergeActivityOptions( activityOptions, extra.options.activityOptions ) } )
+              ...( extra?.options?.activityOptions && { activityOptions: deepMerge( activityOptions, extra.options.activityOptions ) } )
             }
           } )
       }, input, context );

package/src/interface/workflow.spec.js

@@ -0,0 +1,79 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { z } from 'zod';
+
+const traceDestinationsStepMock = vi.fn().mockResolvedValue( { local: '/tmp/trace' } );
+const proxyActivitiesMock = vi.fn( () => new Proxy( {}, {
+  get: ( _, prop ) => {
+    if ( prop === '__internal#getTraceDestinations' ) {
+      return traceDestinationsStepMock;
+    }
+    return vi.fn();
+  }
+} ) );
+const workflowInfoMock = vi.fn( () => ( {
+  workflowId: 'wf-test-123',
+  workflowType: 'test_wf',
+  memo: {},
+  startTime: new Date( '2025-01-01T00:00:00Z' ),
+  continueAsNewSuggested: false
+} ) );
+
+vi.mock( '@temporalio/workflow', () => ( {
+  proxyActivities: proxyActivitiesMock,
+  inWorkflowContext: () => true,
+  executeChild: vi.fn(),
+  workflowInfo: workflowInfoMock,
+  uuid4: () => 'uuid-mock',
+  ParentClosePolicy: { TERMINATE: 'TERMINATE', ABANDON: 'ABANDON' },
+  continueAsNew: vi.fn()
+} ) );
+
+vi.mock( '#consts', () => ( {
+  SHARED_STEP_PREFIX: '__shared',
+  ACTIVITY_GET_TRACE_DESTINATIONS: '__internal#getTraceDestinations',
+  METADATA_ACCESS_SYMBOL: Symbol( 'metadata' )
+} ) );
+
+describe( 'workflow()', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    workflowInfoMock.mockReturnValue( {
+      workflowId: 'wf-test-123',
+      workflowType: 'test_wf',
+      memo: {},
+      startTime: new Date( '2025-01-01T00:00:00Z' ),
+      continueAsNewSuggested: false
+    } );
+  } );
+
+  it( 'does not throw when options is omitted (disableTrace defaults to false)', async () => {
+    const { workflow } = await import( './workflow.js' );
+
+    const wf = workflow( {
+      name: 'no_options_wf',
+      description: 'Workflow without options',
+      inputSchema: z.object( { value: z.string() } ),
+      outputSchema: z.object( { value: z.string() } ),
+      fn: async ( { value } ) => ( { value } )
+    } );
+
+    const result = await wf( { value: 'hello' } );
+    expect( result.output ).toEqual( { value: 'hello' } );
+  } );
+
+  it( 'respects disableTrace: true when options is provided', async () => {
+    const { workflow } = await import( './workflow.js' );
+
+    const wf = workflow( {
+      name: 'trace_disabled_wf',
+      description: 'Workflow with tracing disabled',
+      inputSchema: z.object( { value: z.string() } ),
+      outputSchema: z.object( { value: z.string() } ),
+      options: { disableTrace: true },
+      fn: async ( { value } ) => ( { value } )
+    } );
+
+    const result = await wf( { value: 'hello' } );
+    expect( result.output ).toEqual( { value: 'hello' } );
+  } );
+} );

package/src/utils/index.d.ts

@@ -33,14 +33,6 @@ export function throws( error: Error ): void;
  */
 export function setMetadata( target: object, value: object ): void;
 
-/**
- * Merge two temporal activity options
- */
-export function mergeActivityOptions(
-  base?: import( '@temporalio/workflow' ).ActivityOptions,
-  ext?: import( '@temporalio/workflow' ).ActivityOptions
-): import( '@temporalio/workflow' ).ActivityOptions;
-
 /** Represents a {Response} serialized to plain object  */
 export type SerializedFetchResponse = {
   /** The response url */

package/src/utils/utils.js

@@ -37,17 +37,6 @@ export const throws = e => {
 export const setMetadata = ( target, values ) =>
   Object.defineProperty( target, METADATA_ACCESS_SYMBOL, { value: values, writable: false, enumerable: false, configurable: false } );
 
-/**
- * Merge two temporal activity options
- * @param {import('@temporalio/workflow').ActivityOptions} base
- * @param {import('@temporalio/workflow').ActivityOptions} ext
- * @returns {import('@temporalio/workflow').ActivityOptions}
- */
-export const mergeActivityOptions = ( base = {}, ext = {} ) =>
-  Object.entries( ext ).reduce( ( options, [ k, v ] ) =>
-    Object.assign( options, { [k]: typeof v === 'object' ? mergeActivityOptions( options[k], v ) : v } )
-  , clone( base ) );
-
 /**
  * Returns true if string value is stringbool and true
  * @param {string} v
@@ -179,6 +168,7 @@ export const shuffleArray = arr => arr
  * - Object "b" fields that don't exist on object "a" will be created;
  * - Object "a" fields that don't exist on object "b" will not be touched;
  *
+ * If "b" isn't an object, a new object equal to "a" is returned
  *
  * @param {object} a - The base object
  * @param {object} b - The target object
@@ -189,7 +179,7 @@ export const deepMerge = ( a, b ) => {
     throw new Error( 'Parameter "a" is not an object.' );
   }
   if ( !isPlainObject( b ) ) {
-    throw new Error( 'Parameter "b" is not an object.' );
+    return clone( a );
   }
   return Object.entries( b ).reduce( ( obj, [ k, v ] ) =>
     Object.assign( obj, { [k]: isPlainObject( v ) && isPlainObject( a[k] ) ? deepMerge( a[k], v ) : v } )

package/src/utils/utils.spec.js

@@ -2,7 +2,6 @@ import { describe, it, expect } from 'vitest';
 import { Readable } from 'node:stream';
 import {
   clone,
-  mergeActivityOptions,
   serializeBodyAndInferContentType,
   serializeFetchResponse,
   deepMerge,
@@ -223,50 +222,6 @@ describe( 'serializeBodyAndInferContentType', () => {
   } );
 } );
 
-describe( 'mergeActivityOptions', () => {
-  it( 'recursively merges nested objects', () => {
-    const base = {
-      taskQueue: 'q1',
-      retry: { maximumAttempts: 3, backoffCoefficient: 2 }
-    };
-    const ext = {
-      retry: { maximumAttempts: 5, initialInterval: '1s' }
-    };
-
-    const result = mergeActivityOptions( base, ext );
-
-    expect( result ).toEqual( {
-      taskQueue: 'q1',
-      retry: { maximumAttempts: 5, backoffCoefficient: 2, initialInterval: '1s' }
-    } );
-  } );
-
-  it( 'omitted properties in second do not overwrite first', () => {
-    const base = {
-      taskQueue: 'q2',
-      retry: { initialInterval: '2s', backoffCoefficient: 2 }
-    };
-    const ext = {
-      retry: { backoffCoefficient: 3 }
-    };
-
-    const result = mergeActivityOptions( base, ext );
-
-    expect( result.retry.initialInterval ).toBe( '2s' );
-    expect( result.retry.backoffCoefficient ).toBe( 3 );
-    expect( result.taskQueue ).toBe( 'q2' );
-  } );
-
-  it( 'handles omitted second argument by returning a clone', () => {
-    const base = { taskQueue: 'q3', retry: { maximumAttempts: 2 } };
-
-    const result = mergeActivityOptions( base );
-
-    expect( result ).toEqual( base );
-    expect( result ).not.toBe( base );
-  } );
-} );
-
 describe( 'deepMerge', () => {
   it( 'Overwrites properties in object "a"', () => {
     const a = {
@@ -316,13 +271,43 @@ describe( 'deepMerge', () => {
     } );
   } );
 
-  it( 'Throw error on non iterable object types', () => {
-    expect( () => deepMerge( Function, Function ) ).toThrow( Error );
-    expect( () => deepMerge( () => {}, () => {} ) ).toThrow( Error );
-    expect( () => deepMerge( 'a', 'a' ) ).toThrow( Error );
-    expect( () => deepMerge( true, true ) ).toThrow( Error );
-    expect( () => deepMerge( /a/, /a/ ) ).toThrow( Error );
-    expect( () => deepMerge( [], [] ) ).toThrow( Error );
+  it( 'Merge object is a clone', () => {
+    const a = {
+      a: 1
+    };
+    const b = {
+      b: 1
+    };
+    const result = deepMerge( a, b );
+    a.a = 2;
+    b.b = 2;
+    expect( result.a ).toEqual( 1 );
+  } );
+
+  it( 'Returns copy of "a" if "b" is not an object', () => {
+    const a = {
+      a: 1
+    };
+    expect( deepMerge( a, null ) ).toEqual( { a: 1 } );
+    expect( deepMerge( a, undefined ) ).toEqual( { a: 1 } );
+  } );
+
+  it( 'Copy of object "a" is a clone', () => {
+    const a = {
+      a: 1
+    };
+    const result = deepMerge( a, null );
+    a.a = 2;
+    expect( result.a ).toEqual( 1 );
+  } );
+
+  it( 'Throws when first argument is not a plain object', () => {
+    expect( () => deepMerge( Function ) ).toThrow( Error );
+    expect( () => deepMerge( () => {} ) ).toThrow( Error );
+    expect( () => deepMerge( 'a' ) ).toThrow( Error );
+    expect( () => deepMerge( true ) ).toThrow( Error );
+    expect( () => deepMerge( /a/ ) ).toThrow( Error );
+    expect( () => deepMerge( [] ) ).toThrow( Error );
     expect( () => deepMerge( class Foo {}, class Foo {} ) ).toThrow( Error );
     expect( () => deepMerge( Number.constructor, Number.constructor ) ).toThrow( Error );
     expect( () => deepMerge( Number.constructor.prototype, Number.constructor.prototype ) ).toThrow( Error );
@@ -377,6 +362,8 @@ describe( 'isPlainObject', () => {
   } );
 
   it( 'Returns false for primitives', () => {
+    expect( isPlainObject( null ) ).toBe( false );
+    expect( isPlainObject( undefined ) ).toBe( false );
     expect( isPlainObject( false ) ).toBe( false );
     expect( isPlainObject( true ) ).toBe( false );
     expect( isPlainObject( 1 ) ).toBe( false );

package/src/worker/interceptors/workflow.js

@@ -1,7 +1,7 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
 import { workflowInfo, proxySinks, ApplicationFailure, ContinueAsNew } from '@temporalio/workflow';
 import { memoToHeaders } from '../sandboxed_utils.js';
-import { mergeActivityOptions } from '#utils';
+import { deepMerge } from '#utils';
 import { METADATA_ACCESS_SYMBOL } from '#consts';
 // this is a dynamic generated file with activity configs overwrites
 import stepOptions from '../temp/__activity_options.js';
@@ -22,7 +22,7 @@ class HeadersInjectionInterceptor {
     // apply per-invocation options passed as second argument by rewritten calls
     const options = stepOptions[input.activityType];
     if ( options ) {
-      input.options = mergeActivityOptions( memo.activityOptions, options );
+      input.options = deepMerge( memo.activityOptions, options );
     }
     return next( input );
   }