@forgehive/hive-sdk 0.1.6 → 0.2.0

package/dist/test/sendLog.test.js

@@ -4,19 +4,56 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importDefault(require("fs"));
 const index_1 = require("../index");
-// Mock axios
+// Mock axios and fs
 jest.mock('axios');
+jest.mock('fs');
 const mockedAxios = axios_1.default;
+const mockedFs = fs_1.default;
 describe('HiveLogClient sendLog with ExecutionRecord', () => {
     let client;
     const testConfig = {
         projectName: 'test-project',
+        projectUuid: '550e8400-e29b-41d4-a716-446655440000',
         apiKey: 'test-api-key',
         apiSecret: 'test-api-secret',
-        host: 'https://test-host.com'
+        host: 'https://test-host.com',
+        forgeConfigPath: './forge.json'
+    };
+    const mockForgeConfig = {
+        project: {
+            name: 'test-project',
+            uuid: '550e8400-e29b-41d4-a716-446655440000'
+        },
+        tasks: {
+            'test-task': {
+                path: 'src/tasks/test.ts',
+                handler: 'testTask',
+                uuid: 'f47ac10b-58cc-4372-a567-0e02b2c3d479'
+            },
+            'complex-task': {
+                path: 'src/tasks/complex.ts',
+                handler: 'complexTask',
+                uuid: 'a45aafe3-8b01-4b58-b15d-9a96274858ee'
+            },
+            'error-task': {
+                path: 'src/tasks/error.ts',
+                handler: 'errorTask',
+                uuid: '8879271f-7e84-4748-bd11-4d81acf29fb6'
+            },
+            'metadata-task': {
+                path: 'src/tasks/metadata.ts',
+                handler: 'metadataTask',
+                uuid: 'fad2f735-ca09-4b8b-9c44-597de3641d28'
+            }
+        }
     };
     beforeEach(() => {
+        // Mock fs.existsSync to return true
+        mockedFs.existsSync.mockReturnValue(true);
+        // Mock fs.readFileSync to return forge.json content
+        mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockForgeConfig));
         // Create client instance with config
         client = new index_1.HiveLogClient(testConfig);
         // Clear all mocks
@@ -37,23 +74,21 @@ describe('HiveLogClient sendLog with ExecutionRecord', () => {
             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({
-                    input: { value: 'test-input' },
-                    output: { result: 'test-output' },
-                    taskName: 'test-task',
-                    type: 'success',
-                    boundaries: {},
-                    metadata: {}
-                })
-            }, {
-                headers: {
-                    Authorization: 'Bearer test-api-key:test-api-secret',
-                    'Content-Type': 'application/json'
-                }
-            });
+            // Verify it uses the UUID endpoint
+            const callArgs = mockedAxios.post.mock.calls[0];
+            expect(callArgs[0]).toBe('https://test-host.com/api/log-ingest');
+            // Verify request body structure
+            const requestBody = callArgs[1];
+            expect(requestBody.projectUuid).toBe(testConfig.projectUuid);
+            expect(requestBody.taskUuid).toBe('f47ac10b-58cc-4372-a567-0e02b2c3d479');
+            // Verify logItem has UUID generated
+            const logItem = JSON.parse(requestBody.logItem);
+            expect(logItem.uuid).toBeDefined();
+            expect(typeof logItem.uuid).toBe('string');
+            expect(logItem.input).toEqual({ value: 'test-input' });
+            expect(logItem.output).toEqual({ result: 'test-output' });
+            expect(logItem.taskName).toBe('test-task');
+            expect(logItem.type).toBe('success');
         });
         it('should handle ExecutionRecord with complex boundaries', async () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
@@ -78,34 +113,15 @@ describe('HiveLogClient sendLog with ExecutionRecord', () => {
             };
             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({
-                    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: {
-                    Authorization: 'Bearer test-api-key:test-api-secret',
-                    'Content-Type': 'application/json'
-                }
-            });
+            // Verify request structure
+            const callArgs = mockedAxios.post.mock.calls[0];
+            expect(callArgs[0]).toBe('https://test-host.com/api/log-ingest');
+            const requestBody = callArgs[1];
+            expect(requestBody.projectUuid).toBe(testConfig.projectUuid);
+            expect(requestBody.taskUuid).toBe('a45aafe3-8b01-4b58-b15d-9a96274858ee');
+            const logItem = JSON.parse(requestBody.logItem);
+            expect(logItem.uuid).toBeDefined();
+            expect(logItem.boundaries).toEqual(executionRecord.boundaries);
         });
         it('should handle ExecutionRecord with error', async () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
@@ -120,44 +136,51 @@ describe('HiveLogClient sendLog with ExecutionRecord', () => {
             };
             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));
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            expect(requestBody.taskUuid).toBe('8879271f-7e84-4748-bd11-4d81acf29fb6');
+            const logItem = JSON.parse(requestBody.logItem);
+            expect(logItem.error).toBe('Task execution failed');
+            expect(logItem.type).toBe('error');
         });
-        it('should use "unknown-task" when taskName is missing', async () => {
+        it('should preserve existing UUID when execution record already has one', async () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const existingUuid = '01234567-89ab-7def-8123-456789abcdef';
             const executionRecord = {
+                uuid: existingUuid,
                 input: { value: 'test-input' },
                 output: { result: 'test-output' },
-                // taskName is missing
+                taskName: 'test-task',
                 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));
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const logItem = JSON.parse(requestBody.logItem);
+            expect(logItem.uuid).toBe(existingUuid);
+        });
+        it('should generate UUID v7 when execution record has no UUID', async () => {
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            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');
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const logItem = JSON.parse(requestBody.logItem);
+            expect(logItem.uuid).toBeDefined();
+            expect(typeof logItem.uuid).toBe('string');
+            // UUID v7 pattern
+            expect(logItem.uuid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
         });
     });
     describe('sendLog with additional metadata', () => {
@@ -180,22 +203,14 @@ describe('HiveLogClient sendLog with ExecutionRecord', () => {
             };
             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));
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const logItem = JSON.parse(requestBody.logItem);
+            expect(logItem.metadata).toEqual({
+                recordMeta: 'from-record',
+                sharedKey: 'sendlog-value', // sendLog metadata takes priority
+                sendLogMeta: 'from-sendlog'
+            });
         });
     });
     describe('failed sendLog', () => {
@@ -226,6 +241,37 @@ describe('HiveLogClient sendLog with ExecutionRecord', () => {
             const result = await client.sendLog(executionRecord);
             expect(result).toBe('error');
         });
+        it('should return error when task is not found in forge.json', async () => {
+            const executionRecord = {
+                input: { value: 'test-input' },
+                taskName: 'nonexistent-task',
+                type: 'success',
+                boundaries: {},
+                metadata: {}
+            };
+            const result = await client.sendLog(executionRecord);
+            expect(result).toBe('error');
+            expect(mockedAxios.post).not.toHaveBeenCalled();
+        });
+        it('should return error when projectUuid is not set', async () => {
+            // Create client without projectUuid
+            const clientWithoutUuid = new index_1.HiveLogClient({
+                projectName: 'test-project',
+                apiKey: 'test-key',
+                apiSecret: 'test-secret',
+                host: 'https://test-host.com'
+            });
+            const executionRecord = {
+                input: { value: 'test-input' },
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
+                metadata: {}
+            };
+            const result = await clientWithoutUuid.sendLog(executionRecord);
+            expect(result).toBe('error');
+            expect(mockedAxios.post).not.toHaveBeenCalled();
+        });
     });
     describe('sendLog in silent mode', () => {
         it('should return silent when client is not initialized', async () => {
@@ -245,16 +291,71 @@ describe('HiveLogClient sendLog with ExecutionRecord', () => {
             expect(mockedAxios.post).not.toHaveBeenCalled();
         });
     });
+    describe('sendLog with unknown task name', () => {
+        it('should return error when taskName is missing and defaults to unknown-task', async () => {
+            const executionRecord = {
+                input: { value: 'test-input' },
+                output: { result: 'test-output' },
+                // taskName is missing - will default to 'unknown-task'
+                type: 'success',
+                boundaries: {},
+                metadata: {}
+            };
+            const result = await client.sendLog(executionRecord);
+            // Should return error because 'unknown-task' is not in forge.json
+            expect(result).toBe('error');
+            expect(mockedAxios.post).not.toHaveBeenCalled();
+        });
+    });
+    describe('sendLog response handling', () => {
+        it('should return response data when API returns object with uuid', async () => {
+            const responseData = {
+                uuid: 'log-uuid-123',
+                taskName: 'test-task',
+                projectName: 'test-project',
+                logItem: {},
+                createdAt: '2024-01-01T00:00:00Z'
+            };
+            mockedAxios.post.mockResolvedValueOnce({ data: responseData });
+            const executionRecord = {
+                input: { value: 'test' },
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
+                metadata: {}
+            };
+            const result = await client.sendLog(executionRecord);
+            expect(result).toEqual(responseData);
+        });
+    });
 });
 describe('HiveLogClient getListener', () => {
     let client;
     const testConfig = {
         projectName: 'test-project',
+        projectUuid: '550e8400-e29b-41d4-a716-446655440000',
         apiKey: 'test-api-key',
         apiSecret: 'test-api-secret',
-        host: 'https://test-host.com'
+        host: 'https://test-host.com',
+        forgeConfigPath: './forge.json'
+    };
+    const mockForgeConfig = {
+        project: {
+            name: 'test-project',
+            uuid: '550e8400-e29b-41d4-a716-446655440000'
+        },
+        tasks: {
+            'test-task': {
+                path: 'src/tasks/test.ts',
+                handler: 'testTask',
+                uuid: 'f47ac10b-58cc-4372-a567-0e02b2c3d479'
+            }
+        }
     };
     beforeEach(() => {
+        // Mock fs
+        mockedFs.existsSync.mockReturnValue(true);
+        mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockForgeConfig));
         client = new index_1.HiveLogClient(testConfig);
         jest.clearAllMocks();
     });
@@ -273,18 +374,9 @@ describe('HiveLogClient getListener', () => {
             };
             await listener(executionRecord);
             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({
-                    input: { value: 'test-input' },
-                    output: { result: 'test-output' },
-                    taskName: 'test-task',
-                    type: 'success',
-                    boundaries: {},
-                    metadata: {}
-                })
-            }, expect.any(Object));
+            // Verify it uses the UUID endpoint
+            const callArgs = mockedAxios.post.mock.calls[0];
+            expect(callArgs[0]).toBe('https://test-host.com/api/log-ingest');
         });
         it('should return a function that calls sendLog with provided metadata', async () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
@@ -298,20 +390,10 @@ describe('HiveLogClient getListener', () => {
                 metadata: { recordMeta: 'from-record' }
             };
             await listener(executionRecord);
-            expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
-                projectName: 'test-project',
-                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));
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const logItem = JSON.parse(requestBody.logItem);
+            expect(logItem.metadata).toEqual({ recordMeta: 'from-record' });
         });
         it('should handle listener errors gracefully', async () => {
             mockedAxios.post.mockRejectedValueOnce(new Error('Network error'));

package/package.json

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

package/src/index.ts

@@ -266,65 +266,21 @@ export class HiveLogClient {
       return 'silent'
     }
 
-    // Deprecation warning for legacy endpoint
-    log('DEPRECATION WARNING: sendLog() is deprecated. Use sendLogByUuid() with project and task UUIDs for enhanced features and better performance.')
-
-    try {
-      const logsUrl = `${this.host}/api/tasks/log-ingest`
-      log('Sending log for task "%s" to %s', taskName, logsUrl)
-
-      const authToken = `${this.apiKey}:${this.apiSecret}`
-
-      // Merge metadata with priority: sendLog > record.metadata > client
-      const finalMetadata = this.mergeMetadata(record, metadata)
-
-      // Create logItem with merged metadata (no UUID generation for legacy method)
-      const logItem = {
-        ...record,
-        taskName,
-        metadata: finalMetadata
-      }
-
-      const response = await axios.post(logsUrl, {
-        projectName: this.projectName,
-        taskName,
-        logItem: JSON.stringify(logItem)
-      }, {
-        headers: {
-          Authorization: `Bearer ${authToken}`,
-          'Content-Type': 'application/json'
-        }
-      })
-
-      log('Success: Sent log for task "%s"', taskName)
-
-      // Return the full response data if available
-      if (response.data && typeof response.data === 'object' && 'uuid' in response.data) {
-        return response.data as LogApiSuccess
-      }
-
-      return 'success'
-    } catch (e) {
-      const error = e as Error
-      log('Error: Failed to send log for task "%s": %s', taskName, error.message)
+    if (!this.projectUuid) {
+      log('Error: sendLog requires projectUuid to be set in client config')
       return 'error'
     }
-  }
-
-  async sendLogByUuid(record: ExecutionRecord, taskUuid: string, metadata?: Metadata): Promise<'success' | 'error' | 'silent' | LogApiSuccess> {
-    if (!this.isInitialized) {
-      log('Silent mode: Skipping sendLogByUuid for task UUID "%s" - client not initialized', taskUuid)
-      return 'silent'
-    }
 
-    if (!this.projectUuid) {
-      log('Error: sendLogByUuid requires projectUuid to be set in client config')
+    // Look up task UUID from forge.json
+    const taskUuid = this.getTaskUUID(taskName)
+    if (!taskUuid) {
+      log('Error: Cannot find UUID for task "%s" in forge.json', taskName)
       return 'error'
     }
 
     try {
       const logsUrl = `${this.host}/api/log-ingest`
-      log('Sending log for task UUID "%s" to %s', taskUuid, logsUrl)
+      log('Sending log for task "%s" (UUID: %s) to %s', taskName, taskUuid, logsUrl)
 
       const authToken = `${this.apiKey}:${this.apiSecret}`
 
@@ -338,13 +294,10 @@ export class HiveLogClient {
         metadata: finalMetadata
       }
 
-      // Create logItem with merged metadata and UUID
-      const logItem = recordWithUuid
-
       const response = await axios.post(logsUrl, {
         projectUuid: this.projectUuid,
         taskUuid,
-        logItem: JSON.stringify(logItem)
+        logItem: JSON.stringify(recordWithUuid)
       }, {
         headers: {
           Authorization: `Bearer ${authToken}`,
@@ -352,7 +305,7 @@ export class HiveLogClient {
         }
       })
 
-      log('Success: Sent log for task UUID "%s"', taskUuid)
+      log('Success: Sent log for task "%s" (UUID: %s)', taskName, taskUuid)
 
       // Return the full response data if available
       if (response.data && typeof response.data === 'object' && 'uuid' in response.data) {
@@ -362,11 +315,12 @@ export class HiveLogClient {
       return 'success'
     } catch (e) {
       const error = e as Error
-      log('Error: Failed to send log for task UUID "%s": %s', taskUuid, error.message)
+      log('Error: Failed to send log for task "%s": %s', taskName, error.message)
       return 'error'
     }
   }
 
+
   getListener(): (record: ExecutionRecord) => Promise<void> {
     return async (record: ExecutionRecord) => {
       await this.sendLog(record)
@@ -461,27 +415,6 @@ export class HiveLogClient {
     return task.uuid
   }
 
-  async sendLogByName(taskName: string, record: ExecutionRecord, metadata?: Metadata): Promise<'success' | 'error' | 'silent' | LogApiSuccess> {
-    if (!this.isInitialized) {
-      log('Silent mode: Skipping sendLogByName for task "%s" - client not initialized', taskName)
-      return 'silent'
-    }
-
-    if (!this.projectUuid) {
-      log('Error: sendLogByName requires projectUuid to be set in client config')
-      return 'error'
-    }
-
-    const taskUuid = this.getTaskUUID(taskName)
-    if (!taskUuid) {
-      log('Error: Cannot find UUID for task "%s" in forge.json', taskName)
-      return 'error'
-    }
-
-    // Use the existing sendLogByUuid method
-    log('Sending log for task "%s" with uuid "%s"', taskName, taskUuid)
-    return await this.sendLogByUuid(record, taskUuid, metadata)
-  }
 }
 
 export const createHiveLogClient = (config: HiveLogClientConfig): HiveLogClient => {