@forgehive/hive-sdk 0.0.1 → 0.0.2

package/src/test/metadata.test.ts

@@ -0,0 +1,467 @@
+import axios from 'axios'
+import { HiveLogClient, createHiveLogClient, Metadata } from '../index'
+
+// Mock axios
+jest.mock('axios')
+const mockedAxios = axios as jest.Mocked<typeof axios>
+
+describe('HiveLogClient Metadata', () => {
+  const testConfig = {
+    projectName: 'test-project',
+    apiKey: 'test-api-key',
+    apiSecret: 'test-api-secret',
+    host: 'https://test-host.com'
+  }
+
+  beforeEach(() => {
+    // Clear all mocks
+    jest.clearAllMocks()
+  })
+
+  describe('Constructor with base metadata', () => {
+    it('should create client without base metadata', () => {
+      const client = new HiveLogClient(testConfig)
+      expect(client).toBeInstanceOf(HiveLogClient)
+      expect(client.isActive()).toBe(true)
+    })
+
+    it('should create client with base metadata', () => {
+      const baseMetadata: Metadata = {
+        environment: 'production',
+        version: '1.0.0',
+        service: 'test-service'
+      }
+
+      const client = new HiveLogClient({ ...testConfig, metadata: baseMetadata })
+      expect(client).toBeInstanceOf(HiveLogClient)
+      expect(client.isActive()).toBe(true)
+    })
+
+    it('should handle empty base metadata object', () => {
+      const client = new HiveLogClient({ ...testConfig, metadata: {} })
+      expect(client).toBeInstanceOf(HiveLogClient)
+      expect(client.isActive()).toBe(true)
+    })
+
+    it('should handle undefined base metadata', () => {
+      const client = new HiveLogClient({ ...testConfig, metadata: undefined })
+      expect(client).toBeInstanceOf(HiveLogClient)
+      expect(client.isActive()).toBe(true)
+    })
+  })
+
+  describe('createHiveLogClient factory with metadata', () => {
+    it('should create client without base metadata', () => {
+      const client = createHiveLogClient(testConfig)
+      expect(client).toBeInstanceOf(HiveLogClient)
+    })
+
+    it('should create client with base metadata', () => {
+      const baseMetadata: Metadata = {
+        environment: 'development',
+        team: 'backend'
+      }
+
+      const client = createHiveLogClient({ ...testConfig, metadata: baseMetadata })
+      expect(client).toBeInstanceOf(HiveLogClient)
+    })
+  })
+
+  describe('sendLog with metadata parameter', () => {
+    let client: HiveLogClient
+
+    beforeEach(() => {
+      client = new HiveLogClient(testConfig)
+    })
+
+    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)
+
+      expect(result).toBe('success')
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/log-ingest',
+        {
+          projectName: 'test-project',
+          taskName: 'test-task',
+          logItem: JSON.stringify({
+            input: 'test-input',
+            output: 'test-output',
+            metadata: {}
+          })
+        },
+        {
+          headers: {
+            Authorization: 'Bearer test-api-key:test-api-secret',
+            'Content-Type': 'application/json'
+          }
+        }
+      )
+    })
+
+    it('should send log with metadata parameter', async () => {
+      mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
+
+      const logItem = { input: 'test-input', output: 'test-output' }
+      const metadata: Metadata = {
+        requestId: 'req-123',
+        userId: 'user-456'
+      }
+
+      const result = await client.sendLog('test-task', logItem, metadata)
+
+      expect(result).toBe('success')
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/log-ingest',
+        {
+          projectName: 'test-project',
+          taskName: 'test-task',
+          logItem: JSON.stringify({
+            input: 'test-input',
+            output: 'test-output',
+            metadata: {
+              requestId: 'req-123',
+              userId: 'user-456'
+            }
+          })
+        },
+        {
+          headers: {
+            Authorization: 'Bearer test-api-key:test-api-secret',
+            'Content-Type': 'application/json'
+          }
+        }
+      )
+    })
+
+    it('should handle logItem with only input property', async () => {
+      mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
+
+      const metadata: Metadata = { type: 'minimal' }
+      const result = await client.sendLog('test-task', { input: 'simple input' }, metadata)
+
+      expect(result).toBe('success')
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/log-ingest',
+        {
+          projectName: 'test-project',
+          taskName: 'test-task',
+          logItem: JSON.stringify({
+            input: 'simple input',
+            metadata: { type: 'minimal' }
+          })
+        },
+        expect.any(Object)
+      )
+    })
+
+    it('should handle logItem with null input values', async () => {
+      mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
+
+      const metadata: Metadata = { type: 'null-test' }
+      const result = await client.sendLog('test-task', { input: null }, metadata)
+
+      expect(result).toBe('success')
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/log-ingest',
+        {
+          projectName: 'test-project',
+          taskName: 'test-task',
+          logItem: JSON.stringify({
+            input: null,
+            metadata: { type: 'null-test' }
+          })
+        },
+        expect.any(Object)
+      )
+    })
+  })
+
+  describe('Metadata priority system', () => {
+    it('should use only base metadata when no other metadata provided', async () => {
+      mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
+
+      const baseMetadata: Metadata = {
+        environment: 'production',
+        version: '1.0.0'
+      }
+
+      const client = new HiveLogClient({ ...testConfig, metadata: baseMetadata })
+      const logItem = { input: 'test' }
+
+      await client.sendLog('test-task', logItem)
+
+      const expectedLogItem = {
+        input: 'test',
+        metadata: {
+          environment: 'production',
+          version: '1.0.0'
+        }
+      }
+
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/log-ingest',
+        {
+          projectName: 'test-project',
+          taskName: 'test-task',
+          logItem: JSON.stringify(expectedLogItem)
+        },
+        expect.any(Object)
+      )
+    })
+
+    it('should merge logItem metadata with base metadata', async () => {
+      mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
+
+      const baseMetadata: Metadata = {
+        environment: 'production',
+        version: '1.0.0'
+      }
+
+      const client = new HiveLogClient({ ...testConfig, metadata: baseMetadata })
+      const logItem = {
+        input: 'test',
+        metadata: {
+          sessionId: 'session-123',
+          version: '1.1.0' // This should override base version
+        }
+      }
+
+      await client.sendLog('test-task', logItem)
+
+      const expectedLogItem = {
+        input: 'test',
+        metadata: {
+          environment: 'production', // from base
+          version: '1.1.0',          // from logItem (overrides base)
+          sessionId: 'session-123'   // from logItem
+        }
+      }
+
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/log-ingest',
+        {
+          projectName: 'test-project',
+          taskName: 'test-task',
+          logItem: JSON.stringify(expectedLogItem)
+        },
+        expect.any(Object)
+      )
+    })
+
+    it('should give sendLog metadata highest priority', async () => {
+      mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
+
+      const baseMetadata: Metadata = {
+        environment: 'production',
+        version: '1.0.0',
+        priority: 'base'
+      }
+
+      const client = new HiveLogClient({ ...testConfig, metadata: baseMetadata })
+      const logItem = {
+        input: 'test',
+        metadata: {
+          sessionId: 'session-123',
+          version: '1.1.0',
+          priority: 'logItem'
+        }
+      }
+
+      const sendLogMetadata: Metadata = {
+        requestId: 'req-456',
+        version: '1.2.0',
+        priority: 'sendLog'
+      }
+
+      await client.sendLog('test-task', logItem, sendLogMetadata)
+
+      const expectedLogItem = {
+        input: 'test',
+        metadata: {
+          environment: 'production',  // from base
+          version: '1.2.0',           // from sendLog (highest priority)
+          priority: 'sendLog',        // from sendLog (highest priority)
+          sessionId: 'session-123',   // from logItem
+          requestId: 'req-456'        // from sendLog
+        }
+      }
+
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/log-ingest',
+        {
+          projectName: 'test-project',
+          taskName: 'test-task',
+          logItem: JSON.stringify(expectedLogItem)
+        },
+        expect.any(Object)
+      )
+    })
+
+    it('should handle all three metadata sources with complex merging', async () => {
+      mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
+
+      const baseMetadata: Metadata = {
+        environment: 'production',
+        service: 'api-gateway',
+        version: '1.0.0',
+        datacenter: 'us-west-2'
+      }
+
+      const client = new HiveLogClient({ ...testConfig, metadata: baseMetadata })
+      const logItem = {
+        input: { query: 'search' },
+        output: { results: [] },
+        metadata: {
+          algorithm: 'fuzzy-search',
+          processingTime: '250',
+          version: '1.1.0'  // overrides base
+        }
+      }
+
+      const sendLogMetadata: Metadata = {
+        requestId: 'req-789',
+        userId: 'user-123',
+        version: '1.2.0'  // overrides both base and logItem
+      }
+
+      await client.sendLog('search-task', logItem, sendLogMetadata)
+
+      const expectedLogItem = {
+        input: { query: 'search' },
+        output: { results: [] },
+        metadata: {
+          environment: 'production',    // from base
+          service: 'api-gateway',       // from base
+          version: '1.2.0',             // from sendLog (highest priority)
+          datacenter: 'us-west-2',      // from base
+          algorithm: 'fuzzy-search',    // from logItem
+          processingTime: '250',        // from logItem
+          requestId: 'req-789',         // from sendLog
+          userId: 'user-123'            // from sendLog
+        }
+      }
+
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/log-ingest',
+        {
+          projectName: 'test-project',
+          taskName: 'search-task',
+          logItem: JSON.stringify(expectedLogItem)
+        },
+        expect.any(Object)
+      )
+    })
+  })
+
+  describe('Edge cases and error handling', () => {
+    it('should handle logItem without metadata property', async () => {
+      mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
+
+      const baseMetadata: Metadata = { environment: 'test' }
+      const client = new HiveLogClient({ ...testConfig, metadata: baseMetadata })
+
+      const logItem = {
+        input: 'test'
+        // No metadata property
+      }
+
+      await client.sendLog('test-task', logItem)
+
+      const expectedLogItem = {
+        input: 'test',
+        metadata: {
+          environment: 'test' // Only base metadata should be used
+        }
+      }
+
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/log-ingest',
+        {
+          projectName: 'test-project',
+          taskName: 'test-task',
+          logItem: JSON.stringify(expectedLogItem)
+        },
+        expect.any(Object)
+      )
+    })
+
+    it('should handle logItem with undefined metadata', async () => {
+      mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
+
+      const baseMetadata: Metadata = { environment: 'test' }
+      const client = new HiveLogClient({ ...testConfig, metadata: baseMetadata })
+
+      const logItem = {
+        input: 'test',
+        metadata: undefined
+      }
+
+      await client.sendLog('test-task', logItem)
+
+      const expectedLogItem = {
+        input: 'test',
+        metadata: {
+          environment: 'test' // Only base metadata should be used
+        }
+      }
+
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/log-ingest',
+        {
+          projectName: 'test-project',
+          taskName: 'test-task',
+          logItem: JSON.stringify(expectedLogItem)
+        },
+        expect.any(Object)
+      )
+    })
+
+    it('should handle empty metadata objects', async () => {
+      mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
+
+      const client = new HiveLogClient({ ...testConfig, metadata: {} })
+      const logItem = { input: 'test', metadata: {} }
+
+      await client.sendLog('test-task', logItem, {})
+
+      const expectedLogItem = {
+        input: 'test',
+        metadata: {} // All empty metadata objects result in empty final metadata
+      }
+
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/log-ingest',
+        {
+          projectName: 'test-project',
+          taskName: 'test-task',
+          logItem: JSON.stringify(expectedLogItem)
+        },
+        expect.any(Object)
+      )
+    })
+
+    it('should work in silent mode with metadata', async () => {
+      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' })
+
+      expect(result).toBe('silent')
+      expect(mockedAxios.post).not.toHaveBeenCalled()
+    })
+
+    it('should handle network errors with metadata', async () => {
+      mockedAxios.post.mockRejectedValueOnce(new Error('Network error'))
+
+      const baseMetadata: Metadata = { environment: 'test' }
+      const client = new HiveLogClient({ ...testConfig, metadata: baseMetadata })
+
+      const result = await client.sendLog('test-task', { input: 'test' }, { requestId: 'req-123' })
+
+      expect(result).toBe('error')
+    })
+  })
+})

package/src/test/sendLog.test.ts

@@ -6,29 +6,23 @@ jest.mock('axios')
 const mockedAxios = axios as jest.Mocked<typeof axios>
 
 describe('HiveLogClient sendLog', () => {
-  const originalEnv = process.env
   let client: HiveLogClient
 
-  beforeEach(() => {
-    jest.resetModules()
-    process.env = { ...originalEnv }
-
-    // Set up environment variables
-    process.env.HIVE_API_KEY = 'test-api-key'
-    process.env.HIVE_API_SECRET = 'test-api-secret'
-    process.env.HIVE_HOST = 'https://test-host.com'
+  const testConfig = {
+    projectName: 'test-project',
+    apiKey: 'test-api-key',
+    apiSecret: 'test-api-secret',
+    host: 'https://test-host.com'
+  }
 
-    // Create client instance
-    client = new HiveLogClient('test-project')
+  beforeEach(() => {
+    // Create client instance with config
+    client = new HiveLogClient(testConfig)
 
     // Clear all mocks
     jest.clearAllMocks()
   })
 
-  afterAll(() => {
-    process.env = originalEnv
-  })
-
   describe('successful sendLog', () => {
     it('should send log successfully and return true', async () => {
       // Mock successful axios response
@@ -44,7 +38,7 @@ describe('HiveLogClient sendLog', () => {
         {
           projectName: 'test-project',
           taskName: 'test-task',
-          logItem: JSON.stringify(logItem)
+          logItem: JSON.stringify({ ...logItem, metadata: {} })
         },
         {
           headers: {
@@ -75,7 +69,7 @@ describe('HiveLogClient sendLog', () => {
         {
           projectName: 'test-project',
           taskName: 'complex-task',
-          logItem: JSON.stringify(complexLogItem)
+          logItem: JSON.stringify({ ...complexLogItem, metadata: {} })
         },
         {
           headers: {
@@ -110,18 +104,18 @@ describe('HiveLogClient sendLog', () => {
   })
 
   describe('sendLog parameters', () => {
-    it('should handle empty log items', async () => {
+    it('should handle log items with minimal input', async () => {
       mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
 
-      const result = await client.sendLog('empty-task', {})
+      const result = await client.sendLog('minimal-task', { input: 'minimal input' })
 
       expect(result).toBe('success')
       expect(mockedAxios.post).toHaveBeenCalledWith(
         'https://test-host.com/api/tasks/log-ingest',
         {
           projectName: 'test-project',
-          taskName: 'empty-task',
-          logItem: JSON.stringify({})
+          taskName: 'minimal-task',
+          logItem: JSON.stringify({ input: 'minimal input', metadata: {} })
         },
         expect.any(Object)
       )
@@ -139,7 +133,7 @@ describe('HiveLogClient sendLog', () => {
         {
           projectName: 'test-project',
           taskName: 'null-task',
-          logItem: JSON.stringify(logItem)
+          logItem: JSON.stringify({ ...logItem, metadata: {} })
         },
         expect.any(Object)
       )

package/src/test/setQuality.test.ts

@@ -6,29 +6,23 @@ jest.mock('axios')
 const mockedAxios = axios as jest.Mocked<typeof axios>
 
 describe('HiveLogClient setQuality', () => {
-  const originalEnv = process.env
   let client: HiveLogClient
 
-  beforeEach(() => {
-    jest.resetModules()
-    process.env = { ...originalEnv }
-
-    // Set up environment variables
-    process.env.HIVE_API_KEY = 'test-api-key'
-    process.env.HIVE_API_SECRET = 'test-api-secret'
-    process.env.HIVE_HOST = 'https://test-host.com'
+  const testConfig = {
+    projectName: 'test-project',
+    apiKey: 'test-api-key',
+    apiSecret: 'test-api-secret',
+    host: 'https://test-host.com'
+  }
 
-    // Create client instance
-    client = new HiveLogClient('test-project')
+  beforeEach(() => {
+    // Create client instance with config
+    client = new HiveLogClient(testConfig)
 
     // Clear all mocks
     jest.clearAllMocks()
   })
 
-  afterAll(() => {
-    process.env = originalEnv
-  })
-
   describe('successful setQuality', () => {
     it('should set quality successfully and return true', async () => {
       // Mock successful axios response
@@ -245,11 +239,7 @@ describe('HiveLogClient setQuality', () => {
   describe('silent mode behavior', () => {
     it('should throw error when credentials are missing', async () => {
       // Create client without credentials
-      process.env.HIVE_API_KEY = ''
-      process.env.HIVE_API_SECRET = ''
-      process.env.HIVE_HOST = ''
-
-      const silentClient = new HiveLogClient('silent-project')
+      const silentClient = new HiveLogClient({ projectName: 'silent-project' })
 
       const quality: Quality = {
         score: 8.0,
@@ -259,7 +249,7 @@ describe('HiveLogClient setQuality', () => {
 
       await expect(silentClient.setQuality('test-task', 'test-uuid', quality))
         .rejects
-        .toThrow('Missing Hive API credentials or host, get them at https://forgehive.dev')
+        .toThrow('Missing Hive API credentials or host, get them at https://www.forgehive.cloud')
 
       // Verify axios was never called
       expect(mockedAxios.post).not.toHaveBeenCalled()