blockmine 1.25.0 → 1.27.1

package/backend/src/core/errors/__tests__/ErrorHandler.test.js

@@ -0,0 +1,188 @@
+const ErrorHandler = require('../ErrorHandler');
+const { BaseError, ValidationError, NotFoundError } = require('../index');
+
+function makeLogger() {
+    return {
+        warn: jest.fn(),
+        error: jest.fn(),
+    };
+}
+
+describe('ErrorHandler', () => {
+    describe('isOperational', () => {
+        it('returns true for BaseError with isOperational=true', () => {
+            const err = new ValidationError('errors.validation');
+            expect(ErrorHandler.isOperational(err)).toBe(true);
+        });
+
+        it('returns false for BaseError with isOperational=false', () => {
+            const err = new BaseError('errors.critical', { isOperational: false });
+            expect(ErrorHandler.isOperational(err)).toBe(false);
+        });
+
+        it('returns false for plain Error', () => {
+            expect(ErrorHandler.isOperational(new Error('boom'))).toBe(false);
+        });
+
+        it('returns false for non-error values', () => {
+            expect(ErrorHandler.isOperational(null)).toBe(false);
+            expect(ErrorHandler.isOperational('string')).toBe(false);
+            expect(ErrorHandler.isOperational(42)).toBe(false);
+        });
+    });
+
+    describe('sanitize', () => {
+        it('redacts password field', () => {
+            const result = ErrorHandler.sanitize({ password: 'secret123' });
+            expect(result.password).toBe('[REDACTED]');
+        });
+
+        it('redacts token field', () => {
+            const result = ErrorHandler.sanitize({ token: 'abc' });
+            expect(result.token).toBe('[REDACTED]');
+        });
+
+        it('redacts secret field', () => {
+            const result = ErrorHandler.sanitize({ secret: 'xyz' });
+            expect(result.secret).toBe('[REDACTED]');
+        });
+
+        it('redacts key field', () => {
+            const result = ErrorHandler.sanitize({ key: 'mykey' });
+            expect(result.key).toBe('[REDACTED]');
+        });
+
+        it('redacts authorization field', () => {
+            const result = ErrorHandler.sanitize({ authorization: 'Bearer token' });
+            expect(result.authorization).toBe('[REDACTED]');
+        });
+
+        it('redacts cookie field', () => {
+            const result = ErrorHandler.sanitize({ cookie: 'session=abc' });
+            expect(result.cookie).toBe('[REDACTED]');
+        });
+
+        it('redacts apiKey field', () => {
+            const result = ErrorHandler.sanitize({ apiKey: 'key123' });
+            expect(result.apiKey).toBe('[REDACTED]');
+        });
+
+        it('redacts api_key field', () => {
+            const result = ErrorHandler.sanitize({ api_key: 'key123' });
+            expect(result.api_key).toBe('[REDACTED]');
+        });
+
+        it('preserves non-sensitive fields', () => {
+            const result = ErrorHandler.sanitize({ botId: 'bot1', userId: 'user1' });
+            expect(result.botId).toBe('bot1');
+            expect(result.userId).toBe('user1');
+        });
+
+        it('redacts nested sensitive fields', () => {
+            const result = ErrorHandler.sanitize({ user: { password: 'secret', name: 'Alice' } });
+            expect(result.user.password).toBe('[REDACTED]');
+            expect(result.user.name).toBe('Alice');
+        });
+
+        it('handles arrays', () => {
+            const result = ErrorHandler.sanitize([{ password: 'x' }, { name: 'y' }]);
+            expect(result[0].password).toBe('[REDACTED]');
+            expect(result[1].name).toBe('y');
+        });
+
+        it('returns primitives unchanged', () => {
+            expect(ErrorHandler.sanitize('hello')).toBe('hello');
+            expect(ErrorHandler.sanitize(42)).toBe(42);
+            expect(ErrorHandler.sanitize(null)).toBeNull();
+        });
+    });
+
+    describe('handle', () => {
+        it('logs operational errors with warn', () => {
+            const logger = makeLogger();
+            const handler = new ErrorHandler({ logger });
+            const err = new ValidationError('errors.validation');
+
+            handler.handle(err, { botId: 'b1', userId: 'u1' });
+
+            expect(logger.warn).toHaveBeenCalledTimes(1);
+            expect(logger.error).not.toHaveBeenCalled();
+        });
+
+        it('logs non-operational errors with error', () => {
+            const logger = makeLogger();
+            const handler = new ErrorHandler({ logger });
+            const err = new Error('unexpected');
+
+            handler.handle(err, {});
+
+            expect(logger.error).toHaveBeenCalledTimes(1);
+            expect(logger.warn).not.toHaveBeenCalled();
+        });
+
+        it('returns structured error response', () => {
+            const logger = makeLogger();
+            const handler = new ErrorHandler({ logger });
+            const err = new NotFoundError('errors.notFound');
+
+            const result = handler.handle(err);
+
+            expect(result.success).toBe(false);
+            expect(result.error.code).toBe('NOT_FOUND');
+            expect(result.error.statusCode).toBe(404);
+            expect(result.error.messageKey).toBe('errors.notFound');
+            expect(result.error.isOperational).toBe(true);
+        });
+
+        it('sanitizes sensitive data in context before logging', () => {
+            const logger = makeLogger();
+            const handler = new ErrorHandler({ logger });
+            const err = new ValidationError('errors.validation');
+
+            handler.handle(err, { password: 'secret', botId: 'b1' });
+
+            const loggedEntry = logger.warn.mock.calls[0][0];
+            expect(loggedEntry.context.password).toBe('[REDACTED]');
+            expect(loggedEntry.context.botId).toBe('b1');
+        });
+
+        it('emits error:handled event', () => {
+            const logger = makeLogger();
+            const handler = new ErrorHandler({ logger });
+            const err = new ValidationError('errors.validation');
+            const listener = jest.fn();
+
+            handler.on('error:handled', listener);
+            handler.handle(err, { botId: 'b1' });
+
+            expect(listener).toHaveBeenCalledTimes(1);
+            const payload = listener.mock.calls[0][0];
+            expect(payload.error).toBe(err);
+            expect(payload.isOperational).toBe(true);
+        });
+
+        it('includes timestamp in log entry', () => {
+            const logger = makeLogger();
+            const handler = new ErrorHandler({ logger });
+            const err = new ValidationError('errors.validation');
+
+            handler.handle(err, {});
+
+            const loggedEntry = logger.warn.mock.calls[0][0];
+            expect(loggedEntry.timestamp).toBeDefined();
+            expect(new Date(loggedEntry.timestamp).toString()).not.toBe('Invalid Date');
+        });
+
+        it('falls back to INTERNAL_ERROR code for plain errors', () => {
+            const logger = makeLogger();
+            const handler = new ErrorHandler({ logger });
+            const err = new Error('plain error');
+
+            const result = handler.handle(err);
+
+            expect(result.error.code).toBe('INTERNAL_ERROR');
+            expect(result.error.statusCode).toBe(500);
+            expect(result.error.messageKey).toBe('errors.internal');
+        });
+    });
+});

package/backend/src/core/errors/index.js

@@ -0,0 +1,68 @@
+const BaseError = require('./BaseError');
+
+class ValidationError extends BaseError {
+    constructor(messageKey, options = {}) {
+        super(messageKey, { code: 'VALIDATION_ERROR', statusCode: 400, ...options });
+    }
+}
+
+class NotFoundError extends BaseError {
+    constructor(messageKey, options = {}) {
+        super(messageKey, { code: 'NOT_FOUND', statusCode: 404, ...options });
+    }
+}
+
+class ConflictError extends BaseError {
+    constructor(messageKey, options = {}) {
+        super(messageKey, { code: 'CONFLICT', statusCode: 409, ...options });
+    }
+}
+
+class AuthorizationError extends BaseError {
+    constructor(messageKey, options = {}) {
+        super(messageKey, { code: 'AUTHORIZATION_ERROR', statusCode: 403, ...options });
+    }
+}
+
+class ExternalServiceError extends BaseError {
+    constructor(messageKey, options = {}) {
+        super(messageKey, { code: 'EXTERNAL_SERVICE_ERROR', statusCode: 502, ...options });
+    }
+}
+
+class ConfigurationError extends BaseError {
+    constructor(messageKey, options = {}) {
+        super(messageKey, { code: 'CONFIGURATION_ERROR', statusCode: 500, ...options });
+    }
+}
+
+class PluginError extends BaseError {
+    constructor(messageKey, options = {}) {
+        super(messageKey, { code: 'PLUGIN_ERROR', statusCode: 500, ...options });
+    }
+}
+
+class GraphExecutionError extends BaseError {
+    constructor(messageKey, options = {}) {
+        super(messageKey, { code: 'GRAPH_EXECUTION_ERROR', statusCode: 500, ...options });
+    }
+}
+
+class BotError extends BaseError {
+    constructor(messageKey, options = {}) {
+        super(messageKey, { code: 'BOT_ERROR', statusCode: 500, ...options });
+    }
+}
+
+module.exports = {
+    BaseError,
+    ValidationError,
+    NotFoundError,
+    ConflictError,
+    AuthorizationError,
+    ExternalServiceError,
+    ConfigurationError,
+    PluginError,
+    GraphExecutionError,
+    BotError,
+};

package/backend/src/core/infrastructure/BatchingUtility.js

@@ -0,0 +1,66 @@
+class BatchingUtility {
+    constructor({ windowMs = 10, maxSize = 100 } = {}) {
+        this.windowMs = windowMs;
+        this.maxSize = maxSize;
+        this._queue = [];
+        this._timer = null;
+        this._resolvers = [];
+    }
+
+    add(operation) {
+        return new Promise((resolve, reject) => {
+            this._queue.push({ operation, resolve, reject });
+            this._resolvers.push({ resolve, reject });
+
+            if (this._queue.length >= this.maxSize) {
+                this._flush();
+                return;
+            }
+
+            if (!this._timer) {
+                this._timer = setTimeout(() => this._flush(), this.windowMs);
+            }
+        });
+    }
+
+    async _flush() {
+        if (this._timer) {
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+
+        const batch = this._queue.splice(0);
+        if (batch.length === 0) return;
+
+        for (const { operation, resolve, reject } of batch) {
+            try {
+                const result = await operation();
+                resolve(result);
+            } catch (err) {
+                reject(err);
+            }
+        }
+    }
+
+    async flush() {
+        return this._flush();
+    }
+
+    getPendingCount() {
+        return this._queue.length;
+    }
+
+    destroy() {
+        if (this._timer) {
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+        const err = new Error('BatchingUtility destroyed');
+        for (const { reject } of this._queue) {
+            reject(err);
+        }
+        this._queue = [];
+    }
+}
+
+module.exports = BatchingUtility;

package/backend/src/core/infrastructure/CircuitBreaker.js

@@ -0,0 +1,103 @@
+const { EventEmitter } = require('events');
+const { ExternalServiceError } = require('../errors/index');
+
+const STATE = { CLOSED: 'CLOSED', OPEN: 'OPEN', HALF_OPEN: 'HALF_OPEN' };
+
+class CircuitBreaker extends EventEmitter {
+    constructor({ failureThreshold = 5, successThreshold = 2, timeout = 60000, logger } = {}) {
+        super();
+        this.failureThreshold = failureThreshold;
+        this.successThreshold = successThreshold;
+        this.timeout = timeout;
+        this.logger = logger;
+
+        this.state = STATE.CLOSED;
+        this.failureCount = 0;
+        this.successCount = 0;
+        this.nextAttempt = null;
+        this._cachedResponse = null;
+    }
+
+    async call(fn, fallback = null) {
+        if (this.state === STATE.OPEN) {
+            if (Date.now() < this.nextAttempt) {
+                if (fallback !== null) return typeof fallback === 'function' ? fallback() : fallback;
+                throw new ExternalServiceError('errors.circuitBreaker.open');
+            }
+            this._transition(STATE.HALF_OPEN);
+        }
+
+        try {
+            const result = await fn();
+            this._onSuccess(result);
+            return result;
+        } catch (err) {
+            this._onFailure(err);
+            if (fallback !== null) return typeof fallback === 'function' ? fallback() : fallback;
+            throw err;
+        }
+    }
+
+    _onSuccess(result) {
+        this._cachedResponse = result;
+        this.failureCount = 0;
+
+        if (this.state === STATE.HALF_OPEN) {
+            this.successCount++;
+            if (this.successCount >= this.successThreshold) {
+                this._transition(STATE.CLOSED);
+            }
+        }
+    }
+
+    _onFailure(err) {
+        this.failureCount++;
+        this.successCount = 0;
+
+        if (this.state === STATE.HALF_OPEN || this.failureCount >= this.failureThreshold) {
+            this._transition(STATE.OPEN);
+        }
+    }
+
+    _transition(newState) {
+        const prevState = this.state;
+        this.state = newState;
+
+        if (newState === STATE.OPEN) {
+            this.nextAttempt = Date.now() + this.timeout;
+            this.successCount = 0;
+        } else if (newState === STATE.CLOSED) {
+            this.failureCount = 0;
+            this.successCount = 0;
+            this.nextAttempt = null;
+        } else if (newState === STATE.HALF_OPEN) {
+            this.successCount = 0;
+        }
+
+        if (this.logger) {
+            this.logger.warn(
+                { from: prevState, to: newState, failureCount: this.failureCount },
+                'errors.circuitBreaker.stateChange'
+            );
+        }
+
+        this.emit('stateChange', { from: prevState, to: newState });
+    }
+
+    getState() {
+        return this.state;
+    }
+
+    getStats() {
+        return {
+            state: this.state,
+            failureCount: this.failureCount,
+            successCount: this.successCount,
+            nextAttempt: this.nextAttempt,
+        };
+    }
+}
+
+CircuitBreaker.STATE = STATE;
+
+module.exports = CircuitBreaker;

package/backend/src/core/infrastructure/ConnectionPool.js

@@ -0,0 +1,81 @@
+const { ExternalServiceError } = require('../errors/index');
+
+class ConnectionPool {
+    constructor({ factory, min = 2, max = 10, acquireTimeout = 5000, logger } = {}) {
+        this.factory = factory;
+        this.min = min;
+        this.max = max;
+        this.acquireTimeout = acquireTimeout;
+        this.logger = logger;
+        this.idle = [];
+        this.total = 0;
+        this.queue = [];
+    }
+
+    async acquire() {
+        if (this.idle.length > 0) {
+            return this.idle.pop();
+        }
+
+        if (this.total < this.max) {
+            this.total++;
+            try {
+                return await this.factory.create();
+            } catch (err) {
+                this.total--;
+                throw new ExternalServiceError('errors.connectionPool.createFailed', { cause: err });
+            }
+        }
+
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                const idx = this.queue.findIndex(item => item.resolve === resolve);
+                if (idx !== -1) this.queue.splice(idx, 1);
+                reject(new ExternalServiceError('errors.connectionPool.acquireTimeout'));
+            }, this.acquireTimeout);
+
+            this.queue.push({
+                resolve: (conn) => {
+                    clearTimeout(timer);
+                    resolve(conn);
+                },
+                reject,
+            });
+        });
+    }
+
+    release(connection) {
+        if (this.queue.length > 0) {
+            const waiter = this.queue.shift();
+            waiter.resolve(connection);
+            return;
+        }
+        this.idle.push(connection);
+    }
+
+    async destroy() {
+        const connections = [...this.idle];
+        this.idle = [];
+        this.queue.forEach(({ reject }) =>
+            reject(new ExternalServiceError('errors.connectionPool.destroyed'))
+        );
+        this.queue = [];
+        this.total = 0;
+        await Promise.all(connections.map(conn => this.factory.destroy(conn)));
+    }
+
+    getStats() {
+        const pending = this.queue.length;
+        const idle = this.idle.length;
+        const total = this.total;
+        const utilization = total > 0 ? (total - idle) / total : 0;
+
+        if (utilization > 0.8 && this.logger) {
+            this.logger.warn({ utilization, total, idle, pending }, 'errors.connectionPool.highUtilization');
+        }
+
+        return { total, idle, pending, utilization };
+    }
+}
+
+module.exports = ConnectionPool;

package/backend/src/core/infrastructure/RateLimiter.js

@@ -0,0 +1,64 @@
+class RateLimiter {
+    constructor({ windowMs = 60000, max = 100, keyPrefix = '' } = {}) {
+        this.windowMs = windowMs;
+        this.max = max;
+        this.keyPrefix = keyPrefix;
+        this.store = new Map();
+    }
+
+    _getKey(key) {
+        return this.keyPrefix ? `${this.keyPrefix}:${key}` : key;
+    }
+
+    _prune(timestamps, now) {
+        const cutoff = now - this.windowMs;
+        let i = 0;
+        while (i < timestamps.length && timestamps[i] <= cutoff) i++;
+        return timestamps.slice(i);
+    }
+
+    check(key) {
+        const storeKey = this._getKey(key);
+        const now = Date.now();
+        const timestamps = this._prune(this.store.get(storeKey) || [], now);
+
+        const resetAt = timestamps.length > 0 ? timestamps[0] + this.windowMs : now + this.windowMs;
+        const allowed = timestamps.length < this.max;
+
+        if (allowed) {
+            timestamps.push(now);
+            this.store.set(storeKey, timestamps);
+            return { allowed: true, remaining: this.max - timestamps.length, resetAt };
+        }
+
+        const retryAfter = Math.ceil((resetAt - now) / 1000);
+        this.store.set(storeKey, timestamps);
+        return { allowed: false, remaining: 0, resetAt, retryAfter };
+    }
+
+    reset(key) {
+        this.store.delete(this._getKey(key));
+    }
+
+    middleware() {
+        return (req, res, next) => {
+            const key = req.user?.id ? String(req.user.id) : req.ip;
+            const result = this.check(key);
+
+            res.set('X-RateLimit-Limit', String(this.max));
+            res.set('X-RateLimit-Remaining', String(result.remaining));
+            res.set('X-RateLimit-Reset', String(Math.ceil(result.resetAt / 1000)));
+
+            if (!result.allowed) {
+                return res.status(429).json({
+                    error: 'errors.rateLimit.exceeded',
+                    retryAfter: result.retryAfter,
+                });
+            }
+
+            next();
+        };
+    }
+}
+
+module.exports = RateLimiter;

package/backend/src/core/infrastructure/__tests__/BatchingUtility.test.js

@@ -0,0 +1,86 @@
+const BatchingUtility = require('../BatchingUtility');
+
+describe('BatchingUtility', () => {
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+
+    it('executes operations and resolves promises', async () => {
+        const batcher = new BatchingUtility({ windowMs: 50 });
+        const p = batcher.add(() => 42);
+        await batcher.flush();
+        expect(await p).toBe(42);
+    });
+
+    it('batches multiple operations within window', async () => {
+        jest.useFakeTimers();
+        const order = [];
+        const batcher = new BatchingUtility({ windowMs: 100 });
+
+        const p1 = batcher.add(() => { order.push(1); return 1; });
+        const p2 = batcher.add(() => { order.push(2); return 2; });
+        const p3 = batcher.add(() => { order.push(3); return 3; });
+
+        await batcher.flush();
+
+        expect(order).toEqual([1, 2, 3]);
+        expect(await p1).toBe(1);
+        expect(await p2).toBe(2);
+        expect(await p3).toBe(3);
+    });
+
+    it('flushes immediately when maxSize is reached', async () => {
+        const batcher = new BatchingUtility({ windowMs: 10000, maxSize: 2 });
+        const results = [];
+        const p1 = batcher.add(() => results.push(1));
+        const p2 = batcher.add(() => results.push(2));
+        await Promise.all([p1, p2]);
+        expect(results).toEqual([1, 2]);
+    });
+
+    it('preserves operation order', async () => {
+        const batcher = new BatchingUtility({ windowMs: 50 });
+        const order = [];
+        batcher.add(() => order.push('a'));
+        batcher.add(() => order.push('b'));
+        batcher.add(() => order.push('c'));
+        await batcher.flush();
+        expect(order).toEqual(['a', 'b', 'c']);
+    });
+
+    it('rejects promise when operation throws', async () => {
+        const batcher = new BatchingUtility({ windowMs: 50 });
+        const p = batcher.add(() => { throw new Error('fail'); });
+        await batcher.flush();
+        await expect(p).rejects.toThrow('fail');
+    });
+
+    it('handles mixed success and failure in same batch', async () => {
+        const batcher = new BatchingUtility({ windowMs: 50 });
+        const p1 = batcher.add(() => 'ok');
+        const p2 = batcher.add(() => { throw new Error('fail'); });
+        const p3 = batcher.add(() => 'also ok');
+        await batcher.flush();
+        expect(await p1).toBe('ok');
+        await expect(p2).rejects.toThrow('fail');
+        expect(await p3).toBe('also ok');
+    });
+
+    it('getPendingCount returns correct count', () => {
+        jest.useFakeTimers();
+        const batcher = new BatchingUtility({ windowMs: 1000 });
+        batcher.add(() => 1);
+        batcher.add(() => 2);
+        expect(batcher.getPendingCount()).toBe(2);
+    });
+
+    it('destroy rejects all pending operations', async () => {
+        jest.useFakeTimers();
+        const batcher = new BatchingUtility({ windowMs: 1000 });
+        const p1 = batcher.add(() => 1);
+        const p2 = batcher.add(() => 2);
+        batcher.destroy();
+        await expect(p1).rejects.toThrow();
+        await expect(p2).rejects.toThrow();
+    });
+});