@outputai/core 0.10.1-next.be4ec7f.0 → 0.10.1-next.c717e35.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.10.1-next.be4ec7f.0",
+  "version": "0.10.1-next.c717e35.0",
   "description": "The core module of the output framework",
   "type": "module",
   "engines": {
@@ -41,17 +41,17 @@
     "@babel/parser": "7.29.2",
     "@babel/traverse": "7.29.0",
     "@babel/types": "7.29.0",
-    "@temporalio/activity": "1.17.0",
-    "@temporalio/client": "1.17.0",
-    "@temporalio/common": "1.17.0",
-    "@temporalio/worker": "1.17.0",
-    "@temporalio/workflow": "1.17.0",
+    "@temporalio/activity": "1.20.3",
+    "@temporalio/client": "1.20.3",
+    "@temporalio/common": "1.20.3",
+    "@temporalio/worker": "1.20.3",
+    "@temporalio/workflow": "1.20.3",
     "decimal.js": "10.6.0",
     "folder-hash": "4.1.3",
     "json-stream-stringify": "3.1.6",
     "redis": "5.12.1",
     "stacktrace-parser": "0.1.11",
-    "undici": "8.5.0",
+    "undici": "8.9.0",
     "winston": "3.19.0"
   },
   "peerDependencies": {

package/src/interface/index.js

@@ -8,7 +8,7 @@ import {
 import { evaluator } from './evaluator.js';
 import { step } from './step.js';
 import { workflow } from './workflow.js';
-import { executeInParallel } from './workflow_utils.js';
+import { executeInParallel, hasErrorType } from './workflow_utils.js';
 import { sendHttpRequest, sendPostRequestAndAwaitWebhook } from './webhook.js';
 import { Logger } from './logger.js';
 
@@ -23,6 +23,7 @@ export {
   EvaluationVerdictResult,
   EvaluationFeedback,
   executeInParallel,
+  hasErrorType,
   sendHttpRequest,
   sendPostRequestAndAwaitWebhook
 };

package/src/interface/workflow_utils.d.ts

@@ -74,3 +74,18 @@ export declare function executeInParallel<T extends readonly ( () => Promise<unk
     onJobCompleted?: ( result: ParallelResults<T>[number] ) => void;
   }
 ): Promise<ParallelResults<T>>;
+
+/**
+ * Checks whether an error or any error in its cause chain matches an Error class.
+ *
+ * Temporal Application Failures are matched through their serialized `type`,
+ * in addition to standard `instanceof` and `name` checks.
+ *
+ * @param error - Error or failure chain to inspect
+ * @param ErrorType - Error class to match
+ * @returns Whether the Error class appears in the chain
+ */
+export declare function hasErrorType<T extends Error>(
+  error: unknown,
+  ErrorType: abstract new ( ...args: never[] ) => T
+): boolean;

package/src/interface/workflow_utils.js

@@ -48,3 +48,22 @@ export const executeInParallel = async ( { jobs, concurrency = Infinity, onJobCo
 
   return results.sort( ( a, b ) => a.index - b.index );
 };
+
+/**
+ * Check if an error, or any parts of its cause chain are instances of a given Error class.
+ * Also check .name and .type
+ *
+ * @param {Error} error
+ * @param {Error} ErrorType
+ * @returns {boolean}
+ */
+export const hasErrorType = ( error, ErrorType, depth = 0 ) => {
+  if ( depth > 20 || typeof ErrorType !== 'function' ) {
+    return false;
+  }
+  const expectedType = ErrorType.name;
+  if ( error instanceof ErrorType || error?.type === expectedType || error?.name === expectedType || error === expectedType ) {
+    return true;
+  }
+  return error?.cause ? hasErrorType( error.cause, ErrorType, depth + 1 ) : false;
+};

package/src/interface/workflow_utils.spec.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
-import { executeInParallel } from './workflow_utils.js';
+import { hasErrorType, executeInParallel } from './workflow_utils.js';
 
 describe( 'executeInParallel', () => {
   it( 'returns empty array for empty jobs', async () => {
@@ -188,3 +188,84 @@ describe( 'executeInParallel', () => {
     ] );
   } );
 } );
+
+describe( 'hasErrorType', () => {
+  class FooError extends Error {}
+
+  it( 'matches a direct error instance', () => {
+    expect( hasErrorType( new FooError( 'foo' ), FooError ) ).toBe( true );
+  } );
+
+  it( 'matches an error instance in the cause chain', () => {
+    const error = new Error( 'outer', {
+      cause: new Error( 'middle', {
+        cause: new FooError( 'foo' )
+      } )
+    } );
+
+    expect( hasErrorType( error, FooError ) ).toBe( true );
+  } );
+
+  it( 'matches Temporal ApplicationFailure type in the cause chain', () => {
+    const applicationFailure = Object.assign( new Error( 'foo' ), {
+      name: 'ApplicationFailure',
+      type: 'FooError'
+    } );
+    const activityFailure = Object.assign( new Error( 'Activity execution failed', {
+      cause: applicationFailure
+    } ), {
+      name: 'ActivityFailure'
+    } );
+
+    expect( hasErrorType( activityFailure, FooError ) ).toBe( true );
+  } );
+
+  it( 'matches a serialized error name', () => {
+    const error = Object.assign( new Error( 'foo' ), { name: 'FooError' } );
+
+    expect( hasErrorType( error, FooError ) ).toBe( true );
+  } );
+
+  it( 'matches an error serialized as its type name', () => {
+    expect( hasErrorType( 'FooError', FooError ) ).toBe( true );
+  } );
+
+  it( 'matches an error type in a plain object cause chain', () => {
+    const error = {
+      name: 'ActivityFailure',
+      cause: {
+        name: 'ApplicationFailure',
+        type: 'FooError'
+      }
+    };
+
+    expect( hasErrorType( error, FooError ) ).toBe( true );
+  } );
+
+  it.each( [ null, undefined, '', 42, false ] )( 'returns false for unsupported error value %j', error => {
+    expect( hasErrorType( error, FooError ) ).toBe( false );
+  } );
+
+  it( 'returns false when ErrorType is not a class', () => {
+    expect( hasErrorType( new FooError( 'foo' ), null ) ).toBe( false );
+  } );
+
+  it( 'returns false when the requested error type is absent', () => {
+    const error = new Error( 'outer', { cause: new TypeError( 'inner' ) } );
+
+    expect( hasErrorType( error, FooError ) ).toBe( false );
+  } );
+
+  it( 'keeps plain Error matching backwards compatible', () => {
+    expect( hasErrorType( new Error( 'foo' ), Error ) ).toBe( true );
+  } );
+
+  it( 'stops traversing cause chains after the depth limit', () => {
+    const createCauseChain = depth => depth === 20 ?
+      new FooError( 'foo' ) :
+      new Error( `depth-${depth}`, { cause: createCauseChain( depth + 1 ) } );
+    const root = new Error( 'root', { cause: createCauseChain( 0 ) } );
+
+    expect( hasErrorType( root, FooError ) ).toBe( false );
+  } );
+} );