@forgehive/hive-sdk 0.0.3 → 0.1.0

package/dist/test/sendLog.test.js

@@ -8,7 +8,7 @@ const index_1 = require("../index");
 // Mock axios
 jest.mock('axios');
 const mockedAxios = axios_1.default;
-describe('HiveLogClient sendLog', () => {
+describe('HiveLogClient sendLog with ExecutionRecord', () => {
     let client;
     const testConfig = {
         projectName: 'test-project',
@@ -22,18 +22,32 @@ describe('HiveLogClient sendLog', () => {
         // Clear all mocks
         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',
+                boundaries: {},
+                metadata: {}
+            };
+            const result = await client.sendLog(executionRecord);
             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, metadata: {} })
+                logItem: JSON.stringify({
+                    input: { value: 'test-input' },
+                    output: { result: 'test-output' },
+                    taskName: 'test-task',
+                    type: 'success',
+                    boundaries: {},
+                    metadata: {}
+                })
             }, {
                 headers: {
                     Authorization: 'Bearer test-api-key:test-api-secret',
@@ -41,22 +55,35 @@ 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',
                 boundaries: {
-                    database: [{ input: 'SELECT * FROM users', output: [{ id: 123 }], error: null }]
-                }
+                    database: [{ input: 'SELECT * FROM users', output: [{ id: 123 }], error: null }],
+                    api: [{ input: { endpoint: '/auth' }, output: { token: 'jwt123' }, error: null }]
+                },
+                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('https://test-host.com/api/tasks/log-ingest', {
                 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 }], error: null }],
+                        api: [{ input: { endpoint: '/auth' }, output: { token: 'jwt123' }, error: null }]
+                    },
+                    metadata: { environment: 'test' }
+                })
             }, {
                 headers: {
                     Authorization: 'Bearer test-api-key:test-api-secret',
@@ -64,44 +91,224 @@ 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',
+                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',
+                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',
+                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',
+                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',
+                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 index_1.HiveLogClient({
+                projectName: 'test-project'
+                // No API credentials
+            });
+            const executionRecord = {
+                input: { value: 'test-input' },
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
+                metadata: {}
+            };
+            const result = await uninitializedClient.sendLog(executionRecord);
+            expect(result).toBe('silent');
+            expect(mockedAxios.post).not.toHaveBeenCalled();
+        });
+    });
+});
+describe('HiveLogClient getListener', () => {
+    let client;
+    const testConfig = {
+        projectName: 'test-project',
+        apiKey: 'test-api-key',
+        apiSecret: 'test-api-secret',
+        host: 'https://test-host.com'
+    };
+    beforeEach(() => {
+        client = new index_1.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' });
-            expect(result).toBe('success');
+            const listener = client.getListener();
+            expect(typeof listener).toBe('function');
+            const executionRecord = {
+                input: { value: 'test-input' },
+                output: { result: 'test-output' },
+                taskName: 'test-task',
+                type: 'success',
+                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);
-            expect(result).toBe('success');
+            const listener = client.getListener();
+            const executionRecord = {
+                input: { value: 'test-input' },
+                output: { result: 'test-output' },
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
+                metadata: { recordMeta: 'from-record' }
+            };
+            await listener(executionRecord);
             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',
+                boundaries: {},
+                metadata: {}
+            };
+            // Should not throw, even if sendLog fails
+            await expect(listener(executionRecord)).resolves.toBeUndefined();
+        });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgehive/hive-sdk",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -8,18 +8,17 @@ export interface Metadata {
   [key: string]: string
 }
 
-// Log item interface for sendLog method - flexible to accept task execution records
-export interface LogItemInput {
-  input: unknown
-  output?: unknown
-  error?: unknown
-  boundaries?: unknown // Allow any boundary structure (task records have different format)
+// Import ExecutionRecord type from task package
+export interface ExecutionRecord<InputType = unknown, OutputType = unknown, B = unknown> {
+  input: InputType
+  output?: OutputType
+  error?: string
+  boundaries?: B
+  taskName?: string
   metadata?: Metadata
+  type?: 'success' | 'error' | 'pending'
 }
 
-// Backward compatibility alias
-export type LogItem = LogItemInput
-
 // Configuration interface for HiveLogClient
 export interface HiveLogClientConfig {
   projectName: string
@@ -34,13 +33,7 @@ export interface LogApiResponse {
   uuid: string
   taskName: string
   projectName: string
-  logItem: {
-    input: unknown
-    output?: unknown
-    error?: unknown
-    boundaries?: Record<string, Array<{ input: unknown; output: unknown, error: unknown }>>
-    metadata?: Metadata
-  }
+  logItem: ExecutionRecord
   replayFrom?: string
   createdAt: string
 }
@@ -100,13 +93,13 @@ export class HiveLogClient {
     return this.isInitialized
   }
 
-  private mergeMetadata<T extends { input: unknown; metadata?: Metadata }>(logItem: T, sendLogMetadata?: Metadata): Metadata {
+  private mergeMetadata(record: ExecutionRecord, sendLogMetadata?: Metadata): Metadata {
     // Start with base metadata from client
     let finalMetadata = { ...this.baseMetadata }
 
-    // Merge with logItem metadata if it exists
-    if (logItem.metadata) {
-      finalMetadata = { ...finalMetadata, ...logItem.metadata }
+    // Merge with record metadata if it exists
+    if (record.metadata) {
+      finalMetadata = { ...finalMetadata, ...record.metadata }
     }
 
     // Merge with sendLog metadata (highest priority)
@@ -117,7 +110,10 @@ export class HiveLogClient {
     return finalMetadata
   }
 
-  async sendLog<T extends { input: unknown; metadata?: Metadata }>(taskName: string, logItem: T, metadata?: Metadata): Promise<'success' | 'error' | 'silent'> {
+  async sendLog(record: ExecutionRecord, metadata?: Metadata): Promise<'success' | 'error' | 'silent'> {
+    // Extract taskName from record
+    const taskName = record.taskName || 'unknown-task'
+
     if (!this.isInitialized) {
       log('Silent mode: Skipping sendLog for task "%s" - client not initialized', taskName)
       return 'silent'
@@ -129,19 +125,20 @@ export class HiveLogClient {
 
       const authToken = `${this.apiKey}:${this.apiSecret}`
 
-      // Merge metadata with priority: sendLog > logItem > client
-      const finalMetadata = this.mergeMetadata(logItem, metadata)
+      // Merge metadata with priority: sendLog > record.metadata > client
+      const finalMetadata = this.mergeMetadata(record, metadata)
 
-      // Create enhanced logItem with merged metadata
-      const enhancedLogItem = {
-        ...logItem,
+      // Create logItem with merged metadata
+      const logItem = {
+        ...record,
+        taskName,
         metadata: finalMetadata
       }
 
       await axios.post(logsUrl, {
         projectName: this.projectName,
         taskName,
-        logItem: JSON.stringify(enhancedLogItem)
+        logItem: JSON.stringify(logItem)
       }, {
         headers: {
           Authorization: `Bearer ${authToken}`,
@@ -158,6 +155,12 @@ export class HiveLogClient {
     }
   }
 
+  getListener(): (record: ExecutionRecord) => Promise<void> {
+    return async (record: ExecutionRecord) => {
+      await this.sendLog(record)
+    }
+  }
+
   async getLog(taskName: string, uuid: string): Promise<LogApiResult | null> {
     if (!this.isInitialized) {
       log('Error: getLog for task "%s" with uuid "%s" - missing credentials', taskName, uuid)

package/src/test/getLog.test.ts

@@ -32,7 +32,7 @@ describe('HiveLogClient getLog', () => {
         logItem: {
           input: { userId: 123, action: 'login' },
           output: { success: true, sessionId: 'abc123' },
-          error: null,
+          error: undefined,
           boundaries: {
             database: [{ input: 'SELECT * FROM users', output: [{ id: 123 }], error: null }]
           }

package/src/test/index.test.ts

@@ -106,7 +106,14 @@ describe('Hive SDK', () => {
     })
 
     it('should return "silent" for sendLog in silent mode', async () => {
-      const result = await silentClient.sendLog('test-task', { input: 'test' })
+      const executionRecord = {
+        input: { test: 'value' },
+        taskName: 'test-task',
+        type: 'success' as const,
+        boundaries: {},
+        metadata: {}
+      }
+      const result = await silentClient.sendLog(executionRecord)
       expect(result).toBe('silent')
     })