nexabase-console 2.0.6 → 2.0.7

package/dist/app/NexaApp.d.ts

@@ -1,7 +1,7 @@
 import { AxiosInstance } from 'axios';
 import { NexaConfig, DatabaseReference, StorageReference, UploadOptions, OfflineJob } from '../types/index';
 import { HttpClient } from '../transport/HttpClient';
-import { SSEClient } from '../transport/SSEClient';
+import { SSEClient, WebSocketClient } from '../transport/SSEClient';
 import { Auth } from '../auth/Auth';
 import { User as AuthUser, AuthSession } from '../auth/authTypes';
 import { IndexedDB } from '../persistence/IndexedDB';
@@ -18,6 +18,7 @@ export declare class NexaApp {
     cacheStrategy: 'network-first' | 'cache-first';
     httpClient: HttpClient;
     client: AxiosInstance;
+    wsClient: WebSocketClient;
     sseClient: SSEClient;
     authService: Auth;
     indexedDB: IndexedDB;
@@ -43,7 +44,9 @@ export declare class NexaApp {
     _addOfflineJob(job: OfflineJob): Promise<void>;
     _syncOfflineQueue(): Promise<void>;
     _ensureFirestoreSSE(): void;
+    _ensureFirestoreWebSocket(): void;
     _closeFirestoreSSEIfIdle(): void;
+    _closeFirestoreWebSocketIfIdle(): 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>;
@@ -61,4 +64,6 @@ export declare class NexaApp {
         path: string;
     }>;
     getDownloadURL(path: string): Promise<string>;
+    isConnected(): boolean;
+    onConnectionStateChanged(callback: (isConnected: boolean) => void): () => void;
 }

package/dist/app/NexaApp.js

@@ -31,6 +31,7 @@ class NexaApp {
         // Transport
         this.httpClient = new HttpClient_1.HttpClient(this.endpoint, () => (this.authService ? this.authService.getToken() : this.token), this.projectId, this.token);
         this.client = this.httpClient.getAxiosInstance();
+        this.wsClient = new SSEClient_1.WebSocketClient(this.projectId, this.endpoint);
         this.sseClient = new SSEClient_1.SSEClient(this.projectId, this.endpoint);
         // Auth & Persistence
         this.authService = new Auth_1.Auth(this.projectId, this.client, this.token);
@@ -77,6 +78,7 @@ class NexaApp {
         try {
             await this.indexedDB.init();
             await this.localStore.loadAll();
+            await this.localStore.garbageCollect(1000); // 1000 docs limit
             await this.mutationQueue.init();
             if (typeof window !== 'undefined') {
                 window.addEventListener('online', () => this._syncOfflineQueue());
@@ -103,7 +105,7 @@ class NexaApp {
         if (this._firestoreListening)
             return;
         this._firestoreListening = true;
-        const unsub1 = this.sseClient.addListener('data_changed', (payload) => {
+        const unsub1 = this.wsClient.addListener('data_changed', (payload) => {
             if (payload && payload.path) {
                 if (payload.action === 'delete') {
                     this._deleteCache(payload.path);
@@ -114,11 +116,14 @@ class NexaApp {
                 this._notifySnapshotCallbacks(payload.path, payload.action === 'delete' ? 'document_deleted' : 'document_written', payload.data);
             }
         });
-        const unsub2 = this.sseClient.addListener('firestore_changed', (payload) => {
+        const unsub2 = this.wsClient.addListener('firestore_changed', (payload) => {
             this._notifySnapshotCallbacks(payload.collectionPath || payload.docPath, 'server_update', payload.data);
         });
         this._firestoreUnsubscribes.push(unsub1, unsub2);
     }
+    _ensureFirestoreWebSocket() {
+        this._ensureFirestoreSSE();
+    }
     _closeFirestoreSSEIfIdle() {
         if (Object.keys(this._snapshotCallbacks).length === 0) {
             this._firestoreUnsubscribes.forEach((unsub) => unsub());
@@ -126,6 +131,9 @@ class NexaApp {
             this._firestoreListening = false;
         }
     }
+    _closeFirestoreWebSocketIfIdle() {
+        this._closeFirestoreSSEIfIdle();
+    }
     _notifySnapshotCallbacks(path, actionType, payload) {
         Object.keys(this._snapshotCallbacks).forEach((cbKey) => {
             const parts = cbKey.split('_');
@@ -180,5 +188,37 @@ class NexaApp {
     async getDownloadURL(path) {
         return this.storage.getDownloadURL(path);
     }
+    isConnected() {
+        return this.wsClient.isConnected;
+    }
+    onConnectionStateChanged(callback) {
+        let lastState = this.isConnected();
+        callback(lastState);
+        // Make sure socket is created and connected if it isn't already
+        this.wsClient.ensureConnected();
+        const unsubOpen = this.wsClient.addListener('open', () => {
+            if (!lastState) {
+                lastState = true;
+                callback(true);
+            }
+        });
+        const unsubClose = this.wsClient.addListener('close', () => {
+            if (lastState) {
+                lastState = false;
+                callback(false);
+            }
+        });
+        const unsubError = this.wsClient.addListener('error', () => {
+            if (lastState) {
+                lastState = false;
+                callback(false);
+            }
+        });
+        return () => {
+            unsubOpen();
+            unsubClose();
+            unsubError();
+        };
+    }
 }
 exports.NexaApp = NexaApp;

package/dist/firestore/writes.js

@@ -11,26 +11,21 @@ const setDoc = async (docRef, data, options) => {
         await db._initPromise;
     const existingData = options?.merge ? db._firestoreCache[docRef.path] || {} : {};
     const finalData = (0, helpers_1.applyDataTransforms)(existingData, data);
-    await db._setCache(docRef.path, finalData);
-    db._broadcastLocalMutation(docRef.path, 'set', finalData);
-    db._notifySnapshotCallbacks(docRef.path, 'document_written', finalData);
     const key = options?.idempotencyKey || (0, helpers_1.generateIdempotencyKey)();
     const jobId = Math.random().toString(36).substring(2, 9);
     const isOnline = typeof navigator !== 'undefined' ? navigator.onLine : true;
+    db.markInflight(docRef.path);
+    await db._setCache(docRef.path, finalData);
+    db._broadcastLocalMutation(docRef.path, 'set', finalData);
+    db._notifySnapshotCallbacks(docRef.path, 'document_written', finalData);
     if (!isOnline) {
+        db.unmarkInflight(docRef.path);
         await db._addOfflineJob({
-            id: jobId,
-            type: 'set',
-            path: docRef.path,
-            data,
-            idempotencyKey: key,
-            merge: options?.merge,
-            state: 'pending'
+            id: jobId, type: 'set', path: docRef.path, data, idempotencyKey: key, merge: options?.merge, state: 'pending'
         });
         return { success: true, message: 'Offline: Tersimpan di cache lokal' };
     }
     else {
-        db.markInflight(docRef.path);
         try {
             const res = (await db.client.post(`/api/firestore/${db.projectId}/document`, { docPath: docRef.path, data, idempotencyKey: key, merge: options?.merge }, { headers: { 'X-Idempotency-Key': key } })).data;
             return res;
@@ -62,13 +57,15 @@ const patchDoc = async (docRef, data, options) => {
         await db._initPromise;
     const existingData = db._firestoreCache[docRef.path] || {};
     const finalData = (0, helpers_1.applyDataTransforms)(existingData, data);
-    await db._setCache(docRef.path, finalData);
-    db._broadcastLocalMutation(docRef.path, 'patch', finalData);
-    db._notifySnapshotCallbacks(docRef.path, 'document_written', finalData);
     const key = options?.idempotencyKey || (0, helpers_1.generateIdempotencyKey)();
     const jobId = Math.random().toString(36).substring(2, 9);
     const isOnline = typeof navigator !== 'undefined' ? navigator.onLine : true;
+    db.markInflight(docRef.path);
+    await db._setCache(docRef.path, finalData);
+    db._broadcastLocalMutation(docRef.path, 'patch', finalData);
+    db._notifySnapshotCallbacks(docRef.path, 'document_written', finalData);
     if (!isOnline) {
+        db.unmarkInflight(docRef.path);
         await db._addOfflineJob({
             id: jobId,
             type: 'patch',
@@ -113,13 +110,15 @@ const deleteDoc = async (docRef, options) => {
     const db = docRef.db;
     if (db._initPromise)
         await db._initPromise;
-    await db._deleteCache(docRef.path);
-    db._broadcastLocalMutation(docRef.path, 'delete');
-    db._notifySnapshotCallbacks(docRef.path, 'document_deleted', null);
     const key = options?.idempotencyKey || (0, helpers_1.generateIdempotencyKey)();
     const jobId = Math.random().toString(36).substring(2, 9);
     const isOnline = typeof navigator !== 'undefined' ? navigator.onLine : true;
+    db.markInflight(docRef.path);
+    await db._deleteCache(docRef.path);
+    db._broadcastLocalMutation(docRef.path, 'delete');
+    db._notifySnapshotCallbacks(docRef.path, 'document_deleted', null);
     if (!isOnline) {
+        db.unmarkInflight(docRef.path);
         await db._addOfflineJob({
             id: jobId,
             type: 'delete',

package/dist/index.d.ts

@@ -30,6 +30,10 @@ export * from './sync/SyncEngine';
 export * from './sync/ConflictResolver';
 export * from './transport/HttpClient';
 export * from './transport/SSEClient';
+export * from './transport/WebSocketClient';
 export * from './errors/NexaError';
 export * from './types/index';
 export * from './utils/helpers';
+export * from './storage/types';
+export * from './storage/NexaStorageError';
+export { connectStorageEmulator } from './storage/Storage';

package/dist/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectStorageEmulator = void 0;
 // App
 __exportStar(require("./app/initializeApp"), exports);
 __exportStar(require("./app/NexaApp"), exports);
@@ -54,7 +55,12 @@ __exportStar(require("./sync/ConflictResolver"), exports);
 // Transport
 __exportStar(require("./transport/HttpClient"), exports);
 __exportStar(require("./transport/SSEClient"), exports);
+__exportStar(require("./transport/WebSocketClient"), exports);
 // Errors & Types
 __exportStar(require("./errors/NexaError"), exports);
 __exportStar(require("./types/index"), exports);
 __exportStar(require("./utils/helpers"), exports);
+__exportStar(require("./storage/types"), exports);
+__exportStar(require("./storage/NexaStorageError"), exports);
+var Storage_1 = require("./storage/Storage");
+Object.defineProperty(exports, "connectStorageEmulator", { enumerable: true, get: function () { return Storage_1.connectStorageEmulator; } });

package/dist/persistence/LocalStore.d.ts

@@ -9,4 +9,5 @@ export declare class LocalStore {
     get(path: string): Promise<any>;
     delete(path: string): Promise<void>;
     loadAll(): Promise<Record<string, any>>;
+    garbageCollect(maxItems?: number): Promise<void>;
 }

package/dist/persistence/LocalStore.js

@@ -74,5 +74,48 @@ class LocalStore {
             req.onerror = () => reject(req.error);
         });
     }
+    // LRU Cache Garbage Collection (Max size 5000 items)
+    async garbageCollect(maxItems = 5000) {
+        const db = this.indexedDB.getRawDB();
+        if (!db)
+            return;
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction('offline_cache', 'readwrite');
+            const store = tx.objectStore('offline_cache');
+            const req = store.getAll();
+            req.onsuccess = () => {
+                const items = req.result;
+                if (items.length > maxItems) {
+                    // Sort by timestamp (oldest first)
+                    items.sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));
+                    const itemsToRemove = items.slice(0, items.length - maxItems);
+                    if (itemsToRemove.length === 0) {
+                        return resolve();
+                    }
+                    let removedCount = 0;
+                    itemsToRemove.forEach((item) => {
+                        const delReq = store.delete(item.path);
+                        delReq.onsuccess = () => {
+                            delete this.inMemoryCache[item.path];
+                            removedCount++;
+                            if (removedCount === itemsToRemove.length) {
+                                resolve();
+                            }
+                        };
+                        delReq.onerror = () => {
+                            removedCount++;
+                            if (removedCount === itemsToRemove.length) {
+                                resolve();
+                            }
+                        };
+                    });
+                }
+                else {
+                    resolve();
+                }
+            };
+            req.onerror = () => reject(req.error);
+        });
+    }
 }
 exports.LocalStore = LocalStore;

package/dist/transport/SSEClient.d.ts

@@ -1,15 +1,16 @@
+import { WebSocketClient } from './WebSocketClient';
 export declare class SSEClient {
-    private projectId;
-    private sseUrl;
-    private sse;
-    private isListening;
-    private listeners;
+    private wsClient;
     constructor(projectId: string, sseUrl: string);
     addListener(event: string, callback: (data: any) => void): () => void;
+    subscribe(path: string): void;
+    unsubscribe(path: string): void;
     ensureConnected(): void;
     checkCloseConnection(): void;
     hasListeners(): boolean;
     dispatch(event: string, data: any): void;
+    send(event: string, data: any): Promise<any>;
     close(): void;
 }
 export { SSEClient as SSEManager };
+export { WebSocketClient };

package/dist/transport/SSEClient.js

@@ -1,95 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SSEManager = exports.SSEClient = void 0;
+exports.WebSocketClient = exports.SSEManager = exports.SSEClient = void 0;
+const WebSocketClient_1 = require("./WebSocketClient");
+Object.defineProperty(exports, "WebSocketClient", { enumerable: true, get: function () { return WebSocketClient_1.WebSocketClient; } });
 class SSEClient {
     constructor(projectId, sseUrl) {
-        this.sse = null;
-        this.isListening = false;
-        this.listeners = new Map();
-        this.projectId = projectId;
-        this.sseUrl = sseUrl;
+        this.wsClient = new WebSocketClient_1.WebSocketClient(projectId, sseUrl);
     }
     addListener(event, callback) {
-        if (!this.listeners.has(event)) {
-            this.listeners.set(event, new Set());
-        }
-        this.listeners.get(event).add(callback);
-        this.ensureConnected();
-        return () => {
-            const callbacks = this.listeners.get(event);
-            if (callbacks) {
-                callbacks.delete(callback);
-                if (callbacks.size === 0) {
-                    this.listeners.delete(event);
-                }
-            }
-            this.checkCloseConnection();
-        };
+        return this.wsClient.addListener(event, callback);
+    }
+    subscribe(path) {
+        this.wsClient.subscribe(path);
+    }
+    unsubscribe(path) {
+        this.wsClient.unsubscribe(path);
     }
     ensureConnected() {
-        if (this.isListening || typeof window === 'undefined')
-            return;
-        this.isListening = true;
-        this.sse = new EventSource(`${this.sseUrl}/api/firestore/${this.projectId}/sse`);
-        this.sse.onopen = () => {
-            this.dispatch('open', null);
-        };
-        this.sse.onmessage = (event) => {
-            try {
-                const payload = JSON.parse(event.data);
-                this.dispatch(payload.event || 'message', payload.data || payload);
-                this.dispatch('all', payload);
-            }
-            catch (e) {
-                console.error('[SSEClient] Error parsing SSE payload:', e);
-            }
-        };
-        this.sse.onerror = (err) => {
-            this.dispatch('error', err);
-            if (this.sse) {
-                this.sse.close();
-                this.sse = null;
-            }
-            this.isListening = false;
-            if (this.hasListeners()) {
-                setTimeout(() => this.ensureConnected(), 3000);
-            }
-        };
+        this.wsClient.ensureConnected();
     }
     checkCloseConnection() {
-        if (!this.hasListeners() && this.sse) {
-            this.sse.close();
-            this.sse = null;
-            this.isListening = false;
-        }
+        this.wsClient.checkCloseConnection();
     }
     hasListeners() {
-        let count = 0;
-        this.listeners.forEach((set) => {
-            count += set.size;
-        });
-        return count > 0;
+        return this.wsClient.hasListeners();
     }
     dispatch(event, data) {
-        const callbacks = this.listeners.get(event);
-        if (callbacks) {
-            callbacks.forEach((cb) => {
-                try {
-                    cb(data);
-                }
-                catch (e) {
-                    console.error(`[SSEClient] Error in listener for event ${event}:`, e);
-                }
-            });
-        }
+        this.wsClient.dispatch(event, data);
+    }
+    send(event, data) {
+        return this.wsClient.send(event, data);
     }
     close() {
-        if (this.sse) {
-            this.sse.close();
-            this.sse = null;
-        }
-        this.isListening = false;
-        this.listeners.clear();
+        this.wsClient.close();
     }
 }
 exports.SSEClient = SSEClient;

package/dist/transport/WebSocketClient.d.ts

@@ -0,0 +1,24 @@
+export declare class WebSocketClient {
+    private projectId;
+    private serverUrl;
+    private socket;
+    isConnected: boolean;
+    private listeners;
+    private subscribedPaths;
+    private broadcastChannel;
+    private isLeader;
+    private hasInitialized;
+    constructor(projectId: string, serverUrl: string);
+    private handleBroadcastMessage;
+    addListener(event: string, callback: (data: any) => void): () => void;
+    subscribe(path: string): void;
+    unsubscribe(path: string): void;
+    private broadcastToFollowers;
+    ensureConnected(): void;
+    private startSocketConnection;
+    send(event: string, data: any): Promise<any>;
+    checkCloseConnection(): void;
+    hasListeners(): boolean;
+    dispatch(event: string, data: any): void;
+    close(): void;
+}

package/dist/transport/WebSocketClient.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClient = void 0;
+const socket_io_client_1 = require("socket.io-client");
+class WebSocketClient {
+    constructor(projectId, serverUrl) {
+        this.socket = null;
+        this.isConnected = false;
+        this.listeners = new Map();
+        this.subscribedPaths = new Set();
+        // Cross-tab sync properties
+        this.broadcastChannel = null;
+        this.isLeader = false;
+        this.hasInitialized = false;
+        this.projectId = projectId;
+        this.serverUrl = serverUrl;
+        if (typeof window !== 'undefined' && 'BroadcastChannel' in window) {
+            this.broadcastChannel = new BroadcastChannel(`nexabase_ws_${projectId}`);
+            this.broadcastChannel.onmessage = this.handleBroadcastMessage.bind(this);
+        }
+    }
+    handleBroadcastMessage(event) {
+        const { type, payload } = event.data;
+        if (this.isLeader) {
+            if (type === 'follower_subscribe') {
+                this.socket?.emit('subscribe', this.projectId, payload.path);
+            }
+            else if (type === 'follower_unsubscribe') {
+                this.socket?.emit('unsubscribe', this.projectId, payload.path);
+            }
+            else if (type === 'follower_sync_request') {
+                this.broadcastChannel?.postMessage({ type: 'leader_state', payload: { isConnected: this.isConnected } });
+            }
+        }
+        else {
+            if (type === 'leader_event') {
+                const { event: socketEvent, data } = payload;
+                if (socketEvent === 'connect') {
+                    this.isConnected = true;
+                    this.dispatch('open', data);
+                }
+                else if (socketEvent === 'disconnect') {
+                    this.isConnected = false;
+                    this.dispatch('close', data);
+                }
+                else {
+                    this.dispatch(socketEvent, data);
+                    if (socketEvent === 'data_changed' || socketEvent === 'firestore_changed') {
+                        this.dispatch('message', data);
+                        this.dispatch('all', data);
+                    }
+                }
+            }
+            else if (type === 'leader_state') {
+                this.isConnected = payload.isConnected;
+                if (this.isConnected) {
+                    this.dispatch('open', {});
+                }
+            }
+        }
+    }
+    addListener(event, callback) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(callback);
+        this.ensureConnected();
+        return () => {
+            const callbacks = this.listeners.get(event);
+            if (callbacks) {
+                callbacks.delete(callback);
+                if (callbacks.size === 0) {
+                    this.listeners.delete(event);
+                }
+            }
+            this.checkCloseConnection();
+        };
+    }
+    subscribe(path) {
+        const cleanPath = (path || '').replace(/^\/+|\/+$/g, '');
+        this.subscribedPaths.add(cleanPath);
+        if (this.isLeader && this.socket && this.isConnected) {
+            this.socket.emit('subscribe', this.projectId, cleanPath);
+        }
+        else if (!this.isLeader && this.broadcastChannel) {
+            this.broadcastChannel.postMessage({ type: 'follower_subscribe', payload: { path: cleanPath } });
+        }
+    }
+    unsubscribe(path) {
+        const cleanPath = (path || '').replace(/^\/+|\/+$/g, '');
+        this.subscribedPaths.delete(cleanPath);
+        if (this.isLeader && this.socket && this.isConnected) {
+            this.socket.emit('unsubscribe', this.projectId, cleanPath);
+        }
+        else if (!this.isLeader && this.broadcastChannel) {
+            this.broadcastChannel.postMessage({ type: 'follower_unsubscribe', payload: { path: cleanPath } });
+        }
+    }
+    broadcastToFollowers(event, data) {
+        if (this.isLeader && this.broadcastChannel) {
+            this.broadcastChannel.postMessage({ type: 'leader_event', payload: { event, data } });
+        }
+    }
+    ensureConnected() {
+        if (this.hasInitialized || typeof window === 'undefined')
+            return;
+        this.hasInitialized = true;
+        if (navigator.locks) {
+            navigator.locks.request(`nexabase_ws_leader_${this.projectId}`, { mode: 'exclusive', ifAvailable: false }, async (lock) => {
+                // This promise won't resolve until we explicitly return from it (which we only do on close)
+                return new Promise((resolve) => {
+                    this.isLeader = true;
+                    this.startSocketConnection();
+                    // If we are closed intentionally, resolve the lock
+                    const originalClose = this.close.bind(this);
+                    this.close = () => {
+                        originalClose();
+                        resolve();
+                    };
+                });
+            }).catch(() => {
+                // We are a follower
+                this.isLeader = false;
+                this.broadcastChannel?.postMessage({ type: 'follower_sync_request' });
+            });
+        }
+        else {
+            // Fallback if no Web Locks API
+            this.isLeader = true;
+            this.startSocketConnection();
+        }
+    }
+    startSocketConnection() {
+        this.socket = (0, socket_io_client_1.io)(this.serverUrl, {
+            transports: ['websocket', 'polling'],
+            autoConnect: true,
+            reconnection: true,
+            reconnectionDelay: 1000,
+        });
+        this.socket.on('connect', () => {
+            this.isConnected = true;
+            this.dispatch('open', { socketId: this.socket?.id });
+            this.broadcastToFollowers('connect', { socketId: this.socket?.id });
+            // Always join project room
+            this.socket?.emit('subscribe', this.projectId, '');
+            // Resubscribe to all paths
+            this.subscribedPaths.forEach((path) => {
+                this.socket?.emit('subscribe', this.projectId, path);
+            });
+        });
+        this.socket.on('data_changed', (payload) => {
+            this.dispatch('data_changed', payload);
+            this.dispatch('message', payload);
+            this.dispatch('all', payload);
+            this.broadcastToFollowers('data_changed', payload);
+        });
+        this.socket.on('firestore_changed', (payload) => {
+            this.dispatch('firestore_changed', payload);
+            this.dispatch('message', payload);
+            this.dispatch('all', payload);
+            this.broadcastToFollowers('firestore_changed', payload);
+        });
+        this.socket.on('activity_logged', (payload) => {
+            this.dispatch('activity_logged', payload);
+            this.broadcastToFollowers('activity_logged', payload);
+        });
+        this.socket.on('stats_update', (payload) => {
+            this.dispatch('stats_update', payload);
+            this.broadcastToFollowers('stats_update', payload);
+        });
+        this.socket.on('connect_error', (err) => {
+            this.dispatch('error', err);
+            this.broadcastToFollowers('connect_error', err);
+        });
+        this.socket.on('disconnect', (reason) => {
+            this.isConnected = false;
+            this.dispatch('close', { reason });
+            this.broadcastToFollowers('disconnect', { reason });
+        });
+    }
+    send(event, data) {
+        return new Promise((resolve, reject) => {
+            this.ensureConnected();
+            if (!this.socket && this.isLeader) {
+                return reject(new Error('WebSocket client unavailable'));
+            }
+            if (!this.isLeader) {
+                // Followers can't send via websocket directly in this design without more plumbing.
+                // We fallback to standard HTTP API for writes anyway.
+                return reject(new Error('Cannot send WebSocket message from follower tab'));
+            }
+            this.socket.emit(event, data, (response) => {
+                if (response && response.error) {
+                    reject(new Error(response.error));
+                }
+                else {
+                    resolve(response);
+                }
+            });
+        });
+    }
+    checkCloseConnection() {
+        if (!this.hasListeners() && this.subscribedPaths.size === 0 && this.socket) {
+            this.socket.disconnect();
+            this.socket = null;
+            this.isConnected = false;
+            this.hasInitialized = false;
+        }
+    }
+    hasListeners() {
+        let count = 0;
+        this.listeners.forEach((set) => {
+            count += set.size;
+        });
+        return count > 0;
+    }
+    dispatch(event, data) {
+        const callbacks = this.listeners.get(event);
+        if (callbacks) {
+            callbacks.forEach((cb) => {
+                try {
+                    cb(data);
+                }
+                catch (e) {
+                    console.error(`[WebSocketClient] Error in listener for event ${event}:`, e);
+                }
+            });
+        }
+    }
+    close() {
+        if (this.socket) {
+            this.socket.disconnect();
+            this.socket = null;
+        }
+        this.isConnected = false;
+        this.hasInitialized = false;
+        this.listeners.clear();
+        this.subscribedPaths.clear();
+        if (this.broadcastChannel) {
+            this.broadcastChannel.close();
+            this.broadcastChannel = null;
+        }
+    }
+}
+exports.WebSocketClient = WebSocketClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexabase-console",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "SDK Client resmi untuk NexaBase: Platform Sinkronisasi NoSQL, Realtime, File Storage, & Autentikasi Offline-First.",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -26,7 +26,8 @@
   "author": "NexaBase Team",
   "license": "MIT",
   "dependencies": {
-    "axios": "^1.7.9"
+    "axios": "^1.7.9",
+    "socket.io-client": "^4.8.3"
   },
   "devDependencies": {
     "typescript": "^5.0.0"