nexabase-console 2.0.6 → 2.0.8

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/dist/types/index.d.ts

@@ -140,14 +140,21 @@ export interface WriteBatch {
 }
 export interface OfflineJob {
     id: string;
-    type: 'set' | 'update' | 'patch' | 'delete';
+    type: 'set' | 'patch' | 'delete';
     path: string;
     data?: any;
     idempotencyKey?: string;
+    precondition?: {
+        exists?: boolean;
+        updateTime?: string;
+    };
     timestamp?: number;
     merge?: boolean;
     state?: 'pending' | 'acknowledged' | 'rejected';
     retryCount?: number;
+    leaseOwner?: string;
+    leaseExpiresAt?: number;
+    sequenceNumber?: number;
     lastError?: string;
 }
 export interface Transaction {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexabase-console",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "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"