@output.ai/core 0.0.16 → 0.1.1

package/src/configs.spec.js

@@ -1,379 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-
-describe( 'configs', () => {
-  const originalEnv = process.env;
-
-  beforeEach( () => {
-    vi.resetModules();
-    process.env = { ...originalEnv };
-  } );
-
-  afterEach( () => {
-    process.env = originalEnv;
-  } );
-
-  describe( 'Environment Variable Validation', () => {
-    describe( 'TEMPORAL_ADDRESS', () => {
-      it( 'should accept string addresses', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'localhost:7233',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.address ).toBe( 'localhost:7233' );
-      } );
-
-      it( 'should use default when omitted', async () => {
-        process.env = {
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.address ).toBe( 'localhost:7233' );
-      } );
-
-      it( 'should reject non-string values', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: '123',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        // Convert to number to test non-string
-        const originalEnv = process.env.TEMPORAL_ADDRESS;
-        process.env.TEMPORAL_ADDRESS = 123;
-
-        await expect( import( './configs.js' ) ).rejects.toThrow();
-
-        process.env.TEMPORAL_ADDRESS = originalEnv;
-      } );
-    } );
-
-    describe( 'CATALOG_ID', () => {
-      it( 'should accept valid catalog IDs with letters and numbers', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'catalog123'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.catalogId ).toBe( 'catalog123' );
-        expect( worker.taskQueue ).toBe( 'catalog123' );
-      } );
-
-      it( 'should accept catalog IDs with dots and hyphens', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'my.catalog-id'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.catalogId ).toBe( 'my.catalog-id' );
-      } );
-
-      it( 'should accept catalog IDs with underscores', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'my_catalog_id'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.catalogId ).toBe( 'my_catalog_id' );
-      } );
-
-      it( 'should accept catalog IDs with @ symbol', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: '@my-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.catalogId ).toBe( '@my-catalog' );
-      } );
-
-      it( 'should reject catalog IDs with special characters', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'catalog!@#$'
-        };
-
-        await expect( import( './configs.js' ) ).rejects.toThrow();
-      } );
-
-      it( 'should reject when CATALOG_ID is missing', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233'
-        };
-
-        await expect( import( './configs.js' ) ).rejects.toThrow();
-      } );
-
-      it( 'should reject empty CATALOG_ID', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: ''
-        };
-
-        await expect( import( './configs.js' ) ).rejects.toThrow();
-      } );
-    } );
-
-    describe( 'Optional Fields', () => {
-      it( 'should use default namespace when TEMPORAL_NAMESPACE is not provided', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.namespace ).toBe( 'default' );
-      } );
-
-      it( 'should use custom namespace when provided', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'test-catalog',
-          TEMPORAL_NAMESPACE: 'custom-namespace'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.namespace ).toBe( 'custom-namespace' );
-      } );
-
-      it( 'should handle TEMPORAL_API_KEY when provided', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'test-catalog',
-          TEMPORAL_API_KEY: 'secret-api-key'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.apiKey ).toBe( 'secret-api-key' );
-      } );
-
-      it( 'should handle missing TEMPORAL_API_KEY', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.apiKey ).toBeUndefined();
-      } );
-
-      it( 'should handle API_AUTH_KEY when provided', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'test-catalog',
-          API_AUTH_KEY: 'api-secret-key'
-        };
-
-        const { api } = await import( './configs.js' );
-        expect( api.authKey ).toBe( 'api-secret-key' );
-      } );
-
-      it( 'should handle missing API_AUTH_KEY', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { api } = await import( './configs.js' );
-        expect( api.authKey ).toBeUndefined();
-      } );
-
-      it( 'should handle TRACING_ENABLED when true', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'test-catalog',
-          TRACING_ENABLED: 'true'
-        };
-
-        const { tracing } = await import( './configs.js' );
-        expect( tracing.enabled ).toBe( true );
-      } );
-
-      it( 'should handle TRACING_ENABLED when false', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'test-catalog',
-          TRACING_ENABLED: 'false'
-        };
-
-        const { tracing } = await import( './configs.js' );
-        expect( tracing.enabled ).toBe( false );
-      } );
-
-      it( 'should handle missing TRACING_ENABLED', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { tracing } = await import( './configs.js' );
-        expect( tracing.enabled ).toBeUndefined();
-      } );
-    } );
-  } );
-
-  describe( 'Exported Config Objects', () => {
-    it( 'should export worker config with all properties', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'http://localhost:7233',
-        CATALOG_ID: 'test-catalog',
-        TEMPORAL_NAMESPACE: 'test-namespace',
-        TEMPORAL_API_KEY: 'test-api-key'
-      };
-
-      const { worker } = await import( './configs.js' );
-
-      expect( worker ).toEqual( {
-        address: 'http://localhost:7233',
-        apiKey: 'test-api-key',
-        executionTimeout: '1m',
-        maxActivities: 100,
-        maxWorkflows: 100,
-        namespace: 'test-namespace',
-        taskQueue: 'test-catalog',
-        catalogId: 'test-catalog'
-      } );
-    } );
-
-    it( 'should export api config', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'http://localhost:7233',
-        CATALOG_ID: 'test-catalog',
-        API_AUTH_KEY: 'test-auth-key'
-      };
-
-      const { api } = await import( './configs.js' );
-
-      expect( api ).toEqual( {
-        authKey: 'test-auth-key'
-      } );
-    } );
-
-    it( 'should export tracing config', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'http://localhost:7233',
-        CATALOG_ID: 'test-catalog',
-        TRACING_ENABLED: 'true'
-      };
-
-      const { tracing } = await import( './configs.js' );
-
-      expect( tracing ).toEqual( {
-        enabled: true
-      } );
-    } );
-
-    it( 'should have correct static worker config values', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'http://localhost:7233',
-        CATALOG_ID: 'test-catalog'
-      };
-
-      const { worker } = await import( './configs.js' );
-
-      expect( worker.executionTimeout ).toBe( '1m' );
-      expect( worker.maxActivities ).toBe( 100 );
-      expect( worker.maxWorkflows ).toBe( 100 );
-    } );
-  } );
-
-  describe( 'Error Handling', () => {
-    it( 'should throw InvalidEnvVarsErrors for invalid configuration', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'localhost:7233',
-        CATALOG_ID: 'invalid!@#'
-      };
-
-      await expect( import( './configs.js' ) ).rejects.toThrow();
-    } );
-
-    it( 'should handle multiple validation errors', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'localhost:7233',
-        CATALOG_ID: 'invalid!@#'
-      };
-
-      await expect( import( './configs.js' ) ).rejects.toThrow();
-    } );
-  } );
-
-  describe( 'Edge Cases', () => {
-    it( 'should handle environment variables with spaces', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'http://localhost:7233',
-        CATALOG_ID: 'test-catalog',
-        TEMPORAL_NAMESPACE: '  custom-namespace  '
-      };
-
-      const { worker } = await import( './configs.js' );
-      expect( worker.namespace ).toBe( '  custom-namespace  ' );
-    } );
-
-    it( 'should handle very long catalog IDs', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'http://localhost:7233',
-        CATALOG_ID: 'a'.repeat( 100 )
-      };
-
-      const { worker } = await import( './configs.js' );
-      expect( worker.catalogId ).toBe( 'a'.repeat( 100 ) );
-    } );
-
-    it( 'should handle URLs with ports outside typical range', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'http://localhost:65535',
-        CATALOG_ID: 'test-catalog'
-      };
-
-      const { worker } = await import( './configs.js' );
-      expect( worker.address ).toBe( 'http://localhost:65535' );
-    } );
-
-    it( 'should handle container names with numbers', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'temporal123:7233',
-        CATALOG_ID: 'test-catalog'
-      };
-
-      const { worker } = await import( './configs.js' );
-      expect( worker.address ).toBe( 'temporal123:7233' );
-    } );
-
-    it( 'should handle mixed case in catalog ID', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'http://localhost:7233',
-        CATALOG_ID: 'Test.Catalog-ID_123'
-      };
-
-      const { worker } = await import( './configs.js' );
-      expect( worker.catalogId ).toBe( 'Test.Catalog-ID_123' );
-    } );
-  } );
-
-  describe( 'Complete Valid Configuration', () => {
-    it( 'should handle a complete valid configuration with all optional fields', async () => {
-      process.env = {
-        TEMPORAL_ADDRESS: 'https://temporal.cloud.example.com',
-        TEMPORAL_NAMESPACE: 'production',
-        TEMPORAL_API_KEY: 'prod-api-key-123',
-        CATALOG_ID: 'prod.catalog@v1',
-        API_AUTH_KEY: 'secure-auth-key',
-        TRACING_ENABLED: 'true'
-      };
-
-      const { worker, api, tracing } = await import( './configs.js' );
-
-      expect( worker.address ).toBe( 'https://temporal.cloud.example.com' );
-      expect( worker.namespace ).toBe( 'production' );
-      expect( worker.apiKey ).toBe( 'prod-api-key-123' );
-      expect( worker.catalogId ).toBe( 'prod.catalog@v1' );
-      expect( worker.taskQueue ).toBe( 'prod.catalog@v1' );
-      expect( api.authKey ).toBe( 'secure-auth-key' );
-      expect( tracing.enabled ).toBe( true );
-    } );
-  } );
-} );

package/src/worker/internal_utils.js

@@ -1,60 +0,0 @@
-/*
- * These tools cant be used in sandbox environment!!!
- */
-import { resolve } from 'path';
-import { pathToFileURL } from 'url';
-import { METADATA_ACCESS_SYMBOL } from '#consts';
-import { writeFileSync, existsSync, readdirSync, mkdirSync } from 'fs';
-
-/**
- * Recursive traverse directories looking for files with given name,
- * For each found file, return its path, pathname and URI
- *
- * @param {string} path - The path to scan
- * @param {string[]} filenames  - The filenames to look for
- * @returns {string[{}]} An array containing an object with path, pathname and URI for each file found
- * */
-export function recursiveNavigateWhileCollecting( path, filenames, collection = [], ignoreDirNames = [ 'vendor', 'node_modules' ] ) {
-  for ( const entry of readdirSync( path, { withFileTypes: true } ) ) {
-    if ( ignoreDirNames.includes( entry.name ) ) {
-      continue;
-    }
-
-    const pathname = resolve( path, entry.name );
-    if ( entry.isDirectory() ) {
-      recursiveNavigateWhileCollecting( pathname, filenames, collection );
-    } else if ( filenames.includes( entry.name ) ) {
-      collection.push( { pathname, path, url: pathToFileURL( pathname ).href } );
-    }
-  }
-
-  return collection;
-};
-
-/**
- * For each path, dynamic import it, and for each exported component with metadata (step, workflow), yields it.
- * @param {string[]} paths - Paths of the files to import
- */
-export async function *iteratorOverImportedComponents( paths ) {
-  for ( const { url, path, pathname } of paths ) {
-    const imported = await import( url );
-    for ( const component of Object.values( imported ) ) {
-      const metadata = component[METADATA_ACCESS_SYMBOL];
-      if ( !metadata ) {
-        continue;
-      }
-      yield { component, metadata, path, pathname };
-    }
-  }
-};
-
-/**
- * Write a file using the same signature as Node's FS writeFileSync, but recursively creates the necessary directories in the path.
- */
-export function writeFileOnLocationSync( path, content ) {
-  const targetDir = path.split( '/' ).slice( 0, -1 ).join( '/' );
-  if ( targetDir && !existsSync( targetDir ) ) {
-    mkdirSync( targetDir, { recursive: true } );
-  }
-  writeFileSync( path, content, 'utf-8' );
-};

package/src/worker/internal_utils.spec.js

@@ -1,134 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, existsSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { tmpdir } from 'node:os';
-import { pathToFileURL } from 'node:url';
-import { recursiveNavigateWhileCollecting, iteratorOverImportedComponents, writeFileOnLocationSync } from './internal_utils.js';
-
-function makeTmpRoot( prefix ) {
-  return mkdtempSync( join( tmpdir(), prefix ) );
-}
-
-describe( '.recursiveNavigateWhileCollecting', () => {
-  it( 'collects matching files recursively (happy path)', () => {
-    const root = makeTmpRoot( 'nsu-happy-' );
-    const target = 'target.txt';
-
-    // layout:
-    // root/target.txt
-    // root/a/target.txt
-    // root/b/c/target.txt
-    mkdirSync( join( root, 'a' ), { recursive: true } );
-    mkdirSync( join( root, 'b', 'c' ), { recursive: true } );
-    writeFileSync( join( root, target ), 'root' );
-    writeFileSync( join( root, 'a', target ), 'a' );
-    writeFileSync( join( root, 'b', 'c', target ), 'bc' );
-
-    const results = recursiveNavigateWhileCollecting( root, [ target ] );
-
-    expect( results.length ).toBe( 3 );
-    for ( const { pathname, path, url } of results ) {
-      expect( url ).toBe( pathToFileURL( pathname ).href );
-      expect( resolve( path, target ) ).toBe( pathname );
-    }
-
-    rmSync( root, { recursive: true, force: true } );
-  } );
-
-  it( 'skips files inside ignored directories (ignoreDirNames)', () => {
-    const root = makeTmpRoot( 'nsu-ignore-' );
-    const target = 'target.txt';
-
-    // layout:
-    // root/node_modules/target.txt   (ignored)
-    // root/vendor/target.txt         (ignored)
-    // root/ok/target.txt             (collected)
-    mkdirSync( join( root, 'node_modules' ), { recursive: true } );
-    mkdirSync( join( root, 'vendor' ), { recursive: true } );
-    mkdirSync( join( root, 'ok' ), { recursive: true } );
-    writeFileSync( join( root, 'node_modules', target ), 'nm' );
-    writeFileSync( join( root, 'vendor', target ), 'v' );
-    writeFileSync( join( root, 'ok', target ), 'ok' );
-
-    const results = recursiveNavigateWhileCollecting( root, [ target ] );
-
-    expect( results.length ).toBe( 1 );
-    expect( results[0].pathname ).toBe( join( root, 'ok', target ) );
-    expect( results[0].path ).toBe( join( root, 'ok' ) );
-    expect( results[0].url ).toBe( pathToFileURL( results[0].pathname ).href );
-
-    rmSync( root, { recursive: true, force: true } );
-  } );
-} );
-
-describe( '.iteratorOverImportedComponents', () => {
-  it( 'imports modules and yields metadata from exports tagged with METADATA_ACCESS_SYMBOL', async () => {
-    const root = join( process.cwd(), 'sdk/core/temp_test_modules', `meta-${Date.now()}` );
-    mkdirSync( root, { recursive: true } );
-    const file = join( root, 'meta.module.js' );
-    writeFileSync( file, [
-      'import { METADATA_ACCESS_SYMBOL } from \"#consts\";',
-      'export const StepA = () => {};',
-      'StepA[METADATA_ACCESS_SYMBOL] = { kind: \"step\", name: \"a\" };',
-      'export const FlowB = () => {};',
-      'FlowB[METADATA_ACCESS_SYMBOL] = { kind: \"workflow\", name: \"b\" };'
-    ].join( '\n' ) );
-
-    const paths = recursiveNavigateWhileCollecting( root, [ 'meta.module.js' ] );
-    const collected = [];
-    for await ( const m of iteratorOverImportedComponents( paths ) ) {
-      collected.push( m );
-    }
-
-    expect( collected.length ).toBe( 2 );
-    expect( collected.map( m => m.metadata.name ).sort() ).toEqual( [ 'a', 'b' ] );
-    expect( collected.map( m => m.metadata.kind ).sort() ).toEqual( [ 'step', 'workflow' ] );
-    for ( const m of collected ) {
-      expect( m.pathname ).toBe( file );
-      expect( m.path ).toBe( root );
-      expect( typeof m.component ).toBe( 'function' );
-    }
-
-    rmSync( root, { recursive: true, force: true } );
-  } );
-
-  it( 'ignores exports without metadata symbol', async () => {
-    const root = join( process.cwd(), 'sdk/core/temp_test_modules', `meta-${Date.now()}-nometa` );
-    mkdirSync( root, { recursive: true } );
-    const file = join( root, 'meta.module.js' );
-    writeFileSync( file, [
-      'export const Plain = () => {};',
-      'export const AlsoPlain = {}'
-    ].join( '\n' ) );
-
-    const paths = recursiveNavigateWhileCollecting( root, [ 'meta.module.js' ] );
-    const collected = [];
-    for await ( const m of iteratorOverImportedComponents( paths ) ) {
-      collected.push( m );
-    }
-
-    expect( collected.length ).toBe( 0 );
-    rmSync( root, { recursive: true, force: true } );
-  } );
-} );
-
-describe( '.writeFileOnLocationSync', () => {
-  it( 'creates missing directories and writes file', () => {
-    const root = makeTmpRoot( 'nsu-write-' );
-    const nested = join( root, 'a', 'b', 'c.txt' );
-    writeFileOnLocationSync( nested, 'hello' );
-    expect( existsSync( join( root, 'a', 'b' ) ) ).toBe( true );
-    expect( readFileSync( nested, 'utf-8' ) ).toBe( 'hello' );
-    rmSync( root, { recursive: true, force: true } );
-  } );
-
-  it( 'overwrites existing content', () => {
-    const root = makeTmpRoot( 'nsu-write2-' );
-    const file = join( root, 'x', 'y.txt' );
-    mkdirSync( join( root, 'x' ), { recursive: true } );
-    writeFileSync( file, 'old' );
-    writeFileOnLocationSync( file, 'new' );
-    expect( readFileSync( file, 'utf-8' ) ).toBe( 'new' );
-    rmSync( root, { recursive: true, force: true } );
-  } );
-} );

package/src/worker/tracer/index.js

@@ -1,75 +0,0 @@
-import { Storage } from '../async_storage.js';
-import { mkdirSync, existsSync, readdirSync, appendFileSync } from 'node:fs';
-import { join } from 'path';
-import { EOL } from 'os';
-import { buildLogTree } from './tracer_tree.js';
-import { tracing as tracingConfig } from '#configs';
-
-const callerDir = process.argv[2];
-
-/**
- * Appends new information to a file
- *
- * Information has to be a JSON
- *
- * File is encoded in utf-8
- *
- * @param {string} path - The full filename
- * @param {object} json - The content
- */
-const flushEntry = ( path, json ) => appendFileSync( path, JSON.stringify( json ) + EOL, 'utf-8' );
-
-/**
- * Add an event to the execution trace file.
- *
- * Events normally are the result of an operation, either a function call or an IO.
- *
- * @param {object} options
- * @param {string} options.lib - The macro part of the platform that triggered the event
- * @param {string} options.event - The name of the event
- * @param {any} [options.input] - The input of the operation
- * @param {any} [options.output] - The output of the operation
- */
-export function trace( { lib, event, input = undefined, output = undefined } ) {
-  const now = Date.now();
-
-  if ( !tracingConfig.enabled ) {
-    return;
-  }
-
-  const {
-    activityId: stepId,
-    activityType: stepName,
-    workflowId,
-    workflowType,
-    workflowPath,
-    parentWorkflowId,
-    rootWorkflowId,
-    rootWorkflowType
-  } = Storage.load();
-
-  const entry = { event, input, lib, output, parentWorkflowId, stepId, stepName, timestamp: now, workflowId, workflowPath, workflowType };
-
-  // test for rootWorkflow to append to the same file as the parent/grandparent
-  const outputDir = join( callerDir, 'logs', 'runs', rootWorkflowType ?? workflowType );
-  if ( !existsSync( outputDir ) ) {
-    mkdirSync( outputDir, { recursive: true } );
-  }
-
-  const suffix = `-${rootWorkflowId ?? workflowId}.raw`;
-  const logFile = readdirSync( outputDir ).find( f => f.endsWith( suffix ) ) ?? `${new Date( now ).toISOString()}-${suffix}`;
-  const logPath = join( outputDir, logFile );
-
-  flushEntry( logPath, entry );
-  buildLogTree( logPath );
-};
-
-/**
- * Setup the global tracer function, so it is available to be used by other libraries
- *
- * It will be situated in the global object, under Symbol.for('__trace')
- *
- * @returns {object} The assigned globalThis
- */
-export const setupGlobalTracer = () =>
-  Object.defineProperty( globalThis, Symbol.for( '__trace' ), { value: trace, writable: false, enumerable: false, configurable: false } );