@serve.zone/dcrouter 11.14.0 → 11.16.0

package/dist_ts/sms/config/sms.schema.js

@@ -0,0 +1,121 @@
+/**
+ * SMS service configuration schema
+ */
+export const smsConfigSchema = {
+    apiGatewayApiToken: {
+        type: 'string',
+        required: true
+    },
+    defaultSender: {
+        type: 'string',
+        required: false
+    },
+    rateLimit: {
+        type: 'object',
+        required: false,
+        schema: {
+            enabled: {
+                type: 'boolean',
+                required: false,
+                default: true
+            },
+            maxPerPeriod: {
+                type: 'number',
+                required: false,
+                default: 100,
+                min: 1
+            },
+            periodMs: {
+                type: 'number',
+                required: false,
+                default: 60000, // 1 minute
+                min: 1000
+            },
+            perKey: {
+                type: 'boolean',
+                required: false,
+                default: true
+            },
+            burstTokens: {
+                type: 'number',
+                required: false,
+                default: 5,
+                min: 0
+            },
+            maxPerRecipientPerDay: {
+                type: 'number',
+                required: false,
+                default: 10,
+                min: 1
+            }
+        }
+    },
+    provider: {
+        type: 'object',
+        required: false,
+        schema: {
+            type: {
+                type: 'string',
+                required: false,
+                enum: ['gateway', 'twilio', 'other'],
+                default: 'gateway'
+            },
+            config: {
+                type: 'object',
+                required: false
+            },
+            fallback: {
+                type: 'object',
+                required: false,
+                schema: {
+                    enabled: {
+                        type: 'boolean',
+                        required: false,
+                        default: false
+                    },
+                    type: {
+                        type: 'string',
+                        required: false,
+                        enum: ['gateway', 'twilio', 'other']
+                    },
+                    config: {
+                        type: 'object',
+                        required: false
+                    }
+                }
+            }
+        }
+    },
+    verification: {
+        type: 'object',
+        required: false,
+        schema: {
+            codeLength: {
+                type: 'number',
+                required: false,
+                default: 6,
+                min: 4,
+                max: 10
+            },
+            expirationSeconds: {
+                type: 'number',
+                required: false,
+                default: 300, // 5 minutes
+                min: 60
+            },
+            maxAttempts: {
+                type: 'number',
+                required: false,
+                default: 3,
+                min: 1
+            },
+            cooldownSeconds: {
+                type: 'number',
+                required: false,
+                default: 60, // 1 minute
+                min: 0
+            }
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/sms/index.d.ts

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

package/dist_ts/sms/index.js

@@ -0,0 +1,2 @@
+export * from './classes.smsservice.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9zbXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5QkFBeUIsQ0FBQyJ9

package/dist_ts/storage/classes.storagemanager.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Storage configuration interface
+ */
+export interface IStorageConfig {
+    /** Filesystem path for storage */
+    fsPath?: string;
+    /** Custom read function */
+    readFunction?: (key: string) => Promise<string | null>;
+    /** Custom write function */
+    writeFunction?: (key: string, value: string) => Promise<void>;
+}
+/**
+ * Storage backend type
+ */
+export type StorageBackend = 'filesystem' | 'custom' | 'memory';
+/**
+ * Central storage manager for DcRouter
+ * Provides unified key-value storage with multiple backend support
+ */
+export declare class StorageManager {
+    private static readonly MAX_MEMORY_ENTRIES;
+    private backend;
+    private memoryStore;
+    private config;
+    private fsBasePath?;
+    constructor(config?: IStorageConfig);
+    /**
+     * Show warning when using memory backend
+     */
+    private showMemoryWarning;
+    /**
+     * Ensure directory exists for filesystem backend
+     */
+    private ensureDirectory;
+    /**
+     * Validate and sanitize storage key
+     */
+    private validateKey;
+    /**
+     * Convert key to filesystem path
+     */
+    private keyToPath;
+    /**
+     * Internal filesystem read function
+     */
+    private fsRead;
+    /**
+     * Internal filesystem write function
+     */
+    private fsWrite;
+    /**
+     * Get value by key
+     */
+    get(key: string): Promise<string | null>;
+    /**
+     * Set value by key
+     */
+    set(key: string, value: string): Promise<void>;
+    /**
+     * Delete value by key
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * List keys by prefix
+     */
+    list(prefix?: string): Promise<string[]>;
+    /**
+     * Check if key exists
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * Get storage backend type
+     */
+    getBackend(): StorageBackend;
+    /**
+     * JSON helper: Get and parse JSON value
+     */
+    getJSON<T = any>(key: string): Promise<T | null>;
+    /**
+     * JSON helper: Set value as JSON
+     */
+    setJSON(key: string, value: any): Promise<void>;
+}

package/dist_ts/storage/classes.storagemanager.js

@@ -0,0 +1,348 @@
+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 {
+    static MAX_MEMORY_ENTRIES = 10_000;
+    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 = (key) => 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);
+                    // Evict oldest entries if memory store exceeds limit
+                    while (this.memoryStore.size > StorageManager.MAX_MEMORY_ENTRIES) {
+                        const firstKey = this.memoryStore.keys().next().value;
+                        this.memoryStore.delete(firstKey);
+                    }
+                    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=