nexabase-console 2.1.3 → 2.1.5

package/dist/app/NexaApp.d.ts

@@ -36,6 +36,7 @@ export declare class NexaApp {
     _activeQueryTimestamps: Map<string, number>;
     constructor(config: NexaConfig);
     get _firestoreCache(): Record<string, any>;
+    private _setupVisibilityResync;
     private _setupCrossTabSync;
     _broadcastLocalMutation(path: string, action: string, data?: any): void;
     getPendingWritesCount(): number;
@@ -92,7 +93,7 @@ export declare class NexaApp {
     _ensureFirestoreWebSocket(): void;
     _closeFirestoreSSEIfIdle(): void;
     _closeFirestoreWebSocketIfIdle(): void;
-    _notifySnapshotCallbacks(path: string, actionType: string, payload: any): void;
+    _notifySnapshotCallbacks(path: string, actionType: string, payload?: any): void;
     signInWithEmailAndPassword(email: string, password: string): Promise<AuthSession>;
     createUserWithEmailAndPassword(email: string, password: string, name?: string): Promise<AuthSession>;
     sendOtp(email: string): Promise<{

package/dist/app/NexaApp.js

@@ -46,23 +46,51 @@ class NexaApp {
         this.mutationQueue = new MutationQueue_1.MutationQueue(this.projectId, this.indexedDB, this.client);
         this.syncEngine = new SyncEngine_1.SyncEngine(this.projectId, this.mutationQueue, this.sseClient);
         // Realtime & Storage
-        const realtimeConn = new RealtimeConnection_1.RealtimeConnection(this.sseClient);
+        const realtimeConn = new RealtimeConnection_1.RealtimeConnection(this.sseClient, this.wsClient);
         this.realtimeDatabase = new RealtimeDatabase_1.RealtimeDatabase(this.projectId, this.client, realtimeConn);
         this.storage = new Storage_1.Storage(this.projectId, this.client);
         this._setupCrossTabSync();
+        this._setupVisibilityResync();
     }
     get _firestoreCache() {
         return this.localStore.getMemoryCache();
     }
+    _setupVisibilityResync() {
+        if (typeof document !== 'undefined' && typeof document.addEventListener === 'function') {
+            document.addEventListener('visibilitychange', () => {
+                if (document.visibilityState === 'visible') {
+                    // Re-ensure SSE and WS when coming back from background
+                    if (this._firestoreListening) {
+                        if (this.wsClient && typeof this.wsClient.ensureConnected === 'function') {
+                            this.wsClient.ensureConnected();
+                        }
+                        if (this.sseClient && typeof this.sseClient.ensureConnected === 'function') {
+                            this.sseClient.ensureConnected();
+                        }
+                        // Notify server that we need latest changes by simulating subscribe again for each path?
+                        // wsClient handles this on resync event.
+                    }
+                    // Optionally sync offline queue
+                    this._syncOfflineQueue().catch(console.error);
+                }
+            });
+        }
+    }
     _setupCrossTabSync() {
         this.syncEngine.listenCrossTab((path, action, data) => {
+            const cleanPath = path.replace(/^\/+|\/+$/g, '');
             if (action === 'delete') {
-                this.localStore.delete(path);
+                this.localStore.delete(cleanPath);
             }
             else if (data) {
-                this.localStore.set(path, data);
+                this.localStore.set(cleanPath, data);
+            }
+            this._notifySnapshotCallbacks(cleanPath, action === 'delete' ? 'document_deleted' : 'document_written', data);
+            const parts = cleanPath.split('/');
+            const colPath = parts.length > 1 ? parts.slice(0, -1).join('/') : '';
+            if (colPath) {
+                this._notifySnapshotCallbacks(colPath, action === 'delete' ? 'document_deleted' : 'document_written', data);
             }
-            this._notifySnapshotCallbacks(path, action === 'delete' ? 'document_deleted' : 'document_written', data);
         });
     }
     _broadcastLocalMutation(path, action, data) {
@@ -366,34 +394,44 @@ class NexaApp {
         const targetDocPath = docPath || rawPath;
         const isDelete = type === 'document_deleted' || action === 'delete' || type === 'delete';
         if (targetDocPath && typeof targetDocPath === 'string') {
+            const cleanDocPath = targetDocPath.replace(/^\/+|\/+$/g, '');
             if (isDelete) {
-                this._deleteCache(targetDocPath);
+                this._deleteCache(cleanDocPath);
             }
-            else if (data) {
-                this._setCache(targetDocPath, data);
+            else if (data !== undefined && data !== null) {
+                this._setCache(cleanDocPath, data);
             }
-            const parts = targetDocPath.split('/');
+            const parts = cleanDocPath.split('/');
             const colPath = parts.length > 1 ? parts.slice(0, -1).join('/') : '';
-            this._notifySnapshotCallbacks(targetDocPath, isDelete ? 'document_deleted' : 'document_written', data);
+            this._notifySnapshotCallbacks(cleanDocPath, isDelete ? 'document_deleted' : 'document_written', data);
             if (colPath) {
                 this._notifySnapshotCallbacks(colPath, isDelete ? 'document_deleted' : 'document_written', data);
             }
         }
         else if (collectionPath && typeof collectionPath === 'string') {
-            this._notifySnapshotCallbacks(collectionPath, 'server_update', data);
+            const cleanColPath = collectionPath.replace(/^\/+|\/+$/g, '');
+            this._notifySnapshotCallbacks(cleanColPath, 'server_update', data);
         }
     }
     _ensureFirestoreSSE() {
         if (this._firestoreListening)
             return;
         this._firestoreListening = true;
+        // Listen to WebSocketClient
         const unsub1 = this.wsClient.addListener('data_changed', (payload) => {
             this._handleServerFirestoreChange(payload);
         });
         const unsub2 = this.wsClient.addListener('firestore_changed', (payload) => {
             this._handleServerFirestoreChange(payload);
         });
-        this._firestoreUnsubscribes.push(unsub1, unsub2);
+        // Also listen to SSEClient
+        const unsub3 = this.sseClient.addListener('data_changed', (payload) => {
+            this._handleServerFirestoreChange(payload);
+        });
+        const unsub4 = this.sseClient.addListener('firestore_changed', (payload) => {
+            this._handleServerFirestoreChange(payload);
+        });
+        this._firestoreUnsubscribes.push(unsub1, unsub2, unsub3, unsub4);
     }
     _ensureFirestoreWebSocket() {
         this._ensureFirestoreSSE();
@@ -411,14 +449,28 @@ class NexaApp {
     _notifySnapshotCallbacks(path, actionType, payload) {
         if (!path || typeof path !== 'string')
             return;
-        Object.keys(this._snapshotCallbacks).forEach((cbKey) => {
-            const parts = cbKey.split('_');
-            const targetPath = parts.slice(2).join('_');
-            if (cbKey.startsWith('document_') && targetPath === path) {
-                this._snapshotCallbacks[cbKey](payload);
+        const cleanPath = path.replace(/^\/+|\/+$/g, '');
+        Object.entries(this._snapshotCallbacks).forEach(([cbKey, callback]) => {
+            let type = '';
+            let targetPath = '';
+            if (cbKey.includes('::')) {
+                const parts = cbKey.split('::');
+                type = parts[0];
+                targetPath = parts.slice(2).join('::');
+            }
+            else {
+                const firstUnderscore = cbKey.indexOf('_');
+                const lastUnderscore = cbKey.lastIndexOf('_');
+                type = cbKey.substring(0, firstUnderscore);
+                targetPath = cbKey.substring(lastUnderscore + 1);
+            }
+            const cleanTargetPath = (targetPath || '').replace(/^\/+|\/+$/g, '');
+            if (type === 'document' && cleanTargetPath === cleanPath) {
+                callback(payload);
             }
-            else if ((cbKey.startsWith('collection_') || cbKey.startsWith('query_')) && (path.startsWith(targetPath + '/') || path === targetPath)) {
-                this._snapshotCallbacks[cbKey](payload);
+            else if ((type === 'collection' || type === 'query') &&
+                (cleanPath === cleanTargetPath || cleanPath.startsWith(cleanTargetPath + '/'))) {
+                callback(payload);
             }
         });
     }

package/dist/firestore/Snapshot.js

@@ -79,9 +79,9 @@ const onSnapshot = (ref, callback) => {
     }
     const db = ref.db;
     let active = true;
-    const pathKey = ref.path;
+    const pathKey = ref.path.replace(/^\/+|\/+$/g, '');
     const listenerId = `${Date.now()}_${Math.random().toString(36).slice(2)}_${++listenerSequence}`;
-    const keyToClean = `${ref.type}_${listenerId}_${pathKey}`;
+    const keyToClean = `${ref.type}::${listenerId}::${pathKey}`;
     let isInitial = true;
     let lastData = undefined;
     let lastDocsForChanges = [];
@@ -115,13 +115,11 @@ const onSnapshot = (ref, callback) => {
     };
     db._snapshotCallbacks[keyToClean] = triggerCallback;
     triggerCallback();
-    // Unified transport coordination: Prefer WebSocket if available, otherwise SSE
+    // Unified transport coordination: Always ensure listening on change events & subscribe path
+    db._ensureFirestoreWebSocket();
     if (db.wsClient && typeof db.wsClient.subscribe === 'function') {
         db.wsClient.subscribe(ref.path);
     }
-    else {
-        db._ensureFirestoreSSE();
-    }
     (async () => {
         if (db._initPromise)
             await db._initPromise;

package/dist/firestore/writes.js

@@ -48,14 +48,20 @@ const normalizeError = (error) => {
     };
 };
 const safelyNotifyMutation = (db, path, action, data, metadata) => {
+    const cleanPath = path.replace(/^\/+|\/+$/g, '');
     try {
-        db._broadcastLocalMutation(path, action, data, metadata);
+        db._broadcastLocalMutation(cleanPath, action, data, metadata);
     }
     catch (e) {
         console.error('[NexaBase] Listener error:', e);
     }
     try {
-        db._notifySnapshotCallbacks(path, action === 'delete' ? 'document_deleted' : 'document_written', data, metadata);
+        db._notifySnapshotCallbacks(cleanPath, action === 'delete' ? 'document_deleted' : 'document_written', data, metadata);
+        const parts = cleanPath.split('/');
+        const colPath = parts.length > 1 ? parts.slice(0, -1).join('/') : '';
+        if (colPath) {
+            db._notifySnapshotCallbacks(colPath, action === 'delete' ? 'document_deleted' : 'document_written', data, metadata);
+        }
     }
     catch (e) {
         console.error('[NexaBase] Listener error:', e);

package/dist/realtime/RealtimeConnection.d.ts

@@ -1,7 +1,8 @@
-import { SSEClient } from '../transport/SSEClient';
+import { SSEClient, WebSocketClient } from '../transport/SSEClient';
 export declare class RealtimeConnection {
     private sseClient;
-    constructor(sseClient: SSEClient);
+    private wsClient?;
+    constructor(sseClient: SSEClient, wsClient?: WebSocketClient);
     subscribeToPath(path: string, callback: (value: any) => void): () => void;
     close(): void;
 }

package/dist/realtime/RealtimeConnection.js

@@ -2,15 +2,40 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RealtimeConnection = void 0;
 class RealtimeConnection {
-    constructor(sseClient) {
+    constructor(sseClient, wsClient) {
         this.sseClient = sseClient;
+        this.wsClient = wsClient;
     }
     subscribeToPath(path, callback) {
-        return this.sseClient.addListener('data_changed', (payload) => {
-            if (payload && payload.path === path) {
-                callback(payload.value);
+        const cleanPath = (path || '').replace(/^\/+|\/+$/g, '');
+        if (this.wsClient && typeof this.wsClient.subscribe === 'function') {
+            this.wsClient.subscribe(cleanPath);
+        }
+        const unsubWS = this.wsClient
+            ? this.wsClient.addListener('data_changed', (payload) => {
+                if (payload) {
+                    const p = (payload.path || payload.docPath || '').replace(/^\/+|\/+$/g, '');
+                    if (p === cleanPath) {
+                        callback(payload.value !== undefined ? payload.value : payload.data);
+                    }
+                }
+            })
+            : () => { };
+        const unsubSSE = this.sseClient.addListener('data_changed', (payload) => {
+            if (payload) {
+                const p = (payload.path || payload.docPath || '').replace(/^\/+|\/+$/g, '');
+                if (p === cleanPath) {
+                    callback(payload.value !== undefined ? payload.value : payload.data);
+                }
             }
         });
+        return () => {
+            unsubWS();
+            unsubSSE();
+            if (this.wsClient && typeof this.wsClient.unsubscribe === 'function') {
+                this.wsClient.unsubscribe(cleanPath);
+            }
+        };
     }
     close() {
         this.sseClient.close();

package/dist/transport/WebSocketClient.js

@@ -1882,6 +1882,7 @@ class WebSocketClient {
                 return;
             }
             if (document.visibilityState === 'visible') {
+                this.dispatch('resync', { reason: 'visibility_change' });
                 if (!this.isLeader && this._coordinationMode === 'shared') {
                     this.postBroadcast('follower_heartbeat', {
                         globalListenersCount: this.getGlobalListenersCount(),
@@ -1893,6 +1894,9 @@ class WebSocketClient {
                     });
                     this.postBroadcast('follower_sync_request');
                 }
+                if (this.isLeader && this._socket && !this._socket.connected) {
+                    this._socket.connect();
+                }
                 if (this.hasLocalNeeds() && this._state === 'idle') {
                     this.ensureConnected();
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexabase-console",
-  "version": "2.1.3",
+  "version": "2.1.5",
   "description": "SDK Client resmi untuk NexaBase: Platform Sinkronisasi NoSQL, Realtime, File Storage, & Autentikasi Offline-First.",
   "main": "dist/index.cjs",
   "module": "dist/index.js",