@outputai/core 0.12.1-next.a4a41b6.0 → 0.12.1-next.d1d27f7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.12.1-next.a4a41b6.0",
+  "version": "0.12.1-next.d1d27f7.0",
   "description": "The core module of the output framework",
   "type": "module",
   "engines": {

package/src/helpers/function.js

@@ -1,19 +1,3 @@
-/**
- * Returns a function that invokes the fn argument only once when called, further calls do nothing.
- * @param {Function} fn
- * @returns {Function}
- */
-export const runOnce = fn => {
-  const state = { executed: false, result: undefined };
-  return ( ...args ) => {
-    if ( !state.executed ) {
-      state.executed = true;
-      return state.result = fn( ...args );
-    }
-    return state.result;
-  };
-};
-
 /**
  * Calls a given function and in case it throws errors, returns `undefined`
  * @param {Function} fn

package/src/helpers/function.spec.js

@@ -1,51 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
-import { runOnce, tryOrUndefined } from './function.js';
-
-describe( 'runOnce', () => {
-  it( 'calls the wrapped function only once', () => {
-    const fn = vi.fn();
-    const once = runOnce( fn );
-
-    once();
-    once();
-    once();
-
-    expect( fn ).toHaveBeenCalledOnce();
-  } );
-
-  it( 'passes arguments and replays the first call result', () => {
-    const fn = vi.fn( ( a, b ) => a + b );
-    const once = runOnce( fn );
-
-    expect( once( 2, 3 ) ).toBe( 5 );
-    expect( once( 4, 5 ) ).toBe( 5 );
-    expect( once( 6, 7 ) ).toBe( 5 );
-    expect( fn ).toHaveBeenCalledWith( 2, 3 );
-    expect( fn ).toHaveBeenCalledOnce();
-  } );
-
-  it( 'replays the first returned promise', () => {
-    const result = Promise.resolve( 'done' );
-    const fn = vi.fn( () => result );
-    const once = runOnce( fn );
-
-    expect( once() ).toBe( result );
-    expect( once() ).toBe( result );
-    expect( fn ).toHaveBeenCalledOnce();
-  } );
-
-  it( 'does not retry when the first call throws', () => {
-    const error = new Error( 'boom' );
-    const fn = vi.fn( () => {
-      throw error;
-    } );
-    const once = runOnce( fn );
-
-    expect( () => once() ).toThrow( error );
-    expect( once() ).toBeUndefined();
-    expect( fn ).toHaveBeenCalledOnce();
-  } );
-} );
+import { tryOrUndefined } from './function.js';
 
 describe( 'tryOrUndefined', () => {
   it( 'returns the invoked function result', () => {

package/src/helpers/promise.js

@@ -1,29 +1,11 @@
-/**
- * Builds a promise that can be resolved from the outside.
- */
-export class CancellablePromise {
-  #promise = null;
-  #complete = null;
-  #completed = false;
+import { setTimeout as delay } from 'node:timers/promises';
 
-  constructor() {
-    this.#promise = new Promise( resolve => {
-      this.#complete = () => {
-        resolve();
-        this.#completed = true;
-      };
-    } );
-  }
-  /** Retrieves the promise */
-  get promise() {
-    return this.#promise;
-  }
-  /** Returns whether the promise is resolved or not */
-  get completed() {
-    return this.#completed;
-  }
-  /** Resolves the promise */
-  complete() {
-    this.#complete();
+export const sleepCancellable = async ( timeoutMs, signal ) => {
+  try {
+    await delay( timeoutMs, true, { ref: false, signal } );
+  } catch ( error ) {
+    if ( error?.name !== 'AbortError' ) {
+      throw error;
+    }
   }
 };

package/src/helpers/promise.spec.js

@@ -1,35 +1,62 @@
 import { describe, it, expect, vi } from 'vitest';
-import { CancellablePromise } from './promise.js';
+import { sleepCancellable } from './promise.js';
 
-describe( 'CancellablePromise', () => {
-  it( 'exposes a pending promise until it is completed', async () => {
-    const cancellable = new CancellablePromise();
-    const onComplete = vi.fn();
+// Long enough that a sleep reaching it means the abort was not honored and the test times out.
+const neverElapses = 60000;
+
+describe( 'sleepCancellable', () => {
+  it( 'resolves only once the timeout elapses', async () => {
+    const order = [];
+    const sleeping = sleepCancellable( 10 ).then( () => order.push( 'slept' ) );
 
-    cancellable.promise.then( onComplete );
     await Promise.resolve();
+    expect( order ).toEqual( [] );
+
+    await sleeping;
+    expect( order ).toEqual( [ 'slept' ] );
+  } );
 
-    expect( cancellable.completed ).toBe( false );
-    expect( onComplete ).not.toHaveBeenCalled();
+  it( 'resolves without a signal', async () => {
+    await expect( sleepCancellable( 10 ) ).resolves.toBeUndefined();
+  } );
 
-    cancellable.complete();
-    await cancellable.promise;
+  it( 'resolves immediately when the signal is already aborted', async () => {
+    const controller = new AbortController();
+    controller.abort();
 
-    expect( cancellable.completed ).toBe( true );
-    expect( onComplete ).toHaveBeenCalledOnce();
+    await expect( sleepCancellable( neverElapses, controller.signal ) ).resolves.toBeUndefined();
   } );
 
-  it( 'can be completed multiple times without resolving again', async () => {
-    const cancellable = new CancellablePromise();
-    const onComplete = vi.fn();
+  it( 'resolves as soon as the signal aborts mid sleep', async () => {
+    const controller = new AbortController();
+    const sleeping = sleepCancellable( neverElapses, controller.signal );
 
-    cancellable.promise.then( onComplete );
-    cancellable.complete();
-    cancellable.complete();
-    await cancellable.promise;
-    await Promise.resolve();
+    controller.abort();
+
+    await expect( sleeping ).resolves.toBeUndefined();
+  } );
+
+  it( 'swallows the abort reason instead of rejecting with it', async () => {
+    const controller = new AbortController();
+    const sleeping = sleepCancellable( neverElapses, controller.signal );
+
+    controller.abort( new Error( 'shutting down' ) );
+
+    await expect( sleeping ).resolves.toBeUndefined();
+  } );
+
+  it( 'rethrows a rejection that is not an abort', async () => {
+    const failure = new Error( 'timer failed' );
+    vi.doMock( 'node:timers/promises', () => ( { setTimeout: () => Promise.reject( failure ) } ) );
+    vi.resetModules();
+
+    try {
+      const { sleepCancellable: sleeping } = await import( './promise.js' );
 
-    expect( cancellable.completed ).toBe( true );
-    expect( onComplete ).toHaveBeenCalledOnce();
+      await expect( sleeping( 10 ) ).rejects.toBe( failure );
+    } finally {
+      vi.doUnmock( 'node:timers/promises' );
+      vi.resetModules();
+    }
   } );
 } );

package/src/hooks/pending_hooks.js

@@ -3,17 +3,17 @@ import { createChildLogger } from '#logger';
 export const pendingHooks = new Set();
 
 const log = createChildLogger( 'Hooks' );
-const flushTimeoutMs = 30_000;
 
 /**
  * Await all pending hooks to flush for a certain time
+ * @param {number} timeoutMs - How long to await the pending hooks before giving up
  */
-export const flushPendingHooks = async () => {
+export const flushPendingHooks = async timeoutMs => {
   const state = { timeout: null };
   try {
     const flushed = await Promise.race( [
       Promise.allSettled( [ ...pendingHooks ] ).then( _ => true ),
-      new Promise( r => state.timeout = setTimeout( () => r( false ), flushTimeoutMs ) )
+      new Promise( r => state.timeout = setTimeout( () => r( false ), timeoutMs ) )
     ] );
     if ( !flushed ) {
       log.warn( 'Some hook callbacks exceeded the timeout and will not be awaited', { count: pendingHooks.size } );

package/src/hooks/pending_hooks.spec.js

@@ -24,7 +24,7 @@ describe( 'pending hooks', () => {
     } );
     pendingHooks.add( hookPromise );
 
-    const flushPromise = flushPendingHooks();
+    const flushPromise = flushPendingHooks( 5000 );
     const state = { flushed: false };
     flushPromise.then( () => {
       state.flushed = true;
@@ -42,8 +42,8 @@ describe( 'pending hooks', () => {
     vi.useFakeTimers();
     pendingHooks.add( new Promise( () => {} ) );
 
-    const flushPromise = flushPendingHooks();
-    await vi.advanceTimersByTimeAsync( 30_000 );
+    const flushPromise = flushPendingHooks( 5000 );
+    await vi.advanceTimersByTimeAsync( 5000 );
 
     await expect( flushPromise ).resolves.toBeUndefined();
   } );
@@ -53,8 +53,8 @@ describe( 'pending hooks', () => {
     pendingHooks.add( new Promise( () => {} ) );
     pendingHooks.add( new Promise( () => {} ) );
 
-    const flushPromise = flushPendingHooks();
-    await vi.advanceTimersByTimeAsync( 30_000 );
+    const flushPromise = flushPendingHooks( 5000 );
+    await vi.advanceTimersByTimeAsync( 5000 );
     await flushPromise;
 
     expect( logMock.warn ).toHaveBeenCalledWith( expect.any( String ), { count: 2 } );

package/src/worker/catalog_workflow/catalog_publisher.js

@@ -0,0 +1,149 @@
+import { Client, WorkflowNotFoundError } from '@temporalio/client';
+import { WorkflowExecutionAlreadyStartedError, WorkflowIdConflictPolicy } from '@temporalio/common';
+import { WORKFLOW_CATALOG } from '#consts';
+import { catalogId as workflowId, taskQueue } from '../configs.js';
+import { createChildLogger } from '#logger';
+import { sleepCancellable } from '#helpers/promise';
+import { serializeError } from '#helpers/error_serializer';
+
+const log = createChildLogger( 'Catalog' );
+
+const MAX_RETRIES = 2;
+const RETRY_DELAY = 10_000;
+
+// The default 10s is not enough for a cold worker: the workflow bundle takes 7-8s to activate,
+// so the first workflow task can exceed it and get retried. Temporal caps this at 120s.
+const WORKFLOW_TASK_TIMEOUT = 30_000;
+
+/** Make sure the latest version of the catalog workflow is running. Stateful. */
+export class CatalogPublisher {
+  #connection = null;
+  #namespace = null;
+  #catalog = null;
+  #catalogHash = null;
+  #client = null;
+  #signal = null;
+
+  #abortCtrl = new AbortController();
+  #running = false;
+  #execution = null;
+
+  async #describe() {
+    log.info( 'Checking running catalog hash against worker hash...' );
+
+    try {
+      const description = await this.#client.workflow.getHandle( workflowId ).describe();
+      return description.closeTime ? null : {
+        runId: description.runId,
+        hash: description.memo?.hash
+      };
+    } catch ( error ) {
+      if ( !( error instanceof WorkflowNotFoundError ) ) {
+        log.warn( 'Ignoring error while describing catalog workflow', { error: serializeError( error, { dropKeys: [ 'stack' ] } ) } );
+      }
+      return null;
+    }
+  };
+
+  async #terminate( runId ) {
+    log.info( 'Terminating previous catalog workflow...' );
+
+    try {
+      const handle = await this.#client.workflow.getHandle( workflowId, runId );
+      await handle.terminate( `Systematic terminating. Superseded by catalog ${this.#catalogHash}` );
+    } catch ( error ) {
+      if ( !( error instanceof WorkflowNotFoundError ) ) {
+        log.warn( 'Ignoring error while terminating previous catalog workflow', { error: serializeError( error, { dropKeys: [ 'stack' ] } ) } );
+      }
+    }
+  };
+
+  async #start() {
+    log.info( 'Starting catalog workflow...' );
+
+    try {
+      await this.#client.workflow.start( WORKFLOW_CATALOG, {
+        taskQueue,
+        workflowId,
+        workflowIdConflictPolicy: WorkflowIdConflictPolicy.FAIL,
+        workflowTaskTimeout: WORKFLOW_TASK_TIMEOUT,
+        args: [ this.#catalog ],
+        memo: {
+          workflowNames: this.#catalog.workflowNames,
+          hash: this.#catalogHash
+        }
+      } );
+      return true;
+    } catch ( error ) {
+      // if catalog exists and its hash is the same as the one from the worker, ignore the error
+      if ( error instanceof WorkflowExecutionAlreadyStartedError ) {
+        const description = await this.#describe();
+        if ( description && description.hash === this.#catalogHash ) {
+          return false;
+        }
+      }
+
+      throw error;
+    }
+  }
+
+  /** Run the sequence to start the catalog */
+  async #execute( signal, retries = 0 ) {
+    if ( signal.aborted ) {
+      return;
+    }
+
+    try {
+      const description = await this.#describe();
+
+      if ( description ) {
+        if ( description.hash === this.#catalogHash ) {
+          log.info( 'Current catalog workflow hash matches worker, restart skipped' );
+          return;
+        }
+        await this.#terminate( description.runId );
+      }
+
+      const success = await this.#start();
+      log.info( success ? 'Catalog workflow started' : 'Found a catalog workflow with matching hashes, start skipped' );
+    } catch ( error ) {
+      if ( retries < MAX_RETRIES ) {
+        log.warn( 'Error while starting catalog workflow, retrying...', { error: serializeError( error, { dropKeys: [ 'stack' ] } ) } );
+        await sleepCancellable( RETRY_DELAY, signal );
+        await this.#execute( signal, retries + 1 );
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  constructor( { connection, namespace, catalog, catalogHash, signal } ) {
+    this.#connection = connection;
+    this.#namespace = namespace;
+    this.#catalog = catalog;
+    this.#catalogHash = catalogHash;
+    this.#signal = signal;
+    this.#client = new Client( { connection: this.#connection, namespace: this.#namespace } );
+  }
+
+  get running() {
+    return this.#running;
+  }
+
+  run() {
+    if ( this.#execution ) {
+      return this.#execution;
+    }
+
+    const signal = AbortSignal.any( [ this.#signal, this.#abortCtrl.signal ] );
+
+    this.#running = true;
+    this.#execution = this.#execute( signal ).finally( _ => this.#running = false );
+    return this.#execution;
+  }
+
+  interrupt() {
+    this.#abortCtrl.abort();
+    return this.#execution ?? Promise.resolve();
+  }
+};