@serve.zone/dcrouter 5.0.2 → 5.0.3

package/dist_ts/storage/classes.storagemanager.js

@@ -0,0 +1,344 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logger.js';
+// Promisify filesystem operations
+const readFile = plugins.util.promisify(plugins.fs.readFile);
+const writeFile = plugins.util.promisify(plugins.fs.writeFile);
+const unlink = plugins.util.promisify(plugins.fs.unlink);
+const rename = plugins.util.promisify(plugins.fs.rename);
+const readdir = plugins.util.promisify(plugins.fs.readdir);
+/**
+ * Central storage manager for DcRouter
+ * Provides unified key-value storage with multiple backend support
+ */
+export class StorageManager {
+    backend;
+    memoryStore = new Map();
+    config;
+    fsBasePath;
+    constructor(config) {
+        this.config = config || {};
+        // Check if both fsPath and custom functions are provided
+        if (config?.fsPath && (config?.readFunction || config?.writeFunction)) {
+            console.warn('⚠️  WARNING: Both fsPath and custom read/write functions are configured.\n' +
+                '   Using custom read/write functions. fsPath will be ignored.');
+        }
+        // Determine backend based on configuration
+        if (config?.readFunction && config?.writeFunction) {
+            this.backend = 'custom';
+        }
+        else if (config?.fsPath) {
+            // Set up internal read/write functions for filesystem
+            this.backend = 'custom'; // Use custom backend with internal functions
+            this.fsBasePath = plugins.path.resolve(config.fsPath);
+            this.ensureDirectory(this.fsBasePath);
+            // Set up internal filesystem read/write functions
+            this.config.readFunction = async (key) => {
+                return this.fsRead(key);
+            };
+            this.config.writeFunction = async (key, value) => {
+                await this.fsWrite(key, value);
+            };
+        }
+        else {
+            this.backend = 'memory';
+            this.showMemoryWarning();
+        }
+        logger.log('info', `StorageManager initialized with ${this.backend} backend`);
+    }
+    /**
+     * Show warning when using memory backend
+     */
+    showMemoryWarning() {
+        console.warn('⚠️  WARNING: StorageManager is using in-memory storage.\n' +
+            '   Data will be lost when the process restarts.\n' +
+            '   Configure storage.fsPath or storage functions for persistence.');
+    }
+    /**
+     * Ensure directory exists for filesystem backend
+     */
+    async ensureDirectory(dirPath) {
+        try {
+            await plugins.fsUtils.ensureDir(dirPath);
+        }
+        catch (error) {
+            logger.log('error', `Failed to create storage directory: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Validate and sanitize storage key
+     */
+    validateKey(key) {
+        if (!key || typeof key !== 'string') {
+            throw new Error('Storage key must be a non-empty string');
+        }
+        // Ensure key starts with /
+        if (!key.startsWith('/')) {
+            key = '/' + key;
+        }
+        // Remove any dangerous path elements
+        key = key.replace(/\.\./g, '').replace(/\/+/g, '/');
+        return key;
+    }
+    /**
+     * Convert key to filesystem path
+     */
+    keyToPath(key) {
+        if (!this.fsBasePath) {
+            throw new Error('Filesystem base path not configured');
+        }
+        // Remove leading slash and convert to path
+        const relativePath = key.substring(1);
+        return plugins.path.join(this.fsBasePath, relativePath);
+    }
+    /**
+     * Internal filesystem read function
+     */
+    async fsRead(key) {
+        const filePath = this.keyToPath(key);
+        try {
+            const content = await readFile(filePath, 'utf8');
+            return content;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Internal filesystem write function
+     */
+    async fsWrite(key, value) {
+        const filePath = this.keyToPath(key);
+        const dir = plugins.path.dirname(filePath);
+        // Ensure directory exists
+        await plugins.fsUtils.ensureDir(dir);
+        // Write atomically with temp file
+        const tempPath = `${filePath}.tmp`;
+        await writeFile(tempPath, value, 'utf8');
+        await rename(tempPath, filePath);
+    }
+    /**
+     * Get value by key
+     */
+    async get(key) {
+        key = this.validateKey(key);
+        try {
+            switch (this.backend) {
+                case 'custom': {
+                    if (!this.config.readFunction) {
+                        throw new Error('Read function not configured');
+                    }
+                    try {
+                        return await this.config.readFunction(key);
+                    }
+                    catch (error) {
+                        // Assume null if read fails (key doesn't exist)
+                        return null;
+                    }
+                }
+                case 'memory': {
+                    return this.memoryStore.get(key) || null;
+                }
+                default:
+                    throw new Error(`Unknown backend: ${this.backend}`);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Storage get error for key ${key}: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Set value by key
+     */
+    async set(key, value) {
+        key = this.validateKey(key);
+        if (typeof value !== 'string') {
+            throw new Error('Storage value must be a string');
+        }
+        try {
+            switch (this.backend) {
+                case 'filesystem': {
+                    const filePath = this.keyToPath(key);
+                    const dirPath = plugins.path.dirname(filePath);
+                    // Ensure directory exists
+                    await plugins.fsUtils.ensureDir(dirPath);
+                    // Write atomically
+                    const tempPath = filePath + '.tmp';
+                    await writeFile(tempPath, value, 'utf8');
+                    await rename(tempPath, filePath);
+                    break;
+                }
+                case 'custom': {
+                    if (!this.config.writeFunction) {
+                        throw new Error('Write function not configured');
+                    }
+                    await this.config.writeFunction(key, value);
+                    break;
+                }
+                case 'memory': {
+                    this.memoryStore.set(key, value);
+                    break;
+                }
+                default:
+                    throw new Error(`Unknown backend: ${this.backend}`);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Storage set error for key ${key}: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Delete value by key
+     */
+    async delete(key) {
+        key = this.validateKey(key);
+        try {
+            switch (this.backend) {
+                case 'filesystem': {
+                    const filePath = this.keyToPath(key);
+                    try {
+                        await unlink(filePath);
+                    }
+                    catch (error) {
+                        if (error.code !== 'ENOENT') {
+                            throw error;
+                        }
+                    }
+                    break;
+                }
+                case 'custom': {
+                    // Try to delete by setting empty value
+                    if (this.config.writeFunction) {
+                        await this.config.writeFunction(key, '');
+                    }
+                    break;
+                }
+                case 'memory': {
+                    this.memoryStore.delete(key);
+                    break;
+                }
+                default:
+                    throw new Error(`Unknown backend: ${this.backend}`);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Storage delete error for key ${key}: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * List keys by prefix
+     */
+    async list(prefix) {
+        prefix = prefix ? this.validateKey(prefix) : '/';
+        try {
+            switch (this.backend) {
+                case 'custom': {
+                    // If we have fsBasePath, this is actually filesystem backend
+                    if (this.fsBasePath) {
+                        const basePath = this.keyToPath(prefix);
+                        const keys = [];
+                        const walkDir = async (dir, baseDir) => {
+                            try {
+                                const entries = await readdir(dir, { withFileTypes: true });
+                                for (const entry of entries) {
+                                    const fullPath = plugins.path.join(dir, entry.name);
+                                    if (entry.isDirectory()) {
+                                        await walkDir(fullPath, baseDir);
+                                    }
+                                    else if (entry.isFile()) {
+                                        // Convert path back to key
+                                        const relativePath = plugins.path.relative(this.fsBasePath, fullPath);
+                                        const key = '/' + relativePath.replace(/\\/g, '/');
+                                        if (key.startsWith(prefix)) {
+                                            keys.push(key);
+                                        }
+                                    }
+                                }
+                            }
+                            catch (error) {
+                                if (error.code !== 'ENOENT') {
+                                    throw error;
+                                }
+                            }
+                        };
+                        await walkDir(basePath, basePath);
+                        return keys.sort();
+                    }
+                    else {
+                        // True custom backends need to implement their own listing
+                        logger.log('warn', 'List operation not supported for custom backend');
+                        return [];
+                    }
+                }
+                case 'memory': {
+                    const keys = [];
+                    for (const key of this.memoryStore.keys()) {
+                        if (key.startsWith(prefix)) {
+                            keys.push(key);
+                        }
+                    }
+                    return keys.sort();
+                }
+                default:
+                    throw new Error(`Unknown backend: ${this.backend}`);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Storage list error for prefix ${prefix}: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Check if key exists
+     */
+    async exists(key) {
+        key = this.validateKey(key);
+        try {
+            const value = await this.get(key);
+            return value !== null;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Get storage backend type
+     */
+    getBackend() {
+        // If we're using custom backend with fsBasePath, report it as filesystem
+        if (this.backend === 'custom' && this.fsBasePath) {
+            return 'filesystem';
+        }
+        return this.backend;
+    }
+    /**
+     * JSON helper: Get and parse JSON value
+     */
+    async getJSON(key) {
+        const value = await this.get(key);
+        if (value === null) {
+            return null;
+        }
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            logger.log('error', `Failed to parse JSON for key ${key}: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * JSON helper: Set value as JSON
+     */
+    async setJSON(key, value) {
+        const jsonString = JSON.stringify(value, null, 2);
+        await this.set(key, jsonString);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.storagemanager.js","sourceRoot":"","sources":["../../../ts/storage/classes.storagemanager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,kCAAkC;AAClC,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;AAC7D,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;AAC/D,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;AACzD,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;AACzD,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC;AAmB3D;;;GAGG;AACH,MAAM,OAAO,cAAc;IACjB,OAAO,CAAiB;IACxB,WAAW,GAAwB,IAAI,GAAG,EAAE,CAAC;IAC7C,MAAM,CAAiB;IACvB,UAAU,CAAU;IAE5B,YAAY,MAAuB;QACjC,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QAE3B,yDAAyD;QACzD,IAAI,MAAM,EAAE,MAAM,IAAI,CAAC,MAAM,EAAE,YAAY,IAAI,MAAM,EAAE,aAAa,CAAC,EAAE,CAAC;YACtE,OAAO,CAAC,IAAI,CACV,4EAA4E;gBAC5E,+DAA+D,CAChE,CAAC;QACJ,CAAC;QAED,2CAA2C;QAC3C,IAAI,MAAM,EAAE,YAAY,IAAI,MAAM,EAAE,aAAa,EAAE,CAAC;YAClD,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC;QAC1B,CAAC;aAAM,IAAI,MAAM,EAAE,MAAM,EAAE,CAAC;YAC1B,sDAAsD;YACtD,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC,CAAC,6CAA6C;YACtE,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YACtD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAEtC,kDAAkD;YAClD,IAAI,CAAC,MAAM,CAAC,YAAY,GAAG,KAAK,EAAE,GAAW,EAAE,EAAE;gBAC/C,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAC1B,CAAC,CAAC;YACF,IAAI,CAAC,MAAM,CAAC,aAAa,GAAG,KAAK,EAAE,GAAW,EAAE,KAAa,EAAE,EAAE;gBAC/D,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YACjC,CAAC,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC;YACxB,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC3B,CAAC;QAED,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,mCAAmC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;IAChF,CAAC;IAED;;OAEG;IACK,iBAAiB;QACvB,OAAO,CAAC,IAAI,CACV,2DAA2D;YAC3D,mDAAmD;YACnD,mEAAmE,CACpE,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,eAAe,CAAC,OAAe;QAC3C,IAAI,CAAC;YACH,MAAM,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QAC3C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,uCAAuC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAC5E,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACK,WAAW,CAAC,GAAW;QAC7B,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;YACpC,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;QAC5D,CAAC;QAED,2BAA2B;QAC3B,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YACzB,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;QAClB,CAAC;QAED,qCAAqC;QACrC,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAEpD,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;OAEG;IACK,SAAS,CAAC,GAAW;QAC3B,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACzD,CAAC;QAED,2CAA2C;QAC3C,MAAM,YAAY,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;QACtC,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;IAC1D,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,MAAM,CAAC,GAAW;QAC9B,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QACrC,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YACjD,OAAO,OAAO,CAAC;QACjB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC5B,OAAO,IAAI,CAAC;YACd,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,OAAO,CAAC,GAAW,EAAE,KAAa;QAC9C,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QACrC,MAAM,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAE3C,0BAA0B;QAC1B,MAAM,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAErC,kCAAkC;QAClC,MAAM,QAAQ,GAAG,GAAG,QAAQ,MAAM,CAAC;QACnC,MAAM,SAAS,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;QACzC,MAAM,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACnC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,GAAG,CAAC,GAAW;QACnB,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QAE5B,IAAI,CAAC;YACH,QAAQ,IAAI,CAAC,OAAO,EAAE,CAAC;gBAErB,KAAK,QAAQ,CAAC,CAAC,CAAC;oBACd,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;wBAC9B,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;oBAClD,CAAC;oBACD,IAAI,CAAC;wBACH,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;oBAC7C,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,gDAAgD;wBAChD,OAAO,IAAI,CAAC;oBACd,CAAC;gBACH,CAAC;gBAED,KAAK,QAAQ,CAAC,CAAC,CAAC;oBACd,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC;gBAC3C,CAAC;gBAED;oBACE,MAAM,IAAI,KAAK,CAAC,oBAAoB,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;YACxD,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,6BAA6B,GAAG,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAC1E,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,GAAG,CAAC,GAAW,EAAE,KAAa;QAClC,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QAE5B,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;QACpD,CAAC;QAED,IAAI,CAAC;YACH,QAAQ,IAAI,CAAC,OAAO,EAAE,CAAC;gBACrB,KAAK,YAAY,CAAC,CAAC,CAAC;oBAClB,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;oBACrC,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;oBAE/C,0BAA0B;oBAC1B,MAAM,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;oBAEzC,mBAAmB;oBACnB,MAAM,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;oBACnC,MAAM,SAAS,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;oBACzC,MAAM,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;oBACjC,MAAM;gBACR,CAAC;gBAED,KAAK,QAAQ,CAAC,CAAC,CAAC;oBACd,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;wBAC/B,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;oBACnD,CAAC;oBACD,MAAM,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;oBAC5C,MAAM;gBACR,CAAC;gBAED,KAAK,QAAQ,CAAC,CAAC,CAAC;oBACd,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;oBACjC,MAAM;gBACR,CAAC;gBAED;oBACE,MAAM,IAAI,KAAK,CAAC,oBAAoB,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;YACxD,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,6BAA6B,GAAG,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAC1E,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,GAAW;QACtB,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QAE5B,IAAI,CAAC;YACH,QAAQ,IAAI,CAAC,OAAO,EAAE,CAAC;gBACrB,KAAK,YAAY,CAAC,CAAC,CAAC;oBAClB,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;oBACrC,IAAI,CAAC;wBACH,MAAM,MAAM,CAAC,QAAQ,CAAC,CAAC;oBACzB,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;4BAC5B,MAAM,KAAK,CAAC;wBACd,CAAC;oBACH,CAAC;oBACD,MAAM;gBACR,CAAC;gBAED,KAAK,QAAQ,CAAC,CAAC,CAAC;oBACd,uCAAuC;oBACvC,IAAI,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;wBAC9B,MAAM,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;oBAC3C,CAAC;oBACD,MAAM;gBACR,CAAC;gBAED,KAAK,QAAQ,CAAC,CAAC,CAAC;oBACd,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;oBAC7B,MAAM;gBACR,CAAC;gBAED;oBACE,MAAM,IAAI,KAAK,CAAC,oBAAoB,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;YACxD,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,gCAAgC,GAAG,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAC7E,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,IAAI,CAAC,MAAe;QACxB,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;QAEjD,IAAI,CAAC;YACH,QAAQ,IAAI,CAAC,OAAO,EAAE,CAAC;gBACrB,KAAK,QAAQ,CAAC,CAAC,CAAC;oBACd,6DAA6D;oBAC7D,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;wBACpB,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;wBACxC,MAAM,IAAI,GAAa,EAAE,CAAC;wBAE1B,MAAM,OAAO,GAAG,KAAK,EAAE,GAAW,EAAE,OAAe,EAAiB,EAAE;4BACpE,IAAI,CAAC;gCACH,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;gCAE5D,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;oCAC5B,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;oCAEpD,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;wCACxB,MAAM,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;oCACnC,CAAC;yCAAM,IAAI,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;wCAC1B,2BAA2B;wCAC3B,MAAM,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAW,EAAE,QAAQ,CAAC,CAAC;wCACvE,MAAM,GAAG,GAAG,GAAG,GAAG,YAAY,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;wCACnD,IAAI,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;4CAC3B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;wCACjB,CAAC;oCACH,CAAC;gCACH,CAAC;4BACH,CAAC;4BAAC,OAAO,KAAK,EAAE,CAAC;gCACf,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;oCAC5B,MAAM,KAAK,CAAC;gCACd,CAAC;4BACH,CAAC;wBACH,CAAC,CAAC;wBAEF,MAAM,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;wBAClC,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC;oBACrB,CAAC;yBAAM,CAAC;wBACN,2DAA2D;wBAC3D,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,iDAAiD,CAAC,CAAC;wBACtE,OAAO,EAAE,CAAC;oBACZ,CAAC;gBACH,CAAC;gBAED,KAAK,QAAQ,CAAC,CAAC,CAAC;oBACd,MAAM,IAAI,GAAa,EAAE,CAAC;oBAC1B,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC;wBAC1C,IAAI,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;4BAC3B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;wBACjB,CAAC;oBACH,CAAC;oBACD,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC;gBACrB,CAAC;gBAED;oBACE,MAAM,IAAI,KAAK,CAAC,oBAAoB,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;YACxD,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,iCAAiC,MAAM,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACjF,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,GAAW;QACtB,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QAE5B,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAClC,OAAO,KAAK,KAAK,IAAI,CAAC;QACxB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;OAEG;IACH,UAAU;QACR,yEAAyE;QACzE,IAAI,IAAI,CAAC,OAAO,KAAK,QAAQ,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACjD,OAAO,YAA8B,CAAC;QACxC,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO,CAAU,GAAW;QAChC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,CAAC;YACH,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAM,CAAC;QAChC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,gCAAgC,GAAG,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAC7E,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO,CAAC,GAAW,EAAE,KAAU;QACnC,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QAClD,MAAM,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;IAClC,CAAC;CACF"}

package/dist_ts/storage/index.d.ts

@@ -0,0 +1 @@
+export * from './classes.storagemanager.js';

package/dist_ts/storage/index.js

@@ -0,0 +1,3 @@
+// Storage module exports
+export * from './classes.storagemanager.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9zdG9yYWdlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHlCQUF5QjtBQUN6QixjQUFjLDZCQUE2QixDQUFDIn0=

package/dist_ts_interfaces/data/auth.d.ts

@@ -0,0 +1,8 @@
+export interface IIdentity {
+    jwt: string;
+    userId: string;
+    name: string;
+    expiresAt: number;
+    role?: string;
+    type?: string;
+}

package/dist_ts_interfaces/data/auth.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzX2ludGVyZmFjZXMvZGF0YS9hdXRoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist_ts_interfaces/data/index.d.ts

@@ -0,0 +1,2 @@
+export * from './auth.js';
+export * from './stats.js';

package/dist_ts_interfaces/data/index.js

@@ -0,0 +1,3 @@
+export * from './auth.js';
+export * from './stats.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c19pbnRlcmZhY2VzL2RhdGEvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxZQUFZLENBQUMifQ==

package/dist_ts_interfaces/data/stats.d.ts

@@ -0,0 +1,120 @@
+export interface IServerStats {
+    uptime: number;
+    startTime: number;
+    memoryUsage: {
+        heapUsed: number;
+        heapTotal: number;
+        external: number;
+        rss: number;
+        maxMemoryMB?: number;
+        actualUsageBytes?: number;
+        actualUsagePercentage?: number;
+    };
+    cpuUsage: {
+        user: number;
+        system: number;
+    };
+    activeConnections: number;
+    totalConnections: number;
+}
+export interface IEmailStats {
+    sent: number;
+    received: number;
+    bounced: number;
+    queued: number;
+    failed: number;
+    averageDeliveryTime: number;
+    deliveryRate: number;
+    bounceRate: number;
+}
+export interface IDnsStats {
+    totalQueries: number;
+    cacheHits: number;
+    cacheMisses: number;
+    cacheHitRate: number;
+    activeDomains: number;
+    averageResponseTime: number;
+    queryTypes: {
+        [key: string]: number;
+    };
+}
+export interface IRateLimitInfo {
+    domain: string;
+    currentRate: number;
+    limit: number;
+    remaining: number;
+    resetTime: number;
+    blocked: boolean;
+}
+export interface ISecurityMetrics {
+    blockedIPs: string[];
+    reputationScores: {
+        [domain: string]: number;
+    };
+    spamDetected: number;
+    malwareDetected: number;
+    phishingDetected: number;
+    authenticationFailures: number;
+    suspiciousActivities: number;
+}
+export interface ILogEntry {
+    timestamp: number;
+    level: 'debug' | 'info' | 'warn' | 'error';
+    category: 'smtp' | 'dns' | 'security' | 'system' | 'email';
+    message: string;
+    metadata?: any;
+}
+export interface IConnectionInfo {
+    id: string;
+    remoteAddress: string;
+    localAddress: string;
+    startTime: number;
+    protocol: 'smtp' | 'smtps' | 'http' | 'https';
+    state: 'connecting' | 'connected' | 'authenticated' | 'transmitting' | 'closing';
+    bytesReceived: number;
+    bytesSent: number;
+}
+export interface IQueueStatus {
+    name: string;
+    size: number;
+    processing: number;
+    failed: number;
+    retrying: number;
+    averageProcessingTime: number;
+}
+export interface IHealthStatus {
+    healthy: boolean;
+    uptime: number;
+    services: {
+        [service: string]: {
+            status: 'healthy' | 'degraded' | 'unhealthy';
+            message?: string;
+            lastCheck: number;
+        };
+    };
+    version?: string;
+}
+export interface INetworkMetrics {
+    totalBandwidth: {
+        in: number;
+        out: number;
+    };
+    activeConnections: number;
+    connectionDetails: IConnectionDetails[];
+    topEndpoints: Array<{
+        endpoint: string;
+        requests: number;
+        bandwidth: {
+            in: number;
+            out: number;
+        };
+    }>;
+}
+export interface IConnectionDetails {
+    remoteAddress: string;
+    protocol: 'http' | 'https' | 'smtp' | 'smtps';
+    state: 'connecting' | 'connected' | 'established' | 'closing';
+    startTime: number;
+    bytesIn: number;
+    bytesOut: number;
+}

package/dist_ts_interfaces/data/stats.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c19pbnRlcmZhY2VzL2RhdGEvc3RhdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/{ts_interfaces/index.ts → dist_ts_interfaces/index.d.ts}

@@ -1,9 +1,5 @@
 export * from './plugins.js';
-
-// Data types
 import * as data from './data/index.js';
 export { data };
-
-// Request interfaces
 import * as requests from './requests/index.js';
-export { requests };
+export { requests };

package/dist_ts_interfaces/index.js

@@ -0,0 +1,8 @@
+export * from './plugins.js';
+// Data types
+import * as data from './data/index.js';
+export { data };
+// Request interfaces
+import * as requests from './requests/index.js';
+export { requests };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19pbnRlcmZhY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBYyxDQUFDO0FBRTdCLGFBQWE7QUFDYixPQUFPLEtBQUssSUFBSSxNQUFNLGlCQUFpQixDQUFDO0FBQ3hDLE9BQU8sRUFBRSxJQUFJLEVBQUUsQ0FBQztBQUVoQixxQkFBcUI7QUFDckIsT0FBTyxLQUFLLFFBQVEsTUFBTSxxQkFBcUIsQ0FBQztBQUNoRCxPQUFPLEVBQUUsUUFBUSxFQUFFLENBQUMifQ==

package/{ts_interfaces/plugins.ts → dist_ts_interfaces/plugins.d.ts}

@@ -1,6 +1,2 @@
-// @apiglobal scope
 import * as typedrequestInterfaces from '@api.global/typedrequest-interfaces';
-
-export {
-  typedrequestInterfaces
-}
+export { typedrequestInterfaces };

package/dist_ts_interfaces/plugins.js

@@ -0,0 +1,4 @@
+// @apiglobal scope
+import * as typedrequestInterfaces from '@api.global/typedrequest-interfaces';
+export { typedrequestInterfaces };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2ludGVyZmFjZXMvcGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxtQkFBbUI7QUFDbkIsT0FBTyxLQUFLLHNCQUFzQixNQUFNLHFDQUFxQyxDQUFDO0FBRTlFLE9BQU8sRUFDTCxzQkFBc0IsRUFDdkIsQ0FBQSJ9

package/dist_ts_interfaces/requests/admin.d.ts

@@ -0,0 +1,31 @@
+import * as plugins from '../plugins.js';
+import * as authInterfaces from '../data/auth.js';
+export interface IReq_AdminLoginWithUsernameAndPassword extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_AdminLoginWithUsernameAndPassword> {
+    method: 'adminLoginWithUsernameAndPassword';
+    request: {
+        username: string;
+        password: string;
+    };
+    response: {
+        identity?: authInterfaces.IIdentity;
+    };
+}
+export interface IReq_AdminLogout extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_AdminLogout> {
+    method: 'adminLogout';
+    request: {
+        identity: authInterfaces.IIdentity;
+    };
+    response: {
+        success: boolean;
+    };
+}
+export interface IReq_VerifyIdentity extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_VerifyIdentity> {
+    method: 'verifyIdentity';
+    request: {
+        identity: authInterfaces.IIdentity;
+    };
+    response: {
+        valid: boolean;
+        identity?: authInterfaces.IIdentity;
+    };
+}

package/dist_ts_interfaces/requests/admin.js

@@ -0,0 +1,3 @@
+import * as plugins from '../plugins.js';
+import * as authInterfaces from '../data/auth.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRtaW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c19pbnRlcmZhY2VzL3JlcXVlc3RzL2FkbWluLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sS0FBSyxjQUFjLE1BQU0saUJBQWlCLENBQUMifQ==

package/dist_ts_interfaces/requests/combined.stats.d.ts

@@ -0,0 +1,24 @@
+import type * as data from '../data/index.js';
+export interface IReq_GetCombinedMetrics {
+    method: 'getCombinedMetrics';
+    request: {
+        identity: data.IIdentity;
+        sections?: {
+            server?: boolean;
+            email?: boolean;
+            dns?: boolean;
+            security?: boolean;
+            network?: boolean;
+        };
+    };
+    response: {
+        metrics: {
+            server?: data.IServerStats;
+            email?: data.IEmailStats;
+            dns?: data.IDnsStats;
+            security?: data.ISecurityMetrics;
+            network?: data.INetworkMetrics;
+        };
+        timestamp: number;
+    };
+}

package/dist_ts_interfaces/requests/combined.stats.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tYmluZWQuc3RhdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c19pbnRlcmZhY2VzL3JlcXVlc3RzL2NvbWJpbmVkLnN0YXRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist_ts_interfaces/requests/config.d.ts

@@ -0,0 +1,13 @@
+import * as plugins from '../plugins.js';
+import * as authInterfaces from '../data/auth.js';
+export interface IReq_GetConfiguration extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_GetConfiguration> {
+    method: 'getConfiguration';
+    request: {
+        identity?: authInterfaces.IIdentity;
+        section?: string;
+    };
+    response: {
+        config: any;
+        section?: string;
+    };
+}

package/dist_ts_interfaces/requests/config.js

@@ -0,0 +1,3 @@
+import * as plugins from '../plugins.js';
+import * as authInterfaces from '../data/auth.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHNfaW50ZXJmYWNlcy9yZXF1ZXN0cy9jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxLQUFLLGNBQWMsTUFBTSxpQkFBaUIsQ0FBQyJ9