nexabase-console 2.1.2 → 2.1.3

package/dist/firestore/QueryUtils.js

@@ -1,92 +1,330 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDirectChildDocument = isDirectChildDocument;
-exports.reviveNexaData = reviveNexaData;
+exports.getNestedValue = getNestedValue;
 exports.cloneNexaData = cloneNexaData;
+exports.reviveNexaData = reviveNexaData;
 exports.compareNexaValues = compareNexaValues;
+exports.deepEqual = deepEqual;
 exports.serializeConstraint = serializeConstraint;
+const FieldPath_1 = require("./FieldPath");
 const Timestamp_1 = require("./Timestamp");
+const GeoPoint_1 = require("./GeoPoint");
+const FieldValue_1 = require("./FieldValue");
+const NexaError_1 = require("../errors/NexaError");
 function isDirectChildDocument(collectionPath, documentPath) {
     if (!documentPath.startsWith(`${collectionPath}/`))
         return false;
     return documentPath.split('/').length === collectionPath.split('/').length + 1;
 }
-function reviveNexaData(data) {
+function getNestedValue(obj, fieldPath) {
+    if (obj === null || obj === undefined)
+        return undefined;
+    let segments;
+    if (fieldPath instanceof FieldPath_1.FieldPath) {
+        segments = fieldPath.segments;
+    }
+    else if (typeof fieldPath === 'string') {
+        // If exact key exists directly on object, prefer it
+        if (Object.prototype.hasOwnProperty.call(obj, fieldPath)) {
+            return obj[fieldPath];
+        }
+        segments = fieldPath.split('.');
+    }
+    else {
+        return undefined;
+    }
+    let curr = obj;
+    for (const seg of segments) {
+        if (curr === null || curr === undefined || typeof curr !== 'object') {
+            return undefined;
+        }
+        if (seg === '__proto__' || seg === 'constructor' || seg === 'prototype') {
+            return undefined;
+        }
+        curr = curr[seg];
+    }
+    return curr;
+}
+/**
+ * Type-aware codec that preserves supported Firestore primitives/classes
+ * while rejecting cycles, unsupported prototypes, and prototype pollution.
+ */
+function cloneNexaData(data, seen = new WeakSet()) {
     if (data === null || data === undefined)
         return data;
-    if (data instanceof Timestamp_1.Timestamp)
+    const type = typeof data;
+    if (type === 'boolean' || type === 'number' || type === 'string') {
+        return data;
+    }
+    if (type === 'bigint' || type === 'symbol' || type === 'function') {
+        throw new NexaError_1.NexaError('invalid-argument', `Cannot serialize unsupported data type: ${type}`);
+    }
+    if (data instanceof Timestamp_1.Timestamp) {
         return new Timestamp_1.Timestamp(data.seconds, data.nanoseconds);
-    if (Array.isArray(data))
-        return data.map(reviveNexaData);
-    if (typeof data === 'object') {
-        if (typeof data.isEqual === 'function' && typeof data.toMillis === 'function') {
-            return data;
-        }
-        // Revive timestamp
-        if (typeof data.seconds === 'number' && typeof data.nanoseconds === 'number' && Object.keys(data).length <= 2) {
-            return new Timestamp_1.Timestamp(data.seconds, data.nanoseconds);
+    }
+    if (data instanceof GeoPoint_1.GeoPoint) {
+        return new GeoPoint_1.GeoPoint(data.latitude, data.longitude);
+    }
+    if (data instanceof FieldPath_1.FieldPath) {
+        return data;
+    }
+    if (FieldValue_1.FieldValue.isFieldValue(data)) {
+        return data;
+    }
+    if (data instanceof Date) {
+        if (isNaN(data.getTime())) {
+            throw new NexaError_1.NexaError('invalid-argument', 'Invalid Date object cannot be cloned.');
         }
-        const cloned = {};
-        for (const k in data) {
-            if (Object.prototype.hasOwnProperty.call(data, k)) {
-                cloned[k] = reviveNexaData(data[k]);
+        return new Date(data.getTime());
+    }
+    if (data?.type === 'document' && typeof data.path === 'string') {
+        return { type: 'document', path: data.path, db: data.db };
+    }
+    if (Array.isArray(data)) {
+        if (seen.has(data)) {
+            throw new NexaError_1.NexaError('invalid-argument', 'Circular reference detected in array.');
+        }
+        seen.add(data);
+        const clonedArr = data.map((item) => cloneNexaData(item, seen));
+        seen.delete(data);
+        return clonedArr;
+    }
+    if (type === 'object') {
+        if (seen.has(data)) {
+            throw new NexaError_1.NexaError('invalid-argument', 'Circular reference detected in object.');
+        }
+        seen.add(data);
+        // Validate prototype: allow only plain objects or Object.create(null)
+        const proto = Object.getPrototypeOf(data);
+        if (proto !== null && proto !== Object.prototype) {
+            throw new NexaError_1.NexaError('invalid-argument', 'Custom class instances or unsupported prototypes cannot be stored.');
+        }
+        const clonedObj = {};
+        for (const key of Object.keys(data)) {
+            if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+                continue;
             }
+            clonedObj[key] = cloneNexaData(data[key], seen);
         }
-        return cloned;
+        seen.delete(data);
+        return clonedObj;
     }
-    return data;
+    throw new NexaError_1.NexaError('invalid-argument', `Unsupported data type: ${type}`);
 }
-function cloneNexaData(data) {
+/**
+ * Revives serialized JSON data back into rich Nexa/Firestore types.
+ * Never infers Timestamp from an unbranded ordinary object.
+ */
+function reviveNexaData(data, seen = new WeakSet()) {
     if (data === null || data === undefined)
         return data;
-    if (data instanceof Timestamp_1.Timestamp)
-        return new Timestamp_1.Timestamp(data.seconds, data.nanoseconds);
-    if (Array.isArray(data))
-        return data.map(cloneNexaData);
-    if (typeof data === 'object') {
-        if (typeof data.isEqual === 'function' && typeof data.toMillis === 'function') {
-            return data; // Treat as immutable if it's our own object like Timestamp/GeoPoint
-        }
-        const cloned = {};
-        for (const k in data) {
-            if (Object.prototype.hasOwnProperty.call(data, k)) {
-                cloned[k] = cloneNexaData(data[k]);
+    const type = typeof data;
+    if (type === 'boolean' || type === 'number' || type === 'string') {
+        return data;
+    }
+    if (data instanceof Timestamp_1.Timestamp || data instanceof GeoPoint_1.GeoPoint || data instanceof FieldPath_1.FieldPath || FieldValue_1.FieldValue.isFieldValue(data)) {
+        return data;
+    }
+    if (data instanceof Date) {
+        return new Date(data.getTime());
+    }
+    if (Array.isArray(data)) {
+        if (seen.has(data)) {
+            throw new NexaError_1.NexaError('invalid-argument', 'Circular reference detected in array.');
+        }
+        seen.add(data);
+        const revivedArr = data.map((item) => reviveNexaData(item, seen));
+        seen.delete(data);
+        return revivedArr;
+    }
+    if (type === 'object') {
+        if (seen.has(data)) {
+            throw new NexaError_1.NexaError('invalid-argument', 'Circular reference detected in object.');
+        }
+        seen.add(data);
+        // Explicit type markers (e.g. from backend serializer)
+        if (data.__nexa_type__ === 'timestamp' && typeof data.seconds === 'number' && typeof data.nanoseconds === 'number') {
+            seen.delete(data);
+            return new Timestamp_1.Timestamp(data.seconds, data.nanoseconds);
+        }
+        if (data.__nexa_type__ === 'geopoint' && typeof data.latitude === 'number' && typeof data.longitude === 'number') {
+            seen.delete(data);
+            return new GeoPoint_1.GeoPoint(data.latitude, data.longitude);
+        }
+        const proto = Object.getPrototypeOf(data);
+        if (proto !== null && proto !== Object.prototype) {
+            throw new NexaError_1.NexaError('invalid-argument', 'Custom class instances or unsupported prototypes cannot be revived.');
+        }
+        const revivedObj = {};
+        for (const key of Object.keys(data)) {
+            if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+                continue;
             }
+            revivedObj[key] = reviveNexaData(data[key], seen);
         }
-        return cloned;
+        seen.delete(data);
+        return revivedObj;
     }
     return data;
 }
+function getTypeOrder(v) {
+    if (v === null || v === undefined)
+        return 0;
+    if (typeof v === 'boolean')
+        return 1;
+    if (typeof v === 'number')
+        return 2;
+    if (v instanceof Timestamp_1.Timestamp || v instanceof Date)
+        return 3;
+    if (typeof v === 'string')
+        return 4;
+    if (v instanceof Uint8Array)
+        return 5;
+    if (v?.type === 'document' && typeof v.path === 'string')
+        return 6;
+    if (v instanceof GeoPoint_1.GeoPoint)
+        return 7;
+    if (Array.isArray(v))
+        return 8;
+    if (typeof v === 'object')
+        return 9;
+    return 10;
+}
+/**
+ * Deterministic Firestore-compatible value comparison.
+ */
 function compareNexaValues(a, b) {
     if (a === b)
         return 0;
-    if (a === null && b !== null)
-        return -1;
-    if (a !== null && b === null)
-        return 1;
-    if (a === undefined && b !== undefined)
-        return -1;
-    if (a !== undefined && b === undefined)
-        return 1;
-    if (typeof a === 'number' && typeof b === 'number') {
-        if (Number.isNaN(a) && Number.isNaN(b))
+    const orderA = getTypeOrder(a);
+    const orderB = getTypeOrder(b);
+    if (orderA !== orderB) {
+        return orderA < orderB ? -1 : 1;
+    }
+    switch (orderA) {
+        case 0: // null / undefined
+            return 0;
+        case 1: // boolean
+            return a === b ? 0 : a ? 1 : -1;
+        case 2: // number
+            if (Number.isNaN(a) && Number.isNaN(b))
+                return 0;
+            if (Number.isNaN(a))
+                return -1;
+            if (Number.isNaN(b))
+                return 1;
+            return a === b ? 0 : a < b ? -1 : 1;
+        case 3: { // Timestamp / Date
+            const tsA = a instanceof Timestamp_1.Timestamp ? a : Timestamp_1.Timestamp.fromDate(a);
+            const tsB = b instanceof Timestamp_1.Timestamp ? b : Timestamp_1.Timestamp.fromDate(b);
+            if (tsA.seconds !== tsB.seconds)
+                return tsA.seconds < tsB.seconds ? -1 : 1;
+            if (tsA.nanoseconds !== tsB.nanoseconds)
+                return tsA.nanoseconds < tsB.nanoseconds ? -1 : 1;
+            return 0;
+        }
+        case 4: // string
+            return a === b ? 0 : a < b ? -1 : 1;
+        case 5: { // Uint8Array
+            const minLen = Math.min(a.length, b.length);
+            for (let i = 0; i < minLen; i++) {
+                if (a[i] !== b[i])
+                    return a[i] < b[i] ? -1 : 1;
+            }
+            return a.length === b.length ? 0 : a.length < b.length ? -1 : 1;
+        }
+        case 6: // DocumentReference
+            return a.path === b.path ? 0 : a.path < b.path ? -1 : 1;
+        case 7: // GeoPoint
+            if (a.latitude !== b.latitude)
+                return a.latitude < b.latitude ? -1 : 1;
+            if (a.longitude !== b.longitude)
+                return a.longitude < b.longitude ? -1 : 1;
+            return 0;
+        case 8: { // Array
+            const minLen = Math.min(a.length, b.length);
+            for (let i = 0; i < minLen; i++) {
+                const cmp = compareNexaValues(a[i], b[i]);
+                if (cmp !== 0)
+                    return cmp;
+            }
+            return a.length === b.length ? 0 : a.length < b.length ? -1 : 1;
+        }
+        case 9: { // Object
+            const keysA = Object.keys(a).filter((k) => k !== '__proto__' && k !== 'constructor' && k !== 'prototype').sort();
+            const keysB = Object.keys(b).filter((k) => k !== '__proto__' && k !== 'constructor' && k !== 'prototype').sort();
+            const minLen = Math.min(keysA.length, keysB.length);
+            for (let i = 0; i < minLen; i++) {
+                const keyCmp = keysA[i].localeCompare(keysB[i]);
+                if (keyCmp !== 0)
+                    return keyCmp;
+                const valCmp = compareNexaValues(a[keysA[i]], b[keysB[i]]);
+                if (valCmp !== 0)
+                    return valCmp;
+            }
+            return keysA.length === keysB.length ? 0 : keysA.length < keysB.length ? -1 : 1;
+        }
+        default:
             return 0;
-        if (Number.isNaN(a))
-            return -1;
-        if (Number.isNaN(b))
-            return 1;
-        return a < b ? -1 : 1;
-    }
-    if (a?.toMillis && b?.toMillis) {
-        const ma = a.toMillis();
-        const mb = b.toMillis();
-        return ma < mb ? -1 : (ma > mb ? 1 : 0);
-    }
-    if (typeof a === 'string' && typeof b === 'string')
-        return a < b ? -1 : 1;
-    if (typeof a === 'boolean' && typeof b === 'boolean')
-        return a === b ? 0 : (a ? 1 : -1);
-    return 0; // Fallback
+    }
+}
+/**
+ * Deterministic deep equality check.
+ */
+function deepEqual(a, b, seen = new WeakSet()) {
+    if (a === b)
+        return true;
+    if (a === null || b === null || a === undefined || b === undefined)
+        return false;
+    if (typeof a !== typeof b)
+        return false;
+    if (typeof a !== 'object') {
+        if (typeof a === 'number' && typeof b === 'number') {
+            return Number.isNaN(a) && Number.isNaN(b);
+        }
+        return a === b;
+    }
+    if (a instanceof Timestamp_1.Timestamp && b instanceof Timestamp_1.Timestamp) {
+        return a.isEqual(b);
+    }
+    if (a instanceof GeoPoint_1.GeoPoint && b instanceof GeoPoint_1.GeoPoint) {
+        return a.isEqual(b);
+    }
+    if (a instanceof FieldPath_1.FieldPath && b instanceof FieldPath_1.FieldPath) {
+        return a.isEqual(b);
+    }
+    if (FieldValue_1.FieldValue.isFieldValue(a) && FieldValue_1.FieldValue.isFieldValue(b)) {
+        return a.isEqual(b);
+    }
+    if (a instanceof Date && b instanceof Date) {
+        return a.getTime() === b.getTime();
+    }
+    if (a?.type === 'document' && b?.type === 'document') {
+        return a.path === b.path;
+    }
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    if (Array.isArray(a)) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!deepEqual(a[i], b[i], seen))
+                return false;
+        }
+        return true;
+    }
+    const keysA = Object.keys(a).filter((k) => k !== '__proto__' && k !== 'constructor' && k !== 'prototype');
+    const keysB = Object.keys(b).filter((k) => k !== '__proto__' && k !== 'constructor' && k !== 'prototype');
+    if (keysA.length !== keysB.length)
+        return false;
+    for (const k of keysA) {
+        if (!Object.prototype.hasOwnProperty.call(b, k))
+            return false;
+        if (!deepEqual(a[k], b[k], seen))
+            return false;
+    }
+    return true;
 }
 function serializeConstraint(c) {
     const res = { type: c.type };

package/dist/firestore/Snapshot.js

@@ -5,26 +5,39 @@ const SnapshotManager_1 = require("./SnapshotManager");
 Object.defineProperty(exports, "SnapshotManager", { enumerable: true, get: function () { return SnapshotManager_1.SnapshotManager; } });
 const Query_1 = require("./Query");
 const NexaError_1 = require("../errors/NexaError");
-const helpers_1 = require("../utils/helpers");
+const QueryUtils_1 = require("./QueryUtils");
+const pathValidation_1 = require("./pathValidation");
+let listenerSequence = 0;
 const getCachedDoc = (docRef) => {
+    if (!docRef || !docRef.path) {
+        throw new NexaError_1.NexaError('invalid-argument', 'getCachedDoc requires a valid DocumentReference.');
+    }
+    (0, pathValidation_1.validateDocumentPath)(docRef.path);
     const db = docRef.db;
-    const data = (db._firestoreCache[docRef.path] || null);
+    const data = (db._firestoreCache[docRef.path] ?? null);
     return SnapshotManager_1.SnapshotManager.createDocumentSnapshot(docRef, data, true, db.hasPendingWrites(docRef.path));
 };
 exports.getCachedDoc = getCachedDoc;
 const getDoc = async (docRef) => {
+    if (!docRef || !docRef.path) {
+        throw new NexaError_1.NexaError('invalid-argument', 'getDoc requires a valid DocumentReference.');
+    }
+    (0, pathValidation_1.validateDocumentPath)(docRef.path);
     const db = docRef.db;
     if (db._initPromise)
         await db._initPromise;
     if (db.cacheStrategy === 'cache-first') {
         const cached = (0, exports.getCachedDoc)(docRef);
         if (cached && cached.exists()) {
+            // background refresh
             db.client
                 .get(`/api/firestore/${db.projectId}/document?docPath=${encodeURIComponent(docRef.path)}`)
                 .then(async (res) => {
-                const data = res.data.data;
-                await db._setCache(docRef.path, data);
-                db._notifySnapshotCallbacks(docRef.path, 'document_written', data);
+                const data = res.data?.data;
+                if (!db.hasPendingWrites(docRef.path)) {
+                    await db._setCache(docRef.path, data);
+                    db._notifySnapshotCallbacks(docRef.path, 'document_written', data);
+                }
             })
                 .catch(() => { });
             return cached;
@@ -32,23 +45,42 @@ const getDoc = async (docRef) => {
     }
     try {
         const res = await db.client.get(`/api/firestore/${db.projectId}/document?docPath=${encodeURIComponent(docRef.path)}`);
-        const data = res.data.data;
-        await db._setCache(docRef.path, data);
-        return SnapshotManager_1.SnapshotManager.createDocumentSnapshot(docRef, data, false, db.hasPendingWrites(docRef.path));
+        const serverData = res.data?.data;
+        if (!db.hasPendingWrites(docRef.path)) {
+            await db._setCache(docRef.path, serverData);
+        }
+        const effectiveData = db._firestoreCache[docRef.path] ?? serverData;
+        return SnapshotManager_1.SnapshotManager.createDocumentSnapshot(docRef, effectiveData, false, db.hasPendingWrites(docRef.path));
     }
     catch (err) {
-        if (err && err.response && err.response.status < 500) {
+        const status = err?.response?.status;
+        // Genuine 404: Document does not exist on server
+        if (status === 404) {
+            if (!db.hasPendingWrites(docRef.path)) {
+                await db._deleteCache(docRef.path);
+            }
+            return SnapshotManager_1.SnapshotManager.createDocumentSnapshot(docRef, db._firestoreCache[docRef.path] ?? null, false, db.hasPendingWrites(docRef.path));
+        }
+        // Permission or authentication error: throw immediately
+        if (status === 401 || status === 403) {
             throw (0, NexaError_1.toNexaError)(err);
         }
+        // Network / 5xx error: fallback to local cache
         return (0, exports.getCachedDoc)(docRef);
     }
 };
 exports.getDoc = getDoc;
 const onSnapshot = (ref, callback) => {
+    if (!ref || !ref.path) {
+        throw new NexaError_1.NexaError('invalid-argument', 'onSnapshot requires a valid Reference or Query.');
+    }
+    if (typeof callback !== 'function') {
+        throw new NexaError_1.NexaError('invalid-argument', 'onSnapshot callback must be a function.');
+    }
     const db = ref.db;
     let active = true;
     const pathKey = ref.path;
-    const listenerId = Math.random().toString(36).substring(2, 9);
+    const listenerId = `${Date.now()}_${Math.random().toString(36).slice(2)}_${++listenerSequence}`;
     const keyToClean = `${ref.type}_${listenerId}_${pathKey}`;
     let isInitial = true;
     let lastData = undefined;
@@ -60,7 +92,7 @@ const onSnapshot = (ref, callback) => {
             if (ref.type === 'collection' || ref.type === 'query') {
                 const cached = (0, Query_1.getCachedDocs)(ref);
                 const newData = cached.docs.map((d) => ({ id: d.id, data: d.data() }));
-                if (!(0, helpers_1.deepEqual)(newData, lastData)) {
+                if (!(0, QueryUtils_1.deepEqual)(newData, lastData)) {
                     const currentDocsForChanges = cached.docs.map((d) => ({ id: d.id, data: d.data(), doc: d }));
                     const snapshotWithChanges = SnapshotManager_1.SnapshotManager.createQuerySnapshot(cached.docs, true, db.hasPendingWrites(ref.path), lastDocsForChanges);
                     lastDocsForChanges = currentDocsForChanges;
@@ -71,17 +103,25 @@ const onSnapshot = (ref, callback) => {
             else {
                 const cached = (0, exports.getCachedDoc)(ref);
                 const newData = cached.exists() ? { id: cached.id, data: cached.data() } : null;
-                if (!(0, helpers_1.deepEqual)(newData, lastData)) {
+                if (!(0, QueryUtils_1.deepEqual)(newData, lastData)) {
                     callback(cached);
                     lastData = newData;
                 }
             }
         }
-        catch (e) { }
+        catch (e) {
+            console.error('[NexaBase] onSnapshot trigger error:', e);
+        }
     };
     db._snapshotCallbacks[keyToClean] = triggerCallback;
     triggerCallback();
-    db._ensureFirestoreSSE();
+    // Unified transport coordination: Prefer WebSocket if available, otherwise SSE
+    if (db.wsClient && typeof db.wsClient.subscribe === 'function') {
+        db.wsClient.subscribe(ref.path);
+    }
+    else {
+        db._ensureFirestoreSSE();
+    }
     (async () => {
         if (db._initPromise)
             await db._initPromise;
@@ -93,7 +133,7 @@ const onSnapshot = (ref, callback) => {
                 if (ref.type === 'collection' || ref.type === 'query') {
                     const docs = await (0, Query_1.getDocs)(ref);
                     const newData = docs.docs.map((d) => ({ id: d.id, data: d.data() }));
-                    if (!(0, helpers_1.deepEqual)(newData, lastData) && active) {
+                    if (!(0, QueryUtils_1.deepEqual)(newData, lastData) && active) {
                         const currentDocsForChanges = docs.docs.map((d) => ({ id: d.id, data: d.data(), doc: d }));
                         const snapshotWithChanges = SnapshotManager_1.SnapshotManager.createQuerySnapshot(docs.docs, false, db.hasPendingWrites(ref.path), lastDocsForChanges);
                         lastDocsForChanges = currentDocsForChanges;
@@ -104,19 +144,24 @@ const onSnapshot = (ref, callback) => {
                 else {
                     const docData = await (0, exports.getDoc)(ref);
                     const newData = docData.exists() ? { id: docData.id, data: docData.data() } : null;
-                    if (!(0, helpers_1.deepEqual)(newData, lastData) && active) {
+                    if (!(0, QueryUtils_1.deepEqual)(newData, lastData) && active) {
                         callback(docData);
                         lastData = newData;
                     }
                 }
             }
-            catch (e) { }
+            catch (e) {
+                // Suppress initial fetch network errors if offline
+            }
         }
     })();
     return () => {
         active = false;
         if (keyToClean) {
             delete db._snapshotCallbacks[keyToClean];
+            if (db.wsClient && typeof db.wsClient.unsubscribe === 'function') {
+                db.wsClient.unsubscribe(ref.path);
+            }
             if (Object.keys(db._snapshotCallbacks).length === 0) {
                 db._closeFirestoreSSEIfIdle();
             }

package/dist/firestore/SnapshotManager.js

@@ -1,21 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SnapshotManager = void 0;
+const FieldPath_1 = require("./FieldPath");
+const QueryUtils_1 = require("./QueryUtils");
 const helpers_1 = require("../utils/helpers");
 class SnapshotManager {
     static createDocumentSnapshot(docRef, data, fromCache, hasPendingWrites) {
         const segments = docRef.path.split('/');
         const docId = segments[segments.length - 1];
-        return {
+        const internalData = data !== null && data !== undefined ? (0, QueryUtils_1.cloneNexaData)(data) : null;
+        const snapshot = {
             id: docId,
             ref: docRef,
-            metadata: { fromCache, hasPendingWrites },
-            exists: () => data !== null && data !== undefined,
-            data: () => data,
-            get: (fieldPath) => (0, helpers_1.getNestedValue)(data, fieldPath, docId)
+            metadata: Object.freeze({ fromCache, hasPendingWrites }),
+            exists: () => internalData !== null && internalData !== undefined,
+            data: () => (internalData !== null && internalData !== undefined ? (0, QueryUtils_1.cloneNexaData)(internalData) : undefined),
+            get: (fieldPath) => {
+                if (fieldPath === '__name__' || (fieldPath instanceof FieldPath_1.FieldPath && fieldPath.segments[0] === '__name__')) {
+                    return docId;
+                }
+                if (internalData === null || internalData === undefined)
+                    return undefined;
+                const val = (0, QueryUtils_1.getNestedValue)(internalData, fieldPath);
+                return (0, QueryUtils_1.cloneNexaData)(val);
+            }
         };
+        return Object.freeze(snapshot);
     }
     static createQuerySnapshot(docs, fromCache, hasPendingWrites, previousDocs) {
+        const frozenDocs = Object.freeze([...docs]);
         const currentDocsForChanges = docs.map((d) => ({
             id: d.id,
             data: d.data(),
@@ -24,14 +37,16 @@ class SnapshotManager {
         const changes = previousDocs
             ? (0, helpers_1.calculateDocChanges)(previousDocs, currentDocsForChanges)
             : docs.map((d, i) => ({ type: 'added', doc: d, oldIndex: -1, newIndex: i }));
-        return {
-            docs,
-            forEach: (cb) => docs.forEach(cb),
-            empty: docs.length === 0,
-            size: docs.length,
-            metadata: { fromCache, hasPendingWrites },
-            docChanges: () => changes
+        const frozenChanges = Object.freeze([...changes]);
+        const snapshot = {
+            docs: frozenDocs,
+            forEach: (cb) => frozenDocs.forEach(cb),
+            empty: frozenDocs.length === 0,
+            size: frozenDocs.length,
+            metadata: Object.freeze({ fromCache, hasPendingWrites }),
+            docChanges: () => frozenChanges
         };
+        return Object.freeze(snapshot);
     }
 }
 exports.SnapshotManager = SnapshotManager;

package/dist/firestore/Timestamp.d.ts

@@ -8,6 +8,7 @@ export declare class Timestamp {
     toDate(): Date;
     toMillis(): number;
     isEqual(other: Timestamp): boolean;
+    valueOf(): string;
     toString(): string;
     toJSON(): {
         seconds: number;