@forgehive/hive-sdk 0.1.6 → 0.2.0

package/dist/index.d.ts

@@ -61,13 +61,11 @@ export declare class HiveLogClient {
     }>;
     private mergeMetadata;
     sendLog(record: ExecutionRecord, metadata?: Metadata): Promise<'success' | 'error' | 'silent' | LogApiSuccess>;
-    sendLogByUuid(record: ExecutionRecord, taskUuid: string, metadata?: Metadata): Promise<'success' | 'error' | 'silent' | LogApiSuccess>;
     getListener(): (record: ExecutionRecord) => Promise<void>;
     getLog(taskName: string, uuid: string): Promise<LogApiResult | null>;
     setQuality(taskName: string, uuid: string, quality: Quality): Promise<boolean>;
     private loadForgeConfig;
     private getTaskUUID;
-    sendLogByName(taskName: string, record: ExecutionRecord, metadata?: Metadata): Promise<'success' | 'error' | 'silent' | LogApiSuccess>;
 }
 export declare const createHiveLogClient: (config: HiveLogClientConfig) => HiveLogClient;
 export interface HiveClientConfig {

package/dist/index.js

@@ -169,55 +169,19 @@ class HiveLogClient {
             log('Silent mode: Skipping sendLog for task "%s" - client not initialized', taskName);
             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_1.default.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;
-            }
-            return 'success';
-        }
-        catch (e) {
-            const error = e;
-            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, taskUuid, metadata) {
-        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}`;
             // Merge metadata with priority: sendLog > record.metadata > client
             const finalMetadata = this.mergeMetadata(record, metadata);
@@ -227,19 +191,17 @@ class HiveLogClient {
                 uuid: record.uuid || (0, uuid_1.v7)(),
                 metadata: finalMetadata
             };
-            // Create logItem with merged metadata and UUID
-            const logItem = recordWithUuid;
             const response = await axios_1.default.post(logsUrl, {
                 projectUuid: this.projectUuid,
                 taskUuid,
-                logItem: JSON.stringify(logItem)
+                logItem: JSON.stringify(recordWithUuid)
             }, {
                 headers: {
                     Authorization: `Bearer ${authToken}`,
                     'Content-Type': 'application/json'
                 }
             });
-            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) {
                 return response.data;
@@ -248,7 +210,7 @@ class HiveLogClient {
         }
         catch (e) {
             const error = e;
-            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';
         }
     }
@@ -335,24 +297,6 @@ class HiveLogClient {
         log('Found UUID "%s" for task "%s"', task.uuid, taskName);
         return task.uuid;
     }
-    async sendLogByName(taskName, record, metadata) {
-        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);
-    }
 }
 exports.HiveLogClient = HiveLogClient;
 const createHiveLogClient = (config) => {

package/dist/test/metadata.test.js

@@ -4,18 +4,44 @@ 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 Metadata', () => {
     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'
+            },
+            'search-task': {
+                path: 'src/tasks/search.ts',
+                handler: 'searchTask',
+                uuid: 'a45aafe3-8b01-4b58-b15d-9a96274858ee'
+            }
+        }
     };
     beforeEach(() => {
+        // Mock fs
+        mockedFs.existsSync.mockReturnValue(true);
+        mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockForgeConfig));
         // Clear all mocks
         jest.clearAllMocks();
     });
@@ -64,6 +90,7 @@ describe('HiveLogClient Metadata', () => {
         let client;
         beforeEach(() => {
             client = new index_1.HiveLogClient(testConfig);
+            jest.clearAllMocks();
         });
         it('should send log without metadata parameter', async () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
@@ -77,23 +104,21 @@ describe('HiveLogClient 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: 'test-task',
-                logItem: JSON.stringify({
-                    input: 'test-input',
-                    output: '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');
+            // Parse and verify logItem
+            const logItem = JSON.parse(requestBody.logItem);
+            expect(logItem.uuid).toBeDefined();
+            expect(logItem.input).toBe('test-input');
+            expect(logItem.output).toBe('test-output');
+            expect(logItem.taskName).toBe('test-task');
+            expect(logItem.type).toBe('success');
+            expect(logItem.metadata).toEqual({});
         });
         it('should send log with metadata parameter', async () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
@@ -111,25 +136,13 @@ describe('HiveLogClient Metadata', () => {
             };
             const result = await client.sendLog(executionRecord, 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',
-                    taskName: 'test-task',
-                    type: 'success',
-                    boundaries: {},
-                    metadata: {
-                        requestId: 'req-123',
-                        userId: 'user-456'
-                    }
-                })
-            }, {
-                headers: {
-                    Authorization: 'Bearer test-api-key:test-api-secret',
-                    'Content-Type': 'application/json'
-                }
+            const callArgs = mockedAxios.post.mock.calls[0];
+            expect(callArgs[0]).toBe('https://test-host.com/api/log-ingest');
+            const requestBody = callArgs[1];
+            const logItem = JSON.parse(requestBody.logItem);
+            expect(logItem.metadata).toEqual({
+                requestId: 'req-123',
+                userId: 'user-456'
             });
         });
         it('should handle logItem with only input property', async () => {
@@ -137,34 +150,22 @@ describe('HiveLogClient Metadata', () => {
             const metadata = { type: 'minimal' };
             const result = await client.sendLog({ input: 'simple input', taskName: 'test-task', type: 'success', boundaries: {}, metadata: {} }, 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',
-                    taskName: 'test-task',
-                    type: 'success',
-                    boundaries: {},
-                    metadata: { type: 'minimal' }
-                })
-            }, expect.any(Object));
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const logItem = JSON.parse(requestBody.logItem);
+            expect(logItem.input).toBe('simple input');
+            expect(logItem.metadata).toEqual({ type: 'minimal' });
         });
         it('should handle logItem with null input values', async () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
             const metadata = { type: 'null-test' };
             const result = await client.sendLog({ input: null, taskName: 'test-task', type: 'success', boundaries: {}, metadata: {} }, 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,
-                    taskName: 'test-task',
-                    type: 'success',
-                    boundaries: {},
-                    metadata: { type: 'null-test' }
-                })
-            }, expect.any(Object));
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const logItem = JSON.parse(requestBody.logItem);
+            expect(logItem.input).toBeNull();
+            expect(logItem.metadata).toEqual({ type: 'null-test' });
         });
     });
     describe('Metadata priority system', () => {
@@ -175,23 +176,16 @@ describe('HiveLogClient Metadata', () => {
                 version: '1.0.0'
             };
             const client = new index_1.HiveLogClient({ ...testConfig, metadata: baseMetadata });
+            jest.clearAllMocks();
             const logItem = { input: 'test' };
             await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success', boundaries: {}, metadata: {} });
-            const expectedLogItem = {
-                input: 'test',
-                taskName: 'test-task',
-                type: 'success',
-                boundaries: {},
-                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));
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const parsedLogItem = JSON.parse(requestBody.logItem);
+            expect(parsedLogItem.metadata).toEqual({
+                environment: 'production',
+                version: '1.0.0'
+            });
         });
         it('should merge logItem metadata with base metadata', async () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
@@ -200,6 +194,7 @@ describe('HiveLogClient Metadata', () => {
                 version: '1.0.0'
             };
             const client = new index_1.HiveLogClient({ ...testConfig, metadata: baseMetadata });
+            jest.clearAllMocks();
             const logItem = {
                 input: 'test',
                 metadata: {
@@ -208,22 +203,14 @@ describe('HiveLogClient Metadata', () => {
                 }
             };
             await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success', boundaries: {}, metadata: logItem.metadata || {} });
-            const expectedLogItem = {
-                input: 'test',
-                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('https://test-host.com/api/tasks/log-ingest', {
-                projectName: 'test-project',
-                taskName: 'test-task',
-                logItem: JSON.stringify(expectedLogItem)
-            }, expect.any(Object));
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const parsedLogItem = JSON.parse(requestBody.logItem);
+            expect(parsedLogItem.metadata).toEqual({
+                environment: 'production', // from base
+                version: '1.1.0', // from logItem (overrides base)
+                sessionId: 'session-123' // from logItem
+            });
         });
         it('should give sendLog metadata highest priority', async () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
@@ -233,6 +220,7 @@ describe('HiveLogClient Metadata', () => {
                 priority: 'base'
             };
             const client = new index_1.HiveLogClient({ ...testConfig, metadata: baseMetadata });
+            jest.clearAllMocks();
             const logItem = {
                 input: 'test',
                 metadata: {
@@ -247,24 +235,16 @@ describe('HiveLogClient Metadata', () => {
                 priority: 'sendLog'
             };
             await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success', boundaries: {}, metadata: logItem.metadata || {} }, 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
-                },
-                taskName: 'test-task',
-                type: 'success',
-                boundaries: {}
-            };
-            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));
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const parsedLogItem = JSON.parse(requestBody.logItem);
+            expect(parsedLogItem.metadata).toEqual({
+                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
+            });
         });
         it('should handle all three metadata sources with complex merging', async () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
@@ -275,6 +255,7 @@ describe('HiveLogClient Metadata', () => {
                 datacenter: 'us-west-2'
             };
             const client = new index_1.HiveLogClient({ ...testConfig, metadata: baseMetadata });
+            jest.clearAllMocks();
             const logItem = {
                 input: { query: 'search' },
                 output: { results: [] },
@@ -290,28 +271,19 @@ describe('HiveLogClient Metadata', () => {
                 version: '1.2.0' // overrides both base and logItem
             };
             await client.sendLog({ ...logItem, taskName: 'search-task', type: 'success', boundaries: {}, metadata: logItem.metadata || {} }, 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
-                },
-                taskName: 'search-task',
-                type: 'success',
-                boundaries: {}
-            };
-            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));
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const parsedLogItem = JSON.parse(requestBody.logItem);
+            expect(parsedLogItem.metadata).toEqual({
+                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
+            });
         });
     });
     describe('Edge cases and error handling', () => {
@@ -319,67 +291,46 @@ describe('HiveLogClient Metadata', () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
             const baseMetadata = { environment: 'test' };
             const client = new index_1.HiveLogClient({ ...testConfig, metadata: baseMetadata });
+            jest.clearAllMocks();
             const logItem = {
                 input: 'test'
                 // No metadata property
             };
             await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success', boundaries: {}, metadata: {} });
-            const expectedLogItem = {
-                input: 'test',
-                taskName: 'test-task',
-                type: 'success',
-                boundaries: {},
-                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));
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const parsedLogItem = JSON.parse(requestBody.logItem);
+            expect(parsedLogItem.metadata).toEqual({
+                environment: 'test' // Only base metadata should be used
+            });
         });
         it('should handle logItem with undefined metadata', async () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
             const baseMetadata = { environment: 'test' };
             const client = new index_1.HiveLogClient({ ...testConfig, metadata: baseMetadata });
+            jest.clearAllMocks();
             const logItem = {
                 input: 'test',
                 metadata: undefined
             };
             await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success', 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('https://test-host.com/api/tasks/log-ingest', {
-                projectName: 'test-project',
-                taskName: 'test-task',
-                logItem: JSON.stringify(expectedLogItem)
-            }, expect.any(Object));
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const parsedLogItem = JSON.parse(requestBody.logItem);
+            expect(parsedLogItem.metadata).toEqual({
+                environment: 'test' // Only base metadata should be used
+            });
         });
         it('should handle empty metadata objects', async () => {
             mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
             const client = new index_1.HiveLogClient({ ...testConfig, metadata: {} });
+            jest.clearAllMocks();
             const logItem = { input: 'test', metadata: {} };
             await client.sendLog({ ...logItem, taskName: 'test-task', type: 'success', boundaries: {}, metadata: logItem.metadata || {} }, {});
-            const expectedLogItem = {
-                input: 'test',
-                metadata: {}, // All empty metadata objects result in empty final metadata
-                taskName: 'test-task',
-                type: 'success',
-                boundaries: {}
-            };
-            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));
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const parsedLogItem = JSON.parse(requestBody.logItem);
+            expect(parsedLogItem.metadata).toEqual({}); // All empty metadata objects result in empty final metadata
         });
         it('should work in silent mode with metadata', async () => {
             const baseMetadata = { environment: 'test' };
@@ -392,6 +343,7 @@ describe('HiveLogClient Metadata', () => {
             mockedAxios.post.mockRejectedValueOnce(new Error('Network error'));
             const baseMetadata = { environment: 'test' };
             const client = new index_1.HiveLogClient({ ...testConfig, metadata: baseMetadata });
+            jest.clearAllMocks();
             const result = await client.sendLog({ input: 'test', taskName: 'test-task', type: 'success', boundaries: {}, metadata: {} }, { requestId: 'req-123' });
             expect(result).toBe('error');
         });