@outputai/core 0.10.1-next.b7b2fbe.0 → 0.10.1-next.bf95a6f.0

package/src/helpers/errors.spec.js

@@ -1,89 +1,45 @@
 import { describe, expect, it } from 'vitest';
-import { ApplicationFailure } from '@temporalio/common';
-import { buildApplicationFailureWithDetails } from './errors.js';
+import { inheritsFromAnyNamedType } from './errors.js';
 
-class CustomFailure extends Error {}
+describe( 'inheritsFromAnyNamedType', () => {
+  class BaseFailure extends Error {}
+  class DomainFailure extends BaseFailure {}
+  class RequestFailure extends DomainFailure {}
+  class UnrelatedFailure extends Error {}
 
-describe( 'buildApplicationFailureWithDetails', () => {
-  it( 'wraps a regular error in an ApplicationFailure with appended details', () => {
-    const error = new Error( 'step failed' );
-    const info = { aggregations: { cost: { total: 1 } } };
+  it( 'matches exact, parent, and grandparent constructor names', () => {
+    const error = new RequestFailure( 'request failed' );
 
-    const failure = buildApplicationFailureWithDetails( error, info );
-
-    expect( failure ).toBeInstanceOf( ApplicationFailure );
-    expect( failure ).toMatchObject( {
-      message: 'step failed',
-      type: 'Error',
-      nonRetryable: false,
-      details: [ info ],
-      cause: error
-    } );
-  } );
-
-  it( 'uses the original constructor name for custom errors', () => {
-    const error = new CustomFailure( 'custom failed' );
-    const info = { trace: { destinations: { local: '/tmp/trace' } } };
-
-    const failure = buildApplicationFailureWithDetails( error, info );
-
-    expect( failure ).toMatchObject( {
-      message: 'custom failed',
-      type: 'CustomFailure',
-      details: [ info ],
-      cause: error
-    } );
+    expect( inheritsFromAnyNamedType( error, [ 'RequestFailure' ] ) ).toBe( true );
+    expect( inheritsFromAnyNamedType( error, [ 'DomainFailure' ] ) ).toBe( true );
+    expect( inheritsFromAnyNamedType( error, [ 'BaseFailure' ] ) ).toBe( true );
+    expect( inheritsFromAnyNamedType( error, [ 'OtherFailure', 'BaseFailure' ] ) ).toBe( true );
   } );
 
-  it( 'preserves existing details and appends new info without mutating the original error', () => {
-    const existingDetails = [ { domain: { reason: 'bad-input' } } ];
-    const error = new Error( 'step failed' );
-    error.details = existingDetails;
-    const info = { aggregations: { httpRequests: { total: 1 } } };
-
-    const failure = buildApplicationFailureWithDetails( error, info );
-
-    expect( failure.details ).toEqual( [
-      { domain: { reason: 'bad-input' } },
-      info
-    ] );
-    expect( error.details ).toBe( existingDetails );
-    expect( error.details ).toEqual( [ { domain: { reason: 'bad-input' } } ] );
+  it( 'does not match unrelated or descendant constructor names', () => {
+    expect( inheritsFromAnyNamedType( new RequestFailure(), [ 'UnrelatedFailure' ] ) ).toBe( false );
+    expect( inheritsFromAnyNamedType( new BaseFailure(), [ 'RequestFailure' ] ) ).toBe( false );
+    expect( inheritsFromAnyNamedType( new UnrelatedFailure(), [ 'BaseFailure' ] ) ).toBe( false );
   } );
 
-  it( 'ignores non-array details on the original error', () => {
-    const error = new Error( 'step failed' );
-    error.details = { domain: { reason: 'bad-input' } };
-    const info = { aggregations: { tokens: { total: 3 } } };
-
-    const failure = buildApplicationFailureWithDetails( error, info );
+  it( 'ignores a spoofed own constructor property', () => {
+    const error = new RequestFailure();
+    Object.defineProperty( error, 'constructor', {
+      value: { name: 'SpoofedFailure' }
+    } );
 
-    expect( failure.details ).toEqual( [ info ] );
+    expect( inheritsFromAnyNamedType( error, [ 'SpoofedFailure' ] ) ).toBe( false );
+    expect( inheritsFromAnyNamedType( error, [ 'RequestFailure' ] ) ).toBe( true );
   } );
 
-  it( 'preserves ApplicationFailure type, nonRetryable flag, and details while avoiding self-cause', () => {
-    const original = ApplicationFailure.create( {
-      message: 'application failed',
-      type: 'DomainFailure',
-      nonRetryable: true,
-      details: [ { domain: { reason: 'bad-input' } } ]
-    } );
-    const info = { aggregations: { cost: { total: 2 } } };
-
-    const failure = buildApplicationFailureWithDetails( original, info );
+  it( 'rejects empty names and invalid values without false positives', () => {
+    const unnamedConstructor = function NamedConstructor() {};
+    Object.defineProperty( unnamedConstructor, 'name', { value: '' } );
+    const value = Object.create( { constructor: unnamedConstructor } );
 
-    expect( failure ).toBeInstanceOf( ApplicationFailure );
-    expect( failure ).not.toBe( original );
-    expect( failure.cause ).toBe( original );
-    expect( failure.cause ).not.toBe( failure );
-    expect( failure ).toMatchObject( {
-      message: 'application failed',
-      type: 'DomainFailure',
-      nonRetryable: true,
-      details: [
-        { domain: { reason: 'bad-input' } },
-        info
-      ]
-    } );
+    expect( inheritsFromAnyNamedType( value, [ '', undefined ] ) ).toBe( false );
+    expect( inheritsFromAnyNamedType( value, [] ) ).toBe( false );
+    expect( inheritsFromAnyNamedType( null, [ 'BaseFailure' ] ) ).toBe( false );
+    expect( inheritsFromAnyNamedType( 'failure', [ 'String' ] ) ).toBe( false );
   } );
 } );

package/src/helpers/fetch.js

@@ -1,42 +1,5 @@
 import { FatalError } from '#errors';
-
-/** Matches red int "hot-red-pie", but not int "redact" */
-const wordMatcher = term => new RegExp( `(?<![a-z\\d])${term}(?![a-z\\d])`, 'i' );
-
-/** Matches red in "acquired", but not in "redact" */
-const wordEndMatcher = term => new RegExp( `${term}(?![a-z\\d])`, 'i' );
-
-/**
- * Redacts sensitive headers
- * @param {object} headers
- * @returns {object} The redacted headers
- */
-export const redactHeaders = headers => {
-  /** Header names that look sensitive by substring rules but are not secret material. */
-  const ignoreHeaders = new Set( [
-    'x-csrf-token',
-    'public-key-pins'
-  ] );
-
-  /** * Sensitive header patterns for redaction (case-insensitive). */
-  const sensitiveHeadersPatterns = [
-    // matches headers that contain these exact words
-    wordMatcher( 'authorization' ),
-    wordMatcher( 'token' ),
-    wordMatcher( 'secret' ),
-    wordMatcher( 'password' ),
-    wordMatcher( 'pwd' ),
-    wordMatcher( 'cookie' ),
-    // matches header that contain words ending with these sequences
-    wordEndMatcher( 'key' )
-  ];
-
-  return Object.entries( headers ).reduce( ( redacted, [ key, value ] ) => {
-    const lowKey = key.toLowerCase();
-    const isSensitive = !ignoreHeaders.has( lowKey ) && sensitiveHeadersPatterns.some( rx => rx.test( lowKey ) );
-    return Object.assign( redacted, { [key]: isSensitive ? '[REDACTED]' : value } );
-  }, {} );
-};
+import { redactHeaders } from './redact.js';
 
 /**
  * Consume the body of a Response according it its content-type and returns it

package/src/helpers/fetch.spec.js

@@ -1,44 +1,6 @@
 import { afterEach, describe, it, expect } from 'vitest';
 import { Readable } from 'node:stream';
-import { hydrateHeaders, redactHeaders, serializeBodyAndInferContentType, serializeResponse } from './fetch.js';
-
-describe( 'redactHeaders', () => {
-  it( 'redacts sensitive header names', () => {
-    const result = redactHeaders( {
-      Authorization: 'Bearer token',
-      'X-Api-Key': 'api-key',
-      Cookie: 'session=id',
-      'x-client-secret': 'secret'
-    } );
-
-    expect( result ).toEqual( {
-      Authorization: '[REDACTED]',
-      'X-Api-Key': '[REDACTED]',
-      Cookie: '[REDACTED]',
-      'x-client-secret': '[REDACTED]'
-    } );
-  } );
-
-  it( 'preserves non-sensitive header names and ignored false positives', () => {
-    const result = redactHeaders( {
-      Accept: 'application/json',
-      'Content-Type': 'application/json',
-      'x-csrf-token': 'csrf-token',
-      'public-key-pins': 'pin'
-    } );
-
-    expect( result ).toEqual( {
-      Accept: 'application/json',
-      'Content-Type': 'application/json',
-      'x-csrf-token': 'csrf-token',
-      'public-key-pins': 'pin'
-    } );
-  } );
-
-  it( 'handles empty headers', () => {
-    expect( redactHeaders( {} ) ).toEqual( {} );
-  } );
-} );
+import { hydrateHeaders, serializeBodyAndInferContentType, serializeResponse } from './fetch.js';
 
 describe( 'hydrateHeaders', () => {
   afterEach( () => {

package/src/helpers/function.js

@@ -13,3 +13,16 @@ export const runOnce = fn => {
     return state.result;
   };
 };
+
+/**
+ * Calls a given function and in case it throws errors, returns `undefined`
+ * @param {Function} fn
+ * @returns {unknown|undefined}
+ */
+export const tryOrUndefined = fn => {
+  try {
+    return fn();
+  } catch {
+    return undefined; // eslint-disable-line consistent-return
+  }
+};

package/src/helpers/function.spec.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
-import { runOnce } from './function.js';
+import { runOnce, tryOrUndefined } from './function.js';
 
 describe( 'runOnce', () => {
   it( 'calls the wrapped function only once', () => {
@@ -46,3 +46,25 @@ describe( 'runOnce', () => {
     expect( fn ).toHaveBeenCalledOnce();
   } );
 } );
+
+describe( 'tryOrUndefined', () => {
+  it( 'returns the invoked function result', () => {
+    const fn = vi.fn( () => 'result' );
+
+    expect( tryOrUndefined( fn ) ).toBe( 'result' );
+    expect( fn ).toHaveBeenCalledOnce();
+  } );
+
+  it( 'returns undefined when the invoked function throws', () => {
+    const fn = vi.fn( () => {
+      throw new Error( 'unavailable' );
+    } );
+
+    expect( tryOrUndefined( fn ) ).toBeUndefined();
+    expect( fn ).toHaveBeenCalledOnce();
+  } );
+
+  it( 'preserves an explicit undefined result', () => {
+    expect( tryOrUndefined( () => undefined ) ).toBeUndefined();
+  } );
+} );

package/src/helpers/object.js

@@ -24,58 +24,71 @@ export const clone = v => {
 };
 
 /**
- * Creates a new object merging object "b" onto object "a", using a resolver function to define the value to keep.
- * - Object "b" fields that also exists on "a" will have their value defined by the "resolver" function
- * - Object "b" fields that don't exist on object "a" will be added;
- * - Object "a" fields that don't exist on object "b" will be preserved;
+ * Creates a new object recursively merging the rightmost object over the previous one using a resolver function.
+ * Give two objects, (L)eft and (R)right
+ * - Object "R" will overwrite fields on object "L" based on the result of the resolver function;
+ * - Object "R" fields that don't exist on object "L" will be added;
+ * - Object "L" fields that don't exist on object "R" will be preserved;
  *
- * If "b" isn't an object, a new object equal to "a" is returned
+ * If "R" isn't an object, a new object equal to "L" is returned.
  *
- * @param {object} a - The base object
- * @param {object} b - The target object
- * @param {function} resolver - A function that return the value to be kept. First argument is value a, second is value b
+ * The resolver function will define the final value of the merge, it receives two args value "L" and "R".
+ *
+ *
+ * @param {object} base - The base object
+ * @param {...(object|function)} args - Target objects followed by the resolver function
  * @returns {object} A new object
  */
-export const deepMergeWithResolver = ( a, b, resolver ) => {
-  if ( !isPlainObject( a ) ) {
-    throw new Error( 'Parameter "a" is not an object.' );
+export const deepMergeWithResolver = ( base, ...args ) => {
+  const objects = args.slice( 0, -1 );
+  const resolver = args.at( -1 );
+
+  if ( !isPlainObject( base ) ) {
+    throw new Error( 'First argument (base object) is not an object.' );
   }
-  if ( !isPlainObject( b ) ) {
-    return clone( a );
+
+  if ( typeof resolver !== 'function' ) {
+    throw new Error( 'Last argument (resolver) is not a function.' );
   }
-  return Object.entries( b ).reduce( ( obj, [ k, v ] ) =>
-    Object.assign( obj, {
-      [k]: ( () => {
-        if ( isPlainObject( v ) && isPlainObject( a[k] ) ) {
-          return deepMergeWithResolver( a[k], v, resolver );
-        }
-        if ( Object.hasOwn( a, k ) ) {
-          return resolver( a[k], v );
-        }
-        return v;
-      } )()
-    } )
-  , clone( a ) );
+
+  return objects.reduce( ( merged, object ) => {
+    if ( !isPlainObject( object ) ) {
+      return merged;
+    }
+
+    for ( const [ k, v ] of Object.entries( object ) ) {
+      if ( isPlainObject( v ) && isPlainObject( merged[k] ) ) {
+        merged[k] = deepMergeWithResolver( merged[k], v, resolver );
+      } else if ( Object.hasOwn( merged, k ) ) {
+        merged[k] = resolver( merged[k], v );
+      } else {
+        merged[k] = v;
+      }
+    }
+    return merged;
+  }, clone( base ) );
 };
 
 /**
- * Creates a new object merging object "b" onto object "a" biased to "b":
- * - Object "b" will overwrite fields on object "a";
- * - Object "b" fields that don't exist on object "a" will be added;
- * - Object "a" fields that don't exist on object "b" will be preserved;
+ * Creates a new object recursively merging the rightmost object over the previous one.
+ * Give two objects, (L)eft and (R)right
+ * - Object "R" will overwrite fields on object "L";
+ * - Object "R" fields that don't exist on object "L" will be added;
+ * - Object "L" fields that don't exist on object "R" will be preserved;
  *
- * If "b" isn't an object, a new object equal to "a" is returned
+ * If "R" isn't an object, a new object equal to "L" is returned.
  *
- * @param {object} a - The base object
- * @param {object} b - The target object
+ * @param {object} base - The base object
+ * @param {...object} rest - The target objects
  * @returns {object} A new object
  */
-export const deepMerge = ( a, b ) => deepMergeWithResolver( a, b, ( _, b ) => b );
+export const deepMerge = ( base, ...rest ) =>
+  deepMergeWithResolver( base, ...rest, ( _, b ) => b );
 
 /**
  * Adds an non-writable, non-configurable and non-enumerable property to an object
  * @param {object} obj
- * @param {string} key
+ * @param {string|Symbol} key
  * @param {any} value
  * @returns
  */

package/src/helpers/object.spec.js

@@ -95,98 +95,86 @@ describe( 'clone', () => {
 } );
 
 describe( 'deepMerge', () => {
-  it( 'Overwrites properties in object "a"', () => {
+  it( 'returns a clone when only the base object is provided', () => {
     const a = {
-      a: 1,
-      b: {
-        c: 2
-      }
+      nested: { value: 1 }
     };
-    const b = {
-      a: false,
-      b: {
-        c: true
-      }
-    };
-    expect( deepMerge( a, b ) ).toEqual( {
-      a: false,
-      b: {
-        c: true
-      }
-    } );
-  } );
+    const result = deepMerge( a );
 
-  it( 'Adds properties existing in "b" but absent in "a"', () => {
-    const a = {
-      a: 1
-    };
-    const b = {
-      a: false,
-      b: true
-    };
-    expect( deepMerge( a, b ) ).toEqual( {
-      a: false,
-      b: true
+    a.nested.value = 2;
+
+    expect( result ).toEqual( {
+      nested: { value: 1 }
     } );
   } );
 
-  it( 'Keep extra properties in "a"', () => {
-    const a = {
-      a: 1
-    };
-    const b = {
-      b: true
-    };
-    expect( deepMerge( a, b ) ).toEqual( {
-      a: 1,
-      b: true
+  it( 'Throws when first argument is not a plain object', () => {
+    expect( () => deepMerge( null ) ).toThrow( Error );
+  } );
+
+  it( 'merges multiple objects from left to right using rightmost values', () => {
+    expect( deepMerge(
+      {
+        a: 1,
+        nested: {
+          a: 'base',
+          kept: true
+        }
+      },
+      {
+        b: 2,
+        nested: {
+          a: 'first',
+          b: 'first'
+        }
+      },
+      {
+        a: 3,
+        nested: {
+          b: 'second',
+          c: 'second'
+        }
+      }
+    ) ).toEqual( {
+      a: 3,
+      b: 2,
+      nested: {
+        a: 'first',
+        b: 'second',
+        c: 'second',
+        kept: true
+      }
     } );
   } );
 
-  it( 'Merge object is a clone', () => {
-    const a = {
-      a: 1
-    };
-    const b = {
-      b: 1
-    };
-    const result = deepMerge( a, b );
-    a.a = 2;
-    b.b = 2;
-    expect( result.a ).toEqual( 1 );
+  it( 'ignores non-object values among multiple overlays', () => {
+    expect( deepMerge(
+      { a: 1 },
+      null,
+      { b: 2 },
+      undefined,
+      { a: 3 }
+    ) ).toEqual( {
+      a: 3,
+      b: 2
+    } );
   } );
+} );
 
-  it( 'Returns copy of "a" if "b" is not an object', () => {
+describe( 'deepMergeWithResolver', () => {
+  it( 'returns a clone when only the base object and resolver are provided', () => {
     const a = {
-      a: 1
+      nested: { value: 1 }
     };
-    expect( deepMerge( a, null ) ).toEqual( { a: 1 } );
-    expect( deepMerge( a, undefined ) ).toEqual( { a: 1 } );
-  } );
+    const result = deepMergeWithResolver( a, ( x, y ) => x + y );
 
-  it( 'Copy of object "a" is a clone', () => {
-    const a = {
-      a: 1
-    };
-    const result = deepMerge( a, null );
-    a.a = 2;
-    expect( result.a ).toEqual( 1 );
-  } );
+    a.nested.value = 2;
 
-  it( 'Throws when first argument is not a plain object', () => {
-    expect( () => deepMerge( Function ) ).toThrow( Error );
-    expect( () => deepMerge( () => {} ) ).toThrow( Error );
-    expect( () => deepMerge( 'a' ) ).toThrow( Error );
-    expect( () => deepMerge( true ) ).toThrow( Error );
-    expect( () => deepMerge( /a/ ) ).toThrow( Error );
-    expect( () => deepMerge( [] ) ).toThrow( Error );
-    expect( () => deepMerge( class Foo {}, class Foo {} ) ).toThrow( Error );
-    expect( () => deepMerge( Number.constructor, Number.constructor ) ).toThrow( Error );
-    expect( () => deepMerge( Number.constructor.prototype, Number.constructor.prototype ) ).toThrow( Error );
+    expect( result ).toEqual( {
+      nested: { value: 1 }
+    } );
   } );
-} );
 
-describe( 'deepMergeWithResolver', () => {
   it( 'uses resolver for existing leaf values, including nested leaves', () => {
     const a = {
       cost: { total: 1 },
@@ -235,6 +223,66 @@ describe( 'deepMergeWithResolver', () => {
     expect( () => deepMergeWithResolver( [], {}, ( x, y ) => x + y ) ).toThrow( Error );
     expect( () => deepMergeWithResolver( 'a', {}, ( x, y ) => x + y ) ).toThrow( Error );
   } );
+
+  it( 'throws when last argument is not a resolver function', () => {
+    expect( () => deepMergeWithResolver( { a: 1 }, { a: 2 } ) )
+      .toThrow( 'Last argument (resolver) is not a function.' );
+  } );
+
+  it( 'merges multiple objects using the resolver from left to right', () => {
+    const resolver = vi.fn( ( x, y ) => `${ x }:${ y }` );
+
+    expect( deepMergeWithResolver(
+      {
+        a: 'base',
+        nested: {
+          count: 1,
+          kept: 'yes'
+        }
+      },
+      {
+        a: 'first',
+        nested: {
+          count: 2,
+          firstOnly: true
+        }
+      },
+      {
+        a: 'second',
+        nested: {
+          count: 3,
+          secondOnly: true
+        }
+      },
+      resolver
+    ) ).toEqual( {
+      a: 'base:first:second',
+      nested: {
+        count: '1:2:3',
+        firstOnly: true,
+        kept: 'yes',
+        secondOnly: true
+      }
+    } );
+    expect( resolver ).toHaveBeenCalledTimes( 4 );
+  } );
+
+  it( 'ignores non-object values among multiple resolver overlays', () => {
+    const resolver = vi.fn( ( x, y ) => x + y );
+
+    expect( deepMergeWithResolver(
+      { a: 1 },
+      null,
+      { a: 2 },
+      undefined,
+      { b: 3 },
+      resolver
+    ) ).toEqual( {
+      a: 3,
+      b: 3
+    } );
+    expect( resolver ).toHaveBeenCalledOnce();
+  } );
 } );
 
 describe( 'isPlainObject', () => {

package/src/helpers/redact.js

@@ -0,0 +1,51 @@
+/**
+ * Redacts a given URL object by setting each search param, hash, username and password to '***'
+ * @param {URL|string} target
+ * @returns {string} Redacted URL as a string
+ */
+export const redactUrl = target => {
+  const url = new URL( target );
+  url.search = new URLSearchParams( url.searchParams.entries().map( ( [ p ] ) => [ p, '***' ] ) ).toString();
+  url.username = url.username.length > 0 ? '***' : '';
+  url.password = url.password.length > 0 ? '***' : '';
+  url.hash = url.hash ? '#***' : '';
+  return url.toString();
+};
+
+/** Matches red in "hot-red-pie", but not in "redact" */
+const wordMatcher = term => new RegExp( `(?<![a-z\\d])${term}(?![a-z\\d])`, 'i' );
+
+/** Matches red in "acquired", but not in "redact" */
+const wordEndMatcher = term => new RegExp( `${term}(?![a-z\\d])`, 'i' );
+
+/**
+ * Redacts sensitive headers
+ * @param {object} headers
+ * @returns {object} The redacted headers
+ */
+export const redactHeaders = headers => {
+  /** Header names that look sensitive by substring rules but are not secret material. */
+  const ignoreHeaders = new Set( [
+    'x-csrf-token',
+    'public-key-pins'
+  ] );
+
+  /** * Sensitive header patterns for redaction (case-insensitive). */
+  const sensitiveHeadersPatterns = [
+    // matches headers that contain these exact words
+    wordMatcher( 'authorization' ),
+    wordMatcher( 'token' ),
+    wordMatcher( 'secret' ),
+    wordMatcher( 'password' ),
+    wordMatcher( 'pwd' ),
+    wordMatcher( 'cookie' ),
+    // matches header that contain words ending with these sequences
+    wordEndMatcher( 'key' )
+  ];
+
+  return Object.entries( headers ).reduce( ( redacted, [ key, value ] ) => {
+    const lowKey = key.toLowerCase();
+    const isSensitive = !ignoreHeaders.has( lowKey ) && sensitiveHeadersPatterns.some( rx => rx.test( lowKey ) );
+    return Object.assign( redacted, { [key]: isSensitive ? '[REDACTED]' : value } );
+  }, {} );
+};