hive-stream 2.0.5 → 3.0.0

package/ecosystem.config.js

@@ -1,17 +1,17 @@
-// PM2 configuration
-
-module.exports = {
-  apps: [
-    {
-      name: 'steem-stream',
-      script: 'index.js',
-      ignore_watch: ['node_modules'],
-      env: {
-        NODE_ENV: 'development'
-      },
-      env_production: {
-        NODE_ENV: 'production'
-      }
-    }
-  ]
-};
+// PM2 configuration
+
+module.exports = {
+  apps: [
+    {
+      name: 'steem-stream',
+      script: 'index.js',
+      ignore_watch: ['node_modules'],
+      env: {
+        NODE_ENV: 'development'
+      },
+      env_production: {
+        NODE_ENV: 'production'
+      }
+    }
+  ]
+};

package/jest.config.js

@@ -1,9 +1,9 @@
-module.exports = {
-    setupFilesAfterEnv: ["<rootDir>/tests/setup.ts"],
-    moduleFileExtensions: ['ts', 'js'],
-    transform: {
-        '^.+\\.(ts|tsx)$': 'ts-jest'
-    },
-    testMatch: ['**/tests/**/*.spec.(ts)'],
-    testEnvironment: 'node'
+module.exports = {
+    setupFilesAfterEnv: ["<rootDir>/tests/setup.ts"],
+    moduleFileExtensions: ['ts', 'js'],
+    transform: {
+        '^.+\\.(ts|tsx)$': 'ts-jest'
+    },
+    testMatch: ['**/tests/**/*.spec.(ts)'],
+    testEnvironment: 'node'
 };

package/package.json

@@ -1,48 +1,53 @@
-{
-    "name": "hive-stream",
-    "version": "2.0.5",
-    "description": "A layer for streaming actions on the Hive blockchain and reacting to them.",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "repository": "git@github.com:Vheissu/hive-stream.git",
-    "author": "Dwayne Charrington <dwaynecharrington@gmail.com>",
-    "license": "MIT",
-    "private": false,
-    "scripts": {
-        "build": "tsc --project tsconfig.build.json",
-        "start": "npx ts-node src/test.ts",
-        "watch": "tsc -w",
-        "test": "jest --verbose",
-        "clean-tests": "jest --clearCache"
-    },
-    "dependencies": {
-        "@hiveio/dhive": "^1.2.4",
-        "bignumber.js": "^9.1.0",
-        "cors": "^2.8.5",
-        "dotenv": "^16.0.3",
-        "express": "^4.18.2",
-        "moment": "^2.29.4",
-        "mongodb": "^4.11.0",
-        "node-fetch": "^3.2.10",
-        "seedrandom": "^3.0.5",
-        "sqlite3": "^5.1.2",
-        "sscjs": "^0.0.9",
-        "uuid": "^9.0.0"
-    },
-    "devDependencies": {
-        "@types/bytebuffer": "^5.0.44",
-        "@types/dotenv": "^8.2.0",
-        "@types/jest": "^29.2.3",
-        "@types/mongodb": "^4.0.7",
-        "@types/node": "^18.11.9",
-        "@types/node-cron": "^3.0.5",
-        "@types/seedrandom": "^3.0.2",
-        "jest": "^29.3.1",
-        "jest-cli": "^29.3.1",
-        "jest-fetch-mock": "^3.0.3",
-        "mongodb-memory-server": "^8.9.5",
-        "ts-jest": "^29.0.3",
-        "ts-node": "^10.9.1",
-        "typescript": "^4.9.3"
-    }
-}
+{
+    "name": "hive-stream",
+    "version": "3.0.0",
+    "description": "A layer for streaming actions on the Hive blockchain and reacting to them.",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "repository": "git@github.com:Vheissu/hive-stream.git",
+    "author": "Dwayne Charrington <dwaynecharrington@gmail.com>",
+    "license": "MIT",
+    "private": false,
+    "scripts": {
+        "build": "tsc --project tsconfig.build.json",
+        "start": "npx ts-node src/test.ts",
+        "watch": "tsc -w",
+        "test": "jest --verbose",
+        "clean-tests": "jest --clearCache"
+    },
+    "dependencies": {
+        "@hiveio/dhive": "^1.2.4",
+        "@types/better-sqlite3": "^7.6.13",
+        "better-sqlite3": "^12.2.0",
+        "bignumber.js": "^9.1.0",
+        "cors": "^2.8.5",
+        "dotenv": "^16.0.3",
+        "express": "^4.18.2",
+        "knex": "^3.1.0",
+        "moment": "^2.29.4",
+        "mongodb": "^4.11.0",
+        "node-fetch": "^3.2.10",
+        "pg": "^8.16.3",
+        "seedrandom": "^3.0.5",
+        "sscjs": "^0.0.9",
+        "uuid": "^9.0.0"
+    },
+    "devDependencies": {
+        "@types/bytebuffer": "^5.0.44",
+        "@types/dotenv": "^8.2.0",
+        "@types/jest": "^29.2.3",
+        "@types/mongodb": "^4.0.7",
+        "@types/node": "^18.19.121",
+        "@types/node-cron": "^3.0.5",
+        "@types/pg": "^8.15.5",
+        "@types/seedrandom": "^3.0.8",
+        "@types/uuid": "^10.0.0",
+        "jest": "^29.3.1",
+        "jest-cli": "^29.3.1",
+        "jest-fetch-mock": "^3.0.3",
+        "mongodb-memory-server": "^8.9.5",
+        "ts-jest": "^29.0.3",
+        "ts-node": "^10.9.1",
+        "typescript": "^4.9.3"
+    }
+}

package/test-contract-block.md

@@ -1,19 +1,19 @@
-42189228
-
-hive_keychain.requestCustomJson('beggars', 'hivedice', 'active', JSON.stringify({ hiveContract: { name: 'hivedice', action: 'roll', payload: { roll: 22, direction: 'lesserThan'} } }), 'Test', function(response) {
-	console.log(response);
-});
-
-42203941
-Transfer memo payload
-
-{"hiveContract":{"id":"testdice", "name":"hivedice","action":"roll","payload":{"roll":95,"direction":"greaterThan"}}}
-
-42208330
-Transfer memo, amount higher than max
-
-42209768
-Transfer memo, valid bet
-
-42210252
+42189228
+
+hive_keychain.requestCustomJson('beggars', 'hivedice', 'active', JSON.stringify({ hiveContract: { name: 'hivedice', action: 'roll', payload: { roll: 22, direction: 'lesserThan'} } }), 'Test', function(response) {
+	console.log(response);
+});
+
+42203941
+Transfer memo payload
+
+{"hiveContract":{"id":"testdice", "name":"hivedice","action":"roll","payload":{"roll":95,"direction":"greaterThan"}}}
+
+42208330
+Transfer memo, amount higher than max
+
+42209768
+Transfer memo, valid bet
+
+42210252
 Transfer memo, valid bet and greater than

package/tests/actions.spec.ts

@@ -0,0 +1,252 @@
+import { TimeAction } from '../src/actions';
+
+describe('TimeAction', () => {
+    describe('Constructor and Validation', () => {
+        test('Should create a valid TimeAction with required parameters', () => {
+            const action = new TimeAction('1m', 'test-action', 'testcontract', 'testmethod');
+            
+            expect(action.timeValue).toBe('1m');
+            expect(action.id).toBe('test-action');
+            expect(action.contractName).toBe('testcontract');
+            expect(action.contractMethod).toBe('testmethod');
+            expect(action.payload).toEqual({});
+            expect(action.enabled).toBe(true);
+            expect(action.executionCount).toBe(0);
+            expect(action.date).toBeInstanceOf(Date);
+        });
+
+        test('Should create TimeAction with all optional parameters', () => {
+            const testDate = new Date('2023-01-01T00:00:00Z');
+            const payload = { test: 'data' };
+            
+            const action = new TimeAction(
+                '1h',
+                'test-action',
+                'testcontract',
+                'testmethod',
+                payload,
+                testDate,
+                false,
+                5,
+                10,
+                'America/New_York'
+            );
+            
+            expect(action.timeValue).toBe('1h');
+            expect(action.payload).toEqual(payload);
+            expect(action.date).toEqual(testDate);
+            expect(action.enabled).toBe(false);
+            expect(action.executionCount).toBe(5);
+            expect(action.maxExecutions).toBe(10);
+            expect(action.timezone).toBe('America/New_York');
+        });
+
+        test('Should throw error for invalid timeValue', () => {
+            expect(() => {
+                new TimeAction('invalid', 'test-action', 'testcontract', 'testmethod');
+            }).toThrow('Invalid timeValue \'invalid\'');
+        });
+
+        test('Should throw error for empty timeValue', () => {
+            expect(() => {
+                new TimeAction('', 'test-action', 'testcontract', 'testmethod');
+            }).toThrow('timeValue must be a non-empty string');
+        });
+
+        test('Should throw error for invalid id format', () => {
+            expect(() => {
+                new TimeAction('1m', 'test action!', 'testcontract', 'testmethod');
+            }).toThrow('id can only contain alphanumeric characters, underscores, and hyphens');
+        });
+
+        test('Should throw error for too long id', () => {
+            const longId = 'a'.repeat(256);
+            expect(() => {
+                new TimeAction('1m', longId, 'testcontract', 'testmethod');
+            }).toThrow('id must not exceed 255 characters');
+        });
+
+        test('Should throw error for empty contractName', () => {
+            expect(() => {
+                new TimeAction('1m', 'test-action', '', 'testmethod');
+            }).toThrow('contractName must be a non-empty string');
+        });
+
+        test('Should throw error for empty contractMethod', () => {
+            expect(() => {
+                new TimeAction('1m', 'test-action', 'testcontract', '');
+            }).toThrow('contractMethod must be a non-empty string');
+        });
+
+        test('Should throw error for invalid date string', () => {
+            expect(() => {
+                new TimeAction('1m', 'test-action', 'testcontract', 'testmethod', {}, 'invalid-date');
+            }).toThrow('Invalid date string \'invalid-date\'');
+        });
+    });
+
+    describe('Methods', () => {
+        let action: TimeAction;
+
+        beforeEach(() => {
+            action = new TimeAction('1m', 'test-action', 'testcontract', 'testmethod');
+        });
+
+        test('Should reset date and lastExecution', async () => {
+            const originalDate = action.date;
+            action.lastExecution = new Date();
+            
+            // Wait a bit to ensure time difference
+            await new Promise(resolve => setTimeout(resolve, 10));
+            
+            action.reset();
+            
+            expect(action.date.getTime()).toBeGreaterThan(originalDate.getTime());
+            expect(action.lastExecution).toBeUndefined();
+        });
+
+        test('Should disable and enable action', () => {
+            expect(action.enabled).toBe(true);
+            
+            action.disable();
+            expect(action.enabled).toBe(false);
+            
+            action.enable();
+            expect(action.enabled).toBe(true);
+        });
+
+        test('Should track execution count and max executions', () => {
+            action.maxExecutions = 3;
+            
+            expect(action.hasReachedMaxExecutions()).toBe(false);
+            
+            action.incrementExecutionCount();
+            expect(action.executionCount).toBe(1);
+            expect(action.lastExecution).toBeInstanceOf(Date);
+            expect(action.hasReachedMaxExecutions()).toBe(false);
+            
+            action.incrementExecutionCount();
+            action.incrementExecutionCount();
+            expect(action.executionCount).toBe(3);
+            expect(action.hasReachedMaxExecutions()).toBe(true);
+        });
+
+        test('Should not reach max executions when maxExecutions is undefined', () => {
+            action.executionCount = 1000;
+            expect(action.hasReachedMaxExecutions()).toBe(false);
+        });
+    });
+
+    describe('Serialization', () => {
+        test('Should serialize to JSON correctly', () => {
+            const testDate = new Date('2023-01-01T00:00:00Z');
+            const lastExecution = new Date('2023-01-01T01:00:00Z');
+            const payload = { test: 'data' };
+            
+            const action = new TimeAction(
+                '1h',
+                'test-action',
+                'testcontract',
+                'testmethod',
+                payload,
+                testDate,
+                false,
+                5,
+                10,
+                'UTC'
+            );
+            action.lastExecution = lastExecution;
+            
+            const json = action.toJSON();
+            
+            expect(json).toEqual({
+                timeValue: '1h',
+                id: 'test-action',
+                contractName: 'testcontract',
+                contractMethod: 'testmethod',
+                payload: payload,
+                date: testDate.toISOString(),
+                enabled: false,
+                lastExecution: lastExecution.toISOString(),
+                executionCount: 5,
+                maxExecutions: 10,
+                timezone: 'UTC'
+            });
+        });
+
+        test('Should deserialize from JSON correctly', () => {
+            const testDate = new Date('2023-01-01T00:00:00Z');
+            const lastExecution = new Date('2023-01-01T01:00:00Z');
+            const payload = { test: 'data' };
+            
+            const jsonData = {
+                timeValue: '1h',
+                id: 'test-action',
+                contractName: 'testcontract',
+                contractMethod: 'testmethod',
+                payload: payload,
+                date: testDate.toISOString(),
+                enabled: false,
+                lastExecution: lastExecution.toISOString(),
+                executionCount: 5,
+                maxExecutions: 10,
+                timezone: 'UTC'
+            };
+            
+            const action = TimeAction.fromJSON(jsonData);
+            
+            expect(action.timeValue).toBe('1h');
+            expect(action.id).toBe('test-action');
+            expect(action.contractName).toBe('testcontract');
+            expect(action.contractMethod).toBe('testmethod');
+            expect(action.payload).toEqual(payload);
+            expect(action.date).toEqual(testDate);
+            expect(action.enabled).toBe(false);
+            expect(action.lastExecution).toEqual(lastExecution);
+            expect(action.executionCount).toBe(5);
+            expect(action.maxExecutions).toBe(10);
+            expect(action.timezone).toBe('UTC');
+        });
+
+        test('Should handle serialization without optional fields', () => {
+            const action = new TimeAction('1m', 'test-action', 'testcontract', 'testmethod');
+            
+            const json = action.toJSON();
+            const restored = TimeAction.fromJSON(json);
+            
+            expect(restored.timeValue).toBe(action.timeValue);
+            expect(restored.id).toBe(action.id);
+            expect(restored.contractName).toBe(action.contractName);
+            expect(restored.contractMethod).toBe(action.contractMethod);
+            expect(restored.payload).toEqual({});
+            expect(restored.enabled).toBe(true);
+            expect(restored.executionCount).toBe(0);
+            expect(restored.lastExecution).toBeUndefined();
+            expect(restored.maxExecutions).toBeUndefined();
+        });
+    });
+
+    describe('Static Methods', () => {
+        test('Should return valid time values', () => {
+            const validValues = TimeAction.getValidTimeValues();
+            
+            expect(validValues).toContain('3s');
+            expect(validValues).toContain('1m');
+            expect(validValues).toContain('1h');
+            expect(validValues).toContain('24h');
+            expect(validValues).toContain('week');
+            expect(Array.isArray(validValues)).toBe(true);
+        });
+
+        test('Should return a copy of valid time values', () => {
+            const validValues1 = TimeAction.getValidTimeValues();
+            const validValues2 = TimeAction.getValidTimeValues();
+            
+            expect(validValues1).toEqual(validValues2);
+            expect(validValues1).not.toBe(validValues2); // Different array instances
+            
+            validValues1.push('invalid');
+            expect(validValues2).not.toContain('invalid');
+        });
+    });
+});

package/tests/adapters/actions-persistence.spec.ts

@@ -0,0 +1,144 @@
+import { TimeAction } from '../../src/actions';
+import { SqliteAdapter } from '../../src/adapters/sqlite.adapter';
+import { MongodbAdapter } from '../../src/adapters/mongodb.adapter';
+import fs from 'fs';
+import path from 'path';
+
+describe('Actions Persistence', () => {
+    describe('SqliteAdapter', () => {
+        let adapter: SqliteAdapter;
+        let testDbPath: string;
+
+        beforeEach(async () => {
+            // Create unique database path for each test
+            testDbPath = path.resolve(__dirname, `../../src/adapters/hive-stream-test-${Date.now()}-${Math.random()}.db`);
+            
+            // Clean up any existing test database
+            if (fs.existsSync(testDbPath)) {
+                fs.unlinkSync(testDbPath);
+            }
+            
+            adapter = new SqliteAdapter(testDbPath);
+            await adapter.create();
+        });
+
+        afterEach(async () => {
+            if (adapter && adapter.getDb()) {
+                await adapter.destroy();
+            }
+            
+            // Clean up test database
+            if (fs.existsSync(testDbPath)) {
+                fs.unlinkSync(testDbPath);
+            }
+        });
+
+        test('Should save and load actions correctly', async () => {
+            const testActions = [
+                new TimeAction('1m', 'action1', 'contract1', 'method1', { data: 'test1' }),
+                new TimeAction('5m', 'action2', 'contract2', 'method2', { data: 'test2' }, new Date('2023-01-01'), false, 5, 10)
+            ];
+            
+            // Serialize actions as they would be in the streamer
+            const serializedActions = testActions.map(a => a.toJSON());
+            
+            const stateData = {
+                lastBlockNumber: 12345,
+                actions: serializedActions
+            };
+            
+            await adapter.saveState(stateData);
+            
+            const loadedActions = await adapter.loadActions();
+            
+            expect(loadedActions).toHaveLength(2);
+            
+            const action1 = loadedActions.find(a => a.id === 'action1');
+            const action2 = loadedActions.find(a => a.id === 'action2');
+            
+            expect(action1).toBeDefined();
+            expect(action1?.timeValue).toBe('1m');
+            expect(action1?.contractName).toBe('contract1');
+            expect(action1?.contractMethod).toBe('method1');
+            expect(action1?.payload).toEqual({ data: 'test1' });
+            expect(action1?.enabled).toBe(true);
+            expect(action1?.executionCount).toBe(0);
+            
+            expect(action2).toBeDefined();
+            expect(action2?.timeValue).toBe('5m');
+            expect(action2?.contractName).toBe('contract2');
+            expect(action2?.contractMethod).toBe('method2');
+            expect(action2?.payload).toEqual({ data: 'test2' });
+            expect(action2?.enabled).toBe(false);
+            expect(action2?.executionCount).toBe(5);
+            expect(action2?.maxExecutions).toBe(10);
+            expect(action2?.date).toEqual(new Date('2023-01-01'));
+        });
+
+        test('Should handle empty actions array', async () => {
+            const stateData = {
+                lastBlockNumber: 12345,
+                actions: []
+            };
+            
+            await adapter.saveState(stateData);
+            const loadedActions = await adapter.loadActions();
+            
+            expect(loadedActions).toHaveLength(0);
+            expect(Array.isArray(loadedActions)).toBe(true);
+        });
+
+        test('Should handle corrupted action data gracefully', async () => {
+            const stateData = {
+                lastBlockNumber: 12345,
+                actions: [
+                    { timeValue: '1m', id: 'valid-action', contractName: 'test', contractMethod: 'test' },
+                    { invalid: 'data' }, // Invalid action
+                    null, // Null action
+                    'invalid string' // Invalid type
+                ]
+            };
+            
+            await adapter.saveState(stateData);
+            const loadedActions = await adapter.loadActions();
+            
+            // Should only load the valid action
+            expect(loadedActions).toHaveLength(1);
+            expect(loadedActions[0].id).toBe('valid-action');
+        });
+
+        test('Should handle missing state gracefully', async () => {
+            const loadedActions = await adapter.loadActions();
+            
+            expect(loadedActions).toHaveLength(0);
+            expect(Array.isArray(loadedActions)).toBe(true);
+        });
+    });
+
+    // Note: MongoDB tests would require a running MongoDB instance
+    // For now, we'll test the serialization logic only
+    describe('MongodbAdapter Serialization', () => {
+        test('Should serialize actions data correctly for MongoDB', () => {
+            const testActions = [
+                new TimeAction('1m', 'action1', 'contract1', 'method1', { data: 'test1' }),
+                new TimeAction('5m', 'action2', 'contract2', 'method2', { data: 'test2' })
+            ];
+            
+            const serializedActions = testActions.map(a => a.toJSON());
+            
+            const stateData = {
+                lastBlockNumber: 12345,
+                actions: serializedActions
+            };
+            
+            // Verify the data structure is valid for MongoDB
+            expect(stateData.actions).toHaveLength(2);
+            expect(stateData.actions[0]).toHaveProperty('timeValue');
+            expect(stateData.actions[0]).toHaveProperty('id');
+            expect(stateData.actions[0]).toHaveProperty('contractName');
+            expect(stateData.actions[0]).toHaveProperty('contractMethod');
+            expect(stateData.actions[0]).toHaveProperty('date');
+            expect(typeof stateData.actions[0].date).toBe('string'); // Should be ISO string
+        });
+    });
+});