@output.ai/core 0.0.11 → 0.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "The core module of the output framework",
   "type": "module",
   "main": "src/index.js",

package/src/configs.js

@@ -1,61 +1,19 @@
 import * as z from 'zod';
 
-class InvalidEnvVarsErrors extends Error {}
-
-const ipv4Validator = z.ipv4();
-const ipv6Validator = z.ipv6();
-const portValidator = z.number().int().min( 10 ).max( 65535 ).optional();
-
-const ipValidator = z.union( [ ipv4Validator, ipv6Validator ] );
-
-const likelyIpv6 = val => val.startsWith( '[' );
-
-const splitIpWithPort = val => {
-  // ipv6
-  if ( likelyIpv6( val ) ) {
-    const address = val.slice( 1, val.lastIndexOf( ']' ) );
-    const portString = val.split( ']' )[1].slice( 1 ); // remove the :
-    const port = portString ? parseInt( portString, 10 ) : undefined;
-    return { address, port };
-  }
-
-  // ipv4
-  const parts = val.split( ':' );
-  if ( parts.length !== 2 ) {
-    return { address: val, port: undefined };
-  }
-
-  const [ address, portString ] = parts;
-  const port = portString ? parseInt( portString, 10 ) : undefined;
-  return { address, port };
-};
-
-const ipWithOptionalPort = z.string().refine(
-  val => {
-    const { address, port } = splitIpWithPort( val );
-    return ipValidator.safeParse( address ).success && portValidator.safeParse( port ).success;
-  },
-  {
-    message: 'Must be a valid IP address'
-  }
-);
+class InvalidEnvVarsErrors extends Error { }
 
 const envVarSchema = z.object( {
-  TEMPORAL_ADDRESS: z.union( [
-    z.string().regex( /^https?:\/\/.+/ ), // HTTP or HTTPS URLs
-    z.string().regex( /^[a-z0-9_-]+:\d{2,5}$/i ), // local docker container name like worker:7233
-    ipWithOptionalPort // IP address (IPv4 or IPv6) with port
-  ] ),
+  TEMPORAL_ADDRESS: z.string().optional().default( 'localhost:7233' ),
   TEMPORAL_NAMESPACE: z.string().optional().default( 'default' ),
   TEMPORAL_API_KEY: z.string().optional(),
   CATALOG_ID: z.string().regex( /^[a-z0-9_.@-]+$/i ),
   API_AUTH_KEY: z.string().optional(),
-  TRACING_ENABLED: z.enum( [ 'true', 'false' ] ).optional()
+  TRACING_ENABLED: z.stringbool().optional()
 } );
 
 const { data: safeEnvVar, error } = envVarSchema.safeParse( process.env );
 if ( error ) {
-  throw new InvalidEnvVarsErrors( JSON.stringify( error.format(), null, 2 ) );
+  throw new InvalidEnvVarsErrors( z.prettifyError( error ) );
 }
 
 export const worker = {

package/src/configs.spec.js

@@ -14,139 +14,38 @@ describe( 'configs', () => {
 
   describe( 'Environment Variable Validation', () => {
     describe( 'TEMPORAL_ADDRESS', () => {
-      it( 'should accept valid http URLs', async () => {
+      it( 'should accept string addresses', async () => {
         process.env = {
-          TEMPORAL_ADDRESS: 'http://localhost:7233',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.address ).toBe( 'http://localhost:7233' );
-      } );
-
-      it( 'should accept valid https URLs', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'https://temporal.example.com',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.address ).toBe( 'https://temporal.example.com' );
-      } );
-
-      it( 'should accept docker container names with ports', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'temporal-server:7233',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.address ).toBe( 'temporal-server:7233' );
-      } );
-
-      it( 'should accept container names with underscores and hyphens', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'my_temporal-server:7233',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.address ).toBe( 'my_temporal-server:7233' );
-      } );
-
-      it( 'should accept IP addresses with HTTP', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'http://192.168.1.100:7233',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.address ).toBe( 'http://192.168.1.100:7233' );
-      } );
-
-      it( 'should accept IP addresses with HTTPS', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'https://10.0.0.1:7233',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.address ).toBe( 'https://10.0.0.1:7233' );
-      } );
-
-      it( 'should accept IP addresses without protocol for docker format', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: '172.17.0.2:7233',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        const { worker } = await import( './configs.js' );
-        expect( worker.address ).toBe( '172.17.0.2:7233' );
-      } );
-
-      it( 'should accept IPv6 addresses with brackets and port', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: '[2001:db8::1]:7233',
+          TEMPORAL_ADDRESS: 'localhost:7233',
           CATALOG_ID: 'test-catalog'
         };
 
         const { worker } = await import( './configs.js' );
-        expect( worker.address ).toBe( '[2001:db8::1]:7233' );
+        expect( worker.address ).toBe( 'localhost:7233' );
       } );
 
-      it( 'should accept IPv6 addresses with HTTP', async () => {
+      it( 'should use default when omitted', async () => {
         process.env = {
-          TEMPORAL_ADDRESS: 'http://[2001:db8::1]:7233',
           CATALOG_ID: 'test-catalog'
         };
 
         const { worker } = await import( './configs.js' );
-        expect( worker.address ).toBe( 'http://[2001:db8::1]:7233' );
+        expect( worker.address ).toBe( 'localhost:7233' );
       } );
 
-      it( 'should accept IPv6 addresses with HTTPS', async () => {
+      it( 'should reject non-string values', async () => {
         process.env = {
-          TEMPORAL_ADDRESS: 'https://[::1]:7233',
+          TEMPORAL_ADDRESS: '123',
           CATALOG_ID: 'test-catalog'
         };
 
-        const { worker } = await import( './configs.js' );
-        expect( worker.address ).toBe( 'https://[::1]:7233' );
-      } );
-
-      it( 'should reject invalid addresses', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'not-a-valid-address',
-          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();
-      } );
 
-      it( 'should reject addresses without ports in container format', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'temporal-server',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        await expect( import( './configs.js' ) ).rejects.toThrow();
-      } );
-
-      it( 'should reject addresses with single digit port numbers', async () => {
-        process.env = {
-          TEMPORAL_ADDRESS: 'temporal-server:1',
-          CATALOG_ID: 'test-catalog'
-        };
-
-        await expect( import( './configs.js' ) ).rejects.toThrow();
-      } );
-
-      it( 'should reject when TEMPORAL_ADDRESS is missing', async () => {
-        process.env = {
-          CATALOG_ID: 'test-catalog'
-        };
-
-        await expect( import( './configs.js' ) ).rejects.toThrow();
+        process.env.TEMPORAL_ADDRESS = originalEnv;
       } );
     } );
 
@@ -291,7 +190,7 @@ describe( 'configs', () => {
         };
 
         const { tracing } = await import( './configs.js' );
-        expect( tracing.enabled ).toBe( 'true' );
+        expect( tracing.enabled ).toBe( true );
       } );
 
       it( 'should handle TRACING_ENABLED when false', async () => {
@@ -302,7 +201,7 @@ describe( 'configs', () => {
         };
 
         const { tracing } = await import( './configs.js' );
-        expect( tracing.enabled ).toBe( 'false' );
+        expect( tracing.enabled ).toBe( false );
       } );
 
       it( 'should handle missing TRACING_ENABLED', async () => {
@@ -364,7 +263,7 @@ describe( 'configs', () => {
       const { tracing } = await import( './configs.js' );
 
       expect( tracing ).toEqual( {
-        enabled: 'true'
+        enabled: true
       } );
     } );
 
@@ -385,8 +284,8 @@ describe( 'configs', () => {
   describe( 'Error Handling', () => {
     it( 'should throw InvalidEnvVarsErrors for invalid configuration', async () => {
       process.env = {
-        TEMPORAL_ADDRESS: 'invalid',
-        CATALOG_ID: 'test-catalog'
+        TEMPORAL_ADDRESS: 'localhost:7233',
+        CATALOG_ID: 'invalid!@#'
       };
 
       await expect( import( './configs.js' ) ).rejects.toThrow();
@@ -394,7 +293,7 @@ describe( 'configs', () => {
 
     it( 'should handle multiple validation errors', async () => {
       process.env = {
-        TEMPORAL_ADDRESS: 'invalid',
+        TEMPORAL_ADDRESS: 'localhost:7233',
         CATALOG_ID: 'invalid!@#'
       };
 
@@ -474,7 +373,7 @@ describe( 'configs', () => {
       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' );
+      expect( tracing.enabled ).toBe( true );
     } );
   } );
 } );

package/src/internal_activities/index.js

@@ -48,8 +48,20 @@ export const sendWebhookPost = async ( { url, workflowId, payload } ) => {
  */
 export const readTraceFile = async ( { workflowType, workflowId } ) => {
   const dir = join( callerDir, 'logs', 'runs', workflowType );
+
+  if ( !existsSync( dir ) ) {
+    console.log( '[Core.ReadTraceFile]', 'Trace folder not found', dir );
+    return [];
+  }
+
   const suffix = `-${workflowId}.raw`;
-  const file = join( dir, readdirSync( dir ).find( f => f.endsWith( suffix ) ) );
+  const matchingFile = readdirSync( dir ).find( f => f.endsWith( suffix ) );
+
+  if ( !matchingFile ) {
+    console.log( '[Core.ReadTraceFile]', 'Trace file not found', dir, suffix );
+    return [];
+  }
 
-  return existsSync( file ) ? readFileSync( file, 'utf-8' ).split( '\n' ) : null;
+  const file = join( dir, matchingFile );
+  return existsSync( file ) ? readFileSync( file, 'utf-8' ).split( '\n' ) : [];
 };