@outputai/core 0.13.1-next.357174a.0 → 0.13.1-next.38c895c.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.13.1-next.357174a.0",
+  "version": "0.13.1-next.38c895c.0",
   "description": "The core module of the output framework",
   "type": "module",
   "engines": {

package/src/helpers/error_serializer.js

@@ -61,6 +61,18 @@ export const flattenPrototypeChain = ( target, depth = 0, result = [], maxDepth
   !target || depth >= maxDepth ? result :
     flattenPrototypeChain( Object.getPrototypeOf( target ), depth + 1, result.concat( target ), maxDepth );
 
+// Realm agnostic check for DOMException, works for AbortController errors even on environments without DOMExceptions
+export const isDomException = target => Object.prototype.toString.call( target ) === '[object DOMException]';
+
+const evaluateSpecialObjectsKeysList = target => {
+  // DOMException has a special serialization because it carries a bunch of legacy constant fields
+  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException
+  if ( isDomException( target ) ) {
+    return [ 'name', 'message', 'code', 'cause', 'stack' ];
+  }
+  return null;
+};
+
 /**
  * Define the best "name" for an Error object
  * Rules: Assigned .name property > inherited .name if not "Error" > constructor.name
@@ -176,6 +188,8 @@ const serializeValue = ( target, options, state = { depth: 0, seen: new GlobalCo
     const prototypes = flattenPrototypeChain( target );
     const receiver = target;
 
+    const strictKeysList = evaluateSpecialObjectsKeysList( target );
+
     const props = prototypes.reduce( ( projection, proto ) => {
       if ( Object.keys( projection ).length > MAX_OBJECT_KEYS ) {
         return projection;
@@ -187,6 +201,10 @@ const serializeValue = ( target, options, state = { depth: 0, seen: new GlobalCo
           continue;
         }
 
+        if ( Array.isArray( strictKeysList ) && !strictKeysList.includes( key ) ) {
+          continue;
+        }
+
         const sanitizedKey = truncateString( key, MAX_OBJECT_KEY_LEN );
         if ( Object.hasOwn( projection, sanitizedKey ) ) { // do not overwrite similar keys
           continue;
@@ -212,7 +230,7 @@ const serializeValue = ( target, options, state = { depth: 0, seen: new GlobalCo
     if ( !options.ignoredKeys.includes( 'name' ) && target instanceof Error ) {
       const name = resolveErrorName( target );
       if ( name !== undefined ) {
-        props.name = name;
+        props.name = typeof name === 'string' ? truncateString( name ) : serializeValue( name, options, nextState );
       }
     }
 

package/src/helpers/error_serializer.spec.js

@@ -1,6 +1,7 @@
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 import {
   flattenPrototypeChain,
+  isDomException,
   resolveErrorName,
   serializeError,
   truncateArray,
@@ -43,6 +44,33 @@ describe( 'error serializer helpers', () => {
     } );
   } );
 
+  describe( 'isDomException', () => {
+    afterEach( () => {
+      vi.unstubAllGlobals();
+    } );
+
+    it( 'detects DOMExceptions, including abort reasons, and rejects lookalikes', () => {
+      expect( isDomException( new DOMException( 'aborted', 'AbortError' ) ) ).toBe( true );
+      expect( isDomException( AbortSignal.abort().reason ) ).toBe( true );
+      expect( isDomException( new Error( 'aborted' ) ) ).toBe( false );
+      expect( isDomException( { name: 'AbortError', code: 20 } ) ).toBe( false );
+      expect( isDomException( undefined ) ).toBe( false );
+      expect( isDomException( null ) ).toBe( false );
+    } );
+
+    it( 'detects DOMExceptions where the global is unavailable, as in the workflow sandbox', () => {
+      const error = new DOMException( 'aborted', 'AbortError' );
+      vi.stubGlobal( 'DOMException', undefined );
+
+      expect( isDomException( error ) ).toBe( true );
+      expect( serializeError( error, { dropKeys: [ 'stack' ] } ) ).toEqual( {
+        name: 'AbortError',
+        message: 'aborted',
+        code: 20
+      } );
+    } );
+  } );
+
   describe( 'resolveErrorName', () => {
     it( 'uses explicit, inherited, and constructor names in precedence order', () => {
       class ConstructorNamedError extends Error {}
@@ -194,6 +222,33 @@ describe( 'serializeError', () => {
     expect( serializeError( /request-\d+/gi ) ).toBe( '/request-\\d+/gi' );
   } );
 
+  it( 'serializes DOMException values without the legacy prototype constants', () => {
+    const error = new DOMException( 'Cancelled by caller', 'AbortError' );
+
+    expect( serializeError( error ) ).toEqual( {
+      name: 'AbortError',
+      message: 'Cancelled by caller',
+      code: 20,
+      stack: expect.stringContaining( 'AbortError: Cancelled by caller' )
+    } );
+    expect( serializeError( error, { dropKeys: [ /stack/ ] } ) ).toEqual( {
+      name: 'AbortError',
+      message: 'Cancelled by caller',
+      code: 20
+    } );
+  } );
+
+  it( 'marks circular DOMException fields and drops properties outside the allowed list', () => {
+    const error = new DOMException( 'aborted', 'AbortError' );
+    Object.defineProperty( error, 'message', { value: error, enumerable: true } );
+    error.attempt = 2;
+
+    expect( serializeError( { reason: error, sibling: 'preserved' }, { dropKeys: [ 'stack' ] } ) ).toEqual( {
+      reason: { name: 'AbortError', message: '[Circular Reference]', code: 20 },
+      sibling: 'preserved'
+    } );
+  } );
+
   it( 'serializes bigint values with an n suffix', () => {
     expect( serializeError( 42n ) ).toBe( '42n' );
     expect( serializeError( -42n ) ).toBe( '-42n' );
@@ -298,6 +353,17 @@ describe( 'serializeError', () => {
     expect( serialized['...'] ).toBe( '[Maximum Object Properties Reached]' );
   } );
 
+  it( 'serializes the resolved error name instead of returning it raw', () => {
+    const circular = new Error( 'boom' );
+    circular.name = circular;
+    const oversized = new Error( 'boom' );
+    oversized.name = 'n'.repeat( 16_385 );
+
+    expect( serializeError( circular, { dropKeys: [ 'stack' ] } ).name ).toBe( '[Circular Reference]' );
+    expect( serializeError( oversized, { dropKeys: [ 'stack' ] } ).name )
+      .toBe( `${'n'.repeat( 16_384 )}... [1 more characters omitted]` );
+  } );
+
   it( 'retains error identity when properties reach the object limit', () => {
     class DetailedError extends Error {}
     const error = new DetailedError( 'failed' );

package/src/worker/index.js

@@ -1,4 +1,4 @@
-import { Worker, NativeConnection, GracefulShutdownPeriodExpiredError } from '@temporalio/worker';
+import { Worker, NativeConnection } from '@temporalio/worker';
 import * as configs from './configs.js';
 import { loadActivities } from './loader/activities.js';
 import { loadWorkflows } from './loader/workflows.js';
@@ -174,11 +174,10 @@ execute()
     log.info( 'Flushing hook callbacks...' );
     await flushPendingHooks( hookFlushTimeoutMs );
 
-    // An expired drain is the bound working as intended, not a worker failure, so it keeps exit code 0.
-    const workerFailedToStop = shutdownFailures.some( v => v.service === 'worker' && !( v.error instanceof GracefulShutdownPeriodExpiredError ) );
+    const workerFailedToStop = shutdownFailures.some( v => v.service === 'worker' );
     const exitCode = workerFailedToStop || hasError ? 1 : 0;
     setTimeout( () => {
-      log.info( 'Bye' );
+      log.info( 'Bye', { exitCode } );
       process.exit( exitCode );
     } );
   } );

package/src/worker/index.spec.js

@@ -8,7 +8,6 @@ const {
   connectionMonitorInstance,
   createCatalogMock,
   flushPendingHooksMock,
-  GracefulShutdownPeriodExpiredError,
   hashSourceCodeMock,
   initInterceptorsMock,
   interruption,
@@ -118,11 +117,6 @@ const {
     name = 'UncaughtError';
   };
 
-  /** Stands in for the Temporal error thrown when the drain outlives the force time */
-  class GracefulShutdownPeriodExpiredError extends Error {
-    name = 'GracefulShutdownPeriodExpiredError';
-  };
-
   const interruption = { controller: null, KillSignError, UncaughtError };
 
   return {
@@ -132,7 +126,6 @@ const {
     connectionMonitorInstance,
     createCatalogMock: vi.fn().mockReturnValue( { workflowNames: [ 'demo' ] } ),
     flushPendingHooksMock: vi.fn().mockResolvedValue( undefined ),
-    GracefulShutdownPeriodExpiredError,
     hashSourceCodeMock: vi.fn().mockResolvedValue( 'catalog-hash' ),
     initInterceptorsMock: vi.fn().mockReturnValue( [] ),
     interruption,
@@ -204,8 +197,7 @@ vi.mock( './catalog_workflow/catalog_publisher.js', () => ( {
 vi.mock( './shutdown.js', () => ( { shutdownServices: shutdownServicesMock } ) );
 vi.mock( '@temporalio/worker', () => ( {
   NativeConnection: { connect: vi.fn().mockResolvedValue( mockConnection ) },
-  Worker: { create: vi.fn().mockResolvedValue( mockWorker ) },
-  GracefulShutdownPeriodExpiredError
+  Worker: { create: vi.fn().mockResolvedValue( mockWorker ) }
 } ) );
 
 const importWorker = async () => {
@@ -397,7 +389,7 @@ describe( 'worker/index', () => {
       } );
       expect( mockLog.error ).not.toHaveBeenCalled();
       expect( mainEventBusMock.emit ).not.toHaveBeenCalledWith( BusEventType.RUNTIME_ERROR, expect.anything() );
-      expect( mockLog.info ).toHaveBeenCalledWith( 'Bye' );
+      expect( mockLog.info ).toHaveBeenCalledWith( 'Bye', { exitCode: 0 } );
       expect( process.exit ).toHaveBeenCalledWith( 0 );
     } );
 
@@ -412,18 +404,6 @@ describe( 'worker/index', () => {
       expect( process.exit ).toHaveBeenCalledWith( 0 );
     } );
 
-    it( 'still exits cleanly when the drain outlived the force time', async () => {
-      await bootWorker();
-      const error = new GracefulShutdownPeriodExpiredError( 'Timed out while waiting for worker to shutdown gracefully' );
-      shutdownServicesMock.mockResolvedValueOnce( [ { service: 'worker', error } ] );
-
-      interruption.controller.abort( new interruption.KillSignError( 'SIGTERM' ) );
-      await waitForExit();
-
-      expect( mockLog.error ).not.toHaveBeenCalled();
-      expect( process.exit ).toHaveBeenCalledWith( 0 );
-    } );
-
     it( 'does not report the worker as terminated when a signal ended the run', async () => {
       await bootWorker();
 
@@ -482,7 +462,6 @@ describe( 'worker/index', () => {
 
       expect( process.exit ).toHaveBeenCalledWith( 1 );
     } );
-
     it( 'reports a lost connection and shuts down', async () => {
       const error = new Error( 'connection lost' );
       await bootWorker();