@serve.zone/dcrouter 13.17.0 → 13.17.3

package/dist_ts/db/classes.cache.cleaner.d.ts

@@ -0,0 +1,47 @@
+import { DcRouterDb } from './classes.dcrouter-db.js';
+/**
+ * Configuration for the cache cleaner
+ */
+export interface ICacheCleanerOptions {
+    /** Cleanup interval in milliseconds (default: 1 hour) */
+    intervalMs?: number;
+    /** Enable verbose logging */
+    verbose?: boolean;
+}
+/**
+ * CacheCleaner - Periodically removes expired documents from the cache
+ *
+ * Runs on a configurable interval (default: hourly) and queries each
+ * collection for documents where expiresAt < now(), then deletes them.
+ */
+export declare class CacheCleaner {
+    private cleanupInterval;
+    private isRunning;
+    private options;
+    private dcRouterDb;
+    constructor(dcRouterDb: DcRouterDb, options?: ICacheCleanerOptions);
+    /**
+     * Start the periodic cleanup process
+     */
+    start(): void;
+    /**
+     * Stop the periodic cleanup process
+     */
+    stop(): void;
+    /**
+     * Run a single cleanup cycle
+     */
+    runCleanup(): Promise<void>;
+    /**
+     * Clean expired documents from a specific collection using smartdata API
+     */
+    private cleanExpiredDocuments;
+    /**
+     * Check if the cleaner is running
+     */
+    isActive(): boolean;
+    /**
+     * Get the cleanup interval in milliseconds
+     */
+    getIntervalMs(): number;
+}

package/dist_ts/db/classes.cache.cleaner.js

@@ -0,0 +1,130 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logger.js';
+import { DcRouterDb } from './classes.dcrouter-db.js';
+// Import document classes for cleanup
+import { CachedEmail } from './documents/classes.cached.email.js';
+import { CachedIPReputation } from './documents/classes.cached.ip.reputation.js';
+/**
+ * CacheCleaner - Periodically removes expired documents from the cache
+ *
+ * Runs on a configurable interval (default: hourly) and queries each
+ * collection for documents where expiresAt < now(), then deletes them.
+ */
+export class CacheCleaner {
+    cleanupInterval = null;
+    isRunning = false;
+    options;
+    dcRouterDb;
+    constructor(dcRouterDb, options = {}) {
+        this.dcRouterDb = dcRouterDb;
+        this.options = {
+            intervalMs: options.intervalMs || 60 * 60 * 1000, // 1 hour default
+            verbose: options.verbose || false,
+        };
+    }
+    /**
+     * Start the periodic cleanup process
+     */
+    start() {
+        if (this.isRunning) {
+            logger.log('warn', 'CacheCleaner already running');
+            return;
+        }
+        this.isRunning = true;
+        // Run cleanup immediately on start
+        this.runCleanup().catch((error) => {
+            logger.log('error', `Initial cache cleanup failed: ${error.message}`);
+        });
+        // Schedule periodic cleanup
+        this.cleanupInterval = setInterval(() => {
+            this.runCleanup().catch((error) => {
+                logger.log('error', `Cache cleanup failed: ${error.message}`);
+            });
+        }, this.options.intervalMs);
+        logger.log('info', `CacheCleaner started with interval: ${this.options.intervalMs / 1000 / 60} minutes`);
+    }
+    /**
+     * Stop the periodic cleanup process
+     */
+    stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.isRunning = false;
+        logger.log('info', 'CacheCleaner stopped');
+    }
+    /**
+     * Run a single cleanup cycle
+     */
+    async runCleanup() {
+        if (!this.dcRouterDb.isReady()) {
+            logger.log('warn', 'DcRouterDb not ready, skipping cleanup');
+            return;
+        }
+        const now = new Date();
+        const results = [];
+        try {
+            const emailsDeleted = await this.cleanExpiredDocuments(CachedEmail, now);
+            results.push({ collection: 'CachedEmail', deleted: emailsDeleted });
+            const ipReputationDeleted = await this.cleanExpiredDocuments(CachedIPReputation, now);
+            results.push({ collection: 'CachedIPReputation', deleted: ipReputationDeleted });
+            // Log results
+            const totalDeleted = results.reduce((sum, r) => sum + r.deleted, 0);
+            if (totalDeleted > 0 || this.options.verbose) {
+                const summary = results
+                    .filter((r) => r.deleted > 0)
+                    .map((r) => `${r.collection}: ${r.deleted}`)
+                    .join(', ');
+                logger.log('info', `Cache cleanup completed. Deleted ${totalDeleted} expired documents. ${summary || 'No deletions.'}`);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Cache cleanup error: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Clean expired documents from a specific collection using smartdata API
+     */
+    async cleanExpiredDocuments(documentClass, now) {
+        try {
+            // Find all expired documents
+            const expiredDocs = await documentClass.getInstances({
+                expiresAt: { $lt: now },
+            });
+            // Delete each expired document
+            let deletedCount = 0;
+            for (const doc of expiredDocs) {
+                try {
+                    await doc.delete();
+                    deletedCount++;
+                }
+                catch (deleteError) {
+                    logger.log('warn', `Failed to delete expired document: ${deleteError.message}`);
+                }
+            }
+            return deletedCount;
+        }
+        catch (error) {
+            logger.log('error', `Error cleaning collection: ${error.message}`);
+            return 0;
+        }
+    }
+    /**
+     * Check if the cleaner is running
+     */
+    isActive() {
+        return this.isRunning;
+    }
+    /**
+     * Get the cleanup interval in milliseconds
+     */
+    getIntervalMs() {
+        return this.options.intervalMs;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/db/classes.cached.document.d.ts

@@ -0,0 +1,76 @@
+import * as plugins from '../plugins.js';
+/**
+ * Base class for all cached documents with TTL support
+ *
+ * Extends smartdata's SmartDataDbDoc to add:
+ * - Automatic timestamps (createdAt, lastAccessedAt)
+ * - TTL/expiration support (expiresAt)
+ * - Helper methods for TTL management
+ *
+ * NOTE: Subclasses MUST add @svDb() decorators to createdAt, expiresAt, and lastAccessedAt
+ * since decorators on abstract classes don't propagate correctly.
+ */
+export declare abstract class CachedDocument<T extends CachedDocument<T>> extends plugins.smartdata.SmartDataDbDoc<T, T> {
+    /**
+     * Timestamp when the document was created
+     * NOTE: Subclasses must add @svDb() decorator
+     */
+    createdAt: Date;
+    /**
+     * Timestamp when the document expires and should be cleaned up
+     * NOTE: Subclasses must add @svDb() decorator
+     */
+    expiresAt: Date;
+    /**
+     * Timestamp of last access (for LRU-style eviction if needed)
+     * NOTE: Subclasses must add @svDb() decorator
+     */
+    lastAccessedAt: Date;
+    /**
+     * Set the TTL (time to live) for this document
+     * @param ttlMs Time to live in milliseconds
+     */
+    setTTL(ttlMs: number): void;
+    /**
+     * Set TTL using days
+     * @param days Number of days until expiration
+     */
+    setTTLDays(days: number): void;
+    /**
+     * Set TTL using hours
+     * @param hours Number of hours until expiration
+     */
+    setTTLHours(hours: number): void;
+    /**
+     * Check if this document has expired
+     */
+    isExpired(): boolean;
+    /**
+     * Update the lastAccessedAt timestamp
+     */
+    touch(): void;
+    /**
+     * Get remaining TTL in milliseconds
+     * Returns 0 if expired, -1 if no expiration set
+     */
+    getRemainingTTL(): number;
+    /**
+     * Extend the TTL by the specified milliseconds from now
+     * @param ttlMs Additional time to live in milliseconds
+     */
+    extendTTL(ttlMs: number): void;
+    /**
+     * Set the document to never expire (100 years in the future)
+     */
+    setNeverExpires(): void;
+}
+/**
+ * TTL constants in milliseconds
+ */
+export declare const TTL: {
+    readonly HOURS_1: number;
+    readonly HOURS_24: number;
+    readonly DAYS_7: number;
+    readonly DAYS_30: number;
+    readonly DAYS_90: number;
+};

package/dist_ts/db/classes.cached.document.js

@@ -0,0 +1,100 @@
+import * as plugins from '../plugins.js';
+/**
+ * Base class for all cached documents with TTL support
+ *
+ * Extends smartdata's SmartDataDbDoc to add:
+ * - Automatic timestamps (createdAt, lastAccessedAt)
+ * - TTL/expiration support (expiresAt)
+ * - Helper methods for TTL management
+ *
+ * NOTE: Subclasses MUST add @svDb() decorators to createdAt, expiresAt, and lastAccessedAt
+ * since decorators on abstract classes don't propagate correctly.
+ */
+export class CachedDocument extends plugins.smartdata.SmartDataDbDoc {
+    /**
+     * Timestamp when the document was created
+     * NOTE: Subclasses must add @svDb() decorator
+     */
+    createdAt = new Date();
+    /**
+     * Timestamp when the document expires and should be cleaned up
+     * NOTE: Subclasses must add @svDb() decorator
+     */
+    expiresAt;
+    /**
+     * Timestamp of last access (for LRU-style eviction if needed)
+     * NOTE: Subclasses must add @svDb() decorator
+     */
+    lastAccessedAt = new Date();
+    /**
+     * Set the TTL (time to live) for this document
+     * @param ttlMs Time to live in milliseconds
+     */
+    setTTL(ttlMs) {
+        this.expiresAt = new Date(Date.now() + ttlMs);
+    }
+    /**
+     * Set TTL using days
+     * @param days Number of days until expiration
+     */
+    setTTLDays(days) {
+        this.setTTL(days * 24 * 60 * 60 * 1000);
+    }
+    /**
+     * Set TTL using hours
+     * @param hours Number of hours until expiration
+     */
+    setTTLHours(hours) {
+        this.setTTL(hours * 60 * 60 * 1000);
+    }
+    /**
+     * Check if this document has expired
+     */
+    isExpired() {
+        if (!this.expiresAt) {
+            return false; // No expiration set
+        }
+        return new Date() > this.expiresAt;
+    }
+    /**
+     * Update the lastAccessedAt timestamp
+     */
+    touch() {
+        this.lastAccessedAt = new Date();
+    }
+    /**
+     * Get remaining TTL in milliseconds
+     * Returns 0 if expired, -1 if no expiration set
+     */
+    getRemainingTTL() {
+        if (!this.expiresAt) {
+            return -1;
+        }
+        const remaining = this.expiresAt.getTime() - Date.now();
+        return remaining > 0 ? remaining : 0;
+    }
+    /**
+     * Extend the TTL by the specified milliseconds from now
+     * @param ttlMs Additional time to live in milliseconds
+     */
+    extendTTL(ttlMs) {
+        this.expiresAt = new Date(Date.now() + ttlMs);
+    }
+    /**
+     * Set the document to never expire (100 years in the future)
+     */
+    setNeverExpires() {
+        this.expiresAt = new Date(Date.now() + 100 * 365 * 24 * 60 * 60 * 1000);
+    }
+}
+/**
+ * TTL constants in milliseconds
+ */
+export const TTL = {
+    HOURS_1: 1 * 60 * 60 * 1000,
+    HOURS_24: 24 * 60 * 60 * 1000,
+    DAYS_7: 7 * 24 * 60 * 60 * 1000,
+    DAYS_30: 30 * 24 * 60 * 60 * 1000,
+    DAYS_90: 90 * 24 * 60 * 60 * 1000,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/db/classes.dcrouter-db.d.ts

@@ -0,0 +1,70 @@
+import * as plugins from '../plugins.js';
+/**
+ * Configuration options for the unified DCRouter database
+ */
+export interface IDcRouterDbConfig {
+    /** External MongoDB connection URL. If absent, uses embedded LocalSmartDb. */
+    mongoDbUrl?: string;
+    /** Storage path for embedded LocalSmartDb data (default: ~/.serve.zone/dcrouter/tsmdb) */
+    storagePath?: string;
+    /** Database name (default: dcrouter) */
+    dbName?: string;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * DcRouterDb - Unified database layer for DCRouter
+ *
+ * Replaces both StorageManager (flat-file key-value) and CacheDb (embedded MongoDB).
+ * All data is stored as smartdata document classes in a single database.
+ *
+ * Two modes:
+ * - **Embedded** (default): Spawns a LocalSmartDb (Rust-based MongoDB-compatible engine)
+ * - **External**: Connects to a provided MongoDB URL
+ */
+export declare class DcRouterDb {
+    private static instance;
+    private localSmartDb;
+    private smartdataDb;
+    private options;
+    private isStarted;
+    constructor(options?: IDcRouterDbConfig);
+    /**
+     * Get or create the singleton instance
+     */
+    static getInstance(options?: IDcRouterDbConfig): DcRouterDb;
+    /**
+     * Reset the singleton instance (useful for testing)
+     */
+    static resetInstance(): void;
+    /**
+     * Start the database
+     * - If mongoDbUrl is provided, connects directly to external MongoDB
+     * - Otherwise, starts an embedded LocalSmartDb instance
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the database
+     */
+    stop(): Promise<void>;
+    /**
+     * Get the smartdata database instance for @Collection decorators
+     */
+    getDb(): plugins.smartdata.SmartdataDb;
+    /**
+     * Check if the database is ready
+     */
+    isReady(): boolean;
+    /**
+     * Whether running in embedded mode (LocalSmartDb) vs external MongoDB
+     */
+    isEmbedded(): boolean;
+    /**
+     * Get the storage path (only relevant for embedded mode)
+     */
+    getStoragePath(): string;
+    /**
+     * Get the database name
+     */
+    getDbName(): string;
+}

package/dist_ts/db/classes.dcrouter-db.js

@@ -0,0 +1,146 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logger.js';
+import { defaultTsmDbPath } from '../paths.js';
+/**
+ * DcRouterDb - Unified database layer for DCRouter
+ *
+ * Replaces both StorageManager (flat-file key-value) and CacheDb (embedded MongoDB).
+ * All data is stored as smartdata document classes in a single database.
+ *
+ * Two modes:
+ * - **Embedded** (default): Spawns a LocalSmartDb (Rust-based MongoDB-compatible engine)
+ * - **External**: Connects to a provided MongoDB URL
+ */
+export class DcRouterDb {
+    static instance = null;
+    localSmartDb = null;
+    smartdataDb;
+    options;
+    isStarted = false;
+    constructor(options = {}) {
+        this.options = {
+            mongoDbUrl: options.mongoDbUrl || '',
+            storagePath: options.storagePath || defaultTsmDbPath,
+            dbName: options.dbName || 'dcrouter',
+            debug: options.debug || false,
+        };
+    }
+    /**
+     * Get or create the singleton instance
+     */
+    static getInstance(options) {
+        if (!DcRouterDb.instance) {
+            DcRouterDb.instance = new DcRouterDb(options);
+        }
+        return DcRouterDb.instance;
+    }
+    /**
+     * Reset the singleton instance (useful for testing)
+     */
+    static resetInstance() {
+        DcRouterDb.instance = null;
+    }
+    /**
+     * Start the database
+     * - If mongoDbUrl is provided, connects directly to external MongoDB
+     * - Otherwise, starts an embedded LocalSmartDb instance
+     */
+    async start() {
+        if (this.isStarted) {
+            logger.log('warn', 'DcRouterDb already started');
+            return;
+        }
+        try {
+            let connectionUri;
+            if (this.options.mongoDbUrl) {
+                // External MongoDB mode
+                connectionUri = this.options.mongoDbUrl;
+                logger.log('info', `DcRouterDb connecting to external MongoDB`);
+            }
+            else {
+                // Embedded LocalSmartDb mode
+                await plugins.fsUtils.ensureDir(this.options.storagePath);
+                this.localSmartDb = new plugins.smartdb.LocalSmartDb({
+                    folderPath: this.options.storagePath,
+                });
+                const connectionInfo = await this.localSmartDb.start();
+                connectionUri = connectionInfo.connectionUri;
+                if (this.options.debug) {
+                    logger.log('debug', `LocalSmartDb started with URI: ${connectionUri}`);
+                }
+                logger.log('info', `DcRouterDb started embedded instance at ${this.options.storagePath}`);
+            }
+            // Initialize smartdata ORM
+            this.smartdataDb = new plugins.smartdata.SmartdataDb({
+                mongoDbUrl: connectionUri,
+                mongoDbName: this.options.dbName,
+            });
+            await this.smartdataDb.init();
+            this.isStarted = true;
+            logger.log('info', `DcRouterDb ready (db: ${this.options.dbName})`);
+        }
+        catch (error) {
+            logger.log('error', `Failed to start DcRouterDb: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Stop the database
+     */
+    async stop() {
+        if (!this.isStarted) {
+            return;
+        }
+        try {
+            // Close smartdata connection
+            if (this.smartdataDb) {
+                await this.smartdataDb.close();
+            }
+            // Stop embedded LocalSmartDb if running
+            if (this.localSmartDb) {
+                await this.localSmartDb.stop();
+                this.localSmartDb = null;
+            }
+            this.isStarted = false;
+            logger.log('info', 'DcRouterDb stopped');
+        }
+        catch (error) {
+            logger.log('error', `Error stopping DcRouterDb: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Get the smartdata database instance for @Collection decorators
+     */
+    getDb() {
+        if (!this.isStarted) {
+            throw new Error('DcRouterDb not started. Call start() first.');
+        }
+        return this.smartdataDb;
+    }
+    /**
+     * Check if the database is ready
+     */
+    isReady() {
+        return this.isStarted;
+    }
+    /**
+     * Whether running in embedded mode (LocalSmartDb) vs external MongoDB
+     */
+    isEmbedded() {
+        return !this.options.mongoDbUrl;
+    }
+    /**
+     * Get the storage path (only relevant for embedded mode)
+     */
+    getStoragePath() {
+        return this.options.storagePath;
+    }
+    /**
+     * Get the database name
+     */
+    getDbName() {
+        return this.options.dbName;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/db/documents/classes.accounting-session.doc.d.ts

@@ -0,0 +1,32 @@
+import * as plugins from '../../plugins.js';
+export declare class AccountingSessionDoc extends plugins.smartdata.SmartDataDbDoc<AccountingSessionDoc, AccountingSessionDoc> {
+    sessionId: string;
+    username: string;
+    macAddress: string;
+    nasIpAddress: string;
+    nasPort: number;
+    nasPortType: string;
+    nasIdentifier: string;
+    vlanId: number;
+    framedIpAddress: string;
+    calledStationId: string;
+    callingStationId: string;
+    startTime: number;
+    endTime: number;
+    lastUpdateTime: number;
+    status: 'active' | 'stopped' | 'terminated';
+    terminateCause: string;
+    inputOctets: number;
+    outputOctets: number;
+    inputPackets: number;
+    outputPackets: number;
+    sessionTime: number;
+    serviceType: string;
+    constructor();
+    static findBySessionId(sessionId: string): Promise<AccountingSessionDoc | null>;
+    static findActive(): Promise<AccountingSessionDoc[]>;
+    static findByUsername(username: string): Promise<AccountingSessionDoc[]>;
+    static findByNas(nasIpAddress: string): Promise<AccountingSessionDoc[]>;
+    static findByVlan(vlanId: number): Promise<AccountingSessionDoc[]>;
+    static findStoppedBefore(cutoffTime: number): Promise<AccountingSessionDoc[]>;
+}