@outputai/core 0.3.3-dev.422151e.0 → 0.3.3-dev.e8eff63.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.3.3-dev.422151e.0",
+  "version": "0.3.3-dev.e8eff63.0",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -45,7 +45,12 @@
     "redis": "5.12.1",
     "stacktrace-parser": "0.1.11",
     "undici": "8.1.0",
-    "winston": "3.19.0",
+    "winston": "3.19.0"
+  },
+  "peerDependencies": {
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
     "zod": "4.3.6"
   },
   "license": "Apache-2.0",

package/src/consts.js

@@ -32,3 +32,7 @@ export const BusEventType = {
 
   RUNTIME_ERROR: 'runtime_error'
 };
+
+export const WorkflowSpecialOutput = {
+  CONTINUED_AS_NEW: '<<continued_as_new>>'
+};

package/src/interface/workflow.d.ts

@@ -139,9 +139,9 @@ export type WorkflowFunction<
  */
 export type WorkflowFunctionWrapper<WorkflowFunction> =
   [Parameters<WorkflowFunction>[0]] extends [undefined | null] ?
-    ( input?: undefined | null, config?: WorkflowInvocationConfiguration<Parameters<WorkflowFunction>[1]> ) =>
+    ( input?: undefined | null, config?: WorkflowInvocationConfiguration ) =>
     ReturnType<WorkflowFunction> :
-    ( input: Parameters<WorkflowFunction>[0], config?: WorkflowInvocationConfiguration<Parameters<WorkflowFunction>[1]> ) =>
+    ( input: Parameters<WorkflowFunction>[0], config?: WorkflowInvocationConfiguration ) =>
     ReturnType<WorkflowFunction>;
 
 /**

package/src/worker/interceptors/workflow.js

@@ -1,8 +1,8 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
-import { workflowInfo, proxySinks, ApplicationFailure, ContinueAsNew } from '@temporalio/workflow';
+import { workflowInfo, proxySinks, ApplicationFailure, ContinueAsNew, isCancellation } from '@temporalio/workflow';
 import { memoToHeaders } from '../sandboxed_utils.js';
 import { deepMerge } from '#utils';
-import { METADATA_ACCESS_SYMBOL } from '#consts';
+import { METADATA_ACCESS_SYMBOL, WorkflowSpecialOutput } from '#consts';
 // this is a dynamic generated file with activity configs overwrites
 import stepOptions from '../temp/__activity_options.js';
 
@@ -44,7 +44,12 @@ class WorkflowExecutionInterceptor {
        * a new trace file will be generated
        */
       if ( error instanceof ContinueAsNew ) {
-        sinks.workflow.end( '<continued_as_new>' );
+        sinks.workflow.end( WorkflowSpecialOutput.CONTINUED_AS_NEW );
+        throw error;
+      }
+
+      if ( isCancellation( error ) ) {
+        sinks.workflow.error( error );
         throw error;
       }
 

package/src/worker/interceptors/workflow.spec.js

@@ -6,6 +6,7 @@ const workflowInfoMock = vi.fn();
 const workflowStartMock = vi.fn();
 const workflowEndMock = vi.fn();
 const workflowErrorMock = vi.fn();
+const isCancellationMock = vi.fn();
 vi.mock( '@temporalio/workflow', () => ( {
   workflowInfo: ( ...args ) => workflowInfoMock( ...args ),
   proxySinks: () => ( {
@@ -26,7 +27,8 @@ vi.mock( '@temporalio/workflow', () => ( {
       super( 'ContinueAsNew' );
       this.name = 'ContinueAsNew';
     }
-  }
+  },
+  isCancellation: ( ...args ) => isCancellationMock( ...args )
 } ) );
 
 const memoToHeadersMock = vi.fn( memo => ( memo ? { ...memo, __asHeaders: true } : {} ) );
@@ -50,6 +52,7 @@ vi.mock( '../temp/__activity_options.js', () => ( { default: stepOptionsDefault
 describe( 'workflow interceptors', () => {
   beforeEach( () => {
     vi.clearAllMocks();
+    isCancellationMock.mockReturnValue( false );
     workflowInfoMock.mockReturnValue( { workflowType: 'MyWorkflow', memo: { executionContext: { id: 'ctx-1' } } } );
   } );
 
@@ -151,8 +154,25 @@ describe( 'workflow interceptors', () => {
       expect( error.details ).toEqual( [ meta ] );
     } );
 
+    it( 'calls sinks.workflow.error and rethrows cancellation errors without wrapping', async () => {
+      const { interceptors } = await import( './workflow.js' );
+      const { ApplicationFailure } = await import( '@temporalio/workflow' );
+      const { inbound } = interceptors();
+      const interceptor = inbound[0];
+      const cancellation = new Error( 'Workflow cancelled' );
+      const next = vi.fn().mockRejectedValue( cancellation );
+      isCancellationMock.mockReturnValue( true );
+
+      await expect( interceptor.execute( { args: [ {} ] }, next ) ).rejects.toBe( cancellation );
+      expect( isCancellationMock ).toHaveBeenCalledWith( cancellation );
+      expect( cancellation ).not.toBeInstanceOf( ApplicationFailure );
+      expect( workflowErrorMock ).toHaveBeenCalledWith( cancellation );
+      expect( workflowEndMock ).not.toHaveBeenCalled();
+    } );
+
     it( 'on ContinueAsNew calls sinks.trace.addWorkflowEventEnd and rethrows', async () => {
       const { ContinueAsNew } = await import( '@temporalio/workflow' );
+      const { WorkflowSpecialOutput } = await import( '#consts' );
       const { interceptors } = await import( './workflow.js' );
       const { inbound } = interceptors();
       const interceptor = inbound[0];
@@ -160,7 +180,7 @@ describe( 'workflow interceptors', () => {
       const next = vi.fn().mockRejectedValue( continueErr );
 
       await expect( interceptor.execute( { args: [ {} ] }, next ) ).rejects.toThrow( ContinueAsNew );
-      expect( workflowEndMock ).toHaveBeenCalledWith( '<continued_as_new>' );
+      expect( workflowEndMock ).toHaveBeenCalledWith( WorkflowSpecialOutput.CONTINUED_AS_NEW );
       expect( workflowErrorMock ).not.toHaveBeenCalled();
     } );
   } );

package/src/worker/start_catalog.js

@@ -1,4 +1,4 @@
-import { Client } from '@temporalio/client';
+import { Client, WorkflowNotFoundError } from '@temporalio/client';
 import { WorkflowIdConflictPolicy } from '@temporalio/common';
 import { WORKFLOW_CATALOG } from '#consts';
 import { catalogId, taskQueue } from './configs.js';
@@ -8,12 +8,29 @@ const log = createChildLogger( 'Catalog' );
 
 export const startCatalog = async ( { connection, namespace, catalog } ) => {
   const client = new Client( { connection, namespace } );
+  const catalogWorkflowHandle = client.workflow.getHandle( catalogId );
+
+  try {
+    const catalogWorkflowDescription = await catalogWorkflowHandle.describe();
+    if ( !catalogWorkflowDescription.closeTime ) {
+      log.info( 'Completing previous catalog workflow...' );
+      await catalogWorkflowHandle.executeUpdate( 'complete', { args: [] } );
+    }
+  } catch ( error ) {
+    // When "not found", it's either a cold start or the catalog was already stopped/terminated, ignore it.
+    // Otherwise, create a log and try the next operation:
+    // A. If the workflow is still running, the start() will fail and throw;
+    // B. If the workflow is no running, the start() will succeed, and the error was transient;
+    if ( !( error instanceof WorkflowNotFoundError ) ) {
+      log.warn( 'Error interacting with previous catalog workflow', { error } );
+    }
+  }
 
   log.info( 'Starting catalog workflow...' );
   await client.workflow.start( WORKFLOW_CATALOG, {
     taskQueue,
-    workflowId: catalogId,
-    workflowIdConflictPolicy: WorkflowIdConflictPolicy.TERMINATE_EXISTING,
+    workflowId: catalogId, // use the name of the task queue as the catalog name, ensuring uniqueness
+    workflowIdConflictPolicy: WorkflowIdConflictPolicy.FAIL,
     args: [ catalog ]
   } );
 };

package/src/worker/start_catalog.spec.js

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { WorkflowNotFoundError } from '@temporalio/client';
 
 const mockLog = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
 vi.mock( '#logger', () => ( { createChildLogger: () => mockLog } ) );
@@ -9,18 +10,25 @@ const catalogId = 'test-catalog';
 const taskQueue = 'test-queue';
 vi.mock( './configs.js', () => ( { catalogId, taskQueue } ) );
 
+const describeMock = vi.fn();
+const executeUpdateMock = vi.fn();
 const workflowStartMock = vi.fn().mockResolvedValue( undefined );
 vi.mock( '@temporalio/client', async importOriginal => {
   const actual = await importOriginal();
   return {
     ...actual,
     Client: vi.fn().mockImplementation( function () {
-      return { workflow: { start: workflowStartMock } };
+      return {
+        workflow: {
+          start: workflowStartMock,
+          getHandle: () => ( { describe: describeMock, executeUpdate: executeUpdateMock } )
+        }
+      };
     } )
   };
 } );
 
-vi.mock( '@temporalio/common', () => ( { WorkflowIdConflictPolicy: { TERMINATE_EXISTING: 'TERMINATE_EXISTING' } } ) );
+vi.mock( '@temporalio/common', () => ( { WorkflowIdConflictPolicy: { FAIL: 'FAIL' } } ) );
 
 describe( 'worker/start_catalog', () => {
   const mockConnection = {};
@@ -32,24 +40,79 @@ describe( 'worker/start_catalog', () => {
     workflowStartMock.mockResolvedValue( undefined );
   } );
 
-  it( 'starts catalog workflow with TERMINATE_EXISTING policy', async () => {
+  it( 'when previous catalog still running: completes it then starts catalog workflow', async () => {
+    describeMock.mockResolvedValue( { closeTime: undefined } );
+    executeUpdateMock.mockResolvedValue( undefined );
+
+    const { startCatalog } = await import( './start_catalog.js' );
+    await startCatalog( { connection: mockConnection, namespace, catalog } );
+
+    expect( describeMock ).toHaveBeenCalled();
+    expect( mockLog.info ).toHaveBeenCalledWith( 'Completing previous catalog workflow...' );
+    expect( executeUpdateMock ).toHaveBeenCalledWith( 'complete', { args: [] } );
+    expect( mockLog.info ).toHaveBeenCalledWith( 'Starting catalog workflow...' );
+    expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', {
+      taskQueue,
+      workflowId: catalogId,
+      workflowIdConflictPolicy: 'FAIL',
+      args: [ catalog ]
+    } );
+  } );
+
+  it( 'when no previous catalog: ignores and starts catalog workflow', async () => {
+    describeMock.mockRejectedValue( new WorkflowNotFoundError( 'not found' ) );
+
+    const { startCatalog } = await import( './start_catalog.js' );
+    await startCatalog( { connection: mockConnection, namespace, catalog } );
+
+    expect( describeMock ).toHaveBeenCalled();
+    expect( mockLog.warn ).not.toHaveBeenCalled();
+    expect( mockLog.info ).toHaveBeenCalledWith( 'Starting catalog workflow...' );
+    expect( executeUpdateMock ).not.toHaveBeenCalled();
+    expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', {
+      taskQueue,
+      workflowId: catalogId,
+      workflowIdConflictPolicy: 'FAIL',
+      args: [ catalog ]
+    } );
+  } );
+
+  it( 'when previous catalog already closed: skips complete and starts catalog workflow', async () => {
+    describeMock.mockResolvedValue( { closeTime: '2024-01-01T00:00:00Z' } );
+
     const { startCatalog } = await import( './start_catalog.js' );
     await startCatalog( { connection: mockConnection, namespace, catalog } );
 
+    expect( describeMock ).toHaveBeenCalled();
+    expect( mockLog.info ).not.toHaveBeenCalledWith( 'Completing previous catalog workflow...' );
+    expect( executeUpdateMock ).not.toHaveBeenCalled();
     expect( mockLog.info ).toHaveBeenCalledWith( 'Starting catalog workflow...' );
     expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', {
       taskQueue,
       workflowId: catalogId,
-      workflowIdConflictPolicy: 'TERMINATE_EXISTING',
+      workflowIdConflictPolicy: 'FAIL',
       args: [ catalog ]
     } );
   } );
 
-  it( 'propagates errors from workflow.start', async () => {
-    workflowStartMock.mockRejectedValue( new Error( 'Connection refused' ) );
+  it( 'when describe or complete fails with other error: logs warn and still starts catalog workflow', async () => {
+    describeMock.mockResolvedValue( { closeTime: undefined } );
+    executeUpdateMock.mockRejectedValue( new Error( 'Connection refused' ) );
 
     const { startCatalog } = await import( './start_catalog.js' );
-    await expect( startCatalog( { connection: mockConnection, namespace, catalog } ) )
-      .rejects.toThrow( 'Connection refused' );
+    await startCatalog( { connection: mockConnection, namespace, catalog } );
+
+    expect( describeMock ).toHaveBeenCalled();
+    expect( executeUpdateMock ).toHaveBeenCalledWith( 'complete', { args: [] } );
+    expect( mockLog.warn ).toHaveBeenCalledWith( 'Error interacting with previous catalog workflow', {
+      error: expect.any( Error )
+    } );
+    expect( mockLog.info ).toHaveBeenCalledWith( 'Starting catalog workflow...' );
+    expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', {
+      taskQueue,
+      workflowId: catalogId,
+      workflowIdConflictPolicy: 'FAIL',
+      args: [ catalog ]
+    } );
   } );
 } );