nexabase-console 2.0.6 → 2.0.8

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';
@@ -16,8 +16,10 @@ export declare class NexaApp {
     endpoint: string;
     enablePersistence: boolean;
     cacheStrategy: 'network-first' | 'cache-first';
+    _queryCacheMetadata: Record<string, boolean>;
     httpClient: HttpClient;
     client: AxiosInstance;
+    wsClient: WebSocketClient;
     sseClient: SSEClient;
     authService: Auth;
     indexedDB: IndexedDB;
@@ -35,15 +37,55 @@ export declare class NexaApp {
     private _setupCrossTabSync;
     _broadcastLocalMutation(path: string, action: string, data?: any): void;
     hasPendingWrites(path: string): boolean;
-    markInflight(path: string): void;
-    unmarkInflight(path: string): void;
+    markInflight(path: string, mutationId: string): void;
+    unmarkInflight(path: string, mutationId: string): void;
     _initFirestoreState(): Promise<void>;
     _setCache(path: string, data: any): Promise<void>;
     _deleteCache(path: string): Promise<void>;
     _addOfflineJob(job: OfflineJob): Promise<void>;
+    _calculateLocalView(path: string): {
+        data: any | null;
+        hasPendingWrites: boolean;
+    };
+    _commitAtomicMutation(path: string, action: 'set' | 'patch' | 'delete', job: OfflineJob): Promise<{
+        data: any | null;
+        hasPendingWrites: boolean;
+    }>;
+    _commitMutationAck(options: {
+        mutationId: string;
+        path: string;
+        action: 'set' | 'patch' | 'delete';
+        serverDocument?: any;
+        updateTime?: string;
+    }): Promise<{
+        data: any | null;
+        hasPendingWrites: boolean;
+    }>;
+    _rejectMutationAtomically(options: {
+        mutationId: string;
+        path: string;
+        error: any;
+    }): Promise<{
+        data: any | null;
+        hasPendingWrites: boolean;
+    }>;
+    _commitAtomicQueryResults(options: {
+        queryKey: string;
+        collectionPath: string;
+        serverDocs: {
+            id: string;
+            fields: any;
+        }[];
+        isComplete: boolean;
+        constraints?: any[];
+        readTime?: string;
+        revision?: string;
+    }): 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 +103,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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NexaApp = void 0;
+const helpers_1 = require("../utils/helpers");
+const QueryUtils_1 = require("../firestore/QueryUtils");
 const HttpClient_1 = require("../transport/HttpClient");
 const SSEClient_1 = require("../transport/SSEClient");
 const Auth_1 = require("../auth/Auth");
@@ -14,6 +16,7 @@ const Storage_1 = require("../storage/Storage");
 class NexaApp {
     constructor(config) {
         this.token = null;
+        this._queryCacheMetadata = {};
         // Internal Firestore caches/callbacks
         this._snapshotCallbacks = {};
         this._firestoreListening = false;
@@ -31,6 +34,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);
@@ -65,11 +69,11 @@ class NexaApp {
     hasPendingWrites(path) {
         return this.mutationQueue.hasPendingWrites(path);
     }
-    markInflight(path) {
-        this.mutationQueue.markInflight(path);
+    markInflight(path, mutationId) {
+        this.mutationQueue.markInflight(path, mutationId);
     }
-    unmarkInflight(path) {
-        this.mutationQueue.unmarkInflight(path);
+    unmarkInflight(path, mutationId) {
+        this.mutationQueue.unmarkInflight(path, mutationId);
     }
     async _initFirestoreState() {
         if (!this.enablePersistence)
@@ -77,6 +81,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());
@@ -96,6 +101,226 @@ class NexaApp {
     async _addOfflineJob(job) {
         await this.mutationQueue.addJob(job);
     }
+    _calculateLocalView(path) {
+        let base = this.localStore.getServerBaseCache()[path];
+        base = base !== undefined && base !== null ? (0, QueryUtils_1.cloneNexaData)(base) : base;
+        const mQueue = this.mutationQueue.inMemoryQueue || [];
+        let hasPendingWrites = false;
+        for (const job of mQueue) {
+            if (job.path !== path)
+                continue;
+            hasPendingWrites = true;
+            if (job.type === 'delete') {
+                base = null;
+            }
+            else if (job.type === 'set' && !job.merge) {
+                base = (0, helpers_1.applyDataTransforms)({}, job.data);
+            }
+            else if (base !== null && base !== undefined) {
+                base = (0, helpers_1.applyDataTransforms)(base, job.data);
+            }
+            else if (job.type === 'set' || job.type === 'patch' || job.type === 'update') {
+                base = (0, helpers_1.applyDataTransforms)(base || {}, job.data);
+            }
+        }
+        return { data: base === undefined ? null : base, hasPendingWrites };
+    }
+    async _commitAtomicMutation(path, action, job) {
+        const db = this.indexedDB.getRawDB();
+        this.mutationQueue.inMemoryQueue.push(job);
+        const view = this._calculateLocalView(path);
+        const rebasedData = view.data;
+        if (rebasedData === null) {
+            delete this.localStore.getMemoryCache()[path];
+        }
+        else {
+            this.localStore.getMemoryCache()[path] = rebasedData;
+        }
+        if (!db)
+            return view;
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(['offline_cache', 'offline_queue'], 'readwrite');
+            const cacheStore = tx.objectStore('offline_cache');
+            const queueStore = tx.objectStore('offline_queue');
+            if (rebasedData === null) {
+                const sb = this.localStore.getServerBaseCache()[path];
+                if (sb !== undefined) {
+                    cacheStore.put({ path, data: null, serverBase: sb, timestamp: Date.now() });
+                }
+                else {
+                    cacheStore.delete(path);
+                }
+            }
+            else {
+                const sb = this.localStore.getServerBaseCache()[path];
+                cacheStore.put({ path, data: rebasedData, serverBase: sb !== undefined ? sb : null, timestamp: Date.now() });
+            }
+            queueStore.put(job);
+            tx.oncomplete = () => resolve(view);
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async _commitMutationAck(options) {
+        const { mutationId, path, serverDocument } = options;
+        const db = this.indexedDB.getRawDB();
+        const queue = this.mutationQueue.inMemoryQueue;
+        const jobIndex = queue.findIndex((j) => j.id === mutationId);
+        if (jobIndex !== -1)
+            queue.splice(jobIndex, 1);
+        if (options.action === 'delete') {
+            this.localStore.getServerBaseCache()[path] = null;
+        }
+        else if (serverDocument && serverDocument.fields) {
+            this.localStore.getServerBaseCache()[path] = serverDocument.fields;
+        }
+        const view = this._calculateLocalView(path);
+        const rebasedData = view.data;
+        if (rebasedData === null) {
+            delete this.localStore.getMemoryCache()[path];
+        }
+        else {
+            this.localStore.getMemoryCache()[path] = rebasedData;
+        }
+        if (!db)
+            return view;
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(['offline_cache', 'offline_queue'], 'readwrite');
+            const cacheStore = tx.objectStore('offline_cache');
+            const queueStore = tx.objectStore('offline_queue');
+            queueStore.delete(mutationId);
+            if (rebasedData === null) {
+                if (options.action === 'delete') {
+                    cacheStore.put({ path, data: null, serverBase: null, timestamp: Date.now() });
+                }
+                else {
+                    const sb = this.localStore.getServerBaseCache()[path];
+                    cacheStore.put({ path, data: null, serverBase: sb !== undefined ? sb : null, timestamp: Date.now() });
+                }
+            }
+            else {
+                const sb = this.localStore.getServerBaseCache()[path];
+                cacheStore.put({ path, data: rebasedData, serverBase: sb !== undefined ? sb : null, timestamp: Date.now() });
+            }
+            tx.oncomplete = () => resolve(view);
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async _rejectMutationAtomically(options) {
+        const { mutationId, path } = options;
+        const db = this.indexedDB.getRawDB();
+        const queue = this.mutationQueue.inMemoryQueue;
+        const jobIndex = queue.findIndex((j) => j.id === mutationId);
+        if (jobIndex !== -1)
+            queue.splice(jobIndex, 1);
+        const view = this._calculateLocalView(path);
+        const rebasedData = view.data;
+        if (rebasedData === null) {
+            delete this.localStore.getMemoryCache()[path];
+        }
+        else {
+            this.localStore.getMemoryCache()[path] = rebasedData;
+        }
+        if (!db)
+            return view;
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(['offline_cache', 'offline_queue'], 'readwrite');
+            const cacheStore = tx.objectStore('offline_cache');
+            const queueStore = tx.objectStore('offline_queue');
+            queueStore.delete(mutationId);
+            if (rebasedData === null) {
+                const sb = this.localStore.getServerBaseCache()[path];
+                if (sb === undefined)
+                    cacheStore.delete(path);
+                else
+                    cacheStore.put({ path, data: null, serverBase: sb, timestamp: Date.now() });
+            }
+            else {
+                const sb = this.localStore.getServerBaseCache()[path];
+                cacheStore.put({ path, data: rebasedData, serverBase: sb !== undefined ? sb : null, timestamp: Date.now() });
+            }
+            tx.oncomplete = () => resolve(view);
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async _commitAtomicQueryResults(options) {
+        const { collectionPath, serverDocs, isComplete } = options;
+        const db = this.indexedDB.getRawDB();
+        const pendingMutations = new Map();
+        // Get jobs array directly from mutation queue memory
+        const mQueue = this.mutationQueue.inMemoryQueue || [];
+        for (const job of mQueue) {
+            if (!pendingMutations.has(job.path))
+                pendingMutations.set(job.path, []);
+            pendingMutations.get(job.path).push(job);
+        }
+        const finalUpdates = new Map();
+        const serverIds = new Set();
+        for (const doc of serverDocs) {
+            const docPath = `${collectionPath}/${doc.id}`;
+            serverIds.add(docPath);
+            let data = doc.fields;
+            const jobs = pendingMutations.get(docPath);
+            if (jobs) {
+                for (const job of jobs) {
+                    if (job.type === 'delete')
+                        data = null;
+                    else if (job.type === 'set' && !job.merge)
+                        data = job.data;
+                    else if (data !== null) {
+                        data = { ...data, ...job.data };
+                    }
+                    else if (job.type === 'set') {
+                        data = job.data;
+                    }
+                }
+            }
+            finalUpdates.set(docPath, data);
+        }
+        const deletedPaths = [];
+        if (isComplete) {
+            for (const cachePath of Object.keys(this.localStore.getMemoryCache())) {
+                if (cachePath.startsWith(collectionPath + '/') && cachePath.split('/').length === collectionPath.split('/').length + 1) {
+                    if (!serverIds.has(cachePath)) {
+                        const jobs = pendingMutations.get(cachePath);
+                        const hasActivePending = jobs && jobs.length > 0 && jobs[jobs.length - 1].type !== 'delete';
+                        if (!hasActivePending) {
+                            deletedPaths.push(cachePath);
+                        }
+                    }
+                }
+            }
+        }
+        for (const path of Array.from(finalUpdates.keys())) {
+            const data = finalUpdates.get(path);
+            if (data === null)
+                delete this.localStore.getMemoryCache()[path];
+            else
+                this.localStore.getMemoryCache()[path] = data;
+        }
+        for (const path of deletedPaths) {
+            delete this.localStore.getMemoryCache()[path];
+        }
+        if (!db)
+            return;
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(['offline_cache'], 'readwrite');
+            const cacheStore = tx.objectStore('offline_cache');
+            for (const path of Array.from(finalUpdates.keys())) {
+                const data = finalUpdates.get(path);
+                if (data !== null) {
+                    cacheStore.put({ path, data, timestamp: Date.now() });
+                }
+                else {
+                    cacheStore.delete(path);
+                }
+            }
+            for (const path of deletedPaths) {
+                cacheStore.delete(path);
+            }
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
     async _syncOfflineQueue() {
         await this.syncEngine.syncOfflineMutations();
     }
@@ -103,7 +328,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 +339,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 +354,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 +411,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/Query.d.ts

@@ -1,7 +1,7 @@
 import { FieldPath } from './FieldPath';
 import { CollectionReference, Query, QueryConstraint, QuerySnapshot, AggregateField, AggregateSpec, AggregateSpecData, AggregateQuerySnapshot } from '../types/index';
 export declare const query: <T = any>(queryObject: Query<T> | CollectionReference<T>, ...queryConstraints: QueryConstraint[]) => Query<T>;
-export declare const getCachedDocs: <T = any>(queryOrCollection: Query<T> | CollectionReference<T>) => QuerySnapshot<T>;
+export declare const getCachedDocs: <T = any>(queryOrCollection: Query<T> | CollectionReference<T>, fromCache?: boolean) => QuerySnapshot<T>;
 export declare const getDocs: <T = any>(queryOrCollection: Query<T> | CollectionReference<T>) => Promise<QuerySnapshot<T>>;
 export declare const count: () => AggregateField<number>;
 export declare const sum: (field: string | FieldPath) => AggregateField<number>;