hive-stream 3.0.2 → 3.0.4

package/examples/contracts/poll.ts

@@ -1,21 +0,0 @@
-import { Streamer, createPollContract } from 'hive-stream';
-import { SqliteAdapter } from 'hive-stream';
-
-async function main() {
-    const streamer = new Streamer({
-        JSON_ID: 'hivestream',
-        PAYLOAD_IDENTIFIER: 'hive_stream'
-    });
-
-    await streamer.registerAdapter(new SqliteAdapter());
-    await streamer.registerContract(createPollContract());
-
-    streamer.start();
-
-    // Create poll:
-    // {"hive_stream": {"contract":"polls","action":"createPoll","payload":{"pollId":"launch","question":"Ship it?","options":["yes","no"],"durationHours":24}}}
-    // Vote:
-    // {"hive_stream": {"contract":"polls","action":"vote","payload":{"pollId":"launch","option":0}}}
-}
-
-main();

package/examples/contracts/rps.ts

@@ -1,19 +0,0 @@
-import { Streamer, createRpsContract } from 'hive-stream';
-import { SqliteAdapter } from 'hive-stream';
-
-async function main() {
-    const streamer = new Streamer({
-        JSON_ID: 'hivestream',
-        PAYLOAD_IDENTIFIER: 'hive_stream'
-    });
-
-    await streamer.registerAdapter(new SqliteAdapter());
-    await streamer.registerContract(createRpsContract({ account: 'my-rps-bank' }));
-
-    streamer.start();
-
-    // User sends transfer with memo:
-    // {"hive_stream": {"contract":"rps","action":"play","payload":{"move":"rock","seed":"optional"}}}
-}
-
-main();

package/examples/contracts/tipjar.ts

@@ -1,19 +0,0 @@
-import { Streamer, createTipJarContract } from 'hive-stream';
-import { SqliteAdapter } from 'hive-stream';
-
-async function main() {
-    const streamer = new Streamer({
-        JSON_ID: 'hivestream',
-        PAYLOAD_IDENTIFIER: 'hive_stream'
-    });
-
-    await streamer.registerAdapter(new SqliteAdapter());
-    await streamer.registerContract(createTipJarContract({ name: 'tipjar' }));
-
-    streamer.start();
-
-    // User sends transfer with memo:
-    // {"hive_stream": {"contract":"tipjar","action":"tip","payload":{"message":"Great project!"}}}
-}
-
-main();

package/jest.config.js

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

package/test-contract-block.md

@@ -1,19 +0,0 @@
-42189228
-
-hive_keychain.requestCustomJson('beggars', 'hivestream', 'active', JSON.stringify({ hive_stream: { contract: 'hivedice', action: 'roll', payload: { roll: 22, direction: 'lesserThan'} } }), 'Test', function(response) {
-	console.log(response);
-});
-
-42203941
-Transfer memo payload
-
-{"hive_stream":{"contract":"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

@@ -1,252 +0,0 @@
-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.contractAction).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 contractAction', () => {
-            expect(() => {
-                new TimeAction('1m', 'test-action', 'testcontract', '');
-            }).toThrow('contractAction 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',
-                contractAction: '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',
-                contractAction: '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.contractAction).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.contractAction).toBe(action.contractAction);
-            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

@@ -1,144 +0,0 @@
-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?.contractAction).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?.contractAction).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', contractAction: '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('contractAction');
-            expect(stateData.actions[0]).toHaveProperty('date');
-            expect(typeof stateData.actions[0].date).toBe('string'); // Should be ISO string
-        });
-    });
-});

package/tests/adapters/postgresql.adapter.spec.ts

@@ -1,127 +0,0 @@
-import { PostgreSQLAdapter } from "../../src/adapters/postgresql.adapter";
-
-describe('PostgreSQL Adapter', () => {
-    let sut: PostgreSQLAdapter;
-
-    beforeEach(() => {
-        sut = new PostgreSQLAdapter({
-            host: 'localhost',
-            port: 5432,
-            user: 'test',
-            password: 'test',
-            database: 'test_db'
-        });
-    });
-
-    test('constructor creates adapter with connection config', () => {
-        expect(sut).toBeInstanceOf(PostgreSQLAdapter);
-        expect(sut.getDb()).toBeDefined();
-    });
-
-    test('constructor works with connection string', () => {
-        const adapter = new PostgreSQLAdapter({
-            connectionString: 'postgresql://user:pass@localhost:5432/dbname',
-            ssl: true
-        });
-        
-        expect(adapter).toBeInstanceOf(PostgreSQLAdapter);
-        expect(adapter.getDb()).toBeDefined();
-    });
-
-    test('constructor uses default values when not provided', () => {
-        const adapter = new PostgreSQLAdapter({
-            password: 'test'
-        });
-        
-        expect(adapter).toBeInstanceOf(PostgreSQLAdapter);
-        expect(adapter.getDb()).toBeDefined();
-    });
-
-    test('processOperation sets internal state', async () => {
-        const testData = {
-            blockNumber: 12345,
-            blockId: 'test-block',
-            prevBlockId: 'prev-block',
-            trxId: 'test-tx',
-            blockTime: new Date()
-        };
-
-        await sut.processOperation({}, testData.blockNumber, testData.blockId, testData.prevBlockId, testData.trxId, testData.blockTime);
-
-        // Since these are private properties, we can't directly test them
-        // But we can verify the method doesn't throw
-        expect(true).toBe(true);
-    });
-
-    test('getDb returns knex instance', () => {
-        const db = sut.getDb();
-        expect(db).toBeDefined();
-        expect(typeof db).toBe('function'); // Knex instance is callable
-    });
-
-    test('destroy method is implemented', async () => {
-        // Create a mock knex instance
-        const mockKnex = {
-            destroy: jest.fn().mockResolvedValue(undefined)
-        };
-        (sut as any).db = mockKnex;
-
-        const result = await sut.destroy();
-
-        expect(result).toBe(true);
-        expect(mockKnex.destroy).toHaveBeenCalled();
-    });
-
-    test('query method handles raw SQL', async () => {
-        // Create a mock knex instance
-        const mockKnex = {
-            raw: jest.fn().mockResolvedValue({ rows: [{ id: 1, name: 'test' }] })
-        };
-        (sut as any).db = mockKnex;
-
-        const result = await sut.query('SELECT * FROM test WHERE id = $1', [1]);
-
-        expect(result).toEqual([{ id: 1, name: 'test' }]);
-        expect(mockKnex.raw).toHaveBeenCalledWith('SELECT * FROM test WHERE id = $1', [1]);
-    });
-
-    test('loadState handles missing state gracefully', async () => {
-        // Mock the query to return no results
-        const mockQuery = jest.fn().mockReturnValue({
-            select: jest.fn().mockReturnValue({
-                first: jest.fn().mockResolvedValue(null)
-            })
-        });
-        (sut as any).db = mockQuery;
-
-        const result = await sut.loadState();
-
-        expect(result).toBeNull();
-    });
-
-    test('saveState serializes actions correctly', async () => {
-        const testData = {
-            lastBlockNumber: 12345,
-            actions: [{ id: 'test', type: 'action' }]
-        };
-
-        // Mock the query chain
-        const mockMerge = jest.fn().mockResolvedValue(undefined);
-        const mockOnConflict = jest.fn().mockReturnValue({ merge: mockMerge });
-        const mockInsert = jest.fn().mockReturnValue({ onConflict: mockOnConflict });
-        const mockQuery = jest.fn().mockReturnValue({ insert: mockInsert });
-        (sut as any).db = mockQuery;
-
-        const result = await sut.saveState(testData);
-
-        expect(result).toBe(true);
-        expect(mockQuery).toHaveBeenCalledWith('params');
-        expect(mockInsert).toHaveBeenCalledWith({
-            id: 1,
-            actions: JSON.stringify(testData.actions),
-            lastBlockNumber: 12345
-        });
-        expect(mockOnConflict).toHaveBeenCalledWith('id');
-        expect(mockMerge).toHaveBeenCalled();
-    });
-});