@outputai/core 0.1.0

package/src/internal_activities/index.spec.js

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { MockAgent, setGlobalDispatcher } from 'undici';
+import { FatalError } from '#errors';
+import { serializeBodyAndInferContentType, serializeFetchResponse } from '#utils';
+import { sendHttpRequest } from './index.js';
+
+vi.mock( '#logger', () => {
+  const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+  return { createChildLogger: vi.fn( () => log ) };
+} );
+
+vi.mock( '#utils', () => ( {
+  setMetadata: vi.fn(),
+  isStringboolTrue: vi.fn( () => false ),
+  serializeBodyAndInferContentType: vi.fn(),
+  serializeFetchResponse: vi.fn()
+} ) );
+
+const mockAgent = new MockAgent();
+mockAgent.disableNetConnect();
+
+setGlobalDispatcher( mockAgent );
+
+const url = 'https://growthx.ai';
+const method = 'GET';
+
+describe( 'internal_activities/sendHttpRequest', () => {
+  beforeEach( async () => {
+    vi.restoreAllMocks();
+    vi.clearAllMocks();
+  } );
+
+  it( 'succeeds and returns serialized JSON response', async () => {
+    const payload = { a: 1 };
+    const method = 'POST';
+
+    mockAgent.get( url ).intercept( { path: '/', method } )
+      .reply( 200, JSON.stringify( { ok: true, value: 42 } ), {
+        headers: { 'content-type': 'application/json' }
+      } );
+
+    // mock utils
+    serializeBodyAndInferContentType.mockReturnValueOnce( {
+      body: JSON.stringify( payload ),
+      contentType: 'application/json; charset=UTF-8'
+    } );
+    const fakeSerialized = { sentinel: true };
+    serializeFetchResponse.mockResolvedValueOnce( fakeSerialized );
+
+    const result = await sendHttpRequest( { url, method, payload } );
+
+    // utils mocked: verify calls and returned value
+    expect( serializeBodyAndInferContentType ).toHaveBeenCalledTimes( 1 );
+    expect( serializeBodyAndInferContentType ).toHaveBeenCalledWith( payload );
+    expect( serializeFetchResponse ).toHaveBeenCalledTimes( 1 );
+    const respArg = serializeFetchResponse.mock.calls[0][0];
+    expect( respArg && typeof respArg.text ).toBe( 'function' );
+    expect( respArg.status ).toBe( 200 );
+    expect( respArg.headers.get( 'content-type' ) ).toContain( 'application/json' );
+    expect( result ).toBe( fakeSerialized );
+  } );
+
+  it( 'throws FatalError when response.ok is false', async () => {
+    mockAgent.get( url ).intercept( { path: '/', method } ).reply( 500, 'Internal error' );
+
+    await expect( sendHttpRequest( { url, method } ) ).rejects
+      .toThrow( new FatalError( 'GET https://growthx.ai 500' ) );
+    expect( serializeFetchResponse ).not.toHaveBeenCalled();
+    expect( serializeBodyAndInferContentType ).not.toHaveBeenCalled();
+  } );
+
+  it( 'throws FatalError on timeout failure', async () => {
+    mockAgent.get( url ).intercept( { path: '/', method } )
+      .reply( 200, 'ok', { headers: { 'content-type': 'text/plain' } } )
+      .delay( 10_000 );
+
+    await expect( sendHttpRequest( { url, method, timeout: 250 } ) ).rejects
+      .toThrow( new FatalError( 'GET https://growthx.ai The operation was aborted due to timeout' ) );
+    expect( serializeFetchResponse ).not.toHaveBeenCalled();
+    expect( serializeBodyAndInferContentType ).not.toHaveBeenCalled();
+  } );
+
+  it( 'wraps DNS resolution errors (ENOTFOUND) preserving cause message', async () => {
+    mockAgent.get( url ).intercept( { path: '/', method } )
+      .replyWithError( new Error( 'getaddrinfo ENOTFOUND nonexistent.example.test' ) );
+
+    await expect( sendHttpRequest( { url, method } ) ).rejects
+      .toThrow( new FatalError( 'GET https://growthx.ai Error: getaddrinfo ENOTFOUND nonexistent.example.test' ) );
+    expect( serializeFetchResponse ).not.toHaveBeenCalled();
+    expect( serializeBodyAndInferContentType ).not.toHaveBeenCalled();
+  } );
+
+  it( 'wraps TCP connection errors (ECONNREFUSED) preserving cause message', async () => {
+    mockAgent.get( url ).intercept( { path: '/', method } )
+      .replyWithError( new Error( 'connect ECONNREFUSED 127.0.0.1:65500' ) );
+
+    await expect( sendHttpRequest( { url, method } ) ).rejects
+      .toThrow( new FatalError( 'GET https://growthx.ai Error: connect ECONNREFUSED 127.0.0.1:65500' ) );
+    expect( serializeFetchResponse ).not.toHaveBeenCalled();
+    expect( serializeBodyAndInferContentType ).not.toHaveBeenCalled();
+  } );
+} );

package/src/logger.js

@@ -0,0 +1,73 @@
+import winston from 'winston';
+import { shuffleArray } from '#utils';
+
+const isProduction = process.env.NODE_ENV === 'production';
+
+const levels = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  http: 3,
+  debug: 4
+};
+
+const colors = shuffleArray( [
+  '033', // blue
+  '030', // green
+  '208', // orange
+  '045', // turquoise
+  '129', // purple
+  '184' // yellow
+] );
+const assignedColors = new Map();
+
+// Format metadata as friendly JSON: "{ name: "foo", count: 5 }"
+const formatMeta = obj => {
+  const entries = Object.entries( obj );
+  if ( !entries.length ) {
+    return '';
+  }
+  return ' { ' + entries.map( ( [ k, v ] ) => `${k}: ${JSON.stringify( v )}` ).join( ', ' ) + ' }';
+};
+// Distribute the namespace in a map and assign it the next available color
+const getColor = v =>
+  assignedColors.has( v ) ? assignedColors.get( v ) : assignedColors.set( v, colors[assignedColors.size % colors.length] ).get( v );
+
+// Colorize a text using the namespace string
+const colorizeByNamespace = ( namespace, text ) => `\x1b[38;5;${getColor( namespace )}m${text}\x1b[0m`;
+
+// Development format: colorized with namespace prefix
+const devFormat = winston.format.combine(
+  winston.format.colorize(),
+  winston.format.printf( ( { level, message, namespace, service: _, environment: __, ...rest } ) => {
+    const ns = 'Core' + ( namespace ? `.${namespace}` : '' );
+    const meta = formatMeta( rest );
+    return `[${level}] ${colorizeByNamespace( ns, `${namespace}: ${message}` )}${meta}`;
+  } )
+);
+
+// Production format: structured JSON
+const prodFormat = winston.format.combine(
+  winston.format.timestamp( { format: 'YYYY-MM-DDTHH:mm:ss.SSSZ' } ),
+  winston.format.errors( { stack: true } ),
+  winston.format.json()
+);
+
+export const logger = winston.createLogger( {
+  levels,
+  level: isProduction ? 'info' : 'debug',
+  format: isProduction ? prodFormat : devFormat,
+  defaultMeta: {
+    service: 'output-worker',
+    environment: process.env.NODE_ENV || 'development'
+  },
+  transports: [ new winston.transports.Console() ]
+} );
+
+/**
+ * Creates a child logger with a specific namespace
+ *
+ * @param {string} namespace - The namespace for this logger (e.g., 'Scanner', 'Tracing')
+ * @returns {winston.Logger} Child logger instance with namespace metadata
+ */
+export const createChildLogger = namespace => logger.child( { namespace } );

package/src/tracing/internal_interface.js

@@ -0,0 +1,71 @@
+import { addEventPhase, addEventPhaseWithContext, init, getDestinations } from './trace_engine.js';
+
+/**
+ * Init method, if not called, no processors are attached and trace functions are dummy
+ */
+export { init, getDestinations };
+
+/**
+ * Internal use only - adds event phase with AsyncLocalStorage context resolution
+ */
+export { addEventPhaseWithContext };
+
+/**
+ * Trace nomenclature
+ *
+ * Trace - The collection of Events;
+ * Event - Any entry in the Trace file, must have the two phases START and END or ERROR;
+ * Phase - An specific part of an Event, either START or the conclusive END or ERROR;
+ */
+
+/**
+ * Internal use only
+ *
+ * Adds the start phase of a new event at the default trace for the current workflow.
+ *
+ * @param {object} args
+ * @param {string} args.id - A unique id for the Event, must be the same across all phases: start, end, error.
+ * @param {string} args.kind - The kind of Event, like HTTP, DiskWrite, DBOp, etc.
+ * @param {string} args.name - The human friendly name of the Event: query, request, create.
+ * @param {any} args.details - All details attached to this Event Phase. DB queried records, HTTP response body.
+ * @param {string} args.parentId - The parent Event, used to build a three.
+ * @param {object} args.executionContext - The original execution context from the workflow
+ * @returns {void}
+ */
+export const addEventStart = options => addEventPhase( 'start', options );
+
+/**
+ * Internal use only
+ *
+ * Adds the end phase at an event at the default trace for the current workflow.
+ *
+ * It needs to use the same id of the start phase.
+ *
+ * @param {object} args
+ * @param {string} args.id - A unique id for the Event, must be the same across all phases: start, end, error.
+ * @param {string} args.kind - The kind of Event, like HTTP, DiskWrite, DBOp, etc.
+ * @param {string} args.name - The human friendly name of the Event: query, request, create.
+ * @param {any} args.details - All details attached to this Event Phase. DB queried records, HTTP response body.
+ * @param {string} args.parentId - The parent Event, used to build a three.
+ * @param {object} args.executionContext - The original execution context from the workflow
+ * @returns {void}
+ */
+export const addEventEnd = options => addEventPhase( 'end', options );
+
+/**
+ * Internal use only
+ *
+ * Adds the error phase at an event as error at the default trace for the current workflow.
+ *
+ * It needs to use the same id of the start phase.
+ *
+ * @param {object} args
+ * @param {string} args.id - A unique id for the Event, must be the same across all phases: start, end, error.
+ * @param {string} args.kind - The kind of Event, like HTTP, DiskWrite, DBOp, etc.
+ * @param {string} args.name - The human friendly name of the Event: query, request, create.
+ * @param {any} args.details - All details attached to this Event Phase. DB queried records, HTTP response body.
+ * @param {string} args.parentId - The parent Event, used to build a three.
+ * @param {object} args.executionContext - The original execution context from the workflow
+ * @returns {void}
+ */
+export const addEventError = options => addEventPhase( 'error', options );

package/src/tracing/processors/local/index.js

@@ -0,0 +1,111 @@
+import { appendFileSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'url';
+import buildTraceTree from '../../tools/build_trace_tree.js';
+import { EOL } from 'node:os';
+
+const __dirname = dirname( fileURLToPath( import.meta.url ) );
+
+const tempFilesTTL = 1000 * 60 * 60 * 24 * 7; // 1 week in milliseconds
+
+// Retrieves the caller path from the standard args used to start workflows
+const callerDir = process.argv[2];
+
+const tempTraceFilesDir = join( __dirname, 'temp', 'traces' );
+
+const accumulate = ( { entry, executionContext: { workflowId, startTime } } ) => {
+  const path = join( tempTraceFilesDir, `${startTime}_${workflowId}.trace` );
+  appendFileSync( path, JSON.stringify( entry ) + EOL, 'utf-8' );
+  return readFileSync( path, 'utf-8' ).split( EOL ).slice( 0, -1 ).map( v => JSON.parse( v ) );
+};
+
+const cleanupOldTempFiles = ( threshold = Date.now() - tempFilesTTL ) =>
+  readdirSync( tempTraceFilesDir )
+    .filter( f => +f.split( '_' )[0] < threshold )
+    .forEach( f => rmSync( join( tempTraceFilesDir, f ) ) );
+
+/**
+ * Resolves the deep folder structure that stores a workflow trace.
+ * @param {string} workflowName - Name of the workflow
+ * @returns {string}
+ */
+const resolveTraceFolder = workflowName => join( 'runs', workflowName );
+
+/**
+ * Resolves the local file system path for ALL file I/O operations (read/write)
+ * Uses the project root path
+ * @param {string} workflowName - The name of the workflow
+ * @returns {string} The local filesystem path for file operations
+ */
+const resolveIOPath = workflowName => join( callerDir, 'logs', resolveTraceFolder( workflowName ) );
+
+/**
+ * Resolves the file path to be reported as the trace destination.
+ *
+ * Considering that in containerized environments (e.g., Docker), the file path might differ from the host machine,
+ * this value takes in consideration the OUTPUT_TRACE_HOST_PATH env variable instead of the local filesystem to mount
+ * the final file path.
+ *
+ * If the env variable is not present, it falls back to the same value used to write files locally.
+ *
+ * @param {string} workflowName - The name of the workflow
+ * @returns {string} The path to report, reflecting the actual filesystem
+ */
+const resolveReportPath = workflowName => process.env.OUTPUT_TRACE_HOST_PATH ?
+  join( process.env.OUTPUT_TRACE_HOST_PATH, resolveTraceFolder( workflowName ) ) :
+  resolveIOPath( workflowName );
+
+/**
+ * Builds the actual trace filename
+ *
+ * @param {object} options
+ * @param {number} options.startTime
+ * @param {string} options.workflowId
+ * @returns {string}
+ */
+const buildTraceFilename = ( { startTime, workflowId } ) => {
+  const timestamp = new Date( startTime ).toISOString().replace( /[:T.]/g, '-' );
+  return `${timestamp}_${workflowId}.json`;
+};
+
+/**
+ * Init this processor
+ */
+export const init = () => {
+  mkdirSync( tempTraceFilesDir, { recursive: true } );
+  cleanupOldTempFiles();
+};
+
+/**
+ * Execute this processor:
+ *
+ * Persist a trace tree file to local file system, updating upon each new entry
+ *
+ * @param {object} args
+ * @param {object} entry - Trace event phase
+ * @param {object} executionContext - Execution info: workflowId, workflowName, startTime
+ * @returns {void}
+ */
+export const exec = ( { entry, executionContext } ) => {
+  const { workflowId, workflowName, startTime } = executionContext;
+  const content = buildTraceTree( accumulate( { entry, executionContext } ) );
+  const dir = resolveIOPath( workflowName );
+  const path = join( dir, buildTraceFilename( { startTime, workflowId } ) );
+
+  mkdirSync( dir, { recursive: true } );
+  writeFileSync( path, JSON.stringify( content, undefined, 2 ) + EOL, 'utf-8' );
+};
+
+/**
+ * Returns where the trace is saved as an absolute path.
+ *
+ * This uses the optional OUTPUT_TRACE_HOST_PATH to return values relative to the host OS, not the container, if applicable.
+ *
+ * @param {object} executionContext
+ * @param {string} executionContext.startTime - The start time of the workflow
+ * @param {string} executionContext.workflowId - The id of the workflow execution
+ * @param {string} executionContext.workflowName - The name of the workflow
+ * @returns {string} The absolute path where the trace will be saved
+ */
+export const getDestination = ( { startTime, workflowId, workflowName } ) =>
+  join( resolveReportPath( workflowName ), buildTraceFilename( { workflowId, startTime } ) );

package/src/tracing/processors/local/index.spec.js

@@ -0,0 +1,149 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// In-memory fs mock store
+const store = { files: new Map() };
+const mkdirSyncMock = vi.fn();
+const writeFileSyncMock = vi.fn();
+const appendFileSyncMock = vi.fn( ( path, data ) => {
+  const prev = store.files.get( path ) ?? '';
+  store.files.set( path, prev + data );
+} );
+const readFileSyncMock = vi.fn( path => store.files.get( path ) ?? '' );
+const readdirSyncMock = vi.fn( () => [] );
+const rmSyncMock = vi.fn();
+
+vi.mock( 'node:fs', () => ( {
+  mkdirSync: mkdirSyncMock,
+  writeFileSync: writeFileSyncMock,
+  appendFileSync: appendFileSyncMock,
+  readFileSync: readFileSyncMock,
+  readdirSync: readdirSyncMock,
+  rmSync: rmSyncMock
+} ) );
+
+const buildTraceTreeMock = vi.fn( entries => ( { count: entries.length } ) );
+vi.mock( '../../tools/build_trace_tree.js', () => ( { default: buildTraceTreeMock } ) );
+
+describe( 'tracing/processors/local', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    store.files.clear();
+    process.argv[2] = '/tmp/project';
+    delete process.env.OUTPUT_TRACE_HOST_PATH; // Clear OUTPUT_TRACE_HOST_PATH for clean tests
+  } );
+
+  it( 'init(): creates temp dir and cleans up old files', async () => {
+    const { init } = await import( './index.js' );
+
+    const now = Date.now();
+    readdirSyncMock.mockReturnValue( [ `${now - ( 8 * 24 * 60 * 60 * 1000 )}_old.trace`, `${now}_new.trace` ] );
+
+    init();
+
+    // Should create temp dir relative to module location using __dirname
+    expect( mkdirSyncMock ).toHaveBeenCalledWith( expect.stringMatching( /temp\/traces$/ ), { recursive: true } );
+    expect( rmSyncMock ).toHaveBeenCalledTimes( 1 );
+  } );
+
+  it( 'exec(): accumulates entries and writes aggregated tree', async () => {
+    const { exec, init } = await import( './index.js' );
+    init();
+
+    const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
+    const ctx = { executionContext: { workflowId: 'id1', workflowName: 'WF', startTime } };
+
+    exec( { ...ctx, entry: { name: 'A', phase: 'start', timestamp: startTime } } );
+    exec( { ...ctx, entry: { name: 'A', phase: 'tick', timestamp: startTime + 1 } } );
+    exec( { ...ctx, entry: { name: 'A', phase: 'end', timestamp: startTime + 2 } } );
+
+    // buildTraceTree called with 1, 2, 3 entries respectively
+    expect( buildTraceTreeMock ).toHaveBeenCalledTimes( 3 );
+    expect( buildTraceTreeMock.mock.calls.at( -1 )[0].length ).toBe( 3 );
+
+    expect( writeFileSyncMock ).toHaveBeenCalledTimes( 3 );
+    const [ writtenPath, content ] = writeFileSyncMock.mock.calls.at( -1 );
+    // Changed: Now uses process.cwd() + '/logs' fallback when OUTPUT_TRACE_HOST_PATH not set
+    expect( writtenPath ).toMatch( /\/runs\/WF\// );
+    expect( JSON.parse( content.trim() ).count ).toBe( 3 );
+  } );
+
+  it( 'getDestination(): returns absolute path', async () => {
+    const { getDestination } = await import( './index.js' );
+
+    const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
+    const workflowId = 'workflow-id-123';
+    const workflowName = 'test-workflow';
+
+    const destination = getDestination( { startTime, workflowId, workflowName } );
+
+    // Should return an absolute path
+    expect( destination ).toMatch( /^\/|^[A-Z]:\\/i ); // Starting with / or Windows drive letter
+    expect( destination ).toContain( '/logs/runs/test-workflow/2020-01-02-03-04-05-678Z_workflow-id-123.json' );
+  } );
+
+  it( 'exec(): writes to container path regardless of OUTPUT_TRACE_HOST_PATH', async () => {
+    const { exec, init } = await import( './index.js' );
+
+    // Set OUTPUT_TRACE_HOST_PATH to simulate Docker environment
+    process.env.OUTPUT_TRACE_HOST_PATH = '/host/path/logs';
+
+    init();
+
+    const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
+    const ctx = { executionContext: { workflowId: 'id1', workflowName: 'WF', startTime } };
+
+    exec( { ...ctx, entry: { name: 'A', phase: 'start', timestamp: startTime } } );
+
+    expect( writeFileSyncMock ).toHaveBeenCalledTimes( 1 );
+    const [ writtenPath ] = writeFileSyncMock.mock.calls.at( -1 );
+
+    // Should write to process.cwd()/logs, NOT to OUTPUT_TRACE_HOST_PATH
+    expect( writtenPath ).not.toContain( '/host/path/logs' );
+    expect( writtenPath ).toMatch( /logs\/runs\/WF\// );
+  } );
+
+  it( 'getDestination(): returns OUTPUT_TRACE_HOST_PATH when set', async () => {
+    const { getDestination } = await import( './index.js' );
+
+    // Set OUTPUT_TRACE_HOST_PATH to simulate Docker environment
+    process.env.OUTPUT_TRACE_HOST_PATH = '/host/path/logs';
+
+    const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
+    const workflowId = 'workflow-id-123';
+    const workflowName = 'test-workflow';
+
+    const destination = getDestination( { startTime, workflowId, workflowName } );
+
+    // Should return OUTPUT_TRACE_HOST_PATH-based path for reporting
+    expect( destination ).toBe( '/host/path/logs/runs/test-workflow/2020-01-02-03-04-05-678Z_workflow-id-123.json' );
+  } );
+
+  it( 'separation of write and report paths works correctly', async () => {
+    const { exec, getDestination, init } = await import( './index.js' );
+
+    // Set OUTPUT_TRACE_HOST_PATH to simulate Docker environment
+    process.env.OUTPUT_TRACE_HOST_PATH = '/Users/ben/project/logs';
+
+    init();
+
+    const startTime = Date.parse( '2020-01-02T03:04:05.678Z' );
+    const workflowId = 'workflow-id-123';
+    const workflowName = 'test-workflow';
+    const ctx = { executionContext: { workflowId, workflowName, startTime } };
+
+    // Execute to write file
+    exec( { ...ctx, entry: { name: 'A', phase: 'start', timestamp: startTime } } );
+
+    // Get destination for reporting
+    const destination = getDestination( { startTime, workflowId, workflowName } );
+
+    // Verify write path is local
+    const [ writtenPath ] = writeFileSyncMock.mock.calls.at( -1 );
+    expect( writtenPath ).not.toContain( '/Users/ben/project' );
+    expect( writtenPath ).toMatch( /logs\/runs\/test-workflow\// );
+
+    // Verify report path uses OUTPUT_TRACE_HOST_PATH
+    expect( destination ).toBe( '/Users/ben/project/logs/runs/test-workflow/2020-01-02-03-04-05-678Z_workflow-id-123.json' );
+  } );
+} );
+

package/src/tracing/processors/s3/configs.js

@@ -0,0 +1,31 @@
+import * as z from 'zod';
+
+const envVarSchema = z.object( {
+  OUTPUT_AWS_REGION: z.string(),
+  OUTPUT_AWS_ACCESS_KEY_ID: z.string(),
+  OUTPUT_AWS_SECRET_ACCESS_KEY: z.string(),
+  OUTPUT_TRACE_REMOTE_S3_BUCKET: z.string(),
+  OUTPUT_REDIS_URL: z.string(),
+  OUTPUT_REDIS_TRACE_TTL: z.coerce.number().int().positive().default( 60 * 60 * 24 * 7 ), // 7 days
+  OUTPUT_TRACE_UPLOAD_DELAY_MS: z.coerce.number().int().nonnegative().default( 10_000 ) // 10s
+} );
+
+const env = {};
+
+export const loadEnv = () => {
+  const parsedFields = envVarSchema.parse( process.env );
+  env.awsRegion = parsedFields.OUTPUT_AWS_REGION;
+  env.awsAccessKeyId = parsedFields.OUTPUT_AWS_ACCESS_KEY_ID;
+  env.awsSecretAccessKey = parsedFields.OUTPUT_AWS_SECRET_ACCESS_KEY;
+  env.remoteS3Bucket = parsedFields.OUTPUT_TRACE_REMOTE_S3_BUCKET;
+  env.redisUrl = parsedFields.OUTPUT_REDIS_URL;
+  env.redisIncompleteWorkflowsTTL = parsedFields.OUTPUT_REDIS_TRACE_TTL;
+  env.traceUploadDelayMs = parsedFields.OUTPUT_TRACE_UPLOAD_DELAY_MS;
+};
+
+export const getVars = () => {
+  if ( Object.keys( env ).length === 0 ) {
+    throw new Error( 'Env vars not loaded. Use loadEnv() first.' );
+  }
+  return env;
+};

package/src/tracing/processors/s3/configs.spec.js

@@ -0,0 +1,64 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+async function loadModule() {
+  vi.resetModules();
+  return import( './configs.js' );
+}
+
+describe( 'tracing/processors/s3/configs', () => {
+  const required = {
+    OUTPUT_AWS_REGION: 'us-east-1',
+    OUTPUT_AWS_ACCESS_KEY_ID: 'id',
+    OUTPUT_AWS_SECRET_ACCESS_KEY: 'sek',
+    OUTPUT_TRACE_REMOTE_S3_BUCKET: 'bkt',
+    OUTPUT_REDIS_URL: 'redis://localhost:6379'
+  };
+
+  beforeEach( () => {
+    vi.stubEnv( 'OUTPUT_AWS_REGION', required.OUTPUT_AWS_REGION );
+    vi.stubEnv( 'OUTPUT_AWS_ACCESS_KEY_ID', required.OUTPUT_AWS_ACCESS_KEY_ID );
+    vi.stubEnv( 'OUTPUT_AWS_SECRET_ACCESS_KEY', required.OUTPUT_AWS_SECRET_ACCESS_KEY );
+    vi.stubEnv( 'OUTPUT_TRACE_REMOTE_S3_BUCKET', required.OUTPUT_TRACE_REMOTE_S3_BUCKET );
+    vi.stubEnv( 'OUTPUT_REDIS_URL', required.OUTPUT_REDIS_URL );
+  } );
+
+  afterEach( () => {
+    vi.unstubAllEnvs();
+  } );
+
+  it( 'loadEnv() throws when required env vars are missing', async () => {
+    vi.stubEnv( 'OUTPUT_REDIS_URL', undefined );
+    const { loadEnv } = await loadModule();
+    expect( () => loadEnv() ).toThrow( /OUTPUT_REDIS_URL/ );
+  } );
+
+  it( 'loadEnv() populates getVars() with parsed env', async () => {
+    const { loadEnv, getVars } = await loadModule();
+    loadEnv();
+    const vars = getVars();
+    expect( vars.awsRegion ).toBe( required.OUTPUT_AWS_REGION );
+    expect( vars.awsAccessKeyId ).toBe( required.OUTPUT_AWS_ACCESS_KEY_ID );
+    expect( vars.awsSecretAccessKey ).toBe( required.OUTPUT_AWS_SECRET_ACCESS_KEY );
+    expect( vars.remoteS3Bucket ).toBe( required.OUTPUT_TRACE_REMOTE_S3_BUCKET );
+    expect( vars.redisUrl ).toBe( required.OUTPUT_REDIS_URL );
+    expect( vars.redisIncompleteWorkflowsTTL ).toBe( 60 * 60 * 24 * 7 );
+  } );
+
+  it( 'loadEnv() uses OUTPUT_REDIS_TRACE_TTL when set', async () => {
+    vi.stubEnv( 'OUTPUT_REDIS_TRACE_TTL', '3600' );
+    const { loadEnv, getVars } = await loadModule();
+    loadEnv();
+    expect( getVars().redisIncompleteWorkflowsTTL ).toBe( 3600 );
+  } );
+
+  it( 'getVars() throws when loadEnv() was not called', async () => {
+    const { getVars } = await loadModule();
+    expect( () => getVars() ).toThrow( 'Env vars not loaded. Use loadEnv() first.' );
+  } );
+
+  it( 'loadEnv() throws when OUTPUT_REDIS_TRACE_TTL is invalid', async () => {
+    vi.stubEnv( 'OUTPUT_REDIS_TRACE_TTL', 'not-a-number' );
+    const { loadEnv } = await loadModule();
+    expect( () => loadEnv() ).toThrow();
+  } );
+} );