nexabase-console 2.1.5 → 2.1.7

package/dist/app/NexaApp.js

@@ -59,7 +59,6 @@ class NexaApp {
         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();
@@ -67,10 +66,7 @@ class NexaApp {
                         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);
                 }
             });
@@ -80,10 +76,10 @@ class NexaApp {
         this.syncEngine.listenCrossTab((path, action, data) => {
             const cleanPath = path.replace(/^\/+|\/+$/g, '');
             if (action === 'delete') {
-                this.localStore.delete(cleanPath);
+                this._deleteCache(cleanPath);
             }
-            else if (data) {
-                this.localStore.set(cleanPath, data);
+            else if (data !== undefined && data !== null) {
+                this._setCache(cleanPath, data);
             }
             this._notifySnapshotCallbacks(cleanPath, action === 'delete' ? 'document_deleted' : 'document_written', data);
             const parts = cleanPath.split('/');
@@ -395,17 +391,31 @@ class NexaApp {
         const isDelete = type === 'document_deleted' || action === 'delete' || type === 'delete';
         if (targetDocPath && typeof targetDocPath === 'string') {
             const cleanDocPath = targetDocPath.replace(/^\/+|\/+$/g, '');
-            if (isDelete) {
-                this._deleteCache(cleanDocPath);
-            }
-            else if (data !== undefined && data !== null) {
-                this._setCache(cleanDocPath, data);
+            const segments = cleanDocPath.split('/');
+            const isCollection = segments.length % 2 === 1;
+            if (isCollection && data !== null && typeof data === 'object' && !Array.isArray(data)) {
+                // Distribute collection payload to individual docs
+                if (!isDelete) {
+                    for (const docId of Object.keys(data)) {
+                        const docData = data[docId];
+                        this._setCache(`${cleanDocPath}/${docId}`, docData);
+                        this._notifySnapshotCallbacks(`${cleanDocPath}/${docId}`, 'document_written', docData);
+                    }
+                }
+                this._notifySnapshotCallbacks(cleanDocPath, isDelete ? 'document_deleted' : 'document_written', data);
             }
-            const parts = cleanDocPath.split('/');
-            const colPath = parts.length > 1 ? parts.slice(0, -1).join('/') : '';
-            this._notifySnapshotCallbacks(cleanDocPath, isDelete ? 'document_deleted' : 'document_written', data);
-            if (colPath) {
-                this._notifySnapshotCallbacks(colPath, isDelete ? 'document_deleted' : 'document_written', data);
+            else {
+                if (isDelete) {
+                    this._deleteCache(cleanDocPath);
+                }
+                else if (data !== undefined && data !== null) {
+                    this._setCache(cleanDocPath, data);
+                }
+                const colPath = segments.length > 1 ? segments.slice(0, -1).join('/') : '';
+                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') {

package/dist/firestore/writes.d.ts

@@ -13,6 +13,10 @@ export type WriteResult<T = unknown> = {
     writtenLocally: true;
     mutationId: string;
 };
+export declare const addDoc: <T = any>(reference: any, // CollectionReference
+data: any, options?: {
+    idempotencyKey?: string;
+}) => Promise<DocumentReference<T>>;
 export declare const setDoc: (docRef: DocumentReference, data: any, options?: {
     merge?: boolean;
     idempotencyKey?: string;

package/dist/firestore/writes.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPendingWritesCount = exports.deleteDoc = exports.updateDoc = exports.patchDoc = exports.setDoc = exports.FieldValue = void 0;
+exports.getPendingWritesCount = exports.deleteDoc = exports.updateDoc = exports.patchDoc = exports.setDoc = exports.addDoc = exports.FieldValue = void 0;
 const helpers_1 = require("../utils/helpers");
 const NexaError_1 = require("../errors/NexaError");
 const QueryUtils_1 = require("./QueryUtils");
@@ -217,6 +217,28 @@ const executeWriteMutation = async (docRef, action, data, options) => {
     });
     return { status: 'committed', committed: true, writtenLocally: true, mutationId, data: ackView.data };
 };
+const addDoc = async (reference, // CollectionReference
+data, options) => {
+    // We need to import doc, but since writes.ts doesn't have it, we can construct the path.
+    // Actually it's easier to just generate an auto ID if we can't import doc.
+    // We don't want circular dependencies.
+    const db = reference.db;
+    const generateAutoId = () => {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let autoId = '';
+        for (let i = 0; i < 20; i++)
+            autoId += chars.charAt(Math.floor(Math.random() * chars.length));
+        return autoId;
+    };
+    const d = {
+        type: 'document',
+        path: `${reference.path}/${generateAutoId()}`,
+        db
+    };
+    await executeWriteMutation(d, 'set', data, options);
+    return d;
+};
+exports.addDoc = addDoc;
 const setDoc = async (docRef, data, options) => {
     return executeWriteMutation(docRef, 'set', data, options);
 };

package/dist/sync/SyncEngine.d.ts

@@ -7,6 +7,7 @@ export declare class SyncEngine {
     private broadcastChannel;
     constructor(projectId: string, mutationQueue: MutationQueue, sseClient: SSEClient);
     private initCrossTabSync;
+    private _serializeForBroadcast;
     broadcastLocalMutation(path: string, action: string, data?: any): void;
     listenCrossTab(onMutation: (path: string, action: string, data?: any) => void): () => void;
     syncOfflineMutations(): Promise<void>;

package/dist/sync/SyncEngine.js

@@ -19,10 +19,48 @@ class SyncEngine {
             }
         }
     }
+    _serializeForBroadcast(data, seen = new WeakSet()) {
+        if (data === null || data === undefined)
+            return data;
+        if (typeof data === 'boolean' || typeof data === 'number' || typeof data === 'string')
+            return data;
+        if (data instanceof Date) {
+            return { __nexa_type__: 'timestamp', seconds: Math.floor(data.getTime() / 1000), nanoseconds: (data.getTime() % 1000) * 1000000 };
+        }
+        // Check if it's a Timestamp object (even without prototype due to potential prior cloning)
+        if (typeof data === 'object' && 'seconds' in data && 'nanoseconds' in data && typeof data.seconds === 'number' && typeof data.nanoseconds === 'number') {
+            return { __nexa_type__: 'timestamp', seconds: data.seconds, nanoseconds: data.nanoseconds };
+        }
+        // Check for GeoPoint
+        if (typeof data === 'object' && 'latitude' in data && 'longitude' in data && typeof data.latitude === 'number' && typeof data.longitude === 'number') {
+            return { __nexa_type__: 'geopoint', latitude: data.latitude, longitude: data.longitude };
+        }
+        if (Array.isArray(data)) {
+            if (seen.has(data))
+                return null;
+            seen.add(data);
+            const res = data.map(item => this._serializeForBroadcast(item, seen));
+            seen.delete(data);
+            return res;
+        }
+        if (typeof data === 'object') {
+            if (seen.has(data))
+                return null;
+            seen.add(data);
+            const res = {};
+            for (const key of Object.keys(data)) {
+                res[key] = this._serializeForBroadcast(data[key], seen);
+            }
+            seen.delete(data);
+            return res;
+        }
+        return data;
+    }
     broadcastLocalMutation(path, action, data) {
         if (this.broadcastChannel) {
             try {
-                this.broadcastChannel.postMessage({ type: 'LOCAL_MUTATION', path, action, data });
+                const serialized = this._serializeForBroadcast(data);
+                this.broadcastChannel.postMessage({ type: 'LOCAL_MUTATION', path, action, data: serialized });
             }
             catch (e) { }
         }

package/package.json

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