@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/mail/routing/classes.email.router.js

@@ -0,0 +1,491 @@
+import * as plugins from '../../plugins.js';
+import { EventEmitter } from 'node:events';
+/**
+ * Email router that evaluates routes and determines actions
+ */
+export class EmailRouter extends EventEmitter {
+    /**
+     * Create a new email router
+     * @param routes Array of email routes
+     * @param options Router options
+     */
+    constructor(routes, options) {
+        super();
+        this.patternCache = new Map();
+        this.routes = this.sortRoutesByPriority(routes);
+        this.storageManager = options?.storageManager;
+        this.persistChanges = options?.persistChanges ?? !!this.storageManager;
+        // If storage manager is provided, try to load persisted routes
+        if (this.storageManager) {
+            this.loadRoutes({ merge: true }).catch(error => {
+                console.error(`Failed to load persisted routes: ${error.message}`);
+            });
+        }
+    }
+    /**
+     * Sort routes by priority (higher priority first)
+     * @param routes Routes to sort
+     * @returns Sorted routes
+     */
+    sortRoutesByPriority(routes) {
+        return [...routes].sort((a, b) => {
+            const priorityA = a.priority ?? 0;
+            const priorityB = b.priority ?? 0;
+            return priorityB - priorityA; // Higher priority first
+        });
+    }
+    /**
+     * Get all configured routes
+     * @returns Array of routes
+     */
+    getRoutes() {
+        return [...this.routes];
+    }
+    /**
+     * Update routes
+     * @param routes New routes
+     * @param persist Whether to persist changes (defaults to persistChanges setting)
+     */
+    async updateRoutes(routes, persist) {
+        this.routes = this.sortRoutesByPriority(routes);
+        this.clearCache();
+        this.emit('routesUpdated', this.routes);
+        // Persist if requested or if persistChanges is enabled
+        if (persist ?? this.persistChanges) {
+            await this.saveRoutes();
+        }
+    }
+    /**
+     * Set routes (alias for updateRoutes)
+     * @param routes New routes
+     * @param persist Whether to persist changes
+     */
+    async setRoutes(routes, persist) {
+        await this.updateRoutes(routes, persist);
+    }
+    /**
+     * Clear the pattern cache
+     */
+    clearCache() {
+        this.patternCache.clear();
+        this.emit('cacheCleared');
+    }
+    /**
+     * Evaluate routes and find the first match
+     * @param context Email context
+     * @returns Matched route or null
+     */
+    async evaluateRoutes(context) {
+        for (const route of this.routes) {
+            if (await this.matchesRoute(route, context)) {
+                this.emit('routeMatched', route, context);
+                return route;
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if a route matches the context
+     * @param route Route to check
+     * @param context Email context
+     * @returns True if route matches
+     */
+    async matchesRoute(route, context) {
+        const match = route.match;
+        // Check recipients
+        if (match.recipients && !this.matchesRecipients(context.email, match.recipients)) {
+            return false;
+        }
+        // Check senders
+        if (match.senders && !this.matchesSenders(context.email, match.senders)) {
+            return false;
+        }
+        // Check client IP
+        if (match.clientIp && !this.matchesClientIp(context, match.clientIp)) {
+            return false;
+        }
+        // Check authentication
+        if (match.authenticated !== undefined &&
+            context.session.authenticated !== match.authenticated) {
+            return false;
+        }
+        // Check headers
+        if (match.headers && !this.matchesHeaders(context.email, match.headers)) {
+            return false;
+        }
+        // Check size
+        if (match.sizeRange && !this.matchesSize(context.email, match.sizeRange)) {
+            return false;
+        }
+        // Check subject
+        if (match.subject && !this.matchesSubject(context.email, match.subject)) {
+            return false;
+        }
+        // Check attachments
+        if (match.hasAttachments !== undefined &&
+            (context.email.attachments.length > 0) !== match.hasAttachments) {
+            return false;
+        }
+        // All checks passed
+        return true;
+    }
+    /**
+     * Check if email recipients match patterns
+     * @param email Email to check
+     * @param patterns Patterns to match
+     * @returns True if any recipient matches
+     */
+    matchesRecipients(email, patterns) {
+        const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+        const recipients = email.getAllRecipients();
+        for (const recipient of recipients) {
+            for (const pattern of patternArray) {
+                if (this.matchesPattern(recipient, pattern)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if email sender matches patterns
+     * @param email Email to check
+     * @param patterns Patterns to match
+     * @returns True if sender matches
+     */
+    matchesSenders(email, patterns) {
+        const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+        const sender = email.from;
+        for (const pattern of patternArray) {
+            if (this.matchesPattern(sender, pattern)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if client IP matches patterns
+     * @param context Email context
+     * @param patterns IP patterns to match
+     * @returns True if IP matches
+     */
+    matchesClientIp(context, patterns) {
+        const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+        const clientIp = context.session.remoteAddress;
+        if (!clientIp) {
+            return false;
+        }
+        for (const pattern of patternArray) {
+            // Check for CIDR notation
+            if (pattern.includes('/')) {
+                if (this.ipInCidr(clientIp, pattern)) {
+                    return true;
+                }
+            }
+            else {
+                // Exact match
+                if (clientIp === pattern) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if email headers match patterns
+     * @param email Email to check
+     * @param headerPatterns Header patterns to match
+     * @returns True if headers match
+     */
+    matchesHeaders(email, headerPatterns) {
+        for (const [header, pattern] of Object.entries(headerPatterns)) {
+            const value = email.headers[header];
+            if (!value) {
+                return false;
+            }
+            if (pattern instanceof RegExp) {
+                if (!pattern.test(value)) {
+                    return false;
+                }
+            }
+            else {
+                if (value !== pattern) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * Check if email size matches range
+     * @param email Email to check
+     * @param sizeRange Size range to match
+     * @returns True if size is in range
+     */
+    matchesSize(email, sizeRange) {
+        // Calculate approximate email size
+        const size = this.calculateEmailSize(email);
+        if (sizeRange.min !== undefined && size < sizeRange.min) {
+            return false;
+        }
+        if (sizeRange.max !== undefined && size > sizeRange.max) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check if email subject matches pattern
+     * @param email Email to check
+     * @param pattern Pattern to match
+     * @returns True if subject matches
+     */
+    matchesSubject(email, pattern) {
+        const subject = email.subject || '';
+        if (pattern instanceof RegExp) {
+            return pattern.test(subject);
+        }
+        else {
+            return this.matchesPattern(subject, pattern);
+        }
+    }
+    /**
+     * Check if a string matches a glob pattern
+     * @param str String to check
+     * @param pattern Glob pattern
+     * @returns True if matches
+     */
+    matchesPattern(str, pattern) {
+        // Check cache
+        const cacheKey = `${str}:${pattern}`;
+        const cached = this.patternCache.get(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+        // Convert glob to regex
+        const regexPattern = this.globToRegExp(pattern);
+        const matches = regexPattern.test(str);
+        // Cache result
+        this.patternCache.set(cacheKey, matches);
+        return matches;
+    }
+    /**
+     * Convert glob pattern to RegExp
+     * @param pattern Glob pattern
+     * @returns Regular expression
+     */
+    globToRegExp(pattern) {
+        // Escape special regex characters except * and ?
+        let regexString = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+        return new RegExp(`^${regexString}$`, 'i');
+    }
+    /**
+     * Check if IP is in CIDR range
+     * @param ip IP address to check
+     * @param cidr CIDR notation (e.g., '192.168.0.0/16')
+     * @returns True if IP is in range
+     */
+    ipInCidr(ip, cidr) {
+        try {
+            const [range, bits] = cidr.split('/');
+            const mask = parseInt(bits, 10);
+            // Convert IPs to numbers
+            const ipNum = this.ipToNumber(ip);
+            const rangeNum = this.ipToNumber(range);
+            // Calculate mask
+            const maskBits = 0xffffffff << (32 - mask);
+            // Check if in range
+            return (ipNum & maskBits) === (rangeNum & maskBits);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Convert IP address to number
+     * @param ip IP address
+     * @returns Number representation
+     */
+    ipToNumber(ip) {
+        const parts = ip.split('.');
+        return parts.reduce((acc, part, index) => {
+            return acc + (parseInt(part, 10) << (8 * (3 - index)));
+        }, 0);
+    }
+    /**
+     * Calculate approximate email size in bytes
+     * @param email Email to measure
+     * @returns Size in bytes
+     */
+    calculateEmailSize(email) {
+        let size = 0;
+        // Headers
+        for (const [key, value] of Object.entries(email.headers)) {
+            size += key.length + value.length + 4; // ": " + "\r\n"
+        }
+        // Body
+        size += (email.text || '').length;
+        size += (email.html || '').length;
+        // Attachments
+        for (const attachment of email.attachments) {
+            if (attachment.content) {
+                size += attachment.content.length;
+            }
+        }
+        return size;
+    }
+    /**
+     * Save current routes to storage
+     */
+    async saveRoutes() {
+        if (!this.storageManager) {
+            this.emit('persistenceWarning', 'Cannot save routes: StorageManager not configured');
+            return;
+        }
+        try {
+            // Validate all routes before saving
+            for (const route of this.routes) {
+                if (!route.name || !route.match || !route.action) {
+                    throw new Error(`Invalid route: ${JSON.stringify(route)}`);
+                }
+            }
+            const routesData = JSON.stringify(this.routes, null, 2);
+            await this.storageManager.set('/email/routes/config.json', routesData);
+            this.emit('routesPersisted', this.routes.length);
+        }
+        catch (error) {
+            console.error(`Failed to save routes: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Load routes from storage
+     * @param options Load options
+     */
+    async loadRoutes(options) {
+        if (!this.storageManager) {
+            this.emit('persistenceWarning', 'Cannot load routes: StorageManager not configured');
+            return [];
+        }
+        try {
+            const routesData = await this.storageManager.get('/email/routes/config.json');
+            if (!routesData) {
+                return [];
+            }
+            const loadedRoutes = JSON.parse(routesData);
+            // Validate loaded routes
+            for (const route of loadedRoutes) {
+                if (!route.name || !route.match || !route.action) {
+                    console.warn(`Skipping invalid route: ${JSON.stringify(route)}`);
+                    continue;
+                }
+            }
+            if (options?.replace) {
+                // Replace all routes
+                this.routes = this.sortRoutesByPriority(loadedRoutes);
+            }
+            else if (options?.merge) {
+                // Merge with existing routes (loaded routes take precedence)
+                const routeMap = new Map();
+                // Add existing routes
+                for (const route of this.routes) {
+                    routeMap.set(route.name, route);
+                }
+                // Override with loaded routes
+                for (const route of loadedRoutes) {
+                    routeMap.set(route.name, route);
+                }
+                this.routes = this.sortRoutesByPriority(Array.from(routeMap.values()));
+            }
+            this.clearCache();
+            this.emit('routesLoaded', loadedRoutes.length);
+            return loadedRoutes;
+        }
+        catch (error) {
+            console.error(`Failed to load routes: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Add a route
+     * @param route Route to add
+     * @param persist Whether to persist changes
+     */
+    async addRoute(route, persist) {
+        // Validate route
+        if (!route.name || !route.match || !route.action) {
+            throw new Error('Invalid route: missing required fields');
+        }
+        // Check if route already exists
+        const existingIndex = this.routes.findIndex(r => r.name === route.name);
+        if (existingIndex >= 0) {
+            throw new Error(`Route '${route.name}' already exists`);
+        }
+        // Add route
+        this.routes.push(route);
+        this.routes = this.sortRoutesByPriority(this.routes);
+        this.clearCache();
+        this.emit('routeAdded', route);
+        this.emit('routesUpdated', this.routes);
+        // Persist if requested
+        if (persist ?? this.persistChanges) {
+            await this.saveRoutes();
+        }
+    }
+    /**
+     * Remove a route by name
+     * @param name Route name
+     * @param persist Whether to persist changes
+     */
+    async removeRoute(name, persist) {
+        const index = this.routes.findIndex(r => r.name === name);
+        if (index < 0) {
+            throw new Error(`Route '${name}' not found`);
+        }
+        const removedRoute = this.routes.splice(index, 1)[0];
+        this.clearCache();
+        this.emit('routeRemoved', removedRoute);
+        this.emit('routesUpdated', this.routes);
+        // Persist if requested
+        if (persist ?? this.persistChanges) {
+            await this.saveRoutes();
+        }
+    }
+    /**
+     * Update a route
+     * @param name Route name
+     * @param route Updated route data
+     * @param persist Whether to persist changes
+     */
+    async updateRoute(name, route, persist) {
+        // Validate route
+        if (!route.name || !route.match || !route.action) {
+            throw new Error('Invalid route: missing required fields');
+        }
+        const index = this.routes.findIndex(r => r.name === name);
+        if (index < 0) {
+            throw new Error(`Route '${name}' not found`);
+        }
+        // Update route
+        this.routes[index] = route;
+        this.routes = this.sortRoutesByPriority(this.routes);
+        this.clearCache();
+        this.emit('routeUpdated', route);
+        this.emit('routesUpdated', this.routes);
+        // Persist if requested
+        if (persist ?? this.persistChanges) {
+            await this.saveRoutes();
+        }
+    }
+    /**
+     * Get a route by name
+     * @param name Route name
+     * @returns Route or undefined
+     */
+    getRoute(name) {
+        return this.routes.find(r => r.name === name);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.email.router.js","sourceRoot":"","sources":["../../../../ts/mail/routing/classes.email.router.ts"],"names":[],"mappings":"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"}