@unvired/react-native-unvired-sdk 0.0.11 → 0.0.12

package/BuildNo.txt

@@ -1 +1 @@
-R-0.000.0011
+R-0.000.0012

package/dist/logger/BaseLogger.js

@@ -2,6 +2,7 @@
 import { Platform } from 'react-native';
 import { LoggerNative } from './services/LoggerNative';
 import { LoggerWeb } from './services/LoggerWeb';
+import { LoggerWindows } from './services/LoggerWindows';
 export const MAX_LOG_SIZE = 100 * 1024 * 1024;
 export class BaseLogger {
     constructor() {
@@ -10,9 +11,7 @@ export class BaseLogger {
             this.impl = new LoggerWeb();
         }
         else if (Platform.OS === 'windows') {
-            // TODO: Implement LoggerWindows
-            console.warn('Windows logger not implemented yet, using web logger');
-            this.impl = new LoggerWeb();
+            this.impl = new LoggerWindows();
         }
         else {
             this.impl = new LoggerNative();
@@ -24,7 +23,7 @@ export class BaseLogger {
     // -------------------------
     format(className, methodName, message, level) {
         const ts = new Date().toISOString();
-        return `--[${ts}] [${level.toUpperCase()}] [${className}] [${methodName}] ${message}`;
+        return `[${ts}] [${level.toUpperCase()}] [${className}] [${methodName}] ${message}`;
     }
     setLogLevel(level) {
         this.logLevel = level;
@@ -46,17 +45,13 @@ export class BaseLogger {
             return;
         const line = this.format(className, methodName, message, level);
         // console always
+        /*
         switch (level) {
-            case 'debug':
-                console.debug(line);
-                break;
-            case 'info':
-                console.info(line);
-                break;
-            case 'error':
-                console.error(line);
-                break;
+            case 'debug': console.debug(line); break;
+            case 'info': console.info(line); break;
+            case 'error': console.error(line); break;
         }
+        */
         await this.impl.writeLine(line, MAX_LOG_SIZE);
     }
     // -------------------------

package/dist/logger/services/LoggerNative.js

@@ -27,8 +27,8 @@ export class LoggerNative {
     constructor() {
         this.isRotating = false; // Rotation lock to prevent concurrent rotations
         this.isAvailable = false;
-        const dir = 'unvired_logs_local';
-        const file = 'applog_local.txt'; // main log file
+        const dir = 'unvired_logs';
+        const file = 'applog.txt'; // main log file
         if (!RNFS) {
             console.warn('⚠️ LoggerNative: RNFS not available, logging to file system disabled');
             this.logDir = '';
@@ -47,7 +47,7 @@ export class LoggerNative {
             this.logDir = '';
         }
         this.logFile = `${this.logDir}/${file}`;
-        this.backupZip = `${this.logDir}/backuplog_local.zip`;
+        this.backupZip = `${this.logDir}/backuplog.zip`;
     }
     async init() {
         if (!this.isAvailable || !this.logDir || !RNFS)
@@ -188,8 +188,8 @@ export class LoggerNative {
         if (!this.isAvailable || !RNFS)
             return null;
         try {
-            // Force rotation to ensure current logs are zipped
-            await this.rotateLog();
+            // Do NOT force rotation. Only return existing backup if present.
+            // await this.rotateLog();
             if (await RNFS.exists(this.backupZip)) {
                 // Return base64 content for download/upload
                 return await RNFS.readFile(this.backupZip, 'base64');

package/dist/logger/services/LoggerWindows.d.ts

@@ -0,0 +1,20 @@
+import type { ILoggerImplementation } from '../Logger.types';
+export declare class LoggerWindows implements ILoggerImplementation {
+    logDir: string;
+    logFile: string;
+    backupZip: string;
+    private isRotating;
+    private isAvailable;
+    constructor();
+    init(): Promise<void>;
+    private writeQueue;
+    private isWriting;
+    writeLine(line: string, maxSize: number): Promise<void>;
+    private processWriteQueue;
+    private ensureDir;
+    private rotateLog;
+    getLogFileURL(): Promise<string>;
+    getLogFileContent(): Promise<any>;
+    getBackupLogFileContent(): Promise<any>;
+    clear(): Promise<void>;
+}

package/dist/logger/services/LoggerWindows.js

@@ -0,0 +1,225 @@
+import * as pako from 'pako';
+// Import with null safety
+let RNFS = null;
+try {
+    RNFS = require('@dr.pogodin/react-native-fs');
+    if (!RNFS || !RNFS.DocumentDirectoryPath) {
+        console.error('❌ @dr.pogodin/react-native-fs is not properly linked.');
+        RNFS = null;
+    }
+}
+catch (e) {
+    console.error('❌ @dr.pogodin/react-native-fs module not found.');
+}
+export class LoggerWindows {
+    constructor() {
+        this.isRotating = false; // Rotation lock to prevent concurrent rotations
+        this.isAvailable = false;
+        this.writeQueue = [];
+        this.isWriting = false;
+        const dir = 'unvired_logs';
+        const file = 'applog.txt'; // main log file
+        if (!RNFS) {
+            console.warn('⚠️ LoggerWindows: RNFS not available, logging to file system disabled');
+            this.logDir = '';
+            this.logFile = '';
+            this.backupZip = '';
+            return;
+        }
+        this.isAvailable = true;
+        // Windows specifically uses DocumentDirectoryPath (AppData/Local/Packages/.../LocalState)
+        this.logDir = `${RNFS.DocumentDirectoryPath}/${dir}`;
+        this.logFile = `${this.logDir}/${file}`;
+        this.backupZip = `${this.logDir}/backuplog.zip`;
+    }
+    async init() {
+        if (!this.isAvailable || !this.logDir || !RNFS)
+            return;
+        try {
+            if (!(await RNFS.exists(this.logDir)))
+                await RNFS.mkdir(this.logDir);
+            if (!(await RNFS.exists(this.logFile)))
+                await RNFS.writeFile(this.logFile, '', 'utf8');
+        }
+        catch (e) {
+            console.error('❌ LoggerWindows init error:', e);
+        }
+    }
+    async writeLine(line, maxSize) {
+        if (!this.isAvailable || !RNFS)
+            return;
+        // Push to queue
+        this.writeQueue.push(line);
+        // Trigger processing if not already running
+        this.processWriteQueue(maxSize);
+    }
+    async processWriteQueue(maxSize) {
+        if (this.isWriting)
+            return;
+        this.isWriting = true;
+        try {
+            await this.ensureDir();
+            while (this.writeQueue.length > 0) {
+                // Peek at the chunk of lines to write? 
+                // Writing one by one is safe but slow. 
+                // Let's write one by one for safety first.
+                const line = this.writeQueue.shift();
+                if (!line)
+                    continue;
+                try {
+                    await RNFS.appendFile(this.logFile, line + '\n', 'utf8');
+                    // Check rotation (only occasionally to avoid stat spam?)
+                    // We can check every N writes or if queue is empty
+                    if (!this.isRotating && this.writeQueue.length === 0) {
+                        try {
+                            const stat = await RNFS.stat(this.logFile);
+                            if (Number(stat.size) >= maxSize) {
+                                this.rotateLog();
+                            }
+                        }
+                        catch (statErr) {
+                            // ignore
+                        }
+                    }
+                }
+                catch (filesErr) {
+                    // If file is locked, we might want to put line back?
+                    // or just retry? 
+                    // For now, retry once then drop to avoid infinite loop
+                    console.warn('⚠️ Write failed, retrying once:', filesErr.message);
+                    try {
+                        await new Promise(r => setTimeout(r, 50)); // small delay
+                        await RNFS.appendFile(this.logFile, line + '\n', 'utf8');
+                    }
+                    catch (retryErr) {
+                        console.error('❌ Failed to write log line after retry:', retryErr);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.error('❌ LoggerWindows queue error:', e);
+        }
+        finally {
+            this.isWriting = false;
+            // If logs came in while we were finishing, trigger again
+            if (this.writeQueue.length > 0) {
+                this.processWriteQueue(maxSize);
+            }
+        }
+    }
+    async ensureDir() {
+        if (!this.isAvailable || !this.logDir || !RNFS)
+            return;
+        try {
+            if (!(await RNFS.exists(this.logDir)))
+                await RNFS.mkdir(this.logDir);
+        }
+        catch (e) {
+            // Ignore if dir already exists race condition
+        }
+    }
+    async rotateLog() {
+        if (!this.isAvailable || !RNFS) {
+            return;
+        }
+        // Prevent concurrent rotations
+        if (this.isRotating) {
+            console.log('⏭️ Rotation already in progress, skipping...');
+            return;
+        }
+        this.isRotating = true;
+        try {
+            console.log('🔄 Starting log rotation (using pako gzip)...');
+            // Check if log file exists
+            if (!(await RNFS.exists(this.logFile))) {
+                return;
+            }
+            // Step 1: Read current log content
+            // Reading whole file into memory might be heavy for huge files, 
+            // but for mobile logs generally acceptable (e.g. 5-10MB limit)
+            const content = await RNFS.readFile(this.logFile, 'utf8');
+            // Step 2: Compress content using Pako (gzip)
+            const binaryData = pako.gzip(content);
+            // Step 3: Convert binary to base64 for writing using Buffer (more robust)
+            // React Native environment usually has Buffer polyfill, or we use a chunked approach
+            const base64 = Buffer.from(binaryData).toString('base64');
+            // Step 4: Write to backup file (overwriting old one)
+            // We rename extensions to .gz to be accurate, or keep .zip if requirement is strict 
+            // (but technically it IS a gzip stream, not a PKZip archive)
+            // User asked for base64 return, so storing it purely is fine.
+            await RNFS.writeFile(this.backupZip, base64, 'base64');
+            console.log('✅ Backup created successfully');
+            // Step 5: Clear current log
+            await RNFS.writeFile(this.logFile, '', 'utf8');
+            console.log('✔ Log rotation completed successfully');
+        }
+        catch (e) {
+            console.error('❌ Logger rotation error:', e);
+            // Recovery: ensure log file exists
+            try {
+                if (!(await RNFS.exists(this.logFile))) {
+                    await RNFS.writeFile(this.logFile, '', 'utf8');
+                }
+            }
+            catch { }
+        }
+        finally {
+            this.isRotating = false;
+        }
+    }
+    // ------------------------
+    // Public accessors
+    // ------------------------
+    async getLogFileURL() {
+        if (!this.isAvailable)
+            return '';
+        return this.logFile;
+    }
+    async getLogFileContent() {
+        if (!this.isAvailable || !RNFS)
+            return '';
+        try {
+            if (await RNFS.exists(this.logFile)) {
+                return await RNFS.readFile(this.logFile, 'utf8');
+            }
+            return '';
+        }
+        catch (e) {
+            return '';
+        }
+    }
+    async getBackupLogFileContent() {
+        if (!this.isAvailable || !RNFS)
+            return null;
+        try {
+            // Do NOT force rotation. Only return existing backup if present.
+            // await this.rotateLog();
+            if (await RNFS.exists(this.backupZip)) {
+                // It's already written as base64 in rotateLog step via writeFile('base64'), 
+                // but readFile('base64') reads the file content and returns base64. 
+                // Wait, writeFile(path, data, 'base64') expects data to BE base64.
+                // readFile(path, 'base64') reads binary and RETURNS base64.
+                // Yes, so we can just read it back.
+                return await RNFS.readFile(this.backupZip, 'base64');
+            }
+            return null;
+        }
+        catch (e) {
+            console.error('❌ LoggerWindows getBackupLogFileContent error:', e);
+            return null;
+        }
+    }
+    async clear() {
+        if (!this.isAvailable || !RNFS)
+            return;
+        try {
+            await RNFS.writeFile(this.logFile, '', 'utf8');
+            if (await RNFS.exists(this.backupZip))
+                await RNFS.unlink(this.backupZip);
+        }
+        catch (e) {
+            // silent
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unvired/react-native-unvired-sdk",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "description": "Unvired SDK for React Native with logging, database, notifications, and file system support",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -38,7 +38,10 @@
     "prettier": "^3.0.0",
     "typescript": "^5.0.0"
   },
-  "dependencies": {},
+  "dependencies": {
+    "@types/pako": "^2.0.4",
+    "pako": "^2.1.0"
+  },
   "repository": {},
   "bugs": {},
   "volta": {
@@ -47,4 +50,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}