packet-events-js 1.0.0 → 1.0.1

package/src/advanced/MiddlewareSystem.js

@@ -0,0 +1,416 @@
+import { EventEmitter } from '../events/EventEmitter.js';
+
+export class MiddlewareContext {
+    constructor(options = {}) {
+        this.packet = options.packet;
+        this.direction = options.direction;
+        this.state = options.state;
+        this.rawData = options.rawData;
+        this.client = options.client;
+        this.timestamp = Date.now();
+        this.metadata = {};
+        this.cancelled = false;
+        this.modified = false;
+        this.errors = [];
+    }
+
+    cancel() {
+        this.cancelled = true;
+        return this;
+    }
+
+    setMetadata(key, value) {
+        this.metadata[key] = value;
+        return this;
+    }
+
+    getMetadata(key) {
+        return this.metadata[key];
+    }
+
+    markModified() {
+        this.modified = true;
+        return this;
+    }
+
+    addError(error) {
+        this.errors.push(error);
+        return this;
+    }
+}
+
+export class Middleware {
+    constructor(name, options = {}) {
+        this.name = name;
+        this.enabled = true;
+        this.priority = options.priority || 0;
+        this.filters = options.filters || {};
+    }
+
+    shouldProcess(ctx) {
+        if (!this.enabled) return false;
+        
+        if (this.filters.directions && !this.filters.directions.includes(ctx.direction)) return false;
+        if (this.filters.states && !this.filters.states.includes(ctx.state)) return false;
+        if (this.filters.packetNames && !this.filters.packetNames.includes(ctx.packet?.constructor?.packetName)) return false;
+        
+        return true;
+    }
+
+    async process(ctx, next) {
+        return next();
+    }
+
+    enable() {
+        this.enabled = true;
+        return this;
+    }
+
+    disable() {
+        this.enabled = false;
+        return this;
+    }
+}
+
+export class LoggingMiddleware extends Middleware {
+    constructor(options = {}) {
+        super('logging', options);
+        this.logger = options.logger || console;
+        this.logLevel = options.logLevel || 'debug';
+        this.format = options.format || 'simple';
+    }
+
+    async process(ctx, next) {
+        const start = Date.now();
+        
+        if (this.format === 'detailed') {
+            this.logger.log(`[${ctx.direction}] ${ctx.packet?.constructor?.packetName} (${ctx.rawData?.length || 0} bytes)`);
+        }
+
+        await next();
+
+        const duration = Date.now() - start;
+        
+        if (this.format === 'detailed') {
+            this.logger.log(`  └─ Processed in ${duration}ms, cancelled=${ctx.cancelled}, modified=${ctx.modified}`);
+        }
+    }
+}
+
+export class RateLimitMiddleware extends Middleware {
+    constructor(options = {}) {
+        super('rateLimit', options);
+        this.maxPackets = options.maxPackets || 100;
+        this.windowMs = options.windowMs || 1000;
+        this.perPacketType = options.perPacketType || false;
+        this.counters = new Map();
+        this.onLimit = options.onLimit || null;
+    }
+
+    async process(ctx, next) {
+        const now = Date.now();
+        const key = this.perPacketType ? ctx.packet?.constructor?.packetName : 'global';
+        
+        let counter = this.counters.get(key);
+        if (!counter || now - counter.windowStart > this.windowMs) {
+            counter = { count: 0, windowStart: now };
+            this.counters.set(key, counter);
+        }
+
+        counter.count++;
+
+        if (counter.count > this.maxPackets) {
+            ctx.cancel();
+            ctx.setMetadata('rateLimited', true);
+            ctx.setMetadata('rateLimitKey', key);
+            
+            if (this.onLimit) {
+                this.onLimit(ctx, key, counter.count);
+            }
+            return;
+        }
+
+        await next();
+    }
+
+    getStats() {
+        const stats = {};
+        for (const [key, counter] of this.counters) {
+            stats[key] = {
+                count: counter.count,
+                remaining: Math.max(0, this.maxPackets - counter.count),
+                windowMs: this.windowMs
+            };
+        }
+        return stats;
+    }
+
+    reset() {
+        this.counters.clear();
+        return this;
+    }
+}
+
+export class ValidationMiddleware extends Middleware {
+    constructor(options = {}) {
+        super('validation', options);
+        this.validators = new Map();
+        this.strict = options.strict || false;
+    }
+
+    addValidator(packetName, validator) {
+        this.validators.set(packetName, validator);
+        return this;
+    }
+
+    async process(ctx, next) {
+        const packetName = ctx.packet?.constructor?.packetName;
+        const validator = this.validators.get(packetName);
+
+        if (validator) {
+            try {
+                const result = await validator(ctx.packet, ctx);
+                
+                if (result === false) {
+                    ctx.cancel();
+                    ctx.addError({ type: 'validation', message: 'Validation failed' });
+                    return;
+                }
+                
+                if (typeof result === 'object' && result.valid === false) {
+                    ctx.cancel();
+                    ctx.addError({ type: 'validation', message: result.message || 'Validation failed' });
+                    return;
+                }
+            } catch (e) {
+                ctx.addError({ type: 'validation', message: e.message });
+                if (this.strict) {
+                    ctx.cancel();
+                    return;
+                }
+            }
+        }
+
+        await next();
+    }
+}
+
+export class TransformMiddleware extends Middleware {
+    constructor(options = {}) {
+        super('transform', options);
+        this.transformers = new Map();
+    }
+
+    addTransformer(packetName, transformer) {
+        this.transformers.set(packetName, transformer);
+        return this;
+    }
+
+    async process(ctx, next) {
+        const packetName = ctx.packet?.constructor?.packetName;
+        const transformer = this.transformers.get(packetName);
+
+        if (transformer) {
+            try {
+                const result = await transformer(ctx.packet, ctx);
+                if (result !== undefined && result !== ctx.packet) {
+                    ctx.packet = result;
+                    ctx.markModified();
+                }
+            } catch (e) {
+                ctx.addError({ type: 'transform', message: e.message });
+            }
+        }
+
+        await next();
+    }
+}
+
+export class CacheMiddleware extends Middleware {
+    constructor(options = {}) {
+        super('cache', options);
+        this.cache = new Map();
+        this.ttl = options.ttl || 60000;
+        this.maxSize = options.maxSize || 1000;
+        this.keyGenerator = options.keyGenerator || ((ctx) => ctx.packet?.constructor?.packetName);
+    }
+
+    async process(ctx, next) {
+        const key = this.keyGenerator(ctx);
+        const cached = this.cache.get(key);
+
+        if (cached && Date.now() - cached.timestamp < this.ttl) {
+            ctx.setMetadata('cached', true);
+            ctx.setMetadata('cachedData', cached.data);
+            return;
+        }
+
+        await next();
+
+        if (!ctx.cancelled) {
+            if (this.cache.size >= this.maxSize) {
+                const oldestKey = this.cache.keys().next().value;
+                this.cache.delete(oldestKey);
+            }
+            
+            this.cache.set(key, {
+                timestamp: Date.now(),
+                data: ctx.packet
+            });
+        }
+    }
+
+    clear() {
+        this.cache.clear();
+        return this;
+    }
+
+    getStats() {
+        return {
+            size: this.cache.size,
+            maxSize: this.maxSize,
+            ttl: this.ttl
+        };
+    }
+}
+
+export class MetricsMiddleware extends Middleware {
+    constructor(options = {}) {
+        super('metrics', options);
+        this.metrics = {
+            processed: 0,
+            cancelled: 0,
+            errors: 0,
+            totalTime: 0,
+            byPacketType: new Map()
+        };
+    }
+
+    async process(ctx, next) {
+        const start = Date.now();
+        const packetName = ctx.packet?.constructor?.packetName || 'unknown';
+
+        try {
+            await next();
+        } finally {
+            const duration = Date.now() - start;
+            
+            this.metrics.processed++;
+            this.metrics.totalTime += duration;
+            
+            if (ctx.cancelled) this.metrics.cancelled++;
+            if (ctx.errors.length > 0) this.metrics.errors++;
+
+            const typeMetrics = this.metrics.byPacketType.get(packetName) || { count: 0, time: 0 };
+            typeMetrics.count++;
+            typeMetrics.time += duration;
+            this.metrics.byPacketType.set(packetName, typeMetrics);
+        }
+    }
+
+    getMetrics() {
+        return {
+            ...this.metrics,
+            byPacketType: Object.fromEntries(this.metrics.byPacketType),
+            avgProcessingTime: this.metrics.processed > 0 ? 
+                (this.metrics.totalTime / this.metrics.processed).toFixed(2) : 0
+        };
+    }
+
+    reset() {
+        this.metrics = {
+            processed: 0,
+            cancelled: 0,
+            errors: 0,
+            totalTime: 0,
+            byPacketType: new Map()
+        };
+        return this;
+    }
+}
+
+export class MiddlewarePipeline extends EventEmitter {
+    constructor() {
+        super();
+        this.middlewares = [];
+    }
+
+    use(middleware) {
+        if (typeof middleware === 'function') {
+            const fn = middleware;
+            middleware = new Middleware('anonymous');
+            middleware.process = async (ctx, next) => {
+                await fn(ctx, next);
+            };
+        }
+
+        this.middlewares.push(middleware);
+        this.middlewares.sort((a, b) => b.priority - a.priority);
+        
+        this.emit('add', middleware);
+        return this;
+    }
+
+    remove(name) {
+        const index = this.middlewares.findIndex(m => m.name === name);
+        if (index !== -1) {
+            const removed = this.middlewares.splice(index, 1)[0];
+            this.emit('remove', removed);
+        }
+        return this;
+    }
+
+    get(name) {
+        return this.middlewares.find(m => m.name === name);
+    }
+
+    async execute(ctx) {
+        const chain = this.middlewares.filter(m => m.shouldProcess(ctx));
+        
+        const executeMiddleware = async (index) => {
+            if (index >= chain.length || ctx.cancelled) {
+                return;
+            }
+
+            const middleware = chain[index];
+            
+            try {
+                await middleware.process(ctx, () => executeMiddleware(index + 1));
+            } catch (e) {
+                ctx.addError({ middleware: middleware.name, message: e.message });
+                this.emit('error', { middleware: middleware.name, error: e, ctx });
+            }
+        };
+
+        this.emit('beforeExecute', ctx);
+        await executeMiddleware(0);
+        this.emit('afterExecute', ctx);
+
+        return ctx;
+    }
+
+    async process(options) {
+        const ctx = new MiddlewareContext(options);
+        return this.execute(ctx);
+    }
+
+    list() {
+        return this.middlewares.map(m => ({
+            name: m.name,
+            enabled: m.enabled,
+            priority: m.priority
+        }));
+    }
+}
+
+export default {
+    MiddlewarePipeline,
+    MiddlewareContext,
+    Middleware,
+    LoggingMiddleware,
+    RateLimitMiddleware,
+    ValidationMiddleware,
+    TransformMiddleware,
+    CacheMiddleware,
+    MetricsMiddleware
+};