local-lite 0.0.2 → 0.0.4

package/dist/adapters/local/better-sqlite3.d.ts

@@ -17,7 +17,9 @@ export interface BetterSqliteDatabase {
  */
 export declare class BetterSQLite3Adapter implements LocalDBAdapter {
     private db;
+    private queue;
     constructor(betterSqliteInstance: any);
     execute(query: string, params?: any[]): Promise<any[]>;
     transaction<T>(action: (tx: LocalTransaction) => Promise<T>): Promise<T>;
+    close(): void;
 }

package/dist/adapters/local/better-sqlite3.js

@@ -6,40 +6,61 @@ exports.BetterSQLite3Adapter = void 0;
  */
 class BetterSQLite3Adapter {
     db;
+    queue = Promise.resolve();
     constructor(betterSqliteInstance) {
         this.db = betterSqliteInstance;
     }
     async execute(query, params = []) {
-        const trimmed = query.trim();
-        const stmt = this.db.prepare(trimmed);
-        // If query returns rows (SELECT, PRAGMA) or is marked as reader
-        if (stmt.reader || /^SELECT|^PRAGMA/i.test(trimmed)) {
-            return stmt.all(...params);
-        }
-        const info = stmt.run(...params);
-        return [info];
+        const run = async () => {
+            const trimmed = query.trim();
+            const stmt = this.db.prepare(trimmed);
+            // If query returns rows (SELECT, PRAGMA) or is marked as reader
+            if (stmt.reader || /^SELECT|^PRAGMA/i.test(trimmed)) {
+                return stmt.all(...params);
+            }
+            const info = stmt.run(...params);
+            return [info];
+        };
+        const next = this.queue.then(run, run);
+        this.queue = next.catch(() => { });
+        return await next;
     }
     async transaction(action) {
-        // Explicit transaction control compatible with async actions
-        this.db.prepare('BEGIN IMMEDIATE').run();
-        try {
-            const txWrapper = {
-                execute: async (q, p = []) => {
-                    return await this.execute(q, p);
-                },
-            };
-            const result = await action(txWrapper);
-            this.db.prepare('COMMIT').run();
-            return result;
-        }
-        catch (err) {
+        const run = async () => {
+            // Explicit transaction control compatible with async actions
+            this.db.prepare('BEGIN IMMEDIATE').run();
             try {
-                this.db.prepare('ROLLBACK').run();
+                const txWrapper = {
+                    execute: async (q, p = []) => {
+                        const trimmed = q.trim();
+                        const stmt = this.db.prepare(trimmed);
+                        if (stmt.reader || /^SELECT|^PRAGMA/i.test(trimmed)) {
+                            return stmt.all(...p);
+                        }
+                        return [stmt.run(...p)];
+                    },
+                };
+                const result = await action(txWrapper);
+                this.db.prepare('COMMIT').run();
+                return result;
             }
-            catch {
-                // Ignore secondary rollback error if connection closed
+            catch (err) {
+                try {
+                    this.db.prepare('ROLLBACK').run();
+                }
+                catch {
+                    // Ignore secondary rollback error if connection closed
+                }
+                throw err;
             }
-            throw err;
+        };
+        const next = this.queue.then(run, run);
+        this.queue = next.catch(() => { });
+        return await next;
+    }
+    close() {
+        if (typeof this.db.close === 'function') {
+            this.db.close();
         }
     }
 }

package/dist/adapters/local/expo-sqlite.d.ts

@@ -1,8 +1,12 @@
 import { LocalDBAdapter, LocalTransaction } from './index.js';
 export declare class ExpoSQLiteAdapter implements LocalDBAdapter {
     private db;
-    private txMutex;
+    private queue;
     constructor(expoDbInstance: any);
     execute(query: string, params?: any[]): Promise<any[]>;
     transaction<T>(action: (tx: LocalTransaction) => Promise<T>): Promise<T>;
+    /**
+     * Waits for pending queries/transactions to finish and closes the underlying SQLite database connection.
+     */
+    close(): Promise<void>;
 }

package/dist/adapters/local/expo-sqlite.js

@@ -3,28 +3,61 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExpoSQLiteAdapter = void 0;
 class ExpoSQLiteAdapter {
     db;
-    txMutex = Promise.resolve();
+    queue = Promise.resolve();
     constructor(expoDbInstance) {
         this.db = expoDbInstance;
     }
     async execute(query, params = []) {
-        return await this.db.getAllAsync(query, params);
+        const run = async () => {
+            const trimmed = query.trim();
+            const isSelect = /^SELECT\b/i.test(trimmed) || /^PRAGMA\b/i.test(trimmed);
+            // Parameterless DDL/write statements can bypass statement preparation
+            // to avoid NativeStatement SharedObject allocation race conditions on Android
+            if (!isSelect && (!params || params.length === 0) && typeof this.db.execAsync === 'function') {
+                await this.db.execAsync(query);
+                return [];
+            }
+            return await this.db.getAllAsync(query, params);
+        };
+        const next = this.queue.then(run, run);
+        this.queue = next.catch(() => { });
+        return await next;
     }
     async transaction(action) {
         const run = async () => {
             let result;
             await this.db.withTransactionAsync(async () => {
                 const txWrapper = {
-                    execute: async (q, p = []) => await this.db.getAllAsync(q, p)
+                    execute: async (q, p = []) => {
+                        const trimmed = q.trim();
+                        const isSelect = /^SELECT\b/i.test(trimmed) || /^PRAGMA\b/i.test(trimmed);
+                        if (!isSelect && (!p || p.length === 0) && typeof this.db.execAsync === 'function') {
+                            await this.db.execAsync(q);
+                            return [];
+                        }
+                        return await this.db.getAllAsync(q, p);
+                    }
                 };
                 result = await action(txWrapper);
             });
             return result;
         };
-        // Serialize transactions to prevent SQLite "cannot start a transaction within a transaction"
-        const currentTx = this.txMutex.then(run, run);
-        this.txMutex = currentTx.catch(() => { });
-        return await currentTx;
+        // Serialize transactions and queries to prevent SQLite concurrency crashes
+        const next = this.queue.then(run, run);
+        this.queue = next.catch(() => { });
+        return await next;
+    }
+    /**
+     * Waits for pending queries/transactions to finish and closes the underlying SQLite database connection.
+     */
+    async close() {
+        await this.queue;
+        if (typeof this.db.closeAsync === 'function') {
+            await this.db.closeAsync();
+        }
+        else if (typeof this.db.closeSync === 'function') {
+            this.db.closeSync();
+        }
     }
 }
 exports.ExpoSQLiteAdapter = ExpoSQLiteAdapter;

package/dist/adapters/local/index.d.ts

@@ -4,6 +4,7 @@ export interface LocalTransaction {
 export interface LocalDBAdapter {
     execute(query: string, params?: any[]): Promise<any[]>;
     transaction<T>(action: (tx: LocalTransaction) => Promise<T>): Promise<T>;
+    close?(): Promise<void> | void;
 }
 export * from './expo-sqlite.js';
 export * from './op-sqlite.js';

package/dist/adapters/local/node-sqlite.d.ts

@@ -18,7 +18,9 @@ export interface NodeSqliteDatabaseSync {
  */
 export declare class NodeSQLiteAdapter implements LocalDBAdapter {
     private db;
+    private queue;
     constructor(nodeSqliteDb: any);
     execute(query: string, params?: any[]): Promise<any[]>;
     transaction<T>(action: (tx: LocalTransaction) => Promise<T>): Promise<T>;
+    close(): void;
 }

package/dist/adapters/local/node-sqlite.js

@@ -7,37 +7,60 @@ exports.NodeSQLiteAdapter = void 0;
  */
 class NodeSQLiteAdapter {
     db;
+    queue = Promise.resolve();
     constructor(nodeSqliteDb) {
         this.db = nodeSqliteDb;
     }
     async execute(query, params = []) {
-        const trimmed = query.trim();
-        const stmt = this.db.prepare(trimmed);
-        // Queries that return rows (SELECT, PRAGMA)
-        if (/^SELECT|^PRAGMA/i.test(trimmed)) {
-            return stmt.all(...params);
-        }
-        const res = stmt.run(...params);
-        return [res];
+        const run = async () => {
+            const trimmed = query.trim();
+            const stmt = this.db.prepare(trimmed);
+            // Queries that return rows (SELECT, PRAGMA)
+            if (/^SELECT|^PRAGMA/i.test(trimmed)) {
+                return stmt.all(...params);
+            }
+            const res = stmt.run(...params);
+            return [res];
+        };
+        const next = this.queue.then(run, run);
+        this.queue = next.catch(() => { });
+        return await next;
     }
     async transaction(action) {
-        this.db.exec('BEGIN IMMEDIATE');
-        try {
-            const txWrapper = {
-                execute: async (q, p = []) => this.execute(q, p),
-            };
-            const result = await action(txWrapper);
-            this.db.exec('COMMIT');
-            return result;
-        }
-        catch (err) {
+        const run = async () => {
+            this.db.exec('BEGIN IMMEDIATE');
             try {
-                this.db.exec('ROLLBACK');
+                const txWrapper = {
+                    execute: async (q, p = []) => {
+                        const trimmed = q.trim();
+                        const stmt = this.db.prepare(trimmed);
+                        if (/^SELECT|^PRAGMA/i.test(trimmed)) {
+                            return stmt.all(...p);
+                        }
+                        return [stmt.run(...p)];
+                    },
+                };
+                const result = await action(txWrapper);
+                this.db.exec('COMMIT');
+                return result;
             }
-            catch {
-                // ignore rollback errors
+            catch (err) {
+                try {
+                    this.db.exec('ROLLBACK');
+                }
+                catch {
+                    // ignore rollback errors
+                }
+                throw err;
             }
-            throw err;
+        };
+        const next = this.queue.then(run, run);
+        this.queue = next.catch(() => { });
+        return await next;
+    }
+    close() {
+        if (typeof this.db.close === 'function') {
+            this.db.close();
         }
     }
 }

package/dist/adapters/local/op-sqlite.d.ts

@@ -23,4 +23,5 @@ export declare class OpSQLiteAdapter implements LocalDBAdapter {
     constructor(opSqliteInstance: any);
     execute(query: string, params?: any[]): Promise<any[]>;
     transaction<T>(action: (tx: LocalTransaction) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
 }

package/dist/adapters/local/op-sqlite.js

@@ -55,5 +55,11 @@ class OpSQLiteAdapter {
         this.txMutex = currentTx.catch(() => { });
         return await currentTx;
     }
+    async close() {
+        await this.txMutex;
+        if (typeof this.db.close === 'function') {
+            this.db.close();
+        }
+    }
 }
 exports.OpSQLiteAdapter = OpSQLiteAdapter;

package/dist/adapters/local/sql-js.d.ts

@@ -23,4 +23,5 @@ export declare class SqlJsAdapter implements LocalDBAdapter {
     constructor(sqlJsDatabase: any);
     execute(query: string, params?: any[]): Promise<any[]>;
     transaction<T>(action: (tx: LocalTransaction) => Promise<T>): Promise<T>;
+    close(): void;
 }

package/dist/adapters/local/sql-js.js

@@ -59,5 +59,10 @@ class SqlJsAdapter {
             throw err;
         }
     }
+    close() {
+        if (typeof this.db.close === 'function') {
+            this.db.close();
+        }
+    }
 }
 exports.SqlJsAdapter = SqlJsAdapter;

package/dist/adapters/network/index.js

@@ -7,6 +7,39 @@ class DefaultNetworkStatusProvider {
     cleanupBrowserListeners;
     constructor(initialOnline = true) {
         this._isOnline = initialOnline;
+        // 1. Try React Native NetInfo if available in environment
+        try {
+            const NetInfo = require('@react-native-community/netinfo');
+            const netInfoInstance = NetInfo?.default || NetInfo;
+            if (netInfoInstance && typeof netInfoInstance.addEventListener === 'function') {
+                netInfoInstance
+                    .fetch()
+                    .then((state) => {
+                    const online = state.isConnected === true &&
+                        (state.isInternetReachable === true || state.isInternetReachable === null);
+                    this.setOnline(online);
+                })
+                    .catch(() => { });
+                const unsub = netInfoInstance.addEventListener((state) => {
+                    const online = state.isConnected === true &&
+                        (state.isInternetReachable === true || state.isInternetReachable === null);
+                    this.setOnline(online);
+                });
+                this.cleanupBrowserListeners = () => {
+                    if (typeof unsub === 'function') {
+                        unsub();
+                    }
+                    else if (unsub && typeof unsub.remove === 'function') {
+                        unsub.remove();
+                    }
+                };
+                return;
+            }
+        }
+        catch {
+            // NetInfo not installed or running in node/web
+        }
+        // 2. Web DOM environment fallback
         if (typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
             if (typeof navigator !== 'undefined' && typeof navigator.onLine === 'boolean') {
                 this._isOnline = navigator.onLine;

package/dist/adapters/remote/convex.d.ts

@@ -1,5 +1,5 @@
 import { RemoteDBAdapter } from './index.js';
-import { DeltaChanges, SyncOperation } from '../../core/types.js';
+import { DeltaChanges, SyncOperation, PushResult } from '../../core/types.js';
 import { SyncLogger, CustomLogger, LogLevel } from '../../utils/logger.js';
 export interface ConvexRemoteAdapterOptions {
     /**
@@ -55,7 +55,7 @@ export declare class ConvexRemoteAdapter implements RemoteDBAdapter {
     /**
      * Pushes outbox operations as a batch mutation to Convex.
      */
-    pushChanges(operations: SyncOperation[]): Promise<boolean>;
+    pushChanges(operations: SyncOperation[]): Promise<boolean | PushResult>;
     /**
      * Fetches delta changes from Convex since a given timestamp.
      */

package/dist/adapters/remote/convex.js

@@ -23,18 +23,7 @@ class ConvexRemoteAdapter {
         this.pullQuery = options.pullQuery ?? 'sync:pullDeltas';
         this.deletedColumn = options.deletedColumn ?? 'deleted';
         this.updatedAtColumn = options.updatedAtColumn ?? 'updatedAt';
-        if (options.logger instanceof logger_js_1.SyncLogger) {
-            this.logger = options.logger;
-        }
-        else if (typeof options.logger === 'boolean') {
-            this.logger = new logger_js_1.SyncLogger({ enabled: options.logger, level: options.logLevel });
-        }
-        else if (options.logger && typeof options.logger === 'object') {
-            this.logger = new logger_js_1.SyncLogger({ customLogger: options.logger, level: options.logLevel });
-        }
-        else {
-            this.logger = options.logLevel ? new logger_js_1.SyncLogger({ level: options.logLevel }) : logger_js_1.defaultLogger;
-        }
+        this.logger = (0, logger_js_1.createSyncLogger)(options.logger, options.logLevel);
     }
     /**
      * Dynamically update tracked tables.
@@ -61,6 +50,13 @@ class ConvexRemoteAdapter {
             const res = await this.client.mutation(this.pushMutation, {
                 operations: payload,
             });
+            if (res && typeof res === 'object' && Array.isArray(res.failedIds)) {
+                return {
+                    success: res.failedIds.length === 0,
+                    failedIds: res.failedIds,
+                    errors: res.errors,
+                };
+            }
             return res !== false;
         }
         catch (error) {

package/dist/adapters/remote/demo.d.ts

@@ -12,7 +12,7 @@ export declare class MemoryDemoRemoteAdapter implements RemoteDBAdapter {
     constructor(simulatedLatencyMs?: number);
     pushChanges(operations: SyncOperation[]): Promise<boolean>;
     fetchChanges(_sinceTimestamp: number): Promise<DeltaChanges>;
-    subscribeToLiveChanges(callback: (changes: DeltaChanges) => void): void;
+    subscribeToLiveChanges(callback: (changes: DeltaChanges) => void): () => void;
     /**
      * Manually emit simulated server deltas to subscribers.
      */

package/dist/adapters/remote/demo.js

@@ -29,6 +29,9 @@ class MemoryDemoRemoteAdapter {
     }
     subscribeToLiveChanges(callback) {
         this.liveSubscribers.push(callback);
+        return () => {
+            this.liveSubscribers = this.liveSubscribers.filter((subscriber) => subscriber !== callback);
+        };
     }
     /**
      * Manually emit simulated server deltas to subscribers.

package/dist/adapters/remote/firestore.d.ts

@@ -1,5 +1,5 @@
 import { RemoteDBAdapter } from './index.js';
-import { DeltaChanges, SyncOperation } from '../../core/types.js';
+import { DeltaChanges, SyncOperation, PushResult } from '../../core/types.js';
 import { SyncLogger, CustomLogger, LogLevel } from '../../utils/logger.js';
 export interface FirestoreAdapterOptions {
     /**
@@ -47,8 +47,9 @@ export declare class FirestoreRemoteAdapter implements RemoteDBAdapter {
     /**
      * Pushes outbox operations as batch writes to Firestore.
      * Chunks operations into batches of 450 (below Firestore 500-write limit).
+     * Falls back to individual writes if a batch fails, returning partial push results.
      */
-    pushChanges(operations: SyncOperation[]): Promise<boolean>;
+    pushChanges(operations: SyncOperation[]): Promise<boolean | PushResult>;
     /**
      * Fetches delta changes across tracked collections where updatedAt > sinceTimestamp.
      */

package/dist/adapters/remote/firestore.js

@@ -43,18 +43,7 @@ class FirestoreRemoteAdapter {
         this.deletedColumn = options.deletedColumn ?? 'deleted';
         this.updatedAtColumn = options.updatedAtColumn ?? 'updatedAt';
         this.firestoreModule = options.firestoreModule;
-        if (options.logger instanceof logger_js_1.SyncLogger) {
-            this.logger = options.logger;
-        }
-        else if (typeof options.logger === 'boolean') {
-            this.logger = new logger_js_1.SyncLogger({ enabled: options.logger, level: options.logLevel });
-        }
-        else if (options.logger && typeof options.logger === 'object') {
-            this.logger = new logger_js_1.SyncLogger({ customLogger: options.logger, level: options.logLevel });
-        }
-        else {
-            this.logger = options.logLevel ? new logger_js_1.SyncLogger({ level: options.logLevel }) : logger_js_1.defaultLogger;
-        }
+        this.logger = (0, logger_js_1.createSyncLogger)(options.logger, options.logLevel);
     }
     setTables(tables) {
         this.tables = tables;
@@ -75,11 +64,14 @@ class FirestoreRemoteAdapter {
     /**
      * Pushes outbox operations as batch writes to Firestore.
      * Chunks operations into batches of 450 (below Firestore 500-write limit).
+     * Falls back to individual writes if a batch fails, returning partial push results.
      */
     async pushChanges(operations) {
         if (!operations || operations.length === 0) {
             return true;
         }
+        const failedIds = [];
+        const errors = {};
         try {
             const isCompat = typeof this.db.batch === 'function' && typeof this.db.collection === 'function';
             const mod = isCompat ? null : await this.getModule();
@@ -87,56 +79,87 @@ class FirestoreRemoteAdapter {
             for (let i = 0; i < operations.length; i += CHUNK_SIZE) {
                 const chunk = operations.slice(i, i + CHUNK_SIZE);
                 const now = Date.now();
+                const buildDocData = (op) => {
+                    if (op.operation === 'DELETE') {
+                        return {
+                            [this.primaryKey]: op.rowId,
+                            [this.deletedColumn]: true,
+                            [this.updatedAtColumn]: now,
+                        };
+                    }
+                    else {
+                        return {
+                            ...(op.payload || {}),
+                            [this.primaryKey]: op.rowId,
+                            [this.deletedColumn]: false,
+                            [this.updatedAtColumn]: now,
+                        };
+                    }
+                };
                 if (isCompat) {
                     // React Native Firebase / Compat SDK
-                    const batch = this.db.batch();
-                    for (const op of chunk) {
-                        const docRef = this.db.collection(op.tableName).doc(op.rowId);
-                        if (op.operation === 'DELETE') {
-                            batch.set(docRef, {
-                                [this.primaryKey]: op.rowId,
-                                [this.deletedColumn]: true,
-                                [this.updatedAtColumn]: now,
-                            }, { merge: true });
+                    try {
+                        const batch = this.db.batch();
+                        for (const op of chunk) {
+                            const docRef = this.db.collection(op.tableName).doc(op.rowId);
+                            batch.set(docRef, buildDocData(op), { merge: true });
                         }
-                        else {
-                            batch.set(docRef, {
-                                ...(op.payload || {}),
-                                [this.primaryKey]: op.rowId,
-                                [this.deletedColumn]: false,
-                                [this.updatedAtColumn]: now,
-                            }, { merge: true });
+                        await batch.commit();
+                    }
+                    catch (batchError) {
+                        this.logger.warn(`[Firestore] Batch write failed, falling back to per-document writes: ${batchError?.message || batchError}`);
+                        for (const op of chunk) {
+                            try {
+                                const docRef = this.db.collection(op.tableName).doc(op.rowId);
+                                await docRef.set(buildDocData(op), { merge: true });
+                            }
+                            catch (opErr) {
+                                failedIds.push(op.id);
+                                errors[op.id] = opErr?.message || String(opErr);
+                            }
                         }
                     }
-                    await batch.commit();
                 }
                 else if (mod && typeof mod.writeBatch === 'function') {
                     // Modular Firebase SDK
-                    const batch = mod.writeBatch(this.db);
-                    for (const op of chunk) {
-                        const docRef = mod.doc(mod.collection(this.db, op.tableName), op.rowId);
-                        if (op.operation === 'DELETE') {
-                            batch.set(docRef, {
-                                [this.primaryKey]: op.rowId,
-                                [this.deletedColumn]: true,
-                                [this.updatedAtColumn]: now,
-                            }, { merge: true });
+                    try {
+                        const batch = mod.writeBatch(this.db);
+                        for (const op of chunk) {
+                            const docRef = mod.doc(mod.collection(this.db, op.tableName), op.rowId);
+                            batch.set(docRef, buildDocData(op), { merge: true });
                         }
-                        else {
-                            batch.set(docRef, {
-                                ...(op.payload || {}),
-                                [this.primaryKey]: op.rowId,
-                                [this.deletedColumn]: false,
-                                [this.updatedAtColumn]: now,
-                            }, { merge: true });
+                        await batch.commit();
+                    }
+                    catch (batchError) {
+                        this.logger.warn(`[Firestore] Batch write failed, falling back to per-document writes: ${batchError?.message || batchError}`);
+                        for (const op of chunk) {
+                            try {
+                                const docRef = mod.doc(mod.collection(this.db, op.tableName), op.rowId);
+                                if (typeof mod.setDoc === 'function') {
+                                    await mod.setDoc(docRef, buildDocData(op), { merge: true });
+                                }
+                                else {
+                                    throw batchError;
+                                }
+                            }
+                            catch (opErr) {
+                                failedIds.push(op.id);
+                                errors[op.id] = opErr?.message || String(opErr);
+                            }
                         }
                     }
-                    await batch.commit();
                 }
                 else {
                     throw new Error('Firestore client does not have .batch() and modular firebase/firestore writeBatch could not be loaded.');
                 }
             }
+            if (failedIds.length > 0) {
+                return {
+                    success: false,
+                    failedIds,
+                    errors,
+                };
+            }
             return true;
         }
         catch (error) {

package/dist/adapters/remote/index.d.ts

@@ -1,8 +1,10 @@
-import { SyncOperation, DeltaChanges } from '../../core/types.js';
+import { SyncOperation, DeltaChanges, PushResult } from '../../core/types.js';
 export interface RemoteDBAdapter {
-    pushChanges(operations: SyncOperation[]): Promise<boolean>;
-    fetchChanges(sinceTimestamp: number): Promise<DeltaChanges>;
-    subscribeToLiveChanges(callback: (changes: DeltaChanges) => void): void;
+    pushChanges(operations: SyncOperation[]): Promise<boolean | PushResult>;
+    /** Return a complete batch through timestamp; reject on partial failure. Supports optional scope for data filtering. */
+    fetchChanges(sinceTimestamp: number, scope?: Record<string, any>): Promise<DeltaChanges>;
+    /** Live events do not advance the durable pull checkpoint. Return cleanup when supported. */
+    subscribeToLiveChanges(callback: (changes: DeltaChanges) => void): void | (() => void);
 }
 export * from './supabase.js';
 export * from './demo.js';