@forgehive/hive-sdk 0.0.1

package/src/test/getLog.test.ts

@@ -0,0 +1,181 @@
+import axios from 'axios'
+import { HiveLogClient, LogApiResponse, ApiError, isApiError } from '../index'
+
+// Mock axios
+jest.mock('axios')
+const mockedAxios = axios as jest.Mocked<typeof axios>
+
+describe('HiveLogClient getLog', () => {
+  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'
+
+    // Create client instance
+    client = new HiveLogClient('test-project')
+
+    // Clear all mocks
+    jest.clearAllMocks()
+  })
+
+  afterAll(() => {
+    process.env = originalEnv
+  })
+
+  describe('successful getLog', () => {
+    it('should fetch log successfully and return LogApiResponse', async () => {
+      const mockLogResponse: LogApiResponse = {
+        uuid: 'test-uuid-123',
+        taskName: 'test-task',
+        projectName: 'test-project',
+        logItem: {
+          input: { userId: 123, action: 'login' },
+          output: { success: true, sessionId: 'abc123' },
+          error: null,
+          boundaries: {
+            database: [{ input: 'SELECT * FROM users', output: [{ id: 123 }], error: null }]
+          }
+        },
+        replayFrom: 'some-replay-id',
+        createdAt: '2023-12-01T10:00:00Z'
+      }
+
+      // Mock successful axios response
+      mockedAxios.get.mockResolvedValueOnce({ data: mockLogResponse })
+
+      const result = await client.getLog('test-task', 'test-uuid-123')
+
+      expect(result).toEqual(mockLogResponse)
+      expect(mockedAxios.get).toHaveBeenCalledTimes(1)
+      expect(mockedAxios.get).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/test-task/logs/test-uuid-123',
+        {
+          headers: {
+            Authorization: 'Bearer test-api-key:test-api-secret',
+            'Content-Type': 'application/json'
+          }
+        }
+      )
+    })
+
+    it('should handle API error response', async () => {
+      const mockErrorResponse: ApiError = {
+        error: 'Log not found'
+      }
+
+      mockedAxios.get.mockResolvedValueOnce({ data: mockErrorResponse })
+
+      const result = await client.getLog('test-task', 'non-existent-uuid')
+
+      expect(result).toEqual(mockErrorResponse)
+      expect(isApiError(result)).toBe(true)
+    })
+
+    it('should handle minimal log response', async () => {
+      const mockMinimalResponse: LogApiResponse = {
+        uuid: 'minimal-uuid',
+        taskName: 'minimal-task',
+        projectName: 'test-project',
+        logItem: {
+          input: 'simple input'
+        },
+        createdAt: '2023-12-01T10:00:00Z'
+      }
+
+      mockedAxios.get.mockResolvedValueOnce({ data: mockMinimalResponse })
+
+      const result = await client.getLog('minimal-task', 'minimal-uuid')
+
+      expect(result).toEqual(mockMinimalResponse)
+      expect(isApiError(result)).toBe(false)
+    })
+  })
+
+  describe('failed getLog', () => {
+    it('should return null when axios throws an error', async () => {
+      // Mock axios to throw an error
+      mockedAxios.get.mockRejectedValueOnce(new Error('Network error'))
+
+      const result = await client.getLog('test-task', 'test-uuid')
+
+      expect(result).toBeNull()
+    })
+
+    it('should return null when server returns 404', async () => {
+      // Mock axios to throw a 404 error
+      const notFoundError = new Error('Request failed with status code 404')
+      mockedAxios.get.mockRejectedValueOnce(notFoundError)
+
+      const result = await client.getLog('test-task', 'non-existent-uuid')
+
+      expect(result).toBeNull()
+    })
+
+    it('should return null when server returns 500', async () => {
+      // Mock axios to throw a server error
+      const serverError = new Error('Server Error')
+      mockedAxios.get.mockRejectedValueOnce(serverError)
+
+      const result = await client.getLog('test-task', 'test-uuid')
+
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('getLog parameters', () => {
+    it('should handle special characters in taskName and uuid', async () => {
+      const mockResponse: LogApiResponse = {
+        uuid: 'uuid-with-special-chars-!@#',
+        taskName: 'task-with-special-chars-!@#',
+        projectName: 'test-project',
+        logItem: { input: 'test' },
+        createdAt: '2023-12-01T10:00:00Z'
+      }
+
+      mockedAxios.get.mockResolvedValueOnce({ data: mockResponse })
+
+      const result = await client.getLog('task-with-special-chars-!@#', 'uuid-with-special-chars-!@#')
+
+      expect(result).toEqual(mockResponse)
+      expect(mockedAxios.get).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/task-with-special-chars-!@#/logs/uuid-with-special-chars-!@#',
+        expect.any(Object)
+      )
+    })
+  })
+})
+
+describe('isApiError type guard', () => {
+  it('should return true for ApiError objects', () => {
+    const apiError: ApiError = { error: 'Something went wrong' }
+    expect(isApiError(apiError)).toBe(true)
+  })
+
+  it('should return false for LogApiResponse objects', () => {
+    const logResponse: LogApiResponse = {
+      uuid: 'test-uuid',
+      taskName: 'test-task',
+      projectName: 'test-project',
+      logItem: { input: 'test' },
+      createdAt: '2023-12-01T10:00:00Z'
+    }
+    expect(isApiError(logResponse)).toBe(false)
+  })
+
+  it('should return false for null or undefined', () => {
+    expect(isApiError(null)).toBeFalsy()
+    expect(isApiError(undefined)).toBeFalsy()
+  })
+
+  it('should return false for objects without error property', () => {
+    expect(isApiError({ success: true })).toBe(false)
+    expect(isApiError({ data: 'some data' })).toBe(false)
+  })
+})

package/src/test/index.test.ts

@@ -0,0 +1,126 @@
+import { HiveLogClient, createHiveLogClient } from '../index'
+
+describe('Hive SDK', () => {
+  const originalEnv = process.env
+
+  beforeEach(() => {
+    jest.resetModules()
+    process.env = { ...originalEnv }
+  })
+
+  afterAll(() => {
+    process.env = originalEnv
+  })
+
+  describe('HiveLogClient constructor', () => {
+    it('should create client in silent mode when HIVE_API_KEY is missing', () => {
+      delete process.env.HIVE_API_KEY
+      process.env.HIVE_API_SECRET = 'test-secret'
+      process.env.HIVE_HOST = 'https://test.com'
+
+      expect(() => new HiveLogClient('test-project')).not.toThrow()
+    })
+
+    it('should create client in silent mode when HIVE_API_SECRET is missing', () => {
+      process.env.HIVE_API_KEY = 'test-key'
+      delete process.env.HIVE_API_SECRET
+      process.env.HIVE_HOST = 'https://test.com'
+
+      expect(() => new HiveLogClient('test-project')).not.toThrow()
+    })
+
+    it('should create client in silent mode when HIVE_HOST is missing', () => {
+      process.env.HIVE_API_KEY = 'test-key'
+      process.env.HIVE_API_SECRET = 'test-secret'
+      delete process.env.HIVE_HOST
+
+      expect(() => new HiveLogClient('test-project')).not.toThrow()
+    })
+
+    it('should create client in silent mode when all environment variables are missing', () => {
+      delete process.env.HIVE_API_KEY
+      delete process.env.HIVE_API_SECRET
+      delete process.env.HIVE_HOST
+
+      expect(() => new HiveLogClient('test-project')).not.toThrow()
+    })
+
+    it('should create client successfully when all environment variables are present', () => {
+      process.env.HIVE_API_KEY = 'test-key'
+      process.env.HIVE_API_SECRET = 'test-secret'
+      process.env.HIVE_HOST = 'https://test.com'
+
+      expect(() => new HiveLogClient('test-project')).not.toThrow()
+    })
+  })
+
+  describe('isActive method', () => {
+    it('should return false when credentials are missing', () => {
+      delete process.env.HIVE_API_KEY
+      delete process.env.HIVE_API_SECRET
+      delete process.env.HIVE_HOST
+
+      const client = new HiveLogClient('test-project')
+      expect(client.isActive()).toBe(false)
+    })
+
+    it('should return true when all credentials are present', () => {
+      process.env.HIVE_API_KEY = 'test-key'
+      process.env.HIVE_API_SECRET = 'test-secret'
+      process.env.HIVE_HOST = 'https://test.com'
+
+      const client = new HiveLogClient('test-project')
+      expect(client.isActive()).toBe(true)
+    })
+  })
+
+  describe('createHiveLogClient factory function', () => {
+    it('should create HiveLogClient instance when env vars are present', () => {
+      process.env.HIVE_API_KEY = 'test-key'
+      process.env.HIVE_API_SECRET = 'test-secret'
+      process.env.HIVE_HOST = 'https://test.com'
+
+      const client = createHiveLogClient('test-project')
+
+      expect(client).toBeInstanceOf(HiveLogClient)
+    })
+
+    it('should create client in silent mode when env vars are missing', () => {
+      delete process.env.HIVE_API_KEY
+      delete process.env.HIVE_API_SECRET
+      delete process.env.HIVE_HOST
+
+      expect(() => createHiveLogClient('test-project')).not.toThrow()
+    })
+  })
+
+  describe('Silent mode behavior', () => {
+    let silentClient: HiveLogClient
+
+    beforeEach(() => {
+      delete process.env.HIVE_API_KEY
+      delete process.env.HIVE_API_SECRET
+      delete process.env.HIVE_HOST
+
+      silentClient = new HiveLogClient('silent-project')
+    })
+
+    it('should return "silent" for sendLog in silent mode', async () => {
+      const result = await silentClient.sendLog('test-task', { data: 'test' })
+      expect(result).toBe('silent')
+    })
+
+    it('should throw error for getLog in silent mode', async () => {
+      await expect(silentClient.getLog('test-task', 'test-uuid')).rejects.toThrow(
+        'Missing Hive API credentials or host, get them at https://forgehive.dev'
+      )
+    })
+
+    it('should throw error for setQuality in silent mode', async () => {
+      const quality = { score: 8, reason: 'test', suggestions: 'test' }
+      await expect(silentClient.setQuality('test-task', 'test-uuid', quality)).rejects.toThrow(
+        'Missing Hive API credentials or host, get them at https://forgehive.dev'
+      )
+    })
+  })
+})

package/src/test/sendLog.test.ts

@@ -0,0 +1,148 @@
+import axios from 'axios'
+import { HiveLogClient } from '../index'
+
+// Mock axios
+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'
+
+    // Create client instance
+    client = new HiveLogClient('test-project')
+
+    // 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
+      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).toHaveBeenCalledTimes(1)
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/log-ingest',
+        {
+          projectName: 'test-project',
+          taskName: 'test-task',
+          logItem: JSON.stringify(logItem)
+        },
+        {
+          headers: {
+            Authorization: 'Bearer test-api-key:test-api-secret',
+            'Content-Type': 'application/json'
+          }
+        }
+      )
+    })
+
+    it('should handle complex log items', async () => {
+      mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
+
+      const complexLogItem = {
+        input: { userId: 123, action: 'login' },
+        output: { success: true, sessionId: 'abc123' },
+        error: null,
+        boundaries: {
+          database: [{ input: 'SELECT * FROM users', output: [{ id: 123 }], error: null }]
+        }
+      }
+
+      const result = await client.sendLog('complex-task', complexLogItem)
+
+      expect(result).toBe('success')
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        'https://test-host.com/api/tasks/log-ingest',
+        {
+          projectName: 'test-project',
+          taskName: 'complex-task',
+          logItem: JSON.stringify(complexLogItem)
+        },
+        {
+          headers: {
+            Authorization: 'Bearer test-api-key:test-api-secret',
+            'Content-Type': 'application/json'
+          }
+        }
+      )
+    })
+  })
+
+  describe('failed sendLog', () => {
+    it('should return false 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)
+
+      expect(result).toBe('error')
+    })
+
+    it('should return false 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' })
+
+      expect(result).toBe('error')
+    })
+  })
+
+  describe('sendLog parameters', () => {
+    it('should handle empty log items', async () => {
+      mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
+
+      const result = await client.sendLog('empty-task', {})
+
+      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({})
+        },
+        expect.any(Object)
+      )
+    })
+
+    it('should handle null/undefined values in log items', async () => {
+      mockedAxios.post.mockResolvedValueOnce({ data: { success: true } })
+
+      const logItem = { input: null, output: undefined, error: 'some error' }
+      const result = await client.sendLog('null-task', logItem)
+
+      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)
+        },
+        expect.any(Object)
+      )
+    })
+  })
+})