@outputai/core 0.1.13-dev.98dfd72.0 → 0.1.13-dev.e3e3291.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.1.13-dev.98dfd72.0",
+  "version": "0.1.13-dev.e3e3291.0",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {

package/src/worker/configs.js

@@ -26,9 +26,7 @@ const envVarSchema = z.object( {
   // Whether to send activity heartbeats (enabled by default)
   OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: z.transform( v => v === undefined ? true : isStringboolTrue( v ) ),
   // Time to allow for hooks to flush before shutdown
-  OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 3000 ) ),
-  // HTTP CONNECT proxy for Temporal gRPC connections (e.g. "proxy-host:8080")
-  TEMPORAL_GRPC_PROXY: z.string().optional()
+  OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 3000 ) )
 } );
 
 const { data: envVars, error } = envVarSchema.safeParse( process.env );
@@ -49,4 +47,3 @@ export const catalogId = envVars.OUTPUT_CATALOG_ID;
 export const activityHeartbeatIntervalMs = envVars.OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS;
 export const activityHeartbeatEnabled = envVars.OUTPUT_ACTIVITY_HEARTBEAT_ENABLED;
 export const processFailureShutdownDelay = envVars.OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY;
-export const grpcProxy = envVars.TEMPORAL_GRPC_PROXY;

package/src/worker/index.js

@@ -9,7 +9,6 @@ import { initInterceptors } from './interceptors.js';
 import { createChildLogger } from '#logger';
 import { registerShutdown } from './shutdown.js';
 import { startCatalog } from './start_catalog.js';
-import { bootstrapFetchProxy } from './proxy.js';
 import { messageBus } from '#bus';
 import './log_hooks.js';
 import { BusEventType } from '#consts';
@@ -25,7 +24,6 @@ const callerDir = process.argv[2];
     apiKey,
     namespace,
     taskQueue,
-    grpcProxy,
     maxConcurrentWorkflowTaskExecutions,
     maxConcurrentActivityTaskExecutions,
     maxCachedWorkflows,
@@ -43,7 +41,6 @@ const callerDir = process.argv[2];
   const activities = await loadActivities( callerDir, workflows );
 
   messageBus.emit( BusEventType.WORKER_BEFORE_START );
-  bootstrapFetchProxy();
 
   log.info( 'Creating worker entry point...' );
   const workflowsPath = createWorkflowsEntryPoint( workflows );
@@ -55,8 +52,8 @@ const callerDir = process.argv[2];
   const catalog = createCatalog( { workflows, activities } );
 
   log.info( 'Connecting Temporal...' );
-  const proxy = grpcProxy ? { type: 'http-connect', targetHost: grpcProxy } : undefined;
-  const connection = await NativeConnection.connect( { address, tls: Boolean( apiKey ), apiKey, proxy } );
+  // Enable TLS when connecting to remote Temporal (API key present)
+  const connection = await NativeConnection.connect( { address, tls: Boolean( apiKey ), apiKey } );
 
   log.info( 'Creating worker...' );
   const worker = await Worker.create( {

package/src/worker/index.spec.js

@@ -16,7 +16,6 @@ const configValues = {
   namespace: 'default',
   taskQueue: 'test-queue',
   catalogId: 'test-catalog',
-  grpcProxy: undefined,
   maxConcurrentWorkflowTaskExecutions: 200,
   maxConcurrentActivityTaskExecutions: 40,
   maxCachedWorkflows: 1000,
@@ -53,9 +52,6 @@ vi.mock( './interceptors.js', () => ( { initInterceptors: initInterceptorsMock }
 const startCatalogMock = vi.fn().mockResolvedValue( undefined );
 vi.mock( './start_catalog.js', () => ( { startCatalog: startCatalogMock } ) );
 
-const bootstrapFetchProxyMock = vi.fn();
-vi.mock( './proxy.js', () => ( { bootstrapFetchProxy: bootstrapFetchProxyMock } ) );
-
 const registerShutdownMock = vi.fn();
 vi.mock( './shutdown.js', () => ( { registerShutdown: registerShutdownMock } ) );
 
@@ -108,8 +104,7 @@ describe( 'worker/index', () => {
     expect( NativeConnection.connect ).toHaveBeenCalledWith( {
       address: configValues.address,
       tls: false,
-      apiKey: undefined,
-      proxy: undefined
+      apiKey: undefined
     } );
     expect( Worker.create ).toHaveBeenCalledWith( expect.objectContaining( {
       namespace: configValues.namespace,

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

package/src/worker/proxy.js

@@ -1,16 +0,0 @@
-import { EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
-import { createChildLogger } from '#logger';
-
-const log = createChildLogger( 'Proxy' );
-
-export const bootstrapFetchProxy = () => {
-  const proxyUrl = process.env.HTTPS_PROXY || process.env.https_proxy ||
-    process.env.HTTP_PROXY || process.env.http_proxy;
-
-  if ( !proxyUrl ) {
-    return;
-  }
-
-  log.info( 'Routing fetch() through HTTP proxy', { proxyUrl } );
-  setGlobalDispatcher( new EnvHttpProxyAgent() );
-};

package/src/worker/proxy.spec.js

@@ -1,63 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-const mockSetGlobalDispatcher = vi.fn();
-const MockEnvHttpProxyAgent = vi.fn();
-
-vi.mock( 'undici', () => ( {
-  EnvHttpProxyAgent: MockEnvHttpProxyAgent,
-  setGlobalDispatcher: mockSetGlobalDispatcher
-} ) );
-
-vi.mock( '#logger', () => ( {
-  createChildLogger: () => ( { info: vi.fn(), warn: vi.fn(), error: vi.fn() } )
-} ) );
-
-describe( 'worker/proxy', () => {
-  const originalEnv = { ...process.env };
-
-  beforeEach( () => {
-    vi.clearAllMocks();
-    delete process.env.HTTPS_PROXY;
-    delete process.env.https_proxy;
-    delete process.env.HTTP_PROXY;
-    delete process.env.http_proxy;
-  } );
-
-  afterEach( () => {
-    process.env = { ...originalEnv };
-  } );
-
-  it( 'does nothing when no proxy env vars are set', async () => {
-    const { bootstrapFetchProxy } = await import( './proxy.js' );
-    bootstrapFetchProxy();
-
-    expect( mockSetGlobalDispatcher ).not.toHaveBeenCalled();
-  } );
-
-  it( 'sets global dispatcher when HTTPS_PROXY is set', async () => {
-    process.env.HTTPS_PROXY = 'http://proxy:8080';
-    const { bootstrapFetchProxy } = await import( './proxy.js' );
-    bootstrapFetchProxy();
-
-    expect( MockEnvHttpProxyAgent ).toHaveBeenCalled();
-    expect( mockSetGlobalDispatcher ).toHaveBeenCalledTimes( 1 );
-  } );
-
-  it( 'sets global dispatcher when HTTP_PROXY is set', async () => {
-    process.env.HTTP_PROXY = 'http://proxy:8080';
-    const { bootstrapFetchProxy } = await import( './proxy.js' );
-    bootstrapFetchProxy();
-
-    expect( MockEnvHttpProxyAgent ).toHaveBeenCalled();
-    expect( mockSetGlobalDispatcher ).toHaveBeenCalledTimes( 1 );
-  } );
-
-  it( 'prefers HTTPS_PROXY over HTTP_PROXY for detection', async () => {
-    process.env.HTTPS_PROXY = 'http://secure-proxy:8080';
-    process.env.HTTP_PROXY = 'http://plain-proxy:8080';
-    const { bootstrapFetchProxy } = await import( './proxy.js' );
-    bootstrapFetchProxy();
-
-    expect( mockSetGlobalDispatcher ).toHaveBeenCalledTimes( 1 );
-  } );
-} );