@forgehive/hive-sdk 0.0.1 → 0.0.3

package/dist/test/index.test.js

@@ -15,31 +15,31 @@ describe('Hive SDK', () => {
             delete process.env.HIVE_API_KEY;
             process.env.HIVE_API_SECRET = 'test-secret';
             process.env.HIVE_HOST = 'https://test.com';
-            expect(() => new index_1.HiveLogClient('test-project')).not.toThrow();
+            expect(() => new index_1.HiveLogClient({ projectName: '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 index_1.HiveLogClient('test-project')).not.toThrow();
+            expect(() => new index_1.HiveLogClient({ projectName: '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 index_1.HiveLogClient('test-project')).not.toThrow();
+            expect(() => new index_1.HiveLogClient({ projectName: '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 index_1.HiveLogClient('test-project')).not.toThrow();
+            expect(() => new index_1.HiveLogClient({ projectName: '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 index_1.HiveLogClient('test-project')).not.toThrow();
+            expect(() => new index_1.HiveLogClient({ projectName: 'test-project' })).not.toThrow();
         });
     });
     describe('isActive method', () => {
@@ -47,14 +47,14 @@ describe('Hive SDK', () => {
             delete process.env.HIVE_API_KEY;
             delete process.env.HIVE_API_SECRET;
             delete process.env.HIVE_HOST;
-            const client = new index_1.HiveLogClient('test-project');
+            const client = new index_1.HiveLogClient({ projectName: '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 index_1.HiveLogClient('test-project');
+            const client = new index_1.HiveLogClient({ projectName: 'test-project' });
             expect(client.isActive()).toBe(true);
         });
     });
@@ -63,14 +63,14 @@ describe('Hive SDK', () => {
             process.env.HIVE_API_KEY = 'test-key';
             process.env.HIVE_API_SECRET = 'test-secret';
             process.env.HIVE_HOST = 'https://test.com';
-            const client = (0, index_1.createHiveLogClient)('test-project');
+            const client = (0, index_1.createHiveLogClient)({ projectName: 'test-project' });
             expect(client).toBeInstanceOf(index_1.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(() => (0, index_1.createHiveLogClient)('test-project')).not.toThrow();
+            expect(() => (0, index_1.createHiveLogClient)({ projectName: 'test-project' })).not.toThrow();
         });
     });
     describe('Silent mode behavior', () => {
@@ -79,18 +79,18 @@ describe('Hive SDK', () => {
             delete process.env.HIVE_API_KEY;
             delete process.env.HIVE_API_SECRET;
             delete process.env.HIVE_HOST;
-            silentClient = new index_1.HiveLogClient('silent-project');
+            silentClient = new index_1.HiveLogClient({ projectName: 'silent-project' });
         });
         it('should return "silent" for sendLog in silent mode', async () => {
-            const result = await silentClient.sendLog('test-task', { data: 'test' });
+            const result = await silentClient.sendLog('test-task', { input: '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');
+            await expect(silentClient.getLog('test-task', 'test-uuid')).rejects.toThrow('Missing Hive API credentials or host, get them at https://www.forgehive.cloud');
         });
         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');
+            await expect(silentClient.setQuality('test-task', 'test-uuid', quality)).rejects.toThrow('Missing Hive API credentials or host, get them at https://www.forgehive.cloud');
         });
     });
 });

package/dist/test/metadata.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/metadata.test.js

@@ -0,0 +1,352 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const index_1 = require("../index");
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+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 index_1.HiveLogClient(testConfig);
+            expect(client).toBeInstanceOf(index_1.HiveLogClient);
+            expect(client.isActive()).toBe(true);
+        });
+        it('should create client with base metadata', () => {
+            const baseMetadata = {
+                environment: 'production',
+                version: '1.0.0',
+                service: 'test-service'
+            };
+            const client = new index_1.HiveLogClient({ ...testConfig, metadata: baseMetadata });
+            expect(client).toBeInstanceOf(index_1.HiveLogClient);
+            expect(client.isActive()).toBe(true);
+        });
+        it('should handle empty base metadata object', () => {
+            const client = new index_1.HiveLogClient({ ...testConfig, metadata: {} });
+            expect(client).toBeInstanceOf(index_1.HiveLogClient);
+            expect(client.isActive()).toBe(true);
+        });
+        it('should handle undefined base metadata', () => {
+            const client = new index_1.HiveLogClient({ ...testConfig, metadata: undefined });
+            expect(client).toBeInstanceOf(index_1.HiveLogClient);
+            expect(client.isActive()).toBe(true);
+        });
+    });
+    describe('createHiveLogClient factory with metadata', () => {
+        it('should create client without base metadata', () => {
+            const client = (0, index_1.createHiveLogClient)(testConfig);
+            expect(client).toBeInstanceOf(index_1.HiveLogClient);
+        });
+        it('should create client with base metadata', () => {
+            const baseMetadata = {
+                environment: 'development',
+                team: 'backend'
+            };
+            const client = (0, index_1.createHiveLogClient)({ ...testConfig, metadata: baseMetadata });
+            expect(client).toBeInstanceOf(index_1.HiveLogClient);
+        });
+    });
+    describe('sendLog with metadata parameter', () => {
+        let client;
+        beforeEach(() => {
+            client = new index_1.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 = {
+                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 = { 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 = { 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 = {
+                environment: 'production',
+                version: '1.0.0'
+            };
+            const client = new index_1.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 = {
+                environment: 'production',
+                version: '1.0.0'
+            };
+            const client = new index_1.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 = {
+                environment: 'production',
+                version: '1.0.0',
+                priority: 'base'
+            };
+            const client = new index_1.HiveLogClient({ ...testConfig, metadata: baseMetadata });
+            const logItem = {
+                input: 'test',
+                metadata: {
+                    sessionId: 'session-123',
+                    version: '1.1.0',
+                    priority: 'logItem'
+                }
+            };
+            const sendLogMetadata = {
+                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 = {
+                environment: 'production',
+                service: 'api-gateway',
+                version: '1.0.0',
+                datacenter: 'us-west-2'
+            };
+            const client = new index_1.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 = {
+                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 = { environment: 'test' };
+            const client = new index_1.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 = { environment: 'test' };
+            const client = new index_1.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 index_1.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 = { environment: 'test' };
+            const silentClient = new index_1.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 = { environment: 'test' };
+            const client = new index_1.HiveLogClient({ ...testConfig, metadata: baseMetadata });
+            const result = await client.sendLog('test-task', { input: 'test' }, { requestId: 'req-123' });
+            expect(result).toBe('error');
+        });
+    });
+});

package/dist/test/sendLog.test.js

@@ -9,23 +9,19 @@ const index_1 = require("../index");
 jest.mock('axios');
 const mockedAxios = axios_1.default;
 describe('HiveLogClient sendLog', () => {
-    const originalEnv = process.env;
     let client;
+    const testConfig = {
+        projectName: 'test-project',
+        apiKey: 'test-api-key',
+        apiSecret: 'test-api-secret',
+        host: 'https://test-host.com'
+    };
     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 index_1.HiveLogClient('test-project');
+        // Create client instance with config
+        client = new index_1.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
@@ -37,7 +33,7 @@ describe('HiveLogClient sendLog', () => {
             expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
                 projectName: 'test-project',
                 taskName: 'test-task',
-                logItem: JSON.stringify(logItem)
+                logItem: JSON.stringify({ ...logItem, metadata: {} })
             }, {
                 headers: {
                     Authorization: 'Bearer test-api-key:test-api-secret',
@@ -60,7 +56,7 @@ describe('HiveLogClient sendLog', () => {
             expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
                 projectName: 'test-project',
                 taskName: 'complex-task',
-                logItem: JSON.stringify(complexLogItem)
+                logItem: JSON.stringify({ ...complexLogItem, metadata: {} })
             }, {
                 headers: {
                     Authorization: 'Bearer test-api-key:test-api-secret',
@@ -86,14 +82,14 @@ 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));
         });
         it('should handle null/undefined values in log items', async () => {
@@ -104,7 +100,7 @@ describe('HiveLogClient sendLog', () => {
             expect(mockedAxios.post).toHaveBeenCalledWith('https://test-host.com/api/tasks/log-ingest', {
                 projectName: 'test-project',
                 taskName: 'null-task',
-                logItem: JSON.stringify(logItem)
+                logItem: JSON.stringify({ ...logItem, metadata: {} })
             }, expect.any(Object));
         });
     });

package/dist/test/setQuality.test.js

@@ -9,23 +9,19 @@ const index_1 = require("../index");
 jest.mock('axios');
 const mockedAxios = axios_1.default;
 describe('HiveLogClient setQuality', () => {
-    const originalEnv = process.env;
     let client;
+    const testConfig = {
+        projectName: 'test-project',
+        apiKey: 'test-api-key',
+        apiSecret: 'test-api-secret',
+        host: 'https://test-host.com'
+    };
     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 index_1.HiveLogClient('test-project');
+        // Create client instance with config
+        client = new index_1.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
@@ -173,10 +169,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 index_1.HiveLogClient('silent-project');
+            const silentClient = new index_1.HiveLogClient({ projectName: 'silent-project' });
             const quality = {
                 score: 8.0,
                 reason: 'Test quality for silent mode',
@@ -184,7 +177,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();
         });

package/package.json

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