@output.ai/core 0.5.0 → 0.5.2

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/index.spec.js

@@ -0,0 +1,180 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const mockLog = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+vi.mock( '#logger', () => ( { createChildLogger: () => mockLog } ) );
+
+vi.mock( '#consts', () => ( { WORKFLOW_CATALOG: 'catalog' } ) );
+
+vi.mock( '#tracing', () => ( { init: vi.fn().mockResolvedValue( undefined ) } ) );
+
+const configValues = {
+  address: 'localhost:7233',
+  apiKey: undefined,
+  namespace: 'default',
+  taskQueue: 'test-queue',
+  catalogId: 'test-catalog',
+  maxConcurrentWorkflowTaskExecutions: 200,
+  maxConcurrentActivityTaskExecutions: 40,
+  maxCachedWorkflows: 1000,
+  maxConcurrentActivityTaskPolls: 5,
+  maxConcurrentWorkflowTaskPolls: 5
+};
+vi.mock( './configs.js', () => configValues );
+
+const loadWorkflowsMock = vi.fn().mockResolvedValue( [] );
+const loadActivitiesMock = vi.fn().mockResolvedValue( {} );
+const createWorkflowsEntryPointMock = vi.fn().mockReturnValue( '/fake/workflows/path.js' );
+vi.mock( './loader.js', () => ( {
+  loadWorkflows: loadWorkflowsMock,
+  loadActivities: loadActivitiesMock,
+  createWorkflowsEntryPoint: createWorkflowsEntryPointMock
+} ) );
+
+vi.mock( './sinks.js', () => ( { sinks: {} } ) );
+
+const createCatalogMock = vi.fn().mockReturnValue( { workflows: [], activities: {} } );
+vi.mock( './catalog_workflow/index.js', () => ( { createCatalog: createCatalogMock } ) );
+
+vi.mock( './bundler_options.js', () => ( { webpackConfigHook: vi.fn() } ) );
+
+const initInterceptorsMock = vi.fn().mockReturnValue( [] );
+vi.mock( './interceptors.js', () => ( { initInterceptors: initInterceptorsMock } ) );
+
+const runState = { resolve: null };
+const runPromise = new Promise( r => {
+  runState.resolve = r;
+} );
+const shutdownMock = vi.fn();
+const mockConnection = { close: vi.fn().mockResolvedValue( undefined ) };
+const mockWorker = { run: () => runPromise, shutdown: shutdownMock };
+
+vi.mock( '@temporalio/worker', () => ( {
+  Worker: { create: vi.fn().mockResolvedValue( mockWorker ) },
+  NativeConnection: { connect: vi.fn().mockResolvedValue( mockConnection ) }
+} ) );
+
+const workflowStartMock = vi.fn().mockResolvedValue( undefined );
+vi.mock( '@temporalio/client', () => ( {
+  Client: vi.fn().mockImplementation( () => ( {
+    workflow: { start: workflowStartMock }
+  } ) )
+} ) );
+
+vi.mock( '@temporalio/common', () => ( {
+  WorkflowIdConflictPolicy: { TERMINATE_EXISTING: 'TERMINATE_EXISTING' }
+} ) );
+
+describe( 'worker/index', () => {
+  const exitMock = vi.fn();
+  const originalArgv = process.argv;
+  const originalExit = process.exit;
+  const originalOn = process.on;
+
+  beforeEach( () => {
+    vi.clearAllMocks();
+    process.argv = [ ...originalArgv.slice( 0, 2 ), '/test/caller/dir' ];
+    process.exit = exitMock;
+  } );
+
+  afterEach( () => {
+    process.argv = originalArgv;
+    process.exit = originalExit;
+    process.on = originalOn;
+    configValues.apiKey = undefined;
+  } );
+
+  it( 'loads configs, workflows, activities and creates worker with correct options', async () => {
+    const { Worker, NativeConnection } = await import( '@temporalio/worker' );
+    const { Client } = await import( '@temporalio/client' );
+    const { init: initTracing } = await import( '#tracing' );
+
+    import( './index.js' );
+
+    await vi.waitFor( () => {
+      expect( loadWorkflowsMock ).toHaveBeenCalledWith( '/test/caller/dir' );
+    } );
+    expect( loadActivitiesMock ).toHaveBeenCalledWith( '/test/caller/dir', [] );
+    expect( createWorkflowsEntryPointMock ).toHaveBeenCalledWith( [] );
+    expect( initTracing ).toHaveBeenCalled();
+    expect( createCatalogMock ).toHaveBeenCalledWith( { workflows: [], activities: {} } );
+    expect( NativeConnection.connect ).toHaveBeenCalledWith( {
+      address: configValues.address,
+      tls: false,
+      apiKey: undefined
+    } );
+    expect( Worker.create ).toHaveBeenCalledWith( expect.objectContaining( {
+      namespace: configValues.namespace,
+      taskQueue: configValues.taskQueue,
+      workflowsPath: '/fake/workflows/path.js',
+      activities: {},
+      maxConcurrentWorkflowTaskExecutions: configValues.maxConcurrentWorkflowTaskExecutions,
+      maxConcurrentActivityTaskExecutions: configValues.maxConcurrentActivityTaskExecutions,
+      maxCachedWorkflows: configValues.maxCachedWorkflows,
+      maxConcurrentActivityTaskPolls: configValues.maxConcurrentActivityTaskPolls,
+      maxConcurrentWorkflowTaskPolls: configValues.maxConcurrentWorkflowTaskPolls
+    } ) );
+    expect( initInterceptorsMock ).toHaveBeenCalledWith( { activities: {} } );
+    expect( Client ).toHaveBeenCalledWith( { connection: mockConnection, namespace: configValues.namespace } );
+    expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', {
+      taskQueue: configValues.taskQueue,
+      workflowId: configValues.catalogId,
+      workflowIdConflictPolicy: 'TERMINATE_EXISTING',
+      args: [ { workflows: [], activities: {} } ]
+    } );
+
+    runState.resolve();
+    await vi.waitFor( () => {
+      expect( mockConnection.close ).toHaveBeenCalled();
+    } );
+    expect( exitMock ).toHaveBeenCalledWith( 0 );
+  } );
+
+  it( 'enables TLS when apiKey is set', async () => {
+    configValues.apiKey = 'secret';
+    vi.resetModules();
+
+    const { NativeConnection } = await import( '@temporalio/worker' );
+    import( './index.js' );
+
+    await vi.waitFor( () => {
+      expect( NativeConnection.connect ).toHaveBeenCalledWith( expect.objectContaining( {
+        tls: true,
+        apiKey: 'secret'
+      } ) );
+    } );
+    await vi.waitFor( () => expect( exitMock ).toHaveBeenCalled() );
+  } );
+
+  it( 'registers SIGTERM and SIGINT handlers that shut down worker', async () => {
+    const onMock = vi.fn();
+    process.on = onMock;
+    vi.resetModules();
+
+    import( './index.js' );
+
+    await vi.waitFor( () => {
+      expect( onMock ).toHaveBeenCalledWith( 'SIGTERM', expect.any( Function ) );
+      expect( onMock ).toHaveBeenCalledWith( 'SIGINT', expect.any( Function ) );
+    } );
+
+    const sigtermHandler = onMock.mock.calls.find( c => c[0] === 'SIGTERM' )?.[1];
+    expect( sigtermHandler ).toBeDefined();
+    sigtermHandler();
+    expect( shutdownMock ).toHaveBeenCalled();
+
+    runState.resolve();
+    await vi.waitFor( () => expect( exitMock ).toHaveBeenCalled() );
+  } );
+
+  it( 'calls process.exit(1) on fatal error', async () => {
+    loadWorkflowsMock.mockRejectedValueOnce( new Error( 'load failed' ) );
+    vi.resetModules();
+
+    import( './index.js' );
+
+    await vi.waitFor( () => {
+      expect( mockLog.error ).toHaveBeenCalledWith( 'Fatal error', expect.any( Object ) );
+    } );
+    expect( exitMock ).toHaveBeenCalledWith( 1 );
+  } );
+} );

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 );
   }