@serve.zone/dcrouter 9.1.0 → 9.1.2

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 || value.trim() === '') {
+            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":"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"}

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_web/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/dcrouter',
-    version: '9.1.0',
+    version: '9.1.2',
     description: 'A multifaceted routing service handling mail and SMS delivery functions.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfd2ViLzAwX2NvbW1pdGluZm9fZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRztJQUN4QixJQUFJLEVBQUUsc0JBQXNCO0lBQzVCLE9BQU8sRUFBRSxPQUFPO0lBQ2hCLFdBQVcsRUFBRSwwRUFBMEU7Q0FDeEYsQ0FBQSJ9

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@serve.zone/dcrouter",
   "private": false,
-  "version": "9.1.0",
+  "version": "9.1.2",
   "description": "A multifaceted routing service handling mail and SMS delivery functions.",
   "type": "module",
   "exports": {
@@ -20,19 +20,19 @@
   },
   "devDependencies": {
     "@git.zone/tsbuild": "^4.1.2",
-    "@git.zone/tsbundle": "^2.8.3",
+    "@git.zone/tsbundle": "^2.9.0",
     "@git.zone/tsrun": "^2.0.1",
     "@git.zone/tstest": "^3.1.8",
-    "@git.zone/tswatch": "^3.1.0",
+    "@git.zone/tswatch": "^3.2.0",
     "@types/node": "^25.3.0"
   },
   "dependencies": {
     "@api.global/typedrequest": "^3.2.6",
     "@api.global/typedrequest-interfaces": "^3.0.19",
-    "@api.global/typedserver": "^8.3.0",
+    "@api.global/typedserver": "^8.3.1",
     "@api.global/typedsocket": "^4.1.0",
     "@apiclient.xyz/cloudflare": "^7.1.0",
-    "@design.estate/dees-catalog": "^3.43.2",
+    "@design.estate/dees-catalog": "^3.43.3",
     "@design.estate/dees-element": "^2.1.6",
     "@push.rocks/projectinfo": "^5.0.2",
     "@push.rocks/qenv": "^6.1.3",

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/dcrouter',
-  version: '9.1.0',
+  version: '9.1.2',
   description: 'A multifaceted routing service handling mail and SMS delivery functions.'
 }

package/ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/dcrouter',
-  version: '9.1.0',
+  version: '9.1.2',
   description: 'A multifaceted routing service handling mail and SMS delivery functions.'
 }