@forgehive/hive-sdk 0.0.4 → 0.1.1

package/src/test/metadata.test.ts

@@ -77,8 +77,15 @@ describe('HiveLogClient Metadata', () => {
     it('should send log without metadata parameter', async () => {
       mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
 
-      const logItem = { input: 'test-input', output: 'test-output' }
-      const result = await client.sendLog('test-task', logItem)
+      const executionRecord = {
+        input: 'test-input',
+        output: 'test-output',
+        taskName: 'test-task',
+        type: 'success' as const,
+        boundaries: {},
+        metadata: {}
+      }
+      const result = await client.sendLog(executionRecord)
 
       expect(result).toBe('success')
       expect(mockedAxios.post).toHaveBeenCalledWith(
@@ -89,6 +96,9 @@ describe('HiveLogClient Metadata', () => {
           logItem: JSON.stringify({
             input: 'test-input',
             output: 'test-output',
+            taskName: 'test-task',
+            type: 'success',
+            boundaries: {},
             metadata: {}
           })
         },
@@ -104,13 +114,20 @@ describe('HiveLogClient Metadata', () => {
     it('should send log with metadata parameter', async () => {
       mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
 
-      const logItem = { input: 'test-input', output: 'test-output' }
+      const executionRecord = {
+        input: 'test-input',
+        output: 'test-output',
+        taskName: 'test-task',
+        type: 'success' as const,
+        boundaries: {},
+        metadata: {}
+      }
       const metadata: Metadata = {
         requestId: 'req-123',
         userId: 'user-456'
       }
 
-      const result = await client.sendLog('test-task', logItem, metadata)
+      const result = await client.sendLog(executionRecord, metadata)
 
       expect(result).toBe('success')
       expect(mockedAxios.post).toHaveBeenCalledWith(
@@ -121,6 +138,9 @@ describe('HiveLogClient Metadata', () => {
           logItem: JSON.stringify({
             input: 'test-input',
             output: 'test-output',
+            taskName: 'test-task',
+            type: 'success',
+            boundaries: {},
             metadata: {
               requestId: 'req-123',
               userId: 'user-456'
@@ -140,7 +160,7 @@ describe('HiveLogClient Metadata', () => {
       mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
 
       const metadata: Metadata = { type: 'minimal' }
-      const result = await client.sendLog('test-task', { input: 'simple input' }, metadata)
+      const result = await client.sendLog({ input: 'simple input', taskName: 'test-task', type: 'success' as const, boundaries: {}, metadata: {} }, metadata)
 
       expect(result).toBe('success')
       expect(mockedAxios.post).toHaveBeenCalledWith(
@@ -150,6 +170,9 @@ describe('HiveLogClient Metadata', () => {
           taskName: 'test-task',
           logItem: JSON.stringify({
             input: 'simple input',
+            taskName: 'test-task',
+            type: 'success',
+            boundaries: {},
             metadata: { type: 'minimal' }
           })
         },
@@ -161,7 +184,7 @@ describe('HiveLogClient Metadata', () => {
       mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
 
       const metadata: Metadata = { type: 'null-test' }
-      const result = await client.sendLog('test-task', { input: null }, metadata)
+      const result = await client.sendLog({ input: null, taskName: 'test-task', type: 'success' as const, boundaries: {}, metadata: {} }, metadata)
 
       expect(result).toBe('success')
       expect(mockedAxios.post).toHaveBeenCalledWith(
@@ -171,6 +194,9 @@ describe('HiveLogClient Metadata', () => {
           taskName: 'test-task',
           logItem: JSON.stringify({
             input: null,
+            taskName: 'test-task',
+            type: 'success',
+            boundaries: {},
             metadata: { type: 'null-test' }
           })
         },
@@ -191,10 +217,13 @@ describe('HiveLogClient Metadata', () => {
       const client = new HiveLogClient({ ...testConfig, metadata: baseMetadata })
       const logItem = { input: 'test' }
 
-      await client.sendLog('test-task', logItem)
+      await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success' as const, boundaries: {}, metadata: {} })
 
       const expectedLogItem = {
         input: 'test',
+        taskName: 'test-task',
+        type: 'success',
+        boundaries: {},
         metadata: {
           environment: 'production',
           version: '1.0.0'
@@ -229,7 +258,7 @@ describe('HiveLogClient Metadata', () => {
         }
       }
 
-      await client.sendLog('test-task', logItem)
+      await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success' as const, boundaries: {}, metadata: logItem.metadata || {} })
 
       const expectedLogItem = {
         input: 'test',
@@ -237,7 +266,10 @@ describe('HiveLogClient Metadata', () => {
           environment: 'production', // from base
           version: '1.1.0',          // from logItem (overrides base)
           sessionId: 'session-123'   // from logItem
-        }
+        },
+        taskName: 'test-task',
+        type: 'success',
+        boundaries: {}
       }
 
       expect(mockedAxios.post).toHaveBeenCalledWith(
@@ -276,7 +308,7 @@ describe('HiveLogClient Metadata', () => {
         priority: 'sendLog'
       }
 
-      await client.sendLog('test-task', logItem, sendLogMetadata)
+      await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success' as const, boundaries: {}, metadata: logItem.metadata || {} }, sendLogMetadata)
 
       const expectedLogItem = {
         input: 'test',
@@ -286,7 +318,10 @@ describe('HiveLogClient Metadata', () => {
           priority: 'sendLog',        // from sendLog (highest priority)
           sessionId: 'session-123',   // from logItem
           requestId: 'req-456'        // from sendLog
-        }
+        },
+        taskName: 'test-task',
+        type: 'success',
+        boundaries: {}
       }
 
       expect(mockedAxios.post).toHaveBeenCalledWith(
@@ -327,7 +362,7 @@ describe('HiveLogClient Metadata', () => {
         version: '1.2.0'  // overrides both base and logItem
       }
 
-      await client.sendLog('search-task', logItem, sendLogMetadata)
+      await client.sendLog({ ...logItem, taskName: 'search-task', type: 'success' as const, boundaries: {}, metadata: logItem.metadata || {} }, sendLogMetadata)
 
       const expectedLogItem = {
         input: { query: 'search' },
@@ -341,7 +376,10 @@ describe('HiveLogClient Metadata', () => {
           processingTime: '250',        // from logItem
           requestId: 'req-789',         // from sendLog
           userId: 'user-123'            // from sendLog
-        }
+        },
+        taskName: 'search-task',
+        type: 'success',
+        boundaries: {}
       }
 
       expect(mockedAxios.post).toHaveBeenCalledWith(
@@ -368,10 +406,13 @@ describe('HiveLogClient Metadata', () => {
         // No metadata property
       }
 
-      await client.sendLog('test-task', logItem)
+      await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success' as const, boundaries: {}, metadata: {} })
 
       const expectedLogItem = {
         input: 'test',
+        taskName: 'test-task',
+        type: 'success',
+        boundaries: {},
         metadata: {
           environment: 'test' // Only base metadata should be used
         }
@@ -399,13 +440,16 @@ describe('HiveLogClient Metadata', () => {
         metadata: undefined
       }
 
-      await client.sendLog('test-task', logItem)
+      await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success' as const, boundaries: {}, metadata: logItem.metadata || {} })
 
       const expectedLogItem = {
         input: 'test',
         metadata: {
           environment: 'test' // Only base metadata should be used
-        }
+        },
+        taskName: 'test-task',
+        type: 'success',
+        boundaries: {}
       }
 
       expect(mockedAxios.post).toHaveBeenCalledWith(
@@ -425,11 +469,14 @@ describe('HiveLogClient Metadata', () => {
       const client = new HiveLogClient({ ...testConfig, metadata: {} })
       const logItem = { input: 'test', metadata: {} }
 
-      await client.sendLog('test-task', logItem, {})
+      await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success' as const, boundaries: {}, metadata: logItem.metadata || {} }, {})
 
       const expectedLogItem = {
         input: 'test',
-        metadata: {} // All empty metadata objects result in empty final metadata
+        metadata: {}, // All empty metadata objects result in empty final metadata
+        taskName: 'test-task',
+        type: 'success',
+        boundaries: {}
       }
 
       expect(mockedAxios.post).toHaveBeenCalledWith(
@@ -447,7 +494,7 @@ describe('HiveLogClient Metadata', () => {
       const baseMetadata: Metadata = { environment: 'test' }
       const silentClient = new HiveLogClient({ projectName: 'silent-project', metadata: baseMetadata })
 
-      const result = await silentClient.sendLog('test-task', { input: 'test' }, { requestId: 'req-123' })
+      const result = await silentClient.sendLog({ input: 'test', taskName: 'test-task', type: 'success' as const, boundaries: {}, metadata: {} }, { requestId: 'req-123' })
 
       expect(result).toBe('silent')
       expect(mockedAxios.post).not.toHaveBeenCalled()
@@ -459,7 +506,7 @@ describe('HiveLogClient Metadata', () => {
       const baseMetadata: Metadata = { environment: 'test' }
       const client = new HiveLogClient({ ...testConfig, metadata: baseMetadata })
 
-      const result = await client.sendLog('test-task', { input: 'test' }, { requestId: 'req-123' })
+      const result = await client.sendLog({ input: 'test', taskName: 'test-task', type: 'success' as const, boundaries: {}, metadata: {} }, { requestId: 'req-123' })
 
       expect(result).toBe('error')
     })

package/src/test/sendLog.test.ts

@@ -5,7 +5,7 @@ import { HiveLogClient } from '../index'
 jest.mock('axios')
 const mockedAxios = axios as jest.Mocked<typeof axios>
 
-describe('HiveLogClient sendLog', () => {
+describe('HiveLogClient sendLog with ExecutionRecord', () => {
   let client: HiveLogClient
 
   const testConfig = {
@@ -23,13 +23,21 @@ describe('HiveLogClient sendLog', () => {
     jest.clearAllMocks()
   })
 
-  describe('successful sendLog', () => {
-    it('should send log successfully and return true', async () => {
+  describe('successful sendLog with ExecutionRecord', () => {
+    it('should send log successfully with ExecutionRecord and return success', async () => {
       // Mock successful axios response
       mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
 
-      const logItem = { input: 'test-input', output: 'test-output' }
-      const result = await client.sendLog('test-task', logItem)
+      const executionRecord = {
+        input: { value: 'test-input' },
+        output: { result: 'test-output' },
+        taskName: 'test-task',
+        type: 'success' as const,
+        boundaries: {},
+        metadata: {}
+      }
+
+      const result = await client.sendLog(executionRecord)
 
       expect(result).toBe('success')
       expect(mockedAxios.post).toHaveBeenCalledTimes(1)
@@ -38,7 +46,14 @@ describe('HiveLogClient sendLog', () => {
         {
           projectName: 'test-project',
           taskName: 'test-task',
-          logItem: JSON.stringify({ ...logItem, metadata: {} })
+          logItem: JSON.stringify({
+            input: { value: 'test-input' },
+            output: { result: 'test-output' },
+            taskName: 'test-task',
+            type: 'success',
+            boundaries: {},
+            metadata: {}
+          })
         },
         {
           headers: {
@@ -49,19 +64,30 @@ describe('HiveLogClient sendLog', () => {
       )
     })
 
-    it('should handle complex log items', async () => {
+    it('should handle ExecutionRecord with complex boundaries', async () => {
       mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
 
-      const complexLogItem = {
+      const executionRecord = {
         input: { userId: 123, action: 'login' },
         output: { success: true, sessionId: 'abc123' },
-        error: null,
+        taskName: 'complex-task',
+        type: 'success' as const,
         boundaries: {
-          database: [{ input: 'SELECT * FROM users', output: [{ id: 123 }], error: null }]
-        }
+          database: [{
+            input: ['SELECT * FROM users'],
+            output: [{ id: 123 }],
+            timing: { startTime: 1000, endTime: 1100, duration: 100 }
+          }],
+          api: [{
+            input: [{ endpoint: '/auth' }],
+            output: { token: 'jwt123' },
+            timing: { startTime: 1200, endTime: 1250, duration: 50 }
+          }]
+        },
+        metadata: { environment: 'test' }
       }
 
-      const result = await client.sendLog('complex-task', complexLogItem)
+      const result = await client.sendLog(executionRecord)
 
       expect(result).toBe('success')
       expect(mockedAxios.post).toHaveBeenCalledWith(
@@ -69,7 +95,25 @@ describe('HiveLogClient sendLog', () => {
         {
           projectName: 'test-project',
           taskName: 'complex-task',
-          logItem: JSON.stringify({ ...complexLogItem, metadata: {} })
+          logItem: JSON.stringify({
+            input: { userId: 123, action: 'login' },
+            output: { success: true, sessionId: 'abc123' },
+            taskName: 'complex-task',
+            type: 'success',
+            boundaries: {
+              database: [{
+                input: ['SELECT * FROM users'],
+                output: [{ id: 123 }],
+                timing: { startTime: 1000, endTime: 1100, duration: 100 }
+              }],
+              api: [{
+                input: [{ endpoint: '/auth' }],
+                output: { token: 'jwt123' },
+                timing: { startTime: 1200, endTime: 1250, duration: 50 }
+              }]
+            },
+            metadata: { environment: 'test' }
+          })
         },
         {
           headers: {
@@ -79,64 +123,288 @@ describe('HiveLogClient sendLog', () => {
         }
       )
     })
+
+    it('should handle ExecutionRecord with error', async () => {
+      mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
+
+      const executionRecord = {
+        input: { value: 'test-input' },
+        output: undefined,
+        error: 'Task execution failed',
+        taskName: 'error-task',
+        type: 'error' as const,
+        boundaries: {},
+        metadata: {}
+      }
+
+      const result = await client.sendLog(executionRecord)
+
+      expect(result).toBe('success')
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/log-ingest',
+        {
+          projectName: 'test-project',
+          taskName: 'error-task',
+          logItem: JSON.stringify({
+            input: { value: 'test-input' },
+            output: undefined,
+            error: 'Task execution failed',
+            taskName: 'error-task',
+            type: 'error',
+            boundaries: {},
+            metadata: {}
+          })
+        },
+        expect.any(Object)
+      )
+    })
+
+    it('should use "unknown-task" when taskName is missing', async () => {
+      mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
+
+      const executionRecord = {
+        input: { value: 'test-input' },
+        output: { result: 'test-output' },
+        // taskName is missing
+        type: 'success' as const,
+        boundaries: {},
+        metadata: {}
+      }
+
+      const result = await client.sendLog(executionRecord)
+
+      expect(result).toBe('success')
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/log-ingest',
+        {
+          projectName: 'test-project',
+          taskName: 'unknown-task',
+          logItem: JSON.stringify({
+            input: { value: 'test-input' },
+            output: { result: 'test-output' },
+            type: 'success',
+            boundaries: {},
+            metadata: {},
+            taskName: 'unknown-task'
+          })
+        },
+        expect.any(Object)
+      )
+    })
+  })
+
+  describe('sendLog with additional metadata', () => {
+    it('should merge metadata from ExecutionRecord and sendLog parameter', async () => {
+      mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
+
+      const executionRecord = {
+        input: { value: 'test-input' },
+        output: { result: 'test-output' },
+        taskName: 'metadata-task',
+        type: 'success' as const,
+        boundaries: {},
+        metadata: {
+          recordMeta: 'from-record',
+          sharedKey: 'record-value'
+        }
+      }
+
+      const sendLogMetadata = {
+        sendLogMeta: 'from-sendlog',
+        sharedKey: 'sendlog-value' // This should override record value
+      }
+
+      const result = await client.sendLog(executionRecord, sendLogMetadata)
+
+      expect(result).toBe('success')
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/log-ingest',
+        {
+          projectName: 'test-project',
+          taskName: 'metadata-task',
+          logItem: JSON.stringify({
+            input: { value: 'test-input' },
+            output: { result: 'test-output' },
+            taskName: 'metadata-task',
+            type: 'success',
+            boundaries: {},
+            metadata: {
+              recordMeta: 'from-record',
+              sharedKey: 'sendlog-value', // sendLog metadata takes priority
+              sendLogMeta: 'from-sendlog'
+            }
+          })
+        },
+        expect.any(Object)
+      )
+    })
   })
 
   describe('failed sendLog', () => {
-    it('should return false when axios throws an error', async () => {
+    it('should return error when axios throws an error', async () => {
       // Mock axios to throw an error
       mockedAxios.post.mockRejectedValueOnce(new Error('Network error'))
 
-      const logItem = { input: 'test-input' }
-      const result = await client.sendLog('test-task', logItem)
+      const executionRecord = {
+        input: { value: 'test-input' },
+        taskName: 'test-task',
+        type: 'success' as const,
+        boundaries: {},
+        metadata: {}
+      }
+
+      const result = await client.sendLog(executionRecord)
 
       expect(result).toBe('error')
     })
 
-    it('should return false when server returns 500', async () => {
+    it('should return error when server returns 500', async () => {
       // Mock axios to throw a server error
       const serverError = new Error('Server Error')
       mockedAxios.post.mockRejectedValueOnce(serverError)
 
-      const result = await client.sendLog('test-task', { input: 'test' })
+      const executionRecord = {
+        input: { value: 'test' },
+        taskName: 'test-task',
+        type: 'success' as const,
+        boundaries: {},
+        metadata: {}
+      }
+
+      const result = await client.sendLog(executionRecord)
 
       expect(result).toBe('error')
     })
   })
 
-  describe('sendLog parameters', () => {
-    it('should handle log items with minimal input', async () => {
+  describe('sendLog in silent mode', () => {
+    it('should return silent when client is not initialized', async () => {
+      const uninitializedClient = new HiveLogClient({
+        projectName: 'test-project'
+        // No API credentials
+      })
+
+      const executionRecord = {
+        input: { value: 'test-input' },
+        taskName: 'test-task',
+        type: 'success' as const,
+        boundaries: {},
+        metadata: {}
+      }
+
+      const result = await uninitializedClient.sendLog(executionRecord)
+
+      expect(result).toBe('silent')
+      expect(mockedAxios.post).not.toHaveBeenCalled()
+    })
+  })
+})
+
+
+describe('HiveLogClient getListener', () => {
+  let client: HiveLogClient
+
+  const testConfig = {
+    projectName: 'test-project',
+    apiKey: 'test-api-key',
+    apiSecret: 'test-api-secret',
+    host: 'https://test-host.com'
+  }
+
+  beforeEach(() => {
+    client = new HiveLogClient(testConfig)
+    jest.clearAllMocks()
+  })
+
+  describe('getListener method', () => {
+    it('should return a function that calls sendLog', async () => {
       mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
 
-      const result = await client.sendLog('minimal-task', { input: 'minimal input' })
+      const listener = client.getListener()
 
-      expect(result).toBe('success')
+      expect(typeof listener).toBe('function')
+
+      const executionRecord = {
+        input: { value: 'test-input' },
+        output: { result: 'test-output' },
+        taskName: 'test-task',
+        type: 'success' as const,
+        boundaries: {},
+        metadata: {}
+      }
+
+      await listener(executionRecord)
+
+      expect(mockedAxios.post).toHaveBeenCalledTimes(1)
       expect(mockedAxios.post).toHaveBeenCalledWith(
         'https://test-host.com/api/tasks/log-ingest',
         {
           projectName: 'test-project',
-          taskName: 'minimal-task',
-          logItem: JSON.stringify({ input: 'minimal input', metadata: {} })
+          taskName: 'test-task',
+          logItem: JSON.stringify({
+            input: { value: 'test-input' },
+            output: { result: 'test-output' },
+            taskName: 'test-task',
+            type: 'success',
+            boundaries: {},
+            metadata: {}
+          })
         },
         expect.any(Object)
       )
     })
 
-    it('should handle null/undefined values in log items', async () => {
+    it('should return a function that calls sendLog with provided metadata', async () => {
       mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
 
-      const logItem = { input: null, output: undefined, error: 'some error' }
-      const result = await client.sendLog('null-task', logItem)
+      const listener = client.getListener()
+
+      const executionRecord = {
+        input: { value: 'test-input' },
+        output: { result: 'test-output' },
+        taskName: 'test-task',
+        type: 'success' as const,
+        boundaries: {},
+        metadata: { recordMeta: 'from-record' }
+      }
+
+      await listener(executionRecord)
 
-      expect(result).toBe('success')
       expect(mockedAxios.post).toHaveBeenCalledWith(
         'https://test-host.com/api/tasks/log-ingest',
         {
           projectName: 'test-project',
-          taskName: 'null-task',
-          logItem: JSON.stringify({ ...logItem, metadata: {} })
+          taskName: 'test-task',
+          logItem: JSON.stringify({
+            input: { value: 'test-input' },
+            output: { result: 'test-output' },
+            taskName: 'test-task',
+            type: 'success',
+            boundaries: {},
+            metadata: {
+              recordMeta: 'from-record'
+            }
+          })
         },
         expect.any(Object)
       )
     })
+
+    it('should handle listener errors gracefully', async () => {
+      mockedAxios.post.mockRejectedValueOnce(new Error('Network error'))
+
+      const listener = client.getListener()
+
+      const executionRecord = {
+        input: { value: 'test-input' },
+        taskName: 'test-task',
+        type: 'success' as const,
+        boundaries: {},
+        metadata: {}
+      }
+
+      // Should not throw, even if sendLog fails
+      await expect(listener(executionRecord)).resolves.toBeUndefined()
+    })
   })
 })