nexabase-console 2.1.8 → 2.2.0

package/dist/firestore/FieldValue.d.ts

@@ -2,10 +2,16 @@ export declare const FIELD_VALUE_BRAND: unique symbol;
 export type FieldValueMethod = 'serverTimestamp' | 'increment' | 'arrayUnion' | 'arrayRemove' | 'deleteField';
 export declare class FieldValue {
     readonly [FIELD_VALUE_BRAND] = true;
+    readonly _isFieldValue: boolean;
     readonly method: FieldValueMethod;
     readonly value?: any;
     constructor(method: FieldValueMethod, value?: any);
     static isFieldValue(val: any): val is FieldValue;
+    toJSON(): {
+        _isFieldValue: boolean;
+        method: FieldValueMethod;
+        value: any;
+    };
     isEqual(other: any): boolean;
 }
 export declare const serverTimestamp: () => FieldValue;

package/dist/firestore/FieldValue.js

@@ -7,14 +7,27 @@ exports.FIELD_VALUE_BRAND = Symbol.for('nexabase.fieldValue');
 class FieldValue {
     constructor(method, value) {
         this[_a] = true;
+        this._isFieldValue = true;
         this.method = method;
         this.value = value;
+        this._isFieldValue = true;
         Object.freeze(this);
     }
     static isFieldValue(val) {
         return (val !== null &&
             typeof val === 'object' &&
-            (val instanceof FieldValue || val[exports.FIELD_VALUE_BRAND] === true));
+            (val instanceof FieldValue ||
+                val[exports.FIELD_VALUE_BRAND] === true ||
+                val._isFieldValue === true ||
+                (typeof val.method === 'string' &&
+                    ['serverTimestamp', 'increment', 'arrayUnion', 'arrayRemove', 'deleteField'].includes(val.method))));
+    }
+    toJSON() {
+        return {
+            _isFieldValue: true,
+            method: this.method,
+            value: this.value !== undefined ? this.value : undefined
+        };
     }
     isEqual(other) {
         if (!FieldValue.isFieldValue(other))

package/dist/index.d.ts

@@ -28,6 +28,7 @@ export * from './persistence/LocalStore';
 export * from './persistence/MutationQueue';
 export * from './sync/SyncEngine';
 export * from './sync/ConflictResolver';
+export * from './sync/CrossTabSync';
 export * from './transport/HttpClient';
 export * from './transport/SSEClient';
 export * from './transport/WebSocketClient';

package/dist/index.js

@@ -52,6 +52,7 @@ __exportStar(require("./persistence/MutationQueue"), exports);
 // Sync
 __exportStar(require("./sync/SyncEngine"), exports);
 __exportStar(require("./sync/ConflictResolver"), exports);
+__exportStar(require("./sync/CrossTabSync"), exports);
 // Transport
 __exportStar(require("./transport/HttpClient"), exports);
 __exportStar(require("./transport/SSEClient"), exports);

package/dist/sync/CrossTabSync.d.ts

@@ -0,0 +1,83 @@
+export interface CrossTabMessage<T = any> {
+    id: string;
+    senderTabId: string;
+    projectId?: string;
+    type: string;
+    timestamp: number;
+    payload: T;
+}
+export interface LocalMutationPayload {
+    path: string;
+    action: 'set' | 'patch' | 'update' | 'delete' | string;
+    data?: any;
+    metadata?: {
+        mutationId?: string;
+        source?: 'local' | 'server' | string;
+        state?: 'pending' | 'acknowledged' | string;
+        hasPendingWrites?: boolean;
+        [key: string]: any;
+    };
+}
+export type CrossTabMessageHandler<T = any> = (payload: T, message: CrossTabMessage<T>) => void;
+export type MutationSyncHandler = (path: string, action: string, data?: any, metadata?: LocalMutationPayload['metadata']) => void;
+/**
+ * Serializes rich JavaScript objects (Timestamp, GeoPoint, Date) into structured JSON-safe
+ * objects with explicit type tags so they can cross BroadcastChannel or localStorage boundaries safely.
+ */
+export declare function serializeCrossTabData(data: any, seen?: WeakSet<object>): any;
+/**
+ * Deserializes structured JSON-safe objects back into rich JavaScript types (Timestamp, GeoPoint, etc.).
+ */
+export declare function deserializeCrossTabData(data: any): any;
+/**
+ * Checks if native BroadcastChannel is supported in the current environment.
+ */
+export declare function isBroadcastChannelSupported(): boolean;
+/**
+ * CrossTabSyncChannel provides ultra-fast, local cross-tab state synchronization
+ * with native BroadcastChannel support and automatic fallback to localStorage storage events.
+ */
+export declare class CrossTabSyncChannel {
+    readonly channelName: string;
+    readonly tabId: string;
+    private broadcastChannel;
+    private listeners;
+    private wildcardListeners;
+    private storageListener;
+    private isClosed;
+    constructor(channelName: string);
+    private initTransport;
+    private handleIncomingRawMessage;
+    /**
+     * Broadcasts a typed message across all other browser tabs.
+     */
+    broadcast<T = any>(type: string, payload: T, projectId?: string): void;
+    /**
+     * Broadcasts a local mutation event (write, update, delete) to keep caches across tabs in sync instantly.
+     */
+    broadcastMutation(path: string, action: string, data?: any, metadata?: LocalMutationPayload['metadata'], projectId?: string): void;
+    /**
+     * Subscribes to a specific event type. Returns an unsubscribe callback.
+     */
+    on<T = any>(type: string, handler: CrossTabMessageHandler<T>): () => void;
+    /**
+     * Subscribes to all incoming messages regardless of type.
+     */
+    onAny(handler: CrossTabMessageHandler): () => void;
+    /**
+     * Helper specifically for listening to local mutations across tabs.
+     */
+    onMutation(handler: MutationSyncHandler): () => void;
+    /**
+     * Closes the channel and removes all event listeners.
+     */
+    close(): void;
+}
+/**
+ * Returns a singleton instance of CrossTabSyncChannel for the given channel name.
+ */
+export declare function getCrossTabChannel(channelName: string): CrossTabSyncChannel;
+/**
+ * Creates or gets a project-scoped cross-tab synchronization channel.
+ */
+export declare function getProjectCrossTabChannel(projectId: string): CrossTabSyncChannel;

package/dist/sync/CrossTabSync.js

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrossTabSyncChannel = void 0;
+exports.serializeCrossTabData = serializeCrossTabData;
+exports.deserializeCrossTabData = deserializeCrossTabData;
+exports.isBroadcastChannelSupported = isBroadcastChannelSupported;
+exports.getCrossTabChannel = getCrossTabChannel;
+exports.getProjectCrossTabChannel = getProjectCrossTabChannel;
+const Timestamp_1 = require("../firestore/Timestamp");
+const GeoPoint_1 = require("../firestore/GeoPoint");
+const QueryUtils_1 = require("../firestore/QueryUtils");
+/**
+ * Generates a unique Tab ID for distinguishing cross-tab messages from current tab.
+ */
+function createTabId() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    return `tab_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+/**
+ * Serializes rich JavaScript objects (Timestamp, GeoPoint, Date) into structured JSON-safe
+ * objects with explicit type tags so they can cross BroadcastChannel or localStorage boundaries safely.
+ */
+function serializeCrossTabData(data, seen = new WeakSet()) {
+    if (data === null || data === undefined)
+        return data;
+    const type = typeof data;
+    if (type === 'boolean' || type === 'number' || type === 'string')
+        return data;
+    if (data instanceof Date) {
+        return {
+            __nexa_type__: 'timestamp',
+            seconds: Math.floor(data.getTime() / 1000),
+            nanoseconds: (data.getTime() % 1000) * 1000000
+        };
+    }
+    if (data instanceof Timestamp_1.Timestamp) {
+        return {
+            __nexa_type__: 'timestamp',
+            seconds: data.seconds,
+            nanoseconds: data.nanoseconds
+        };
+    }
+    // Handle Timestamp-like objects (e.g. if prototype was stripped)
+    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
+        };
+    }
+    if (data instanceof GeoPoint_1.GeoPoint) {
+        return {
+            __nexa_type__: 'geopoint',
+            latitude: data.latitude,
+            longitude: data.longitude
+        };
+    }
+    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) => serializeCrossTabData(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] = serializeCrossTabData(data[key], seen);
+        }
+        seen.delete(data);
+        return res;
+    }
+    return data;
+}
+/**
+ * Deserializes structured JSON-safe objects back into rich JavaScript types (Timestamp, GeoPoint, etc.).
+ */
+function deserializeCrossTabData(data) {
+    return (0, QueryUtils_1.reviveNexaData)(data);
+}
+/**
+ * Checks if native BroadcastChannel is supported in the current environment.
+ */
+function isBroadcastChannelSupported() {
+    return typeof window !== 'undefined' && typeof window.BroadcastChannel !== 'undefined';
+}
+/**
+ * CrossTabSyncChannel provides ultra-fast, local cross-tab state synchronization
+ * with native BroadcastChannel support and automatic fallback to localStorage storage events.
+ */
+class CrossTabSyncChannel {
+    constructor(channelName) {
+        this.broadcastChannel = null;
+        this.listeners = new Map();
+        this.wildcardListeners = new Set();
+        this.storageListener = null;
+        this.isClosed = false;
+        this.channelName = channelName;
+        this.tabId = createTabId();
+        this.initTransport();
+    }
+    initTransport() {
+        if (typeof window === 'undefined')
+            return;
+        if (isBroadcastChannelSupported()) {
+            try {
+                this.broadcastChannel = new window.BroadcastChannel(this.channelName);
+                this.broadcastChannel.onmessage = (event) => {
+                    this.handleIncomingRawMessage(event.data);
+                };
+                return;
+            }
+            catch (err) {
+                console.warn(`[CrossTabSyncChannel] Native BroadcastChannel failed for "${this.channelName}", falling back to StorageEvent:`, err);
+            }
+        }
+        // Fallback: localStorage storage events
+        if (typeof window.addEventListener === 'function' && typeof window.localStorage !== 'undefined') {
+            const storageKey = `__nexa_crosstab_${this.channelName}`;
+            this.storageListener = (e) => {
+                if (e.key === storageKey && e.newValue) {
+                    try {
+                        const raw = JSON.parse(e.newValue);
+                        this.handleIncomingRawMessage(raw);
+                    }
+                    catch (parseErr) {
+                        // Ignore parse errors from concurrent writes
+                    }
+                }
+            };
+            window.addEventListener('storage', this.storageListener);
+        }
+    }
+    handleIncomingRawMessage(raw) {
+        if (!raw || typeof raw !== 'object')
+            return;
+        const msg = raw;
+        // Discard messages originating from the current tab
+        if (msg.senderTabId === this.tabId)
+            return;
+        // Reconstruct rich objects (Timestamp, GeoPoint)
+        const revivedPayload = deserializeCrossTabData(msg.payload);
+        const message = {
+            ...msg,
+            payload: revivedPayload
+        };
+        // Notify specific type listeners
+        if (msg.type && this.listeners.has(msg.type)) {
+            const typeSet = this.listeners.get(msg.type);
+            typeSet.forEach((fn) => {
+                try {
+                    fn(revivedPayload, message);
+                }
+                catch (e) {
+                    console.error(`[CrossTabSyncChannel] Error in listener for type "${msg.type}":`, e);
+                }
+            });
+        }
+        // Notify wildcard listeners
+        this.wildcardListeners.forEach((fn) => {
+            try {
+                fn(revivedPayload, message);
+            }
+            catch (e) {
+                console.error(`[CrossTabSyncChannel] Error in wildcard listener:`, e);
+            }
+        });
+    }
+    /**
+     * Broadcasts a typed message across all other browser tabs.
+     */
+    broadcast(type, payload, projectId) {
+        if (this.isClosed)
+            return;
+        const serializedPayload = serializeCrossTabData(payload);
+        const message = {
+            id: `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+            senderTabId: this.tabId,
+            projectId,
+            type,
+            timestamp: Date.now(),
+            payload: serializedPayload
+        };
+        // 1. Native BroadcastChannel
+        if (this.broadcastChannel) {
+            try {
+                this.broadcastChannel.postMessage(message);
+                return;
+            }
+            catch (e) {
+                console.warn('[CrossTabSyncChannel] BroadcastChannel postMessage failed:', e);
+            }
+        }
+        // 2. StorageEvent Fallback
+        if (typeof window !== 'undefined' && typeof window.localStorage !== 'undefined') {
+            try {
+                const storageKey = `__nexa_crosstab_${this.channelName}`;
+                window.localStorage.setItem(storageKey, JSON.stringify(message));
+            }
+            catch (e) {
+                // Storage quota or restriction
+            }
+        }
+    }
+    /**
+     * Broadcasts a local mutation event (write, update, delete) to keep caches across tabs in sync instantly.
+     */
+    broadcastMutation(path, action, data, metadata, projectId) {
+        const payload = {
+            path,
+            action,
+            data,
+            metadata
+        };
+        this.broadcast('LOCAL_MUTATION', payload, projectId);
+    }
+    /**
+     * Subscribes to a specific event type. Returns an unsubscribe callback.
+     */
+    on(type, handler) {
+        if (!this.listeners.has(type)) {
+            this.listeners.set(type, new Set());
+        }
+        this.listeners.get(type).add(handler);
+        return () => {
+            const set = this.listeners.get(type);
+            if (set) {
+                set.delete(handler);
+                if (set.size === 0) {
+                    this.listeners.delete(type);
+                }
+            }
+        };
+    }
+    /**
+     * Subscribes to all incoming messages regardless of type.
+     */
+    onAny(handler) {
+        this.wildcardListeners.add(handler);
+        return () => {
+            this.wildcardListeners.delete(handler);
+        };
+    }
+    /**
+     * Helper specifically for listening to local mutations across tabs.
+     */
+    onMutation(handler) {
+        return this.on('LOCAL_MUTATION', (payload) => {
+            if (payload && payload.path && payload.action) {
+                handler(payload.path, payload.action, payload.data, payload.metadata);
+            }
+        });
+    }
+    /**
+     * Closes the channel and removes all event listeners.
+     */
+    close() {
+        this.isClosed = true;
+        this.listeners.clear();
+        this.wildcardListeners.clear();
+        if (this.broadcastChannel) {
+            try {
+                this.broadcastChannel.close();
+            }
+            catch (e) { }
+            this.broadcastChannel = null;
+        }
+        if (this.storageListener && typeof window !== 'undefined') {
+            try {
+                window.removeEventListener('storage', this.storageListener);
+            }
+            catch (e) { }
+            this.storageListener = null;
+        }
+    }
+}
+exports.CrossTabSyncChannel = CrossTabSyncChannel;
+// Global registry for CrossTab channels by name
+const channelsRegistry = new Map();
+/**
+ * Returns a singleton instance of CrossTabSyncChannel for the given channel name.
+ */
+function getCrossTabChannel(channelName) {
+    let channel = channelsRegistry.get(channelName);
+    if (!channel) {
+        channel = new CrossTabSyncChannel(channelName);
+        channelsRegistry.set(channelName, channel);
+    }
+    return channel;
+}
+/**
+ * Creates or gets a project-scoped cross-tab synchronization channel.
+ */
+function getProjectCrossTabChannel(projectId) {
+    return getCrossTabChannel(`nexabase_tab_sync_${projectId}`);
+}

package/dist/sync/SyncEngine.d.ts

@@ -1,14 +1,14 @@
 import { MutationQueue } from '../persistence/MutationQueue';
 import { SSEClient } from '../transport/SSEClient';
+import { CrossTabSyncChannel, MutationSyncHandler } from './CrossTabSync';
 export declare class SyncEngine {
     private projectId;
     private mutationQueue;
     private sseClient;
-    private broadcastChannel;
+    private crossTabChannel;
     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;
+    getCrossTabChannel(): CrossTabSyncChannel;
+    broadcastLocalMutation(path: string, action: string, data?: any, metadata?: any): void;
+    listenCrossTab(onMutation: MutationSyncHandler): () => void;
     syncOfflineMutations(): Promise<void>;
 }

package/dist/sync/SyncEngine.js

@@ -1,82 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SyncEngine = void 0;
+const CrossTabSync_1 = require("./CrossTabSync");
 class SyncEngine {
     constructor(projectId, mutationQueue, sseClient) {
-        this.broadcastChannel = null;
         this.projectId = projectId;
         this.mutationQueue = mutationQueue;
         this.sseClient = sseClient;
-        this.initCrossTabSync();
+        this.crossTabChannel = (0, CrossTabSync_1.getProjectCrossTabChannel)(this.projectId);
     }
-    initCrossTabSync() {
-        if (typeof window !== 'undefined' && 'BroadcastChannel' in window && !this.broadcastChannel) {
-            try {
-                this.broadcastChannel = new BroadcastChannel(`nexabase_tab_sync_${this.projectId}`);
-            }
-            catch (e) {
-                console.warn('[SyncEngine] BroadcastChannel initialization failed:', e);
-            }
-        }
+    getCrossTabChannel() {
+        return this.crossTabChannel;
     }
-    _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 {
-                const serialized = this._serializeForBroadcast(data);
-                this.broadcastChannel.postMessage({ type: 'LOCAL_MUTATION', path, action, data: serialized });
-            }
-            catch (e) { }
-        }
+    broadcastLocalMutation(path, action, data, metadata) {
+        this.crossTabChannel.broadcastMutation(path, action, data, metadata, this.projectId);
     }
     listenCrossTab(onMutation) {
-        if (!this.broadcastChannel)
-            return () => { };
-        const handler = (event) => {
-            if (event.data && event.data.type === 'LOCAL_MUTATION') {
-                onMutation(event.data.path, event.data.action, event.data.data);
-            }
-        };
-        this.broadcastChannel.addEventListener('message', handler);
-        return () => {
-            this.broadcastChannel.removeEventListener('message', handler);
-        };
+        return this.crossTabChannel.onMutation(onMutation);
     }
     async syncOfflineMutations() {
         await this.mutationQueue.syncQueue();

package/dist/utils/helpers.js

@@ -5,6 +5,7 @@ exports.deepEqual = deepEqual;
 exports.applyDataTransforms = applyDataTransforms;
 exports.calculateDocChanges = calculateDocChanges;
 exports.generateIdempotencyKey = generateIdempotencyKey;
+const FieldValue_1 = require("../firestore/FieldValue");
 const Timestamp_1 = require("../firestore/Timestamp");
 function getNestedValue(obj, path, docId) {
     if (!obj || !path)
@@ -46,34 +47,61 @@ function deepEqual(a, b) {
     return true;
 }
 function applyDataTransforms(existingData, updateData) {
-    const result = { ...existingData };
+    if (!updateData || typeof updateData !== 'object')
+        return existingData || {};
+    const result = { ...(existingData || {}) };
     const processNode = (obj, keyPath, value) => {
+        if (!obj || typeof obj !== 'object')
+            return;
         const current = keyPath[0];
         if (keyPath.length === 1) {
-            if (value && typeof value === 'object' && value._isFieldValue) {
-                const fv = value;
-                if (fv.method === 'serverTimestamp') {
+            if (FieldValue_1.FieldValue.isFieldValue(value) ||
+                (value &&
+                    typeof value === 'object' &&
+                    (value._isFieldValue ||
+                        ['deleteField', 'serverTimestamp', 'increment', 'arrayUnion', 'arrayRemove'].includes(value.method)))) {
+                const method = value.method;
+                const val = value.value;
+                if (method === 'serverTimestamp') {
                     obj[current] = Timestamp_1.Timestamp.now();
                 }
-                else if (fv.method === 'increment') {
-                    obj[current] = (typeof obj[current] === 'number' ? obj[current] : 0) + (fv.value || 1);
+                else if (method === 'increment') {
+                    obj[current] = (typeof obj[current] === 'number' ? obj[current] : 0) + (typeof val === 'number' ? val : 1);
                 }
-                else if (fv.method === 'arrayUnion') {
+                else if (method === 'arrayUnion') {
                     const arr = Array.isArray(obj[current]) ? obj[current] : [];
-                    obj[current] = [...new Set([...arr, ...(fv.value || [])])];
+                    const toAdd = Array.isArray(val) ? val : (val !== undefined ? [val] : []);
+                    const existingSet = new Set(arr.map((item) => (typeof item === 'object' ? JSON.stringify(item) : item)));
+                    for (const item of toAdd) {
+                        const itemKey = typeof item === 'object' ? JSON.stringify(item) : item;
+                        if (!existingSet.has(itemKey)) {
+                            existingSet.add(itemKey);
+                            arr.push(item);
+                        }
+                    }
+                    obj[current] = arr;
                 }
-                else if (fv.method === 'arrayRemove') {
+                else if (method === 'arrayRemove') {
                     const arr = Array.isArray(obj[current]) ? obj[current] : [];
-                    const toRemove = new Set(fv.value || []);
-                    obj[current] = arr.filter((x) => !toRemove.has(x));
+                    const toRemove = Array.isArray(val) ? val : (val !== undefined ? [val] : []);
+                    const removeSet = new Set(toRemove.map((item) => (typeof item === 'object' ? JSON.stringify(item) : item)));
+                    obj[current] = arr.filter((x) => {
+                        const itemKey = typeof x === 'object' ? JSON.stringify(x) : x;
+                        return !removeSet.has(itemKey);
+                    });
                 }
-                else if (fv.method === 'deleteField') {
+                else if (method === 'deleteField') {
                     delete obj[current];
                 }
             }
-            else if (value && typeof value === 'object' && !Array.isArray(value) && typeof value.isEqual !== 'function') {
-                if (!obj[current] || typeof obj[current] !== 'object')
+            else if (value &&
+                typeof value === 'object' &&
+                !Array.isArray(value) &&
+                typeof value.isEqual !== 'function' &&
+                !(value instanceof Timestamp_1.Timestamp)) {
+                if (!obj[current] || typeof obj[current] !== 'object' || Array.isArray(obj[current])) {
                     obj[current] = {};
+                }
                 for (const [k, v] of Object.entries(value)) {
                     processNode(obj[current], [k], v);
                 }
@@ -83,8 +111,13 @@ function applyDataTransforms(existingData, updateData) {
             }
         }
         else {
-            if (!obj[current] || typeof obj[current] !== 'object')
+            if (!obj[current] || typeof obj[current] !== 'object' || Array.isArray(obj[current])) {
+                const isDelete = FieldValue_1.FieldValue.isFieldValue(value) ||
+                    (value && typeof value === 'object' && value.method === 'deleteField');
+                if (isDelete)
+                    return;
                 obj[current] = {};
+            }
             processNode(obj[current], keyPath.slice(1), value);
         }
     };

package/package.json

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