blockmine 1.24.0 → 1.27.0

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

@@ -0,0 +1,81 @@
+const { EventEmitter } = require('events');
+const { BaseError } = require('./index');
+
+const SENSITIVE_PATTERNS = [
+    /password/i,
+    /token/i,
+    /secret/i,
+    /\bkey\b/i,
+    /authorization/i,
+    /cookie/i,
+    /apiKey/i,
+    /api_key/i,
+];
+
+class ErrorHandler extends EventEmitter {
+    constructor({ logger }) {
+        super();
+        this.logger = logger;
+    }
+
+    handle(error, context = {}) {
+        const sanitizedContext = ErrorHandler.sanitize(context);
+        const isOperational = ErrorHandler.isOperational(error);
+
+        const logEntry = {
+            botId: sanitizedContext.botId,
+            userId: sanitizedContext.userId,
+            requestId: sanitizedContext.requestId,
+            timestamp: new Date().toISOString(),
+            code: error.code,
+            statusCode: error.statusCode,
+            messageKey: error.messageKey || error.message,
+            isOperational,
+            stack: error.stack,
+            context: sanitizedContext,
+        };
+
+        if (isOperational) {
+            this.logger.warn(logEntry, 'errors.operational');
+        } else {
+            this.logger.error(logEntry, 'errors.unexpected');
+        }
+
+        this.emit('error:handled', { error, context: sanitizedContext, isOperational });
+
+        return {
+            success: false,
+            error: {
+                code: error.code || 'INTERNAL_ERROR',
+                messageKey: error.messageKey || 'errors.internal',
+                statusCode: error.statusCode || 500,
+                isOperational,
+            },
+        };
+    }
+
+    static isOperational(error) {
+        return error instanceof BaseError && error.isOperational === true;
+    }
+
+    static sanitize(data) {
+        if (data === null || data === undefined) return data;
+
+        if (typeof data !== 'object') return data;
+
+        if (Array.isArray(data)) {
+            return data.map(ErrorHandler.sanitize);
+        }
+
+        return Object.fromEntries(
+            Object.entries(data).map(([key, value]) => {
+                const isSensitive = SENSITIVE_PATTERNS.some((pattern) => pattern.test(key));
+                if (isSensitive) return [key, '[REDACTED]'];
+                if (value && typeof value === 'object') return [key, ErrorHandler.sanitize(value)];
+                return [key, value];
+            })
+        );
+    }
+}
+
+module.exports = ErrorHandler;

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;