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

package/BuildNo.txt

@@ -1 +1 @@
-R-0.000.0010
+R-0.000.0012

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export { Logger, logger } from './logger/Logger';
-export type { LogLevel, ILogger, ILoggerImplementation, ILoggerConfig, ILogEntry, ILogFileInfo } from './logger/Logger';
+export type { LogLevel, ILogger, ILoggerImplementation, } from './logger/Logger';
 export { default } from './logger/Logger';

package/dist/logger/BaseLogger.d.ts

@@ -16,13 +16,4 @@ export declare class BaseLogger {
     getLogFileContent(): Promise<string>;
     getBackupLogFileContent(): Promise<string | null>;
     clearLogFile(): Promise<void>;
-    get logFile(): string;
-    write(message: string): Promise<void>;
-    readLog(): Promise<string>;
-    rotateLog(): Promise<void>;
-    getLogSizes(): Promise<{
-        logFile: number;
-        backupFile: number;
-    }>;
-    private getFileSize;
 }

package/dist/logger/BaseLogger.js

@@ -2,7 +2,8 @@
 import { Platform } from 'react-native';
 import { LoggerNative } from './services/LoggerNative';
 import { LoggerWeb } from './services/LoggerWeb';
-export const MAX_LOG_SIZE = 1 * 1024 * 1024;
+import { LoggerWindows } from './services/LoggerWindows';
+export const MAX_LOG_SIZE = 100 * 1024 * 1024;
 export class BaseLogger {
     constructor() {
         this.logLevel = 'info';
@@ -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);
     }
     // -------------------------
@@ -72,47 +67,4 @@ export class BaseLogger {
     getLogFileContent() { return this.impl.getLogFileContent(); }
     getBackupLogFileContent() { return this.impl.getBackupLogFileContent(); }
     clearLogFile() { return this.impl.clear(); }
-    // -------------------------
-    // ILogger interface compatibility
-    // -------------------------
-    get logFile() {
-        return this.impl.logFile || '';
-    }
-    async write(message) {
-        const line = `[${new Date().toISOString()}] ${message}`;
-        await this.impl.writeLine(line, MAX_LOG_SIZE);
-    }
-    async readLog() {
-        return this.impl.getLogFileContent();
-    }
-    async rotateLog() {
-        if (this.impl.rotateLog) {
-            await this.impl.rotateLog();
-        }
-        else {
-            // For Windows, force rotation by writing max size
-            await this.impl.writeLine('', Number.MAX_SAFE_INTEGER);
-        }
-    }
-    async getLogSizes() {
-        const logSize = await this.getFileSize(this.impl.logFile);
-        const backupSize = await this.getFileSize(this.impl.backupZip || this.impl.tempFile || '');
-        return { logFile: logSize, backupFile: backupSize };
-    }
-    async getFileSize(path) {
-        if (!path)
-            return 0;
-        try {
-            // Try to use RNFS if available
-            const RNFS = require('@dr.pogodin/react-native-fs');
-            if (await RNFS.exists(path)) {
-                const stat = await RNFS.stat(path);
-                return stat.size;
-            }
-        }
-        catch {
-            // Ignore
-        }
-        return 0;
-    }
 }

package/dist/logger/Logger.d.ts

@@ -2,6 +2,6 @@ import { BaseLogger, LogLevel } from './BaseLogger';
 export declare class Logger extends BaseLogger {
 }
 export declare const logger: Logger;
-export type { ILogger, ILoggerImplementation, ILoggerConfig, ILogEntry, ILogFileInfo, } from './Logger.types';
+export type { ILogger, ILoggerImplementation, } from './Logger.types';
 export type { LogLevel };
 export default logger;

package/dist/logger/Logger.types.d.ts

@@ -13,7 +13,6 @@ export interface ILoggerImplementation {
     backupZip?: string;
     init(): Promise<void>;
     writeLine(line: string, maxSize: number): Promise<void>;
-    rotateLog?(): Promise<void>;
     getLogFileURL(): Promise<string>;
     getLogFileContent(): Promise<string>;
     getBackupLogFileContent(): Promise<string | null>;
@@ -24,48 +23,12 @@ export interface ILoggerImplementation {
  * This is what consumers of the logger package should use
  */
 export interface ILogger {
-    logFile: string;
-    setLogLevel?(level: LogLevel): void;
-    logDebug?(className: string, methodName: string, message: string): void;
-    logInfo?(className: string, methodName: string, message: string): void;
-    logError?(className: string, methodName: string, message: string): void;
-    write(message: string): Promise<void>;
-    readLog(): Promise<string>;
-    rotateLog(): Promise<void>;
-    getLogSizes(): Promise<{
-        logFile: number;
-        backupFile: number;
-    }>;
-    getLogFileURL?(): Promise<string>;
-    getLogFileContent?(): Promise<string>;
+    setLogLevel(level: LogLevel): void;
+    logDebug(className: string, methodName: string, message: string): void;
+    logInfo(className: string, methodName: string, message: string): void;
+    logError(className: string, methodName: string, message: string): void;
+    getLogFileURL(): Promise<string>;
+    getLogFileContent(): Promise<string>;
     getBackupLogFileContent(): Promise<string | null>;
-    clearLogFile?(): Promise<void>;
-}
-/**
- * Configuration options for logger initialization
- */
-export interface ILoggerConfig {
-    logLevel?: LogLevel;
-    maxLogSize?: number;
-    logDir?: string;
-    logFileName?: string;
-}
-/**
- * Log entry structure
- */
-export interface ILogEntry {
-    timestamp: string;
-    level: LogLevel;
-    className?: string;
-    methodName?: string;
-    message: string;
-}
-/**
- * Log file information
- */
-export interface ILogFileInfo {
-    path: string;
-    size: number;
-    exists: boolean;
-    lastModified?: Date;
+    clearLogFile(): Promise<void>;
 }

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

@@ -9,9 +9,9 @@ export declare class LoggerNative implements ILoggerImplementation {
     init(): Promise<void>;
     writeLine(line: string, maxSize: number): Promise<void>;
     private ensureDir;
-    rotateLog(): Promise<void>;
+    private rotateLog;
     getLogFileURL(): Promise<string>;
     getLogFileContent(): Promise<any>;
-    getBackupLogFileContent(): Promise<string | null>;
+    getBackupLogFileContent(): Promise<any>;
     clear(): Promise<void>;
 }

package/dist/logger/services/LoggerNative.js

@@ -27,7 +27,7 @@ export class LoggerNative {
     constructor() {
         this.isRotating = false; // Rotation lock to prevent concurrent rotations
         this.isAvailable = false;
-        const dir = 'unvired_logs_local';
+        const dir = 'unvired_logs';
         const file = 'applog.txt'; // main log file
         if (!RNFS) {
             console.warn('⚠️ LoggerNative: RNFS not available, logging to file system disabled');
@@ -174,7 +174,10 @@ export class LoggerNative {
         if (!this.isAvailable || !RNFS)
             return '';
         try {
-            return (await RNFS.exists(this.logFile)) ? RNFS.readFile(this.logFile, 'utf8') : '';
+            if (await RNFS.exists(this.logFile)) {
+                return await RNFS.readFile(this.logFile, 'utf8');
+            }
+            return '';
         }
         catch (e) {
             console.error('❌ LoggerNative getLogFileContent error:', e);
@@ -185,9 +188,11 @@ export class LoggerNative {
         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)) {
-                const stat = await RNFS.stat(this.backupZip);
-                return `${stat.size}`;
+                // Return base64 content for download/upload
+                return await RNFS.readFile(this.backupZip, 'base64');
             }
             return null;
         }

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.10",
+  "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"
   }
-}
+}