nexabase-console 2.0.7 → 2.0.8

package/dist/app/NexaApp.d.ts

@@ -16,6 +16,7 @@ export declare class NexaApp {
     endpoint: string;
     enablePersistence: boolean;
     cacheStrategy: 'network-first' | 'cache-first';
+    _queryCacheMetadata: Record<string, boolean>;
     httpClient: HttpClient;
     client: AxiosInstance;
     wsClient: WebSocketClient;
@@ -36,12 +37,50 @@ 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;

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;
@@ -66,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)
@@ -98,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();
     }

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>;