@outputai/core 0.10.1-dev.b7b2fbe.0 → 0.10.1-next.1070949.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

@@ -44,7 +44,11 @@ export const deepMergeWithResolver = ( base, ...args ) => {
   const resolver = args.at( -1 );
 
   if ( !isPlainObject( base ) ) {
-    throw new Error( 'First argument is not an object.' );
+    throw new Error( 'First argument (base object) is not an object.' );
+  }
+
+  if ( typeof resolver !== 'function' ) {
+    throw new Error( 'Last argument (resolver) is not a function.' );
   }
 
   return objects.reduce( ( merged, object ) => {

package/src/helpers/object.spec.js

@@ -224,6 +224,11 @@ describe( 'deepMergeWithResolver', () => {
     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 }` );
 

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 } );
+  }, {} );
+};

package/src/helpers/redact.spec.js

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest';
+import { redactHeaders, redactUrl } from './redact.js';
+
+describe( 'redactUrl', () => {
+  it( 'redacts credentials, query values, and the fragment while preserving URL structure', () => {
+    const result = redactUrl( 'https://user:password@example.com/models?model=gpt-5&token=secret#debug' );
+
+    expect( result ).toBe( 'https://***:***@example.com/models?model=***&token=***#***' );
+  } );
+
+  it( 'preserves duplicate query parameters and their order', () => {
+    const result = redactUrl( 'https://example.com/search?tag=first&tag=second&empty=#results' );
+
+    expect( result ).toBe( 'https://example.com/search?tag=***&tag=***&empty=***#***' );
+  } );
+
+  it( 'returns URLs without redacted components unchanged', () => {
+    expect( redactUrl( 'https://example.com/path' ) ).toBe( 'https://example.com/path' );
+  } );
+
+  it( 'does not mutate URL instances', () => {
+    const originalValue = 'ftp://user:password@example.com/file.txt?download=true#details';
+    const url = new URL( originalValue );
+
+    expect( redactUrl( url ) ).toBe( 'ftp://***:***@example.com/file.txt?download=***#***' );
+    expect( url.toString() ).toBe( originalValue );
+  } );
+} );
+
+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( {} );
+  } );
+} );

package/src/helpers/string.js

@@ -28,3 +28,13 @@ export const toUrlSafeBase64 = uuid => {
  * @returns
  */
 export const rxEscape = v => v.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' );
+
+const URL_SCHEME_RX = /^[a-z][a-z\d+.-]*:\/\//i;
+
+/**
+ * Detects if string is an URL starting with `<protocol>://`
+ *
+ * @param {string} s
+ * @returns {boolean}
+ */
+export const isUrl = s => typeof s === 'string' && URL_SCHEME_RX.test( s.trim() ) && URL.canParse( s );

package/src/helpers/string.spec.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { toUrlSafeBase64, rxEscape } from './string.js';
+import { isUrl, toUrlSafeBase64, rxEscape } from './string.js';
 
 describe( 'toUrlSafeBase64', () => {
   const urlSafeAlphabet = /^[A-Za-z0-9_-]+$/;
@@ -62,3 +62,38 @@ describe( 'rxEscape', () => {
     expect( rx.test( String.raw`C:\foo\bar\baz` ) ).toBe( false );
   } );
 } );
+
+describe( 'isUrl', () => {
+  it.each( [
+    'https://example.com/path?token=secret#section',
+    'ftp://user:password@example.com/file.txt',
+    'ftps://example.com/file.txt',
+    'git+ssh://example.com/repository',
+    'custom.protocol-v2://example.com/resource'
+  ] )( 'accepts a valid URL starting with a protocol: %s', value => {
+    expect( isUrl( value ) ).toBe( true );
+  } );
+
+  it.each( [
+    'Error: fetch failed',
+    'TypeError: invalid input',
+    'mailto:user@example.com',
+    'urn:isbn:978014',
+    'data:text/plain,hello'
+  ] )( 'rejects non-authority URI-like strings: %s', value => {
+    expect( isUrl( value ) ).toBe( false );
+  } );
+
+  it.each( [
+    '//example.com/path',
+    '/relative/path',
+    'https://',
+    'not a URL'
+  ] )( 'rejects malformed or relative values: %s', value => {
+    expect( isUrl( value ) ).toBe( false );
+  } );
+
+  it.each( [ undefined, null, 42, new URL( 'https://example.com' ) ] )( 'rejects non-string values', value => {
+    expect( isUrl( value ) ).toBe( false );
+  } );
+} );