@nitronjs/framework 0.2.2 → 0.2.4

package/lib/Session/File.js

@@ -4,307 +4,209 @@ import Paths from "../Core/Paths.js";
 import Environment from "../Core/Environment.js";
 
 /**
- * File Session Store
- * 
- * Stores sessions as individual JSON files on disk.
- * Uses atomic writes to prevent corruption.
- * 
- * Features:
- * - One file per session (session_<id>.json)
- * - Atomic write operations (temp file + rename)
- * - Automatic directory creation
- * - Garbage collection for expired sessions
+ * File-based session storage.
+ * Stores each session as a JSON file with atomic writes.
  */
-class File {
+class FileStore {
     #storagePath;
-    ready; // Promise for Manager to wait on initialization
+    ready;
 
     constructor() {
-        // Store sessions in storage/framework/sessions/
         this.#storagePath = Paths.storageSessions;
         this.ready = this.#initialize();
     }
 
     /**
-     * Initialize storage: create directory and cleanup corrupted files
+     * Gets session data by ID.
+     * @param {string} sessionId
+     * @returns {Promise<Object|null>}
      */
-    async #initialize() {
-        try {
-            await fs.mkdir(this.#storagePath, { recursive: true });
-            
-            // Cleanup empty/corrupted files from previous crash (silent)
-            await this.#cleanupCorruptedFiles();
-        }
-        catch (error) {
-            console.error('[File Store] Initialization failed:', error.message);
-            throw error;
+    async get(sessionId) {
+        if (!this.#isValidId(sessionId)) {
+            return null;
         }
-    }
 
-    /**
-     * Cleanup empty or corrupted session files (startup only)
-     */
-    async #cleanupCorruptedFiles() {
         try {
-            const files = await fs.readdir(this.#storagePath);
-            let cleaned = 0;
-
-            for (const file of files) {
-                if (!file.startsWith('session_') || file.endsWith('.tmp')) {
-                    continue;
-                }
-
-                const filePath = path.join(this.#storagePath, file);
-                
-                try {
-                    const content = await fs.readFile(filePath, 'utf8');
-                    
-                    // Check if empty or invalid JSON
-                    if (!content || content.trim() === '') {
-                        await fs.unlink(filePath);
-                        cleaned++;
-                    }
-                    else {
-                        JSON.parse(content); // Validate JSON
-                    }
-                }
-                catch {
-                    // Corrupted or unreadable - delete
-                    await fs.unlink(filePath).catch(() => {});
-                    cleaned++;
-                }
-            }
-
-            if (cleaned > 0) {
-                console.log(`[File Store] Cleaned ${cleaned} corrupted session files`);
-            }
-        }
-        catch (error) {
-            // Non-critical, ignore
-        }
-    }
-
-    /**
-     * Validate session ID format (hex only, max 128 chars)
-     * Prevents path traversal attacks
-     */
-    #isValidSessionId(sessionId) {
-        if (!sessionId || typeof sessionId !== 'string') return false;
-        if (sessionId.length > 128) return false;
-        return /^[a-f0-9]+$/i.test(sessionId);
-    }
-
-    /**
-     * Get session file path
-     */
-    #getFilePath (sessionId) {
-        return path.join(this.#storagePath, `session_${sessionId}.json`);
-    }
+            const content = await fs.readFile(this.#filePath(sessionId), "utf8");
 
-    /**
-     * Get temporary file path for atomic writes
-     */
-    #getTempFilePath (sessionId) {
-        return path.join(this.#storagePath, `session_${sessionId}.json.tmp`);
-    }
-
-    /**
-     * Retrieve session data by ID
-     * @param {string} sessionId - Session identifier
-     * @returns {object|null} Session data or null if not found
-     */
-    async get (sessionId) {
-        await this.ready;
-        
-        // Guard: Validate session ID format (hex only)
-        if (!this.#isValidSessionId(sessionId)) {
-            return null;
-        }
-        
-        try {
-            const filePath = this.#getFilePath(sessionId);
-            const content = await fs.readFile(filePath, 'utf8');
-            
-            // Validate JSON before parsing
-            if (!content || content.trim() === '') {
-                // Silent cleanup - empty files are normal during hot-reload
-                await fs.unlink(filePath).catch(() => {});
+            if (!content?.trim()) {
+                await this.delete(sessionId);
 
                 return null;
             }
-            
+
             return JSON.parse(content);
         }
-        catch (error) {
-            // File not found
-            if (error.code === 'ENOENT') {
+        catch (err) {
+            if (err.code === "ENOENT") {
                 return null;
             }
-            
-            // Corrupted file - silent cleanup
-            if (error instanceof SyntaxError) {
-                const filePath = this.#getFilePath(sessionId);
-                await fs.unlink(filePath).catch(() => {});
+
+            if (err instanceof SyntaxError) {
+                await this.delete(sessionId);
+
                 return null;
             }
-            
-            // Only log unexpected errors
-            if (error.code !== 'EBUSY' && error.code !== 'EPERM') {
-                console.error('[File Store] Read error:', error.message);
-            }
+
             return null;
         }
     }
 
     /**
-     * Store session data with retry and atomic write
-     * @param {string} sessionId - Session identifier
-     * @param {object} sessionData - Session data to store
+     * Stores session data.
+     * @param {string} sessionId
+     * @param {Object} data
      */
-    async set (sessionId, sessionData) {
-        await this.ready;
-        
-        // Guard: Validate session ID format (hex only)
-        if (!this.#isValidSessionId(sessionId)) {
+    async set(sessionId, data) {
+        if (!this.#isValidId(sessionId)) {
             return;
         }
-        
-        const filePath = this.#getFilePath(sessionId);
-        const tempPath = this.#getTempFilePath(sessionId);
-        const jsonContent = Environment.isDev
-            ? JSON.stringify(sessionData, null, 2)
-            : JSON.stringify(sessionData);
-        
-        // Retry mechanism for Windows file locking
-        const maxRetries = 3;
-        const retryDelay = 50; // ms
-        
-        for (let attempt = 0; attempt < maxRetries; attempt++) {
-            try {
-                // Write to temp file first (with restricted permissions on Unix)
-                const writeOptions = process.platform === 'win32' 
-                    ? { encoding: 'utf8' }
-                    : { encoding: 'utf8', mode: 0o600 };
-                
-                await fs.writeFile(tempPath, jsonContent, writeOptions);
-                
-                // Atomic rename (cross-platform)
-                try {
-                    await fs.rename(tempPath, filePath);
-                }
-                catch (renameError) {
-                    // Windows: EPERM if target exists and is locked
-                    if (renameError.code === 'EPERM' || renameError.code === 'EEXIST') {
-                        try {
-                            await fs.unlink(filePath);
-                        }
-                        catch {}
-                        await fs.rename(tempPath, filePath);
-                    }
-                    else {
-                        throw renameError;
-                    }
-                }
-                
-                return; // Success
-            }
-            catch (error) {
-                const isLastAttempt = attempt === maxRetries - 1;
-                const isLockError = ['EBUSY', 'EPERM', 'ENOENT'].includes(error.code);
-                
-                // Clean up temp file on error
-                try {
-                    await fs.unlink(tempPath);
-                }
-                catch {}
-                
-                // If file locked and not last attempt, retry
-                if (isLockError && !isLastAttempt) {
-                    await new Promise(resolve => setTimeout(resolve, retryDelay * (attempt + 1)));
-                    continue;
-                }
-                
-                // Last attempt or non-lock error - log it
-                if (isLastAttempt || !isLockError) {
-                    console.error('[File Store] Write failed after retries:', error.message);
-                }
-                return;
-            }
+
+        const filePath = this.#filePath(sessionId);
+        const tempPath = filePath + ".tmp";
+        const json = Environment.isDev ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+
+        try {
+            await fs.writeFile(tempPath, json, "utf8");
+            await this.#atomicRename(tempPath, filePath);
+        }
+        catch {
+            await fs.unlink(tempPath).catch(() => {});
         }
     }
 
     /**
-     * Delete session file
-     * @param {string} sessionId - Session identifier
+     * Deletes a session.
+     * @param {string} sessionId
      */
     async delete(sessionId) {
-        await this.ready;
-        
-        // Guard: Validate session ID format (hex only)
-        if (!this.#isValidSessionId(sessionId)) {
+        if (!this.#isValidId(sessionId)) {
             return;
         }
-        
+
         try {
-            const filePath = this.#getFilePath(sessionId);
-            await fs.unlink(filePath);
+            await fs.unlink(this.#filePath(sessionId));
         }
-        catch (error) {
-            // Ignore file-not-found, log other errors
-            if (error.code !== 'ENOENT') {
-                console.error('[File Store] Delete error:', error.message);
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                console.error("[Session File] Delete error:", err.message);
             }
         }
     }
 
     /**
-     * Garbage collection - remove expired session files
-     * @param {number} lifetime - Max session lifetime in milliseconds
-     * @returns {number} Number of deleted sessions
+     * Garbage collection - removes expired sessions.
+     * @param {number} lifetime - Max lifetime in milliseconds
+     * @returns {Promise<number>} Number of deleted sessions
      */
-    async gc (lifetime) {
-        await this.ready;
-        
+    async gc(lifetime) {
         try {
             const files = await fs.readdir(this.#storagePath);
-            let deletedCount = 0;
             const now = Date.now();
+            let deleted = 0;
 
             for (const file of files) {
-                // Only process session files, skip temp files
-                if (!file.startsWith('session_') || file.endsWith('.tmp')) {
+                if (!file.startsWith("session_") || file.endsWith(".tmp")) {
                     continue;
                 }
 
                 const filePath = path.join(this.#storagePath, file);
 
                 try {
-                    const content = await fs.readFile(filePath, 'utf8');
-                    const sessionData = JSON.parse(content);
-                    
-                    // Delete if expired
-                    const lastActivity = sessionData.lastActivity || sessionData.createdAt;
+                    const content = await fs.readFile(filePath, "utf8");
+                    const data = JSON.parse(content);
+                    const lastActivity = data.lastActivity || data.createdAt;
+
                     if (now - lastActivity > lifetime) {
                         await fs.unlink(filePath);
-                        deletedCount++;
+                        deleted++;
                     }
                 }
-                catch (error) {
-                    // Corrupted or unreadable file - delete it
-                    if (error.code !== 'ENOENT') {
-                        await fs.unlink(filePath).catch(() => {});
-                        deletedCount++;
-                    }
+                catch {
+                    await fs.unlink(filePath).catch(() => {});
+                    deleted++;
                 }
             }
 
-            return deletedCount;
+            return deleted;
         }
-        catch (error) {
-            console.error('[File Store] GC error:', error.message);
+        catch (err) {
+            console.error("[Session File] GC error:", err.message);
+
             return 0;
         }
     }
+
+    /** @private */
+    async #initialize() {
+        await fs.mkdir(this.#storagePath, { recursive: true });
+        await this.#cleanupCorrupted();
+    }
+
+    /** @private */
+    async #cleanupCorrupted() {
+        try {
+            const files = await fs.readdir(this.#storagePath);
+            let cleaned = 0;
+
+            for (const file of files) {
+                if (!file.startsWith("session_") || file.endsWith(".tmp")) {
+                    continue;
+                }
+
+                const filePath = path.join(this.#storagePath, file);
+
+                try {
+                    const content = await fs.readFile(filePath, "utf8");
+
+                    if (!content?.trim()) {
+                        await fs.unlink(filePath);
+                        cleaned++;
+                    }
+                    else {
+                        JSON.parse(content);
+                    }
+                }
+                catch {
+                    await fs.unlink(filePath).catch(() => {});
+                    cleaned++;
+                }
+            }
+
+            if (cleaned > 0) {
+                console.log(`[Session File] Cleaned ${cleaned} corrupted files`);
+            }
+        }
+        catch {
+            // Non-critical
+        }
+    }
+
+    /** @private */
+    #isValidId(id) {
+        return id && typeof id === "string" && id.length <= 128 && /^[a-f0-9]+$/i.test(id);
+    }
+
+    /** @private */
+    #filePath(sessionId) {
+        return path.join(this.#storagePath, `session_${sessionId}.json`);
+    }
+
+    /** @private */
+    async #atomicRename(from, to) {
+        try {
+            await fs.rename(from, to);
+        }
+        catch (err) {
+            if (err.code === "EPERM" || err.code === "EEXIST") {
+                await fs.unlink(to).catch(() => {});
+                await fs.rename(from, to);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
 }
 
-export default File;
+export default FileStore;