@outputai/core 0.12.0 → 0.12.1-next.1243f78.0

package/src/worker/worker_runner.spec.js

@@ -0,0 +1,220 @@
+import { describe, expect, it, vi } from 'vitest';
+import { WorkerRunner } from './worker_runner.js';
+
+/**
+ * Stands in for a Temporal worker: run() only settles once the drain finishes,
+ * and shutdown() moves the run state out of RUNNING the way the SDK does.
+ */
+const createWorker = () => {
+  const state = { runState: 'INITIALIZED', resolve: null, reject: null };
+
+  const worker = {
+    run: vi.fn( () => {
+      state.runState = 'RUNNING';
+      return new Promise( ( resolve, reject ) => {
+        state.resolve = resolve;
+        state.reject = reject;
+      } );
+    } ),
+    shutdown: vi.fn( () => {
+      state.runState = 'STOPPING';
+    } ),
+    getStatus: vi.fn( () => ( { runState: state.runState } ) )
+  };
+
+  return {
+    worker,
+    drain: () => {
+      state.runState = 'STOPPED';
+      state.resolve();
+    },
+    fail: error => {
+      state.runState = 'STOPPED';
+      state.reject( error );
+    }
+  };
+};
+
+const createRunner = ( worker, signal = new AbortController().signal ) => new WorkerRunner( { worker, signal } );
+
+describe( 'WorkerRunner', () => {
+  it( 'polls the task queue and reports running until the worker settles', async () => {
+    const { worker, drain } = createWorker();
+    const runner = createRunner( worker );
+
+    const run = runner.start();
+
+    expect( worker.run ).toHaveBeenCalledOnce();
+    expect( runner.running ).toBe( true );
+
+    drain();
+    await run;
+
+    expect( runner.running ).toBe( false );
+  } );
+
+  it( 'returns the same execution when started more than once', async () => {
+    const { worker, drain } = createWorker();
+    const runner = createRunner( worker );
+
+    const first = runner.start();
+    const second = runner.start();
+
+    expect( second ).toBe( first );
+    expect( worker.run ).toHaveBeenCalledOnce();
+
+    drain();
+    await first;
+  } );
+
+  it( 'never polls when the signal is already aborted', async () => {
+    const controller = new AbortController();
+    controller.abort();
+    const { worker } = createWorker();
+    const runner = createRunner( worker, controller.signal );
+
+    await expect( runner.start() ).resolves.toBeUndefined();
+
+    expect( worker.run ).not.toHaveBeenCalled();
+    expect( worker.shutdown ).not.toHaveBeenCalled();
+    expect( runner.running ).toBe( false );
+  } );
+
+  it( 'drains the worker when the signal aborts', async () => {
+    const controller = new AbortController();
+    const { worker, drain } = createWorker();
+    const runner = createRunner( worker, controller.signal );
+
+    const run = runner.start();
+    controller.abort();
+
+    expect( worker.shutdown ).toHaveBeenCalledOnce();
+    expect( runner.running ).toBe( true );
+
+    drain();
+    await run;
+
+    expect( runner.running ).toBe( false );
+  } );
+
+  it( 'drains on stop and resolves once the worker settles', async () => {
+    const { worker, drain } = createWorker();
+    const runner = createRunner( worker );
+
+    const run = runner.start();
+    const stopped = runner.stop();
+
+    expect( worker.shutdown ).toHaveBeenCalledOnce();
+    expect( runner.running ).toBe( true );
+
+    drain();
+
+    await expect( stopped ).resolves.toBeUndefined();
+    await run;
+
+    expect( runner.running ).toBe( false );
+  } );
+
+  it( 'does not shut down a worker that is not running', async () => {
+    const { worker } = createWorker();
+    const runner = createRunner( worker );
+
+    await expect( runner.stop() ).resolves.toBeUndefined();
+
+    expect( worker.run ).not.toHaveBeenCalled();
+    expect( worker.shutdown ).not.toHaveBeenCalled();
+  } );
+
+  it( 'shuts the worker down once when stopped twice', async () => {
+    const { worker, drain } = createWorker();
+    const runner = createRunner( worker );
+
+    const run = runner.start();
+    runner.stop();
+    runner.stop();
+
+    expect( worker.shutdown ).toHaveBeenCalledOnce();
+
+    drain();
+    await run;
+  } );
+
+  it( 'shuts the worker down once when aborted and then stopped', async () => {
+    const controller = new AbortController();
+    const { worker, drain } = createWorker();
+    const runner = createRunner( worker, controller.signal );
+
+    const run = runner.start();
+    controller.abort();
+    const stopped = runner.stop();
+
+    expect( worker.shutdown ).toHaveBeenCalledOnce();
+
+    drain();
+
+    await expect( stopped ).resolves.toBeUndefined();
+    await run;
+  } );
+
+  it( 'rejects when the worker fails', async () => {
+    const error = new Error( 'poll failed' );
+    const { worker, fail } = createWorker();
+    const runner = createRunner( worker );
+
+    const run = runner.start();
+    const rejection = expect( run ).rejects.toBe( error );
+
+    fail( error );
+    await rejection;
+
+    expect( runner.running ).toBe( false );
+  } );
+
+  it( 'reports the failure through stop so a drain error is never silent', async () => {
+    const error = new Error( 'poll failed' );
+    const { worker, fail } = createWorker();
+    const runner = createRunner( worker );
+
+    const run = runner.start();
+    const rejection = expect( run ).rejects.toBe( error );
+
+    fail( error );
+    await rejection;
+
+    await expect( runner.stop() ).rejects.toBe( error );
+    expect( worker.shutdown ).not.toHaveBeenCalled();
+  } );
+
+  it( 'never rethrows a drain that fails after the signal aborted', async () => {
+    const error = new Error( 'drain failed' );
+    const controller = new AbortController();
+    const { worker, fail } = createWorker();
+    const runner = createRunner( worker, controller.signal );
+
+    const run = runner.start();
+    const rejection = expect( run ).rejects.toBe( error );
+
+    // Node rethrows a rejected promise returned by an event listener, so the abort listener must not return one
+    controller.abort();
+    fail( error );
+
+    await rejection;
+
+    expect( runner.running ).toBe( false );
+  } );
+
+  it( 'reports a drain that fails after stop was called', async () => {
+    const error = new Error( 'drain failed' );
+    const { worker, fail } = createWorker();
+    const runner = createRunner( worker );
+
+    const run = runner.start();
+    const rejection = expect( run ).rejects.toBe( error );
+    const stopped = runner.stop();
+
+    fail( error );
+
+    await expect( stopped ).rejects.toBe( error );
+    await rejection;
+  } );
+} );

package/src/worker/catalog_workflow/catalog_job.js

@@ -1,152 +0,0 @@
-import { Client, WorkflowNotFoundError } from '@temporalio/client';
-import { WorkflowExecutionAlreadyStartedError, WorkflowIdConflictPolicy } from '@temporalio/common';
-import { WORKFLOW_CATALOG } from '#consts';
-import { catalogId, taskQueue } from '../configs.js';
-import { createChildLogger } from '#logger';
-import { CancellablePromise } from '#helpers/promise';
-
-const log = createChildLogger( 'Catalog' );
-
-class CancellationError extends Error {};
-
-// Note, functions don't log on "WorkflowNotFound" errors,
-// because they happen when the catalog is not running at all.
-
-/** Make sure the latest version of the catalog workflow is running. Stateful. */
-export class CatalogJob {
-  #cancellation = new CancellablePromise();
-  #connection = null;
-  #namespace = null;
-  #catalog = null;
-  #catalogHash = null;
-
-  #running = false;
-  #executePromise = null;
-  #onErrorCb = null;
-  #error = null;
-
-  #runCancellable = promise => Promise
-    .race( [ promise, this.#cancellation.promise.then( () => {
-      throw new CancellationError();
-    } ) ] );
-
-  /** Check if the currently running catalog has the same hash as instance. */
-  async #checkCatalogIsTheSame( handle ) {
-    log.info( 'Checking running catalog hash against worker hash...' );
-    return this.#runCancellable( handle.describe() ).then( d => d.memo?.hash === this.#catalogHash ).catch( e => {
-      if ( e instanceof CancellationError ) {
-        throw e;
-      }
-      if ( !( e instanceof WorkflowNotFoundError ) ) {
-        log.warn( 'Error describing catalog workflow', { error: e.message } );
-      }
-      return false;
-    } );
-  };
-
-  /**  Check if the catalog workflow is running. */
-  async #checkCatalogRunning( handle ) {
-    log.info( 'Checking if the catalog workflow is running...' );
-    return this.#runCancellable( handle.describe() ).then( d => !d.closeTime ).catch( e => {
-      if ( e instanceof CancellationError ) {
-        throw e;
-      }
-      if ( !( e instanceof WorkflowNotFoundError ) ) {
-        log.warn( 'Error describing catalog workflow', { error: e.message } );
-      }
-      return false;
-    } );
-  };
-
-  /** Complete previous running catalog workflow. */
-  async #completePreviousCatalog( handle ) {
-    log.info( 'Completing previous catalog workflow...' );
-    return this.#runCancellable( handle.executeUpdate( 'complete', { args: [] } ) ).catch( e => {
-      if ( e instanceof CancellationError ) {
-        throw e;
-      }
-      if ( !( e instanceof WorkflowNotFoundError ) ) {
-        log.warn( 'Error completing previous catalog workflow', { error: e.message } );
-      }
-    } );
-  };
-
-  /** Run the sequence to start the catalog */
-  async #execute() {
-    const client = new Client( { connection: this.#connection, namespace: this.#namespace } );
-    const handle = client.workflow.getHandle( catalogId );
-
-    if ( await this.#checkCatalogRunning( handle ) ) {
-      if ( await this.#checkCatalogIsTheSame( handle ) ) {
-        log.info( 'Current catalog workflow hash matches worker, restart skipped' );
-        return;
-      }
-      await this.#completePreviousCatalog( handle );
-    }
-
-    const startArguments = {
-      taskQueue,
-      workflowId: catalogId,
-      workflowIdConflictPolicy: WorkflowIdConflictPolicy.FAIL,
-      args: [ this.#catalog ],
-      memo: {
-        workflowNames: this.#catalog.workflowNames,
-        hash: this.#catalogHash
-      }
-    };
-
-    log.info( 'Starting catalog workflow...' );
-    try {
-      await this.#runCancellable( client.workflow.start( WORKFLOW_CATALOG, startArguments ) );
-    } catch ( error ) {
-      // if the error was caused by the catalog existing and its hash is the same as the one from the worker, just ignore the error
-      if ( error instanceof WorkflowExecutionAlreadyStartedError && await this.#checkCatalogIsTheSame( handle ) ) {
-        log.info( 'Ignoring start error: it failed because execution already started but catalog hash matches worker' );
-      } else {
-        throw error;
-      }
-    }
-    log.info( 'Startup completed' );
-  }
-
-  constructor( { connection, namespace, catalog, catalogHash } ) {
-    this.#connection = connection;
-    this.#namespace = namespace;
-    this.#catalog = catalog;
-    this.#catalogHash = catalogHash;
-  }
-
-  onError( cb ) {
-    this.#onErrorCb = cb;
-  }
-
-  get running() {
-    return this.#running;
-  }
-
-  interrupt() {
-    if ( this.#running ) {
-      this.#cancellation.complete();
-    }
-    return this.#executePromise ?? Promise.resolve();
-  }
-
-  get error() {
-    return this.#error;
-  }
-
-  async run() {
-    this.#running = true;
-    this.#executePromise = this.#execute()
-      .catch( error => {
-        if ( !( error instanceof CancellationError ) ) {
-          this.#error = error;
-          this.#onErrorCb?.( error );
-        }
-      } )
-      .finally( () => {
-        this.#running = false;
-      } );
-    return this.#executePromise;
-  }
-};

package/src/worker/catalog_workflow/catalog_job.spec.js

@@ -1,218 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { WorkflowNotFoundError } from '@temporalio/client';
-import { WorkflowExecutionAlreadyStartedError, WorkflowIdConflictPolicy } from '@temporalio/common';
-import { CatalogJob } from './catalog_job.js';
-
-const {
-  catalogId,
-  describeMock,
-  executeUpdateMock,
-  mockLog,
-  taskQueue,
-  workflowStartMock
-} = vi.hoisted( () => ( {
-  catalogId: 'test-catalog',
-  describeMock: vi.fn(),
-  executeUpdateMock: vi.fn(),
-  mockLog: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-  taskQueue: 'test-queue',
-  workflowStartMock: vi.fn()
-} ) );
-
-vi.mock( '#logger', () => ( { createChildLogger: () => mockLog } ) );
-vi.mock( '#consts', () => ( { WORKFLOW_CATALOG: 'catalog' } ) );
-vi.mock( '../configs.js', () => ( { catalogId, taskQueue } ) );
-vi.mock( '@temporalio/client', async importOriginal => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    Client: vi.fn().mockImplementation( function () {
-      return {
-        workflow: {
-          start: workflowStartMock,
-          getHandle: () => ( { describe: describeMock, executeUpdate: executeUpdateMock } )
-        }
-      };
-    } )
-  };
-} );
-
-const mockConnection = {};
-const namespace = 'default';
-const catalog = { workflows: [], workflowNames: { workflow: 'workflow', alias: 'workflow' }, activities: {} };
-const catalogHash = 'catalog-hash';
-const startArguments = {
-  taskQueue,
-  workflowId: catalogId,
-  workflowIdConflictPolicy: WorkflowIdConflictPolicy.FAIL,
-  args: [ catalog ],
-  memo: {
-    workflowNames: catalog.workflowNames,
-    hash: catalogHash
-  }
-};
-
-const createJob = () => new CatalogJob( { connection: mockConnection, namespace, catalog, catalogHash } );
-
-const flushPromises = async () => Array
-  .from( { length: 10 } )
-  .reduce( promise => promise.then( () => Promise.resolve() ), Promise.resolve() );
-
-describe( 'CatalogJob', () => {
-  beforeEach( () => {
-    vi.clearAllMocks();
-    describeMock.mockResolvedValue( { closeTime: '2024-01-01T00:00:00Z' } );
-    executeUpdateMock.mockResolvedValue( undefined );
-    workflowStartMock.mockResolvedValue( undefined );
-  } );
-
-  it( 'completes a previous running stale catalog before starting the new workflow', async () => {
-    describeMock.mockResolvedValue( { closeTime: undefined, memo: { hash: 'old-catalog-hash' } } );
-    const job = createJob();
-
-    await job.run();
-
-    expect( describeMock ).toHaveBeenCalled();
-    expect( executeUpdateMock ).toHaveBeenCalledWith( 'complete', { args: [] } );
-    expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', startArguments );
-    expect( job.error ).toBeNull();
-    expect( job.running ).toBe( false );
-  } );
-
-  it( 'keeps the existing catalog workflow when the running hash matches', async () => {
-    describeMock.mockResolvedValue( { closeTime: undefined, memo: { hash: catalogHash } } );
-    const job = createJob();
-
-    await job.run();
-
-    expect( executeUpdateMock ).not.toHaveBeenCalled();
-    expect( workflowStartMock ).not.toHaveBeenCalled();
-    expect( mockLog.info ).toHaveBeenCalledWith( 'Current catalog workflow hash matches worker, restart skipped' );
-    expect( job.error ).toBeNull();
-  } );
-
-  it( 'starts the catalog workflow when no previous catalog exists', async () => {
-    describeMock.mockRejectedValue( new WorkflowNotFoundError( 'not found' ) );
-    const job = createJob();
-
-    await job.run();
-
-    expect( describeMock ).toHaveBeenCalled();
-    expect( executeUpdateMock ).not.toHaveBeenCalled();
-    expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', startArguments );
-    expect( mockLog.warn ).not.toHaveBeenCalled();
-  } );
-
-  it( 'starts the catalog workflow when the previous catalog is closed', async () => {
-    const job = createJob();
-
-    await job.run();
-
-    expect( describeMock ).toHaveBeenCalled();
-    expect( executeUpdateMock ).not.toHaveBeenCalled();
-    expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', startArguments );
-  } );
-
-  it( 'warns and continues when describing or completing the previous catalog fails', async () => {
-    const completeError = new Error( 'complete failed' );
-    describeMock.mockResolvedValue( { closeTime: undefined, memo: { hash: 'old-catalog-hash' } } );
-    executeUpdateMock.mockRejectedValue( completeError );
-    const job = createJob();
-
-    await job.run();
-
-    expect( mockLog.warn ).toHaveBeenCalledWith( 'Error completing previous catalog workflow', { error: completeError.message } );
-    expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', expect.any( Object ) );
-    expect( job.error ).toBeNull();
-  } );
-
-  it( 'ignores an already-started error when the running catalog hash matches', async () => {
-    const alreadyStartedError = new WorkflowExecutionAlreadyStartedError( 'already started', catalogId, 'catalog' );
-    describeMock
-      .mockRejectedValueOnce( new WorkflowNotFoundError( 'not found' ) )
-      .mockResolvedValueOnce( { closeTime: undefined, memo: { hash: catalogHash } } );
-    workflowStartMock.mockRejectedValue( alreadyStartedError );
-    const job = createJob();
-
-    await job.run();
-
-    expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', expect.any( Object ) );
-    expect( mockLog.info ).toHaveBeenCalledWith(
-      'Ignoring start error: it failed because execution already started but catalog hash matches worker'
-    );
-    expect( job.error ).toBeNull();
-  } );
-
-  it( 'stores start errors and calls the error callback', async () => {
-    const error = new Error( 'start failed' );
-    const onError = vi.fn();
-    workflowStartMock.mockRejectedValue( error );
-    const job = createJob();
-
-    job.onError( onError );
-    await job.run();
-
-    expect( job.error ).toBe( error );
-    expect( onError ).toHaveBeenCalledWith( error );
-    expect( job.running ).toBe( false );
-  } );
-
-  it( 'stores stale already-started errors and calls the error callback', async () => {
-    const alreadyStartedError = new WorkflowExecutionAlreadyStartedError( 'already started', catalogId, 'catalog' );
-    const onError = vi.fn();
-    describeMock
-      .mockRejectedValueOnce( new WorkflowNotFoundError( 'not found' ) )
-      .mockResolvedValueOnce( { closeTime: undefined, memo: { hash: 'old-catalog-hash' } } );
-    workflowStartMock.mockRejectedValue( alreadyStartedError );
-    const job = createJob();
-
-    job.onError( onError );
-    await job.run();
-
-    expect( job.error ).toBe( alreadyStartedError );
-    expect( onError ).toHaveBeenCalledWith( alreadyStartedError );
-    expect( job.running ).toBe( false );
-  } );
-
-  it( 'reports running while a catalog call is pending', async () => {
-    describeMock.mockReturnValue( new Promise( () => {} ) );
-    const job = createJob();
-
-    const run = job.run();
-    await flushPromises();
-
-    expect( job.running ).toBe( true );
-
-    await job.interrupt();
-    await run;
-
-    expect( job.running ).toBe( false );
-    expect( job.error ).toBeNull();
-  } );
-
-  it( 'interrupts pending catalog calls without storing an error or calling the callback', async () => {
-    const onError = vi.fn();
-    describeMock.mockReturnValue( new Promise( () => {} ) );
-    const job = createJob();
-
-    job.onError( onError );
-    const run = job.run();
-    await flushPromises();
-
-    const interrupt = job.interrupt();
-
-    await expect( interrupt ).resolves.toBeUndefined();
-    await expect( run ).resolves.toBeUndefined();
-    expect( job.error ).toBeNull();
-    expect( onError ).not.toHaveBeenCalled();
-    expect( job.running ).toBe( false );
-  } );
-
-  it( 'returns a resolved promise when interrupted before running', async () => {
-    const job = createJob();
-
-    await expect( job.interrupt() ).resolves.toBeUndefined();
-    expect( job.running ).toBe( false );
-    expect( job.error ).toBeNull();
-  } );
-} );